Benchmark: soa vs aos - MeasureThat.net

Script Preparation code:

var N = 1000000;

var x = [], y = [], z = [];

var xt = new Float32Array(1000000);
var yt = new Float32Array(1000000);
var zt = new Float32Array(1000000);

var vectors = [];

for(var i = 0; i < N; i++){
  x[i] = Math.random();
  y[i] = Math.random();
  z[i] = Math.random();
  
  xt[i] = x[i];
  yt[i] = y[i];
  zt[i] = z[i];
  
  vectors[i] = { x: x[i], y: y[i], z: z[i] };
}

var vector;

​x
 
var N = 1000000;​var x = [], y = [], z = [];​var xt = new Float32Array(1000000);var yt = new Float32Array(1000000);var zt = new Float32Array(1000000);​var vectors = [];​for(var i = 0; i < N; i++){  x[i] = Math.random();  y[i] = Math.random();  z[i] = Math.random();    xt[i] = x[i];  yt[i] = y[i];  zt[i] = z[i];    vectors[i] = { x: x[i], y: y[i], z: z[i] };}​var vector;

Tests:

soa

for (var i = 0, li=x.length; i < li; ++i) {
    xt[i] = 2 * xt[i];
    yt[i] = 2 * yt[i];
    zt[i] = 2 * zt[i];
}

 
for (var i = 0, li=x.length; i < li; ++i) {    xt[i] = 2 * xt[i];    yt[i] = 2 * yt[i];    zt[i] = 2 * zt[i];}

aos

for (var i = 0, li=vectors.length; i < li; ++i) {
    vector = vectors[i];
    vector.x = 2 * vector.x;
    vector.y = 2 * vector.y;
    vector.z = 2 * vector.z;
}

 
for (var i = 0, li=vectors.length; i < li; ++i) {    vector = vectors[i];    vector.x = 2 * vector.x;    vector.y = 2 * vector.y;    vector.z = 2 * vector.z;}

soa mark II

for (var i = 0, li=xt.length; i < li; ++i) {
    xt[i] = 2 * xt[i];
}
for (var i = 0, li=yt.length; i < li; ++i) {
    yt[i] = 2 * yt[i];
}
for (var i = 0, li=zt.length; i < li; ++i) {
    zt[i] = 2 * zt[i];
}

 
for (var i = 0, li=xt.length; i < li; ++i) {    xt[i] = 2 * xt[i];}for (var i = 0, li=yt.length; i < li; ++i) {    yt[i] = 2 * yt[i];}for (var i = 0, li=zt.length; i < li; ++i) {    zt[i] = 2 * zt[i];}

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
soa
aos
soa mark II

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
soa	74.3 Ops/sec
aos	6.4 Ops/sec
soa mark II	69.5 Ops/sec

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

Overview of the Benchmark

The provided JSON represents a JavaScript microbenchmark test case, specifically comparing two approaches to vector operations: Staged Operations (SOA) and Array Operations (AOs).

What is being tested?

In this benchmark, two sets of vectors are created: xt, yt, and zt are 1,000,000-element Float32Array arrays, while x, y, and z are regular JavaScript arrays. The test case then performs a series of operations on each array:

In the "SOA" variant, the three sets of vectors are processed sequentially:
- xt[i] = 2 * xt[i];
- yt[i] = 2 * yt[i];
- zt[i] = 2 * zt[i];
In the "AOs" variant, a single loop iterates over all three sets of vectors simultaneously:
- vector = vectors[i];
- vector.x = 2 * vector.x;
- vector.y = 2 * vector.y;
- vector.z = 2 * vector.z;

Options compared

Two main options are being compared:

Staged Operations (SOA): This approach processes each set of vectors sequentially, which can lead to better performance due to:
- Reduced memory access overhead
- Improved cache locality
Array Operations (AOs): This approach iterates over all three sets of vectors simultaneously, which may incur additional costs due to:
- Increased memory access overhead
- Decreased cache locality

Pros and Cons

Pros of SOA:

