Benchmark: Using Keys vs For Loop v2

Tests:

Simple Lookup Version

function getLowBits(byte, numBits){
    return ((byte >> numBits << numBits) ^ byte)
}

let actions = {
    0x9: [{id:"note_on", hiByte0: 0x9, loByte0: '', type:"simple", getAction(bytes){return createAction(bytes, this)}}],
    0x8: [
            {id:"bank_select", hiByte0: 0x9, loByte0: '', secondary:[0x00, 0x20], type:"msblsb", getAction(bytes){return createAction2(bytes, this)}},
            {id:"mod_wheel", hiByte0: 0x9, loByte0: '', secondary:[0x01, 0x21], type:"msblsb", getAction(bytes){return createAction2(bytes, this)}}
        ]
}

function createAction(bytes, action){
    return {id: action.id, channel: getLowBits(bytes[0], 4), type: "", note: bytes[1], volume: bytes[2]} 
    
}

function createAction2(bytes, action){
    if (action.type === "msblsb"){
        let i = action.secondary.indexOf(bytes[1])
        if (i!==-1){
            return {id: action.id, channel: getLowBits(bytes[0], 4), type: i=0?"msb":"lsb", value: bytes[2]} 
            // its a match! dunno if high or low
        } else {
            return null     // no match
        }
    }
    return null
}

let midi = [0x85, 0x21, 0x64]
//let midi = [0x95, 0x21, 0x64]
let hiByte = midi[0]>> 4
let matches = actions[hiByte]
let result
if (matches.length > 1){
    for (let i = 0; i < matches.length; i++) {
        result = matches[i].getAction(midi);
        if (result){
            //console.log(JSON.stringify(result))        
            break;
        }
        
    }
} else {
    result = matches[0].getAction(midi)
    //console.log(JSON.stringify(result))
}

​x
 
