Benchmark: Fast queue like - MeasureThat.net

Script Preparation code:

var FreedIds = (function () {
    function FreedIds(maxLength) {
        this._i = 0;
        this._ids = new Array(maxLength);
        this.add2 = this.add;
        this.has2 = this.has;
    }
    FreedIds.prototype.add = function (id) {
        var i = this._i;
        this._ids[i++] = id;
        if (i === length) {
            this._i = 0;
        }
    };
    FreedIds.prototype.has = function (id) {
        return this._ids.indexOf(id) !== -1;
    };
    return FreedIds;
}());
var FreedIds2 = (function () {
    function FreedIds2() {
        this._ids = [];
    }
    FreedIds2.prototype.add = function (id) {
        var ids = this._ids;
      ids.push(id);
        if (ids.length > 300) {
            ids = ids.slice(100, 300);
        }
    };
    return FreedIds2;
}());
var freedIds1 = new FreedIds(200);
var freedIds2 = new FreedIds(200);
var freedIds3 = [];
var freedIds4 = [];
var freedIds5 = new FreedIds2();

Tests:

add
for (var i = 0; i < 400; i++) { freedIds1.add(i); }
add2
for (var i = 0; i < 400; i++) { freedIds2.add2(i); }
shift
for (var i = 0; i < 400; i++) { freedIds3.push(i); if (freedIds3.length > 200) { freedIds3.shift(); } }
slice (fastest)
for (var i = 0; i < 400; i++) { freedIds4.push(i); if (freedIds4.length > 300) { freedIds4 = freedIds4.slice(100, 300); } }
slice in object
for (var i = 0; i < 400; i++) { freedIds5.add(i); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
add
add2
shift
slice (fastest)
slice in object

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

The provided JSON represents a benchmarking test for comparing the performance of different data structures and algorithms in JavaScript.

**Benchmark Definition**

The benchmark definition is a JavaScript function that creates an instance of either `FreedIds` or `FreedIds2`, which are two different implementations of a queue-like data structure. The `FreedIds` class uses a fixed-size array to store elements, while the `FreedIds2` class uses a dynamic array.

The benchmark definition is executed in a loop 400 times, adding a variable number to each instance of the data structure.

**Options Compared**

The options compared in this benchmark are:

1. **Fixed-Size Array (`FreedIds`)**: This implementation uses a fixed-size array to store elements. The size of the array is set to 200.
2. **Dynamic Array (`FreedIds2`)**: This implementation uses a dynamic array to store elements. When the length of the array exceeds 300, it slices the array to keep only the last 200 elements.

**Pros and Cons**

* **Fixed-Size Array (`FreedIds`)**:
	+ Pros: Can be more efficient for predictable workloads, as the size of the array is fixed.
	+ Cons: May require more memory allocation and deallocation overhead, especially when adding a large number of elements.
* **Dynamic Array (`FreedIds2`)**:
	+ Pros: Can adapt to changing workloads and reduce memory allocation overhead.
	+ Cons: May lead to slower performance due to the overhead of dynamic resizing.

**Other Considerations**

* The benchmark also includes tests for pushing an element onto a stack (using `shift`), which can be related to the queue-like behavior of the data structures.
* The use of `slice` in the `FreedIds2` implementation is likely intended to optimize performance by reducing the number of elements that need to be processed.

**Library Used**

There is no explicit library used in this benchmark. However, the `slice` method is a built-in JavaScript function.

**Special JS Feature or Syntax**

None are explicitly mentioned in the provided code snippets.

**Alternatives**

Some alternatives for implementing queue-like data structures in JavaScript include:

1. Using a linked list implementation.
2. Utilizing a library like `queue` or `pQueue`.
3. Implementing a circular buffer.
4. Using a more modern data structure like a `PriorityQueue`.

Keep in mind that the best approach will depend on the specific use case and performance requirements of your application.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3576.0 Safari/537.36

Browser/OS: Chrome 71 on Windows 7

View result in a separate tab

Test name	Executions per second
add	5356.3 Ops/sec
add2	5377.9 Ops/sec
shift	4534.8 Ops/sec
slice (fastest)	9881.6 Ops/sec
slice in object	6574.2 Ops/sec

Related benchmarks:

Fast queue like (version: 6)

Comparing performance of: add vs add2 vs shift vs slice (fastest) vs slice in object

Created: 8 years ago by: Registered User

Jump to the latest result

add

add2

shift

slice (fastest)

slice in object

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