Benchmark: Multiplying lists of vectors - SoA vs AoS vs interlaced array - local

Multiplying lists of vectors - SoA vs AoS vs interlaced array - local (version: 0)

What's the fastest way to process a list of vectors? Do you go the OO route, with an array of Vector() objects? Do you create a new data structure, using Float32Arrays for x, y, and z? Do you create a single Float32Array and interlace values for x, y, and z within it? Let's find out!

Comparing performance of: AoS vs SoA vs SoA - one component per loop vs Interlaced Array - no loop unrolling vs Interlaced Array - with loop unrolling

Created: 4 years ago by: Guest

Jump to the latest result

Script Preparation code:

var N = 1000000

var x = new Float32Array(N);
var y = new Float32Array(N);
var z = new Float32Array(N);

var interlaced = new Float32Array(3*N);

var vectors = [];

for (var i = 0, li=x.length; i < li; ++i) {
	x[i] = Math.random();
	y[i] = Math.random();
	z[i] = Math.random();
	vectors.push( {x:Math.random(), y:Math.random(), z:Math.random()} );
}

for (var i = 0, li=interlaced.length; i < li; ++i) {
	interlaced[i] = Math.random();
}

Tests:

AoS
var vector; 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
let x1 = x; let y1 = y; let z1 = z; for (var i = 0, li=x1.length; i < li; ++i) { x1[i] = 2 * x1[i]; y1[i] = 2 * y1[i]; z1[i] = 2 * z1[i]; }
SoA - one component per loop
let x2 = x; let y2 = y; let z2 = z; for (var i = 0, li=x2.length; i < li; ++i) { x2[i] = 2 * x2[i]; } for (var i = 0, li=y2.length; i < li; ++i) { y2[i] = 2 * y2[i]; } for (var i = 0, li=z2.length; i < li; ++i) { z2[i] = 2 * z2[i]; }
Interlaced Array - no loop unrolling
let interlaced2 = interlaced; for (var i = 0, li=interlaced2.length; i < li; ++i) { interlaced2[i] = 2*interlaced2[i]; }
Interlaced Array - with loop unrolling
let interlaced3 = interlaced; for (var i = 0, li=interlaced3.length; i < li; i+=3) { interlaced3[i] = 2*interlaced3[i]; interlaced3[i+1] = 2*interlaced3[i+1]; interlaced3[i+2] = 2*interlaced3[i+2]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
AoS
SoA
SoA - one component per loop
Interlaced Array - no loop unrolling
Interlaced Array - with loop unrolling

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/115.0

Browser/OS: Firefox 115 on Windows

View result in a separate tab

Test name	Executions per second
AoS	92.1 Ops/sec
SoA	145.2 Ops/sec
SoA - one component per loop	157.9 Ops/sec
Interlaced Array - no loop unrolling	158.7 Ops/sec
Interlaced Array - with loop unrolling	153.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its options.

**Benchmark Definition**

The benchmark measures the performance of multiplying lists of vectors in three different ways:

1. **SoA (Structured Array)**: Each vector is represented as an object with `x`, `y`, and `z` properties, and there's a single array containing all these objects.
2. **AoS (Array of Objects)**: Each vector is represented as an object with `x`, `y`, and `z` properties, just like in SoA, but they're stored in separate arrays for each component (`x`, `y`, and `z`).
3. **Interlaced Array**: A single array containing all the components of all vectors, interleaved.

**Options Compared**

The benchmark compares the performance of these three approaches:

* **SoA with one component per loop**: This approach uses separate loops for each vector component (`x`, `y`, and `z`).
* **Interlaced Array with no loop unrolling**: This approach uses a single loop to access all components of all vectors, without loop unrolling.
* **Interlaced Array with loop unrolling**: This approach uses a single loop that accesses every third element (3 indices at a time) in the interleaved array.

**Pros and Cons**

Here's a brief summary of each approach:

* **SoA with one component per loop**:
	+ Pros: Easy to understand, predictable behavior.
	+ Cons: May lead to higher cache misses due to separate loops for each vector component.
* **Interlaced Array with no loop unrolling**:
	+ Pros: Avoids cache issues and reduces branching instructions.
	+ Cons: May not be as efficient due to a single loop accessing all components in sequence.
* **Interlaced Array with loop unrolling**:
	+ Pros: Reduces branching instructions, can improve performance by reducing cache misses.
	+ Cons: Requires careful tuning of the loop unrolling factor and may add more complex code.

**Special JS Features**

The benchmark does not use any special JavaScript features like `let`, `const`, or ES6 syntax. It only uses basic array operations and loops.

**Latest Benchmark Results**

The latest results show that:

* **Interlaced Array with no loop unrolling** is the fastest approach, followed closely by **SoA with one component per loop**.
* **Interlaced Array with loop unrolling** is slower than both of these approaches.

Keep in mind that the performance differences may vary depending on the specific use case and system configuration.

Related benchmarks: