feat: Use fixed queue

README.md

@@ -702,6 +702,56 @@ options on to the custom `TaskQueue` implementation. (Note that because the
 queue options are set as a property on the task, tasks with queue
 options cannot be submitted as JavaScript primitives).
 
+**New:** As of the next major release, Piscina introduces the `FixedQueue`, a more performant task queue implementation based on [`FixedQueue`](https://github.com/nodejs/node/blob/de7b37880f5a541d5f874c1c2362a65a4be76cd0/lib/internal/fixed_queue.js) from Node.Js project.  
+
+Here are some benchmarks to compare new `FixedQueue` with `ArrayTaskQueue` (current default). The benchmarks demonstrate substantial improvements in push and shift operations, especially with larger queue sizes.
+```
+Queue size = 1000
+┌─────────┬─────────────────────────────────────────┬───────────┬────────────────────┬──────────┬─────────┐
+│ (index) │ Task Name                               │ ops/sec   │ Average Time (ns)  │ Margin   │ Samples │
+├─────────┼─────────────────────────────────────────┼───────────┼────────────────────┼──────────┼─────────┤
+│ 0       │ 'ArrayTaskQueue full push + full shift' │ '9 692'   │ 103175.15463917515 │ '±0.80%' │ 970     │
+│ 1       │ 'FixedQueue  full push + full shift'    │ '131 879' │ 7582.696390658352  │ '±1.81%' │ 13188   │
+└─────────┴─────────────────────────────────────────┴───────────┴────────────────────┴──────────┴─────────┘
+
+Queue size = 100_000
+┌─────────┬─────────────────────────────────────────┬─────────┬────────────────────┬──────────┬─────────┐
+│ (index) │ Task Name                               │ ops/sec │ Average Time (ns)  │ Margin   │ Samples │
+├─────────┼─────────────────────────────────────────┼─────────┼────────────────────┼──────────┼─────────┤
+│ 0       │ 'ArrayTaskQueue full push + full shift' │ '0'     │ 1162376920.0000002 │ '±1.77%' │ 10      │
+│ 1       │ 'FixedQueue full push + full shift'     │ '1 026' │ 974328.1553396407  │ '±2.51%' │ 103     │
+└─────────┴─────────────────────────────────────────┴─────────┴────────────────────┴──────────┴─────────┘
+```
+In terms of Piscina performance itself, using `FixedQueue` with a queue size of 100,000 queued tasks can result in up to 6 times faster execution times.
+
+Users can import `FixedQueue` from the `Piscina` package and pass it as the `taskQueue` option to leverage its benefits.
+
+
+### Using FixedQueue Example
+
+Here's an example of how to use the `FixedQueue`:
+
+```js
+const { Piscina, FixedQueue } = require('piscina');
+const { resolve } = require('path');
+
+// Create a Piscina pool with FixedQueue
+const piscina = new Piscina({
+  filename: resolve(__dirname, 'worker.js'),
+  taskQueue: new FixedQueue()
+});
+
+// Submit tasks to the pool
+for (let i = 0; i < 10; i++) {
+  piscina.runTask({ data: i }).then((result) => {
+    console.log(result);
+  }).catch((error) => {
+    console.error(error);
+  });
+}
+```
+In this example, we import `FixedQueue` from the `piscina` package and use it as the `taskQueue` option when creating a new Piscina pool. This allows users to take advantage of the performance improvements offered by `FixedQueue` before it becomes the default task queue implementation.
+
 ## Current Limitations (Things we're working on / would love help with)
 
 * Improved Documentation

benchmark/piscina-queue-comparison.js

@@ -0,0 +1,42 @@
+const { Bench } = require('tinybench');
+const { Piscina, FixedQueue, ArrayTaskQueue } = require('..');
+const { resolve } = require('node:path');
+
+const QUEUE_SIZE = 100_000;
+
+const bench = new Bench({ time: 100 });
+
+bench
+  .add('Piscina with ArrayTaskQueue', async () => {
+    const queue = new ArrayTaskQueue();
+    const pool = new Piscina({
+      filename: resolve(__dirname, 'fixtures/add.js'),
+      taskQueue: queue
+    });
+    const tasks = [];
+    for (let i = 0; i < QUEUE_SIZE; i++) {
+      tasks.push(pool.runTask({ a: 4, b: 6 }));
+    }
+    await Promise.all(tasks);
+    await pool.destroy();
+  })
+  .add('Piscina with FixedQueue', async () => {
+    const queue = new FixedQueue();
+    const pool = new Piscina({
+      filename: resolve(__dirname, 'fixtures/add.js'),
+      taskQueue: queue
+    });
+    const tasks = [];
+    for (let i = 0; i < QUEUE_SIZE; i++) {
+      tasks.push(pool.runTask({ a: 4, b: 6 }));
+    }
+    await Promise.all(tasks);
+    await pool.destroy();
+  });
+
+(async () => {
+  await bench.warmup();
+  await bench.run();
+
+  console.table(bench.table());
+})();

benchmark/queue-comparison.js

@@ -0,0 +1,33 @@
+const { Bench } = require('tinybench');
+const { ArrayTaskQueue, FixedQueue } = require('..');
+
+const QUEUE_SIZE = 100_000;
+
+const bench = new Bench({ time: 100 });
+
+bench
+  .add('ArrayTaskQueue full push + full shift', async () => {
+    const queue = new ArrayTaskQueue();
+    for (let i = 0; i < QUEUE_SIZE; i++) {
+      queue.push(i);
+    }
+    for (let i = 0; i < QUEUE_SIZE; i++) {
+      queue.shift();
+    }
+  })
+  .add('FixedQueue full push + full shift', async () => {
+    const queue = new FixedQueue();
+    for (let i = 0; i < QUEUE_SIZE; i++) {
+      queue.push(i);
+    }
+    for (let i = 0; i < QUEUE_SIZE; i++) {
+      queue.shift();
+    }
+  });
+
+(async () => {
+  await bench.warmup();
+  await bench.run();
+
+  console.table(bench.table());
+})();

benchmark/simple-benchmark-fixed-queue.js

@@ -0,0 +1,33 @@
+'use strict';
+const { Piscina, FixedQueue } = require('..');
+
+const { resolve } = require('path');
+
+async function simpleBenchmark ({ duration = 10000 } = {}) {
+  const pool = new Piscina({
+    filename: resolve(__dirname, 'fixtures/add.js'),
+    taskQueue: new FixedQueue()
+  });
+  let done = 0;
+
+  const results = [];
+  const start = process.hrtime.bigint();
+  while (pool.queueSize === 0) {
+    results.push(scheduleTasks());
+  }
+
+  async function scheduleTasks () {
+    while ((process.hrtime.bigint() - start) / 1_000_000n < duration) {
+      await pool.runTask({ a: 4, b: 6 });
+      done++;
+    }
+  }
+
+  await Promise.all(results);
+
+  return done / duration * 1e3;
+}
+
+simpleBenchmark().then((opsPerSecond) => {
+  console.log(`opsPerSecond: ${opsPerSecond} (with FixedQueue as taskQueue)`);
+});

benchmark/simple-benchmark.js

@@ -25,5 +25,5 @@ async function simpleBenchmark ({ duration = 10000 } = {}) {
 }
 
 simpleBenchmark().then((opsPerSecond) => {
-  console.log(`opsPerSecond: ${opsPerSecond}`);
+  console.log(`opsPerSecond: ${opsPerSecond} (with default taskQueue)`);
 });

package.json

@@ -15,7 +15,12 @@
     "test": "c8 tap",
     "test:ci": "npm run lint && npm run build && npm run test:coverage",
     "test:coverage": "c8 --reporter=lcov tap --cov",
-    "prepack": "npm run build"
+    "prepack": "npm run build",
+    "bench": "npm run benchmark:piscina-default && npm run benchmark:piscina-fixed-queue && npm run benchmark:queue-comparison && npm run benchmark:piscina-comparison",
+    "benchmark:piscina-default": "node benchmark/simple-benchmark.js",
+    "benchmark:piscina-fixed-queue": "node benchmark/simple-benchmark-fixed-queue.js",
+    "benchmark:queue-comparison": "node benchmark/queue-comparison.js",
+    "benchmark:piscina-comparison": "node benchmark/piscina-queue-comparison.js"
   },
   "repository": {
     "type": "git",
@@ -44,6 +49,7 @@
     "snazzy": "^9.0.0",
     "standardx": "^7.0.0",
     "tap": "^16.3.7",
+    "tinybench": "^2.8.0",
     "ts-node": "^10.9.2",
     "typescript": "5.4.5"
   },