Benchmark: Wrapped class field access speed v1

Script Preparation code:

class ValueHolder {
  #value;
  get value() {return this.#value;}
  set value(v) {this.#value = v;}
}
const holder = new ValueHolder();

function getValue1(x) {
  return holder.value;
}
function wrappedValue1(x) { return getValue1(x); }

function getValue2(x, anyHolder=holder) {
  return anyHolder.value;
}
function wrappedValue2(x) { return getValue2(x); }

function getValue3(x, anyHolder=holder) {
  const propName = "value";
  return anyHolder[propName];
}
function wrappedValue3(x) { return getValue3(x); }

function getValue4(x, anyHolder=holder, propName="value") {
  return anyHolder[propName];
}
function wrappedValue4(x) { return getValue1(4); }
               
function benchmark(func) {
  let x; 
  for (let i = 0; i < 1000000; i++) {
    x = func(i);
  }
  return x;
}

Tests:

Static object, static property
benchmark(wrappedValue1)
Dynamic object, static property
benchmark(wrappedValue2)
Dynamic object, const property
benchmark(wrappedValue3)
Dynamic object, dynamic property
benchmark(wrappedValue4)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Static object, static property
Dynamic object, static property
Dynamic object, const property
Dynamic object, dynamic property

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 123 on Windows

View result in a separate tab

Test name	Executions per second
Static object, static property	23.5 Ops/sec
Dynamic object, static property	21.3 Ops/sec
Dynamic object, const property	21.5 Ops/sec
Dynamic object, dynamic property	21.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark is measuring the speed of accessing class fields in different ways. The script definition includes four functions:

1. `getValue1(x)`: Directly accesses the `value` property on the `holder` object.
2. `wrappedValue1(x)`: Wraps `getValue1(x)` and calls it, which essentially does the same thing as `getValue1(x)`.
3. `getValue2(x, anyHolder=holder)`: Accesses the `value` property on an object named `anyHolder`, defaulting to `holder` if not provided.
4. `wrappedValue2(x)`: Wraps `getValue2(x)` and calls it, similar to `wrappedValue1(x)`.
5. `getValue3(x, anyHolder=holder)`: Accesses a property named `value` on an object named `anyHolder`, defaulting to `holder` if not provided.
6. `wrappedValue3(x)`: Wraps `getValue3(x)` and calls it, similar to `wrappedValue2(x)`.
7. `getValue4(x, anyHolder=holder, propName="value")`: Accesses a property named `propName` on an object named `anyHolder`, defaulting to `"value"` if not provided.
8. `wrappedValue4(x)`: Wraps `getValue4(x)` and calls it, similar to `wrappedValue1(x)`.

**What's being tested**

The benchmark is measuring the speed of each function by executing them 1 million times in a loop. The results are displayed as the number of executions per second (ExecutionsPerSecond).

**Options compared**

There are four options being compared:

* Direct access to `value` property (`getValue1(x)`)
* Wrapping around direct access with no parameters (`wrappedValue1(x)` and `wrappedValue4(x)`)
* Accessing a non-existent property named `value` on an object (`getValue3(x)`)

**Pros and Cons**

Here are the pros and cons of each approach:

* Direct access to `value` property (`getValue1(x)`):
	+ Pros: Fast, straightforward.
	+ Cons: May not be applicable in all scenarios (e.g., if `holder` is not a class).
* Wrapping around direct access with no parameters (`wrappedValue1(x)` and `wrappedValue4(x)`):
	+ Pros: Works regardless of the type of object being accessed. Can be useful for creating a interface between functions and objects.
	+ Cons: May introduce overhead due to function calls.
* Accessing a non-existent property named `value` on an object (`getValue3(x)`):
	+ Pros: May be more flexible than direct access, as it allows for accessing properties with different names.
	+ Cons: Can be slower if the property is not found, and may require additional checks.

**Library**

The benchmark uses a library called ES6 classes (ECMAScript 2015 Classes) to define the `ValueHolder` class. This library provides a way to create classes in JavaScript, which can be useful for creating objects with complex behavior.

**Special JS feature or syntax**

None of the test cases use any special features or syntax beyond what's standard in ES6+ JavaScript.

**Other alternatives**

If you wanted to write this benchmark using alternative approaches, here are some options:

* Use a profiling library like V8 Profiler (for Chrome) or Node.js Inspector to measure performance.
* Write a native module in C++ or Rust and use it as a wrapper around the `ValueHolder` class.
* Use a different programming language, such as Java or Python, if you prefer.

Keep in mind that each alternative approach would have its own pros and cons, and may not be suitable for all use cases.

Related benchmarks:

Wrapped class field access speed v1 (version: 1)

Comparing performance of: Static object, static property vs Dynamic object, static property vs Dynamic object, const property vs Dynamic object, dynamic property

Created: 8 months ago by: Registered User

Jump to the latest result

Static object, static property

Dynamic object, static property

Dynamic object, const property

Dynamic object, dynamic property

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):