6 ms·
“Hello world” is slower in C++ than in C (Linux)
- JoeAltmaier 4y agoWell, the C++ iostream library is slower. A truer comparison could be to compile the same code in both.
- butz 4y agoVery interesting to compare assembly code of both variants. C ends up with 10 lines of assembly code (https://godbolt.org/z/EeTTefjfq https://godbolt.org/z/EeTTefjfq), and C++ variant - 42 lines (https://godbolt.org/z/5T5qWc56h https://godbolt.org/z/5T5qWc56h).
- khitchdee 4y agoC++ is slow and bloated but people just hide that under the rug.
- qsdf38100 4y agoC++ is a language, while iostream is one of the many C++ tools available to write to the standard output. It’s available by default, it’s part of the standard library, but you don’t have to use it. printf is also available, and will be as fast as using it from C. Note that in most cases, the speed of writing to standard output is irrelevant unless you are implementing cat or some command line text processing tool. I find iostream very convenient and type safety is a big plus compared to printf. It’s also very easy to implement your own handlers for your own types.
- khitchdee 4y agoC++ adds a layer of functional indirection above the level of the C structure. This is what causes the bloat. The implementation of the C++ object vs. the C struct. Iostream is implemented as an object. C++ is definitely more convenient and that was the intent of its creators. It does not replace C but provides a more convenient alternative to using C structs and fn pointers at the cost of a small performance penalty (maybe slow and bloated is over-expressing the penalty).
- qsdf38100 4y agoThis "bloat" of C objects you mention is only there if you use virtual functions. Same as using function pointers in a C struct. But in some cases C++ can avoid the dynamic indirection thanks to templates like in std::sort while C's qsort gets passed a function pointer, called for each comparison. Iostream do use virtual functions but it’s not the reason of its suboptimal performance. The main reason is that some strings will be copied, allocated and freed during the construction of the whole expression while printf can do its processing with minimal dynamic allocations.
- khitchdee 4y agoNo virtual fns means no inheritance. Also, you can blame the implementation and not the language. But real-world it is slower. Can't say by how much. Why bother?
- dvfjsdhgfv 4y agoI don't believe anyone tries to hide it. Except a couple of well-known cases, C++ is (relatively slightly) slower than C, but it's far more powerful. You can argue about compile times - yes, there is a huge difference here; also some specific features like virtual methods are slow - but overall, C++ is one of the fastest languages available.
- pjmlp 4y agoC++ includes plenty of tools, including a C11 subset, so if it happens to be slower than a bare bones C compiler, the author doesn't know its craft.
- pjmlp 4y agoI get exactly the same 10 lines using C++. https://godbolt.org/z/fTPM35Erq https://godbolt.org/z/fTPM35Erq As the "C code" is also valid C++.
- butz 4y agoOf course, same code compiles into same asm, but in original article author is comparing different source code for C++, which includes iostream and stdlib.h.
- pjmlp 4y agoNope, he uses C code that is also valid C++, to produce an argument why C better than C++. > A simple C program might print ‘hello world’ on screen: > .... > You can write the equivalent in C++: He could keep using his original C example and simply change from gcc into g++. But then he wouldn't be able to use "C is better than C++", when using stdio for both languages.
- psyclobe 4y agotl;dr iostreams is bloated and slow
- charcircuit 4y agoIsn't the C version missing a fflush to be equivalent?
- jonathrg 4y agoStrictly speaking yes (or the "C++ version" could replace std::endl with \n), but the observable behavior isn't going to change much. The runtime is going to flush the output buffer at program exit anyway.
- charcircuit 4y agoBut couldn't it effect the observable behaviour of the time it takes to execute?
- jonathrg 4y agoThat's not really what I mean (I meant that it's not going to result in any difference in which system calls are made etc). If you flush manually, the runtime-provided routine that closes all streams (see e.g. https://www.gnu.org/software/libc/manual/html_node/Normal-Termination.html https://www.gnu.org/software/libc/manual/html_node/Normal-Te...) will just do nothing, so you get a little bit of overhead from that
- Dwedit 4y agoMore like Iostream is slower than writing to stdout's file handle.
- jonathrg 4y ago> What we are testing by running these programs is the overhead due to the choice of programming language. That's just wrong. The first example is a perfectly fine hello world in C++. This is overhead due to the choice of API used to print to stdout It's well known that a typical iostream implementation is slower than a typical printf implementation, which is why printf is still used in C++ and one of the reasons we got std::format in C++20
- guyomes 4y agoMoreover, if strings are the only thing to print, and speed is the only thing to care about, then "puts" is a good alternative too.
- BaculumMeumEst 4y agoA post this ignorant and reductive is something I would expect from a freshman student of computer science, not a professor. Embarrassing.
- newbieuser 4y agoHN is a great site for people who want attention. It's funny that this article is on the front page but ¯\_(ツ)_/¯
- kragen 4y agoPeople get to be professors because they spend their time investigating things they don't understand (that is, that they're ignorant about), not because they spend all their time doing things they already understand well. You just aren't used to seeing that process in action (it usually isn't blogged), so you project your own embarrassment onto Lemire, who doesn't deserve it.
- fluoridation 4y agoWell, I would expect a professor to not waste their time experimenting to learn something that's already been documented. So yes, there are things a professor should be embarrassed for not knowing.
- shadowgovt 4y agoYou hit upon an interesting meta-problem, which is: if something is already documented, how do you know? In general, the ability to search human knowledge (especially in deeply technical fields) has vastly outstripped the generation of such knowledge.
- birdyrooster 4y agoBecause you have experience enough to know what is and isn’t documented. If you don’t have enough experience, you probably shouldn’t be publishing your opinions.
- billpg 4y agoThat surprises me. If you had asked me, I'd have said that with normal optimizations switched on, both programs would boil down to exactly the same single function call that copies a byte-array to the stdout stream. I would have to wonder if there any optimisations someone has missed if there's even a tiny difference. In the C world, I could image there's a loop at runtime scanning the printf string for % characters, but I would equally imagine that the compiler people have made a special case for printf that silently replaces printf calls with a single string literal parameter with no %s are replaced with a puts call. (Which itself gets optimised to to a byte-array copy.)
- danjoredd 4y agoI thought that this was well known?
- magila 4y agoIostream's performance problems have been well known for decades. This post is striking shallow and uninformed for something coming from a professor "focused on software performance".
- not2b 4y agoNope. The equivalent in C++ is not std::cout << "hello world" << std::endl; but is, rather, std::cout << "hello world\n"; The std::endl doesn't just print an '\n' character, it also does a buffer flush.
- CoastalCoder 4y agoI'm not sure how we define "equivalent" here. If we're talking about the majority of C++ code I see in commercial systems, then `std::endl` is definitely used more than `'\n'` to emit a line-break. (std::endl also has the benefit of doing the right thing across different operating systems)
- plorkyeran 4y agostd::cout << "\n"; will emit \r\n on Windows by default.
- CoastalCoder 4y agoI wouldn't have expected that. Is it compiler-specific? Because it sounds totally broken, but maybe the language spec covers this and I didn't realize it.
- plorkyeran 4y agoSimilar to FTP, iostreams have a concept of text mode and binary mode for streams. In text mode, newlines are translated and in binary mode they are not. Which mode std::cout is in by default is implementation-defined just to be obnoxious. VC++ defaults to text mode.
- deleted 4y ago[deleted]
- not2b 4y agoIn the code I write and review I care about the buffer-flush semantics and will revise, or ask for a revision, if excessive flushing will result from too many std::endl uses when generating large volumes of output. It isn't just an academic point; you might want to look at that code to see if std::endl is justified. It is appropriate if you want to guarantee that a given record reaches the output file quickly, and if not much is written it's a don't-care.
- cesarb 4y agoBesides the std::endl gotcha others already mentioned: IIRC, just including the <iostream> header is enough to make it run some extra initialization code before main().
- matrix_overload 4y agoThis is such an ignorant and low-effort post. The author did not bother to check whether the delay comes from the library loading time vs. the actual string formatting. He is complaining about a single millisecond difference (that is near the measurement error) and haven't bothered to run the entire thing in a loop and get the difference to something meaningful (where the terminal performance can eat away any noticeable differences). He picked a completely unrealistic metric (console output is usually meant to be read by humans, so it was never optimized for +- millisecond performance). He doesn't distinguish between the language (C++) and the I/O API (printf() vs iostream). The main advantage of C++ is that if you bother to understand how it works, you can let the compiler/debugger do a lot of mind-numbing and error-prone work that C developers proudly do by hand (collections, RAII, inline templates with concepts) at exactly 0.0 runtime overhead. The key is "if you bother to understand how it works". If you randomly pick an arbitrary API and complain how it's worse than a different arbitrary API from C for an arbitrary use case, it only shows your own incompetence.
- jenscow 4y agoThe post is "Hello world" is slower in C++, not "C++ is slower" or anything else. The speed of the Hello world application is the metric and they used hyperfine - a benchmarking tool.
- __ryan__ 4y agoFrom the article: > I do not believe that printing ‘hello world’ itself should be slower or faster in C++, at least not significantly. What we are testing by running these programs is the overhead due to the choice of programming language.
- MaulingMonkey 4y ago> The post is "Hello world" is slower in C++, not "C++ is slower" or anything else. The post pretty clearly blames "C++" if you read more than the title - note the "due to C++" here: >> Yet if these numbers are to be believed, there is a significant penalty due to C++ for tiny program executions, under Linux. > The speed of the Hello world application is the metric And it's a poor metric, mostly testing process setup/teardown. > and they used hyperfine - a benchmarking tool. And benchmarking tools are only as good as their usage and application. A more apples-to-apples comparison would be to use `\n` instead of `std::endl`, and `std::ios_sync_with_stdio(false)` to avoid excessive syncronization with C I/O. Admittedly, neither particularly helps here: I observe most of the overhead the article does merely by switching out clang/gcc for clang++/g++ on the same C source code, with ~6ms-9ms total runtime under wsl, or ~9ms (no measurable difference between the C++ or C code) when compiled with cl 19.15.26732.1 and run on windows. This is mostly measuring process setup/teardown and OS I/O overhead: redirecting stdout to null, I don't see a significant perf impact until I put the printing in some rather large loops: #include <stdio.h> #include <stdlib.h> int main() { for (int i=0; i<1000000; ++i) printf("hello world\n"); return EXIT_SUCCESS; } #include <iostream> #include <stdlib.h> int main() { std::ios::sync_with_stdio(false); for (int i=0; i<1000000; ++i) std::cout << "hello world\n"; return EXIT_SUCCESS; } Guess which is faster? The C++ version, oddly enough, both on wsl ubuntu linux: /mnt/c/local/ben$ clang++ -Os hello_world.cpp && cargo run --bin bench --quiet --release average runtime: 36.78434ms /mnt/c/local/ben$ clang -Os hello_world.c && cargo run --bin bench --quiet --release average runtime: 86.33667ms /mnt/c/local/ben$ clang++ -O3 hello_world.cpp && cargo run --bin bench --quiet --release average runtime: 36.34467ms /mnt/c/local/ben$ clang -O3 hello_world.c && cargo run --bin bench --quiet --release average runtime: 86.75787ms And on windows: C:\local\ben>cl /nologo /O2 hello_world.cpp && cargo run --bin bench --quiet --release hello_world.cpp C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.15.26726\include\xlocale(319): warning C4530: C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc average runtime: 1.44849203s C:\local\ben>cl /nologo /O2 hello_world.c && cargo run --bin bench --quiet --release hello_world.c average runtime: 1.75088561s Take these numbers with a massive grain of salt: Launching the first subprocess is extra expensive (on the order of 90-100ms) and included in the above averages, distoring them, presumably from delayed loading or initialization of a library in the benchmarking process as subsequent runs of the benchmarking process show the same overhead for the first subprocess[1]. Meanwhile, the author of the original article is calling overhead that has to be rounded up to 1ms a "huge penalty". (EDIT[1]: to rule out first-access overhead being from windows defender or similar, I confirmed that launching a sacrificial, unrelated, first subprocess such as "cmd /C ver" eliminates the overhead for the first "./a.out" execution)
- galkk 4y agoSuch lazy post. Even doing this: * gcc max performance compilation option (-O3) https://godbolt.org/z/18ejPnzrj https://godbolt.org/z/18ejPnzrj * gcc min compilied size compilation options: https://godbolt.org/z/EK1Tzznes https://godbolt.org/z/EK1Tzznes without any written work will give much more insights into differences between C++ and C implementations
- pjmlp 4y agoWhat a ridiculous statement, first of all the first example is also C++ code, and compiles to exactly the same set of machine instructions, https://godbolt.org/z/8jYh79e7e https://godbolt.org/z/8jYh79e7e Second, everyone ones knows that iostream flexibility and type safety comes with a price. Third, the modern way is to use fmt, or std::format.
- andy-x 4y agoSo, if C printf is slower than assembler code that outputs "hello world", then C is garbage?