Benchmark: Lru cache 50% hit ratio test

Tests:

Test1
let Lru = function(cacheSize,callbackBackingStoreLoad,elementLifeTimeMs=1000){ let maxWait = elementLifeTimeMs; let size = parseInt(cacheSize,10); let mapping = {}; let buf = []; for(let i=0;i<size;i++) { let rnd = Math.random(); mapping[rnd] = i; buf.push({data:"",visited:false, key:rnd, time:Date.now()}); } let ctr= 0; let ctrEvict= parseInt(cacheSize/2,10); let loadData = callbackBackingStoreLoad; this.get = async function(key){ if(key in mapping) { if(Date.now() - buf[mapping[key]].time > maxWait) { delete mapping[key]; return await me.get(key); } else { buf[mapping[key]].visited=true; buf[mapping[key]].time = Date.now(); return buf[mapping[key]].data; } } else { let ctrFound = -1; while(ctrFound===-1) { if(buf[ctr].visited) { buf[ctr].visited=false; } ctr++; if(ctr >= size) { ctr=0; } if(!(buf[ctrEvict].visited)) { ctrFound = ctrEvict; } ctrEvict++; if(ctrEvict >= size) { ctrEvict=0; } } delete mapping[buf[ctrFound].key]; mapping[key] = ctrFound; let dataKey = await loadData(key); buf[ctrFound] = {data:dataKey, visited:false, key:e.now()}; return buf[ctrFound].data; } }; }; let lru = new Lru(10, async function(key){ /* cache miss, load from data-store */ let wait=Date.now();let aa=0; while(Date.now()-wait<1){aa++;} return aa.toString()+key; },5000 /*miliseconds before next get() invalidates data */); let c=0; async function runThis() { c++; let myData =await lru.get(parseInt(Math.random()*100,10).toString()+"ee"); console.log(myData); if(c<1000) setImmediate(runThis) } runThis();
Test2
async function runThis() { for(let i=0;i<1000;i++) { let wait=Date.now(); while(Date.now()-wait<1){} console.log(parseInt(Math.random()*100,10)); } } runThis();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Test1
Test2

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases.

**Benchmark Definition**

The benchmark definition represents an implementation of an LRU (Least Recently Used) cache in JavaScript. The `Lru` function takes three arguments:

* `cacheSize`: the size of the cache
* `callbackBackingStoreLoad`: a callback function that loads data from a backing store when the cache misses
* `elementLifeTimeMs`: the lifetime of an element in the cache (default is 1000ms)

The implementation uses an array-based approach to manage the cache, with two main methods: `get` and some internal variables like `ctr`, `ctrEvict`, and `mapping`.

**Test Cases**

There are two test cases:

1. **Test1**: This test case creates a new instance of the `Lru` function with specific parameters (cache size 10, callback backing store load, and element lifetime 5000ms) and runs a loop that fetches random data from the cache using the `get` method. The test logs the results to the console.
2. **Test2**: This test case simply runs a loop that iterates 1000 times, logging the current time to the console.

**Library**

The `Lru` implementation uses no external libraries. However, it does use some internal variables and data structures like arrays (`buf`, `mapping`) and objects (the cache entries).

**Special JS feature or syntax**

This benchmark definition uses some advanced JavaScript features, including:

* **Arrow functions**: The `Lru` function uses arrow functions to define the callback backing store load.
* **Async/await**: The `get` method uses async/await syntax to handle asynchronous operations.
* **Template literals**: The test cases use template literals to construct strings.

**Options compared**

The benchmark compares two different approaches:

1. **Lru implementation with internal data structures**: This is the core LRU cache implementation, which uses an array-based approach to manage the cache.
2. **Simple loop that iterates 1000 times**: This test case simply runs a loop that logs the current time to the console, without any caching or data processing.

**Pros and cons of each approach**

**Lru implementation with internal data structures:**

Pros:

* Efficient use of memory
* Fast cache access times

Cons:

* More complex implementation
* May have performance overhead due to internal data structure management

**Simple loop that iterates 1000 times:**

Pros:

* Simple and easy to understand
* No performance overhead due to caching or data processing

Cons:

* Not scalable for large datasets or high-performance applications
* Logically equivalent to a random number generator, which may not be representative of real-world usage patterns.

**Other considerations**

When running this benchmark, consider the following factors:

* **Cache size**: The Lru implementation uses an array-based approach, so increasing the cache size can affect performance.
* **Element lifetime**: Increasing the element lifetime can reduce cache hits, but also increases memory usage.
* **Callback backing store load**: The callback function used for loading data from a backing store can impact performance.

**Alternatives**

Other alternatives to this benchmark could include:

* Using an existing LRU cache library (e.g., `lru-cache` or `node-lru-cache`) to compare implementation differences and potential performance benefits.
* Adding more complex caching scenarios, such as multi-level caches or caching with expiration times.
* Comparing the performance of different data structures (e.g., arrays vs. linked lists) for managing cache entries.

I hope this helps you understand the benchmark definition and test cases!

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/123.0.0.0 Safari/537.36 OPR/109.0.0.0

Browser/OS: Opera 109 on Windows

View result in a separate tab

Test name	Executions per second
Test1	992.4 Ops/sec
Test2	1.0 Ops/sec

Related benchmarks:

Lru cache 50% hit ratio test (version: 0)

Lru clock 2 hand version

Comparing performance of: Test1 vs Test2

Created: 3 years ago by: Guest

Jump to the latest result

Test1

Test2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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