Benchmark: Uint8Array to String

Script Preparation code:

uint8Array = Uint8Array.from([...Array(2 ** 16)].map(() => Math.floor(Math.random() * (2 ** 8))));
CHUNK_SZ = 0x8000;

function strapply_arrpush(uint8Array) {
  const c = [];
  for (let i = 0; i < uint8Array.length; i += CHUNK_SZ) {
    c.push(
      String.fromCharCode.apply(null, uint8Array.subarray(i, i + CHUNK_SZ))
    );
  }
  return c.join("");
}

function strapply_arrconcat(uint8Array) {
  let c = [];
  for (let i = 0; i < uint8Array.length; i += CHUNK_SZ) {
    c = c.concat(
      String.fromCharCode.apply(null, uint8Array.subarray(i, i + CHUNK_SZ))
    );
  }
  return c;
}

function strapply_strconcat(uint8Array) {
  let s = "";
  for (let i = 0; i < uint8Array.length; i += CHUNK_SZ) {
    s += (
      String.fromCharCode.apply(null, uint8Array.subarray(i, i + CHUNK_SZ))
    );
  }
  return s;
}

function strspread_arrpush(uint8Array) {
  const c = [];
  for (let i = 0; i < uint8Array.length; i += CHUNK_SZ) {
    c.push(
      String.fromCharCode(...uint8Array.subarray(i, i + CHUNK_SZ))
    );
  }
  return c.join("");
}

function strspread_arrconcat(uint8Array) {
  let c = [];
  for (let i = 0; i < uint8Array.length; i += CHUNK_SZ) {
    c = c.concat(
      String.fromCharCode(...uint8Array.subarray(i, i + CHUNK_SZ))
    );
  }
  return c;
}

function strspread_strconcat(uint8Array) {
  let s = "";
  for (let i = 0; i < uint8Array.length; i += CHUNK_SZ) {
    s += (
      String.fromCharCode(...uint8Array.subarray(i, i + CHUNK_SZ))
    );
  }
  return s;
}

Tests:

strapply_arrpush
strapply_arrpush(uint8Array)
strapply_arrconcat
strapply_arrconcat(uint8Array)
strapply_strconcat
strapply_strconcat(uint8Array)
strspread_arrpush
strspread_arrpush(uint8Array)
strspread_arrconcat
strspread_arrconcat(uint8Array)
strspread_strconcat
strspread_strconcat(uint8Array)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
strapply_arrpush
strapply_arrconcat
strapply_strconcat
strspread_arrpush
strspread_arrconcat
strspread_strconcat

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 18 on iOS 18.3.2

View result in a separate tab

Test name	Executions per second
strapply_arrpush	2141.8 Ops/sec
strapply_arrconcat	2132.8 Ops/sec
strapply_strconcat	2086.2 Ops/sec
strspread_arrpush	724.0 Ops/sec
strspread_arrconcat	718.7 Ops/sec
strspread_strconcat	711.8 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and its test cases to explain what's being tested, compared, and their pros and cons.

**Benchmark Definition**

The benchmark is designed to measure the performance of different methods for converting a `Uint8Array` to a string value. A `Uint8Array` is an array of unsigned 8-bit integers, often used to represent binary data in JavaScript.

The benchmark script defines four main functions:

1. `strapply_arrpush(uint8Array)`: Uses `Array.prototype.push()` and concatenates strings using the spread operator (`...`). This approach pushes each chunk of the `Uint8Array` onto the array and then joins them together.
2. `strapply_arrconcat(uint8Array)`: Similar to `strapply_arrpush()`, but uses `Array.prototype.concat()` instead of `Array.prototype.push()`.
3. `strapply_strconcat(uint8Array)`: Uses string concatenation (`+`) to build the resulting string, one character at a time.
4. `strspread_arrpush(uint8Array)`: Similar to `strapply_arrpush()`, but uses the spread operator (`...`) when accessing each chunk of the `Uint8Array`.
5. `strspread_arrconcat(uint8Array)`: Similar to `strapply_arrconcat()`, but uses the spread operator (`...`) when accessing each chunk of the `Uint8Array`.
6. `strspread_strconcat(uint8Array)`: Similar to `strapply_strconcat()`, but uses the spread operator (`...`) when building the resulting string.

**Test Cases**

The benchmark includes six test cases, one for each function:

1. `strapply_arrpush`
2. `strapply_arrconcat`
3. `strapply_strconcat`
4. `strspread_arrconcat`
5. `strspread_strconcat`
6. `strspread_arrpush`

Each test case measures the execution frequency (number of operations per second) for each function.

**Comparison**

The benchmark is designed to compare the performance of different methods for converting a `Uint8Array` to a string value. The main variables being compared are:

* Functionality: Each method uses a different approach to build the resulting string.
* Memory allocation: Some methods may allocate more memory than others, especially those using `Array.prototype.push()` or `Array.prototype.concat()`.
* String construction: Methods like `strapply_strconcat` and `strspread_strconcat` use string concatenation or spread operators to build the resulting string.

**Pros and Cons**

Here's a brief summary of the pros and cons for each method:

1. `strapply_arrpush`:
	* Pros: Can be more efficient than other methods if the array is already allocated.
	* Cons: May allocate more memory than necessary, especially for large arrays.
2. `strapply_arrconcat`:
	* Pros: Similar to `strapply_arrpush`, but uses `Array.prototype.concat()` instead of `Array.prototype.push()`.
	* Cons: May have slightly better performance due to the use of `Array.prototype.concat()`.
3. `strapply_strconcat`:
	+ Pros: Can be more efficient than other methods if the resulting string is small.
	+ Cons: May cause a stack overflow error if the resulting string is very large, as each concatenation creates a new string object on the stack.
4. `strspread_arrpush`:
	* Pros: Uses the spread operator (`...`) when accessing each chunk of the `Uint8Array`, which can be more efficient than other methods.
	* Cons: May allocate more memory than necessary if the array is large, due to the use of `Array.prototype.push()`.
5. `strspread_arrconcat`:
	* Pros: Similar to `strspread_arrpush`, but uses `Array.prototype.concat()` instead of `Array.prototype.push()`.
	* Cons: May have slightly better performance due to the use of `Array.prototype.concat()`.
6. `strspread_strconcat`:
	+ Pros: Uses the spread operator (`...`) when building the resulting string, which can be more efficient than other methods.
	+ Cons: May cause a stack overflow error if the resulting string is very large, as each concatenation creates a new string object on the stack.

The benchmark results show that `strspread_arrconcat` and `strspread_strconcat` have relatively high execution frequencies (around 926-915 operations per second), indicating that they are among the fastest methods for converting a `Uint8Array` to a string value. However, the exact performance differences between each method depend on various factors, including the size of the input array, system resources, and implementation details.

Related benchmarks:

Uint8Array to String (version: 0)

Benchmark of various methods used to convert a Uint8Array to a string value

Comparing performance of: strapply_arrpush vs strapply_arrconcat vs strapply_strconcat vs strspread_arrpush vs strspread_arrconcat vs strspread_strconcat

Created: 4 years ago by: Guest

Jump to the latest result

strapply_arrpush

strapply_arrconcat

strapply_strconcat

strspread_arrpush

strspread_arrconcat

strspread_strconcat

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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