Benchmark: Multiple chunk - MeasureThat.net

HTML Preparation code:

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

Script Preparation code:

var test = Array.from({
    length: 100000
}, () => Math.random())
function createGroupedArray(arr, chunkSize) {
    const groups = [];
    let i = 0;
    while (i < arr.length) {
        groups.push(arr.slice(i, i += chunkSize));
    }
    return groups;
};

function createGroupedArray2(arr, chunkSize) {
    const groups = [];
  for (let i= 0; i < arr.length; i++)
        groups.push(arr.slice(i, i += chunkSize));
    
    return groups;
};


function array_to_chunks(data, size){
   let chunks = []
   let d = data.slice()
   while (d.length >= size) chunks.push(d.splice(0, size))
   return chunks
}

function chunk_ymnn(arr, chunkSize = 1, cache = []) {
  const tmp = [...arr]
  if (chunkSize <= 0) return cache
  while (tmp.length) cache.push(tmp.splice(0, chunkSize))
  return cache
}

function chunkBucket(arr, size) {
  let buckets = []

  // Just create the buckets/chunks storage
  for (let i = 1; i <= Math.ceil(arr.length / size); i++) {
    buckets.push([])
  }

  // Put in the buckets/storage by index access only
  for (let i = 0; i < arr.length; i++) {
    var arrIndex = Math.ceil((i + 1) / size) - 1
    buckets[arrIndex].push(arr[i])
  }

  return buckets;
}

Tests:

Lodash
_.chunk(test,5000)
slice
createGroupedArray(test,5000)
push
array_to_chunks(test,5000)
you might not need
chunk_ymnn(test,5000)
bucket
chunkBucket(test,5000)
slice for
createGroupedArray2(test, 5000)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
slice
push
you might not need
bucket
slice for

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll provide an explanation of the provided benchmark definition, options compared, pros and cons, library usage, special JS features, and alternatives.

**Benchmark Definition**

The benchmark definition is a JSON object that defines multiple test cases for measuring performance. It includes:

1. A "Name" field with the name of the benchmark.
2. A "Description" field (empty in this case) providing additional context about the benchmark.
3. A "Script Preparation Code" field containing JavaScript code used to prepare the test data, including an array of 100,000 random numbers (`test`).
4. An "Html Preparation Code" field referencing a third-party library (`lodash.js`) that will be used in one of the test cases.

**Options Compared**

The benchmark compares six different methods for chunking arrays:

1. `createGroupedArray` and `createGroupedArray2`: Similar functions that create grouped arrays by slicing the input array.
2. `array_to_chunks`: A function that splits an array into chunks using a specified size.
3. `chunk_ymnn`: A function that creates an array of chunked elements using a specified size, caching previous results.
4. `chunkBucket`: A function that creates an array of buckets, each containing a specified number of elements from the input array.

**Pros and Cons**

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

* **createGroupedArray** and **createGroupedArray2**: These functions are simple and efficient but may not be as flexible as other approaches.
* **array_to_chunks**: This function is straightforward, but it can lead to inefficient memory usage if the chunk size is too large.
* **chunk_ymnn**: This function provides caching, which can improve performance for repeated executions. However, its use of a cache can make it less suitable for the first execution.
* **chunkBucket**: This approach uses an array of buckets, which can lead to better locality of reference and improved cache performance.

**Library Usage**

The benchmark includes `lodash.js` as part of the HTML preparation code. Lodash is a utility library that provides functions like `chunk`, used in one of the test cases (`_.chunk(test, 5000)`).

**Special JS Features**

None of the test cases use special JavaScript features or syntax.

**Alternatives**

Other approaches for chunking arrays could be explored, such as:

* Using native array methods (e.g., `Array.prototype.slice()`, `Array.prototype.reduce()`).
* Implementing a custom chunking function using bitwise operations.
* Utilizing parallel processing libraries like Web Workers.

The choice of approach depends on the specific requirements and constraints of the project.

Latest run results:

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

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

Browser/OS: Chrome 126 on Windows

View result in a separate tab

Test name	Executions per second
Lodash	4245.2 Ops/sec
slice	18716.3 Ops/sec
push	1457.3 Ops/sec
you might not need	1494.0 Ops/sec
bucket	101.2 Ops/sec
slice for	18462.6 Ops/sec

Related benchmarks:

Multiple chunk (version: 1)

Comparing performance of: Lodash vs slice vs push vs you might not need vs bucket vs slice for

Created: 4 months ago by: Registered User

Jump to the latest result

Lodash

slice

push

you might not need

bucket

slice for

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