Compression Benchmark

The Compression benchmark evaluates the performance of modern lossless compression algorithms using realistic datasets that represent different classes of production data.

Lossless compression is an essential component of contemporary software systems. Storage engines, databases, distributed file systems, backup platforms, package managers, container registries, messaging systems, and software distribution services all rely on compression to reduce storage requirements and network bandwidth while preserving complete data integrity.

Unlike traditional compression benchmarks that repeatedly compress a single file, the Scalionix Compression benchmark evaluates multiple data characteristics using deterministic datasets specifically designed to represent real-world software workloads.

By combining different compression algorithms, dataset sizes, entropy distributions, and execution scenarios, the benchmark provides a comprehensive evaluation of practical compression performance.

Objectives

The Compression benchmark has five primary objectives.

• Measure compression throughput.
• Measure decompression throughput.
• Evaluate different compression algorithms.
• Measure behavior across different dataset characteristics.
• Evaluate scalability across multiple execution workers.

The benchmark intentionally focuses on production-oriented compression workloads rather than artificial compression ratios.

Why Compression?

Modern software compresses data continuously.

Typical examples include:

• Database storage engines
• Backup software
• Software repositories
• Artifact registries
• Object storage
• Distributed file systems
• Log aggregation
• Telemetry systems
• Message brokers
• Software package managers
• Cloud storage

Because compression executes in numerous infrastructure components, measuring compression throughput provides valuable insight into sustained processor performance under realistic workloads.

Benchmark Philosophy

Compression performance depends heavily on the characteristics of the processed data.

Measuring only one input dataset would therefore provide a distorted view of practical performance.

Instead, the benchmark evaluates multiple deterministic dataset classes representing common production scenarios.

Each workload executes complete compression pipelines including:

            Dataset preparation
                    │
                    ▼
               Compression
                    │
                    ▼
          Optional decompression
                    │
                    ▼
           Output verification
                    │
                    ▼
          Performance measurement

This approach measures complete software behavior rather than isolated library functions.

Typical Compression Pipeline

                 Dataset
                    │
                    ▼
               Compression
                    │
                    ▼
           Compressed Output
                    │
                    ▼
              Decompression
                    │
                    ▼
              Verification
                    │
                    ▼
          Throughput Measurement

Supported Algorithms

The benchmark currently evaluates modern lossless compression algorithms commonly used by production software.

Algorithms have been selected because they represent different design goals.

Examples include:

• Maximum throughput
• Balanced compression
• High compression ratio
• General-purpose compression

Each algorithm executes identical benchmark datasets, allowing direct comparison of implementation efficiency under equivalent workloads.

Compression Scenarios

Each compression algorithm is evaluated using independent execution scenarios.

Compression

Measures raw compression throughput.

Scenario

compression.<algorithm>.compress

Decompression

Measures decompression throughput.

Scenario

compression.<algorithm>.decompress

Round Trip

Measures complete application workflow.

Pipeline

Generate dataset
        │
        ▼
    Compress
        │
        ▼
    Decompress
        │
        ▼
     Verify
        │
        ▼
     Measure

Scenario

compression.<algorithm>.round_trip

Round Trip workloads most closely represent practical application behavior because both compression and decompression contribute to measured performance.

Dataset Types

One of the defining characteristics of the Compression benchmark is the use of multiple deterministic dataset classes.

Each dataset represents a different entropy profile commonly encountered in production environments.

Structured JSON

Represents highly repetitive structured documents similar to REST API payloads, configuration files, telemetry data, and monitoring systems.

Typical characteristics include:

• High repetition
• Predictable field names
• Nested object hierarchies
• Excellent compressibility

Natural Text

Represents human-readable documents.

Examples include:

• Documentation
• Log files
• Source code
• Configuration files
• Documentation repositories

Natural language typically compresses well while exhibiting more variation than structured JSON.

Structured Binary

Represents deterministic binary formats.

