gabriele renzi wrote:

> I suppose that this is a work for persistence/prevalence layers, but I
> don't think thay would actually save *each* change.
> 
> But it seem to me that working this way you'll have too many atomic
> writings, and you'll loose in performance.
> 
> The Madeleine/prevayler approach  should be to save the state of the
> application space with predefined time slices, while the persistence
> layer approach should be about using save/retrieve methods, so you'll
> just have to add a obj.save the way you'll use  Marshal(obj,io).

These snapshots are an important feature, but not the central part of
Madeleine. Instead, the logs are the most important part.
You don't log each change to every object, you log every command that
*enters* the system. If that command causes thousands of objects to be
changed, the only thing that is written is still just the command that
caused the changes.
So how much is written depends on the number of operations you do on the
system from the "outside". For some applications this will cause lots of
atomic writes, for some very few.

> Possibly this performance/fault_tolerance problem is the same of the
> sync/async writing in filesystems, and a middle-way approach a-la
> Madeleine could be , imho, a good thing

Madeleine uses fsync() when it writes to the filesystem, so no magic
middle-way there I'm afraid. :)
But if you don't worry about loosing data you could comment that out and
have a much faster system.

/Anders

-- 

A n d e r s  B e n g t s s o n  |  ndrsbngtssn / yahoo.se
Stockholm, Sweden               |