On 01/05/2011 11:38 PM, Timo Sirainen wrote:
On 6.1.2011, at 0.27, Attila Nagy wrote:
With this, 10 syncs would happen in every second from Dovecot LDA processes,
meaning if a client connects in t=0 it will immediately got the response 250,
if a client connects in t=0.05, it will get the response in 50 ms (in an ideal
world, where syncing does not take time), and the committed blocks could
accumulate for a maximum of 100 ms.
In a busy system (where this setting would make sense), it means it would be
possible to write more data with less IOPS needed.
I guess this could work. Although earlier I thought about delaying fsyncs so
that when saving/copying multiple mails in a single transaction with maildir it
would delay about 10 or so close()s and then fsync() them all at the same time
at the end. This ended up being slower (but I only tested it with a single user
- maybe in real world setups it might have worked better).
What filesystem was used for this test? If that writes only the involved
FD's data with an fsync, the effect is pretty much the same when you
issue fsync real time, or serialize them into nearly the same time: the
file system will write small amounts of data and issue a flush after
each fsync.
On a file system, which writes all the dirty data for an fsync (like ZFS
does), it may work better, altough only the first fsync would be
necessary, with the others you will only risk that other data got into
the caches and you make the solution useless with that.
That's why I wrote in this case you would need to use sync() instead of
fsync(), so this would make this file system independent.
Many sync() man pages write these:
FreeBSD:
BUGS
The sync() system call may return before the buffers are completely
flushed.
Linux:
BUGS
According to the standard specification (e.g., POSIX.1-2001),
sync()
schedules the writes, but may return before the actual writing
is done.
However, since version 1.3.20 Linux does actually wait.
(This still
does not guarantee data integrity: modern disks have large caches.)
But I think the same warning will stand against fsync too.
Otherwise, I guess a little experimenting and reading would be needed
here. I think for this setting it would be OK to assume some technical
knowledge on the users and say: you should only turn this on, if you
have a file system, which flushes all dirty buffers for a single fsync
for the entire file system.
Then you would delay fsyncs for a list of FDs, and issue only one for
the list, instead of one for each of the list elements.
Or just issue a single sync().
I can see two problems:
1. there is no call for committing a lot of file descriptors in one
transaction, so instead of fsync() for each of the modified FDs, a sync() would
be needed. sync() writes all buffers to stable storage, which is bad if you
have a mixed workload, where there are a lot of non-fsynced data, or other
heavy fsync users. But modern file systems, like ZFS will write those back too,
so there an fsync(fd) is -AFAIK- mostly equivalent with a sync(pool on which fd
is). sync() of course is system wide, so if you have other file systems, those
will be synced as well. (this setting isn't for everybody)
2. in a multiprocess environment this would need coordination, so instead of
doing fsyncs in distinct processes, there would be one process needed, which
does the sync and returns OK for the others, so they can notify the client
about the commit to the stable storage.
It's possible for you to send the fds to another process via UNIX socket that
does fsync() on them. I was also hoping for using lib-fs for at least some
mailbox formats at some point (either some modified dbox, or a new one), and
for that it would be even easier to add an fsync plugin that does this kind of
fsync-transfer to another process.
Yes, but as above stated, I don't think it will help, because on a file
system, which writes only the given FD's data, it's the same, nothing
gained, and on a file system, which flushes all dirty buffers, you will
possibly have some dirty buffers between those fsyncs, so it will be the
same, IOPS will be the limiting factor.
