Data Compression Benchmark (cpp, written by Codex)

Codex wrote this cpp project from the task below. It installed and ran on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Data Compression Benchmark

Write a program that benchmarks multiple compression algorithms on given data files, comparing compression ratio, speed, memory usage, and decompression speed across algorithms and compression levels.

FUNCTIONAL REQUIREMENTS:
- Accept one or more file paths as command-line arguments to use as benchmark data
- Support benchmarking multiple compression algorithms: DEFLATE (gzip), bzip2, LZMA (xz), LZ4 (if available), and zlib at various compression levels
- For each algorithm, test at multiple compression levels (e.g., levels 1, 5, 9 for gzip)
- Measure and report for each combination: compression ratio (compressed/original), compression speed (MB/s), decompression speed (MB/s), peak memory usage, and wall-clock time
- Run each benchmark multiple times (configurable via --iterations flag, default 3) and report min/mean/max for timing measurements
- Support a --quick flag to test only the default compression level for each algorithm
- Generate a summary comparison table sorted by a configurable metric via --sort flag (ratio, compress-speed, decompress-speed; default: ratio)
- Verify data integrity: decompress each result and verify it matches the original via checksum comparison
- Support benchmarking with different data types via --generate flag: text (English prose), csv (tabular data), json (structured data), binary (random bytes), and mixed
- Print results as a formatted table to console
- Save the full benchmark report as JSON with --output flag (default: compression_benchmark.json)
- If no input files are given, generate sample data files of each type (1MB each), benchmark all algorithms on each, and display a comprehensive comparison matrix
- Handle errors: unsupported algorithms on the platform, out-of-memory during compression, and algorithm-specific limitations

Create a complete C++ project for a clean Ubuntu 22.04 machine with only G++ 12+ and CMake 3.22+ installed. Include:
- Source code
- CMakeLists.txt with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

