Benchmark: array vs float32array without conversion

Script Preparation code:

function getRandomInt(max) {
  return Math.floor(Math.random() * Math.floor(max));
}
var a = [...Array(10000)].map(_ => Math.random(1000000));
var ta = (new Float32Array(10000)).map(_ => Math.random(1000000));

Tests:

array sort
a.sort();
typedArray sort
ta.sort();
array i/o
for (let i = 0; i < 10000; ++i) { a[i] = a[i] + 1; }
typedArray i/o
for (let i = 0; i < 10000; ++i) { ta[i] = ta[i] + 1; } let tb = Array.from(ta);

Historical Performance Data aggregated from 18 community runs

Desktop Results:

Chrome 18 runs

array i/o

25K/s

typedArray sort

23K/s

typedArray i/o

3K/s

array sort

1K/s

Fastest: array i/o (18.9x faster)

View exact numbers

✓ array i/o: 24,688 ops/sec
• typedArray sort: 23,430 ops/sec
• typedArray i/o: 2,684 ops/sec
• array sort: 1,305 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array sort
typedArray sort
array i/o
typedArray i/o

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 139 on Mac OS X 10.15.7

View result in a separate tab

array i/o

64K/s

typedArray sort

29K/s

typedArray i/o

6K/s

array sort

2K/s

View exact numbers

Test name	Executions per second
✓ array i/o	64,208 Ops/sec
typedArray sort	29,465 Ops/sec
typedArray i/o	6,392 Ops/sec
array sort	2,474 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 JSON and explain what's being tested in each benchmark.

**Benchmark Definition**

The first part of the JSON represents a benchmark definition, which outlines the specific test case:

```json
{
    "Name": "array vs float32array without conversion",
    "Description": null,
    "Script Preparation Code": "function getRandomInt(max) {\r\n  return Math.floor(Math.random() * Math.floor(max));\r\n}\r\nvar a = [...Array(10000)].map(_ => Math.random(1000000));\r\nvar ta = (new Float32Array(10000)).map(_ => Math.random(1000000));",
    "Html Preparation Code": null
}
```

This benchmark tests the performance of two arrays: `a` and `ta`. The script preparation code initializes these arrays with 10,000 elements each, generated randomly. Note that there's no explicit conversion between `a` and `ta`, which is a key aspect of this test.

**Individual Test Cases**

The second part of the JSON represents multiple individual test cases:

```json
[
    {
        "Benchmark Definition": "a.sort();",
        "Test Name": "array sort"
    },
    {
        "Benchmark Definition": "ta.sort();",
        "Test Name": "typedArray sort"
    },
    {
        "Benchmark Definition": "for (let i = 0; i < 10000; ++i) {\r\n  a[i] = a[i] + 1;\r\n}",
        "Test Name": "array i/o"
    },
    {
        "Benchmark Definition": "for (let i = 0; i < 10000; ++i) {\r\n  ta[i] = ta[i] + 1;\r\n}\r\nlet tb = Array.from(ta);",
        "Test Name": "typedArray i/o"
    }
]
```

These test cases compare the performance of different operations on arrays:

*   `array sort`: Sorting an array in ascending order.
*   `typedArray sort`: Sorting a typed array (`Float32Array` in this case) in ascending order.
*   `array i/o`: Incrementing each element in the array by 1 and then reading back the modified elements.
*   `typedArray i/o`: Performing the same operation as above, but using a typed array.

**Library:**

The `getRandomInt(max)` function is not a built-in library; it's a custom function created to generate random integers. However, `Float32Array` is a part of the JavaScript standard library, which represents an array of 32-bit floating-point numbers. It's used in this benchmark to test typed arrays.

**Special JS Feature or Syntax:**

None are explicitly mentioned, but note that some JavaScript versions may have specific optimizations or behaviors for certain array operations. However, these are not explicitly highlighted as special features or syntax in the provided JSON.

**Other Considerations:**

The benchmarks focus on the performance differences between arrays and typed arrays without explicit conversions. This highlights the importance of optimized data structures and efficient memory management in JavaScript applications.

**Alternatives:**

If you were to rewrite this benchmark, consider alternative test cases or variations:

*   Test the impact of different array sizes.
*   Explore the performance of other array operations (e.g., `reduce()`, `every()`).
*   Compare the performance of other typed arrays (e.g., `Int32Array`, `Uint16Array`).

These alternatives could provide a more comprehensive understanding of JavaScript's performance characteristics for different data structures and operations.

array vs float32array without conversion (version: 0)

Comparing performance of: `array sort vs typedArray sort vs array i/o vs typedArray i/o`

Created: 5 years ago by: Guest

Go to the latest result

array sort

typedArray sort

array i/o

typedArray i/o

Historical Performance Data aggregated from 18 community runs

Desktop Results:

Chrome 18 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

array vs float32array without conversion (version: 0)

Comparing performance of: array sort vs typedArray sort vs array i/o vs typedArray i/o

Created: 5 years ago by: Guest

Go to the latest result

array sort

typedArray sort

array i/o

typedArray i/o

Historical Performance Data aggregated from 18 community runs

Desktop Results:

Chrome 18 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `array sort vs typedArray sort vs array i/o vs typedArray i/o`