Benchmark: Data duplication methods

Script Preparation code:

  const loremWords = [
    'lorem',
    'ipsum',
    'dolor',
    'sit',
    'amet',
    'consectetur',
    'adipiscing',
    'elit',
    'nunc',
    'id',
    'hendrerit',
    'arcu',
    'curabitur',
    'vitae',
    'euismod',
    'justo',
    'cras',
    'libero',
    'dui',
    'scelerisque',
    'a',
    'suscipit',
    'et',
    'bibendum',
    'nec',
    'est',
    'in',
    'maximus',
    'purus',
    'ullamcorper',
    'nulla',
    'blandit',
    'cursus',
    'nullam',
    'sapien',
    'ex',
    'rhoncus',
    'at',
    'auctor',
    'vel',
    'scelerisque',
    'auctor',
    'diam',
    'cras',
    'porta',
    'lorem',
    'non',
    'efficitur',
    'pulvinar',
    'massa'
];

const generateLorem = () => {
  const amount = 5 + Math.round(Math.random() * (loremWords.length - 5));
  const joined = loremWords.slice(0, amount).join(' ') + '.';
  return joined[0].toUpperCase() + joined.slice(1);
};

const buildItem = (createdAt, id) => ({
  id,
  createdAt,
  title: `Article ${id + 1}`,
  text: generateLorem(),
});

var makeExampleData = () => {
  const bool = {
    true: true,
    false: false,
    yes: true,
    no: false,
    1: true,
    0: false,
  };
  
  
  const articles = Array(1000).fill(Date.now()).map(buildItem);
  
  const numbers = Array(1000).fill(100).map((x, i) => x * i);
  
  const words = Array(1000).fill(loremWords).flat();
  
  const text = Array(1000).fill(loremWords).flat().join(' ');
  
  return {bool, articles, numbers, words, text};
};

Tests:

Build function
const buildData = () => makeExampleData(); for (let i = 0; i < 100; i += 1) { const newData = buildData(); }
New function, no cache
for (let i = 0; i < 100; i += 1) { const json = JSON.stringify(makeExampleData()); const newData = new Function('json', `return json`)(json); }
New function, cached data
const data = makeExampleData(); for (let i = 0; i < 100; i += 1) { const json = JSON.stringify(data); const newData = new Function('json', `return json`)(json); }
New function, cached stringify
const json = JSON.stringify(makeExampleData()); for (let i = 0; i < 100; i += 1) { const newData = new Function('json', `return json`)(json); }
JSON stringify & parse, no cache
for (let i = 0; i < 100; i += 1) { const json = JSON.stringify(makeExampleData()); const newData = JSON.parse(json); }
JSON stringify & parse, cached data
const data = makeExampleData(); for (let i = 0; i < 100; i += 1) { const json = JSON.stringify(data); const newData = JSON.parse(json); }
JSON stringify & parse, cached stringify
const json = JSON.stringify(makeExampleData()); for (let i = 0; i < 100; i += 1) { const newData = JSON.parse(json); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Build function
New function, no cache
New function, cached data
New function, cached stringify
JSON stringify & parse, no cache
JSON stringify & parse, cached data
JSON stringify & parse, cached stringify

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

It seems like you're looking for insights from benchmark results.

Here are some observations and potential takeaways:

1. **Cache benefits**: The cached data tests show slower execution times compared to the non-cached data test, indicating that the caching mechanism is not providing significant performance gains in this case.
2. **Stringify & parse without caching**: This test has a relatively low execution time, suggesting that the overhead of JSON serialization and deserialization is manageable for most use cases.
3. **Build function vs new function**: The "Build function" and "New function, no cache" tests have similar execution times, while the corresponding cached data tests are slower. This suggests that building data from scratch can be more efficient than using cached data in certain scenarios.

To further optimize performance:

* Investigate why caching is not providing benefits in the cached data tests.
* Consider implementing a more effective caching mechanism or optimizing the data structure to reduce serialization overhead.
* Profile and test different approaches for building data, including both building from scratch and using cached data.

Latest run results:

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

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

Browser/OS: Chrome 91 on Windows

View result in a separate tab

Test name	Executions per second
Build function	0.6 Ops/sec
New function, no cache	0.5 Ops/sec
New function, cached data	2.3 Ops/sec
New function, cached stringify	48.7 Ops/sec
JSON stringify & parse, no cache	0.4 Ops/sec
JSON stringify & parse, cached data	1.2 Ops/sec
JSON stringify & parse, cached stringify	2.9 Ops/sec

Related benchmarks:

Data duplication methods (version: 0)

Comparing performance of: Build function vs New function, no cache vs New function, cached data vs New function, cached stringify vs JSON stringify & parse, no cache vs JSON stringify & parse, cached data vs JSON stringify & parse, cached stringify

Created: 3 years ago by: Registered User

Jump to the latest result

Build function

New function, no cache

New function, cached data

New function, cached stringify

JSON stringify & parse, no cache

JSON stringify & parse, cached data

JSON stringify & parse, cached stringify

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