Examples include:

• Serialized objects
• Binary protocols
• Executable metadata
• Compact storage formats

Binary datasets generally contain less repetition than structured text and therefore provide different compression behavior.

Mixed Entropy

Represents heterogeneous production workloads.

This dataset intentionally combines:

• Structured data
• Textual content
• Binary sections
• High-entropy regions

Mixed entropy datasets most closely resemble practical storage workloads encountered by backup software, archives, container images, and software repositories.

Why Multiple Dataset Types?

Compression algorithms perform differently depending on input characteristics.

An algorithm that performs exceptionally well on structured JSON may perform significantly worse on high-entropy binary data.

Using multiple deterministic datasets prevents benchmark results from being overly optimized toward one particular compression pattern.

This design provides a much more representative evaluation of practical compression performance.

Dataset Sizes

Compression workloads execute multiple deterministic dataset sizes.

Smaller datasets emphasize algorithm initialization overhead.

Larger datasets emphasize sustained throughput, memory hierarchy efficiency, and streaming behavior.

Dataset sizes remain identical across every supported platform.

Worker Configuration

Compression workloads evaluate scalability using multiple worker configurations.

Each worker compresses an independent dataset.

Workers never share compression state.

This execution model closely resembles production software such as backup systems, package builders, artifact repositories, and parallel archive generation.

Representative worker configurations include:

[ 1 / 2 / 4 / 6 / 8 / 12 / 16 / 20 / 24 / 32 ]

The exact worker matrix depends on the detected hardware configuration.

Verification

Every compression workload performs strict correctness verification.

Verification includes:

• Successful compression
• Successful decompression
• Output integrity
• Byte-for-byte equality verification

Benchmark execution is accepted only when decompressed output exactly matches the original dataset.

Verification failures invalidate benchmark results regardless of measured throughput.

Measured Metrics

Primary benchmark metrics include:

• Compressed bytes
• Original bytes
• Execution duration
• Throughput
• Worker configuration
• Compression ratio

Although compression ratio is recorded for diagnostic purposes, benchmark scoring is based exclusively on processing throughput.

This decision ensures that benchmark scores represent computational efficiency rather than algorithm-specific compression characteristics.

Score Calculation

Compression workloads fully participate in the Compute Score.

Each workload contributes:

Single-thread Score

Measures processor efficiency using one execution worker.

Multi-thread Score

Measures maximum sustained throughput.

Scaling Score

Measures parallel scalability across worker configurations.

Scenario scores are aggregated into the Compression category score.

Hardware Characteristics Measured

Compression workloads exercise multiple hardware subsystems simultaneously.

Processor Architecture

Compression algorithms execute large numbers of arithmetic and logical operations.

Cache Hierarchy

Dictionary-based compression heavily benefits from efficient cache utilization.

Memory Bandwidth

Streaming datasets require sustained memory throughput.

Branch Prediction

Compression algorithms frequently contain complex decision trees whose performance depends on processor branch prediction efficiency.

Parallel Execution

Independent compression tasks scale efficiently across processor cores.

As a result, the Compression benchmark reflects the combined efficiency of processor architecture, cache hierarchy, memory subsystem, compiler optimizations, and runtime implementation.

Practical Interpretation

High Compression scores generally indicate:

• Efficient processor architecture
• Strong memory subsystem
• Excellent cache utilization
• Efficient branch prediction
• Good multi-core scalability

Systems with strong compression performance typically perform well in storage infrastructure, backup platforms, software distribution systems, and archive generation workloads.

Design Summary

The Compression benchmark evaluates complete lossless compression workflows using deterministic datasets representative of practical software engineering environments.

By combining multiple algorithms, dataset characteristics, execution scenarios, and worker configurations, the benchmark provides a realistic evaluation of compression performance across a broad range of production workloads.

Unlike synthetic compression benchmarks, the resulting category score reflects practical computational efficiency rather than isolated algorithm behavior.