Benchmark: Multi dimensional array loops 15

HTML Preparation code:

<div id="test1" style="color:grey; margin:10px 0"></div>
<div id="test12" style="margin:10px 0"></div>
<div id="test13" style="color:grey; margin:10px 0"></div>

<div id="test2" style="margin:10px 0"></div>
<div id="test22" style="color:grey; margin:10px 0"></div>
<div id="test23" style="margin:10px 0"></div>

<div id="test3" style="color:grey; margin:10px 0"></div>
<div id="test32" style="margin:10px 0"></div>
<div id="test33" style="color:grey; margin:10px 0"></div>

Script Preparation code:

var max1 = 100;
var max2 = 1000;
var max3 = 10000;
var max = 1000


var time1 = 0;
var time12 = 0;
var time13 = 0;

var total1 = 0;
var total12 = 0;
var total13 = 0;
var number1 = 0;
var number12 = 0;
var number13 = 0;

var time2 = 0;
var time22 = 0;
var time33 = 0;

var total2 = 0;
var total22 = 0;
var total23 = 0;
var number2 = 0;
var number22 = 0;
var number23 = 0;

var time3 = 0;
var time32 = 0;
var time33 = 0;

var total3 = 0;
var total32 = 0;
var total33 = 0;
var number3 = 0;
var number32 = 0;
var number33 = 0;

var arr1 = [];
for (var i = 0; i <= max1; i++) { arr1.push({id: Math.floor(Math.random() * max)}); }
var arr12 = [];
for (var i = 0; i <= max1; i++) { arr12.push({id: Math.floor(Math.random() * max)}); }

var arr2 = [];
for (var i = 0; i <= max2; i++) { arr2.push({id: Math.floor(Math.random() * max)}); }
var arr22 = [];
for (var i = 0; i <= max2; i++) { arr22.push({id: Math.floor(Math.random() * max)}); }

var arr3 = [];
for (var i = 0; i <= max3; i++) { arr3.push({id: Math.floor(Math.random() * max)}); }
var arr32 = [];
for (var i = 0; i <= max3; i++) { arr32.push({id: Math.floor(Math.random() * max)}); }

Tests:

O(n2) * 100
const start1 = new Date(); number1++; arr1.filter(el1 => arr12.includes(el12 => el12.id === el1.id)); time1 = (new Date().getTime() - start1.getTime()) const timeMS1 = time1 / 1000; total1 = total1 + time1; document.querySelector("#test1").innerText = `O(n2) * 100 ${time1} ms / ${timeMS1} sec / total ms ${total1} / total sec ${total1 / 1000} / / Number of executions ${number1} / Average execution time per sample ${total1 / number1}`;
O(n2) * 100 - With Extra Map
const start12 = new Date(); number12++; arr1.filter(el1 => arr12.map(el12 => el12.id).includes(id12 => id12 === el1.id)); time12 = (new Date().getTime() - start12.getTime()) const timeMS12 = time12 / 1000; total12 = total12 + time12; document.querySelector("#test12").innerText = `O(n2) * 100 - Extra Map ${time12} ms / ${timeMS12} sec / total ms ${total12} / total sec ${total12 / 1000} / Number of executions ${number12} / Average execution time per sample ${total12 / number12}`;
O(n) * 100
const start13 = new Date(); const m = new Map(); number13++ arr1.forEach(el1 => m.set(el1.id, el1)); arr12.filter(el12 => m.has(el12.id)); time13 = (new Date().getTime() - start13.getTime()) const timeMS13 = time13 / 1000; total13 = total13 + time13; document.querySelector("#test13").innerText = `O(n) * 100 ${time13} ms / ${timeMS13} sec / total ms ${total13} / total sec ${total13 / 1000} / Number of executions ${number13} / Average execution time per sample ${total13 / number13}`;
O(n2) * 1000
const start2 = new Date(); number2++; arr2.filter(el2 => arr22.includes(el22 => el22.id === el2.id)); time2 = (new Date().getTime() - start2.getTime()) const timeMS2 = time2 / 1000; total2 = total2 + time2; document.querySelector("#test2").innerText = `O(n2) * 1000 ${time2} ms / ${timeMS2} sec / total ms ${total2} / total sec ${total2 / 1000} / Number of executions ${number2} / Average execution time per sample ${total2 / number2}`;
O(n2) * 1000 - With Extra Map
const start22 = new Date(); number22++; arr2.filter(el2 => arr22.map(el22 => el22.id).includes(id22 => id22 === el2.id)); time22 = (new Date().getTime() - start22.getTime()) const timeMS22 = time22 / 1000; total22 = total22 + time22; document.querySelector("#test22").innerText = `O(n2) * 1000 - Extra Map ${time22} ms / ${timeMS22} sec / total ms ${total2} / total sec ${total22 / 1000} / Number of executions ${number22} / Average execution time per sample ${total22 / number22}`;
O(n) * 1000
const start23 = new Date(); number23++; const m = new Map(); arr2.forEach(el2 => m.set(el2.id, el2)); arr22.filter(el22 => m.has(el22.id)); time23 = new Date().getTime() - start23.getTime() const timeMS23 = time23 / 1000; total23 = total23 + time23; document.querySelector("#test23").innerText = `O(n) * 1000 ${time23} ms / ${timeMS23} sec / total ms ${total23} / total sec ${total23 / 1000} / Number of executions ${number23} / Average execution time per sample ${total23 / number23}`;
O(n2) * 10000
const start3 = new Date(); number3++; arr3.filter(el3 => arr32.includes(el32 => el32.id === el3.id)); time3 = (new Date().getTime() - start3.getTime()) const timeMS3 = time3 / 1000; total3 = total3 + time3; document.querySelector("#test3").innerText = `O(n2) * 10000 ${time3} ms / ${timeMS3} sec / total ms ${total3} / total sec ${total3 / 1000} / Number of executions ${number3} / Average execution time per sample ${total3 / number3}`;
O(n2) * 10000 - With Extra Map
const start32 = new Date(); number32++; arr3.filter(el3 => arr32.map(el32 => el32.id).includes(id32 => id32 === el3.id)); time32 = (new Date().getTime() - start32.getTime()) const timeMS32 = time32 / 1000; total32 = total32 + time32; document.querySelector("#test32").innerText = `O(n2) * 10000 - Extra Map ${time32} ms / ${timeMS32} sec / total ms ${total32} / total sec ${total32 / 1000} / Number of executions ${number32} / Average execution time per sample ${total32 / number32}`;
O(n) * 10000
const start33 = new Date(); number33++; const m = new Map(); arr3.forEach(el3 => m.set(el3.id, el3)); arr32.filter(el32 => m.has(el32.id)); time33 = (new Date().getTime() - start33.getTime()) const timeMS33 = time33 / 1000; total33 = total33 + time33; document.querySelector("#test33").innerText = `O(n) * 10000 ${time33} ms / ${timeMS33} sec / total ms ${total33} / total sec ${total33 / 1000} / Number of executions ${number33} / Average execution time per sample ${total33 / number33}`;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
O(n2) * 100
O(n2) * 100 - With Extra Map
O(n) * 100
O(n2) * 1000
O(n2) * 1000 - With Extra Map
O(n) * 1000
O(n2) * 10000
O(n2) * 10000 - With Extra Map
O(n) * 10000

