Data Compression Benchmark (java, written by Claude Code)

diff --git a/pom.xml b/pom.xml
index 2689350..839de45 100644
--- a/pom.xml
+++ b/pom.xml
@@ -55,6 +55,6 @@
                     </archive>
                 </configuration>
             </plugin>
-        </plugins>
+        <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-shade-plugin</artifactId><version>3.5.1</version><executions><execution><phase>package</phase><goals><goal>shade</goal></goals><configuration><transformers><transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"><mainClass>CompressionBench</mainClass></transformer></transformers></configuration></execution></executions></plugin></plugins>
     </build>
 </project>
--- /dev/null
+++ b/src/main/java/CompressionBench.java
@@ -0,0 +1,417 @@
+import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream;
+import org.apache.commons.compress.compressors.bzip2.BZip2CompressorOutputStream;
+import org.apache.commons.compress.compressors.lzma.LZMACompressorInputStream;
+import org.apache.commons.compress.compressors.lzma.LZMACompressorOutputStream;
+import org.apache.commons.compress.compressors.deflate.DeflateCompressorInputStream;
+import org.apache.commons.compress.compressors.deflate.DeflateCompressorOutputStream;
+import org.apache.commons.compress.compressors.deflate.DeflateParameters;
+import net.jpountz.lz4.*;
+import com.github.luben.zstd.Zstd;
+
+import java.io.*;
+import java.util.*;
+import java.util.zip.*;
+
+/**
+ * Data Compression Benchmark - Java (Trial 1)
+ *
+ * Benchmarks DEFLATE, bzip2, LZMA, LZ4, and Zstandard comparing
+ * compression ratio, speed, and memory usage across compression levels.
+ */
+public class CompressionBench {
+
+    static class BenchmarkResult {
+        String algorithm;
+        int level;
+        int originalSize;
+        int compressedSize;
+        double compressionRatio;
+        double compressionTimeMs;
+        double decompressionTimeMs;
+        double compressionSpeedMbps;
+        double decompressionSpeedMbps;
+        long peakMemoryKb;
+
+        @Override
+        public String toString() {
+            return String.format("%-15s %5d %8.2f %10.1f %11.1f %12.1f %11d",
+                    algorithm, level, compressionRatio, compressionTimeMs,
+                    decompressionTimeMs, compressionSpeedMbps, peakMemoryKb);
+        }
+    }
+
+    private static byte[] generateTestData(int sizeBytes) {
+        byte[] data = new byte[sizeBytes];
+        Random random = new Random(42);
+
+        // Text-like patterns
+        String 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. ";
+        byte[] textBytes = textBlock.getBytes();
+
+        int offset = 0;
+        // Fill first third with repeated text
+        while (offset < sizeBytes / 3 && offset + textBytes.length <= sizeBytes) {
+            System.arraycopy(textBytes, 0, data, offset, textBytes.length);
+            offset += textBytes.length;
+        }
+
+        // Fill second third with repeated pattern
+        byte[] pattern = {(byte) 0xAB, (byte) 0xCD, (byte) 0xEF, 0x01, 0x23, 0x45};
+        while (offset < 2 * sizeBytes / 3 && offset + pattern.length <= sizeBytes) {
+            System.arraycopy(pattern, 0, data, offset, pattern.length);
+            offset += pattern.length;
+        }
+
+        // Fill rest with random data
+        byte[] randomBytes = new byte[sizeBytes - offset];
+        random.nextBytes(randomBytes);
+        System.arraycopy(randomBytes, 0, data, offset, randomBytes.length);
+
+        return data;
+    }
+
+    private static long getUsedMemory() {
+        Runtime runtime = Runtime.getRuntime();
+        runtime.gc();
+        return (runtime.totalMemory() - runtime.freeMemory()) / 1024;
+    }
+
+    // --- DEFLATE ---
+    private static BenchmarkResult benchmarkDeflate(byte[] data, int level) throws IOException {
+        BenchmarkResult result = new BenchmarkResult();
+        result.algorithm = "DEFLATE";
+        result.level = level;
+        result.originalSize = data.length;
+
+        long memBefore = getUsedMemory();
+
+        // Compress
+        long start = System.nanoTime();
+        DeflateParameters params = new DeflateParameters();
+        params.setCompressionLevel(level);
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (DeflateCompressorOutputStream dcos = new DeflateCompressorOutputStream(baos, params)) {
+            dcos.write(data);
+        }
+        byte[] compressed = baos.toByteArray();
+        result.compressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;
+
+        result.compressedSize = compressed.length;
+        result.compressionRatio = (double) data.length / compressed.length;
+
+        // Decompress
+        start = System.nanoTime();
+        ByteArrayInputStream bais = new ByteArrayInputStream(compressed);
+        try (DeflateCompressorInputStream dcis = new DeflateCompressorInputStream(bais)) {
+            byte[] decompressed = dcis.readAllBytes();
+            if (!Arrays.equals(data, decompressed)) {
+                throw new RuntimeException("Decompression verification failed");
+            }
+        }
+        result.decompressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;
+
+        long memAfter = getUsedMemory();
+        result.peakMemoryKb = Math.max(0, memAfter - memBefore);
+
+        double sizeMb = data.length / (1024.0 * 1024.0);
+        result.compressionSpeedMbps = sizeMb / (result.compressionTimeMs / 1000.0);
+        result.decompressionSpeedMbps = sizeMb / (result.decompressionTimeMs / 1000.0);
+
+        return result;
+    }
+
+    // --- bzip2 ---
+    private static BenchmarkResult benchmarkBzip2(byte[] data, int level) throws IOException {
+        BenchmarkResult result = new BenchmarkResult();
+        result.algorithm = "bzip2";
+        result.level = level;
+        result.originalSize = data.length;
+
+        long memBefore = getUsedMemory();
+
+        // Compress
+        long start = System.nanoTime();
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (BZip2CompressorOutputStream bcos = new BZip2CompressorOutputStream(baos, level)) {
+            bcos.write(data);
+        }
+        byte[] compressed = baos.toByteArray();
+        result.compressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;
+
+        result.compressedSize = compressed.length;
+        result.compressionRatio = (double) data.length / compressed.length;
+
+        // Decompress
+        start = System.nanoTime();
+        ByteArrayInputStream bais = new ByteArrayInputStream(compressed);
+        try (BZip2CompressorInputStream bcis = new BZip2CompressorInputStream(bais)) {
+            byte[] decompressed = bcis.readAllBytes();
+            if (!Arrays.equals(data, decompressed)) {
+                throw new RuntimeException("Decompression verification failed");
+            }
+        }
+        result.decompressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;
+
+        long memAfter = getUsedMemory();
+        result.peakMemoryKb = Math.max(0, memAfter - memBefore);
+
+        double sizeMb = data.length / (1024.0 * 1024.0);
+        result.compressionSpeedMbps = sizeMb / (result.compressionTimeMs / 1000.0);
+        result.decompressionSpeedMbps = sizeMb / (result.decompressionTimeMs / 1000.0);
+
+        return result;
+    }
+
+    // --- LZMA ---
+    private static BenchmarkResult benchmarkLzma(byte[] data, int level) throws IOException {
+        BenchmarkResult result = new BenchmarkResult();
+        result.algorithm = "LZMA";
+        result.level = level;
+        result.originalSize = data.length;
+
+        long memBefore = getUsedMemory();
+
+        // Compress
+        long start = System.nanoTime();
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (LZMACompressorOutputStream lcos = new LZMACompressorOutputStream(baos)) {
+            lcos.write(data);
+        }
+        byte[] compressed = baos.toByteArray();
+        result.compressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;
+
+        result.compressedSize = compressed.length;
+        result.compressionRatio = (double) data.length / compressed.length;
+
+        // Decompress
+        start = System.nanoTime();
+        ByteArrayInputStream bais = new ByteArrayInputStream(compressed);
+        try (LZMACompressorInputStream lcis = new LZMACompressorInputStream(bais)) {
+            byte[] decompressed = lcis.readAllBytes();
+            if (!Arrays.equals(data, decompressed)) {
+                throw new RuntimeException("Decompression verification failed");
+            }
+        }
+        result.decompressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;
+
+        long memAfter = getUsedMemory();
+        result.peakMemoryKb = Math.max(0, memAfter - memBefore);
+
+        double sizeMb = data.length / (1024.0 * 1024.0);
+        result.compressionSpeedMbps = sizeMb / (result.compressionTimeMs / 1000.0);
+        result.decompressionSpeedMbps = sizeMb / (result.decompressionTimeMs / 1000.0);
+
+        return result;
+    }
+
+    // --- LZ4 ---
+    private static BenchmarkResult benchmarkLz4(byte[] data, int level) {
+        BenchmarkResult result = new BenchmarkResult();
+        result.algorithm = "LZ4";
+        result.level = level;
+        result.originalSize = data.length;
+
+        long memBefore = getUsedMemory();
+
+        LZ4Factory factory = LZ4Factory.fastestInstance();
+        LZ4Compressor compressor;
+        if (level <= 1) {
+            compressor = factory.fastCompressor();
+        } else {
+            compressor = factory.highCompressor(level);
+        }
+
+        // Compress
+        long start = System.nanoTime();
+        int maxCompressedLength = compressor.maxCompressedLength(data.length);
+        byte[] compressed = new byte[maxCompressedLength];
+        int compressedLength = compressor.compress(data, 0, data.length, compressed, 0, maxCompressedLength);
+        result.compressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;
+
+        result.compressedSize = compressedLength;
+        result.compressionRatio = (double) data.length / compressedLength;
+
+        // Decompress
+        start = System.nanoTime();
+        LZ4FastDecompressor decompressor = factory.fastDecompressor();
+        byte[] decompressed = new byte[data.length];
+        decompressor.decompress(compressed, 0, decompressed, 0, data.length);
+        result.decompressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;
+
+        if (!Arrays.equals(data, decompressed)) {
+            throw new RuntimeException("Decompression verification failed");
+        }
+
+        long memAfter = getUsedMemory();
+        result.peakMemoryKb = Math.max(0, memAfter - memBefore);
+
+        double sizeMb = data.length / (1024.0 * 1024.0);
+        result.compressionSpeedMbps = sizeMb / (result.compressionTimeMs / 1000.0);
+        result.decompressionSpeedMbps = sizeMb / (result.decompressionTimeMs / 1000.0);
+
+        return result;
+    }
+
+    // --- Zstandard ---
+    private static BenchmarkResult benchmarkZstd(byte[] data, int level) {
+        BenchmarkResult result = new BenchmarkResult();
+        result.algorithm = "Zstandard";
+        result.level = level;
+        result.originalSize = data.length;
+
+        long memBefore = getUsedMemory();
+
+        // Compress
+        long start = System.nanoTime();
+        byte[] compressed = Zstd.compress(data, level);
+        result.compressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;
+
+        result.compressedSize = compressed.length;
+        result.compressionRatio = (double) data.length / compressed.length;
+
+        // Decompress
+        start = System.nanoTime();
+        byte[] decompressed = Zstd.decompress(compressed, data.length);
+        result.decompressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;
+
+        if (!Arrays.equals(data, decompressed)) {
+            throw new RuntimeException("Decompression verification failed");
+        }
+
+        long memAfter = getUsedMemory();
+        result.peakMemoryKb = Math.max(0, memAfter - memBefore);
+
+        double sizeMb = data.length / (1024.0 * 1024.0);
+        result.compressionSpeedMbps = sizeMb / (result.compressionTimeMs / 1000.0);
+        result.decompressionSpeedMbps = sizeMb / (result.decompressionTimeMs / 1000.0);
+
+        return result;
+    }
+
+    private static void printHeader() {
+        String header = String.format("%-15s %5s %8s %10s %11s %12s %11s",
+                "Algorithm", "Level", "Ratio", "Comp(ms)", "Decomp(ms)", "Speed(MB/s)", "Memory(KB)");
+        String separator = "=".repeat(header.length());
+        System.out.println(separator);
+        System.out.println("COMPRESSION BENCHMARK SUMMARY");
+        System.out.println(separator);
+        System.out.println(header);
+        System.out.println("-".repeat(header.length()));
+    }
+
+    public static void main(String[] args) throws Exception {
+        System.out.println("============================================================");
+        System.out.println("  Data Compression Benchmark - Java");
+        System.out.println("  DEFLATE / bzip2 / LZMA / LZ4 / Zstandard");
+        System.out.println("============================================================");
+        System.out.println();
+
+        int dataSize = 2_000_000;
+        if (args.length > 0) {
+            dataSize = Integer.parseInt(args[0]);
+        }
+        int[] levels = {1, 3, 6, 9};
+        int iterations = 3;
+
+        System.out.printf("Generating %.1f MB of test data...%n", dataSize / (1024.0 * 1024.0));
+        byte[] testData = generateTestData(dataSize);
+        System.out.printf("Test data generated: %d bytes%n%n", testData.length);
+
+        List<BenchmarkResult> results = new ArrayList<>();
+
+        // Warm up JVM
+        System.out.println("Warming up JVM...");
+        benchmarkDeflate(testData, 1);
+        benchmarkLz4(testData, 1);
+        System.out.println();
+
+        // DEFLATE
+        System.out.println("--- Benchmarking DEFLATE ---");
+        for (int level : levels) {
+            BenchmarkResult best = null;
+            for (int i = 0; i < iterations; i++) {
+                BenchmarkResult r = benchmarkDeflate(testData, level);
+                if (best == null || r.compressionTimeMs < best.compressionTimeMs) best = r;
+            }
+            results.add(best);
+            System.out.printf("  Level %2d: ratio=%.2fx compress=%.1fms decompress=%.1fms%n",
+                    best.level, best.compressionRatio, best.compressionTimeMs, best.decompressionTimeMs);
+        }
+
+        // bzip2
+        System.out.println("\n--- Benchmarking bzip2 ---");
+        for (int level : levels) {
+            BenchmarkResult best = null;
+            for (int i = 0; i < iterations; i++) {
+                BenchmarkResult r = benchmarkBzip2(testData, level);
+                if (best == null || r.compressionTimeMs < best.compressionTimeMs) best = r;
+            }
+            results.add(best);
+            System.out.printf("  Level %2d: ratio=%.2fx compress=%.1fms decompress=%.1fms%n",
+                    best.level, best.compressionRatio, best.compressionTimeMs, best.decompressionTimeMs);
+        }
+
+        // LZMA
+        System.out.println("\n--- Benchmarking LZMA ---");
+        for (int level : new int[]{6}) { // LZMA doesn't expose level in commons compress
+            BenchmarkResult best = null;
+            for (int i = 0; i < iterations; i++) {
+                BenchmarkResult r = benchmarkLzma(testData, level);
+                if (best == null || r.compressionTimeMs < best.compressionTimeMs) best = r;
+            }
+            results.add(best);
+            System.out.printf("  Level %2d: ratio=%.2fx compress=%.1fms decompress=%.1fms%n",
+                    best.level, best.compressionRatio, best.compressionTimeMs, best.decompressionTimeMs);
+        }
+
+        // LZ4
+        System.out.println("\n--- Benchmarking LZ4 ---");
+        for (int level : levels) {
+            BenchmarkResult best = null;
+            for (int i = 0; i < iterations; i++) {
+                BenchmarkResult r = benchmarkLz4(testData, level);
+                if (best == null || r.compressionTimeMs < best.compressionTimeMs) best = r;
+            }
+            results.add(best);
+            System.out.printf("  Level %2d: ratio=%.2fx compress=%.1fms decompress=%.1fms%n",
+                    best.level, best.compressionRatio, best.compressionTimeMs, best.decompressionTimeMs);
+        }
+
+        // Zstandard
+        System.out.println("\n--- Benchmarking Zstandard ---");
+        for (int level : levels) {
+            BenchmarkResult best = null;
+            for (int i = 0; i < iterations; i++) {
+                BenchmarkResult r = benchmarkZstd(testData, level);
+                if (best == null || r.compressionTimeMs < best.compressionTimeMs) best = r;
+            }
+            results.add(best);
+            System.out.printf("  Level %2d: ratio=%.2fx compress=%.1fms decompress=%.1fms%n",
+                    best.level, best.compressionRatio, best.compressionTimeMs, best.decompressionTimeMs);
+        }
+
+        // Print summary
+        System.out.println();
+        printHeader();
+        for (BenchmarkResult r : results) {
+            System.out.println(r);
+        }
+
+        // Find best
+        BenchmarkResult bestRatio = results.stream()
+                .max(Comparator.comparingDouble(r -> r.compressionRatio)).orElse(null);
+        BenchmarkResult fastest = results.stream()
+                .min(Comparator.comparingDouble(r -> r.compressionTimeMs)).orElse(null);
+
+        if (bestRatio != null) {
+            System.out.printf("%nBest compression ratio: %s level %d (%.2fx)%n",
+                    bestRatio.algorithm, bestRatio.level, bestRatio.compressionRatio);
+        }
+        if (fastest != null) {
+            System.out.printf("Fastest compression: %s level %d (%.1fms)%n",
+                    fastest.algorithm, fastest.level, fastest.compressionTimeMs);
+        }
+    }
+}

