Tinypool - the node.js worker pool 🧵

Piscina: A fast, efficient Node.js Worker Thread Pool implementation

Tinypool is a fork of piscina. What we try to achieve in this library, is to eliminate some dependencies and features that our target users don't need (currently, our main user will be Vitest). Tinypool's install size (38KB) can then be smaller than Piscina's install size (6MB). If you need features like utilization or NAPI, Piscina is a better choice for you. We think that Piscina is an amazing library, and we may try to upstream some of the dependencies optimization in this fork.

• ✅ Smaller install size, 38KB

• ✅ Minimal

• ✅ No dependencies

• ✅ Physical cores instead of Logical cores with physical-cpu-count

• ✅ Supports worker_threads and child_process

• ❌ No utilization

• ❌ No NAPI

• Written in TypeScript, and ESM support only. For Node.js 18.x and higher.

In case you need more tiny libraries like tinypool or tinyspy, please consider submitting an RFC

Example

Using node:worker_threads

Basic usage

1// main.mjs
2import Tinypool from 'tinypool'
3
4const pool = new Tinypool({
5  filename: new URL('./worker.mjs', import.meta.url).href,
6})
7const result = await pool.run({ a: 4, b: 6 })
8console.log(result) // Prints 10
9
10// Make sure to destroy pool once it's not needed anymore
11// This terminates all pool's idle workers
12await pool.destroy()

1// worker.mjs
2export default ({ a, b }) => {
3  return a + b
4}

Main thread <-> worker thread communication

1// main.mjs
2import Tinypool from 'tinypool'
3import { MessageChannel } from 'node:worker_threads'
4
5const pool = new Tinypool({
6  filename: new URL('./worker.mjs', import.meta.url).href,
7})
8const { port1, port2 } = new MessageChannel()
9const promise = pool.run({ port: port1 }, { transferList: [port1] })
10
11port2.on('message', (message) => console.log('Main thread received:', message))
12setTimeout(() => port2.postMessage('Hello from main thread!'), 1000)
13
14await promise
15
16port1.close()
17port2.close()

1// worker.mjs
2export default ({ port }) => {
3  return new Promise((resolve) => {
4    port.on('message', (message) => {
5      console.log('Worker received:', message)
6
7      port.postMessage('Hello from worker thread!')
8      resolve()
9    })
10  })
11}

Using node:child_process

Basic usage

1// main.mjs
2import Tinypool from 'tinypool'
3
4const pool = new Tinypool({
5  runtime: 'child_process',
6  filename: new URL('./worker.mjs', import.meta.url).href,
7})
8const result = await pool.run({ a: 4, b: 6 })
9console.log(result) // Prints 10

1// worker.mjs
2export default ({ a, b }) => {
3  return a + b
4}

Main process <-> worker process communication

1// main.mjs
2import Tinypool from 'tinypool'
3
4const pool = new Tinypool({
5  runtime: 'child_process',
6  filename: new URL('./worker.mjs', import.meta.url).href,
7})
8
9const messages = []
10const listeners = []
11const channel = {
12  onMessage: (listener) => listeners.push(listener),
13  postMessage: (message) => messages.push(message),
14}
15
16const promise = pool.run({}, { channel })
17
18// Send message to worker
19setTimeout(
20  () => listeners.forEach((listener) => listener('Hello from main process')),
21  1000
22)
23
24// Wait for task to finish
25await promise
26
27console.log(messages)
28// [{ received: 'Hello from main process', response: 'Hello from worker' }]

1// worker.mjs
2export default async function run() {
3  return new Promise((resolve) => {
4    process.on('message', (message) => {
5      // Ignore Tinypool's internal messages
6      if (message?.__tinypool_worker_message__) return
7
8      process.send({ received: message, response: 'Hello from worker' })
9      resolve()
10    })
11  })
12}

API

We have a similar API to Piscina, so for more information, you can read Piscina's detailed documentation and apply the same techniques here.

Tinypool specific APIs

Pool constructor options

• isolateWorkers: Disabled by default. Always starts with a fresh worker when running tasks to isolate the environment.
• terminateTimeout: Disabled by default. If terminating a worker takes terminateTimeout amount of milliseconds to execute, an error is raised.
• maxMemoryLimitBeforeRecycle: Disabled by default. When defined, the worker's heap memory usage is compared against this value after task has been finished. If the current memory usage exceeds this limit, worker is terminated and a new one is started to take its place. This option is useful when your tasks leak memory and you don't want to enable isolateWorkers option.
• runtime: Used to pick worker runtime. Default value is worker_threads.
  • worker_threads: Runs workers in node:worker_threads. For main thread <-> worker thread communication you can use MessagePort in the pool.run() method's transferList option. See example.
  • child_process: Runs workers in node:child_process. For main thread <-> worker process communication you can use TinypoolChannel in the pool.run() method's channel option. For filtering out the Tinypool's internal messages see TinypoolWorkerMessage. See example.

Pool methods

• cancelPendingTasks(): Gracefully cancels all pending tasks without stopping or interfering with on-going tasks. This method is useful when your tasks may have side effects and should not be terminated forcefully during task execution. If your tasks don't have any side effects you may want to use { signal } option for forcefully terminating all tasks, including the on-going ones, instead.
• recycleWorkers(options): Waits for all current tasks to finish and re-creates all workers. Can be used to force isolation imperatively even when isolateWorkers is disabled. Accepts { runtime } option as argument.

Exports

• workerId: Each worker now has an id ( <= maxThreads) that can be imported from tinypool in the worker itself (or process.__tinypool_state__.workerId).

Authors

Mohammad Bagher

Sponsors

Your sponsorship can make a huge difference in continuing our work in open source!

Credits

The Vitest team for giving me the chance of creating and maintaing this project for vitest.

Piscina, because Tinypool is not more than a friendly fork of piscina.