Benchmark: lodash test - MeasureThat.net

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/2.4.1/lodash.min.js"></script>

Script Preparation code:

function shuffle(a) {
    var j, x, i;
    for (i = a.length; i; i--) {
        j = Math.floor(Math.random() * i);
        x = a[i - 1];
        a[i - 1] = a[j];
        a[j] = x;
    }
}
var similar = {
 	all: [],
	ids: [],
	allLength: 1000,
	idsLength: 800
};

for(var i = 0; i < similar.allLength; i++) {
  similar.all[i] = {id: i, value: 'value' + i };
}

for(var i = 0; i < similar.allLength; i++) {
  similar.ids[i] = i;
}
similar.ids = similar.ids.splice(similar.allLength - similar.idsLength)
shuffle(similar.all);
shuffle(similar.ids);

var distant = {
 	all: [],
	ids: [],
	allLength: 1000,
	idsLength: 200
};

for(var i = 0; i < distant.allLength; i++) {
  distant.all[i] = {id: i, value: 'value' + i };
}

for(var i = 0; i < distant.allLength; i++) {
  distant.ids[i] = i;
}
distant.ids = distant.ids.splice(distant.allLength - distant.idsLength)
shuffle(distant.all);
shuffle(distant.ids);

Tests:

800/1000 - map + find iterate on ids
var output = _.map(similar.ids, function(id) { return _.find(similar.all, { id: id }); });
800/1000 - reduce + includes iterate on all
var output = _.reduce(similar.all, function(acc, element) { if(_.includes(similar.ids, element.id)) { acc.push(element); } return acc; }, []);
800/1000 - filter + includes iterate on all
var output = _.filter(similar.all, function(element) { return _.includes(similar.ids, element.id); });
200/1000 - map + find iterate on ids
var output = _.map(distant.ids, function(id) { return _.find(distant.all, { id: id }); });
200/1000 - reduce + includes iterate on all
var output = _.reduce(distant.all, function(acc, element) { if(_.includes(distant.ids, element.id)) { acc.push(element); } return acc; }, []);
200/1000 - filter + includes iterate on all
var output = _.filter(distant.all, function(element) { return _.includes(distant.ids, element.id); });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
800/1000 - map + find iterate on ids
800/1000 - reduce + includes iterate on all
800/1000 - filter + includes iterate on all
200/1000 - map + find iterate on ids
200/1000 - reduce + includes iterate on all
200/1000 - filter + includes iterate on all

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll provide an explanation of the benchmark, its options, pros and cons, and other considerations.

**Benchmark Overview**

The benchmark measures the performance of three different operations in the Lodash library: `map`, `reduce`, and `filter`. Each operation is applied to two datasets: `similar` and `distant`, which contain arrays of objects with identical properties. The datasets are shuffled using a custom function, simulating a real-world scenario where data needs to be processed.

**Options Compared**

The benchmark compares the performance of three different approaches for each operation:

1. **Map + Find**: This approach uses the `map` function to create a new array and then uses the `find` function to search for elements in the original dataset.
2. **Reduce + Includes**: This approach uses the `reduce` function to accumulate elements in an array and checks if each element is included in the second dataset using the `includes` function.
3. **Filter + Includes**: This approach uses the `filter` function to create a new array containing only the elements that pass the test implemented by the provided function, which includes checking if each element is in the second dataset.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. **Map + Find**
	* Pros: Simple and easy to understand. Can be parallelized.
	* Cons: Creates an extra array, which can lead to memory issues for large datasets.
2. **Reduce + Includes**
	* Pros: Accumulates elements in a single array, reducing memory usage. Can be parallelized.
	* Cons: Uses the `includes` function, which may have performance implications due to its implementation details.
3. **Filter + Includes**
	* Pros: Minimizes memory usage by only iterating over the desired elements. Can be parallelized.
	* Cons: May have performance issues if the filtering criterion is complex or computationally expensive.

**Other Considerations**

* **Parallelization**: All three approaches can be parallelized using techniques like parallel iteration, which can significantly improve performance on multi-core processors.
* **Memory Usage**: The `map + find` approach has the highest memory usage due to the creation of an extra array. In contrast, the `filter + includes` approach uses minimal memory, making it suitable for large datasets.
* **Implementation Details**: The `includes` function in Lodash is implemented using a binary search algorithm, which may have performance implications. Additionally, the `reduce` and `filter` functions are implemented using iterative algorithms, which can be optimized for performance.

By considering these factors, you can choose the best approach for your specific use case, taking into account memory constraints, parallelization requirements, and performance considerations.

Latest run results:

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

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

Browser/OS: Chrome 58 on Windows

View result in a separate tab

Test name	Executions per second
800/1000 - map + find iterate on ids	84.4 Ops/sec
800/1000 - reduce + includes iterate on all	221.2 Ops/sec
800/1000 - filter + includes iterate on all	219.6 Ops/sec
200/1000 - map + find iterate on ids	310.2 Ops/sec
200/1000 - reduce + includes iterate on all	468.2 Ops/sec
200/1000 - filter + includes iterate on all	471.9 Ops/sec

Related benchmarks:

lodash test (version: 0)

Comparing performance of: 800/1000 - map + find iterate on ids vs 800/1000 - reduce + includes iterate on all vs 800/1000 - filter + includes iterate on all vs 200/1000 - map + find iterate on ids vs 200/1000 - reduce + includes iterate on all vs 200/1000 - filter + includes iterate on all

Created: 7 years ago by: Guest

Jump to the latest result

800/1000 - map + find iterate on ids

800/1000 - reduce + includes iterate on all

800/1000 - filter + includes iterate on all

200/1000 - map + find iterate on ids

200/1000 - reduce + includes iterate on all

200/1000 - filter + includes iterate on all

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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