Benchmark: nodes vs attributes vs nodeValue string for READING DOM data storage benchmark

nodes vs attributes vs nodeValue string for READING DOM data storage benchmark (version: 0)

Comparing performance of: read nodes with 7 child nodes vs read attribute with 7 attributes vs read nodevalue with 7 string attributes vs read nodes with 3 child nodes vs read attribute with 3 attributes vs read nodevalue with 3 string attributes vs read nodes with 2 child nodes vs read attribute with 2 attributes vs read nodevalue with 2 string attributes vs obj with 7 entries vs read nodes with 4 child nodes backwards vs read nodes with 7 child nodes using children and go straight to position vs read nodes with 7 child nodes and base on position

Created: 4 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<div style='display: none'>
    <div id='node'>
      <name>cat</name>
      <not>blank</not>
      <not1>blank</not1>
      <not2>blank</not2>
      <not3>blank</not3>
      <not4>blank</not4>
      <type>bat</type>
    </div>
    <div id='attr' name='cat' type='bat' not='blank' not1='blank' not2='blank' not3='blank' not4='blank'></div>
  <div id='node2'><data>[name]cat[not]blank[not1]blank[not2]blank[not3]blank[not4]blank[type]bat[</data></div>
  
    <div id='nodeS'>
      <name>cat</name>
      <not>blank</not>
      <type>bat</type>
    </div>
    <div id='attrS' name='cat' type='bat' not='blank'></div>
  <div id='nodeS2'><data>[name]cat[not]blank[type]bat[</data></div>

    <div id='nodeS0'>
      <name>cat</name>
      <type>bat</type>
    </div>
    <div id='attrS0' name='cat' type='bat'></div>
  <div id='nodeS02'><data>[name]cat[type]bat[</data></div>
  
    <div id='nodeB0'>
      <name>cat</name>
      <not>blank</not>
      <type>bat</type>
      <not1>blank</not1>
    </div>
</div>

Script Preparation code:

var node = document.getElementById('node')
var attr = document.getElementById('attr')
var node2 = document.getElementById('node2')

var nodeS = document.getElementById('nodeS')
var attrS = document.getElementById('attrS')
var nodeS2 = document.getElementById('nodeS2')

var nodeS0 = document.getElementById('nodeS0')
var attrS0 = document.getElementById('attrS0')
var nodeS02 = document.getElementById('nodeS02')

var nodeB0 = document.getElementById('nodeB0')

var obj = { name:'cat', not:'blank', not1:'blank', not2:'blank', not3:'blank', not4:'blank', type:'bat' }

Tests:

read nodes with 7 child nodes
let elem = node.firstElementChild; let n; do { if ( elem.nodeName === 'TYPE' ) { n = elem.nodeValue; break; } } while (elem = elem.nextElementSibling)
read attribute with 7 attributes
let n = attr.getAttribute('type');
read nodevalue with 7 string attributes
let t = node2.firstElementChild.firstChild.nodeValue; let s = t.indexOf('[type]') let n = t.substring(s+6, t.indexOf('[', s+6) )
read nodes with 3 child nodes
let elem = nodeS.firstElementChild; let n; do { if ( elem.nodeName === 'TYPE' ) { n = elem.nodeValue; break; } } while (elem = elem.nextElementSibling)
read attribute with 3 attributes
let n = attrS.getAttribute('type');
read nodevalue with 3 string attributes
let t = nodeS2.firstElementChild.firstChild.nodeValue; let s = t.indexOf('[type]') let n = t.substring(s+6, t.indexOf('[', s+6) )
read nodes with 2 child nodes
let elem = nodeS0.firstElementChild; let n; do { if ( elem.nodeName === 'TYPE' ) { n = elem.nodeValue; break; } } while (elem = elem.nextElementSibling)
read attribute with 2 attributes
let n = attrS0.getAttribute('type');
read nodevalue with 2 string attributes
let t = nodeS02.firstElementChild.firstChild.nodeValue; let s = t.indexOf('[type]') let n = t.substring(s+6, t.indexOf('[', s+6) )
obj with 7 entries
let n = obj['type']
read nodes with 4 child nodes backwards
let elem = nodeB0.lastElementChild; let n; do { if ( elem.nodeName === 'TYPE' ) { n = elem.nodeValue; break; } } while (elem = elem.previousElementSibling)
read nodes with 7 child nodes using children and go straight to position
let n = node.children[6].nodeValue
read nodes with 7 child nodes and base on position
let elem = node.firstElementChild; let n; for (let i = 0; i<10; i++) { if ( i === 6 ) { n = elem.nodeValue; break; } elem = elem.nextElementSibling }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
read nodes with 7 child nodes
read attribute with 7 attributes
read nodevalue with 7 string attributes
read nodes with 3 child nodes
read attribute with 3 attributes
read nodevalue with 3 string attributes
read nodes with 2 child nodes
read attribute with 2 attributes
read nodevalue with 2 string attributes
obj with 7 entries
read nodes with 4 child nodes backwards
read nodes with 7 child nodes using children and go straight to position
read nodes with 7 child nodes and base on position

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the data.

It appears that the provided JSON string is a list of test execution results for a specific web page, likely related to testing XML or HTML parsing. Here are some key observations:

1. **Browser and Device**: All tests were run on Chrome 95 on Linux desktop platforms.
2. **Test Names**: The tests seem to cover various scenarios, such as:
	* Reading node values with different numbers of string attributes (e.g., 3, 7).
	* Reading attribute values with varying numbers of attributes (e.g., 2, 7, 3).
	* Reading nodes with different numbers of child nodes.
	* Backwards traversal of nodes with 4 child nodes.
3. **Execution Results**: The execution results are provided as "ExecutionsPerSecond" values, which suggest that the tests were run repeatedly to measure performance under varying loads.

To provide more specific insights or analysis, I'd need more context about what these tests are intended to evaluate (e.g., web page rendering performance, XML parsing efficiency). However, based on the data provided, it's clear that the tests cover a range of scenarios related to parsing and traversing complex XML structures.

Related benchmarks: