Benchmark: Indepotent addition over large lists of vectors - SoA vs AoS

Script Preparation code:

var N = 10000

var x1 = new Float32Array(N);
var x2 = new Float32Array(N);
var x3 = new Float32Array(N);

var AoS1 = [];
var AoS2 = [];
var AoS3 = [];

for (var i = 0; i < N; ++i) {
	x1[i] = Math.random();
	x2[i] = Math.random();
	x3[i] = Math.random();
	AoS1.push( {x:Math.random(), y:Math.random(), z:Math.random()} );
	AoS2.push( {x:Math.random(), y:Math.random(), z:Math.random()} );
	AoS3.push( {x:Math.random(), y:Math.random(), z:Math.random()} );
}

Tests:

SoA
for (var i = 0; i < N; ++i) { x3[i] = x1[i] + x2[i]; }
AoS
for (var i = 0; i < N; ++i) { AoS3[i].x = AoS1[i].x + AoS2[i].x; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
SoA
AoS

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (iPad; CPU OS 15_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6,2 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 15 on iOS 15.7

View result in a separate tab

Test name	Executions per second
SoA	635.7 Ops/sec
AoS	620.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what is being tested in this benchmark.

**Benchmark Definition**

The benchmark tests two approaches to performing element-wise addition on a list of vectors:

1. **SoA (Structured Array)**: The test uses a traditional JavaScript array (`x1`, `x2`) and performs the addition operation directly on these arrays.
2. **AoS (Array of Objects)**: The test uses an array of objects (`AoS1`, `AoS2`, `AoS3`) where each object represents a vector, and performs the addition operation by accessing corresponding elements in the objects.

**Options Compared**

The two options being compared are:

* SoA (Structured Array): Uses traditional JavaScript arrays to store the vectors.
* AoS (Array of Objects): Uses an array of objects to represent the vectors, where each object has `x`, `y`, and `z` properties.

**Pros and Cons**

### SoA (Structured Array)

Pros:

* Efficient memory usage: Since we're using traditional JavaScript arrays, there's no overhead of storing additional metadata for each vector.
* Fast indexing: Accessing elements in a traditional array is fast since it's stored in contiguous memory locations.

Cons:

* Less readable code: When working with large datasets, the code can become cumbersome and hard to read due to the need to access indices explicitly.
* Limited flexibility: If we want to add additional properties or metadata to each vector, modifying the existing array can be difficult.

### AoS (Array of Objects)

Pros:

* More readable code: When working with large datasets, using objects to represent vectors makes the code more readable since it clearly conveys what each element represents.
* Easier extensibility: Adding additional properties or metadata to each vector is straightforward since we're working with objects.

Cons:

* Less efficient memory usage: Each object in the array has its own overhead of storing metadata (e.g., `x`, `y`, and `z` properties).
* Slower indexing: Accessing elements in an object can be slower than accessing indices in a traditional array due to the additional overhead of looking up properties.

**Library Used**

There is no explicit library mentioned in the benchmark definition, but it's likely that the JavaScript engine being used (e.g., V8) implements various optimizations and features that affect the performance of these approaches. However, for this specific benchmark, the focus is on comparing the two approaches themselves.

**Special JS Features or Syntax**

There are no special JavaScript features or syntax mentioned in the benchmark definition.

**Other Alternatives**

Alternative approaches to performing element-wise addition could include:

* Using a library like NumJS or js-numeric to perform vector operations.
* Utilizing specialized libraries for linear algebra, such as Mathjs.
* Implementing the operation using native code (e.g., assembly or C++) for optimized performance.

However, these alternatives are not part of the benchmark definition and would require additional modifications to the test setup.

Related benchmarks:

Indepotent addition over large lists of vectors - SoA vs AoS (version: 5)

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? Let's find out!

Comparing performance of: SoA vs AoS

Created: 8 years ago by: Registered User

Jump to the latest result

SoA

AoS

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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