Benchmark: Queue Test - MeasureThat.net

HTML Preparation code:

<script>
    class Queue {
        #offset;
        #last;
        #elements;

        constructor(...elems) {
            this.#elements = elems;
            this.#offset = 0;
            this.#last = this.#elements.length;
        };

        queue(elem) {
            this.#elements.push(elem);
            this.#last++;
        };

        dequeue() {
            if (!this.isEmpty()) {
                const out = this.#elements[this.#offset];
                this.#elements[this.#offset++] = null;

                return out;
            } else {
                this.#elements = [];
                this.#last = 0;
            }

            return null;
        };

        isEmpty() {
            return this.length <= 0;
        };

        get length() {
            return (this.#last - 1) - this.#offset;
        };
    }

    class QueueWithShift {
        constructor() {
            this.storage = [];
        };

        queue(element) {
            this.storage.push(element);
        };

        dequeue() {
            if (!this.isEmpty()) {
                this.storage.shift();
            } else {
                console.log('Queue is empty');
            }
        };

        isEmpty() {
            if (this.storage.length === 0) {
                return true;
            } else {
                return false;
            }
        };
    }
</script>

Script Preparation code:

var q1 = new Queue();
var qws1 = new QueueWithShift();
for (let i = 0; i < 1_000; i++) {
  q1.queue(i);
  qws1.queue(i);
}

var q2 = new Queue();
var qws2 = new QueueWithShift();
for (let i = 0; i < 10_000; i++) {
  q2.queue(i);
  qws2.queue(i);
}

var q3 = new Queue();
var qws3 = new QueueWithShift();
for (let i = 0; i < 1_000_000; i++) {
  q3.queue(i);
  qws3.queue(i);
}

Tests:

1000 elements - Queue
while (!q1.isEmpty()) { q1.dequeue(); }
1000 elements - QueueWithShift
while (!qws1.isEmpty()) { qws1.dequeue(); }
10000 elements - Queue
while (!q2.isEmpty()) { q2.dequeue(); }
10000 elements - QueueWithShift
while (!qws2.isEmpty()) { qws2.dequeue(); }
1000000 elements - Queue
while (!q3.isEmpty()) { q3.dequeue(); }
1000000 elements - QueueWithShift
while (!qws3.isEmpty()) { qws3.dequeue(); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
1000 elements - Queue
1000 elements - QueueWithShift
10000 elements - Queue
10000 elements - QueueWithShift
1000000 elements - Queue
1000000 elements - QueueWithShift

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The test measures the performance of two queue data structures:

1. `Queue`: A simple, tail-based queue with a fixed-size array.
2. `QueueWithShift`: An in-memory queue that uses JavaScript's built-in `shift()` method to remove elements from the front.

**Test Cases**

Each test case consists of a single benchmark definition, which is a loop that continuously dequeues elements from the queue until it's empty. The number of elements to process varies between 1000, 10,000, and 1,000,000.

**Options Being Compared**

The two main options being compared are:

1. **`Queue`**: A simple, tail-based queue with a fixed-size array.
2. **`QueueWithShift`**: An in-memory queue that uses JavaScript's built-in `shift()` method to remove elements from the front.

**Pros and Cons of Each Approach**

**`Queue`**

Pros:

* Simple to implement
* Predictable performance due to fixed-size array

Cons:

* Limited size (fixed)
* May require more memory allocation and deallocation

**`QueueWithShift`**

Pros:

* More flexible in terms of size and performance
* Reuses existing JavaScript function (`shift()`)

Cons:

* Performance may vary depending on the browser's `shift()` implementation
* Additional overhead due to method call

**Other Considerations**

* The benchmark uses Chrome 89 as the test browser, which may affect the results.
* Device platform (Desktop) and operating system (Windows) are specified, but might not be relevant for web-based applications.

**Benchmark Results**

The latest benchmark results show varying performance across different test cases and queue implementations. `QueueWithShift` tends to perform better than `Queue`, especially for larger data sets. However, the actual performance difference may depend on various factors, such as browser version, JavaScript engine, and system configuration.

Keep in mind that this is a simplified analysis, and there might be additional factors affecting the benchmark results not mentioned here.

Related benchmarks:

Queue Test (version: 0)

Comparing performance of: 1000 elements - Queue vs 1000 elements - QueueWithShift vs 10000 elements - Queue vs 10000 elements - QueueWithShift vs 1000000 elements - Queue vs 1000000 elements - QueueWithShift

Created: 5 years ago by: Guest

Jump to the latest result

1000 elements - Queue

1000 elements - QueueWithShift

10000 elements - Queue

10000 elements - QueueWithShift

1000000 elements - Queue

1000000 elements - QueueWithShift

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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