Benchmark: Read/Write cycle for fixed size array

Script Preparation code:

var count = 120000;
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

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Overview**

The benchmark measures the performance of different approaches for inserting elements into an array while maintaining its length. The test cases simulate 10 writes per 1 read operation, which is described in the benchmark definition.

**Test Cases**

There are six test cases:

1. `slice immutable`
2. `splice immutable`
3. `shift-while immutable`
4. `slice mutable`
5. `splice mutable`
6. `shift-while mutable`

Each test case has a different approach for inserting elements into the array while maintaining its length.

**Approaches Compared**

Here's a brief overview of each approach and their pros and cons:

1. **`slice immutable`**: This approach creates a new array by slicing the original array up to the insertion point, pushes the new element, and assigns it back to the `list` variable. The pros are that it avoids mutating the original array and has a predictable performance since slicing is a constant-time operation. However, creating a new array can be expensive in terms of memory allocation.
2. **`splice immutable`**: This approach uses `Array.prototype.splice()` to remove elements from the beginning of the array until its length matches the desired count. The pros are that it avoids mutating the original array and has a predictable performance since `splice()` is a constant-time operation. However, removing elements can be expensive in terms of memory reallocation.
3. **`shift-while immutable`**: This approach uses a while loop to remove elements from the beginning of the array until its length matches the desired count. The pros are that it avoids mutating the original array and has a predictable performance since removing elements is a constant-time operation. However, creating a new array can be expensive in terms of memory allocation.
4. **`slice mutable`**: This approach modifies the `list` variable directly by using `Array.prototype.push()` to add the new element at the end of the array. The pros are that it's simple and easy to implement. However, modifying an array in-place can lead to unpredictable performance due to potential cache thrashing.
5. **`splice mutable`**: This approach modifies the `list` variable directly by using `Array.prototype.splice()` to add the new element at the beginning of the array. The pros are that it's simple and easy to implement. However, modifying an array in-place can lead to unpredictable performance due to potential cache thrashing.
6. **`shift-while mutable`**: This approach modifies the `list` variable directly by using a while loop to remove elements from the beginning of the array until its length matches the desired count. The pros are that it's simple and easy to implement. However, modifying an array in-place can lead to unpredictable performance due to potential cache thrashing.

**Performance Results**

The benchmark results show that `slice immutable` and `splice immutable` approaches outperform the other test cases, with execution speeds ranging from 150-550 operations per second (ops/sec) on a desktop Safari 14 browser. The `shift-while immutable` approach comes in third, with an execution speed of around 50-100 ops/sec.

**Conclusion**

In conclusion, when it comes to inserting elements into an array while maintaining its length, the `slice immutable` and `splice immutable` approaches offer predictable performance due to their use of constant-time operations. However, these approaches may come at a cost in terms of memory allocation. The other test cases, which modify the array in-place, can lead to unpredictable performance due to potential cache thrashing.

As always, the choice of approach depends on the specific requirements and constraints of your use case. If predictability and performance are crucial, `slice immutable` or `splice immutable` might be a good choice. However, if simplicity and ease of implementation are more important, one of the other approaches might be sufficient.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.3 Safari/605.1.15

Browser/OS: Safari 14 on Mac OS X 10.15.6

View result in a separate tab

Test name	Executions per second
slice immutable	152.8 Ops/sec
splice immutable	62.4 Ops/sec
shift-while immutable	65.2 Ops/sec
slice mutable	144.2 Ops/sec
splice mutable	134220.0 Ops/sec
shift-while mutable	158162.9 Ops/sec
circular buffer	548.8 Ops/sec

Related benchmarks:

Read/Write cycle for fixed size array (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 one month ago):