Claude Code wrote this java project from the task below. It does not run 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 Java project for a clean Ubuntu 22.04 machine with only JDK 17+ installed. Include:
- Source code
- pom.xml with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[
  {
    "category": "misspecification",
    "rule": "signature.build_layout_mismatch",
    "source": "failure_signature",
    "excerpt": "error: no classes were compiled"
  },
  {
    "category": "misspecification",
    "rule": "diff.changes_existing_manifest_line",
    "source": "manifest_diff:pom.xml",
    "excerpt": "-        </plugins>\n+        <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-shade-plugin</artifactId><version>3.5.1</version><executions><execution><phase>package</phase><goals><goal>shade</goal></goals><configuration><transformers><transformer implementation=\"org.apache.maven.plugins.shade.resource.ManifestResourceTransformer\"><mainClass>CompressionBench</mainClass></transformer></transformers></configuration></execution></executions></plugin></plugins>"
  }
]

import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream;
import org.apache.commons.compress.compressors.bzip2.BZip2CompressorOutputStream;
import org.apache.commons.compress.compressors.lzma.LZMACompressorInputStream;
import org.apache.commons.compress.compressors.lzma.LZMACompressorOutputStream;
import org.apache.commons.compress.compressors.deflate.DeflateCompressorInputStream;
import org.apache.commons.compress.compressors.deflate.DeflateCompressorOutputStream;
import org.apache.commons.compress.compressors.deflate.DeflateParameters;
import net.jpountz.lz4.*;
import com.github.luben.zstd.Zstd;

