perf: optimization perfomance

[PandaWorker]

Code

interface ReusifyItem {
	next: this | null;
}

function reusify<T extends ReusifyItem>(Constructor: new () => T) {
	let head: T | null = null;
	let tail: T | null = null;

	head = tail = new Constructor();

	function acquire(): T {
		var current = head;

		if (current?.next) {
			head = current.next;
		} else {
			tail = head = new Constructor();
		}

		current!.next = null;

		return current!;
	}

	function release(obj: T) {
		tail!.next = obj;
		tail = obj;
	}

	return {
		acquire: acquire,
		release: release,
	};
}

class Reusify<T extends ReusifyItem> {
	private head: T | null;
	private tail: T | null;
	private Constructor: new () => T;

	constructor(Constructor: new () => T) {
		this.tail = this.head = new Constructor();
		this.Constructor = Constructor;
	}

	public acquire(): T {
		var current = this.head;

		if (current?.next) {
			this.head = current.next;
			current.next = null;
		} else {
			this.tail = this.head = new this.Constructor();
		}

		return current!;
	}

	public release(obj: T): void {
		this.tail = this.tail!.next = obj;
	}
}

Tests and benchmarks

// tests
import assert from 'node:assert/strict';

class Task {
	next = null;
}

function MyTask() {
	// @ts-expect-error:
	this.next = null;
}

Deno.test({
	name: 'func (task instance class)',
	fn: () => {
		const instance = reusify(Task);

		var obj = instance.acquire();
		var obj2 = instance.acquire();
		var obj3 = instance.acquire();

		assert(obj !== obj2);
		assert(obj2 !== obj3);
		assert(obj3 !== obj);

		assert.notEqual(obj, obj2);
		assert.notEqual(obj2, obj3);
		assert.notEqual(obj3, obj);

		assert.equal(obj.next, null);
		assert.equal(obj2.next, null);
		assert.equal(obj3.next, null);

		instance.release(obj);
		instance.release(obj2);
		instance.release(obj3);

		// skip one
		instance.acquire();

		var obj4 = instance.acquire();
		var obj5 = instance.acquire();
		var obj6 = instance.acquire();

		assert(obj4 === obj, '4');
		assert(obj5 === obj2, '5');
		assert(obj6 === obj3, '6');
	},
});

Deno.test({
	name: 'func (task instance object or func)',
	fn: () => {
		const instance = reusify(Task);

		var obj = instance.acquire();
		var obj2 = instance.acquire();
		var obj3 = instance.acquire();

		assert(obj !== obj2);
		assert(obj2 !== obj3);
		assert(obj3 !== obj);

		assert.notEqual(obj, obj2);
		assert.notEqual(obj2, obj3);
		assert.notEqual(obj3, obj);

		assert.equal(obj.next, null);
		assert.equal(obj2.next, null);
		assert.equal(obj3.next, null);

		instance.release(obj);
		instance.release(obj2);
		instance.release(obj3);

		// skip one
		instance.acquire();

		var obj4 = instance.acquire();
		var obj5 = instance.acquire();
		var obj6 = instance.acquire();

		assert(obj4 === obj, '4');
		assert(obj5 === obj2, '5');
		assert(obj6 === obj3, '6');
	},
});

Deno.test({
	name: 'class (task instance object or func)',
	fn: () => {
		// @ts-expect-error:
		const instance = new Reusify(MyTask);

		var obj = instance.acquire();
		var obj2 = instance.acquire();
		var obj3 = instance.acquire();

		assert(obj !== obj2);
		assert(obj2 !== obj3);
		assert(obj3 !== obj);

		assert.notEqual(obj, obj2);
		assert.notEqual(obj2, obj3);
		assert.notEqual(obj3, obj);

		assert.equal(obj.next, null);
		assert.equal(obj2.next, null);
		assert.equal(obj3.next, null);

		instance.release(obj);
		instance.release(obj2);
		instance.release(obj3);

		// skip one
		instance.acquire();

		var obj4 = instance.acquire();
		var obj5 = instance.acquire();
		var obj6 = instance.acquire();

		assert(obj4 === obj, '4');
		assert(obj5 === obj2, '5');
		assert(obj6 === obj3, '6');
	},
});