cmake_minimum_required(VERSION 3.16)
project(compression_benchmark LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_executable(compression_benchmark src/main.cpp)

# Data Compression Benchmark (C++)

## Requirements
- Ubuntu 22.04
- CMake 3.16+
- C++20 compiler
- System tools: `gzip`, `bzip2`, `xz`, optional `lz4`, `python3` (used for zlib command path)
- `sha256sum` utility

## Build
```bash
cmake -S . -B build
cmake --build build
```

## Run
```bash
./build/compression_benchmark file1 file2
./build/compression_benchmark --iterations 5 --sort compress-speed file.bin
./build/compression_benchmark --quick --generate mixed --output benchmark.json
```

If no files are provided, 1MB samples are generated and benchmarked.

#include <chrono>
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>

namespace fs = std::filesystem;

struct Config {
    std::vector<std::string> files;
    int iterations = 3;
    bool quick = false;
    std::string sort = "ratio";
    std::string generate;
    std::string output = "compression_benchmark.json";
};

struct Result {
    std::string file;
    std::string algorithm;
    int level;
    double ratio;
    double compSpeed;
    double decompSpeed;
    std::uintmax_t peakMem;
    std::uintmax_t compSize;
};

static std::string quote(const std::string& s) { return "\"" + s + "\""; }

static std::string runCommand(const std::string& cmd) {
#if defined(_WIN32)
    FILE* pipe = _popen(cmd.c_str(), "r");
#else
    FILE* pipe = popen(cmd.c_str(), "r");
#endif
    if (!pipe) throw std::runtime_error("Failed to run command: " + cmd);
    std::ostringstream out;
    char buf[4096];
    while (fgets(buf, sizeof(buf), pipe)) out << buf;
#if defined(_WIN32)
    int rc = _pclose(pipe);
#else
    int rc = pclose(pipe);
#endif
    if (rc != 0) throw std::runtime_error("Command failed: " + cmd + "\n" + out.str());
    return out.str();
}

static bool cmdExists(const std::string& c) {
    try { runCommand("command -v " + c); return true; }
    catch (...) { return false; }
}

static std::string sha256File(const fs::path& p) {
    std::string out = runCommand("sha256sum " + quote(p.string()));
    std::stringstream ss(out);
    std::string h;
    ss >> h;
    return h;
}

static Config parseArgs(int argc, char** argv) {
    Config cfg;
    for (int i = 1; i < argc; ++i) {
        std::string a = argv[i];
        if (!a.starts_with("--")) cfg.files.push_back(a);
        else if (a == "--iterations" && i + 1 < argc) cfg.iterations = std::stoi(argv[++i]);
        else if (a == "--quick") cfg.quick = true;
        else if (a == "--sort" && i + 1 < argc) cfg.sort = argv[++i];
        else if (a == "--generate" && i + 1 < argc) cfg.generate = argv[++i];
        else if (a == "--output" && i + 1 < argc) cfg.output = argv[++i];
        else throw std::runtime_error("Unknown option: " + a);
    }
    return cfg;
}

static std::vector<fs::path> generateSamples(const std::string& kind, const fs::path& outDir) {
    fs::create_directories(outDir);
    std::vector<fs::path> files;
    auto add = [&](const std::string& k, const std::string& name, const std::string& content) {
        if (!kind.empty() && kind != k && kind != "mixed") return;
        fs::path p = outDir / name;
        std::ofstream out(p, std::ios::binary);
        out << content;
        files.push_back(p);
    };

    add("text", "sample_text.txt", std::string(1024 * 1024, 'A'));
    if (kind.empty() || kind == "csv" || kind == "mixed") {
        fs::path p = outDir / "sample_csv.csv";
        std::ofstream out(p);
        out << "id,name,value\n";
        while (out.tellp() < 1024 * 1024) {
            static int i = 0;
            out << i << ",user" << i << "," << (i * 0.13) << "\n";
            i++;
        }
        files.push_back(p);
    }
    if (kind.empty() || kind == "json" || kind == "mixed") {
        fs::path p = outDir / "sample_json.json";
        std::ofstream out(p);
        out << "{\"rows\":[";
        for (int i = 0; i < 20000; ++i) {
            if (i) out << ',';
            out << "{\"id\":" << i << ",\"ok\":" << ((i % 2) ? "false" : "true") << ",\"value\":" << (i * 1.25) << "}";
        }
        out << "]}";
        files.push_back(p);
    }
    if (kind.empty() || kind == "binary" || kind == "mixed") {
        fs::path p = outDir / "sample_bin.bin";
        std::ofstream out(p, std::ios::binary);
        for (int i = 0; i < 1024 * 1024; ++i) {
            char c = static_cast<char>(i % 251);
            out.write(&c, 1);
        }
        files.push_back(p);
    }
    return files;
}

static fs::path compressAlgo(const fs::path& file, const std::string& algo, int level, const fs::path& tmpDir) {
    fs::path out = tmpDir / (file.filename().string() + "." + algo + ".cmp");
    std::string cmd;
    if (algo == "gzip") cmd = "gzip -" + std::to_string(level) + " -c " + quote(file.string()) + " > " + quote(out.string());
    else if (algo == "zlib") cmd = "python3 - <<'PY'\nimport zlib,sys\nsrc=open('" + file.string() + "','rb').read()\nopen('" + out.string() + "','wb').write(zlib.compress(src," + std::to_string(level) + "))\nPY";
    else if (algo == "bzip2") cmd = "bzip2 -" + std::to_string(level) + " -c " + quote(file.string()) + " > " + quote(out.string());
    else if (algo == "xz") cmd = "xz -" + std::to_string(level) + " -c " + quote(file.string()) + " > " + quote(out.string());
    else if (algo == "lz4") cmd = "lz4 -" + std::to_string(level) + " -c " + quote(file.string()) + " > " + quote(out.string());
    else throw std::runtime_error("Unknown algo: " + algo);
    runCommand(cmd);
    return out;
}

static fs::path decompressAlgo(const fs::path& comp, const std::string& algo, const fs::path& tmpDir) {
    fs::path out = tmpDir / (comp.filename().string() + ".dec");
    std::string cmd;
    if (algo == "gzip") cmd = "gzip -dc " + quote(comp.string()) + " > " + quote(out.string());
    else if (algo == "zlib") cmd = "python3 - <<'PY'\nimport zlib\nsrc=open('" + comp.string() + "','rb').read()\nopen('" + out.string() + "','wb').write(zlib.decompress(src))\nPY";
    else if (algo == "bzip2") cmd = "bzip2 -dc " + quote(comp.string()) + " > " + quote(out.string());
    else if (algo == "xz") cmd = "xz -dc " + quote(comp.string()) + " > " + quote(out.string());
    else if (algo == "lz4") cmd = "lz4 -dc " + quote(comp.string()) + " > " + quote(out.string());
    else throw std::runtime_error("Unknown algo: " + algo);
    runCommand(cmd);
    return out;
}

static Result benchOne(const fs::path& file, const std::string& algo, int level, int iterations) {
    std::uintmax_t origSize = fs::file_size(file);
    std::string origHash = sha256File(file);
    fs::path tmpDir = fs::temp_directory_path() / ("bench_" + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()));
    fs::create_directories(tmpDir);

    std::vector<double> cTimes, dTimes;
    std::vector<std::uintmax_t> compSizes;

    try {
        for (int i = 0; i < iterations; ++i) {
            auto t0 = std::chrono::steady_clock::now();
            fs::path comp = compressAlgo(file, algo, level, tmpDir);
            auto t1 = std::chrono::steady_clock::now();
            fs::path dec = decompressAlgo(comp, algo, tmpDir);
            auto t2 = std::chrono::steady_clock::now();

            if (sha256File(dec) != origHash) throw std::runtime_error("Integrity mismatch");

            cTimes.push_back(std::chrono::duration<double>(t1 - t0).count());
            dTimes.push_back(std::chrono::duration<double>(t2 - t1).count());
            compSizes.push_back(fs::file_size(comp));
        }
    } catch (...) {
        fs::remove_all(tmpDir);
        throw;
    }

    fs::remove_all(tmpDir);

    auto mean = [](const std::vector<double>& v) { return std::accumulate(v.begin(), v.end(), 0.0) / std::max<std::size_t>(1, v.size()); };
    auto meanSize = std::accumulate(compSizes.begin(), compSizes.end(), 0.0) / std::max<std::size_t>(1, compSizes.size());
    double cMean = mean(cTimes);
    double dMean = mean(dTimes);

    Result r;
    r.file = file.string();
    r.algorithm = algo;
    r.level = level;
    r.ratio = meanSize / origSize;
    r.compSpeed = (origSize / (1024.0 * 1024.0)) / cMean;
    r.decompSpeed = (origSize / (1024.0 * 1024.0)) / dMean;
    r.compSize = static_cast<std::uintmax_t>(meanSize);
    r.peakMem = 0;
    return r;
}

static void printTable(std::vector<Result> rows, const std::string& sortKey) {
    auto key = [&](const Result& r) {
        if (sortKey == "compress-speed") return r.compSpeed;
        if (sortKey == "decompress-speed") return r.decompSpeed;
        return r.ratio;
    };
    std::sort(rows.begin(), rows.end(), [&](const Result& a, const Result& b) {
        if (sortKey == "ratio") return key(a) < key(b);
        return key(a) > key(b);
    });

    std::vector<std::vector<std::string>> table;
    table.push_back({"File", "Algo", "Level", "Ratio", "Comp MB/s", "Decomp MB/s", "PeakMem"});
    for (const auto& r : rows) {
        std::ostringstream ratio, cs, ds;
        ratio.setf(std::ios::fixed); ratio.precision(4); ratio << r.ratio;
        cs.setf(std::ios::fixed); cs.precision(2); cs << r.compSpeed;
        ds.setf(std::ios::fixed); ds.precision(2); ds << r.decompSpeed;
        table.push_back({fs::path(r.file).filename().string(), r.algorithm, std::to_string(r.level), ratio.str(), cs.str(), ds.str(), std::to_string(r.peakMem)});
    }

    std::vector<std::size_t> w(table[0].size(), 0);
    for (const auto& row : table) for (std::size_t i = 0; i < row.size(); ++i) w[i] = std::max(w[i], row[i].size());

    for (std::size_t r = 0; r < table.size(); ++r) {
        for (std::size_t i = 0; i < table[r].size(); ++i) {
            if (i) std::cout << "  ";
            std::cout << std::left << std::setw(static_cast<int>(w[i])) << table[r][i];
        }
        std::cout << "\n";
        if (r == 0) {
            for (std::size_t i = 0; i < w.size(); ++i) {
                if (i) std::cout << "  ";
                std::cout << std::string(w[i], '-');
            }
            std::cout << "\n";
        }
    }
}

