Data Compression Benchmark (javascript, written by Claude Code)

Claude Code wrote this javascript 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 JavaScript project for a clean Ubuntu 22.04 machine with only Node.js 20+ (LTS) installed. Include:
- Source code
- package.json with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

/**
 * Data Compression Benchmark - JavaScript (Trial 1)
 *
 * Benchmarks DEFLATE/zlib and LZ4 compression algorithms comparing
 * compression ratio, speed, and memory usage across compression levels.
 *
 * Dependencies: pako (DEFLATE/zlib), lz4js (LZ4)
 */

const pako = require('pako');
const lz4 = require('lz4js');

/**
 * Generate synthetic test data with mixed patterns.
 */
function generateTestData(sizeBytes) {
    const buffer = Buffer.alloc(sizeBytes);
    let offset = 0;

    const textBlock = 'The quick brown fox jumps over the lazy dog. ' +
        'Data compression reduces the size of data for storage or transmission. ' +
        'Lossless compression allows perfect reconstruction of the original data. ';
    const textBuf = Buffer.from(textBlock, 'utf-8');

    // First third: repeated text
    while (offset < Math.floor(sizeBytes / 3) && offset + textBuf.length <= sizeBytes) {
        textBuf.copy(buffer, offset);
        offset += textBuf.length;
    }

    // Second third: repeated binary pattern
    const pattern = Buffer.from([0xAB, 0xCD, 0xEF, 0x01, 0x23, 0x45]);
    while (offset < Math.floor(2 * sizeBytes / 3) && offset + pattern.length <= sizeBytes) {
        pattern.copy(buffer, offset);
        offset += pattern.length;
    }

    // Final third: pseudo-random data
    let seed = 42;
    while (offset < sizeBytes) {
        seed = (seed * 1103515245 + 12345) & 0x7FFFFFFF;
        buffer[offset] = seed & 0xFF;
        offset++;
    }

    return buffer;
}

/**
 * Measure memory usage in KB.
 */
function getMemoryUsageKB() {
    if (global.gc) global.gc();
    return Math.round(process.memoryUsage().heapUsed / 1024);
}

/**
 * Format bytes as human-readable string.
 */
function formatBytes(bytes) {
    const units = ['B', 'KB', 'MB', 'GB'];
    let size = bytes;
    for (const unit of units) {
        if (size < 1024) return `${size.toFixed(2)} ${unit}`;
        size /= 1024;
    }
    return `${size.toFixed(2)} TB`;
}

/**
 * Benchmark pako (DEFLATE/zlib) at a given compression level.
 */
function benchmarkPakoDeflate(data, level) {
    const memBefore = getMemoryUsageKB();

    // Compress
    const compStart = process.hrtime.bigint();
    const compressed = pako.deflate(data, { level });
    const compEnd = process.hrtime.bigint();
    const compTimeMs = Number(compEnd - compStart) / 1e6;

    // Decompress
    const decompStart = process.hrtime.bigint();
    const decompressed = pako.inflate(compressed);
    const decompEnd = process.hrtime.bigint();
    const decompTimeMs = Number(decompEnd - decompStart) / 1e6;

    // Verify
    if (!Buffer.from(decompressed).equals(data)) {
        throw new Error('DEFLATE decompression verification failed');
    }

    const memAfter = getMemoryUsageKB();
    const sizeMb = data.length / (1024 * 1024);

    return {
        algorithm: 'DEFLATE (pako)',
        level,
        originalSize: data.length,
        compressedSize: compressed.length,
        compressionRatio: data.length / compressed.length,
        compressionTimeMs: compTimeMs,
        decompressionTimeMs: decompTimeMs,
        compressionSpeedMbps: sizeMb / (compTimeMs / 1000),
        decompressionSpeedMbps: sizeMb / (decompTimeMs / 1000),
        peakMemoryKb: Math.max(0, memAfter - memBefore)
    };
}

/**
 * Benchmark pako gzip at a given compression level.
 */
