Benchmark: 64k bytes of crypto.getRandomValues vs Math.Random (part 2)

64k bytes of crypto.getRandomValues vs Math.Random (part 2) (version: 1)

Fair comparison using Crypto in batch mode. All tests run on TypedArray. All tests are inline without function call overhead. All tests use implicit type conversion without calling Math.floor()

Comparing performance of: `64k bytes Crypto API vs Array.map() vs Array.forEach() vs Array for loop`

Created: 2 years ago by: Registered User

Go to the latest result

Script Preparation code:

var arr32 = new Uint32Array(16384) // 16k * 4 bytes per u32 = 64k

Tests:

64k bytes Crypto API
crypto.getRandomValues(arr32)
Array.map()
arr32.map(e => Math.random() * 4294967296)
Array.forEach()
arr32.forEach((_, i) => { arr32[i] = Math.random() * 4294967296 })
Array for loop
for (let i = 0; i < 16384; i++) { arr32[i] = Math.random() * 4294967296 }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
64k bytes Crypto API
Array.map()
Array.forEach()
Array for loop

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36

Browser/OS: Chrome 124 on Linux

View result in a separate tab

64k bytes Crypto API

4K/s

Array.map()

306/s

Array for loop

235/s

Array.forEach()

225/s

View exact numbers

Test name	Executions per second
✓ 64k bytes Crypto API	4,274 Ops/sec
Array.map()	306 Ops/sec
Array for loop	235 Ops/sec
Array.forEach()	225 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**What is being tested?**

The provided JSON represents a set of JavaScript microbenchmarks that compare the performance of different approaches to generate random numbers:

1. `crypto.getRandomValues(arr32)`: This tests the Web Cryptography API, specifically the `getRandomValues` method.
2. `Array.map(e => Math.random() * 4294967296)`: This tests the `map()` method with a custom callback function that generates random numbers using `Math.random()`.
3. `Array.forEach((_, i) => {\r\n    arr32[i] = Math.random() * 4294967296\r\n})`: This tests the `forEach()` method with a custom callback function that generates random numbers using `Math.random()`.
4. `for (let i = 0; i < 16384; i++) {\r\n    arr32[i] = Math.random() * 4294967296\r\n}`: This tests a traditional `for` loop to generate random numbers.

**Options compared**

The four approaches are compared in terms of their execution speed. The results will show which approach is the fastest for generating 64k bytes of pseudo-random data using TypedArray.

**Pros and cons of each approach**

1. **Web Cryptography API (`crypto.getRandomValues(arr32)`)**:
	* Pros: More secure, more suitable for cryptographic purposes.
	* Cons: May have slower performance due to additional overhead.
2. **`map()` method with custom callback function (e.g., `Array.map(e => Math.random() * 4294967296)`)**:
	* Pros: Simple and concise, easy to use.
	* Cons: May not be as efficient as native methods like `getRandomValues`.
3. **`forEach()` method with custom callback function (e.g., `Array.forEach((_, i) => {\r\n    arr32[i] = Math.random() * 4294967296\r\n})`)**:
	* Pros: Similar to `map()` but can be used for side effects.
	* Cons: May not be as efficient as native methods like `getRandomValues`.
4. **Traditional `for` loop (e.g., `for (let i = 0; i < 16384; i++) {\r\n    arr32[i] = Math.random() * 4294967296\r\n}`)**:
	* Pros: Can be highly optimized by the browser.
	* Cons: May require more code and is less readable.

**Library**

The `crypto` library is part of the Web Cryptography API, which provides cryptographic primitives like secure random number generation. The `getRandomValues()` method is used to generate an array of pseudo-random numbers.

**Special JS feature or syntax**

None of the test cases use any special JavaScript features or syntax that would require additional explanation.

**Other alternatives**

If you wanted to benchmark alternative approaches, here are some options:

* Using a native random number generator library like `randu()` (available in Node.js)
* Using a different algorithm for generating pseudo-random numbers, such as the Linear Congruential Generator
* Using a parallel or multi-threaded approach to generate random numbers
* Using a different data structure, such as an array or a buffer, instead of a TypedArray.