Benchmark: array vs Float64Array with floats (small array)

Script Preparation code:

var a = [...Array(500)].map(_ => Math.random());
var ta = (new Float64Array(500)).map(_ => Math.random());

Tests:

normal array reverse
a.reverse().reverse().reverse();
Float64Array reverse
ta.reverse().reverse().reverse();
normal array i/o
for (let i=1; i !== 10000; i=i+1|0) { a[i] = a[i] + 1.1 - a[i-1|0]; }
Float64Array i/o
for (let i=1; i !== 10000; i=i+1|0) { ta[i] = ta[i] + 1.1 - ta[i-1|0]; }
Swap between arrays
for (let i=0; i !== 10000; i=i+1|0) { var tmp = ta[i]; ta[i] = a[i]; a[i] = tmp; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
normal array reverse
Float64Array reverse
normal array i/o
Float64Array i/o
Swap between arrays

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 18 on iOS 18.3.1

View result in a separate tab

Test name	Executions per second
normal array reverse	1139846.4 Ops/sec
Float64Array reverse	2664376.2 Ops/sec
normal array i/o	13896.4 Ops/sec
Float64Array i/o	10785.5 Ops/sec
Swap between arrays	50432.6 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the JSON tests the performance of standard JavaScript arrays versus `Float64Array`, specifically in the context of a small array of floats. Both data structures are evaluated based on various operations, which provide insights into their efficiency for typical use cases in JavaScript programming.

### Tested Options

1. **Normal Array Reverse:**
   - **Benchmark Definition:** `a.reverse().reverse().reverse();`
   - **Test Name:** "normal array reverse"
   - **Description:** This tests the built-in `reverse()` method of a standard JavaScript array to measure how fast it can reverse the order of elements. The triple reversal is employed to restore the original order after performing a reversal, which could provide insights into the performance of consecutive calls to this method.

2. **Float64Array Reverse:**
   - **Benchmark Definition:** `ta.reverse().reverse().reverse();`
   - **Test Name:** "Float64Array reverse"
   - **Description:** Similar to the normal array reverse, but this tests the `reverse()` method on a `Float64Array`. The performance difference between the standard array and the typed array can help in understanding optimizations that might be present for numerical operations.

3. **Normal Array I/O:**
   - **Benchmark Definition:** `for (let i=1; i !== 10000; i=i+1|0) { a[i] = a[i] + 1.1 - a[i-1|0]; }`
   - **Test Name:** "normal array i/o"
   - **Description:** This loop performs read and write operations on an array. The use of `1.1 - a[i-1|0]` adds a floating-point calculation to each element. It measures the efficiency of sequential access and mathematical operations in a regular array.

4. **Float64Array I/O:**
   - **Benchmark Definition:** `for (let i=1; i !== 10000; i=i+1|0) { ta[i] = ta[i] + 1.1 - ta[i-1|0]; }`
   - **Test Name:** "Float64Array i/o"
   - **Description:** This test mirrors the normal array I/O operation but uses `Float64Array`. The benchmark accentuates how typed arrays can handle numerical data efficiently compared to regular arrays in terms of performance.

5. **Swap Between Arrays:**
   - **Benchmark Definition:** `for (let i=0; i !== 10000; i=i+1|0) { var tmp = ta[i]; ta[i] = a[i]; a[i] = tmp; }`
   - **Test Name:** "Swap between arrays"
   - **Description:** This operation measures the performance of swapping elements between a `Float64Array` and a regular array. This provides insights into how efficiently data can be moved back and forth between different types of arrays.

### Pros and Cons

#### Normal Arrays
- **Pros:**
  - More flexible, allowing for mixed data types.
  - Easier to use with a wider range of built-in JavaScript methods.
- **Cons:**
  - Slower performance for numerical computations due to type coercion and overhead.
  - More memory overhead compared to typed arrays.

#### Float64Array
- **Pros:**
  - Optimized for numerical operations; enables faster computation in scenarios involving large volumes of numerical data.
  - Lower memory footprint for numbers compared to standard arrays.
- **Cons:**
  - Less flexibility as it can only hold 64-bit floating-point numbers.
  - Some limitations in functionality compared to regular arrays (e.g., fewer built-in methods).

### Other Alternatives

Other options for numerical performance within JavaScript might include using:
- **Typed Arrays (other than Float64Array):** JavaScript also offers various typed arrays such as `Int32Array`, `Uint8Array`, etc., that might be suited for different use cases depending on the data type needed.
- **WebAssembly:** For compute-intensive tasks, WebAssembly can significantly outperform JavaScript in numeric computations.
- **Libraries:** Libraries such as NumPy and others (compiled to JavaScript) provide robust performance for numerical computing, though they may introduce additional dependencies and complexity.

In summary, this benchmark comparison helps elucidate performance differences between handling numerical data using standard JavaScript arrays versus typed arrays like `Float64Array`. Understanding these differences is crucial for optimizing applications that rely heavily on numerical computations.

Related benchmarks:

array vs Float64Array with floats (small array) (version: 1)

Comparing performance of: normal array reverse vs Float64Array reverse vs normal array i/o vs Float64Array i/o vs Swap between arrays

Created: one month ago by: Guest

Jump to the latest result

normal array reverse

Float64Array reverse

normal array i/o

Float64Array i/o

Swap between arrays

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):