Deno.test({
	name: 'class (task instance class)',
	fn: () => {
		const instance = new Reusify(Task);

		var obj = instance.acquire();
		var obj2 = instance.acquire();
		var obj3 = instance.acquire();

		assert(obj !== obj2);
		assert(obj2 !== obj3);
		assert(obj3 !== obj);

		assert.notEqual(obj, obj2);
		assert.notEqual(obj2, obj3);
		assert.notEqual(obj3, obj);

		assert.equal(obj.next, null);
		assert.equal(obj2.next, null);
		assert.equal(obj3.next, null);

		instance.release(obj);
		instance.release(obj2);
		instance.release(obj3);

		// skip one
		instance.acquire();

		var obj4 = instance.acquire();
		var obj5 = instance.acquire();
		var obj6 = instance.acquire();

		assert(obj4 === obj, '4');
		assert(obj5 === obj2, '5');
		assert(obj6 === obj3, '6');
	},
});

// benchmarks
Deno.bench({
	name: 'func (taks instance func)',
	group: 'reusify',
	fn: () => {
		// @ts-expect-error:
		const queue = reusify(MyTask);

		for (let i = 0; i < 10_000; i++) {
			const task1 = queue.acquire();
			const task2 = queue.acquire();
			const task3 = queue.acquire();

			queue.release(task1);
			queue.release(task2);
			queue.release(task3);
		}
	},
});

Deno.bench({
	name: 'class (task instance func)',
	group: 'reusify',
	fn: () => {
		// @ts-expect-error:
		const queue = new Reusify(MyTask);
		
		for (let i = 0; i < 10_000; i++) {
			const task1 = queue.acquire();
			const task2 = queue.acquire();
			const task3 = queue.acquire();

			queue.release(task1);
			queue.release(task2);
			queue.release(task3);
		}
	},
});

Deno.bench({
	name: 'func (task instance class)',
	group: 'reusify',
	fn: () => {
		const queue = reusify(Task);

		for (let i = 0; i < 10_000; i++) {
			const task1 = queue.acquire();
			const task2 = queue.acquire();
			const task3 = queue.acquire();

			queue.release(task1);
			queue.release(task2);
			queue.release(task3);
		}
	},
});

Deno.bench({
	name: 'class (task instance class)',
	group: 'reusify',
	fn: () => {
		const queue = new Reusify(Task);
		
		for (let i = 0; i < 10_000; i++) {
			const task1 = queue.acquire();
			const task2 = queue.acquire();
			const task3 = queue.acquire();

			queue.release(task1);
			queue.release(task2);
			queue.release(task3);
		}
	},
});

Benchmarks results

    CPU | Apple M1 Max
Runtime | Deno 1.46.3 (aarch64-apple-darwin)


benchmark                     time/iter (avg)        iter/s      (min … max)           p75      p99     p995
----------------------------- ----------------------------- --------------------- --------------------------

group reusify
func (taks instance func)            130.3 µs         7,673 (128.2 µs … 253.1 µs) 131.3 µs 147.0 µs 153.8 µs
class (task instance func)            82.8 µs        12,070 ( 78.0 µs … 286.2 µs)  82.9 µs 107.2 µs 117.5 µs
func (task instance class)           181.7 µs         5,503 (172.0 µs … 372.2 µs) 183.1 µs 213.1 µs 228.7 µs
class (task instance class)          112.6 µs         8,881 (108.5 µs … 304.2 µs) 112.5 µs 152.2 µs 160.5 µs

summary
  class (task instance func)
     1.36x faster than class (task instance class)
     1.57x faster than func (taks instance func)
     2.19x faster than func (task instance class)

[mcollina]

Wow, seems nicer! Would you like to send a PR?

[SukkaW]

@mcollina IIUC this would introduce a breaking change, i.e. reusify currently is a function but the proposed API is a class (from reusify(Clazz) to new Reusify(Clazz)).

My instinct told me that this performance boost came from v8 optimizing the hidden classes of Reusify itself (i.e. optimizing frequent acquire and release invocation).

IMHO the benchmark should be done on Node.js as well.

[SukkaW]

Just modify the current reusify benchmark (to use mitata):

clk: ~3.18 GHz
cpu: Apple M2 Max
runtime: node 22.11.0 (arm64-darwin)

benchmark                   avg (min … max) p75   p99    (min … top 1%)
------------------------------------------- -------------------------------
• reusify vs foxts/reusify
------------------------------------------- -------------------------------
baseline                     470.13 ns/iter 483.59 ns      █▇█▃▆▄▃▃
                    (434.56 ns … 529.30 ns) 514.87 ns ▆▇▇▃████████████▅▃▄▃▂
                  3.84 ipc (  2.86% stalls)  97.99% L1 data cache
          1.62k cycles   6.24k instructions  26.54% retired LD/ST (  1.66k)