function benchmarkPakoGzip(data, level) {
    const memBefore = getMemoryUsageKB();

    const compStart = process.hrtime.bigint();
    const compressed = pako.gzip(data, { level });
    const compEnd = process.hrtime.bigint();
    const compTimeMs = Number(compEnd - compStart) / 1e6;

    const decompStart = process.hrtime.bigint();
    const decompressed = pako.ungzip(compressed);
    const decompEnd = process.hrtime.bigint();
    const decompTimeMs = Number(decompEnd - decompStart) / 1e6;

    if (!Buffer.from(decompressed).equals(data)) {
        throw new Error('Gzip decompression verification failed');
    }

    const memAfter = getMemoryUsageKB();
    const sizeMb = data.length / (1024 * 1024);

    return {
        algorithm: 'Gzip (pako)',
        level,
        originalSize: data.length,
        compressedSize: compressed.length,
        compressionRatio: data.length / compressed.length,
        compressionTimeMs: compTimeMs,
        decompressionTimeMs: decompTimeMs,
        compressionSpeedMbps: sizeMb / (compTimeMs / 1000),
        decompressionSpeedMbps: sizeMb / (decompTimeMs / 1000),
        peakMemoryKb: Math.max(0, memAfter - memBefore)
    };
}

/**
 * Benchmark LZ4 compression.
 */
function benchmarkLz4(data) {
    const memBefore = getMemoryUsageKB();

    const compStart = process.hrtime.bigint();
    const compressed = lz4.compress(data);
    const compEnd = process.hrtime.bigint();
    const compTimeMs = Number(compEnd - compStart) / 1e6;

    const decompStart = process.hrtime.bigint();
    const decompressed = lz4.decompress(compressed, data.length);
    const decompEnd = process.hrtime.bigint();
    const decompTimeMs = Number(decompEnd - decompStart) / 1e6;

    if (!Buffer.from(decompressed).equals(data)) {
        throw new Error('LZ4 decompression verification failed');
    }

    const memAfter = getMemoryUsageKB();
    const sizeMb = data.length / (1024 * 1024);

    return {
        algorithm: 'LZ4 (lz4js)',
        level: 1,
        originalSize: data.length,
        compressedSize: compressed.length,
        compressionRatio: data.length / compressed.length,
        compressionTimeMs: compTimeMs,
        decompressionTimeMs: decompTimeMs,
        compressionSpeedMbps: sizeMb / (compTimeMs / 1000),
        decompressionSpeedMbps: sizeMb / (decompTimeMs / 1000),
        peakMemoryKb: Math.max(0, memAfter - memBefore)
    };
}

/**
 * Print results in a formatted table.
 */
function printResults(results) {
    const header = [
        'Algorithm'.padEnd(20),
        'Level'.padStart(5),
        'Ratio'.padStart(8),
        'Comp(ms)'.padStart(10),
        'Decomp(ms)'.padStart(11),
        'Speed(MB/s)'.padStart(12),
        'Memory(KB)'.padStart(11)
    ].join(' ');

    console.log('\n' + '='.repeat(header.length));
    console.log('COMPRESSION BENCHMARK SUMMARY');
    console.log('='.repeat(header.length));
    console.log(header);
    console.log('-'.repeat(header.length));

    for (const r of results) {
        console.log([
            r.algorithm.padEnd(20),
            String(r.level).padStart(5),
            r.compressionRatio.toFixed(2).padStart(8),
            r.compressionTimeMs.toFixed(1).padStart(10),
            r.decompressionTimeMs.toFixed(1).padStart(11),
            r.compressionSpeedMbps.toFixed(1).padStart(12),
            String(r.peakMemoryKb).padStart(11)
        ].join(' '));
    }

    console.log('='.repeat(header.length));
}

/**
 * Find and display best results.
 */
function printBestResults(results) {
    const bestRatio = results.reduce((a, b) => a.compressionRatio > b.compressionRatio ? a : b);
    const fastest = results.reduce((a, b) => a.compressionTimeMs < b.compressionTimeMs ? a : b);
    const fastestDecomp = results.reduce((a, b) => a.decompressionTimeMs < b.decompressionTimeMs ? a : b);

    console.log(`\nBest compression ratio: ${bestRatio.algorithm} level ${bestRatio.level} (${bestRatio.compressionRatio.toFixed(2)}x)`);
    console.log(`Fastest compression: ${fastest.algorithm} level ${fastest.level} (${fastest.compressionTimeMs.toFixed(1)}ms)`);
    console.log(`Fastest decompression: ${fastestDecomp.algorithm} level ${fastestDecomp.level} (${fastestDecomp.decompressionTimeMs.toFixed(1)}ms)`);
}