import java.io.*;
import java.util.*;
import java.util.zip.*;

/**
 * Data Compression Benchmark - Java (Trial 1)
 *
 * Benchmarks DEFLATE, bzip2, LZMA, LZ4, and Zstandard comparing
 * compression ratio, speed, and memory usage across compression levels.
 */
public class CompressionBench {

    static class BenchmarkResult {
        String algorithm;
        int level;
        int originalSize;
        int compressedSize;
        double compressionRatio;
        double compressionTimeMs;
        double decompressionTimeMs;
        double compressionSpeedMbps;
        double decompressionSpeedMbps;
        long peakMemoryKb;

        @Override
        public String toString() {
            return String.format("%-15s %5d %8.2f %10.1f %11.1f %12.1f %11d",
                    algorithm, level, compressionRatio, compressionTimeMs,
                    decompressionTimeMs, compressionSpeedMbps, peakMemoryKb);
        }
    }

    private static byte[] generateTestData(int sizeBytes) {
        byte[] data = new byte[sizeBytes];
        Random random = new Random(42);

        // Text-like patterns
        String 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. ";
        byte[] textBytes = textBlock.getBytes();

        int offset = 0;
        // Fill first third with repeated text
        while (offset < sizeBytes / 3 && offset + textBytes.length <= sizeBytes) {
            System.arraycopy(textBytes, 0, data, offset, textBytes.length);
            offset += textBytes.length;
        }

        // Fill second third with repeated pattern
        byte[] pattern = {(byte) 0xAB, (byte) 0xCD, (byte) 0xEF, 0x01, 0x23, 0x45};
        while (offset < 2 * sizeBytes / 3 && offset + pattern.length <= sizeBytes) {
            System.arraycopy(pattern, 0, data, offset, pattern.length);
            offset += pattern.length;
        }

        // Fill rest with random data
        byte[] randomBytes = new byte[sizeBytes - offset];
        random.nextBytes(randomBytes);
        System.arraycopy(randomBytes, 0, data, offset, randomBytes.length);

        return data;
    }

    private static long getUsedMemory() {
        Runtime runtime = Runtime.getRuntime();
        runtime.gc();
        return (runtime.totalMemory() - runtime.freeMemory()) / 1024;
    }

    // --- DEFLATE ---
    private static BenchmarkResult benchmarkDeflate(byte[] data, int level) throws IOException {
        BenchmarkResult result = new BenchmarkResult();
        result.algorithm = "DEFLATE";
        result.level = level;
        result.originalSize = data.length;

        long memBefore = getUsedMemory();

        // Compress
        long start = System.nanoTime();
        DeflateParameters params = new DeflateParameters();
        params.setCompressionLevel(level);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (DeflateCompressorOutputStream dcos = new DeflateCompressorOutputStream(baos, params)) {
            dcos.write(data);
        }
        byte[] compressed = baos.toByteArray();
        result.compressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;

        result.compressedSize = compressed.length;
        result.compressionRatio = (double) data.length / compressed.length;

        // Decompress
        start = System.nanoTime();
        ByteArrayInputStream bais = new ByteArrayInputStream(compressed);
        try (DeflateCompressorInputStream dcis = new DeflateCompressorInputStream(bais)) {
            byte[] decompressed = dcis.readAllBytes();
            if (!Arrays.equals(data, decompressed)) {
                throw new RuntimeException("Decompression verification failed");
            }
        }
        result.decompressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;

        long memAfter = getUsedMemory();
        result.peakMemoryKb = Math.max(0, memAfter - memBefore);

        double sizeMb = data.length / (1024.0 * 1024.0);
        result.compressionSpeedMbps = sizeMb / (result.compressionTimeMs / 1000.0);
        result.decompressionSpeedMbps = sizeMb / (result.decompressionTimeMs / 1000.0);

        return result;
    }

