Benchmark: test hash - MeasureThat.net

Script Preparation code:

var hash = function(s) {
    /* Simple hash function. */
    var a = 1, c = 0, h, o;
    if (s) {
        a = 0;
        /* jshint plusplus:false bitwise:false */
        for (h = s.length - 1; h >= 0; h--) {
            o = s.charCodeAt(h);
            a = (a<<6&268435455) + o + (o<<14);
            c = a & 266338304;
            a = c!==0?a^c>>21:a;
        }
    }
    return String(a);
};

var simpleHash = function(str) {
  let hash = 0;
  for (let i = 0; i < str.length; i++) {
    const char = str.charCodeAt(i);
    hash = (hash << 5) - hash + char;
    hash &= hash; // Convert to 32bit integer
  }
  return new Uint32Array([hash])[0].toString(36);
};

function hashCode(s) {
    for(var i = 0, h = 0; i < s.length; i++)
        h = Math.imul(31, h) + s.charCodeAt(i) | 0;
    return h;
}

Tests:

hash with just hash
var hp = hash('/api/planets/1');
hash with simpelHash
var hp2 = simpleHash('/api/planets/1');
hashcode
var hp3 = hashCode('/api/planets/1');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
hash with just hash
hash with simpelHash
hashcode

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what's being tested, compared, and considered in each test case.

**Benchmark Definition**

The benchmark defines three different hash functions:

1. `hash`: A custom, simple hash function that takes a string input `s` and returns a hash value as a string.
2. `simpleHash`: A modified version of the custom hash function, which uses bitwise operations to reduce memory usage and improve performance.
3. `hashCode`: A built-in JavaScript function that calculates the hash code of a string using a simple algorithm.

**Test Cases**

Each test case measures the execution time of one of these hash functions when called with a specific input:

1. `hash with just hash`: Calls the `hash` function with the input `/api/planets/1`.
2. `hash with simpelHash`: Calls the modified `simpleHash` function with the same input.
3. `hashcode`: Calls the built-in `hashCode` function with the same input.

**Options Compared**

The benchmark compares the performance of three different hash functions:

* **Custom Hash (`hash`)**: The original custom hash function, which uses a simple algorithm to calculate the hash value.
* **Modified Custom Hash (`simpleHash`)**: A modified version of the custom hash function, optimized for better performance by reducing memory usage and using bitwise operations.
* **Built-in Hash Code (`hashCode`)**: A built-in JavaScript function that calculates the hash code of a string using a simpler algorithm.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. **Custom Hash (`hash`)**:
	* Pros: Simple to implement, easy to understand.
	* Cons: May not be as efficient or effective as other algorithms.
2. **Modified Custom Hash (`simpleHash`)**:
	* Pros: Optimized for better performance, reduces memory usage.
	* Cons: Requires modification of the original algorithm, may be less intuitive.
3. **Built-in Hash Code (`hashCode`)**:
	* Pros: Efficient and effective, built-in JavaScript function.
	* Cons: Limited control over the calculation process.

**Other Considerations**

When choosing a hash function, consider factors such as:

* **Speed**: Faster execution times are generally preferred for performance-critical applications.
* **Security**: The hash function should be designed to minimize collisions and ensure uniqueness of the output.
* **Memory usage**: For resource-constrained environments or large datasets, optimized memory usage can be crucial.

**Additional Context**

The test cases use various libraries and features, such as:

* `jshint`: A JavaScript linter that enforces coding standards and detects potential errors.
* `Yowser/2.5 Safari/537.36`: Browser versions and engines used for testing, which may affect performance differences between the hash functions.

Keep in mind that these details might not be relevant to the overall performance comparison of the three hash functions.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 YaBrowser/23.7.4.999 (corp) Yowser/2.5 Safari/537.36

Browser/OS: Yandex Browser 23 on Windows

View result in a separate tab

Test name	Executions per second
hash with just hash	4459988.5 Ops/sec
hash with simpelHash	1784467.2 Ops/sec
hashcode	563389.1 Ops/sec

Related benchmarks:

test hash (version: 0)

Comparing performance of: hash with just hash vs hash with simpelHash vs hashcode

Created: 3 years ago by: Guest

Jump to the latest result

hash with just hash

hash with simpelHash

hashcode

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):