Benchmark: Read/Write cycle for fixed size array (Massive Data)

Script Preparation code:

var count = 6000000;
var list = new Array(count).fill(100);

Tests:

slice immutable
var insertCount = 0; for (var i = 0; i < 10; ++i) { if (list.length > count - 1) { list=list.slice(0, count - 1) list.push(insertCount++) } else { list = [...list, insertCount++]; } } var foo = list;
splice immutable
var insertCount = 0; for (var i = 0; i < 10; ++i) { list = [...list, insertCount++] if (list.length > count) { list.splice(0, list.length - count); } } var foo = list;
shift-while immutable
var insertCount = 0; for (var i = 0; i < 10; ++i) { list = [...list, insertCount++] while (list.length > count) { list.shift(); } } var foo = list;
slice mutable
var insertCount = 0; for (var i = 0; i < 10; ++i) { list=list.slice(0, count) list.push(insertCount++) } var foo = list;
splice mutable
var insertCount = 0; for (var i = 0; i < 10; ++i) { list.push(insertCount++) if (list.length > count) { list.splice(0, list.length - count); } } var foo = list;
shift-while mutable
var insertCount = 0; for (var i = 0; i < 10; ++i) { list.push(insertCount++) while (list.length > count) { list.shift(); } } var foo = list;
circular buffer
var idx = 0; var insertCount = 0; for (var i = 0; i < 10; ++i) { list[idx] = insertCount++; idx = (idx + 1) % count; } var foo = [...list.slice(idx), ...list.slice(0, idx)];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
slice immutable
splice immutable
shift-while immutable
slice mutable
splice mutable
shift-while mutable
circular buffer

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.192 Safari/537.36

Browser/OS: Chrome 88 on Windows

View result in a separate tab

Test name	Executions per second
slice immutable	2.0 Ops/sec
splice immutable	1.7 Ops/sec
shift-while immutable	1.5 Ops/sec
slice mutable	1.5 Ops/sec
splice mutable	37.5 Ops/sec
shift-while mutable	45.5 Ops/sec
circular buffer	14.1 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and its various options.

**Benchmark Overview**

The benchmark is designed to measure the performance of different ways to append or insert elements into an array in JavaScript. The test creates a large array with a fixed size (`count`) and then performs 10 writes (insertions) followed by one read (accessing an element). The benchmark measures how many executions per second each test case can perform.

**Test Cases**

There are six test cases:

1. **slice immutable**: This test case uses the spread operator (`...`) to create a new array and append elements to it.
2. **splice immutable**: Similar to the previous one, but uses `splice()` to remove and insert elements.
3. **shift-while immutable**: Uses `shift()` to remove elements from the beginning of the array while inserting new ones.
4. **slice mutable**: This test case modifies the original array by using `push()`.
5. **splice mutable**: Similar to the previous one, but modifies the original array by using `splice()`.
6. **shift-while mutable**: Uses `shift()` and `push()` to modify the original array.

**Pros and Cons of each approach**

* **slice immutable**:
	+ Pros: Creates a new array, which can be more efficient for large arrays.
	+ Cons: Requires creating a new array object, which can be costly in terms of memory allocation and garbage collection.
* **splice immutable**: Similar to `slice immutable`, but uses `splice()` instead. This approach is less efficient than `slice immutable` because it modifies the original array.
* **shift-while immutable**:
	+ Pros: Uses a single operation (`shift()`), which can be more efficient than creating a new array or using multiple operations.
	+ Cons: Can lead to poor cache locality and performance issues if not implemented carefully.
* **slice mutable**, **splice mutable**, and **shift-while mutable**: These approaches are less efficient than the immutable ones because they modify the original array.

**Observations from the benchmark results**

The results show that:

* The `slice immutable` test case is the fastest, followed closely by the `shift-while immutable` test case.
* The `splice immutable`, `splice mutable`, and `shift-while mutable` test cases are slower than the first two because they modify the original array or use more expensive operations.

Overall, the results suggest that creating a new array using the spread operator is the most efficient way to append elements, while minimizing modifications to the original array can lead to better performance.

Related benchmarks:

Read/Write cycle for fixed size array (Massive Data) (version: 0)

10 writes per 1 read

Comparing performance of: slice immutable vs splice immutable vs shift-while immutable vs slice mutable vs splice mutable vs shift-while mutable vs circular buffer

Created: 3 years ago by: Guest

Jump to the latest result

slice immutable

splice immutable

shift-while immutable

slice mutable

splice mutable

shift-while mutable

circular buffer

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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