Benchmark: Passing objects with raw values vs passing new objects with raw values vs passing just raw values vs array of values 2

Passing objects with raw values vs passing new objects with raw values vs passing just raw values vs array of values 2 (version: 0)

Updated to add 'Pass new object' & 'Pass re-created object', these reflect common real-world usage where the object contents are changing

Comparing performance of: Pass object vs Pass raw values vs Pass array vs Pass new object vs Pass re-created object

Created: 2 years ago by: Guest

Jump to the latest result

Script Preparation code:

var a = "Here's a string value";
var b = 5; // and a number
var c = false;

var object = {
  a, b, c
}

var array = [
  a, b, c
];

var passObject = (obj) => {
  return obj.a.length + obj.b * obj.c ? 2 : 1;
}

var passRawValues = (val_a, val_b, val_c) => {
  return val_a.length + val_b * val_c ? 2 : 1;
}

var passArray = (arr) => {
  return arr[0].length + arr[1] * arr[2] ? 2 : 1;
}


var x = 0;

​x
 
var a = "Here's a string value";var b = 5; // and a numbervar c = false;​var object = {  a, b, c}​var array = [  a, b, c];​var passObject = (obj) => {  return obj.a.length + obj.b * obj.c ? 2 : 1;}​var passRawValues = (val_a, val_b, val_c) => {  return val_a.length + val_b * val_c ? 2 : 1;}​var passArray = (arr) => {  return arr[0].length + arr[1] * arr[2] ? 2 : 1;}​​var x = 0;

Tests:

Pass object
x << 1; x ^= passObject(object);
x << 1;
x ^= passObject(object);
Pass raw values
x << 1; x ^= passRawValues(a, b, c);
x << 1;
x ^= passRawValues(a, b, c);
Pass array
x << 1; x ^= passArray(array);
x << 1;
x ^= passArray(array);
Pass new object
x << 1; x ^= passObject({a, b, c});
x << 1;
x ^= passObject({a, b, c});
Pass re-created object
object.a = a; object.b = b; object.c = c; x << 1; x ^= passObject(object);
object.a = a;
object.b = b;
object.c = c;
x << 1;
x ^= passObject(object);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Pass object
Pass raw values
Pass array
Pass new object
Pass re-created object

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 109 on Windows

View result in a separate tab

Test name	Executions per second
Pass object	3894234.2 Ops/sec
Pass raw values	2746705.0 Ops/sec
Pass array	3876710.0 Ops/sec
Pass new object	2765405.8 Ops/sec
Pass re-created object	1771387.2 Ops/sec

Autogenerated LLM Summary (model llama3.1:latest, generated 7 months ago):

Let's break down the benchmark and its test cases.

Benchmark Definition

The benchmark compares the performance of passing objects with raw values, passing new objects with raw values, passing just raw values, and passing an array of values. This is done to determine which approach is the most efficient in terms of execution speed.

Test Cases

There are five test cases:

Pass object: Passes a pre-existing object (object) to the passObject function.
Pass raw values: Passes individual raw values (a, b, and c) to the passRawValues function.
Pass array: Passes an array of values (array) to the passArray function.
Pass new object: Creates a new object with raw values using object literal syntax ({a, b, c}) and passes it to the passObject function.
Pass re-created object: Re-creates an object by assigning individual raw values to an existing object (object) and then passing it to the passObject function.

Library

No external library is used in this benchmark.

JavaScript Features/Syntax

The following JavaScript features or syntax are used:

Object literal syntax: {a, b, c} creates a new object with properties a, b, and c.
Arrow functions: (obj) => { ... } defines an arrow function that takes an argument obj.

Pros/Cons of Each Approach

Here are some general pros and cons for each approach:

Passing objects:
- Pros: Can be more readable and easier to maintain if the object structure is complex.
- Cons: May incur performance overhead due to JavaScript's property lookup mechanism.
Passing raw values:
- Pros: Can be faster than passing objects, especially for simple data structures.
- Cons: May be less readable and more prone to errors if the number of arguments increases.
Passing arrays:
- Pros: Can be faster than passing objects or raw values, especially for large datasets.
- Cons: May require additional memory allocation and copying overhead.

Other Considerations

Cache locality: The performance difference between these approaches may vary depending on cache locality. If the data is mostly accessed in contiguous memory locations, passing arrays may perform better.
Object creation overhead: Creating a new object using new or an object literal syntax may incur additional overhead compared to re-creating an existing object.

Alternatives

Other alternatives for passing data between functions include:

Passing JSON data: Convert the data to JSON format and pass it as a string.
Using callback functions: Define a callback function that takes the required arguments and returns the result.
Using message passing: Use message passing mechanisms, such as Web Workers or SharedArrayBuffer, to transfer data between threads or processes.

Keep in mind that these alternatives may have their own trade-offs and performance implications.

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its test cases.

**Benchmark Definition**

**Test Cases**

There are five test cases:

1. **Pass object**: Passes a pre-existing object (`object`) to the `passObject` function.
2. **Pass raw values**: Passes individual raw values (`a`, `b`, and `c`) to the `passRawValues` function.
3. **Pass array**: Passes an array of values (`array`) to the `passArray` function.
4. **Pass new object**: Creates a new object with raw values using object literal syntax (`{a, b, c}`) and passes it to the `passObject` function.
5. **Pass re-created object**: Re-creates an object by assigning individual raw values to an existing object (`object`) and then passing it to the `passObject` function.

**Library**

No external library is used in this benchmark.

**JavaScript Features/Syntax**

The following JavaScript features or syntax are used:

1. **Object literal syntax**: `{a, b, c}` creates a new object with properties `a`, `b`, and `c`.
2. **Arrow functions**: `(obj) => { ... }` defines an arrow function that takes an argument `obj`.

**Pros/Cons of Each Approach**

Here are some general pros and cons for each approach:

1. **Passing objects**:
	* Pros: Can be more readable and easier to maintain if the object structure is complex.
	* Cons: May incur performance overhead due to JavaScript's property lookup mechanism.
2. **Passing raw values**:
	* Pros: Can be faster than passing objects, especially for simple data structures.
	* Cons: May be less readable and more prone to errors if the number of arguments increases.
3. **Passing arrays**:
	* Pros: Can be faster than passing objects or raw values, especially for large datasets.
	* Cons: May require additional memory allocation and copying overhead.

**Other Considerations**

1. **Cache locality**: The performance difference between these approaches may vary depending on cache locality. If the data is mostly accessed in contiguous memory locations, passing arrays may perform better.
2. **Object creation overhead**: Creating a new object using `new` or an object literal syntax may incur additional overhead compared to re-creating an existing object.

**Alternatives**

Other alternatives for passing data between functions include:

1. **Passing JSON data**: Convert the data to JSON format and pass it as a string.
2. **Using callback functions**: Define a callback function that takes the required arguments and returns the result.
3. **Using message passing**: Use message passing mechanisms, such as Web Workers or SharedArrayBuffer, to transfer data between threads or processes.

Keep in mind that these alternatives may have their own trade-offs and performance implications.

Related benchmarks: