Hashing Benchmark

The Hashing benchmark evaluates the throughput of modern cryptographic hash algorithms using realistic data processing workloads.

Cryptographic hashing represents one of the most fundamental building blocks of modern software systems. Hash functions are extensively used for data integrity verification, content addressing, software distribution, version control systems, databases, backup systems, deduplication engines, blockchain technologies, authentication mechanisms, and countless backend services.

Unlike encryption algorithms, cryptographic hash functions are designed to produce deterministic fixed-size digests that uniquely represent arbitrary amounts of input data.

The benchmark measures the ability of a system to process large volumes of data using production-grade hashing algorithms under realistic execution conditions.

Objectives

The Hashing benchmark has four primary objectives.

• Measure sequential hashing throughput.
• Compare algorithm implementation efficiency.
• Evaluate memory subsystem performance during streaming workloads.
• Measure scalability across multiple execution workers.

The benchmark intentionally focuses on sustained throughput rather than latency, as throughput represents the dominant performance characteristic in most production hashing workloads.

Why Hashing?

Hashing operations are executed continuously in modern computing environments.

Typical applications include:

• File integrity verification
• Package managers
• Software repositories
• Git object storage
• Artifact distribution
• Backup verification
• Object storage
• Container registries
• Deduplication systems
• Content-addressable storage
• Digital signatures
• Password processing

Large-scale backend infrastructure frequently spends significant CPU time computing cryptographic hashes.

Consequently, hashing throughput serves as an excellent indicator of sustained computational performance.

Benchmark Philosophy

The benchmark evaluates complete hashing operations rather than isolated compression functions.

Every workload performs continuous processing of deterministic datasets while measuring sustained throughput.

The benchmark intentionally avoids:

• Tiny synthetic buffers
• Repeated hashing of identical cache-resident data
• Unrealistic benchmark loops

Instead, workloads process datasets large enough to exceed processor cache capacity whenever appropriate.

This produces measurements representative of practical software systems.

Supported Algorithms

The benchmark currently evaluates multiple production-grade cryptographic hash functions.

BLAKE3

BLAKE3 is a modern cryptographic hash algorithm optimized for extremely high throughput and efficient parallel execution.

Its tree-based design allows exceptional scalability on multi-core processors.

Scenarios

hash.blake3.chunked
hash.blake3.one_shot

SHA-256

SHA-256 remains one of the most widely deployed cryptographic hash algorithms in modern software infrastructure.

It is commonly used by:

• TLS
• Software distribution
• Package verification
• Container images
• Blockchain systems

Scenarios

hash.sha256.chunked
hash.sha256.one_shot

SHA-512

SHA-512 belongs to the SHA-2 family and frequently achieves higher throughput than SHA-256 on modern 64-bit processors.

It is commonly used in:

• Backup systems
• Large-scale storage
• Authentication
• Enterprise software

Scenarios

hash.sha512.chunked
hash.sha512.one_shot

Chunked vs One-Shot Processing

The benchmark intentionally measures two different processing models.

One-Shot

Entire datasets are hashed using a single hashing operation.

This represents workloads where complete data is already available in memory.

Typical examples include:

• Memory buffers
• Download verification
• Configuration validation
• API payloads

Chunked

Datasets are processed incrementally using multiple update operations.

This represents streaming workloads commonly encountered in production systems.

Examples include:

• File processing
• Network streams
• Backup software
• Archive creation
• Object storage

Evaluating both execution models provides a more complete representation of practical hashing performance.

Dataset Sizes

Multiple dataset sizes are evaluated.

Small datasets emphasize algorithm overhead.

Large datasets emphasize sustained throughput, cache hierarchy, and memory bandwidth.

Dataset sizes remain deterministic across every supported operating system.

Worker Configuration

Hashing workloads evaluate parallel scalability using multiple worker configurations.

Each worker processes an independent dataset.

No synchronization occurs between workers during hashing.

This execution model measures pure computational scalability.

Representative worker configurations include:

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

The actual execution matrix depends on the detected hardware.

Verification

Every hashing workload verifies digest correctness.

Verification ensures that every produced digest exactly matches the expected reference value.

Benchmark results are accepted only when hash verification succeeds.

Incorrect digests immediately invalidate benchmark execution.

This guarantees that benchmark throughput always represents successful cryptographic computation.

Measured Metrics

Primary benchmark metrics include:

• Processed bytes
• Execution duration
• Throughput
• Worker configuration
• Iteration timing

The scoring adapter converts measured throughput into normalized bytes processed per second.

Score Calculation

Hashing workloads fully participate in the compute scoring model.

Each workload contributes:

Single-thread Score

Measures processor efficiency using one execution worker.

Multi-thread Score

Measures maximum throughput achieved across all worker configurations.

Scaling Score

Measures parallel scalability relative to the single-thread execution.

Scenario scores are aggregated into the Hashing category score.

Hardware Characteristics Measured

Although hashing is primarily CPU intensive, measured performance depends on multiple hardware characteristics.

Processor Architecture

Instruction throughput directly affects hashing performance.

Cache Hierarchy

Efficient cache utilization improves sustained throughput.

Memory Bandwidth

Streaming workloads frequently become memory bandwidth limited.

SIMD Capabilities

Modern hash implementations leverage SIMD instructions extensively.

Parallel Execution

Tree-based algorithms such as BLAKE3 demonstrate exceptional multi-core scalability.

Consequently, hashing performance often reflects the combined efficiency of the processor, cache subsystem, compiler optimizations, and runtime implementation.

Practical Interpretation

High Hashing benchmark scores generally indicate:

• Efficient processor architecture
• Strong SIMD performance
• High sustained memory bandwidth
• Efficient compiler optimizations
• Excellent multi-core scalability

Systems achieving strong hashing performance typically perform well in many streaming data processing workloads encountered by backend infrastructure and software development tools.

Design Summary

The Hashing benchmark evaluates production-grade cryptographic hashing using realistic streaming workloads rather than synthetic algorithm microbenchmarks.

By measuring multiple algorithms, execution models, dataset sizes, and worker configurations, the benchmark provides a comprehensive evaluation of sustained hashing performance representative of modern software engineering environments.

The resulting category score reflects the practical computational efficiency of cryptographic hash processing across a broad range of real-world applications.