Benchmark: CP437 decode - MeasureThat.net

Script Preparation code:

var n = 8;
var arr = new Uint8Array(n);
for (let i = 0; i < n; ++i) {
  arr[i] = (Math.random() * 255) | 0;
}


const CP437 = "\0☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñÑªº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ".split("");
function convert_in_place(s)
{
	for (let k = 0; k < s.length; k++)
		s[k] = CP437[s[k]];
	return s;
}
function convert(buf)
{
	return convert_in_place(buf.slice());
}

function decodeAppend(buf)
{
	let result = "";
	for (let indexCharacter = 0; indexCharacter < buf.length; indexCharacter++) {
		result += CP437[buf[indexCharacter]];
	}
	return result;
}

function decodeFromCharCode(buf)
{
	const s = convert(buf);
	return String.fromCharCode.apply(null, s);
}

function decodeFromCharCode2(buf, chunk)
{
	let str = "";
	let pad = new Uint8Array(chunk);
	for(let k = 0; k < buf.length; k += chunk)
	{
		const remaining = buf.length - k;
		for (let i = 0; i < Math.min(chunk, remaining); i++)
			pad[i] = CP437[buf[k + i]];
		str += String.fromCharCode.apply(null, remaining < chunk ? pad.subarray(0, remaining) : pad);
	}
	return str;
}

Tests:

append string
decodeAppend(arr)
from char code
decodeFromCharCode(arr)
chunk 100
decodeFromCharCode2(arr, 100)
chunk 1000
decodeFromCharCode2(arr, 1000)
chunk 10000
decodeFromCharCode2(arr, 10000)
chunk 10
decodeFromCharCode2(arr, 10)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
append string
from char code
chunk 100
chunk 1000
chunk 10000
chunk 10

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark definition and explain what's being tested.

**Benchmark Definition**

The benchmark is testing four different approaches to decoding a string using the CP437 encoding, which is an extended ASCII character set commonly used in older systems.

**Approaches**

1. **`decodeAppend(arr)`**: This approach appends each decoded character to a single result string.
2. **`decodeFromCharCode(arr)`**: This approach uses `String.fromCharCode()` to convert each encoded byte to a Unicode code point and then constructs the resulting string from these code points.
3. **`decodeFromCharCode2(arr, chunk)`**: This approach is similar to the previous one but breaks down the decoding process into chunks of size `chunk`. It pads the input array with zeros (if necessary) and processes each chunk separately.

**Options Compared**

The benchmark compares the performance of these four approaches:

* The number of executions per second (`ExecutionsPerSecond`) for each approach
* The raw UA string, browser, device platform, operating system, and other metadata

**Pros and Cons**

1. **`decodeAppend(arr)`**:
	* Pros: Simple and straightforward implementation.
	* Cons: May lead to slower performance due to the overhead of concatenating strings in each iteration.
2. **`decodeFromCharCode(arr)`**:
	* Pros: Efficient use of `String.fromCharCode()` which can be optimized for performance.
	* Cons: May require additional memory allocation for the resulting string, and the conversion process might not be as efficient as other approaches.
3. **`decodeFromCharCode2(arr, chunk)`**:
	* Pros: Optimized for large inputs by processing chunks of the input array separately.
	* Cons: Requires an extra parameter `chunk` to specify the size of each chunk, which might add complexity to the implementation.

**Performance Variations**

The benchmark results show significant performance variations between these approaches:

* `decodeAppend(arr)` outperforms other approaches
* `decodeFromCharCode2(arr, chunk)` performs better than `decodeFromCharCode(arr)` for larger input sizes (1000 and 10000)
* Smaller input sizes (10) don't exhibit significant differences in performance

**Device and Browser Variations**

The benchmark results also show variations between different devices and browsers, highlighting the importance of considering platform-specific factors when optimizing code.

Overall, this benchmark provides a good insight into the performance characteristics of these encoding approaches on a specific set of inputs and platforms.

Latest run results:

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

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

Browser/OS: Chrome 128 on Windows

View result in a separate tab

Test name	Executions per second
append string	2621915.5 Ops/sec
from char code	729216.7 Ops/sec
chunk 100	328247.5 Ops/sec
chunk 1000	286712.5 Ops/sec
chunk 10000	121771.9 Ops/sec
chunk 10	340021.4 Ops/sec

Related benchmarks:

CP437 decode (version: 0)

Comparing performance of: append string vs from char code vs chunk 100 vs chunk 1000 vs chunk 10000 vs chunk 10

Created: 2 years ago by: Guest

Jump to the latest result

append string

from char code

chunk 100

chunk 1000

chunk 10000

chunk 10

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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