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 AoS

Created: 8 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]; }
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; }

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
AoS

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON represents a benchmarking test for multiplying lists of vectors using different data structures: Stacked Of Arrays (SoA), Array Of Arrays (AoA), and an interlaced array.

**Benchmark Definition**

The benchmark definition describes the test scenario:

* A list of 1 million vectors is generated.
* Three separate arrays are created to store the x, y, and z components of each vector: `x`, `y`, and `z`.
* An additional array, `interlaced`, is created with a length three times that of `x`, `y`, and `z`. This array will be used to test loop unrolling.
* The vectors are then processed using the following operations:
	+ SoA (Stacked Of Arrays): two separate loops iterate over each component (`x`, `y`, and `z`) individually, multiplying each value by 2.
	+ AoA (Array Of Arrays): three separate loops iterate over each component (`x`, `y`, and `z`) separately, multiplying each value by 2.
	+ Interlaced Array: a single loop iterates over the entire array, but only multiplies every third element (starting from index 0) by 2.

**Options Compared**

The benchmark compares four different approaches:

1. **SoA - one loop**: Two separate loops iterate over each component individually, multiplying each value by 2.
	* Pros: easy to implement and understand.
	* Cons: may lead to higher overhead due to branching and looping.
2. **SoA - one component per loop**: Three separate loops iterate over each component separately, multiplying each value by 2.
	* Pros: can reduce branching and overhead compared to SoA - one loop.
	* Cons: more complex implementation and potentially slower.
3. **Interlaced Array - no loop unrolling**: A single loop iterates over the entire array, but only multiplies every third element (starting from index 0) by 2.
	* Pros: can improve cache locality and reduce overhead due to fewer branching and looping operations.
	* Cons: may lead to slower performance due to the more complex indexing.

**Library Usage**

None of the benchmarking test cases use any external libraries. The tests focus solely on the JavaScript implementation.

**Special JS Features/Syntax**

The benchmark uses a few special JavaScript features:

* **Loop unrolling**: A common optimization technique that can improve performance by reducing branching and overhead.
* **Interlacing**: An array indexing technique that allows for more efficient memory access patterns.

**Other Alternatives**

If the developer wanted to explore alternative approaches, they could consider:

* **Using a library**: There are several JavaScript libraries available that provide optimized implementations of vector operations, such as Three.js or MathJS.
* **Compiling to machine code**: JavaScript can be compiled to machine code using tools like V8 or SpiderMonkey. This would require rewriting the benchmark in a low-level language and may not be practical for complex tests.

By analyzing the benchmark definition and test cases, developers can gain insights into the performance characteristics of different data structures and optimization techniques in JavaScript.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36

Browser/OS: Chrome 53 on Windows

View result in a separate tab

Test name	Executions per second
SoA - one loop	1.9 Ops/sec
SoA - one component per loop	1.9 Ops/sec
Interlaced Array - no loop unrolling	1.9 Ops/sec
AoS	11.5 Ops/sec

Related benchmarks:

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 AoS

Created: 8 years ago by: Guest

Jump to the latest result

SoA - one loop

SoA - one component per loop

Interlaced Array - no loop unrolling

AoS

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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