Benchmark: Deferred & Regular & Async hybrid test

Script Preparation code:

function wait(ms) {
    return new Promise(res => setTimeout(() => { res(ms); }, ms));
}
function factorializeRecursive(num) {
  if (num < 0) 
        return -1;
  else if (num == 0) 
      return 1;
  else {
      return (num * factorializeRecursive(num - 1));
  }
}

AخA
 
function wait(ms) {    return new Promise(res => setTimeout(() => { res(ms); }, ms));}function factorializeRecursive(num) {  if (num < 0)         return -1;  else if (num == 0)       return 1;  else {      return (num * factorializeRecursive(num - 1));  }}

Tests:

Deferred wait 50 [Async/Deferred]
setTimeout(function () { deferred.resolve() }, 50);
setTimeout(function () { deferred.resolve() }, 50);
Deferred wait 500 [Async/Deferred]
setTimeout(function () { deferred.resolve() }, 500);
setTimeout(function () { deferred.resolve() }, 500);
Deferred wait 100 [Async/Deferred]
setTimeout(function () { deferred.resolve() }, 100);
setTimeout(function () { deferred.resolve() }, 100);
Async Wait 100 [Async/Deferred]
await wait(100); deferred.resolve();
await wait(100);
deferred.resolve();
Regular/Sync Test, 5000!
var r = factorializeRecursive(5000);
var r = factorializeRecursive(5000);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Deferred wait 50
Deferred wait 500
Deferred wait 100
Async Wait 100
Regular/Sync Test, 5000!

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36 Edg/136.0.0.0

Browser/OS: Chrome 136 on Windows

View result in a separate tab

Test name	Executions per second
Deferred wait 50	18.2 Ops/sec
Deferred wait 500	2.0 Ops/sec
Deferred wait 100	9.6 Ops/sec
Async Wait 100	9.6 Ops/sec
Regular/Sync Test, 5000!	7410.5 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 6 months ago):

The benchmark titled "Deferred Test" focuses on evaluating the performance of deferred execution in JavaScript, specifically using the setTimeout function to defer the resolution of a deferred object. In this case, the benchmark assesses how different delay times in milliseconds (50ms, 100ms, and 500ms) impact the number of executions per second.

Options Compared

Deferred Wait 50ms
- Code: setTimeout(function () { deferred.resolve() }, 50);
- Executions Per Second: 18.10
Deferred Wait 100ms
- Code: setTimeout(function () { deferred.resolve() }, 100);
- Executions Per Second: 9.45
Deferred Wait 500ms
- Code: setTimeout(function () { deferred.resolve() }, 500);
- Executions Per Second: 1.97

Pros and Cons of Different Approaches

Shorter Wait Times (50ms)
- Pros: Higher throughput indicated by more executions per second. This suggests that the system can handle higher levels of deferred tasks effectively with less wait time.
- Cons: Potential increased load on the event loop if many tasks are executed rapidly, which may impact performance if combined effectively with more resource-intensive operations.
Medium Wait Time (100ms)
- Pros: Moderate balance between throughput and resource management, providing reasonable performance metrics.
- Cons: Still lower than the fastest execution, reinforcing that slight increases in wait time can lead to significantly reduced execution rates.
Longer Wait Times (500ms)
- Pros: Allows for more staggered execution, reducing the immediate load on the event loop.
- Cons: Extremely low throughput with only 1.97 executions per second, indicating that longer deferral times hinder the overall performance.

Other Considerations

Deferred Objects: While not specifically mentioned in the Benchmark Definition, the term "deferred" typically refers to a programming pattern often related to promises in JavaScript, allowing asynchronous execution and resolution. Deferred objects are commonly used in libraries like jQuery or implementations that support Promises, facilitating better control over asynchronous operations.

Alternatives

Promises: Instead of using setTimeout with deferred resolutions, JavaScript developers frequently leverage Promises for managing asynchronous operations. Promises help to create a cleaner and more manageable approach to handle asynchronous flows, providing built-in methods like .then() and error handling with .catch().
Async/Await: With the introduction of async/await, JavaScript simplifies working with asynchronous operations. It allows developers to write asynchronous code that looks more like synchronous code, making it easier to read and maintain.
Web Workers: For heavy computations or tasks that can run independently of the main thread, developers may consider utilizing Web Workers. This technique can provide an alternative to deferring tasks through setTimeout, ensuring responsive UI while executing heavier jobs.

In conclusion, the benchmark primarily tests the impact of various wait times on deferred executions using setTimeout. Each approach has its inherent pros and cons depending on the performance impact the user desires. Alternative methods such as Promises and async/await may offer more modern and maintainable solutions for handling asynchronous tasks.

LLMs can make mistakes. Check important info.

The benchmark titled "Deferred Test" focuses on evaluating the performance of deferred execution in JavaScript, specifically using the `setTimeout` function to defer the resolution of a `deferred` object. In this case, the benchmark assesses how different delay times in milliseconds (50ms, 100ms, and 500ms) impact the number of executions per second.

### Options Compared

1. **Deferred Wait 50ms**
   - **Code:** `setTimeout(function () { deferred.resolve() }, 50);`
   - **Executions Per Second:** 18.10

2. **Deferred Wait 100ms**
   - **Code:** `setTimeout(function () { deferred.resolve() }, 100);`
   - **Executions Per Second:** 9.45

3. **Deferred Wait 500ms**
   - **Code:** `setTimeout(function () { deferred.resolve() }, 500);`
   - **Executions Per Second:** 1.97

### Pros and Cons of Different Approaches

- **Shorter Wait Times (50ms)**
  - **Pros:** Higher throughput indicated by more executions per second. This suggests that the system can handle higher levels of deferred tasks effectively with less wait time.
  - **Cons:** Potential increased load on the event loop if many tasks are executed rapidly, which may impact performance if combined effectively with more resource-intensive operations.

- **Medium Wait Time (100ms)**
  - **Pros:** Moderate balance between throughput and resource management, providing reasonable performance metrics.
  - **Cons:** Still lower than the fastest execution, reinforcing that slight increases in wait time can lead to significantly reduced execution rates.

- **Longer Wait Times (500ms)**
  - **Pros:** Allows for more staggered execution, reducing the immediate load on the event loop.
  - **Cons:** Extremely low throughput with only 1.97 executions per second, indicating that longer deferral times hinder the overall performance.

### Other Considerations

**Deferred Objects:** 
While not specifically mentioned in the `Benchmark Definition`, the term "deferred" typically refers to a programming pattern often related to promises in JavaScript, allowing asynchronous execution and resolution. Deferred objects are commonly used in libraries like jQuery or implementations that support Promises, facilitating better control over asynchronous operations.

### Alternatives

1. **Promises:** Instead of using `setTimeout` with deferred resolutions, JavaScript developers frequently leverage Promises for managing asynchronous operations. Promises help to create a cleaner and more manageable approach to handle asynchronous flows, providing built-in methods like `.then()` and error handling with `.catch()`.

2. **Async/Await:** With the introduction of `async/await`, JavaScript simplifies working with asynchronous operations. It allows developers to write asynchronous code that looks more like synchronous code, making it easier to read and maintain.

3. **Web Workers:** For heavy computations or tasks that can run independently of the main thread, developers may consider utilizing Web Workers. This technique can provide an alternative to deferring tasks through `setTimeout`, ensuring responsive UI while executing heavier jobs.

In conclusion, the benchmark primarily tests the impact of various wait times on deferred executions using `setTimeout`. Each approach has its inherent pros and cons depending on the performance impact the user desires. Alternative methods such as Promises and async/await may offer more modern and maintainable solutions for handling asynchronous tasks.

Related benchmarks:

Deferred & Regular & Async hybrid test (version: 12)

Testing deferred test support that will come in MeasureThat.net v 1.6.0

Comparing performance of: Deferred wait 50 vs Deferred wait 500 vs Deferred wait 100 vs Async Wait 100 vs Regular/Sync Test, 5000!

Created: 6 months ago by: Registered User

Jump to the latest result

Deferred wait 50 [Async/Deferred]

Deferred wait 500 [Async/Deferred]

Deferred wait 100 [Async/Deferred]

Async Wait 100 [Async/Deferred]

Regular/Sync Test, 5000!