Benchmark: soa vs aos - MeasureThat.net

Script Preparation code:

var x = [], y =[], z =[];
var vectors = [];
for(var i = 0; i < 1000000; i++){
  x[i] = Math.random()*100|0;
  y[i] = Math.random()*100|0;
  z[i] = Math.random()*100|0;
  
  vectors[i] = { x: x[i], y: y[i], z: z[i] };
}
var vector;

Tests:

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 12 days ago)

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

Browser/OS: Chrome 135 on Windows

View result in a separate tab

Test name	Executions per second
soa	62.3 Ops/sec
aos	5.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**What is being tested?**

The provided benchmark tests two approaches to scaling an array: **SoA (Structured Array)** and **AoS (Array of Structured Arrays)**. In this case, both SoA and AoS are used to store 3D vectors.

In the `Script Preparation Code`, a large array `x`, `y`, and `z` is created using the following code:
```javascript
for (var i = 0; i < 1000000; i++) {
    x[i] = Math.random() * 100 | 0;
    y[i] = Math.random() * 100 | 0;
    z[i] = Math.random() * 100 | 0;

vectors[i] = { x: x[i], y: y[i], z: z[i] };
}
```
Here, `x`, `y`, and `z` are arrays of length 1,000,000. For each element in the array, a random value is generated between 0 and 100 (inclusive). The resulting values are then stored as 3D vectors in the `vectors` array.

The two benchmark tests differ only in how they access and modify these vectors:

**SoA (Structured Array)**

In this approach, each vector is an element of the `vectors` array. The benchmark code uses a simple index-based access to read, write, and update each vector:
```javascript
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];
}
```
**AoS (Array of Structured Arrays)**

In this approach, each vector is a separate element in the `vectors` array. The benchmark code uses a loop to iterate over the vectors and then access each vector's elements:
```javascript
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;
}
```
**Pros and Cons**

Both approaches have their trade-offs:

SoA (Structured Array):

* Pros:
	+ Cache locality: accessing elements of a single array can lead to better cache performance.
	+ Simpler indexing.
* Cons:
	+ Less memory-efficient, as each element is stored separately.

AoS (Array of Structured Arrays):

* Pros:
	+ More memory-efficient, as only the necessary vector data is stored.
	+ Can be more flexible for larger datasets or different vector sizes.
* Cons:
	+ More complex indexing and looping.

**Other Considerations**

When choosing between SoA and AoS, consider the specific requirements of your application:

* If memory efficiency is crucial, AoS might be a better choice.
* If cache locality is important, SoA might be a better choice.
* If you need to access or update elements of multiple vectors simultaneously, SoA might be more suitable.

**Library usage**

None of the benchmark code explicitly uses any external libraries. However, if the test case used a library like `Array.prototype.map()`, `Array.prototype.forEach()`, or other array methods, it would modify how the benchmarks are executed.

**Special JS features or syntax**

The benchmark does not use any special JavaScript features or syntax, such as `async/await` or `let`/`const` declarations. It also does not include any advanced optimizations like parallel processing or SIMD instructions. The code is straightforward and focuses on showcasing the performance difference between SoA and AoS.

**Other alternatives**

If you're interested in exploring alternative approaches, consider:

* Using **Tails (Transformed Array Iterators)**: An experimental feature that allows iterating over arrays using iterators.
* Employing **SIMD instructions**: Using CPU-specific instructions like SSE or AVX to perform operations on multiple vectors simultaneously.
* Utilizing **parallel processing frameworks**: Libraries like Web Workers or parallel.js can help execute benchmarks in parallel, improving performance and throughput.

Related benchmarks:

soa vs aos (version: 0)

As titled

Comparing performance of: soa vs aos

Created: 8 years ago by: Guest

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 6 months ago):