Reduced memory access overhead
Improved cache locality
Potential for better performance

Cons of SOA:

May require more complex code structure
May lead to slower startup times due to the sequential processing of arrays

Pros of AOs:

Simpler code structure
Easier maintenance and modification

Cons of AOs:

Increased memory access overhead
Decreased cache locality
Potential for reduced performance

Library/Function usage

No specific libraries or functions are used in this benchmark, only built-in JavaScript features.

Special JS feature/syntax

The benchmark uses the for...in loop (not shown explicitly) to iterate over the array elements, which is a legacy syntax. However, it does not use any modern ES6+ features like for...of, forEach, or arrow functions.

Alternative approaches

Other alternatives for vector operations in JavaScript include:

Native Web Workers: Using native Web Workers allows for true parallelism and can significantly improve performance.
GPU Acceleration: Some libraries, such as Three.js, provide GPU acceleration capabilities for graphics-intensive tasks. However, this may not be suitable for general-purpose vector operations.
Custom Optimizations: Depending on the specific use case, it might be possible to optimize the code further using custom optimizations, such as SIMD instructions or bit manipulation.

Keep in mind that the best approach will depend on the specific requirements and constraints of your application.

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript microbenchmark test case, specifically comparing two approaches to vector operations: Staged Operations (SOA) and Array Operations (AOs).

**What is being tested?**

In this benchmark, two sets of vectors are created: `xt`, `yt`, and `zt` are 1,000,000-element Float32Array arrays, while `x`, `y`, and `z` are regular JavaScript arrays. The test case then performs a series of operations on each array:

*   In the "SOA" variant, the three sets of vectors are processed sequentially:
    *   `xt[i] = 2 * xt[i];`
    *   `yt[i] = 2 * yt[i];`
    *   `zt[i] = 2 * zt[i];`
*   In the "AOs" variant, a single loop iterates over all three sets of vectors simultaneously:
    *   `vector = vectors[i];`
    *   `vector.x = 2 * vector.x;`
    *   `vector.y = 2 * vector.y;`
    *   `vector.z = 2 * vector.z;`

**Options compared**

Two main options are being compared:

*   **Staged Operations (SOA)**: This approach processes each set of vectors sequentially, which can lead to better performance due to:
    *   Reduced memory access overhead
    *   Improved cache locality
*   **Array Operations (AOs)**: This approach iterates over all three sets of vectors simultaneously, which may incur additional costs due to:
    *   Increased memory access overhead
    *   Decreased cache locality

**Pros and Cons**

Pros of SOA:

*   Reduced memory access overhead
*   Improved cache locality
*   Potential for better performance

Cons of SOA:

*   May require more complex code structure
*   May lead to slower startup times due to the sequential processing of arrays

Pros of AOs:

*   Simpler code structure
*   Easier maintenance and modification

Cons of AOs:

*   Increased memory access overhead
*   Decreased cache locality
*   Potential for reduced performance

**Library/Function usage**

No specific libraries or functions are used in this benchmark, only built-in JavaScript features.

**Special JS feature/syntax**

The benchmark uses the `for...in` loop (not shown explicitly) to iterate over the array elements, which is a legacy syntax. However, it does not use any modern ES6+ features like `for...of`, `forEach`, or arrow functions.

**Alternative approaches**

Other alternatives for vector operations in JavaScript include:

*   **Native Web Workers**: Using native Web Workers allows for true parallelism and can significantly improve performance.
*   **GPU Acceleration**: Some libraries, such as Three.js, provide GPU acceleration capabilities for graphics-intensive tasks. However, this may not be suitable for general-purpose vector operations.
*   **Custom Optimizations**: Depending on the specific use case, it might be possible to optimize the code further using custom optimizations, such as SIMD instructions or bit manipulation.

Keep in mind that the best approach will depend on the specific requirements and constraints of your application.

Related benchmarks:

soa vs aos (version: 0)

As titled

Comparing performance of: soa vs aos vs soa mark II

Created: 8 years ago by: Guest

Jump to the latest result

soa

aos