/**
 * Main benchmark runner.
 */
function main() {
    console.log('============================================================');
    console.log('  Data Compression Benchmark - JavaScript');
    console.log('  DEFLATE / Gzip / LZ4');
    console.log('============================================================\n');

    const dataSize = parseInt(process.argv[2]) || 2_000_000;
    const levels = [1, 3, 6, 9];
    const iterations = 3;

    console.log(`Generating ${formatBytes(dataSize)} of test data...`);
    const testData = generateTestData(dataSize);
    console.log(`Test data generated: ${testData.length} bytes\n`);

    const results = [];

    // Warm up
    console.log('Warming up...');
    benchmarkPakoDeflate(testData, 1);
    console.log('');

    // DEFLATE benchmarks
    console.log('--- Benchmarking DEFLATE (pako) ---');
    for (const level of levels) {
        let best = null;
        for (let i = 0; i < iterations; i++) {
            const r = benchmarkPakoDeflate(testData, level);
            if (!best || r.compressionTimeMs < best.compressionTimeMs) best = r;
        }
        results.push(best);
        console.log(`  Level ${level}: ratio=${best.compressionRatio.toFixed(2)}x compress=${best.compressionTimeMs.toFixed(1)}ms decompress=${best.decompressionTimeMs.toFixed(1)}ms`);
    }

    // Gzip benchmarks
    console.log('\n--- Benchmarking Gzip (pako) ---');
    for (const level of levels) {
        let best = null;
        for (let i = 0; i < iterations; i++) {
            const r = benchmarkPakoGzip(testData, level);
            if (!best || r.compressionTimeMs < best.compressionTimeMs) best = r;
        }
        results.push(best);
        console.log(`  Level ${level}: ratio=${best.compressionRatio.toFixed(2)}x compress=${best.compressionTimeMs.toFixed(1)}ms decompress=${best.decompressionTimeMs.toFixed(1)}ms`);
    }

    // LZ4 benchmark
    console.log('\n--- Benchmarking LZ4 (lz4js) ---');
    let bestLz4 = null;
    for (let i = 0; i < iterations; i++) {
        const r = benchmarkLz4(testData);
        if (!bestLz4 || r.compressionTimeMs < bestLz4.compressionTimeMs) bestLz4 = r;
    }
    results.push(bestLz4);
    console.log(`  Level 1: ratio=${bestLz4.compressionRatio.toFixed(2)}x compress=${bestLz4.compressionTimeMs.toFixed(1)}ms decompress=${bestLz4.decompressionTimeMs.toFixed(1)}ms`);

    printResults(results);
    printBestResults(results);
}

main();

{
  "name": "compression-benchmark",
  "version": "1.0.0",
  "description": "Data compression benchmark comparing DEFLATE, Gzip, and LZ4 algorithms",
  "main": "benchmark.js",
  "scripts": {
    "start": "node benchmark.js",
    "benchmark": "node benchmark.js",
    "benchmark:large": "node benchmark.js 10000000"
  },
  "keywords": ["compression", "benchmark", "deflate", "lz4", "gzip"],
  "license": "MIT",
  "dependencies": {
    "pako": "^2.1.0",
    "lz4js": "^0.2.0"
  }
}

# Data Compression Benchmark - JavaScript (Trial 1)

## Description

Benchmarks DEFLATE, Gzip, and LZ4 compression algorithms in JavaScript. Compares compression ratio, speed, and memory usage across multiple compression levels. Uses synthetic test data with mixed patterns for realistic benchmarking.

## Dependencies

- **pako** (^2.1.0) - DEFLATE and Gzip compression/decompression
- **lz4js** (^0.2.0) - LZ4 fast compression algorithm

## Install

```bash
npm install
```

## Run

```bash
# Default (2 MB test data)
node benchmark.js

# Custom data size (bytes)
node benchmark.js 5000000

# Using npm scripts
npm start
npm run benchmark:large
```

## Output

The benchmark produces a summary table with columns:
- Algorithm name and compression level
- Compression ratio (higher is better)
- Compression and decompression time (ms)
- Compression speed (MB/s)
- Peak memory usage (KB)