Fastest: N/A

Slowest: N/A

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/110.0.0.0 Safari/537.36

Browser/OS: Chrome 110 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
O(n2) * 100	58174.5 Ops/sec
O(n2) * 100 - With Extra Map	26455.6 Ops/sec
O(n) * 100	73519.1 Ops/sec
O(n2) * 1000	5055.1 Ops/sec
O(n2) * 1000 - With Extra Map	518.3 Ops/sec
O(n) * 1000	25231.6 Ops/sec
O(n2) * 10000	87.1 Ops/sec
O(n2) * 10000 - With Extra Map	5.1 Ops/sec
O(n) * 10000	1979.5 Ops/sec

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

LLMs can make mistakes. Check important info.

It looks like you're sharing some data from a test or benchmarking scenario, specifically related to web browser performance.

Based on the provided data, I'll try to extract some insights:

1. **Execution speed**: The execution speeds vary significantly across different tests (e.g., `O(n)`, `O(n2)`) and scale factors (100, 1000). This suggests that the efficiency of each algorithm or implementation depends heavily on the specific use case.
2. **Browser performance**: Chrome 110 performs well across most test cases, with relatively consistent execution speeds. However, there are some significant variations in speed between `O(n)` and `O(n2)` tests, indicating that quadratic complexity can lead to slower performance.
3. **Device and OS**: All the data points come from a single device (Macintosh with Intel Mac OS X 10.15.7) running Chrome 110, so it's unclear how this would translate to other devices or operating systems.
4. **Memory usage**: The "Extra Map" test cases show slower execution speeds compared to regular `O(n)` and `O(n2)` tests. This might be due to increased memory allocation or garbage collection overhead.

Some possible questions based on these observations:

* Are you looking for ways to optimize Chrome's JavaScript engine or browser performance?
* How does the execution speed of `O(n)` vs. `O(n2)` tests affect your application's performance?
* What is the expected impact of device, OS, and memory usage on web application performance?

Please let me know if I can help with anything else or provide more specific insights based on these observations!

Related benchmarks:

Multi dimensional array loops 15 (version: 11)

Difference between nested loops O(n2) vs O(n) with native maps

Comparing performance of: O(n2) * 100 vs O(n2) * 100 - With Extra Map vs O(n) * 100 vs O(n2) * 1000 vs O(n2) * 1000 - With Extra Map vs O(n) * 1000 vs O(n2) * 10000 vs O(n2) * 10000 - With Extra Map vs O(n) * 10000

Created: one year ago by: Registered User

Jump to the latest result

O(n2) * 100

O(n2) * 100 - With Extra Map

O(n) * 100

O(n2) * 1000

O(n2) * 1000 - With Extra Map

O(n) * 1000

O(n2) * 10000

O(n2) * 10000 - With Extra Map

O(n) * 10000

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