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

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

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

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

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

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The benchmark compares three approaches to process a list of vectors:

1. **SoA (Single Array)**: Each vector is stored as an object within an array, where each element in the array represents a vector.
2. **Interlaced Array**: A single `Float32Array` is used, and values for x, y, and z are interlaced within it to represent vectors.
3. **AoS (Array of Objects)**: Each vector is stored as an object within an array.

**Options Compared**

The benchmark tests the performance differences between these three approaches:

* SoA: Using an array of objects to store vectors
* Interlaced Array: Using a single `Float32Array` with interlaced values for x, y, and z
* AoS (Array of Objects): Using an array of objects to store vectors

**Pros and Cons**

1. **SoA (Single Array)**:
	* Pros:
		+ Easy to implement and understand
		+ No extra memory allocation required
	* Cons:
		+ May lead to slower performance due to object creation and lookup
2. **Interlaced Array**:
	* Pros:
		+ Can be faster than SoA for large datasets
		+ Reduces memory overhead by using a single array
	* Cons:
		+ Requires loop unrolling or manual indexing to access individual vector components
3. **AoS (Array of Objects)**:
	* Pros:
		+ Easy to understand and implement
		+ Can be faster than SoA for small datasets
	* Cons:
		+ May lead to slower performance due to object creation and lookup

**Loop Unrolling**

The Interlaced Array approach uses loop unrolling, where the loop iterates 3 times instead of 1. This can improve performance by reducing branch prediction errors.

**Browser Results**

The benchmark results show that:

* SoA (Single Array) is the slowest approach
* Interlaced Array with loop unrolling is faster than SoA
* Interlaced Array without loop unrolling is slower than SoA
* AoS (Array of Objects) performs similarly to SoA

**Other Considerations**

When choosing an approach, consider the trade-offs between memory usage and performance. If you need to process large datasets, the Interlaced Array approach might be a good choice. However, if you prioritize readability and maintainability, SoA or AoS might be a better fit.

Keep in mind that this benchmark is specific to JavaScript and may not generalize to other languages or platforms.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/114.0

Browser/OS: Firefox 114 on Linux

View result in a separate tab

Test name	Executions per second
AoS	218.4 Ops/sec
SoA	422.8 Ops/sec
SoA - one component per loop	419.0 Ops/sec
Interlaced Array - no loop unrolling	279.0 Ops/sec
Interlaced Array - with loop unrolling	382.5 Ops/sec

Related benchmarks:

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

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: 8 years ago by: Registered User

Jump to the latest result

AoS

SoA

SoA - one component per loop

Interlaced Array - no loop unrolling

Interlaced Array - with loop unrolling

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):