function getLowBits(byte, numBits){    return ((byte >> numBits << numBits) ^ byte)}​let actions = {    0x9: [{id:"note_on", hiByte0: 0x9, loByte0: '', type:"simple", getAction(bytes){return createAction(bytes, this)}}],    0x8: [            {id:"bank_select", hiByte0: 0x9, loByte0: '', secondary:[0x00, 0x20], type:"msblsb", getAction(bytes){return createAction2(bytes, this)}},            {id:"mod_wheel", hiByte0: 0x9, loByte0: '', secondary:[0x01, 0x21], type:"msblsb", getAction(bytes){return createAction2(bytes, this)}}        ]}​function createAction(bytes, action){    return {id: action.id, channel: getLowBits(bytes[0], 4), type: "", note: bytes[1], volume: bytes[2]}     }​function createAction2(bytes, action){    if (action.type === "msblsb"){        let i = action.secondary.indexOf(bytes[1])        if (i!==-1){            return {id: action.id, channel: getLowBits(bytes[0], 4), type: i=0?"msb":"lsb", value: bytes[2]}             // its a match! dunno if high or low        } else {            return null     // no match        }    }    return null}​let midi = [0x85, 0x21, 0x64]//let midi = [0x95, 0x21, 0x64]let hiByte = midi[0]>> 4let matches = actions[hiByte]let resultif (matches.length > 1){    for (let i = 0; i < matches.length; i++) {        result = matches[i].getAction(midi);        if (result){            //console.log(JSON.stringify(result))                    break;        }            }} else {    result = matches[0].getAction(midi)    //console.log(JSON.stringify(result))}​

With lookup Loop

function getLowBits(byte, numBits){
    return ((byte >> numBits << numBits) ^ byte)
}

let actions = {
    0x9: [{id:"note_on", hiByte0: 0x9, loByte0: '', type:"simple", getAction(bytes){return createAction(bytes, this)}}],
    0x8: [
            {id:"bank_select", hiByte0: 0x9, loByte0: '', secondary:[0x00, 0x20], type:"msblsb", getAction(bytes){return createAction2(bytes, this)}},
            {id:"mod_wheel", hiByte0: 0x9, loByte0: '', secondary:[0x01, 0x21], type:"msblsb", getAction(bytes){return createAction2(bytes, this)}}
        ]
}

function createAction(bytes, action){
    if (action.type==="simple"){
        return {id: action.id, channel: getLowBits(bytes[0], 4), type: "", note: bytes[1], volume: bytes[2]} 
    }
}

function createAction2(bytes, action){
    if (action.type === "msblsb"){
        let i = action.secondary.indexOf(bytes[1])
        if (i!==-1){
            return {id: action.id, channel: getLowBits(bytes[0], 4), type: i=0?"msb":"lsb", value: bytes[2]} 
            // its a match! dunno if high or low
        } else {
            return null     // no match
        }
    }
    return null
}

//let midi = [0x85, 0x21, 0x64]
let midi = [0x95, 0x21, 0x64]
let hiByte = midi[0]>> 4
let matches = actions[hiByte]
let result
if (matches.length > 1){
    for (let i = 0; i < matches.length; i++) {
        result = matches[i].getAction(midi);
        if (result){
            //console.log(JSON.stringify(result))        
            break;
        }
        
    }
} else {
    result = matches[0].getAction(midi)
    //console.log(JSON.stringify(result))
}

 
function getLowBits(byte, numBits){    return ((byte >> numBits << numBits) ^ byte)}​let actions = {    0x9: [{id:"note_on", hiByte0: 0x9, loByte0: '', type:"simple", getAction(bytes){return createAction(bytes, this)}}],    0x8: [            {id:"bank_select", hiByte0: 0x9, loByte0: '', secondary:[0x00, 0x20], type:"msblsb", getAction(bytes){return createAction2(bytes, this)}},            {id:"mod_wheel", hiByte0: 0x9, loByte0: '', secondary:[0x01, 0x21], type:"msblsb", getAction(bytes){return createAction2(bytes, this)}}        ]}​function createAction(bytes, action){    if (action.type==="simple"){        return {id: action.id, channel: getLowBits(bytes[0], 4), type: "", note: bytes[1], volume: bytes[2]}     }}​function createAction2(bytes, action){    if (action.type === "msblsb"){        let i = action.secondary.indexOf(bytes[1])        if (i!==-1){            return {id: action.id, channel: getLowBits(bytes[0], 4), type: i=0?"msb":"lsb", value: bytes[2]}             // its a match! dunno if high or low        } else {            return null     // no match        }    }    return null}​//let midi = [0x85, 0x21, 0x64]let midi = [0x95, 0x21, 0x64]let hiByte = midi[0]>> 4let matches = actions[hiByte]let resultif (matches.length > 1){    for (let i = 0; i < matches.length; i++) {        result = matches[i].getAction(midi);        if (result){            //console.log(JSON.stringify(result))                    break;        }            }} else {    result = matches[0].getAction(midi)    //console.log(JSON.stringify(result))}​

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Simple Lookup Version
With lookup Loop

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 84 on Windows

View result in a separate tab

Test name	Executions per second
Simple Lookup Version	3936700.8 Ops/sec
With lookup Loop	4869159.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

Let's break down the benchmark and explain what's being tested.

Benchmark Definition

The benchmark is designed to compare two approaches for optimizing a lookup process in a MIDI (Musical Instrument Digital Interface) system. The goal is to find the fastest way to perform this lookup, which involves searching through an array of actions based on a specific byte value.

Options Being Compared

There are two options being compared:

Simple Lookup Version: This approach uses a direct lookup in the actions object using the hiByte value as the key.
With lookup Loop: This approach uses a loop to iterate through each action in the actions array and check if the hiByte value matches.

Pros and Cons of Each Approach

Simple Lookup Version
- Pros:
  - Fast, as it directly accesses the actions object using the hiByte value.
  - Low overhead, as it only requires a single lookup.
- Cons:
  - May not handle cases where there are multiple matches for the same byte value.
With lookup Loop
- Pros:
  - Can handle cases where there are multiple matches for the same byte value.
- Cons:
  - Slower, as it requires iterating through each action in the actions array.
  - Higher overhead, as it involves more computations.

Library Used

In both test cases, the getLowBits function is used to extract the low bits from a byte value. This function is not a standard JavaScript library, but rather a custom implementation specific to this benchmark.

Special JS Feature or Syntax

There doesn't seem to be any special JavaScript features or syntax being used in these benchmarks. The code appears to be standard JavaScript with some custom functions and variables defined specifically for this benchmark.

Other Alternatives

If the goal is to optimize this lookup process, other alternatives could include:

Using a hash table data structure instead of an array.
Caching the results of previous lookups to avoid repeated searches.
Using a more efficient algorithm, such as binary search.

Overall, this benchmark appears to be designed to test the performance of different approaches to optimizing a lookup process in a MIDI system.

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Definition**

**Options Being Compared**

There are two options being compared:

1. **Simple Lookup Version**: This approach uses a direct lookup in the `actions` object using the `hiByte` value as the key.
2. **With lookup Loop**: This approach uses a loop to iterate through each action in the `actions` array and check if the `hiByte` value matches.

**Pros and Cons of Each Approach**

1. **Simple Lookup Version**
	* Pros:
		+ Fast, as it directly accesses the `actions` object using the `hiByte` value.
		+ Low overhead, as it only requires a single lookup.
	* Cons:
		+ May not handle cases where there are multiple matches for the same byte value.
2. **With lookup Loop**
	* Pros:
		+ Can handle cases where there are multiple matches for the same byte value.
	* Cons:
		+ Slower, as it requires iterating through each action in the `actions` array.
		+ Higher overhead, as it involves more computations.

**Library Used**

In both test cases, the `getLowBits` function is used to extract the low bits from a byte value. This function is not a standard JavaScript library, but rather a custom implementation specific to this benchmark.

**Special JS Feature or Syntax**

**Other Alternatives**

If the goal is to optimize this lookup process, other alternatives could include:

* Using a hash table data structure instead of an array.
* Caching the results of previous lookups to avoid repeated searches.
* Using a more efficient algorithm, such as binary search.

Overall, this benchmark appears to be designed to test the performance of different approaches to optimizing a lookup process in a MIDI system.

Related benchmarks:

Using Keys vs For Loop v2 (version: 1)

Trying to optimize for speed!

Comparing performance of: Simple Lookup Version vs With lookup Loop

Created: 4 years ago by: Registered User

Jump to the latest result