Benchmark: soa vs aos - MeasureThat.net

Script Preparation code:

var x = [], y =[], z =[];
var vectors = [];
for(var i = 0; i < 10000; 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: 6 months ago)

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

Browser/OS: Chrome 141 on Windows

View result in a separate tab

Test name	Executions per second
soa	19428.1 Ops/sec
aos	1249.6 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to explain the benchmark and its various options.

**What is tested:**

The provided JSON represents two test cases for a microbenchmark comparing the performance of **Single-Op Array (SOA)** and **Array-Of-Structures (AOS)** approaches in JavaScript.

In SOA, arrays are manipulated directly, whereas in AOS, each element of an array is treated as a separate object with its own properties.

**Options compared:**

The benchmark compares the performance of two options:

1.  **SOA**: This approach manipulates arrays directly.
2.  **AOS**: Each element of an array is treated as a separate object with its own properties.

**Pros and Cons:**

*   **SOA (Single-Op Array)**:
    *   Pros:
        *   Faster execution times, since operations are performed on contiguous memory locations.
        *   Less overhead due to object creation and property access.
    *   Cons:
        *   Can lead to performance issues when dealing with large arrays or complex data structures.
*   **AOS (Array-Of-Structures)**:
    *   Pros:
        *   More flexible and easier to work with complex data structures.
        *   Can be more efficient for certain operations, especially those involving object properties.
    *   Cons:
        *   Slower execution times due to the overhead of creating objects and accessing their properties.
        *   May lead to increased memory usage.

**Library:**

The benchmark uses no external libraries. The script preparation code defines an array (`x`, `y`, `z`) and a vectors array, which are used as inputs for both test cases. No libraries like jQuery or React are mentioned in the provided JSON.

**Special JS feature/syntax:**

None of the provided benchmarks specifically utilize special JavaScript features or syntax. The benchmark focuses on comparing two different programming approaches (SOA and AOS) without relying on any advanced language features.

**Alternatives:**

Other alternatives for similar benchmarks might include:

*   **For-each loops**: Compare the performance of traditional `for` loops versus modern `forEach` methods.
*   **Object iteration**: Benchmark the execution time of iterating over objects using `for...in`, `for...of`, or ` Object.keys()`/` Object.values()`.
*   **Array manipulation**: Test the performance of different array manipulation techniques, such as `map()`, `filter()`, and `reduce()`.

Related benchmarks:

soa vs aos (version: 0)

As titled

Comparing performance of: soa vs aos

Created: 9 years ago by: Guest

Jump to the latest result

soa

aos

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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