Benchmark: Hashing stuff 2 - MeasureThat.net

Script Preparation code:

var cfg = {
    "car": "resources/cars/141003",
    "color": "#AB2567",
    "angle": 6,
    "rims": "resources/rims/NISSAN_SUV2_kicks_2021_18_1500",
    "tyres": "resources/tyres/T4_18_1500",
    "tint": 25,
    "shadow": true,
    "height": 0,
    "plate": "",
    "background": "",
    "plateFilterQuality": 0,
    "partSelectionEnabled": true,
    "soloPart": "",
    "soloMode": "ghost"
}


function pad (hash, len) {
  while (hash.length < len) {
    hash = '0' + hash;
  }
  return hash;
}

function fold (hash, text) {
  var i;
  var chr;
  var len;
  if (text.length === 0) {
    return hash;
  }
  for (i = 0, len = text.length; i < len; i++) {
    chr = text.charCodeAt(i);
    hash = ((hash << 5) - hash) + chr;
    hash |= 0;
  }
  return hash < 0 ? hash * -2 : hash;
}

function foldObject (hash, o, seen) {
  return Object.keys(o).sort().reduce(foldKey, hash);
  function foldKey (hash, key) {
    return foldValue(hash, o[key], key, seen);
  }
}

function foldValue (input, value, key, seen) {
  var hash = fold(fold(fold(input, key), toString(value)), typeof value);
  if (value === null) {
    return fold(hash, 'null');
  }
  if (value === undefined) {
    return fold(hash, 'undefined');
  }
  if (typeof value === 'object' || typeof value === 'function') {
    if (seen.indexOf(value) !== -1) {
      return fold(hash, '[Circular]' + key);
    }
    seen.push(value);

    var objHash = foldObject(hash, value, seen)

    if (!('valueOf' in value) || typeof value.valueOf !== 'function') {
      return objHash;
    }

    try {
      return fold(objHash, String(value.valueOf()))
    } catch (err) {
      return fold(objHash, '[valueOf exception]' + (err.stack || err.message))
    }
  }
  return fold(hash, value.toString());
}

function toString (o) {
  return Object.prototype.toString.call(o);
}

function sum (o) {
  return pad(foldValue(0, o, '', []).toString(16), 8);
}


function cyrb53(str, seed = 0) {
  let h1 = 0xdeadbeef ^ seed,
    h2 = 0x41c6ce57 ^ seed;
  for (let i = 0, ch; i < str.length; i++) {
    ch = str.charCodeAt(i);
    h1 = Math.imul(h1 ^ ch, 2654435761);
    h2 = Math.imul(h2 ^ ch, 1597334677);
  }
  
  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
  h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
  
  return 4294967296 * (2097151 & h2) + (h1 >>> 0);
};

Tests:

hashSum
cfg.angle = Math.random()*36; const h = sum(cfg);
cyrb53
cfg.angle = Math.random()*36; const h = cyrb53(JSON.stringify(cfg));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
hashSum
cyrb53

Fastest: N/A

Slowest: N/A

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/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
hashSum	28953.5 Ops/sec
cyrb53	105264.7 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Taking a deep breath, let's dive into the explanation.

**Benchmark Overview**

MeasureThat.net is a platform that allows users to create and run JavaScript microbenchmarks. The provided JSON represents a benchmark definition for a hashing-related test case.

**Benchmark Definition**

The benchmark definition is an object with two properties: `Name` and `Script Preparation Code`. The `Name` property is "Hashing stuff 2", and the `Script Preparation Code` defines a configuration object `cfg` containing various parameters used in the benchmark. These parameters are:

* `car`: a resource file path
* `color`: a hexadecimal color code
* `angle`: an integer value between 0 and 36 (multiplied by a random factor)
* `rims`, `tyres`, `tint`, `shadow`, `height`, `plate`, `background`: string values or empty strings
* `plateFilterQuality` and `partSelectionEnabled`: boolean values
* `soloPart` and `soloMode`: string values

**Script Functions**

The script preparation code defines several functions:

1. `pad(hash, len)`: pads a hexadecimal hash with leading zeros to ensure a fixed length.
2. `fold(hash, text)`: performs a folding operation on the `hash` value by concatenating each character of the input `text` and updating the `hash` value using bitwise operations.
3. `foldObject(hash, o, seen)`: recursively folds an object `o` into the `hash` value, handling special cases like null, undefined, and circular references.
4. `toString(o)`: returns a string representation of the input `o` using `Object.prototype.toString.call`.
5. `sum(o)`: calculates a hash sum by padding the folding result with leading zeros to ensure an 8-digit hexadecimal string.

**Benchmark Test Cases**

The benchmark consists of two test cases:

1. `hashSum`: generates a hash value using the `sum()` function and multiplies the `angle` parameter by a random factor.
2. `cyrb53`: generates a hash value using the `cyrb53()` function, which is not publicly disclosed (likely a proprietary algorithm). The input to this function is the JSON-encoded configuration object.

**Library and Special JavaScript Features**

The benchmark uses the following libraries or features:

* None explicitly mentioned; however, it's likely that the `toString()` and `pad()` functions rely on the built-in `String` and `Number` types, which are part of the JavaScript standard library.
* The `Math.random()` function is used to generate a random factor for the `angle` parameter.

**Options Compared**

The two test cases compare the performance of two different hashing algorithms: `sum()` and `cyrb53`. The benchmark measures the number of executions per second for each test case on a specified platform (Chrome 108 on Linux).

**Benchmark Result**

The latest benchmark result shows that the `hashSum` test case has a higher execution rate than the `cyrb53` test case, indicating that the `sum()` function is faster.

Related benchmarks:

Hashing stuff 2 (version: 0)

Testing some hashing

Comparing performance of: hashSum vs cyrb53

Created: 3 years ago by: Registered User

Jump to the latest result

hashSum

cyrb53

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):