Benchmark: Compare hash functions

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

const testData = new Uint8Array(216);
crypto.getRandomValues(testData);

async function webCryptoHash(data) {
    const hash = await crypto.subtle.digest('SHA-1', data);
    return new Uint8Array(hash);
}

// 2. FNV-1a 32-bit (extremely fast, non-cryptographic)
function fnv1a32(data) {
    let hash = 0x811c9dc5;
    for (let i = 0; i < data.length; i++) {
        hash ^= data[i];
        hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
    }
    return hash >>> 0;
}

// 3. xxHash-like implementation (fast, non-cryptographic)
function xxHash(data) {
    const PRIME32_1 = 0x9e3779b1;
    const PRIME32_2 = 0x85ebca77;
    const PRIME32_3 = 0xc2b2ae3d;
    
    let h = 0;
    
    for (let i = 0; i < data.length; i += 4) {
        const chunk = (data[i] || 0) |
                     ((data[i + 1] || 0) << 8) |
                     ((data[i + 2] || 0) << 16) |
                     ((data[i + 3] || 0) << 24);
        
        h = Math.imul(h + Math.imul(chunk, PRIME32_1), PRIME32_2);
    }
    
    return h >>> 0;
}

// 4. MurmurHash3-like implementation (fast, non-cryptographic)
function murmur3(data) {
    const c1 = 0xcc9e2d51;
    const c2 = 0x1b873593;
    let h1 = 0;

    for (let i = 0; i < data.length; i += 4) {
        let k1 = (data[i] || 0) |
                 ((data[i + 1] || 0) << 8) |
                 ((data[i + 2] || 0) << 16) |
                 ((data[i + 3] || 0) << 24);

        k1 = Math.imul(k1, c1);
        k1 = (k1 << 15) | (k1 >>> 17);
        k1 = Math.imul(k1, c2);

        h1 ^= k1;
        h1 = (h1 << 13) | (h1 >>> 19);
        h1 = Math.imul(h1, 5) + 0xe6546b64;
    }

    h1 ^= data.length;
    h1 ^= h1 >>> 16;
    h1 = Math.imul(h1, 0x85ebca6b);
    h1 ^= h1 >>> 13;
    h1 = Math.imul(h1, 0xc2b2ae35);
    h1 ^= h1 >>> 16;

    return h1 >>> 0;
}

window.testData = testData;
window.webCryptoHash = webCryptoHash;
window.fnv1a32 = fnv1a32;
window.xxHash = xxHash;
window.murmur3 = murmur3;

Tests:

webCryptoHash [Async/Deferred]
webCryptoHash(testData).then(() => { deferred.resolve(); });
fnv1a32
fnv1a32(testData);
xxHash
xxHash(testData);
murmur3
murmur3(testData);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
webCryptoHash
fnv1a32
xxHash
murmur3

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 months ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36 OPR/87.0.0.0

Browser/OS: Opera 87 on Android

View result in a separate tab

Test name	Executions per second
webCryptoHash	4968.6 Ops/sec
fnv1a32	195743.7 Ops/sec
xxHash	2219881.0 Ops/sec
murmur3	759959.2 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):

LLMs can make mistakes. Check important info.

The benchmark on MeasureThat.net titled "Compare hash functions" evaluates the performance of four different hashing functions, implemented in JavaScript. Each of these functions is designed to take in a chunk of data and compute a hash value, though they differ in their algorithms and intended use cases.

### Benchmark Overview

#### Hash Functions Compared:

1. **webCryptoHash**:
   - **Implementation**: Uses the Web Crypto API to perform a SHA-1 hashing operation.
   - **Pros**: 
     - Cryptographic security: SHA-1 is a well-known secure hash algorithm.
     - Built-in: Utilizes browser APIs that are likely optimized for performance.
   - **Cons**:
     - Performance: Cryptographic hash functions like SHA-1 are generally slower than non-cryptographic ones.
     - Compatibility: Some older browsers may not support the Web Crypto API.
   
2. **fnv1a32**:
   - **Implementation**: A non-cryptographic hash function, FNV-1a (Fowler–Noll–Vo hash function).
   - **Pros**: 
     - Fast performance, optimized for speed.
     - Lightweight: Minimal computational overhead makes it suitable for large data sets or use cases needing quick hashing without security requirements.
   - **Cons**:
     - Non-cryptographic: Not suitable for security-sensitive applications since it’s vulnerable to hash collisions.

3. **xxHash**:
   - **Implementation**: A fast, non-cryptographic hashing algorithm designed to achieve high speeds.
   - **Pros**: 
     - Extremely fast: Known to outperform many other hashing algorithms in terms of speed.
     - Collision-resistant for many practical applications: Provides a reasonably good distribution of hash values.
   - **Cons**:
     - Not suitable for cryptographic use: Like FNV-1a, it doesn't provide security against malicious capabilities.
   
4. **murmur3**:
   - **Implementation**: A non-cryptographic hash function (specifically, MurmurHash3).
   - **Pros**:
     - Good balance of speed and hash quality: Provides a fast, good-quality hashing function with fewer collisions.
     - Widely used: Common in various applications, ensuring familiarity and community support.
   - **Cons**:
     - Non-cryptographic: Similar limitations in security as the other non-cryptographic algorithms.

### Performance Results

The benchmark results indicate the number of executions per second for each hashing function on a specific device and browser:

- **xxHash**: *8,818,159 executions/second* - Fastest and most efficient in this benchmark.
- **Murmur3**: *3,676,293 executions/second* - Second fastest, suitable for applications that require speed.
- **FNV-1a**: *656,091 executions/second* - Performance is decent but significantly slower than xxHash and Murmur3.
- **webCryptoHash**: *95,750 executions/second* - The slowest option due to the computational complexity of SHA-1.

### Considerations

- **Use Cases**: Depending on the requirement for speed vs. cryptographic security, developers may choose between these hashing functions. If security is paramount (e.g., storing passwords or tokens), the Web Crypto API's SHA-1 might be preferred. For applications where performance is critical and security needs are minimal (like checksums or quick comparisons), xxHash or Murmur3 could be the better choices.
  
- **Alternatives**: Other alternatives in hashing may include:
  - **SHA-256**: A newer and more secure cryptographic hash function than SHA-1 that's also part of the Web Crypto API.
  - **BLAKE3**: A modern hash function that aims to achieve high speed while providing secure cryptographic properties, though it may require a separate library.
  
In summary, the benchmarking provides valuable insights into the performance differences between cryptographic and non-cryptographic hashing functions, helping developers choose the right tool based on their specific needs.

Related benchmarks:

Compare hash functions (version: 1)

Comparing performance of: webCryptoHash vs fnv1a32 vs xxHash vs murmur3

Created: 3 months ago by: Guest

Jump to the latest result

webCryptoHash [Async/Deferred]

fnv1a32

xxHash

murmur3

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):