Add Rust compression/decompression benchmark

Adds a benchmark testing compression and decompression performance for
two popular algorithms: Gzip (deflate) and Brotli. The benchmark
processes ~1MB of mixed data (repeated patterns, structured data,
natural text, and random bytes).

Tests both compression and decompression in a single benchmark cycle,
with verification that decompressed data matches the original.

Author: posborne

benchmarks/rust-compression/.gitignore

@@ -0,0 +1 @@
+benchmark.wasm

benchmarks/rust-compression/Dockerfile

@@ -0,0 +1 @@
+../Dockerfile.rust

benchmarks/rust-compression/README.md

@@ -0,0 +1,44 @@
+# Rust Compression/Decompression Benchmark
+
+This benchmark tests compression and decompression performance for multiple algorithms commonly used in web and systems programming.
+
+## What it tests
+
+The benchmark performs compression and decompression using two algorithms:
+
+1. **Gzip (Deflate)** - via `flate2` with pure Rust backend
+   - Classic compression used in HTTP, gzip files, PNG images
+   - Good balance of speed and compression ratio
+   
+2. **Brotli** - via `brotli` crate
+   - Modern compression by Google, optimized for web content
+   - Better compression ratios than gzip, especially for text/HTML/JSON
+
+Each algorithm:
+- Compresses the input data
+- Decompresses it back
+- Verifies the output matches the original
+
+## Input Data
+
+The `default.input` file (~1 MB) contains a mix of:
+- Repeated patterns (compress very well)
+- Structured JSON-like data (compresses well)
+- Natural language text (compresses moderately)
+- Random bytes (doesn't compress well)
+
+This mix provides a realistic workload showing how algorithms perform on different data types.
+
+## Implementation
+
+Uses:
+- `flate2` 1.0 with pure Rust backend for WASM compatibility
+- `brotli` 7.0 for Brotli compression
+
+## Performance Notes
+
+Expected compression ratios on the test data:
+- Gzip: ~24% (4:1 compression)
+- Brotli: ~7% (14:1 compression)
+
+Brotli achieves better compression but typically requires more CPU time.

benchmarks/rust-compression/benchmark.stderr.expected

@@ -0,0 +1,3 @@
+[rust-compression] original size: 1731587 bytes
+[rust-compression] gzip compressed: 192012 bytes (11.1%)
+[rust-compression] brotli compressed: 167110 bytes (9.7%)

benchmarks/rust-compression/benchmark.stdout.expected

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""Generate input data for compression benchmark.
+
+Creates a file with mixed content that compresses reasonably well:
+- Repeated text patterns
+- JSON-like structured data
+- Some random data
+"""
+
+import random
+import string
+
+
+def generate_text_block(size):
+    """Generate semi-random text that compresses well."""
+    words = [
+        "the",
+        "quick",
+        "brown",
+        "fox",
+        "jumps",
+        "over",
+        "lazy",
+        "dog",
+        "hello",
+        "world",
+        "test",
+        "data",
+        "benchmark",
+        "compression",
+        "algorithm",
+        "performance",
+        "measure",
+        "speed",
+        "quality",
+    ]
+
+    text = []
+    while len(" ".join(text)) < size:
+        text.append(random.choice(words))
+
+    return " ".join(text)[:size]
+
+
+def generate_json_like_data():
+    """Generate JSON-like structured data."""
+    data = []
+    for i in range(1000):
+        record = f'{{"id": {i}, "name": "user_{i}", "email": "user{i}@example.com", '
+        record += f'"status": "active", "score": {random.randint(0, 100)}, '
+        record += f'"tags": ["tag1", "tag2", "tag3"]}}\n'
+        data.append(record)
+    return "".join(data)
+
+
+def generate_repeated_pattern():
+    """Generate data with lots of repetition (compresses very well)."""
+    pattern = "ABCDEFGHIJ" * 100
+    return (pattern + "\n") * 1000
+
+
+def main():
+    with open("default.input", "wb") as f:
+        # Mix of different data types for realistic compression testing
+
+        # 1. Repeated patterns (compress very well)
+        f.write(generate_repeated_pattern().encode("utf-8"))
+
+        # 2. Structured data (compresses well)
+        f.write(generate_json_like_data().encode("utf-8"))
+
+        # 3. Natural language-like text (compresses moderately)
+        f.write(generate_text_block(500000).encode("utf-8"))
+
+        # 4. Some random data (doesn't compress well)
+        random_bytes = bytes(random.randint(0, 255) for _ in range(100000))
+        f.write(random_bytes)
+
+    import os
+
+    size = os.path.getsize("default.input")
+    print(f"Generated input file: {size} bytes ({size / 1024 / 1024:.2f} MB)")
+
+
+if __name__ == "__main__":
+    main()

benchmarks/rust-compression/default.input

@@ -0,0 +1 @@
+target

benchmarks/rust-compression/generate_input.py

@@ -0,0 +1,11 @@
+[package]
+name = "benchmark"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+flate2 = { version = "1.0", default-features = false, features = ["rust_backend"] }
+brotli = "7.0"
+sightglass-api = "0.1"
+
+[workspace]