![\"sport](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/07\/sport-659224_1280.jpg\")
<\/p>\nAs easy as my title and the rules of the C++ core guidelines sound, getting more performance out of the iostreams is no no-brainer.<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
Okay, let’s step back. Although I did a lot of tests, my numbers in this post are more controversial than I thought. Please let me know if you have any ideas, improvements, or clarifications, and I will add them to this post.<\/p>\n
Here are the two performance-related rules from the guidelines to Iostreams.<\/p>\n
printf<\/code>-family functions call ios_base::sync_with_stdio(false)<\/code><\/a><\/li>\n- SL.io.50: Avoid
endl<\/code><\/a><\/li>\n<\/ul>\nI assume you don’t know std::ios_base::sync_with_stdio<\/span>?<\/p>\nSL.io.10: Unless you use printf<\/code>-family functions call ios_base::sync_with_stdio(false)<\/code><\/a><\/h2>\nPer default, operations on the C++ streams are synchronized with the C streams. This synchronization happens after each in- or output operation.<\/p>\n
\n- C++ Streams: std::cin<\/a><\/span>, std::cout<\/a><\/span>, std::cerr<\/a><\/span>, std::clog<\/a><\/span>, std::wcin<\/a><\/span>, std::wcout<\/a><\/span>, std::wcerr<\/a><\/span>, and std::wclog<\/a><\/span>.<\/li>\n
- C Streams: stdin<\/a><\/span>, stdout<\/a><\/span>, and stderr<\/a><\/span>.<\/li>\n<\/ul>\n
This allows it to mix C++ and C in- or output operations because operations on the C++ streams go unbuffered to the C streams. What is also important to note from the concurrency perspective: synchronized C++ streams are thread-safe. All threads can write to the C++ streams without any need for synchronization. The effect may be an interleaving of characters but not a data race.<\/p>\n
When you set the std::ios_base::sync_with_stdio(false)<\/span>, the synchronization between C++ streams and C streams will not happen because the C++ stream may put its output into a buffer. Because of the buffering, the in- and output operation may become faster. You must invoke std::ios_base::sync_with_stdio(false)<\/span> before any in- or output operation. If not, the behavior is implementation-defined.<\/p>\nI assume you noticed that I wrote quite often, maybe. That is for a reason.<\/p>\n
Interleaving of C++ Streams and C Streams<\/h3>\n
First, I want to know what would happen when I execute the following program with various compilers.<\/p>\n
\n\/\/ syncWithStdio.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <cstdio><\/span>\r\n \r\nint<\/span> main<\/span>(){\r\n \r\n std::<\/span>ios::<\/span>sync_with_stdio(false<\/span>);\r\n\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> \"1\"<\/span>;\r\n std::<\/span>printf(\"2\"<\/span>);\r\n std::<\/span>cout <<<\/span> \"3\"<\/span>;\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
I add a few pieces of information to get a better picture of my various compiler.<\/p>\n
GCC 8.2<\/h4>\n
![\"gcc\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/08\/gcc.png\")
<\/p>\n
![\"SyncWithStdioLinux\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/07\/SyncWithStdioLinux.png\")
<\/p>\n
Clang 8.0<\/h4>\n
![\"clang\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/07\/clang.PNG\")
<\/p>\n
![\"SyncWithStdioClang\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/07\/SyncWithStdioClang.png\")
<\/p>\n
<\/p>\n
cl.exe 19.20<\/h4>\n
![\"clexe\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/07\/clexe.PNG\")
<\/p>\n
<\/p>\n
![\"SyncWithStdioWin\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2019\/07\/SyncWithStdioWin.png\")
<\/p>\n
<\/p>\n
It seems that only the output on GCC is not synchronized. This observation does not hold for clang or cl.exe on Windows. A small performance test confirmed my first impression.<\/p>\n<\/p>\n
Performance with and without Synchronisation<\/h3>\n
Let me write a small program with and without synchronization to the console. Doing it without synchronization should be faster.<\/p>\n
\n- Synchronized<\/strong><\/li>\n<\/ul>\n
<\/p>\n
\n\/\/ syncWithStdioPerformanceSync.cpp<\/span>\r\n\r\n#include <chrono><\/span>\r\n#include <fstream><\/span>\r\n#include <iostream><\/span>\r\n#include <random><\/span>\r\n#include <sstream><\/span>\r\n#include <string><\/span>\r\n\r\nconstexpr int<\/span> iterations =<\/span> 10<\/span>;\r\n\r\nstd::<\/span>ifstream openFile(const<\/span> std::<\/span>string&<\/span> myFile){ \r\n\r\n std::<\/span>ifstream file(myFile, std::<\/span>ios::<\/span>in);\r\n if<\/span> ( !<\/span>file ){\r\n std::<\/span>cerr <<<\/span> \"Can't open file \"<\/span>+<\/span> myFile +<\/span> \"!\"<\/span> <<<\/span> std::<\/span>endl;\r\n exit(EXIT_FAILURE);\r\n }\r\n return<\/span> file;\r\n \r\n}\r\n\r\nstd::<\/span>string readFile(std::<\/span>ifstream file){ \r\n \r\n std::<\/span>stringstream buffer;\r\n buffer <<<\/span> file.rdbuf();\r\n \r\n return<\/span> buffer.str();\r\n \r\n}\r\n\r\nauto<\/span> writeToConsole(const<\/span> std::<\/span>string&<\/span> fileContent){\r\n \r\n auto<\/span> start =<\/span> std::<\/span>chrono::<\/span>steady_clock::<\/span>now();\r\n for<\/span> (auto<\/span> c:<\/span> fileContent) std::<\/span>cout <<<\/span> c;\r\n std::<\/span>chrono::<\/span>duration<<\/span>double<\/span>><\/span> dur =<\/span> std::<\/span>chrono::<\/span>steady_clock::<\/span>now() -<\/span> start;\r\n return<\/span> dur;\r\n} \r\n\r\ntemplate<\/span> <<\/span>typename<\/span> Function><\/span>\r\nauto<\/span> measureTime(std::<\/span>size_t<\/span> iter, Function&&<\/span> f){\r\n std::<\/span>chrono::<\/span>duration<<\/span>double<\/span>><\/span> dur{};\r\n for<\/span> (int<\/span> i =<\/span> 0<\/span>; i <<\/span> iter; ++<\/span>i){\r\n dur +=<\/span> f();\r\n }\r\n return<\/span> dur \/<\/span> iter;\r\n}\r\n \r\nint<\/span> main(int<\/span> argc, char<\/span>*<\/span> argv[]){\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n \/\/ get the filename<\/span>\r\n std::<\/span>string myFile;\r\n if<\/span> ( argc ==<\/span> 2<\/span> ){\r\n myFile=<\/span> argv[1<\/span>];\r\n }\r\n else<\/span>{\r\n std::<\/span>cerr <<<\/span> \"Filename missing !\"<\/span> <<<\/span> std::<\/span>endl;\r\n exit(EXIT_FAILURE);\r\n } \r\n \r\n std::<\/span>ifstream file =<\/span> openFile(myFile); \/\/ (1)<\/span>\r\n \r\n std::<\/span>string fileContent =<\/span> readFile(std::<\/span>move(file)); \/\/ (2)
<\/span>\r\n \/\/ (3)<\/span> \r\n auto<\/span> averageWithSync =<\/span> measureTime(iterations, [&<\/span>fileContent]{ return<\/span> writeToConsole(fileContent); });\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \/\/ (4)<\/span> \r\n std::<\/span>cout <<<\/span> \"With Synchronisation: \"<\/span> <<<\/span> averageWithSync.count() <<<\/span> \" seconds\"<\/span> <<<\/span> std::<\/span>endl; \r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The program is relatively easy to explain. I open a file (line 1), read its entire content (line 2) into a string, and write its iterations<\/span>-times to the console (line 3). This is done in the function writeToConsole(fileContent)<\/span>.<\/p>\niterations are in my concrete case 10. In the end, I display the average time of the output operations (line 4).<\/p>\n
\n- Non-synchronized<\/strong><\/li>\n<\/ul>\n
The non-synchronized version of the program is quite similar to the synchronized version. Only the main function changed a bit.<\/p>\n
\n\/\/ syncWithStdioPerformanceWithoutSync.cpp<\/span>\r\n\r\n... \r\n \r\nint<\/span> main(int<\/span> argc, char<\/span>*<\/span> argv[]){\r\n \r\n std::<\/span>ios::<\/span>sync_with_stdio(false<\/span>); \/\/ (1)<\/span>\r\n\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n \/\/ get the filename<\/span>\r\n std::<\/span>string myFile;\r\n if<\/span> ( argc ==<\/span> 2<\/span> ){\r\n myFile=<\/span> argv[1<\/span>];\r\n }\r\n else<\/span>{\r\n std::<\/span>cerr <<<\/span> \"Filename missing !\"<\/span> <<<\/span> std::<\/span>endl;\r\n exit(EXIT_FAILURE);\r\n } \r\n \r\n std::<\/span>ifstream file =<\/span> openFile(myFile);\r\n \r\n std::<\/span>string fileContent =<\/span> readFile(std::<\/span>move(file));\r\n \r\n auto<\/span> averageWithSync =<\/span> measureTime(iterations, [&<\/span>fileContent]{ return<\/span> writeToConsole(fileContent); });\r\n \r\n auto<\/span> averageWithoutSync =<\/span> measureTime(iterations, [&<\/span>fileContent]{ return<\/span> writeToConsole(fileContent); });\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> \"Without Synchronisation: \"<\/span> <<<\/span> averageWithoutSync.count() <<<\/span> \" seconds\"<\/span> <<<\/span> std