    // --- bzip2 ---
    private static BenchmarkResult benchmarkBzip2(byte[] data, int level) throws IOException {
        BenchmarkResult result = new BenchmarkResult();
        result.algorithm = "bzip2";
        result.level = level;
        result.originalSize = data.length;

        long memBefore = getUsedMemory();

        // Compress
        long start = System.nanoTime();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (BZip2CompressorOutputStream bcos = new BZip2CompressorOutputStream(baos, level)) {
            bcos.write(data);
        }
        byte[] compressed = baos.toByteArray();
        result.compressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;

        result.compressedSize = compressed.length;
        result.compressionRatio = (double) data.length / compressed.length;

        // Decompress
        start = System.nanoTime();
        ByteArrayInputStream bais = new ByteArrayInputStream(compressed);
        try (BZip2CompressorInputStream bcis = new BZip2CompressorInputStream(bais)) {
            byte[] decompressed = bcis.readAllBytes();
            if (!Arrays.equals(data, decompressed)) {
                throw new RuntimeException("Decompression verification failed");
            }
        }
        result.decompressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;

        long memAfter = getUsedMemory();
        result.peakMemoryKb = Math.max(0, memAfter - memBefore);

        double sizeMb = data.length / (1024.0 * 1024.0);
        result.compressionSpeedMbps = sizeMb / (result.compressionTimeMs / 1000.0);
        result.decompressionSpeedMbps = sizeMb / (result.decompressionTimeMs / 1000.0);

        return result;
    }

