Benchmark: func table vs switch

Script Preparation code:

const buffer = new ArrayBuffer(644);
const view = new DataView(buffer);
let offs = 0;
let O=0;
view.setInt8(offs, 33, true);offs+=1;
view.setInt8(offs, 21, true);offs+=1;
view.setInt8(offs, 25, true);offs+=1;
view.setInt8(offs, 40, true);offs+=1;
for (let i = 0; i < 40; ++i) {
  view.setInt32(offs, 33, true);offs+=4;
  view.setInt32(offs, 21, true);offs+=4;
  view.setInt32(offs, 25, true);offs+=4;
  view.setInt32(offs, 40, true);offs+=4;
}


let F=[
  (a,b)=>{let c=a.getInt8(b,true);return [c,b+1];},
  (a,b)=>{let c=a.getInt16(b,true);return [c,b+2];},
  (a,b)=>{let c=a.getInt32(b,true);return [c,b+4];},
  (a,b)=>{let c=a.getInt64(b,true);return [c,b+8];}
];

let Z=[
  (a)=>{let c=a.getInt8(O,true);O+=1;return c;},
  (a)=>{let c=a.getInt16(O,true);O+=2;return c;},
  (a)=>{let c=a.getInt32(O,true);O+=4;return c;},
  (a)=>{let c=a.getInt64(O,true);O+=8;return c;}
];

let G=(a,b,c)=>{
  let d=0;
  switch(c){
    case 0:
      d=a.getInt8(b,true);b+=1;break;
    case 1:
      d=a.getInt16(b,true);b+=2;break;
    case 2:
      d=a.getInt32(b,true);b+=4;break;
    case 3:
      d=a.getInt64(b,true);b+=8;break;
  }
  return [d,b];
}

Tests:

All inline
let H=Array(4),k=0; let z=0; H[0]=view.getInt8(z,true);++z; H[1]=view.getInt8(z,true);++z; H[2]=view.getInt8(z,true);++z; k=view.getInt8(z,true);++z; H[3]=Array(k); for (let i = 0; i < k; ++i){ H[3][i]=Array(4); H[3][i][0]=view.getInt32(z,true); z+=4; H[3][i][1]=view.getInt32(z,true); z+=4; H[3][i][2]=view.getInt32(z,true); z+=4; H[3][i][3]=view.getInt32(z,true); z+=4; }
All inline 2
let H=Array(4),k=0; let z=0; H[0]=view.getInt8(z,true);++z; H[1]=view.getInt8(z,true);++z; H[2]=view.getInt8(z,true);++z; k=view.getInt8(z,true);++z; let y=Array(k); for (let i = 0; i < k; ++i){ y[i]=Array(4); y[i][0]=view.getInt32(z,true); z+=4; y[i][1]=view.getInt32(z,true); z+=4; y[i][2]=view.getInt32(z,true); z+=4; y[i][3]=view.getInt32(z,true); z+=4; } H[3]=y;
all inline 3
let H=Array(4),k=0; let z=0; H[0]=view.getInt8(z,true);++z; H[1]=view.getInt8(z,true);++z; H[2]=view.getInt8(z,true);++z; k=view.getInt8(z,true);++z; let y=Array(k); for (let i = 0; i < k; ++i){ let x=Array(4); x[0]=view.getInt32(z,true); z+=4; x[1]=view.getInt32(z,true); z+=4; x[2]=view.getInt32(z,true); z+=4; x[3]=view.getInt32(z,true); z+=4; y[i]=x; } H[3]=y;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
All inline
All inline 2
all inline 3

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Safari 16 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
All inline	2205101.5 Ops/sec
All inline 2	2313312.2 Ops/sec
all inline 3	2331562.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 days ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the JSON document compares several approaches to accessing and manipulating binary data using the `DataView` API in JavaScript. The goal is to determine which method offers better performance in terms of execution speed while handling data extraction from a typed array.

### Test Overview

1. **Data Preparation**: Before running the benchmarks, the `Script Preparation Code` constructs a `DataView` from an `ArrayBuffer`. The buffer is populated with a sequence of integers using various methods, allowing structured data access later. Specifically, the buffer holds:
   - Initial integer values set with `setInt8`, `setInt32`, etc.
   - A series of integers that are intended to be extracted later using different techniques.

2. **Benchmark Cases**:
   - **All inline**: This approach reads directly from the `DataView` using inline processing, storing results in a two-level nested array structure.
   - **All inline 2**: Similar to the first case but uses a temporary array (`y`) to store the results before assigning it to `H[3]`.
   - **All inline 3**: This implementation uses a separate `x` array to hold the data for each iteration before adding `x` to the `y` array.

### Evaluation Criteria & Performance Metrics

The performance of each test is measured in terms of "Executions Per Second." The latest benchmark results indicate that:
- **All inline 3**: 2,331,562.0 executions/second
- **All inline 2**: 2,313,312.25 executions/second
- **All inline**: 2,205,101.5 executions/second

The results suggest that the "All inline 3" approach is the fastest, followed closely by "All inline 2" and then "All inline."

### Pros and Cons of Each Approach

1. **All inline**:
   - **Pros**:
     - Direct reading without intermediate structures.
     - Easier to understand for small data sets.
   - **Cons**:
     - Less flexible if subsequent processing or modification of resulting data is needed; inline manipulation can reduce readability.

2. **All inline 2**:
   - **Pros**:
     - Temporarily stores data which can be useful for debugging.
     - May allow for more complex manipulations and checks on `y` before final assignment.
   - **Cons**:
     - Slightly increased overhead from additional data copies, potentially reducing speed compared to "All inline 3".

3. **All inline 3**:
   - **Pros**:
     - Provides clarity through the use of a dedicated structure `x` for each row of data.
     - It balances maintainability and efficiency.
   - **Cons**:
     - Introduces extra variables, which could lead to slightly higher memory usage.

### Libraries and Features Used

- **DataView**: A built-in JavaScript feature that allows for reading and writing multiple number types from an `ArrayBuffer`. It provides a method to handle binary data in a platform-independent way, which is essential for performance-critical applications like data handling and graphics.

### Other Considerations and Alternatives

- Alternatives to the `DataView` include using the typed arrays (`Int8Array`, `Int16Array`, etc.) directly, which can simplify code when all you need is access to simple numeric types. However, `DataView` is more versatile for mixed data types, while typed arrays are optimized for specific data types, providing better performance in those scenarios.
  
- **Performance Profiling**: When conducting performance benchmarks, always consider using the JavaScript performance tools available in modern browsers (like Chrome DevTools or Firefox Developer Edition) for more detailed profiling and to account for variations in results across different runs.

In summary, the benchmark evaluates the performance of reading structured binary data using `DataView` with different strategies, allowing developers to make informed decisions on which approach optimizes performance based on their specific use case.

Related benchmarks:

func table vs switch (version: 10)

Comparing performance of: All inline vs All inline 2 vs all inline 3

Created: 3 days ago by: Registered User

Jump to the latest result

All inline

All inline 2

all inline 3

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 days ago):