Re: AW: AW: AW: WAL does not recover gracefully from ou t-of -dis k-sp ace

"Mikheev, Vadim" <vmikheev@SECTORBASE.COM> writes:
> Tom, could you run this test for different block sizes?
> Up to 32*8k?
>> 
>> You mean changing the amount written per write(), while holding the
>> total file size constant, right?

> Yes. Currently XLogWrite writes 8k blocks one by one. From what I've seen
> on Solaris we can use O_DSYNC there without changing XLogWrite to
> write() more than 1 block (if > 1 block is available for writing).
> But on other platforms write(BLOCKS_TO_WRITE * 8k) + fsync() probably will
> be
> faster than BLOCKS_TO_WRITE * write(8k) (for file opened with O_DSYNC)
> if BLOCKS_TO_WRITE > 1.
> I just wonder with what BLOCKS_TO_WRITE we'll see same times for both
> approaches.

Okay, I changed the program tochar zbuffer[8192 * BLOCKS];
(all else the same)

and on HPUX 10.20 I get

$ gcc -Wall -O -DINIT_WRITE -DUSE_DSYNC -DBLOCKS=1 tfsync.c
$ time a.out

real    1m18.48s
user    0m0.04s
sys     0m34.69s
$ gcc -Wall -O -DINIT_WRITE -DUSE_DSYNC -DBLOCKS=4 tfsync.c
$ time a.out

real    0m35.10s
user    0m0.01s
sys     0m9.08s
$ gcc -Wall -O -DINIT_WRITE -DUSE_DSYNC -DBLOCKS=8 tfsync.c
$ time a.out

real    0m29.75s
user    0m0.01s
sys     0m5.23s
$ gcc -Wall -O -DINIT_WRITE -DUSE_DSYNC -DBLOCKS=32 tfsync.c
$ time a.out

real    0m22.77s
user    0m0.01s
sys     0m1.80s
$ gcc -Wall -O -DINIT_WRITE -DUSE_DSYNC -DBLOCKS=64 tfsync.c
$ time a.out

real    0m22.08s
user    0m0.01s
sys     0m1.25s


$ gcc -Wall -O -DINIT_WRITE -DUSE_ODSYNC -DBLOCKS=1 tfsync.c
$ time a.out

real    0m20.64s
user    0m0.02s
sys     0m0.67s
$ gcc -Wall -O -DINIT_WRITE -DUSE_ODSYNC -DBLOCKS=4 tfsync.c
$ time a.out

real    0m20.72s
user    0m0.01s
sys     0m0.57s
$ gcc -Wall -O -DINIT_WRITE -DUSE_ODSYNC -DBLOCKS=32 tfsync.c
$ time a.out

real    0m20.59s
user    0m0.01s
sys     0m0.61s
$ gcc -Wall -O -DINIT_WRITE -DUSE_ODSYNC -DBLOCKS=64 tfsync.c
$ time a.out

real    0m20.86s
user    0m0.01s
sys     0m0.69s

So I also see that there is no benefit to writing more than one block at
a time with ODSYNC.  And even at half a meg per write, DSYNC is slower
than ODSYNC with 8K per write!  Note the fairly high system-time
consumption for DSYNC, too.  I think this is not so much a matter of a
really good ODSYNC implementation, as a really bad DSYNC one ...
        regards, tom lane