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: 8 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;

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

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

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

 
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

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 14_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.2 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 14 on iOS 14.7.1

View result in a separate tab

Test name	Executions per second
AoS	1.3 Ops/sec
SoA	1.8 Ops/sec
Interlaced Array - no loop unrolling	1.8 Ops/sec
Interlaced Array - with loop unrolling	1.6 Ops/sec
SoA - one component per loop	0.7 Ops/sec

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

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:

Staggered of Row (SoA): This approach uses separate arrays for each component (x, y, z) of a vector.
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.
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.

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

Related benchmarks: