Benchmark: single v double array queue

Script Preparation code:

function createSingleListQueue() {
	return {
		queue: [],
		enqueue(element) {
			this.queue.push(element)
		},
		dequeue() {
			return this.queue.shift()
		},
		isEmpty() {
			return this.queue.length === 0
		}
	}
}

function createDoubleListQueue() {
	return {
		input: [],
		output: [],
		enqueue(element) {
			this.input.push(element)
		},
		dequeue() {
			if(this.output.length === 0) {
				this.pivot()
			}
			return this.output.pop()
		},
		pivot() {
			this.output = this.input.reverse()
			this.input = []
		},
		isEmpty() {
			return this.input.length === 0 && this.output.length === 0
		}
	}
}

var singleQ = createSingleListQueue()
var doubleQ = createDoubleListQueue()
var queueSize = 100000

for(let i = 0; i < queueSize; i++) {
  singleQ.enqueue('testString' + i)
  doubleQ.enqueue('testString' + i)
}

Tests:

single
for(let i = 0; i < 100000; i++) { singleQ.dequeue() }
double
for(let i = 0; i < 100000; i++) { doubleQ.dequeue() }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
single
double

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided JSON benchmark definition and explanation for you.

**Benchmark Definition**

The benchmark is designed to measure the performance of two different queue implementations: single-linked list (single) and double-linked list (double). The queues are created using JavaScript classes, where `singleQ` represents a simple single-linked list, and `doubleQ` represents a more complex double-linked list with additional functionality.

**Script Preparation Code**

The script preparation code defines the two queue classes:

*   `createSingleListQueue`: Creates a single-linked list queue with basic enqueue, dequeue, and isEmpty methods.
*   `createDoubleListQueue`: Creates a double-linked list queue with additional functionality for managing input and output buffers. This class also includes a pivot method that reverses the input buffer when the output buffer is empty.

**Html Preparation Code**

The HTML preparation code is not provided in this example.

**Individual Test Cases**

There are two test cases:

1.  `single`: Measures the execution time of dequeuing from the single-linked list queue 100,000 times.
2.  `double`: Measures the execution time of dequeuing from the double-linked list queue 100,000 times.

**Comparison Options**

The benchmark compares the performance of two different queue implementations:

*   **Single Linked List (single)**: A simple implementation using a single-linked list with basic enqueue and dequeue operations.
*   **Double Linked List (double)**: A more complex implementation using a double-linked list with additional functionality for managing input and output buffers.

**Pros and Cons**

Here are some pros and cons of each approach:

**Single Linked List (single):**

Pros:

*   Simpler to implement
*   Lower memory overhead

Cons:

*   More expensive operations due to the need to traverse the linked list during dequeue
*   May not be suitable for scenarios with high enqueue rates or large input buffers

**Double Linked List (double):**

Pros:

*   Faster operations due to the ability to access adjacent nodes in O(1) time
*   Suitable for scenarios with high enqueue rates or large input buffers

Cons:

*   More complex implementation
*   Higher memory overhead due to the additional buffer management

**Other Considerations**

*   **Cache Locality**: The double-linked list implementation may exhibit better cache locality, which can lead to faster performance.
*   **Parallelization**: Both implementations can be parallelized using multi-threading or concurrent execution, but this would require modifications to the benchmark code.

**Library and Features**

The `Pivot` method in the double-linked list implementation uses a simple buffer management technique. No external libraries are used in this example.

I hope this explanation helps you understand the provided benchmark definition! Let me know if you have any further questions or need additional clarification.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 114 on Windows

View result in a separate tab

Test name	Executions per second
single	168.8 Ops/sec
double	130.5 Ops/sec

Related benchmarks:

single v double array queue (version: 0)

Comparing performance of: single vs double

Created: 8 years ago by: Guest

Jump to the latest result

single

double

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