Offload functions to worker threads with shared memory primitives for Node.js.
refactor: rename pool() to workers()
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
+38
-38
+2
-2
examples/atomics/main.ts
+2
-2
examples/atomics/main.ts
···
3
3
//
4
4
// Run: node examples/atomics/main.ts
5
5
6
-
import { pool, int32atomic } from '../../src/index.ts';
6
+
import { workers, int32atomic } from '../../src/index.ts';
7
7
import { increment } from './increment.ts';
8
8
9
9
const counter = int32atomic();
10
10
11
11
{
12
-
using run = pool(4);
12
+
using run = workers(4);
13
13
14
14
// Fire off 100 increments across 4 workers
15
15
await Promise.all(Array.from({ length: 100 }, () => run(increment(counter))));
+2
-2
examples/non-blocking/main.ts
+2
-2
examples/non-blocking/main.ts
···
4
4
//
5
5
// Run: node examples/non-blocking/main.ts
6
6
7
-
import { pool } from '../../src/index.ts';
7
+
import { workers } from '../../src/index.ts';
8
8
import { fibonacci } from './fibonacci.ts';
9
9
10
10
// Tick a counter on the main thread to prove it's not blocked
···
18
18
console.log('Meanwhile, the main thread keeps ticking:\n');
19
19
20
20
{
21
-
using run = pool(2);
21
+
using run = workers(2);
22
22
const start = performance.now();
23
23
const [a, b] = await Promise.all([run(fibonacci(42)), run(fibonacci(41))]);
24
24
const elapsed = (performance.now() - start).toFixed(0);
+2
-2
examples/parallel-batch/main.ts
+2
-2
examples/parallel-batch/main.ts
···
4
4
//
5
5
// Run: node examples/parallel-batch/main.ts
6
6
7
-
import { pool } from '../../src/index.ts';
7
+
import { workers } from '../../src/index.ts';
8
8
import { heavyWork } from './heavy-work.ts';
9
9
10
10
const items = Array.from({ length: 20 }, (_, i) => i + 1);
···
23
23
let parTime: string;
24
24
console.log('Parallel (worker pool, 4 workers)...');
25
25
{
26
-
using run = pool(4);
26
+
using run = workers(4);
27
27
const parStart = performance.now();
28
28
const parResults = await Promise.all(items.map((item) => run(heavyWork(item))));
29
29
parTime = (performance.now() - parStart).toFixed(0);
+1
-1
src/index.ts
+1
-1
src/index.ts
+6
-6
src/worker-pool.ts
+6
-6
src/worker-pool.ts
···
5
5
6
6
const workerEntryUrl = new URL('./worker-entry.ts', import.meta.url);
7
7
8
-
export function pool(size: number): Runner {
9
-
const workers: Worker[] = [];
8
+
export function workers(size: number): Runner {
9
+
const pool: Worker[] = [];
10
10
for (let i = 0; i < size; i++) {
11
11
const worker = new Worker(workerEntryUrl);
12
12
worker.unref();
13
13
setupWorker(worker);
14
-
workers.push(worker);
14
+
pool.push(worker);
15
15
}
16
16
17
17
let next = 0;
···
20
20
const run: Runner = Object.assign(
21
21
<T>(task: Task<T>): Promise<T> => {
22
22
if (disposed) return Promise.reject(new Error('Worker pool is disposed'));
23
-
const worker = workers[next % workers.length];
23
+
const worker = pool[next % pool.length];
24
24
next++;
25
25
return execute<T>(worker, task.id, task.args);
26
26
},
27
27
{
28
28
[Symbol.dispose]() {
29
29
disposed = true;
30
-
for (const worker of workers) {
30
+
for (const worker of pool) {
31
31
worker.terminate();
32
32
}
33
-
workers.length = 0;
33
+
pool.length = 0;
34
34
},
35
35
},
36
36
);
+2
-2
test/error.test.ts
+2
-2
test/error.test.ts
···
1
1
import { describe, it } from 'node:test';
2
2
import assert from 'node:assert/strict';
3
-
import { pool } from 'moroutine';
3
+
import { workers } from 'moroutine';
4
4
import { fail } from './fixtures/math.ts';
5
5
6
6
describe('error handling', () => {
···
11
11
});
12
12
13
13
it('rejects with error from pool worker', async () => {
14
-
const run = pool(1);
14
+
const run = workers(1);
15
15
try {
16
16
await assert.rejects(() => run(fail('pool boom')), {
17
17
message: 'pool boom',
+6
-6
test/pool.test.ts
+6
-6
test/pool.test.ts
···
1
1
import { describe, it } from 'node:test';
2
2
import assert from 'node:assert/strict';
3
-
import { pool } from 'moroutine';
3
+
import { workers } from 'moroutine';
4
4
import { double, add } from './fixtures/math.ts';
5
5
6
-
describe('pool', () => {
6
+
describe('workers', () => {
7
7
it('executes a moroutine through the pool', async () => {
8
-
const run = pool(2);
8
+
const run = workers(2);
9
9
try {
10
10
const result = await run(double(2));
11
11
assert.equal(result, 4);
···
15
15
});
16
16
17
17
it('handles concurrent calls across pool workers', async () => {
18
-
const run = pool(2);
18
+
const run = workers(2);
19
19
try {
20
20
const results = await Promise.all([run(double(1)), run(double(2)), run(double(3)), run(double(4))]);
21
21
assert.deepEqual(results, [2, 4, 6, 8]);
···
25
25
});
26
26
27
27
it('handles multiple argument moroutines', async () => {
28
-
const run = pool(1);
28
+
const run = workers(1);
29
29
try {
30
30
const result = await run(add(10, 20));
31
31
assert.equal(result, 30);
···
35
35
});
36
36
37
37
it('dispose terminates pool workers', async () => {
38
-
const run = pool(2);
38
+
const run = workers(2);
39
39
await run(double(1));
40
40
run[Symbol.dispose]();
41
41
// After dispose, calls should fail
+5
-5
test/transfer.test.ts
+5
-5
test/transfer.test.ts
···
1
1
import { describe, it } from 'node:test';
2
2
import assert from 'node:assert/strict';
3
-
import { pool, transfer } from 'moroutine';
3
+
import { workers, transfer } from 'moroutine';
4
4
import { sumBuffer, sumUint8, makeBuffer } from './fixtures/transfer.ts';
5
5
6
6
describe('transfer', () => {
···
12
12
view[2] = 3;
13
13
view[3] = 4;
14
14
15
-
const run = pool(1);
15
+
const run = workers(1);
16
16
try {
17
17
const sum = await run(sumBuffer(transfer(buf)));
18
18
assert.equal(sum, 10);
···
27
27
const arr = new Uint8Array([5, 10, 15, 20]);
28
28
const originalBuffer = arr.buffer;
29
29
30
-
const run = pool(1);
30
+
const run = workers(1);
31
31
try {
32
32
const sum = await run(sumUint8(transfer(arr)));
33
33
assert.equal(sum, 50);
···
39
39
});
40
40
41
41
it('auto-transfers return values from worker (zero-copy)', async () => {
42
-
const run = pool(1);
42
+
const run = workers(1);
43
43
try {
44
44
const buf = await run(makeBuffer(4));
45
45
const view = new Uint8Array(buf);
···
58
58
view[2] = 3;
59
59
view[3] = 4;
60
60
61
-
const run = pool(1);
61
+
const run = workers(1);
62
62
try {
63
63
const sum = await run(sumBuffer(buf));
64
64
assert.equal(sum, 10);