    // --- LZMA ---
    private static BenchmarkResult benchmarkLzma(byte[] data, int level) throws IOException {
        BenchmarkResult result = new BenchmarkResult();
        result.algorithm = "LZMA";
        result.level = level;
        result.originalSize = data.length;

        long memBefore = getUsedMemory();

        // Compress
        long start = System.nanoTime();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (LZMACompressorOutputStream lcos = new LZMACompressorOutputStream(baos)) {
            lcos.write(data);
        }
        byte[] compressed = baos.toByteArray();
        result.compressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;

        result.compressedSize = compressed.length;
        result.compressionRatio = (double) data.length / compressed.length;

        // Decompress
        start = System.nanoTime();
        ByteArrayInputStream bais = new ByteArrayInputStream(compressed);
        try (LZMACompressorInputStream lcis = new LZMACompressorInputStream(bais)) {
            byte[] decompressed = lcis.readAllBytes();
            if (!Arrays.equals(data, decompressed)) {
                throw new RuntimeException("Decompression verification failed");
            }
        }
        result.decompressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;

        long memAfter = getUsedMemory();
        result.peakMemoryKb = Math.max(0, memAfter - memBefore);

        double sizeMb = data.length / (1024.0 * 1024.0);
        result.compressionSpeedMbps = sizeMb / (result.compressionTimeMs / 1000.0);
        result.decompressionSpeedMbps = sizeMb / (result.decompressionTimeMs / 1000.0);

        return result;
    }

    // --- LZ4 ---
    private static BenchmarkResult benchmarkLz4(byte[] data, int level) {
        BenchmarkResult result = new BenchmarkResult();
        result.algorithm = "LZ4";
        result.level = level;
        result.originalSize = data.length;

        long memBefore = getUsedMemory();

        LZ4Factory factory = LZ4Factory.fastestInstance();
        LZ4Compressor compressor;
        if (level <= 1) {
            compressor = factory.fastCompressor();
        } else {
            compressor = factory.highCompressor(level);
        }

        // Compress
        long start = System.nanoTime();
        int maxCompressedLength = compressor.maxCompressedLength(data.length);
        byte[] compressed = new byte[maxCompressedLength];
        int compressedLength = compressor.compress(data, 0, data.length, compressed, 0, maxCompressedLength);
        result.compressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;

        result.compressedSize = compressedLength;
        result.compressionRatio = (double) data.length / compressedLength;

        // Decompress
        start = System.nanoTime();
        LZ4FastDecompressor decompressor = factory.fastDecompressor();
        byte[] decompressed = new byte[data.length];
        decompressor.decompress(compressed, 0, decompressed, 0, data.length);
        result.decompressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;

        if (!Arrays.equals(data, decompressed)) {
            throw new RuntimeException("Decompression verification failed");
        }

        long memAfter = getUsedMemory();
        result.peakMemoryKb = Math.max(0, memAfter - memBefore);

        double sizeMb = data.length / (1024.0 * 1024.0);
        result.compressionSpeedMbps = sizeMb / (result.compressionTimeMs / 1000.0);
        result.decompressionSpeedMbps = sizeMb / (result.decompressionTimeMs / 1000.0);

        return result;
    }

