Date: Sun, 23 Apr 2006 12:12:15 -0700 From: Don Dugger <dugger@hotlz.com> To: freebsd-chat@freebsd.org Subject: Re: Why is not more FreeBSD software written in C++? Message-ID: <444BD18F.9080302@hotlz.com> In-Reply-To: <200604231525.k3NFP64X003155@mist.nodomain> References: <200604231525.k3NFP64X003155@mist.nodomain>
next in thread | previous in thread | raw e-mail | index | archive | help
As I sit here on this beautiful day. It dawns on me that tried improving
a program a few years back by changing
printf("%s",s) to puts(s) and the puts() make it run much slower. I
never found out why. I also
remember doing research a year or so ago on GC and the guy that are
proponents have some interesting ideas
on performance.
http://www.iecc.com/gclist/GC-faq.html
Now I'm getting out of here its to nice of day...
Don 8)
Dan Strick wrote:
>On Sunday 23 Apr 2006 02:03, Benjamin Lutz wrote:
>
>
>>On Saturday 22 April 2006 17:11, Dan Strick wrote:
>>
>>
>>>On Thursday 20 Apr 2006 22:58, Benjamin Lutz wrote: (this line corrected)
>>>
>>>
>>>>The example above is not exactly a realworld example. Even if you stick
>>>>to plain C, a repeated putchar(' ') is 1-2 orders of magnitude slower
>>>>than aggregating those characters and write()'ing them every few dozen
>>>>chars.
>>>>
>>>>
>>>This might seem obvious, but is it really true? I wrote a program that
>>>tries it both ways with the output redirected to /dev/null and discovered
>>>that filling a 24 character buffer and doing a write() takes about 11 times
>>>as much cpu time as 24 putchar()s. Perhaps a buffer larger than a "few
>>>dozen chars" would be useful. There must be a moral here somewhere. :-)
>>>
>>>
>>Yes, it is really true. Since I don't know what your test is, I've created
>>my own.
>>
>>...
>>
>>All files are compiled with gcc/g++ and the -O2 option. I'm running them on
>>a Mac Mini under Linux.
>>
>>And the results are (I've run that command several times and picked a line
>>that shows an average run time):
>>
>>$ time ./test_putchar > /dev/null
>>./test_putchar > /dev/null 0.39s user 0.00s system 97% cpu 0.397 total
>>$ time ./test_write > /dev/null
>>./test_write > /dev/null 0.02s user 0.01s system 82% cpu 0.029 total
>>$ time ./test_iostream > /dev/null
>>./test_iostream > /dev/null 0.94s user 0.00s system 99% cpu 0.950 total
>>$ time ./test_string > /dev/null
>>./test_string > /dev/null 0.21s user 0.00s system 97% cpu 0.213 total
>>
>>
>>That quite clearly shows that my prediction that using putchar is "1-2 orders
>>of magnitude slower" is accurate. It also shows the points you and others
>>have made that iostream is slower than C's I/O mechanisms.
>>
>>If we take the two most sensible variants, test_write and test_iostream, and
>>have them write into a file, we get these numbers:
>>
>>$ time ./test_write > foo
>>./test_write > foo 0.01s user 0.16s system 95% cpu 0.180 total
>>$ time ./test_string > foo
>>./test_string > foo 0.20s user 0.02s system 98% cpu 0.223 total
>>
>>Which is a small enough difference to be irrelevant. The large I/O performance
>>advantage of the write(2) variant over the C++ string variant vanishes as
>>soon as the code actually does something remotely useful.
>>
>>
>>
>
>In order to make sure that we are comparing apples to apples and not
>to oranges, I copied Benjamin Lutz's test programs and ran them on my
>machine, a 2.8 GHz Intel P4 running FreeBSD 5.4. The repetition counts
>in the programs were increased from 50K to 500K and the programs were
>compiled with the -O2 option using whatever version of GNU gcc/g++ comes
>standard with FreeBSD 5.4.
>
>times for output to /dev/null:
>
>test_putchar: 0.140u 0.000s 0:00.14 100.0% 5+180k 0+0io 0pf+0w
>test_write: 0.163u 0.413s 0:00.57 100.0% 5+171k 0+0io 0pf+0w
>test_iostream: 3.673u 0.015s 0:03.69 99.7% 5+179k 0+0io 0pf+0w
>test_string: 0.789u 0.007s 0:00.79 98.7% 5+188k 0+0io 0pf+0w
>
>times for output to file foo:
>
>test_putchar: 0.145u 0.040s 0:01.82 9.8% 5+194k 0+232io 0pf+0w
>test_write: 0.133u 1.333s 0:01.84 79.3% 6+170k 0+232io 0pf+0w
>test_iostream: 3.635u 0.077s 0:03.73 99.1% 6+197k 0+232io 0pf+0w
>test_string: 0.772u 0.076s 0:01.84 45.6% 8+213k 0+232io 0pf+0w
>
>My results show something quite different. Even though the buffer
>size used by Benjamin's write() test (61 bytes) is much larger than
>the one I used (only 24 bytes), the write() test to /dev/null still
>takes about 4 times longer than the putchar() test. As one might
>expect, the write() test spends most of its time in the kernel doing
>all those write() system calls. The putchar() test (i.e. stdio)
>is probably using a 1K byte buffer.
>
>I cannot explain Benjamin's results on a Mac Mini running Linux.
>His write() test to /dev/null took almost no system time. Note that
>on his system the write() test to a real file consumed 16 times as
>much system time as the write() test to /dev/null (best guess since
>the precision of his time measurement was so limited). On my system
>the ratio was about 3 to one. His I/O system must be radically
>different from mine. Does anyone know why? What does Linux do
>differently than FreeBSD?
>
>I stand by my suggestion that using putchar() might not be slower.
>On my system it was much faster.
>
>I also note that while most of the tests writing to a real file used
>about the same real time, there were really huge differences in cpu
>time. Test_putchar was the big winner, running 4.5 times faster than
>test_string, 8 times faster than test_write, and 20 times faster than
>test_iostream. Such differences in cpu consumption can be important
>even when the processes are i/o bound because other processes running
>on the same system may be cpu bound.
>
>Dan Strick
>_______________________________________________
>freebsd-chat@freebsd.org mailing list
>http://lists.freebsd.org/mailman/listinfo/freebsd-chat
>To unsubscribe, send any mail to "freebsd-chat-unsubscribe@freebsd.org"
>
>
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?444BD18F.9080302>