Benchmark: Array Stack/Queue VS Custom Stack/Queue 2

Script Preparation code:

	function Custom(iterable = null) {
		if (iterable !== null) {
			this.array = Array.from(iterable);
		} else {
			this.array = [];
		}
      	this.length = this.array.length;
		this.index0 = 0;
	}
	Custom.prototype.item = function (accessor) {
		return this.array[this.index0 + Number(accessor)];
	};
	Custom.prototype.set = function (index, value) {
		const newIndex = this.index0 + Number(index);
		if (newIndex >= this.length) {
			this.length = newIndex + 1;
		}
		this.array[newIndex] = value;
	};
	Custom.prototype.shift = function () {
		if (this.length !== 0) {
			this.length--;
			this.index0++;
			return this.array[this.index0 - 1];
		}
		return undefined;
	};
	Custom.prototype.pop = function () {
		if (this.length !== 0) {
			this.length--;
			return this.array[this.index0 + this.length];
		}
		return undefined;
	};
	Custom.prototype.push = function (value) {
		this.array[this.index0 + this.length] = value;
		this.length++;
	};
function p(array) {
  for (var i = 0; i <= 10000000; i++) {
       array[array.length] = i;
  }
return array;
}
var a1 = p([]);
var a2 = p([]);
var q = new Custom(p(p(p(p(p([]))))));
var s = new Custom(p(p(p(p(p([]))))));

Tests:

Array Shift
a1.shift();
Array Pop
a2.pop();
Custom Shift
q.shift();
Custom Pop
s.pop();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array Shift
Array Pop
Custom Shift
Custom Pop

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, the pros and cons of each approach, and other considerations.

**Benchmark Overview**

The benchmark compares the performance of three implementations:

1. Array-based Shift/Pop (using JavaScript arrays)
2. Custom non-mutative Stack/Queue implementation (using a Custom class)
3. Both custom implementations are compared to their array-based counterparts

**Array-based Shift/Pop**

This implementation uses JavaScript arrays for both shift and pop operations. The pros of this approach include:

* Familiarity: Many developers are already comfortable with using arrays in JavaScript.
* Easy to implement: Only basic array operations are required.

However, there are some cons:

* Array mutation: When an element is shifted or popped, the entire array needs to be modified, which can lead to unnecessary reallocations and copying of data. This can be inefficient for large datasets.
* Lack of control: The implementation is limited by the internal workings of JavaScript arrays, which may not provide optimal performance.

**Custom non-mutative Stack/Queue**

This implementation uses a Custom class with methods for shift, pop, set, item, and push operations. The pros of this approach include:

* Non-mutative: Elements are not modified in-place, ensuring that the data remains intact.
* Control: The implementation provides more control over the underlying data structure, allowing for potentially better performance.

However, there are some cons:

* Complexity: Implementing a custom class can be more complex and error-prone than using arrays.
* Overhead: Creating and managing objects can incur additional overhead compared to using arrays.

**Comparison**

The benchmark tests the execution speed of these three implementations. The results show that:

* Array-based Shift/Pop is slower than both custom implementations, especially for larger datasets.
* Custom Shift and Pop have similar performance profiles, with Custom Pop being slightly faster in this specific case.

**Other Considerations**

When choosing an implementation, consider the following factors:

* **Performance**: If speed is crucial, a custom implementation might provide better performance, but it requires careful consideration of data structure choices and algorithms.
* **Development complexity**: If simplicity and ease of development are prioritized, using arrays might be a more straightforward choice.
* **Data integrity**: If data mutability needs to be controlled or ensured, the custom implementation provides more control over the underlying data structure.

**Alternatives**

Other alternatives for implementing stack/queue operations include:

* Using libraries like Node.js's built-in `Queue` class or third-party libraries like `bull-queue`.
* Implementing using a data structure like a linked list or circular buffer.
* Utilizing specialized data structures optimized for specific use cases, such as a priority queue.

Keep in mind that each approach has its trade-offs and may be more suitable depending on the specific requirements of your project.

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/116.0.0.0 Safari/537.36

Browser/OS: Chrome 116 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array Shift	1062.8 Ops/sec
Array Pop	31789050.0 Ops/sec
Custom Shift	16700338.0 Ops/sec
Custom Pop	16463451.0 Ops/sec

Related benchmarks:

Array Stack/Queue VS Custom Stack/Queue 2 (version: 9)

Compares Arrays & Shift/Pop against custom non-mutative Stack/Queue implementations.

Comparing performance of: Array Shift vs Array Pop vs Custom Shift vs Custom Pop

Created: 7 years ago by: Registered User

Jump to the latest result

Array Shift

Array Pop

Custom Shift

Custom Pop

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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