reusify                      454.40 ns/iter 467.62 ns      █▇▅▂▅▆ ▃▃
                    (420.73 ns … 519.28 ns) 498.06 ns ▆█▇▃███████████▇▅▅▅▂▁
                  3.97 ipc (  2.25% stalls)  98.59% L1 data cache
          1.56k cycles   6.21k instructions  26.43% retired LD/ST (  1.64k)

Reusify as class             516.41 ns/iter 554.43 ns  █▃      ▄▂▃▃
                    (439.39 ns … 676.96 ns) 633.12 ns ▅██▆▅▄▂▁▄████▆█▅▂▂▁▁▂
                  3.94 ipc (  2.36% stalls)  98.15% L1 data cache
          1.80k cycles   7.09k instructions  27.77% retired LD/ST (  1.97k)

For some reasons, the proposed Reusify is actually slower than the current reusify.

[PandaWorker]

reusify.ts

interface ReusifyItem {
	next: this | null;
}

export function reusify<T extends ReusifyItem>(Constructor: new () => T) {
	let head: T | null = null;
	let tail: T | null = null;

	head = tail = new Constructor();

	function acquire(): T {
		var current = head;

		if (current?.next) {
			head = current.next;
		} else {
			tail = head = new Constructor();
		}

		current!.next = null;

		return current!;
	}

	function release(obj: T) {
		tail!.next = obj;
		tail = obj;
	}

	return {
		acquire: acquire,
		release: release,
	};
}

export class Reusify<T extends ReusifyItem> {
	private head: T | null;
	private tail: T | null;
	private Constructor: new () => T;

	constructor(Constructor: new () => T) {
		this.tail = this.head = new Constructor();
		this.Constructor = Constructor;
	}

	public acquire(): T {
		var current = this.head;

		if (current?.next) {
			this.head = current.next;
			current.next = null;
		} else {
			this.tail = this.head = new this.Constructor();
		}

		return current!;
	}

	public release(obj: T): void {
		this.tail = this.tail!.next = obj;
	}
}

reusify.bench.ts

import { bench, run, summary } from 'mitata';
import { Reusify, reusify } from './reusify.ts';

class Task {
	next = null;
}

function MyTask() {
	// @ts-expect-error:
	this.next = null;
}

function MyTaskNew() {
	return { next: null };
}

summary(() => {
	bench('func (taks instance func)', () => {
		// @ts-expect-error:
		const queue = reusify(MyTaskNew);

		for (let i = 0; i < 10_000; i++) {
			const task1 = queue.acquire();
			const task2 = queue.acquire();
			const task3 = queue.acquire();

			queue.release(task1);
			queue.release(task2);
			queue.release(task3);
		}
	});

	bench('class (task instance func)', () => {
		// @ts-expect-error:
		const queue = new Reusify(MyTaskNew);

		for (let i = 0; i < 10_000; i++) {
			const task1 = queue.acquire();
			const task2 = queue.acquire();
			const task3 = queue.acquire();

			queue.release(task1);
			queue.release(task2);
			queue.release(task3);
		}
	});

	bench('func (task instance class)', () => {
		const queue = reusify(Task);

		for (let i = 0; i < 10_000; i++) {
			const task1 = queue.acquire();
			const task2 = queue.acquire();
			const task3 = queue.acquire();

			queue.release(task1);
			queue.release(task2);
			queue.release(task3);
		}
	});

	bench('class (task instance class)', () => {
		const queue = new Reusify(Task);

		for (let i = 0; i < 10_000; i++) {
			const task1 = queue.acquire();
			const task2 = queue.acquire();
			const task3 = queue.acquire();

			queue.release(task1);
			queue.release(task2);
			queue.release(task3);
		}
	});
});

run();

bench node/deno/bun

clk: ~3.03 GHz
cpu: Apple M1 Max
runtime: node 22.12.0 (arm64-darwin)

benchmark                   avg (min … max) p75   p99    (min … top 1%)
------------------------------------------- -------------------------------
func (taks instance func)    154.14 µs/iter 150.88 µs █                    
                    (143.04 µs … 777.71 µs) 354.71 µs ██▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▂▁
class (task instance func)   104.18 µs/iter  92.00 µs █                    
                     (87.38 µs … 491.75 µs) 251.13 µs █▆▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▂▁
func (task instance class)   196.50 µs/iter 186.83 µs █                    
                    (183.58 µs … 909.00 µs) 368.71 µs █▃▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▂▁
class (task instance class)  157.25 µs/iter 116.04 µs █                    
                    (108.46 µs … 418.83 µs) 319.54 µs █▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▅▁

