How to optimize IO in C++

A developer explains how to optimize I/O in C++ by disabling synchronization between C++ streams and C standard streams, and by manually flushing the output buffer. The post details the performance costs of reading and writing data due to operating system calls and context switching, and provides code examples for competitive programming.

Link to the repository containing all examples https://github.com/MiztonCodes/OptimizeIO Back when I was at my first class of Data Structures and Algorithms, I started to solve competitive programming questions in judges like CodeForces, I didn't know why my code was slower if my solution was efficient at least in theory , my professor explain to the class the reason why our programs were slow, because of I/O is an expensive task for computers. To start working with the examples in this article just clone the repository and play with it as long the article explains how to run the code. git clone https://github.com/MiztonCodes/OptimizeIO.git std::cout and std::cin are slow? In C++ by default, both std::cin and std::cout streams are synchronized with standard C scanf and printf streams and at the same time every single call to std::cin flushes the std::cout buffer, because std::cin before reading input, wants to output any pending prompt to the user, which can cause performance issues because reading and writing are expensive tasks due to the need to make calls to the operating system, the solution is to disable all of this synchronizations and manually flushing the output buffer whenever it is needed. Note: For convenience in all examples I'll use include<bits/stdc++.h header to simplify the imports, this header includes everything we'll need and this header only works on GCC compiler. When you run your program, it is like an isolated box inside your computer, ready to do some work, the input process involves moving raw data from an external source like a keyboard, a file or even the network to your program reading , the output process involves moving data from your program to an external destination like a monitor, the console, a file, the network or even an external device writing , for both processes your program does not read or write directly to the input and output sources, because each source has its own way to transfer data, C++ provides a uniform interface to hide that complexity through the usage of streams . In C++ and other programming languages, a stream is an abstraction layer that hides the complexity of dealing with external sources to read and write data from your program, so you can use a unified interface with the following operators for writing dest << data and reading source dest . The stream is able to translate the raw input data into data types that your program can understand like int , bool , char , so basically the stream is only responsible to transport data. A buffer is a contiguous block of memory located at the RAM, reserved to batch data to reduce the amount of calls to the operating system, once the buffer has reached its full capacity the operating system performs one single efficient transfer of buffer's data to its final destination, so the memory of the buffer can be reused and then wait until the buffer reached its full capacity again, this makes buffers the perfect place to hold data during your program execution. As in real life the travel from shorter distances almost always implies shorter travel times and plus the planning time, reading and writing data is expensive because the data must travel from one location to its destination and at same time the CPU needs to manage the transfer of data. Reading and writing data implies much more than just moving data from one location to its destination, when a reading or writing operation is needed a call to the operating system is made and the process first makes the CPU to switch the context of whatever it was doing before, then verifies permission and perform operations on memory to finally move the data, while all this happens the CPU spends a lot time and operations waiting to move the data to its destination. This is due to the C++ history, C++ at first was C with classes, nowadays to keep compatibility and consistency it keeps synchronized standard input and output streams, so you can mix both styles in a single program and expects the output order be preserved when mixing both styles, but it introduces performance issues, especially when you don't need that synchronization like in competitive programming or newer projects where compatibility with C is not needed. As I said earlier, just disable all synchronizations and manually flush the output stream when needed, just add the following lines to the beginning of your main function. Warning: When you disable synchronization, don't mix both styles because it can produce an undefined behavior // Disable synchronization with standard C scanf and printf streams std::ios base::sync with stdio false ; // Disable synchronization between std::cin and std::cout streams std::cin.tie nullptr ; Note: You only need to untie std::cin like in the code snippet above because std::cout is not tied to anything, so just remember to only untie std::cin. To demonstrate performance gains, you can run the following tests to verify it by yourself. Note: To demonstrate a noticeable performance gain, use as input the dataset.txt file hosted in the repository of this example, this file has a size of 75 MB and contains 10 million integer numbers from 1 to 10'000'000 this is a really simple example to demonstrate performance gains even when your program only read data and don't perform any other computation. To compile and run the next examples just use the following commands. Move the section directory cd 01 Optimize Writing Give execution permissions to compilation scripts chmod +x run without optimization.sh chmod +x run with optimization.sh Run the examples below ./run without optimization.sh ./run with optimization.sh include <bits/stdc++.h int main { // Get the current time before executing the heavy part. auto start = std::chrono::high resolution clock::now ; // Heavy part reading data. int val = 0; for long long i = 0; i < 10'000'000; ++i { std::cin val; } // Get the current time after executing the heavy part. auto end = std::chrono::high resolution clock::now ; // Calculate the exeuction time lapse. std::chrono::duration<double diff = end - start; // Using std::cerr to print diagnostic data immediately. std::cerr << "Time taken: " << diff.count << " seconds" << std::endl; } You will get an output like this Time taken: 5.39379 seconds include <bits/stdc++.h int main { // Optimization std::ios base::sync with stdio false ; std::cin.tie nullptr ; // Get the current time before executing the heavy part. auto start = std::chrono::high resolution clock::now ; // Heavy part reading data. int val = 0; for long long i = 0; i < 10'000'000; ++i { std::cin val; } // Get the current time after executing the heavy part. auto end = std::chrono::high resolution clock::now ; // Calculate the exeuction time lapse. std::chrono::duration<double diff = end - start; // Using std::cerr to print diagnostic data immediately. std::cerr << "Time taken: " << diff.count << " seconds" << std::endl; } You will get an output like this Time taken: 0.667611 seconds Even in this really simple example we can observe a performance gain of five times faster execution, just disabling the synchronization of streams. Avoid the usage of std::endl to add a line break , because std::endl add a line break and at the same time it flushes the buffer which is an expensive operation , so if you only want to add a line break just use the \n character like in the next example: / Avoid this style to add line breaks, it will add a line break at the end of the string and flush the output buffer which will cause performance issue. / std::cout << "Woody " << std::endl; / Prefer this style to add line breaks, it will add a line break at the end of the string and will not flush the output, so the string is going to be batched at the output buffer, / std::cout << "Woody \n"; To demonstrate performance gains, you can run the following tests to verify it by yourself. To compile and run the next examples just use the following commands. Move the section directory cd 01 Optimize Reading Give execution permissions to compilation scripts chmod +x run without optimization.sh chmod +x run with optimization.sh Run the examples below ./run without optimization.sh ./run with optimization.sh std::endl include <bits/stdc++.h int main { / In this case the following lines does not affect in any case because we are not reading data. / std::ios base::sync with stdio false ; std::cin.tie nullptr ; // Get the current time before executing the heavy part. auto start = std::chrono::high resolution clock::now ; // Heavy part writing data. for int i = 1; i <= 10'000'000; ++i { std::cout << "Iteration " << i << std::endl; } // Get the current time after executing the heavy part. auto end = std::chrono::high resolution clock::now ; // Calculate the exeuction time lapse. std::chrono::duration<double diff = end - start; // Using std::cerr to print diagnostic data immediately. std::cerr << "Time taken: " << diff.count << " seconds" << std::endl; } You will get an output like this Time taken: 5.76418 seconds \n include <bits/stdc++.h int main { / In this case the following lines does not affect in any case because we are not reading data. / std::ios base::sync with stdio false ; std::cin.tie nullptr ; // Get the current time before executing the heavy part. auto start = std::chrono::high resolution clock::now ; // Heavy part writing data. for int i = 1; i <= 10'000'000; ++i { std::cout << "Iteration " << i << "\n"; } // Get the current time after executing the heavy part. auto end = std::chrono::high resolution clock::now ; // Calculate the exeuction time lapse. std::chrono::duration<double diff = end - start; // Using std::cerr to print diagnostic data immediately. std::cerr << "Time taken: " << diff.count << " seconds" << std::endl; } You will get an output like this Time taken: 1.47316 seconds Even in this really simple example we can observe a performance gain of five times faster execution, just by not flushing the output buffer every single time we need to add a line break. To compile and run the next examples just use the following commands. Move the section directory cd 02 Miscellaneous Give execution permissions to compilation scripts chmod +x run error log.sh chmod +x run format output.sh chmod +x run redirect io.sh chmod +x run operator overloading.sh Run the examples below ./run error log.sh ./run format output.sh ./run redirect io.sh ./run operator overloading.sh std::cerr stream for errors and diagnostics In addition to the standard std::cin reading and std::cout writing streams, C++ provides another std::cerr stream to write errors and diagnostic data, the difference between std::cout and std::cerr is mainly the way each of them outputs data, while std::cout holds data in a buffer, std::cerr is unbuffered and outputs data immediately after a call to it, so if you use std::cout and the program execution is interrupted, the output buffer is going to be destroyed along the program and data stored in the buffer will be lost. include <bits/stdc++.h int main { std::cout << "First std::cout call\n"; std::cerr << "Using this to print error messages and diagnostic data.\n"; std::cout << "Second std::cout call\n"; } You will get this output First std::cout call Using this to print error messages and diagnostic data. Second std::cout call As you can read a call to std::cerr writes immediately to the console because it is unbuffered. If you are using C++20 or higher, you can use the modern std::format to print in fixed-point, and scientific notations like in the following example. include <bits/stdc++.h int main { double my number = 7.2069; // Default formatting std::cout << std::format "Default notation: {}\n", my number ; // Fixed-point and rounded up with 2 decimal places std::cout << std::format "Fixed and rounded up 2 decimal : {:.2f}\n", my number ; // Fixed-point and floored with 2 decimal places std::cout << std::format "Fixed and floored 2 decimal : {:.2f}\n", std::floor my number ; // Fixed-pint and ceiled with 2 decimal places std::cout << std::format "Fixed and ceiled 2 decimal : {:.2f}\n", std::ceil my number ; // Scientific notation std::cout << std::format "Scientific and rounded up: {:.2e}\n", my number ; return 0; } You will get an output like this Default notation: 7.2069 Fixed and rounded up 2 decimal : 7.21 Fixed and floored 2 decimal : 7.00 Fixed and ceiled 2 decimal : 8.00 Scientific and rounded up: 7.21e+00 This is useful when you need to deal with decimal places and rounding decimal numbers based on the question requirements. It is very tedious to read and write data directly from the terminal, and have mixed output along with logs, errors, diagnostics and output data, so you can redirect all of this input and output categories to files in your filesystem when you execute the program. The operating system has multiple channels to read and write data, so when you run your program you can redirect channels to files like in the following example. ./bin 0< input.txt 1 output.txt 2 errors.txt And you can still use std::cin , std::cout and std::cerr just like any other program and have a more cleaner workspace, this is helpful if you have a really large input.txt dataset file and copy pasting to the terminal is not an option. Extra: There is also an standard std::log stream that is buffered and writes data to the error channel, use it only when you need to write some extra information but you don't need it immediately. In C++ you can keep using std::cin and std::cout but redirect the streams to read and write from a custom string or a file streams and then rollback the original ones to read and write from the standard input and output. In the following example a RAII Resource Acquisition Is Initialization pattern is implemented to ensure the swap and rollback of buffers is secure even if an exception happens or the program ends early. Note: You can run this example using the files provided at the repository of the article. include <bits/stdc++.h / This class will hold the overall logic to swap buffers given a stream and a new buffer using the RAII pattern. / class stream redir { private: // Holds the stream std::ios& stream; // Holds the original buffer of the stream std::streambuf origin buff; public: / The constructor will save a reference to the stream and will hold a pointer to the original buffer while assigning the new buffer to the stream. / stream redir std::ios& stream, std::streambuf new buffer : stream stream , origin buff stream.rdbuf new buffer {} // The destructor automatically restores the original buffer. ~stream redir { stream.rdbuf origin buff ; } // Prevent copying to avoid multiple restorations of the same buffer. stream redir const stream redir& = delete; stream redir operator= const stream redir& = delete; }; void redirect output to string { std::cout << "=== REDIRECT OUTPUT TO A STRING ===\n"; std::stringstream custom out; std::cout << "Before redirection\n"; // In this scope the redirection will happens. { stream redir redir std::cout, custom out.rdbuf ; std::cout << "This message is going to be stored at custom out buffer"; } // At the end of the scope, buffer restoration happens. std::cout << "After redirection\n"; std::cout << "custom out contents:\n"; std::cout << custom out.rdbuf << "\n"; } void redirect input to string { std::cout << "=== REDIRECT INPUT TO A STRING ===\n"; std::string input data = "I'm happy learning C++"; std::stringstream custom in input data ; std::string read data; read data.reserve input data.size ; // In this scope the redirection will happens. { stream redir redir std::cin, custom in.rdbuf ; while std::getline std::cin, read data {} } // At the end of the scope, buffer restoration happens. std::cout << "read data contents:\n"; std::cout << read data << "\n"; } void redirect output to file { std::cout << "=== REDIRECT OUTPUT TO A FILE ===\n"; std::filebuf custom out; custom out.open "dataset temp.txt", std::ios::out ; std::vector<int nums{1, 2, 3, 4, 5}; std::cout << "Before redirection\n"; // In this scope the redirection will happens. { stream redir redir std::cout, &custom out ; for const int& n : nums { std::cout << n << "\n"; } } // At the end of the scope, buffer restoration happens. std::cout << "After redirection\n"; } void redirect input to file { std::cout << "=== REDIRECT INPUT TO A FILE ===\n"; std::filebuf custom in; // Here read data from the file created by redirect output to file function custom in.open "dataset temp.txt", std::ios::in ; constexpr size t MAX NUM SIZE = 5; std::vector<int nums; nums.reserve MAX NUM SIZE ; std::cout << "Before reading nums.size == " << nums.size << "\n"; // In this scope the redirection will happens. { stream redir redir std::cin, &custom in ; for size t i = 0; i < MAX NUM SIZE; ++i { int n = 0; std::cin n; nums.push back n ; } } // At the end of the scope, buffer restoration happens. std::cout << "After reading nums.size == " << nums.size << "\n"; for const auto& n : nums std::cout << n << " "; std::cout << "\n"; } int main { // Optimization for reading and writing std::ios base::sync with stdio false ; std::cin.tie nullptr ; // Examples redirect output to string ; redirect input to string ; redirect output to file ; redirect input to file ; } You will get an output like this === REDIRECT OUTPUT TO A STRING === Before redirection After redirection custom out contents: This message is going to be stored at custom out buffer === REDIRECT INPUT TO A STRING === read data contents: I'm happy learning C++ === REDIRECT OUTPUT TO A FILE === Before redirection After redirection === REDIRECT INPUT TO A FILE === Before reading nums.size == 0 After reading nums.size == 5 1 2 3 4 5 So as you can see, the streams can be redirected to read and write data to other sources, this is useful for testing when you try to mock certain input or output sources while keep using the standard input and output streams. Sometimes you will need to read and write data based on a format or structure, for example to read data and create an instance of a class or struct, maybe you want to print all your vector public members to a certain format so other programs can understand your data. In C++ you can overload the << output operator and the input operator to work with complex data types like in the next example. include <bits/stdc++.h namespace mizton { struct vector 3d { int x, y, z; }; }; / Overloading of output operator on output streams. / std::ostream& operator<< std::ostream& os, const mizton::vector 3d& v { os << "vector{" << v.x << "," << v.y << "," << v.z << "}\n"; return os; } / Overloading of input operator on input streams. / std::istream& operator std::istream& is, mizton::vector 3d& v { int x = 0, y = 0, z = 0; / In this case we don't allow negative numbers as coordinate values, so we will set the read operation as failed, so the calling code can handle the error. / if is x y z { if x < 0 || y < 0 || z < 0 { is.setstate std::ios::failbit ; // Indicates input conversion fails std::cerr << "Negative coordinate value can't be converted to a mizton::vector 3d structure\n"; } else { v.x = x; v.y = y; v.z = z; } } else { is.setstate std::ios::badbit ; // Indicates a loss of integrity std::cerr << "Lost data while trying to read a mizton::vector 3d structure\n"; } return is; } int main { // Mock input stream std::stringstream input stream R" 3 1 0 1 1 0 3 5 6 1 " ; // Reading from input stream int vector size = 0; input stream vector size; assert vector size = 0 ; // Ensure the first number read is positive std::vector<mizton::vector 3d v list vector size ; for int i = 0; i < vector size; ++i { / If input reading fails, just ends the program normally performing a clean up of variables and calling destructors and return exit code of a failure. / if input stream v list i { return EXIT FAILURE; } } // Writing data to standard output for const auto& v : v list { std::cout << v; } return EXIT SUCCESS; } After running the code above, you will get an output like this vector{1,0,1} vector{1,0,3} vector{5,6,1} If you change some of the values for vectors to negative, the program will ends and an error like this will be out Negative coordinate value can't be converted to a mizton::vector 3d structure In real life, using streams and buffers in C++ can be really complex and allow us to create really performant systems, I have shared what I found useful to deal with, especially when I was working with online judges like CodeForces to test my solution.