Benchmark: splitted vs whole in large object

Script Preparation code:

const cut = 3,
    each = 600000

const lists = new Array(cut)
    .fill(0)
    .map((_, k) => k)
    .map((v) => new Array(each).fill(v).map((_, k) => v * each + k));

var objList = lists.map((v) =>
    v.reduce((accu, curr) => {
        accu[curr] = {
            addr: curr.toString(),
            size: 188888,
            vmT: 1,
            cls: "cls name",
            nodeT: 2,
            pNode: ["1", "2", "3", "4", "5", "1", "2", "3", "4", "5"], // addr
            cNode: ["1", "2", "3", "4", "5", "1", "2", "3", "4", "5"], // addr
            edge: {
                1: {
                    refT: 1,
                    off: "string",
                    name: "string",
                },
                2: {
                    refT: 1,
                    off: "string",
                    name: "string",
                }
            },
        };
        return accu;
    }, {})
);

var objStrList = objList.map(v => JSON.stringify(v));
var wholeObj = Object.assign(...objList);
var wholeObjStr = JSON.stringify(wholeObj)

Tests:

splitted-and-assign
const parsedObjList = objStrList.map((v) => JSON.parse(v)); const wholeObj = Object.assign(...parsedObjList);
whole
const parsedWholeObj = JSON.parse(wholeObjStr);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
splitted-and-assign
whole

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided benchmark measures the performance of two approaches to process large objects in JavaScript:

1. **Whole Object Approach**: This approach involves parsing and assigning the entire object at once, using `Object.assign()` and `JSON.parse()`.
2. **Splitted Object Approach**: This approach involves splitting the object into smaller parts (arrays), processing each part individually, and then reassembling the object.

**Options Compared**

The benchmark compares the performance of these two approaches on large objects. The options being compared are:

* Whole Object Approach: `Object.assign()` and `JSON.parse()`
* Splitted Object Approach: splitting the object into smaller parts (arrays), processing each part individually, and reassembling the object

**Pros and Cons**

**Whole Object Approach**

Pros:

* Easier to implement and understand
* Less memory allocation and garbage collection overhead

Cons:

* May be slower due to the need to parse and assign the entire object at once
* Can lead to performance issues if the object is too large

**Splitted Object Approach**

Pros:

* Can be faster for very large objects, as it processes each part individually
* Reduces memory allocation and garbage collection overhead

Cons:

* More complex implementation and understanding required
* Requires careful handling of array indices and bounds checking

**Other Considerations**

* The benchmark uses a fixed-size object (600,000 elements) to test the performance of both approaches.
* The `JSON.stringify()` function is used to convert the entire object into a string, which may introduce additional overhead.
* The `Object.assign()` method is used to reassemble the object from its constituent parts.

**Library and Special JS Features**

The benchmark uses:

* No external libraries (other than JavaScript built-in functions)
* No special JavaScript features or syntax

**Alternative Approaches**

Other approaches that could be considered include:

* Using a more efficient data structure, such as a trie or suffix tree
* Implementing the splitting and reassembling logic using specialized algorithms or techniques
* Optimizing the parsing and assignment steps using specialized libraries or tools

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 109 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
splitted-and-assign	0.2 Ops/sec
whole	0.2 Ops/sec

Related benchmarks:

splitted vs whole in large object (version: 3)

Comparing performance of: splitted-and-assign vs whole

Created: one year ago by: Registered User

Jump to the latest result

splitted-and-assign

whole

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