Benchmark: Compare hash functions with xxHash optimizations

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;
}

function xxHashOptimized(data) {
    const PRIME32_1 = 0x9e3779b1;
    const PRIME32_2 = 0x85ebca77;
    
    let h = 0;
    let i = 0;
    
    // Process 4 items at once using a specialized loop for exactly 216 elements
    // 216 / 4 = 54 complete chunks
    while (i < 216) {
        const chunk = data[i] |
                     (data[i + 1] << 8) |
                     (data[i + 2] << 16) |
                     (data[i + 3] << 24);
        
        h = Math.imul(h + Math.imul(chunk, PRIME32_1), PRIME32_2);
        i += 4;
    }
    
    return h >>> 0;
}

function xxHashUnrolled(data) {
    const PRIME32_1 = 0x9e3779b1;
    const PRIME32_2 = 0x85ebca77;
    
    let h = 0;
    
    // Manually unroll the first few iterations
    // This removes loop overhead and helps branch prediction
    let chunk = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
    h = Math.imul(h + Math.imul(chunk, PRIME32_1), PRIME32_2);
    
    chunk = data[4] | (data[5] << 8) | (data[6] << 16) | (data[7] << 24);
    h = Math.imul(h + Math.imul(chunk, PRIME32_1), PRIME32_2);
    
    chunk = data[8] | (data[9] << 8) | (data[10] << 16) | (data[11] << 24);
    h = Math.imul(h + Math.imul(chunk, PRIME32_1), PRIME32_2);
    
    // Process the rest in a tight loop
    for (let i = 12; i < 216; i += 4) {
        chunk = data[i] | (data[i + 1] << 8) | (data[i + 2] << 16) | (data[i + 3] << 24);
        h = Math.imul(h + Math.imul(chunk, PRIME32_1), PRIME32_2);
    }
    
    return h >>> 0;
}

// Version optimized for modern JS engines
function xxHashModern(data) {
    const PRIME32_1 = 0x9e3779b1;
    const PRIME32_2 = 0x85ebca77;
    
    let h = 0;
    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
    
    // Process 4 bytes at a time using DataView
    for (let i = 0; i < 216; i += 4) {
        const chunk = view.getUint32(i, true);  // true for little-endian
        h = Math.imul(h + Math.imul(chunk, PRIME32_1), PRIME32_2);
    }
    
    return h >>> 0;
}

window.testData = testData;
window.webCryptoHash = webCryptoHash;
window.fnv1a32 = fnv1a32;
window.xxHash = xxHash;
window.murmur3 = murmur3;
window.xxHashOptimized = xxHashOptimized;
window.xxHashUnrolled = xxHashUnrolled;
window.xxHashModern = xxHashModern;

Test case name	Result
webCryptoHash
fnv1a32
xxHash
murmur3
xxHashOptimized
xxHashUnrolled
xxHashModern

Latest run results:

Run details: (Test run date: 24 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36

Browser/OS: Chrome 149 on Mac OS X 10.15.7

View result in a separate tab

xxHashUnrolled

25.8M/s

xxHashOptimized

24.5M/s

xxHashModern

19.2M/s

xxHash

8.3M/s

murmur3

2.4M/s

webCryptoHash

847K/s

fnv1a32

785K/s

View exact numbers

Test name	Executions per second
✓ xxHashUnrolled	25,769,484 Ops/sec
xxHashOptimized	24,484,892 Ops/sec
xxHashModern	19,247,580 Ops/sec
xxHash	8,348,886 Ops/sec
murmur3	2,393,718 Ops/sec
webCryptoHash	846,844 Ops/sec
fnv1a32	785,231 Ops/sec

Compare hash functions with xxHash optimizations (version: 1)

Comparing performance of: `webCryptoHash vs fnv1a32 vs xxHash vs murmur3 vs xxHashOptimized vs xxHashUnrolled vs xxHashModern`

Created: one year ago by: Guest

Go to the latest result

webCryptoHash [Async/Deferred]

fnv1a32

xxHash

murmur3

xxHashOptimized

xxHashUnrolled

xxHashModern

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Compare hash functions with xxHash optimizations (version: 1)

Comparing performance of: webCryptoHash vs fnv1a32 vs xxHash vs murmur3 vs xxHashOptimized vs xxHashUnrolled vs xxHashModern

Created: one year ago by: Guest

Go to the latest result

webCryptoHash [Async/Deferred]

fnv1a32

xxHash

murmur3

xxHashOptimized

xxHashUnrolled

xxHashModern

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Comparing performance of: `webCryptoHash vs fnv1a32 vs xxHash vs murmur3 vs xxHashOptimized vs xxHashUnrolled vs xxHashModern`