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

Multiplying lists of vectors - SoA vs AoS vs interlaced array (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: SoA - one loop vs SoA - one component per loop vs Interlaced Array - no loop unrolling vs Interlaced Array - with loop unrolling

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

Tests:

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

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 the benchmark and its test cases.

**Benchmark Definition**

The benchmark measures the performance of three different approaches for processing a list of vectors:

1. **Structured Array (SoA)**: Each vector is represented as an object with separate fields for x, y, and z components.
2. **Interlaced Array**: A single Float32Array is used to store all three components, interleaved in memory.

**Test Cases**

There are four test cases:

1. **SoA - one loop**: This test case measures the performance of a single loop that updates each component of the vector (x, y, z) using a SoA.
2. **SoA - one component per loop**: In this test case, separate loops are used to update each component of the vector (x, y, z) individually.
3. **Interlaced Array - no loop unrolling**: This test case measures the performance of updating all three components of a vector using a single Float32Array without any loop unrolling.
4. **Interlaced Array - with loop unrolling**: In this test case, the loop is unrolled to update each component of the vector (x, y, z) in three separate iterations.

**Pros and Cons**

Here's a brief overview of the pros and cons of each approach:

* **SoA - one loop**:
	+ Pros: Easy to implement, familiar data structure.
	+ Cons: May incur overhead due to multiple array accesses.
* **SoA - one component per loop**:
	+ Pros: Can be faster since only one array access is required per iteration.
	+ Cons: More complex implementation and may require more memory for the array of objects.
* **Interlaced Array - no loop unrolling**:
	+ Pros: Simple implementation, no additional memory is required.
	+ Cons: May incur significant overhead due to frequent array accesses and updates.
* **Interlaced Array - with loop unrolling**:
	+ Pros: Can potentially reduce overhead by reducing the number of array accesses.
	+ Cons: Requires more complex implementation, may increase memory usage if not done correctly.

**Library Usage**

None of the test cases use any external libraries. The benchmark only relies on built-in JavaScript features and standard library functions (e.g., `Float32Array`, `Math.random()`).

**Special JS Features or Syntax**

No special JavaScript features or syntax are used in these test cases. They focus on comparing different data structures and algorithms for vector processing.

**Other Alternatives**

Some alternative approaches to vector processing that might be considered:

* **Native array operations**: Using native array methods (e.g., `vector.x *= 2;`) instead of JavaScript arrays.
* **Web Assembly (WASM)**: Compiling the benchmark to WASM and running it using a WASM interpreter or runtime.
* **Multi-threading or parallel processing**: Running multiple threads or processes to process different components of the vector in parallel.

Keep in mind that these alternatives might not be relevant to this specific benchmark, which focuses on comparing data structures and algorithms.

Related benchmarks: