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

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

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 Interlaced Array - no loop unrolling vs Interlaced Array - with loop unrolling vs SoA - one component per loop

Created: 9 years ago by: Registered User

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();
}
var vector;

Tests:

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; }
SoA
for (var i = 0, li=x.length; i < li; ++i) { x[i] = 2 * x[i]; y[i] = 2 * y[i]; z[i] = 2 * z[i]; }
Interlaced Array - no loop unrolling
for (var i = 0, li=interlaced.length; i < li; ++i) { interlaced[i] = 2*interlaced[i]; }
Interlaced Array - with loop unrolling
for (var i = 0, li=interlaced.length; i < li; i+=3) { interlaced[i] = 2*interlaced[i]; interlaced[i+1] = 2*interlaced[i+1]; interlaced[i+2] = 2*interlaced[i+2]; }
SoA - one component per loop
for (var i = 0, li=x.length; i < li; ++i) { x[i] = 2 * x[i]; } for (var i = 0, li=y.length; i < li; ++i) { y[i] = 2 * y[i]; } for (var i = 0, li=z.length; i < li; ++i) { z[i] = 2 * z[i]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided benchmark.

**Benchmark Definition**

The benchmark is designed to compare three approaches for multiplying lists of vectors:

1. **Staggered of Row (SoA)**: This approach uses separate arrays for each component (x, y, z) of a vector.
2. **Array of Objects (AoS)**: In this approach, an array of objects is used to represent the vectors, with each object having x, y, and z properties.
3. **Interlaced Array**: This approach uses a single array with three times the length of the original arrays, interlacing values for x, y, and z.

**Options Compared**

Each test case compares two approaches: one with loop unrolling and one without.

* SoA with loop unrolling vs. SoA without loop unrolling
* Interlaced Array with loop unrolling vs. Interlaced Array without loop unrolling
* AoS with loop unrolling vs. AoS without loop unrolling

**Pros and Cons**

* **SoA (Staggered of Row)**:
	+ Pros: Can be faster for certain operations, as each component can be processed independently.
	+ Cons: Requires more memory to store the separate arrays, and may require more complex indexing.
* **AoS (Array of Objects)**:
	+ Pros: Can be easier to implement and understand, as objects provide a natural way to represent data with multiple properties.
	+ Cons: May be slower due to object creation and lookup overhead.
* **Interlaced Array**:
	+ Pros: Uses less memory than SoA, and can be faster for certain operations by reducing cache misses.
	+ Cons: Requires careful indexing and may not perform well for all types of operations.

**Library Used**

None explicitly mentioned in the benchmark definition. However, the use of `Float32Array` suggests that JavaScript's built-in array support is being used to store numerical data.

**Special JS Features or Syntax**

No special features or syntax are used in this benchmark. The code follows standard JavaScript syntax and semantics.

**Execution Results**

The execution results show that:

* SoA with loop unrolling outperforms all other approaches
* Interlaced Array with loop unrolling performs better than without loop unrolling, but still lags behind SoA
* AoS with loop unrolling is the slowest approach

These results suggest that SoA with loop unrolling is a good choice for this specific benchmark. However, it's essential to note that performance may vary depending on the specific use case and requirements.

Related benchmarks: