Benchmark: WeakSet common many types

Script Preparation code:

function func(a, b) {  
  return 0.5 - Math.random();
}  

var arr = Array.from({length: 1000}).map((_, i) => {
  return {num: i, str: String(i)};
}).toSorted(func);
var arrNum = arr.map(v => {return {[v.num]: v.num}});
var arrStr = arr.map(v => {return {[v.str]: v.str}});
var arrObj = arr.map(v =>{ 
  const is = v.num % 2 === 0;
  const val = is ? v.str : v.num;
  return {[val]: val}
})
var arrSymb = arr.map(Symbol)


const arrMix = arr.toSorted(func);
var arrRandom = [...arrNum.slice(0, 250), ...arrStr.slice(250, 500), ...arrObj.slice(500, 750), ...arrMix.slice(750, 1000).map(v => Symbol(v))].toSorted(func)


var number = new WeakSet();
var string = new WeakSet();
var obj = new WeakSet();
var symbol = new WeakSet();
var mixed = new WeakSet();

Tests:

WEAKSET string
arrStr.forEach(v => string.add(v)) arrStr.forEach(v => string.has(v)) arrStr.forEach(v => string.size) arrStr.forEach(v => string.delete(v))
WEAKSET number
arrNum.forEach(v => number.add(v)) arrNum.forEach(v => number.has(v)) arrNum.forEach(v => number.size) arrNum.forEach(v => number.delete(v))
WEAKSET obj
arrObj.forEach(v => obj.add(v)) arrObj.forEach(v => obj.has(v)) arrObj.forEach(v => obj.size) arrObj.forEach(v => obj.delete(v))
WEAKSET symbol
arrSymb.forEach(v => symbol.add(v)) arrSymb.forEach(v => symbol.has(v)) arrSymb.forEach(v => symbol.size) arrSymb.forEach(v => symbol.delete(v))
WEAKSET mixed
arrRandom.forEach(r => mixed.add(r)) arrRandom.forEach(r => mixed.has(r)) arrRandom.forEach(r => mixed.size) arrRandom.forEach(r => mixed.delete(r))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
WEAKSET string
WEAKSET number
WEAKSET obj
WEAKSET symbol
WEAKSET mixed

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided JSON represents a set of JavaScript microbenchmarks that test the performance of WeakSet data structures in different scenarios.

A WeakSet is a specialized collection of unique values, used to keep track of objects that are present in a specific context without the need for reference counting. It's a less common and less used data structure compared to Set or Map.

**Options Compared**

The benchmark compares the performance of four different approaches:

1. **WeakSet.add() + WeakSet.has()**: This approach uses the `add()` method to add elements to the WeakSet, followed by checking if an element is present using the `has()` method.
2. **WeakSet.size + WeakSet.delete()**: This approach calculates the size of the WeakSet using the `size` property and then deletes all elements using the `delete()` method.
3. **WeakSet.add() + WeakSet.has() + WeakSet.size**: This approach adds an extra step to calculate the size of the WeakSet after adding each element.
4. **WeakSet.delete() + WeakSet.size + WeakSet.add() + WeakSet.has()**: This approach deletes elements before calculating the size, and then adds new elements.

**Pros and Cons**

* **Option 1 (WeakSet.add() + WeakSet.has())**:
	+ Pros: Simple and straightforward.
	+ Cons: May incur additional overhead due to repeated lookups in `has()`.
* **Option 2 (WeakSet.size + WeakSet.delete())**:
	+ Pros: Efficiently deletes elements, reducing memory usage.
	+ Cons: May require frequent recalculations of the size property.
* **Option 3 (WeakSet.add() + WeakSet.has() + WeakSet.size)**:
	+ Pros: Scales well for large datasets due to repeated calculations of size.
	+ Cons: May incur additional overhead from repeated lookups in `has()` and recalculations of size.
* **Option 4 (WeakSet.delete() + WeakSet.size + WeakSet.add() + WeakSet.has())**:
	+ Pros: Efficiently deletes elements, reduces memory usage, and scales well for large datasets.
	+ Cons: May require careful consideration of element ordering to ensure correctness.

**Other Considerations**

* The benchmark uses a mix of object types (numbers, strings, symbols) to simulate real-world scenarios.
* The `toSorted()` function is used to sort the array before passing it to each WeakSet implementation, which may impact performance.

**Library Used**

None explicitly mentioned in the provided code. However, WeakSets are a built-in JavaScript data structure and do not rely on external libraries.

**Special JS Feature or Syntax**

* Symbols: The benchmark uses symbols as values in some of the WeakSet implementations, taking advantage of their unique properties to optimize performance.
* Map: Although not explicitly used, the `Array.from()` method is used with a custom sorting function (`toSorted()`) that may utilize similar concepts as those found in the Map data structure.

Overall, the benchmark provides a comprehensive comparison of different approaches for using WeakSets in JavaScript, helping developers understand the trade-offs and potential optimizations for their specific use cases.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15

Browser/OS: Safari 17 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
WEAKSET string	5956.4 Ops/sec
WEAKSET number	5781.2 Ops/sec
WEAKSET obj	5956.4 Ops/sec
WEAKSET symbol	5845.3 Ops/sec
WEAKSET mixed	5672.1 Ops/sec

Related benchmarks:

WeakSet common many types (version: 0)

Comparing performance of: WEAKSET string vs WEAKSET number vs WEAKSET obj vs WEAKSET symbol vs WEAKSET mixed

Created: 5 months ago by: Registered User

Jump to the latest result

WEAKSET string

WEAKSET number

WEAKSET obj

WEAKSET symbol

WEAKSET mixed

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