Benchmark: array vs Float64Array with floats

Script Preparation code:

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

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

Tests:

normal array reverse
a.reverse().reverse().reverse();
a.reverse().reverse().reverse();
Float64Array reverse
ta.reverse().reverse().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]; }
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]; }
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; }
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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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: 27 days 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 7 months ago):

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:

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.
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:

Regular Array (a) vs Float64Array (ta) with float values
Reverse operations: two approaches (array and Float64Array) for reversing an array
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:

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
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.

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: 2 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>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 7 months ago):