    // --- Zstandard ---
    private static BenchmarkResult benchmarkZstd(byte[] data, int level) {
        BenchmarkResult result = new BenchmarkResult();
        result.algorithm = "Zstandard";
        result.level = level;
        result.originalSize = data.length;

        long memBefore = getUsedMemory();

        // Compress
        long start = System.nanoTime();
        byte[] compressed = Zstd.compress(data, level);
        result.compressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;

        result.compressedSize = compressed.length;
        result.compressionRatio = (double) data.length / compressed.length;

        // Decompress
        start = System.nanoTime();
        byte[] decompressed = Zstd.decompress(compressed, data.length);
        result.decompressionTimeMs = (System.nanoTime() - start) / 1_000_000.0;

        if (!Arrays.equals(data, decompressed)) {
            throw new RuntimeException("Decompression verification failed");
        }

        long memAfter = getUsedMemory();
        result.peakMemoryKb = Math.max(0, memAfter - memBefore);

        double sizeMb = data.length / (1024.0 * 1024.0);
        result.compressionSpeedMbps = sizeMb / (result.compressionTimeMs / 1000.0);
        result.decompressionSpeedMbps = sizeMb / (result.decompressionTimeMs / 1000.0);

        return result;
    }

    private static void printHeader() {
        String header = String.format("%-15s %5s %8s %10s %11s %12s %11s",
                "Algorithm", "Level", "Ratio", "Comp(ms)", "Decomp(ms)", "Speed(MB/s)", "Memory(KB)");
        String separator = "=".repeat(header.length());
        System.out.println(separator);
        System.out.println("COMPRESSION BENCHMARK SUMMARY");
        System.out.println(separator);
        System.out.println(header);
        System.out.println("-".repeat(header.length()));
    }

    public static void main(String[] args) throws Exception {
        System.out.println("============================================================");
        System.out.println("  Data Compression Benchmark - Java");
        System.out.println("  DEFLATE / bzip2 / LZMA / LZ4 / Zstandard");
        System.out.println("============================================================");
        System.out.println();

        int dataSize = 2_000_000;
        if (args.length > 0) {
            dataSize = Integer.parseInt(args[0]);
        }
        int[] levels = {1, 3, 6, 9};
        int iterations = 3;

        System.out.printf("Generating %.1f MB of test data...%n", dataSize / (1024.0 * 1024.0));
        byte[] testData = generateTestData(dataSize);
        System.out.printf("Test data generated: %d bytes%n%n", testData.length);

        List<BenchmarkResult> results = new ArrayList<>();

        // Warm up JVM
        System.out.println("Warming up JVM...");
        benchmarkDeflate(testData, 1);
        benchmarkLz4(testData, 1);
        System.out.println();

        // DEFLATE
        System.out.println("--- Benchmarking DEFLATE ---");
        for (int level : levels) {
            BenchmarkResult best = null;
            for (int i = 0; i < iterations; i++) {
                BenchmarkResult r = benchmarkDeflate(testData, level);
                if (best == null || r.compressionTimeMs < best.compressionTimeMs) best = r;
            }
            results.add(best);
            System.out.printf("  Level %2d: ratio=%.2fx compress=%.1fms decompress=%.1fms%n",
                    best.level, best.compressionRatio, best.compressionTimeMs, best.decompressionTimeMs);
        }

        // bzip2
        System.out.println("\n--- Benchmarking bzip2 ---");
        for (int level : levels) {
            BenchmarkResult best = null;
            for (int i = 0; i < iterations; i++) {
                BenchmarkResult r = benchmarkBzip2(testData, level);
                if (best == null || r.compressionTimeMs < best.compressionTimeMs) best = r;
            }
            results.add(best);
            System.out.printf("  Level %2d: ratio=%.2fx compress=%.1fms decompress=%.1fms%n",
                    best.level, best.compressionRatio, best.compressionTimeMs, best.decompressionTimeMs);
        }

        // LZMA
        System.out.println("\n--- Benchmarking LZMA ---");
        for (int level : new int[]{6}) { // LZMA doesn't expose level in commons compress
            BenchmarkResult best = null;
            for (int i = 0; i < iterations; i++) {
                BenchmarkResult r = benchmarkLzma(testData, level);
                if (best == null || r.compressionTimeMs < best.compressionTimeMs) best = r;
            }
            results.add(best);
            System.out.printf("  Level %2d: ratio=%.2fx compress=%.1fms decompress=%.1fms%n",
                    best.level, best.compressionRatio, best.compressionTimeMs, best.decompressionTimeMs);
        }

        // LZ4
        System.out.println("\n--- Benchmarking LZ4 ---");
        for (int level : levels) {
            BenchmarkResult best = null;
            for (int i = 0; i < iterations; i++) {
                BenchmarkResult r = benchmarkLz4(testData, level);
                if (best == null || r.compressionTimeMs < best.compressionTimeMs) best = r;
            }
            results.add(best);
            System.out.printf("  Level %2d: ratio=%.2fx compress=%.1fms decompress=%.1fms%n",
                    best.level, best.compressionRatio, best.compressionTimeMs, best.decompressionTimeMs);
        }

        // Zstandard
        System.out.println("\n--- Benchmarking Zstandard ---");
        for (int level : levels) {
            BenchmarkResult best = null;
            for (int i = 0; i < iterations; i++) {
                BenchmarkResult r = benchmarkZstd(testData, level);
                if (best == null || r.compressionTimeMs < best.compressionTimeMs) best = r;
            }
            results.add(best);
            System.out.printf("  Level %2d: ratio=%.2fx compress=%.1fms decompress=%.1fms%n",
                    best.level, best.compressionRatio, best.compressionTimeMs, best.decompressionTimeMs);
        }

        // Print summary
        System.out.println();
        printHeader();
        for (BenchmarkResult r : results) {
            System.out.println(r);
        }

        // Find best
        BenchmarkResult bestRatio = results.stream()
                .max(Comparator.comparingDouble(r -> r.compressionRatio)).orElse(null);
        BenchmarkResult fastest = results.stream()
                .min(Comparator.comparingDouble(r -> r.compressionTimeMs)).orElse(null);

        if (bestRatio != null) {
            System.out.printf("%nBest compression ratio: %s level %d (%.2fx)%n",
                    bestRatio.algorithm, bestRatio.level, bestRatio.compressionRatio);
        }
        if (fastest != null) {
            System.out.printf("Fastest compression: %s level %d (%.1fms)%n",
                    fastest.algorithm, fastest.level, fastest.compressionTimeMs);
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>compression-benchmark</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>Data Compression Benchmark</name>
    <description>Benchmarks compression algorithms comparing ratio, speed, and memory</description>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-compress</artifactId>
            <version>1.25.0</version>
        </dependency>
        <dependency>
            <groupId>org.lz4</groupId>
            <artifactId>lz4-java</artifactId>
            <version>1.8.0</version>
        </dependency>
        <dependency>
            <groupId>com.github.luben</groupId>
            <artifactId>zstd-jni</artifactId>
            <version>1.5.5-11</version>
        </dependency>
        <dependency>
            <groupId>org.tukaani</groupId>
            <artifactId>xz</artifactId>
            <version>1.9</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>CompressionBench</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

# Data Compression Benchmark - Java (Trial 1)

## Description

Benchmarks DEFLATE, bzip2, LZMA, LZ4, and Zstandard compression algorithms. Compares compression ratio, speed, and memory usage across multiple compression levels. Generates synthetic test data with mixed patterns (text, repetitive, random) for realistic benchmarking.

## Dependencies

- **commons-compress** (1.25.0) - DEFLATE, bzip2, and LZMA compression implementations
- **lz4-java** (1.8.0) - LZ4 fast compression algorithm
- **zstd-jni** (1.5.5-11) - Zstandard compression via JNI bindings
- **xz** (1.9) - XZ/LZMA support for commons-compress

## Build

```bash
mvn clean compile
mvn package
```

## Run

```bash
# Default (2 MB test data)
java -cp target/compression-benchmark-1.0-SNAPSHOT.jar CompressionBench

# Custom data size (bytes)
java -cp target/compression-benchmark-1.0-SNAPSHOT.jar CompressionBench 5000000
```

## 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)