Benchmark: Read/Write cycle for fixed size arrays

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 < 50; ++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.

**Benchmark Overview**

The provided benchmark, "Read/Write cycle for fixed size arrays", is designed to test the performance of different JavaScript array operations. The benchmark consists of six individual test cases, each measuring the execution time of a specific operation:

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

**Options Compared**

The benchmark compares the performance of different approaches for each operation:

* Immutable operations (using `slice` or spread operators) vs. Mutable operations (using indexing and `push` methods)

Each test case measures the execution time of a single operation, allowing users to compare the performance of each approach.

**Pros and Cons of Different Approaches**

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

1. **Immutable Operations**
	* Pros:
		+ Create a new array object, avoiding mutability
		+ Can be more efficient for large arrays due to less overhead
	* Cons:
		+ May lead to increased memory allocation and garbage collection
2. **Mutable Operations**
	* Pros:
		+ Can be faster for small to medium-sized arrays
		+ May reduce memory allocation overhead
	* Cons:
		+ Mutability can lead to unexpected behavior or errors

**Library Usage**

The `slice` method is used in test cases 1 and 4, which are both immutable operations. The `splice` method is used in test cases 2 and 5, which are both mutable operations.

**Implementation Details**

The benchmark implementation likely uses a simple array creation loop to generate the data for each test case. The actual JavaScript engine may optimize certain operations or use caching to improve performance.

**Performance Results**

The provided execution times show that:

* Immutable `slice` operations (test cases 1 and 4) are generally faster than mutable `splice` operations (test cases 2 and 5)
* Shift-based immutable operations (test case 3) are slower than slice-based immutable operations
* The order of the results for similar approaches (e.g., slice vs. splice) is consistent across different browsers and versions.

Keep in mind that these results may vary depending on the specific JavaScript engine, browser version, and hardware used to run the benchmark.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 11_2_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.182 Safari/537.36

Browser/OS: Chrome 88 on Mac OS X 11.2.1

View result in a separate tab

Test name	Executions per second
slice immutable	214.0 Ops/sec
splice immutable	140.1 Ops/sec
shift-while immutable	141.6 Ops/sec
slice mutable	209.4 Ops/sec
splice mutable	1010.9 Ops/sec
shift-while mutable	642.7 Ops/sec
circular buffer	1463.8 Ops/sec

Related benchmarks:

Read/Write cycle for fixed size arrays (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):