Optimization Strategies and Performance Analysis for Efficient Large Binary File Writing in C++

Introduction

In modern computing applications, scenarios involving large-scale datasets are increasingly common, particularly in scientific computing, big data analytics, and storage systems. Efficiently writing massive amounts of data to persistent storage devices has become a critical performance bottleneck. Based on a practical case, this paper explores how to optimize the performance of writing large binary files in C++, specifically in Solid State Drive (SSD) environments.

Problem Background and Initial Implementation

The original problem involved writing 80GB of data to an SSD, with an initial implementation using std::fstream from the C++ Standard Library:

#include <fstream>
const unsigned long long size = 64ULL * 1024ULL * 1024ULL;
unsigned long long a[size];

int main() {
    std::fstream myfile;
    myfile = std::fstream("file.binary", std::ios::out | std::ios::binary);
    for (int i = 0; i < 32; ++i) {
        myfile.write((char*)&a, size * sizeof(unsigned long long));
    }
    myfile.close();
}

This implementation achieved only about 20MB/s write speed in a Windows 7 environment, far below the theoretical performance of SSDs (150-200MB/s). The performance bottleneck primarily stemmed from frequent I/O operations and potential buffer management issues.

Optimization Solution: FILE-Based Implementation

By switching to the C Standard Library's FILE interface, performance was significantly improved:

#include <stdio.h>
const unsigned long long size = 8ULL * 1024ULL * 1024ULL;
unsigned long long a[size];

int main() {
    FILE* pFile = fopen("file.binary", "wb");
    for (unsigned long long j = 0; j < 1024; ++j) {
        fwrite(a, 1, size * sizeof(unsigned long long), pFile);
    }
    fclose(pFile);
    return 0;
}

This implementation reduced the write time for 8GB of data to 36 seconds, increasing speed to approximately 220MB/s, while CPU usage dropped from 100% to 2-5%. Key optimization points include:

• Using larger buffers to reduce system call frequency
• fwrite's batch processing capability outperforms std::fstream::write
• Avoiding the overhead of C++ stream objects

Performance Re-evaluation in Modern Environments

With the evolution of compilers and technology stacks, tests in 2017 showed that std::fstream performance had significantly improved:

#include <fstream>
#include <chrono>
#include <vector>
#include <cstdint>

std::vector<uint64_t> GenerateData(std::size_t bytes) {
    std::vector<uint64_t> data(bytes / sizeof(uint64_t));
    // Data generation logic
    return data;
}

long long option_1(std::size_t bytes) {
    auto data = GenerateData(bytes);
    auto start = std::chrono::high_resolution_clock::now();
    auto file = std::fstream("file.binary", std::ios::out | std::ios::binary);
    file.write((char*)&data[0], bytes);
    file.close();
    auto end = std::chrono::high_resolution_clock::now();
    return std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
}

// Similar implementations for option_2 (FILE) and option_3 (sync_with_stdio(false))

Test results indicated that, with modern compilers and optimization flags, std::fstream could achieve the maximum performance of SSDs, comparable to the FILE implementation.

Analysis of Key Optimization Techniques

Buffer Size Optimization: Appropriately increasing buffer size can reduce the number of I/O operations, but a balance must be struck between memory usage and performance gains.

Compiler Optimization Flags: Flags such as g++'s -O3 and Visual Studio's /Ox significantly improve code generation quality.

Standard Library Selection: std::ios_base::sync_with_stdio(false) disables synchronization between C++ and C I/O, reducing overhead.

Memory Management: Using std::vector instead of raw arrays provides better memory safety and flexibility.

Performance Comparison and Conclusion

Comprehensive test data shows:

• Original std::fstream implementation: ~20MB/s
• Optimized FILE implementation: ~220MB/s
• Modern std::fstream implementation: Reaches SSD maximum speed

The conclusion indicates that in modern C++ development, std::fstream has become a viable option for high-performance file I/O, especially when combined with appropriate compiler optimizations and buffer strategies.

Practical Recommendations

For large-scale data writing scenarios:

1. Prioritize testing different I/O methods in the target environment
2. Use modern C++ features (e.g., RAII) to ensure resource safety
3. Consider asynchronous I/O or memory-mapped files for extreme performance needs
4. Regularly update compilers and standard libraries to leverage the latest optimizations