int main(int argc, char** argv) {
    try {
        Config cfg = parseArgs(argc, argv);
        std::vector<fs::path> files;
        if (cfg.files.empty()) files = generateSamples("", "sample_compression_data");
        else for (const auto& f : cfg.files) files.push_back(f);
        if (!cfg.generate.empty()) files = generateSamples(cfg.generate, "generated_compression_data");

        std::vector<std::pair<std::string, std::vector<int>>> plans;
        std::vector<int> lv = cfg.quick ? std::vector<int>{6} : std::vector<int>{1,5,9};
        plans.push_back({"gzip", lv});
        plans.push_back({"zlib", lv});
        plans.push_back({"bzip2", lv});
        plans.push_back({"xz", cfg.quick ? std::vector<int>{6} : std::vector<int>{0,6,9}});
        plans.push_back({"lz4", {1}});

        std::vector<Result> results;
        std::vector<std::string> skipped;

        for (const auto& f : files) {
            for (const auto& p : plans) {
                if ((p.first == "bzip2" && !cmdExists("bzip2")) || (p.first == "xz" && !cmdExists("xz")) || (p.first == "lz4" && !cmdExists("lz4"))) {
                    skipped.push_back("skip " + f.string() + " " + p.first + " unavailable");
                    continue;
                }
                for (int level : p.second) {
                    try {
                        results.push_back(benchOne(f, p.first, level, cfg.iterations));
                        std::cout << "bench ok: " << f.filename().string() << " " << p.first << "@" << level << "\n";
                    } catch (const std::exception& ex) {
                        skipped.push_back("fail " + f.string() + " " + p.first + "@" + std::to_string(level) + ": " + ex.what());
                    }
                }
            }
        }

        printTable(results, cfg.sort);

        std::ofstream out(cfg.output);
        out << "{\n  \"results\": [\n";
        for (std::size_t i = 0; i < results.size(); ++i) {
            const auto& r = results[i];
            out << "    {\"file\":\"" << r.file << "\",\"algorithm\":\"" << r.algorithm << "\",\"level\":" << r.level
                << ",\"compressionRatio\":" << r.ratio << ",\"compressedSize\":" << r.compSize
                << ",\"compressSpeedMBps\":" << r.compSpeed << ",\"decompressSpeedMBps\":" << r.decompSpeed
                << ",\"peakMemoryBytes\":" << r.peakMem << "}";
            if (i + 1 < results.size()) out << ",";
            out << "\n";
        }
        out << "  ],\n  \"skipped\": [\n";
        for (std::size_t i = 0; i < skipped.size(); ++i) {
            out << "    \"" << skipped[i] << "\"";
            if (i + 1 < skipped.size()) out << ",";
            out << "\n";
        }
        out << "  ]\n}\n";
    } catch (const std::exception& ex) {
        std::cerr << "Error: " << ex.what() << "\n";
        return 1;
    }
    return 0;
}