Benchmark: array vs Float64Array with floats

Script Preparation code:

var a = [...Array(10000)].map(_ => Math.random());
var ta = (new Float64Array(10000)).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 year ago)

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

Browser/OS: Chrome 135 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
normal array reverse	51236.3 Ops/sec
Float64Array reverse	204795.7 Ops/sec
normal array i/o	22370.1 Ops/sec
Float64Array i/o	27777.6 Ops/sec
Swap between arrays	24667.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition JSON**

The provided benchmark definition JSON represents a microbenchmark test that compares two approaches:

1. **Array vs Float64Array with floats**: This test creates two arrays: one using regular `Array` and another using `Float64Array`. Both arrays are filled with random float values between 0 and 1.
2. **Reverse operations**: The benchmark defines three test cases:
	* Reverse operations on the original array (`normal array reverse`)
	* Reverse operations on the `Float64Array` (`Float64Array reverse`)
	* Input/Output (I/O) operations on both arrays (`normal array i/o` and `Float64Array i/o`)
	* Swapping elements between the two arrays (`Swap between arrays`)

**Options Compared**

The benchmark compares the performance of:

1. **Regular Array** (`a`) vs **Float64Array** (`ta`) with float values
2. **Reverse operations**: two approaches (array and `Float64Array`) for reversing an array
3. **Input/Output operations**: two approaches (array and `Float64Array`) for I/O operations on the arrays

**Pros and Cons of Each Approach**

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

1. **Regular Array** (`a`):
	* Pros:
		+ Easy to implement and understand
		+ No additional memory allocation or handling required
	* Cons:
		+ May be slower due to boxing/unboxing operations (converting between primitive types and objects)
		+ May have performance issues with large arrays or complex operations
2. **Float64Array** (`ta`):
	* Pros:
		+ Optimized for floating-point arithmetic and memory efficiency
		+ Can avoid boxing/unboxing operations
	* Cons:
		+ Requires explicit memory management (allocating and deallocating `Float64Array` instances)
		+ May be less intuitive to use, especially for beginners

**Library Used**

No specific library is used in this benchmark, but the `Float64Array` data type is a built-in JavaScript feature that provides an efficient way to work with floating-point numbers.

**Special JS Feature/Syntax**

There are no special JS features or syntaxes mentioned in this benchmark.

**Other Alternatives**

If you're interested in exploring other alternatives, here are a few examples:

* **TypedArrays**: Similar to `Float64Array`, but can also be used for other types of data (e.g., integers, bytes).
* **BigInt**: A built-in JavaScript feature for working with arbitrary-precision integers.
* **Web Workers**: Can be used to parallelize computationally intensive tasks and improve performance.

Keep in mind that these alternatives may have their own trade-offs and use cases, so it's essential to evaluate them based on your specific requirements.

Related benchmarks:

array vs Float64Array with floats (version: 0)

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

Created: 3 years 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>

Fastest: N/A

Slowest: N/A

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