Performance Comparison of handling empty functions

[Luna-Klatzer]

Overview

Comparison of the performance between various methods of handling empty methods:

• Method 1: Returning Promise.resolve(undefined to not create an actual async promise.
• Method 2: Calling an empty async promise. (Leaving the function empty)
• Method 3: Set the function to undefined e.g. make the function type possibly undefined and not call it if it is.

Sample Script

function x(): Promise<void> {
    return Promise.resolve(undefined);  
}

async function y(): Promise<void> {
    return;
}

let z: Promise<void> | undefined = undefined;

(async () => {
  let i = 0;
  let date = new Date();
  while (i < 10000) {
    await x();
    i++;
  }
    console.log(`resolve(undefined) - Done after ${(new Date() - date)}`);
})(); 

(async () => {
  let i = 0;
  let date = new Date();
  while (i < 10000) {
    await y();
    i++;
  }
    console.log(`async function - Done after ${(new Date() - date)}`);
})(); 

(async () => {
  var i = 0;
  var date = new Date();
  while (i < 10000) {
    if (z !== undefined) {
      z();
    }
    i++;
  }
    console.log(`undefined check - Done after ${(new Date() - date)}`);
})(); 

(async () => {
  let i = 0;
  let date = new Date();
  while (i < 10000) {
    i++;
  }
    console.log(`base ref - Done after ${(new Date() - date)}`);
})(); 

Results

Tested on Firefox 108 - Performance depends on the system, which means the values should be used as comparison only between themselves (On the same system and browser).

• Resolve undefined: 101ms
• Empty Async function: 102ms
• Undefined check: 3ms
• Base Ref (Only the loop): < 1ms

[Luna-Klatzer]

This a benchmark for testing which method is better for handling when an AST node in the compiler implementation has no semantic analysis or type-checking needed e.g. the functions would be empty since nothing needs to be checked.