Benchmark: elementFromPoint

HTML Preparation code:

<style>
#container * {
  display: flex;
  flex: 1 1 50px;
  background: red;
}
#container .tick {
  flex-direction: row
  width: 20px;
  height: auto;
}
#container .tock {
  flex-direction: column
  width: auto;
  height: 20px;
}
</style>
<div id="container"></div>

Script Preparation code:

const container = document.getElementById("container");
const depth = 10;
const childrenPerLevel = 3;

/**
 * @param {HTMLElement} parent
 * @param {boolean} isTick
 */
const addElement = (parent, isTick) => {
  const el = document.createElement("div");
  el.classList.add(isTick ? "tick" : "tock");
  parent.appendChild(el);
  return el;
};

let currLevel = [container];
let nextLevel = [];
for (let i = 0; i < depth; i++) {
  for (const parent of currLevel) {
    for (let j = 0; j < childrenPerLevel; j++) {
      nextLevel.push(addElement(parent, i % 2 === 0));
    }
  }
  currLevel = nextLevel;
  nextLevel = [];
}

Tests:

elementFromPoint
const n = 1000; const nsq = Math.floor(Math.sqrt(n)); const arr = Array(n).fill(0).map((v,i)=>i); arr.map((v,i)=>document.elementFromPoint(i%nsq, Math.floor(i/nsq)));
second
console.log(".");

Historical Performance Data aggregated from 28 community runs

Desktop Results:

Chrome 22 runs

second

453K/s

elementFromPoint

446/s

Fastest: second (1016.9x faster)

View exact numbers

✓ second: 453,361 ops/sec
• elementFromPoint: 446 ops/sec

Firefox 6 runs

second

163K/s

elementFromPoint

198/s

Fastest: second (822.4x faster)

View exact numbers

✓ second: 162,971 ops/sec
• elementFromPoint: 198 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
elementFromPoint
second

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36

Browser/OS: Chrome 139 on Mac OS X 10.15.7

View result in a separate tab

second

799K/s

elementFromPoint

518/s

View exact numbers

Test name	Executions per second
✓ second	799,148 Ops/sec
elementFromPoint	518 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring JavaScript performance is essential for optimizing web applications. The provided JSON represents two benchmark definitions: `elementFromPoint` and `second`.

**Benchmark Definition: elementFromPoint**

This benchmark tests the performance of the `document.elementFromPoint(x, y)` method, which returns the element at the specified coordinates within an element or its descendants.

**Options Compared:**

1. **Native Method**: Using the native `document.elementFromPoint(x, y)` method.
2. **Custom Implementation**: Implementing a custom loop to calculate the coordinates and return the corresponding element.

**Pros and Cons:**

* Native Method:
	+ Pros: Fast and efficient implementation provided by the browser engine.
	+ Cons: May not be optimized for performance in certain scenarios or edge cases.
* Custom Implementation:
	+ Pros: Can provide more control over the calculation logic, allowing for potential optimization.
	+ Cons: May introduce additional overhead due to custom calculations.

**Library:**

None explicitly mentioned. However, the use of `document` and DOM manipulation functions suggests that the benchmark is targeting standard web browsers.

**Special JS Feature/Syntax:**

None explicitly mentioned.

**Benchmark Preparation Code Explanation:**

The script preparation code creates a container element with multiple child elements, arranged in a tree-like structure. The `addElement` function is used to create new child elements, which are then appended to the parent element. This process is repeated for 10 levels of depth. The purpose of this setup is to test the performance of the `document.elementFromPoint(x, y)` method in various scenarios.

**Individual Test Cases:**

1. `elementFromPoint`:
	* Tests the native `document.elementFromPoint(x, y)` method with a large number of coordinates (n = 1000) and square root optimization (`nsq`).
2. `second`:
	* Tests the performance of a simple console log statement.

**Latest Benchmark Result:**

The latest benchmark result shows that Firefox 132 performs better than other test cases, indicating potential optimization or improvements in the browser engine.

**Other Alternatives:**

1. **Benchmarking Frameworks:** Popular frameworks like Benchmark.js or JSPerf can be used to create and run benchmarks.
2. **Browser-specific APIs:** Some browsers have their own benchmarking APIs, such as Chrome's `benchmark` API or Safari's `benchmark` API.
3. **JS performance testing tools:** Tools like PerfTree or WebPageTest can be used to test web page performance, including JavaScript performance.

In conclusion, the provided benchmark definition tests the performance of the `document.elementFromPoint(x, y)` method using a custom implementation and native method, allowing users to compare their performance and identify potential optimization opportunities.

elementFromPoint (version: 0)

Comparing performance of: `elementFromPoint vs second`

Created: 2 years ago by: Guest

Go to the latest result

elementFromPoint

second

Historical Performance Data aggregated from 28 community runs

Desktop Results:

Chrome 22 runs

Firefox 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

elementFromPoint (version: 0)

Comparing performance of: elementFromPoint vs second

Created: 2 years ago by: Guest

Go to the latest result

elementFromPoint

second

Historical Performance Data aggregated from 28 community runs

Desktop Results:

Chrome 22 runs

Firefox 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `elementFromPoint vs second`