Benchmark: sync vs promise - MeasureThat.net

Script Preparation code:

var sync = (foo) => { return foo; };
var promise = (foo) => { return Promise.resolve(foo); };

Tests:

sync
(function () { sync('test'); })();
promise
(async function () { await promise('test'); })();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
sync
promise

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/112.0

Browser/OS: Firefox 112 on Ubuntu

View result in a separate tab

Test name	Executions per second
sync	1665558400.0 Ops/sec
promise	489795.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**Overview**

The benchmark measures the performance difference between synchronous and asynchronous code execution in JavaScript. The test case uses two functions: `sync` and `promise`, which return the input value as is, with the former being a synchronous function and the latter using Promises to handle asynchronous execution.

**Script Preparation Code**

The script preparation code defines the two functions:

* `sync`: takes an argument `foo` and returns it directly.
* `promise`: also takes an argument `foo` and returns a resolved Promise with the input value. This is done using the `Promise.resolve()` method, which creates a new Promise that is immediately resolved.

The purpose of these functions is to encapsulate simple synchronous and asynchronous code blocks that will be used for benchmarking.

**Options Compared**

Two options are compared:

1. **Synchronous Execution (sync)**: executes the code synchronously, meaning it waits for the execution to complete before moving on.
2. **Asynchronous Execution with Promises (promise)**: uses Promises to execute the code asynchronously, allowing other tasks to run while waiting for the Promise to resolve.

**Pros and Cons**

* **Synchronous Execution (sync)**:
	+ Pros:
		- Easier to understand and debug, as execution is sequential.
		- No overhead of creating a new thread or context.
	+ Cons:
		- Can block the main thread, leading to poor performance and responsiveness.
		- May not be suitable for I/O-bound tasks or those with high latency.
* **Asynchronous Execution with Promises (promise)**:
	+ Pros:
		- Allows other tasks to run while waiting for the Promise to resolve, improving responsiveness.
		- Can handle I/O-bound tasks and high-latency operations more efficiently.
	+ Cons:
		- Requires more code and can be less straightforward to understand and debug.
		- May introduce additional overhead due to the creation of a new thread or context.

**Other Considerations**

* **Library Usage**: The test case uses the built-in `Promise` object, which is a part of the JavaScript standard library. Promises provide a way to handle asynchronous operations in a more efficient and manageable manner.
* **Special JS Feature/Syntax**: None mentioned in this specific benchmark.

**Alternatives**

Other alternatives for asynchronous code execution include:

1. **Async/Await**: While not used in this benchmark, async/await is another syntax sugar on top of Promises that allows writing asynchronous code that looks more synchronous and easier to understand.
2. **Web Workers**: If the task is CPU-bound or requires low-level memory manipulation, web workers can be used to execute the code in a separate thread, improving performance and responsiveness.
3. **Cooperative scheduling**: Some frameworks and libraries use cooperative scheduling to yield control back to the main thread after executing an I/O-bound operation, allowing for more efficient use of resources.

Keep in mind that each alternative has its own trade-offs and requirements, and the choice ultimately depends on the specific use case and performance characteristics.

Related benchmarks:

sync vs promise (version: 0)

Comparing performance of: sync vs promise

Created: 3 years ago by: Guest

Jump to the latest result

sync

promise

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):