Does the C++ standard mandate poor performance for iostreams, or am I just dealing with a poor implementation?

by

Not answering the specifics of your question so much as the title: the 2006 Technical Report on C++ Performance has an interesting section on IOStreams (p.68). Most relevant to your question is in Section 6.1.2 (“Execution Speed”):

Since certain aspects of IOStreams processing are
distributed over multiple facets, it
appears that the Standard mandates an
inefficient implementation. But this
is not the case — by using some form
of preprocessing, much of the work can
be avoided. With a slightly smarter
linker than is typically used, it is
possible to remove some of these
inefficiencies. This is discussed in
§6.2.3 and §6.2.5.

Since the report was written in 2006 one would hope that many of the recommendations would have been incorporated into current compilers, but perhaps this is not the case.

As you mention, facets may not feature in write() (but I wouldn’t assume that blindly). So what does feature? Running GProf on your ostringstream code compiled with GCC gives the following breakdown:

  • 44.23% in std::basic_streambuf<char>::xsputn(char const*, int)
  • 34.62% in std::ostream::write(char const*, int)
  • 12.50% in main
  • 6.73% in std::ostream::sentry::sentry(std::ostream&)
  • 0.96% in std::string::_M_replace_safe(unsigned int, unsigned int, char const*, unsigned int)
  • 0.96% in std::basic_ostringstream<char>::basic_ostringstream(std::_Ios_Openmode)
  • 0.00% in std::fpos<int>::fpos(long long)

So the bulk of the time is spent in xsputn, which eventually calls std::copy() after lots of checking and updating of cursor positions and buffers (have a look in c++\bits\streambuf.tcc for the details).

My take on this is that you’ve focused on the worst-case situation. All the checking that is performed would be a small fraction of the total work done if you were dealing with reasonably large chunks of data. But your code is shifting data in four bytes at a time, and incurring all the extra costs each time. Clearly one would avoid doing so in a real-life situation – consider how negligible the penalty would have been if write was called on an array of 1m ints instead of on 1m times on one int. And in a real-life situation one would really appreciate the important features of IOStreams, namely its memory-safe and type-safe design. Such benefits come at a price, and you’ve written a test which makes these costs dominate the execution time.

More Related Contents:

  1. Regarding time out in code
  2. Why would we call cin.clear() and cin.ignore() after reading input?
  3. Is < faster than
  4. C++ Standard Library: How to write wrappers for cout, cerr, cin and endl?
  5. Is it better to use std::memcpy() or std::copy() in terms to performance?
  6. Restore the state of std::cout after manipulating it
  7. C++ : Catch a divide by zero error
  8. How to get IOStream to perform better?
  9. How do I deal with the max macro in windows.h colliding with max in std?
  10. How expensive is RTTI?
  11. Which is more efficient: Return a value vs. Pass by reference?
  12. Standard no-op output stream
  13. Why does this delay-loop start to run faster after several iterations with no sleep?
  14. Find all substring’s occurrences and locations
  15. How to print __int128 in g++?
  16. clock function in C++ with threads
  17. How do the stream manipulators work?
  18. How to make cout behave as in binary mode?
  19. Why can’t std::ostream be moved?
  20. Loading a file into a vector
  21. generic way to print out variable name in c++
  22. How to detect negative numbers as parsing errors when reading unsigned integers?
  23. How can I print 0x0a instead of 0xa using cout?
  24. shared_ptr: horrible speed
  25. Why is std::vector::operator[] 5 to 10 times faster than std::vector::at()?
  26. Reading files larger than 4GB using c++ stl
  27. Simple for() loop benchmark takes the same time with any loop bound
  28. Wrapping FILE* with custom std::ostream
  29. New (std::nothrow) vs. New within a try/catch block
  30. C++ most efficient way to convert string to int (faster than atoi)

Leave a Comment