Why is std::cout so time consuming?

by

std::cout ultimately results in the operating system being invoked.

If you want something to compute fast, you have to make sure that no external entities are involved in the computation, especially entities that have been written with versatility more than performance in mind, like the operating system.

Want it to run faster? You have a few options:

  1. Replace << std::endl; with << '\n'. This will refrain from flushing the internal buffer of the C++ runtime to the operating system on every single line. It should result in a huge performance improvement.

  2. Use std::ios::sync_with_stdio(false); as user Galik Mar suggests in a comment.

  3. Collect as much as possible of your outgoing text in a buffer, and output the entire buffer at once with a single call.

  4. Write your output to a file instead of the console, and then keep that file displayed by a separate application such as Notepad++ which can keep track of changes and keep scrolling to the bottom.

As for why it is so “time consuming”, (in other words, slow,) that’s because the primary purpose of std::cout (and ultimately the operating system’s standard output stream) is versatility, not performance. Think about it: std::cout is a C++ library function which will invoke the operating system; the operating system will determine that the file being written to is not really a file, but the console, so it will send the data to the console subsystem; the console subsystem will receive the data and it will start invoking the graphics subsystem to render the text in the console window; the graphics subsystem will be drawing font glyphs on a raster display, and while rendering the data, there will be scrolling of the console window, which involves copying large amounts of video RAM. That’s an awful lot of work, even if the graphics card takes care of some of it in hardware.

As for the C# version, I am not sure exactly what is going on, but what is probably happening is something quite different: In C# you are not invoking Console.Out.Flush(), so your output is cached and you are not suffering the overhead incurred by C++’s std::cout << std::endl which causes each line to be flushed to the operating system. However, when the buffer does become full, C# must flush it to the operating system, and then it is hit not only by the overhead represented by the operating system, but also by the formidable managed-to-native and native-to-managed transition that is inherent in the way it’s virtual machine works.

More Related Contents:

  1. What exactly is nullptr?
  2. Why don’t compilers merge redundant std::atomic writes?
  3. How to change mode from c++98 mode in Dev-C++ to a mode that supports C++0x (range based for)?
  4. Copy constructor for a class with unique_ptr
  5. How to call a function on all variadic template args?
  6. std::array vs array performance
  7. lifetime of a std::initializer_list return value
  8. Brace-enclosed initializer list constructor
  9. Where can I use alignas() in C++11?
  10. How to use sfinae for selecting constructors?
  11. std::thread is not a member of namespace std using Eclipse Kepler MinGW
  12. What is the difference between std::reference_wrapper and a simple pointer?
  13. Which cannot be implemented without compiler hooks?
  14. Should I delete the move constructor and the move assignment of a smart pointer?
  15. How can I iterate over a packed variadic template argument list?
  16. What is the value category of the operands of C++ operators when unspecified?
  17. False positive with is_copy_constructible on vector
  18. Concat two `const char` string literals
  19. Is left-shifting (
  20. Waiting for multiple futures?
  21. How do memory_order_seq_cst and memory_order_acq_rel differ?
  22. When to make a type non-movable in C++11?
  23. Why does using a temporary object in the range-based for initializer result in a crash?
  24. error::make_unique is not a member of ‘std’
  25. Why can’t I replace std::map with std::unordered_map
  26. Should all/most setter functions in C++11 be written as function templates accepting universal references?
  27. Is codecvt not a std header?
  28. Is there a way to statically-initialize a dynamically-allocated array in C++?
  29. enum vs constexpr for actual static constants inside classes
  30. Is there a standard way of moving a range into a vector?

Leave a Comment