summary
  class (task instance func)
   1.48x faster than func (taks instance func)
   1.51x faster than class (task instance class)
   1.89x faster than func (task instance class)

clk: ~3.12 GHz
cpu: Apple M1 Max
runtime: deno 2.1.4 (aarch64-apple-darwin)

benchmark                   avg (min … max) p75   p99    (min … top 1%)
------------------------------------------- -------------------------------
func (taks instance func)    127.60 µs/iter 128.33 µs        █             
                    (116.71 µs … 333.21 µs) 148.46 µs ▄▁▁▁▁▃▅█▂▂▃▁▁▁▁▁▁▁▁▁▁
class (task instance func)    87.70 µs/iter  84.96 µs █                    
                     (83.63 µs … 328.83 µs) 284.58 µs █▃▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
func (task instance class)   169.64 µs/iter 177.63 µs                █     
                    (130.21 µs … 371.54 µs) 191.42 µs ▅▁▁▁▁▁▁▁▁▁▁▁▁▁▂█▆▁▁▁▁
class (task instance class)  114.85 µs/iter 112.00 µs █                    
                    (107.04 µs … 439.38 µs) 395.79 µs █▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁

summary
  class (task instance func)
   1.31x faster than class (task instance class)
   1.46x faster than func (taks instance func)
   1.93x faster than func (task instance class)

clk: ~3.15 GHz
cpu: Apple M1 Max
runtime: bun 1.1.42 (arm64-darwin)

benchmark                   avg (min … max) p75   p99    (min … top 1%)
------------------------------------------- -------------------------------
func (taks instance func)    118.85 µs/iter 117.92 µs █                    
                    (117.67 µs … 213.58 µs) 139.54 µs █▁▁▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
class (task instance func)    43.77 µs/iter  44.04 µs     █                
                     (40.54 µs … 129.13 µs)  50.54 µs ▁▁▁▁█▄▂▂▂▂▄▁▁▁▁▁▁▁▁▁▁
func (task instance class)   161.05 µs/iter 159.83 µs █                    
                    (159.54 µs … 278.38 µs) 181.00 µs █▁▁▃▁▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
class (task instance class)   48.56 µs/iter  47.96 µs   █                  
                     (46.33 µs … 173.29 µs)  64.21 µs ▁██▂▁▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁

summary
  class (task instance func)
   1.11x faster than class (task instance class)
   2.72x faster than func (taks instance func)
   3.68x faster than func (task instance class)

[PandaWorker]

bench with @mitata/counters

clk: ~3.04 GHz
cpu: Apple M1 Max
runtime: node 22.12.0 (arm64-darwin)

benchmark                   avg (min … max) p75   p99    (min … top 1%)
------------------------------------------- -------------------------------
func (taks instance func)    160.17 µs/iter 150.92 µs █                    
                      (143.04 µs … 1.62 ms) 363.79 µs █▇▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▂▁▁
                  6.73 ipc (  0.02% stalls)    NaN% L1 data cache
        505.53k cycles   3.40M instructions   0.00% retired LD/ST (   0.00)

class (task instance func)   103.44 µs/iter  89.67 µs █                    
                     (87.38 µs … 547.92 µs) 248.71 µs █▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▂▁
                  6.19 ipc (  0.01% stalls)    NaN% L1 data cache
        337.89k cycles   2.09M instructions   0.00% retired LD/ST (   0.00)

func (task instance class)   195.37 µs/iter 184.38 µs █                    
                    (183.38 µs … 911.21 µs) 366.63 µs █▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▂
                  6.17 ipc (  0.01% stalls)    NaN% L1 data cache
        634.96k cycles   3.92M instructions   0.00% retired LD/ST (   0.00)

class (task instance class)  140.68 µs/iter 112.08 µs █                    
                    (108.46 µs … 385.92 µs) 317.63 µs █▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▄▁
                  6.37 ipc (  0.01% stalls)    NaN% L1 data cache
        455.95k cycles   2.90M instructions   0.00% retired LD/ST (   0.00)

summary
  class (task instance func)
   1.36x faster than class (task instance class)
   1.55x faster than func (taks instance func)
   1.89x faster than func (task instance class)

clk: ~3.13 GHz
cpu: Apple M1 Max
runtime: deno 2.1.4 (aarch64-apple-darwin)

benchmark                   avg (min … max) p75   p99    (min … top 1%)
------------------------------------------- -------------------------------
func (taks instance func)    132.03 µs/iter 134.38 µs           █          
                    (116.75 µs … 387.08 µs) 150.71 µs ▂▃▁▁▁▄▁▄▁▂█▃▃▂▁▁▁▁▁▁▁
                  6.30 ipc (  0.01% stalls)    NaN% L1 data cache
        426.06k cycles   2.68M instructions   0.00% retired LD/ST (   0.00)

class (task instance func)    86.11 µs/iter  84.92 µs  ▄█                  
                     (83.63 µs … 420.71 µs)  96.63 µs ▂██▁▁▂▂▁▁▂▃▁▁▁▁▁▁▁▁▁▁
                  6.08 ipc (  0.01% stalls)    NaN% L1 data cache
        281.76k cycles   1.71M instructions   0.00% retired LD/ST (   0.00)

func (task instance class)   170.89 µs/iter 177.71 µs               █      
                    (130.17 µs … 359.75 µs) 196.83 µs ▅▁▁▁▁▁▁▁▁▁▁▁▁▁█▄▂▁▁▁▁
                  6.07 ipc (  0.01% stalls)    NaN% L1 data cache
        555.51k cycles   3.37M instructions   0.00% retired LD/ST (   0.00)

class (task instance class)  110.42 µs/iter 112.04 µs      █               
                    (103.46 µs … 215.33 µs) 123.33 µs ▁▁▁▁▂█▂▁▂█▁▂▁▁▁▁▁▁▁▁▁
                  6.22 ipc (  0.01% stalls)    NaN% L1 data cache
        360.08k cycles   2.24M instructions   0.00% retired LD/ST (   0.00)

summary
  class (task instance func)
   1.28x faster than class (task instance class)
   1.53x faster than func (taks instance func)
   1.98x faster than func (task instance class)

[SukkaW]

Indeed the accquire and release become faster, but I notice that the function that needs to be running becomes slower (even slower w/o reusify).

https://github.com/mcollina/reusify/blob/master/benchmarks/reuseNoCodeFunction.js

[PandaWorker]

This code was written 7 years ago, during this time the v8 engine has changed a lot, and even that code can be optimized a little bit and it will work faster than with reusify, so let's give the code and benchmarks)

The maximum that it can save is memory, but even then there will be almost no differences in modern v8.

//@ts-nocheck
import { fib } from './fib.ts';

var max = 100_000_000
var start = performance.now()

// create a funcion with the typical error
// pattern, that delegates the heavy load
// to something else
function createNoCodeFunction () {
  /* eslint no-constant-condition: "off" */
	const obj = new MyObject();
	
	obj.num = 100
	obj.func();
}

function MyObject(){
	this.num = 0;
}

MyObject.prototype.func = function(){
	fib(this.num)
}

for (var i = 0; i < max; i++) {
  createNoCodeFunction()
}

var time = performance.now() - start
console.log(`mode: without reusify`);
console.log('Total time', time)
console.log('Total iterations', max)
console.log('Iteration/s', max / time * 1000)

//@ts-nocheck
import { fib } from './fib.ts';
import { reusify } from './reusify.ts';

const instance = reusify(MyObject);
const max = 100_000_000;
const start = performance.now();

function reuseNoCodeFunction() {
  const obj = instance.acquire();
  obj.num = 100;
  obj.func();
  obj.num = 0;
  instance.release(obj);
}

function MyObject() {
  this.next = null;
  this.num = 0;
}

MyObject.prototype.func = function () {
  fib(this.num);
};

for (let i = 0; i < max; i++) {
  reuseNoCodeFunction();
}

const time = performance.now() - start;
console.log(`mode: with reusify`);
console.log('Total time', time);
console.log('Total iterations', max);
console.log('Iteration/s', max / time * 1000);

[SukkaW]

The maximum that it can save is memory, but even then there will be almost no differences in modern v8.

You can port the fib code with mitata just as I did: #14 (comment)

The current reusify is still faster than the baseline while your implementation is slower than the baseline.

[SukkaW]

@mcollina I believe this issue can be closed now? According to the benchmark, this new implementation would be slower than the current implementation.

[PandaWorker]

Let's get the latest benchmark results on node versions 18-20-22-24. In the latest versions of v8, the classes seem to have been optimized very well.

[SukkaW]

Let's get the latest benchmark results on node versions 18-20-22-24. In the latest versions of v8, the classes seem to have been optimized very well.

I doubt if it will have anything to do with this specific (and the only important) benchmark: https://github.com/mcollina/reusify/blob/master/benchmarks/reuseNoCodeFunction.js

This benchmark cares mostly about how fast the function runs (i.e., any caches/hidden classes/engine shortcuts things actually activated) and doesn't care a lot about where the function is from (either a class property, a class method, or a morphic object).