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

​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

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

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

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

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

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

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:

SoA (Single Array): Each vector is stored as an object within an array, where each element in the array represents a vector.
Interlaced Array: A single Float32Array is used, and values for x, y, and z are interlaced within it to represent vectors.
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

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

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**

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

Related benchmarks: