Benchmark: Option[Int]: box vs unbox

Script Preparation code:

function None() {
}
None.prototype.tag = 0;
const none = new None();
function Some(payload) {
  this.payload = payload;
}
Some.prototype.tag = 1;

var box = [];
var unbox = [];
var unbox2 = [];
for (let i = 0; i < 1000; i++) {
  box.push(i % 2 == 0 ? none : new Some(i));
  unbox.push(i % 2 == 0 ? undefined : i);
  unbox2.push(i % 2 == 0 ? 4294967296 : i + 0);
}

function square(i) {
  return i * i | 0
}

Tests:

box
for (let i of box) { if (i.tag === 1) { square(i.payload) } }
unbox
for (let i of unbox) { if (i !== undefined) { square(i) } }
unbox2
for (let i of unbox2) { if (i === 4294967296) { square(i | 0) } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
box
unbox
unbox2

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 2 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of MeasureThat.net and explore what's being tested in this benchmark.

**Benchmark Definition**

The provided JSON represents a benchmark definition for measuring the performance of JavaScript code. The script preparation code is:

```javascript
function None() {
  // empty function
}

None.prototype.tag = 0;
const none = new None();

function Some(payload) {
  this.payload = payload;
}
Some.prototype.tag = 1;

var box = [];
var unbox = [];
var unbox2 = [];

for (let i = 0; i < 1000; i++) {
  box.push(i % 2 == 0 ? none : new Some(i));
  unbox.push(i % 2 == 0 ? undefined : i);
  unbox2.push(i % 2 == 0 ? 4294967296 : i + 0);
}

function square(i) {
  return i * i | 0;
}
```

This code creates three arrays: `box`, `unbox`, and `unbox2`. The first array contains either an instance of the `None` class or an instance of the `Some` class, depending on whether `i` is even or odd. The second array contains either `undefined` or a number between 0 and 999. The third array contains either a large integer (4294967296) or a small integer between 1 and 1000.

**Options being compared**

There are three options being compared:

1. **Boxing**: In this option, instances of the `Some` class are pushed onto the `box` array. This means that JavaScript will have to perform boxing (converting a primitive value to an object) when iterating over the array.
2. **Unboxing**: In this option, numbers between 0 and 999 are pushed onto the `unbox` array. However, there's an additional twist: some numbers in the range 0-999 are replaced with `undefined`. This means that JavaScript will have to perform unboxing (converting an object to a primitive value) when iterating over the array.
3. **Large integer**: In this option, large integers (4294967296) are pushed onto the `unbox2` array. Since these numbers can't fit in a 32-bit signed integer, JavaScript will have to perform type promotion (upcasting from a smaller type to a larger one).

**Pros and Cons**

Here's a brief analysis of each option:

1. **Boxing**: Pros: This option tests the performance of boxing, which is an essential operation in JavaScript. Cons: Since `Some` instances are pushed onto the array, this option might be slower due to the overhead of object creation.
2. **Unboxing**: Pros: This option tests the performance of unboxing, another essential operation in JavaScript. Cons: The presence of `undefined` values in the array adds complexity and might make the test less representative of real-world scenarios.
3. **Large integer**: Pros: This option tests the performance of type promotion, which is critical for handling large integers in JavaScript. Cons: The use of a very large integer (4294967296) might make the test less representative of common use cases.

**Libraries and special features**

There are no external libraries being used in this benchmark. However, some special features of JavaScript are being utilized:

* **Object creation**: In the `box` option, instances of the `Some` class are created using the `new` keyword.
* **Type promotion**: In the `unbox2` option, large integers are pushed onto the array, which triggers type promotion to handle the larger value.
* **Primitive-to-object conversion**: In all three options, primitive values (numbers) are converted to objects when being pushed onto the arrays.

**Other alternatives**

MeasureThat.net provides a range of alternative benchmarking scenarios, including:

* Testing the performance of JavaScript engines under different workload types
* Measuring the impact of various optimizations and features on execution time
* Comparing the performance of different JavaScript implementations (e.g., V8 vs. SpiderMonkey)

These alternative benchmarks can provide more comprehensive insights into the performance characteristics of JavaScript engines and help developers optimize their code for better performance.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36

Browser/OS: Chrome 129 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
box	64849.8 Ops/sec
unbox	14890.1 Ops/sec
unbox2	60906.3 Ops/sec

Related benchmarks:

Option[Int]: box vs unbox (version: 1)

Comparing performance of: box vs unbox vs unbox2

Created: 7 days ago by: Registered User

Jump to the latest result

box

unbox

unbox2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 2 days ago):