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: 3 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();
}

​x
 
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;
}

 
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];
}

 
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];
}

 
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]; }
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]; }
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

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
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: 8 months 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 5 months ago):

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:

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.
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).
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.

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: