Benchmark: Classes SoA vs AoS

Script Preparation code:

'use strict';
window.N = Math.pow(10, 9);

class PointAndVelocity {
    constructor(x, y, vx, vy) {
        this.x = x;
        this.y = y;
        this.vx = vx;
        this.vy = vy;
    }
}

class Point {
    constructor(x, y) {
        this.x = x;
        this.y = y;
    }
}

class Velocity {
    constructor(vx, vy) {
        this.vx = vx;
        this.vy = vy;
    }
}

aos = Array(N).fill(new PointAndVelocity(0, 0, 0, 0))
    .map(() => new PointAndVelocity(Math.random() * 100, Math.random() * 100, Math.random() * 100, Math.random() * 100));

// SoA, we try to duplicate the data so numeric differences are out of the question.
points = Array(N).fill(new Point(0, 0)).
    .map((_, i) => new Point(aos[i].x, aos[i].y));
velocities = Array(N).fill(new Velocity(0, 0)).
    .map((_, i) => new Velocity(aos[i].vx, aos[i].vy));

​x
 
'use strict';window.N = Math.pow(10, 9);​class PointAndVelocity {    constructor(x, y, vx, vy) {        this.x = x;        this.y = y;        this.vx = vx;        this.vy = vy;    }}​class Point {    constructor(x, y) {        this.x = x;        this.y = y;    }}​class Velocity {    constructor(vx, vy) {        this.vx = vx;        this.vy = vy;    }}​aos = Array(N).fill(new PointAndVelocity(0, 0, 0, 0))    .map(() => new PointAndVelocity(Math.random() * 100, Math.random() * 100, Math.random() * 100, Math.random() * 100));​// SoA, we try to duplicate the data so numeric differences are out of the question.points = Array(N).fill(new Point(0, 0)).    .map((_, i) => new Point(aos[i].x, aos[i].y));velocities = Array(N).fill(new Velocity(0, 0)).    .map((_, i) => new Velocity(aos[i].vx, aos[i].vy));

Tests:

SoA

var N = window.N;
for (var i = 0; i < N; ++i) {
	var point = points[i];
	var velocity = velocities[i];
    point.x += velocity.vx;
    point.y += velocity.vy;
}

 
var N = window.N;for (var i = 0; i < N; ++i) {    var point = points[i];    var velocity = velocities[i];    point.x += velocity.vx;    point.y += velocity.vy;}

AoS

var N = window.N;
for (var i = 0; i < N; ++i) {
	var pav = aos[i]
    pav.x += pav.vx;
    pav.y += pav.vy;
}

 
var N = window.N;for (var i = 0; i < N; ++i) {    var pav = aos[i]    pav.x += pav.vx;    pav.y += pav.vy;}

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
SoA
AoS

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 134 on Windows

View result in a separate tab

Test name	Executions per second
SoA	3472144.0 Ops/sec
AoS	3482580.8 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 9 days ago):

The benchmark titled "Classes SoA vs AoS" compares two data organization strategies: Structure of Arrays (SoA) and Array of Structures (AoS). These approaches are being evaluated in the context of JavaScript programming, specifically looking at the performance of operations involving class instances.

Overview of the Benchmark

Classes and Objects: The test employs three classes:
- PointAndVelocity: Represents both position (x, y) and velocity (vx, vy) in a single structure.
- Point: Represents position only.
- Velocity: Represents velocity only.
Data Population: The benchmark initializes two datasets:
- AoS (Array of Structures): An array (aos) consists of PointAndVelocity objects. This simulates a traditional approach where related data is grouped together in a single structure.
- SoA (Structure of Arrays): Two arrays (points and velocities) represent the same data but separated into two distinct structures: one for positions and one for velocities. This format is commonly advantageous in data processing for performance optimization.

Individual Test Cases

AoS Test Case:
- Code: The code iterates through the aos array, directly updating the position (x, y) of each PointAndVelocity object based on its velocity (vx, vy).
- Pros:
  - Simple and intuitive because related data is kept together.
  - Fewer class instances lead to reduced memory overhead (though not substantial in this case).
- Cons:
  - Can lead to inefficient cache utilization due to spatial locality issues, particularly if many individual properties are accessed separately.
SoA Test Case:
- Code: The code operates on the points and velocities arrays independently, updating positions based on the respective velocity arrays.
- Pros:
  - Better cache performance since each data type is stored contiguously, allowing for more efficient memory access patterns.
  - This organization may significantly improve performance in scenarios where batch processing is done on large datasets.
- Cons:
  - Increased complexity when needing to maintain and sync two separate arrays.
  - More wrappers around data can increase overhead when compared to a single composite object.

Results and Considerations

The benchmark results show that the AoS approach (3,482,580.75 executions per second) outperformed the SoA approach (3,472,144.0 executions per second). Several factors could influence these outcomes:

JavaScript Engine Optimization: The specific optimizations employed by JavaScript engines (like V8) can heavily influence performance. AoS might be optimized better in certain contexts.
Memory Access Patterns: For the sizes of N (a billion), if the engine can efficiently cache data in the AoS setup, it could lead to the observed performance benefits.

Alternatives to SoA and AoS

Other data structures and approaches exist that can cater to various needs:

Mixed Approaches: Sometimes, a hybrid method might be useful, combining both structures based on specific use cases.
Entity-Component-System (ECS): This design pattern decouples data from behavior, which can be beneficial in game development and simulation scenarios.
FlatBuffer/Protocol Buffers: When data interchanges occur (e.g., between services), binary formats can yield better performance while reducing overhead from JavaScript's object model.

In conclusion, this benchmark provides a meaningful insight into the performance implications of using classes and object-oriented design principles in JavaScript, exemplified by the traditional versus contemporary data organization techniques. Understanding the trade-offs between SoA and AoS can aid engineers in making informed decisions, especially when performance is critical.

LLMs can make mistakes. Check important info.

The benchmark titled "Classes SoA vs AoS" compares two data organization strategies: **Structure of Arrays (SoA)** and **Array of Structures (AoS)**. These approaches are being evaluated in the context of JavaScript programming, specifically looking at the performance of operations involving class instances.

### Overview of the Benchmark

1. **Classes and Objects**: The test employs three classes:
   - `PointAndVelocity`: Represents both position (x, y) and velocity (vx, vy) in a single structure.
   - `Point`: Represents position only.
   - `Velocity`: Represents velocity only.

2. **Data Population**: The benchmark initializes two datasets:
   - **AoS (Array of Structures)**: An array (`aos`) consists of `PointAndVelocity` objects. This simulates a traditional approach where related data is grouped together in a single structure.
   - **SoA (Structure of Arrays)**: Two arrays (`points` and `velocities`) represent the same data but separated into two distinct structures: one for positions and one for velocities. This format is commonly advantageous in data processing for performance optimization.

### Individual Test Cases

1. **AoS Test Case**:
   - **Code**: The code iterates through the `aos` array, directly updating the position (x, y) of each `PointAndVelocity` object based on its velocity (vx, vy).
   - **Pros**: 
     - Simple and intuitive because related data is kept together.
     - Fewer class instances lead to reduced memory overhead (though not substantial in this case).
   - **Cons**:
     - Can lead to inefficient cache utilization due to spatial locality issues, particularly if many individual properties are accessed separately.

2. **SoA Test Case**:
   - **Code**: The code operates on the `points` and `velocities` arrays independently, updating positions based on the respective velocity arrays.
   - **Pros**:
     - Better cache performance since each data type is stored contiguously, allowing for more efficient memory access patterns.
     - This organization may significantly improve performance in scenarios where batch processing is done on large datasets.
   - **Cons**:
     - Increased complexity when needing to maintain and sync two separate arrays.
     - More wrappers around data can increase overhead when compared to a single composite object.

### Results and Considerations

- **JavaScript Engine Optimization**: The specific optimizations employed by JavaScript engines (like V8) can heavily influence performance. AoS might be optimized better in certain contexts.
- **Memory Access Patterns**: For the sizes of N (a billion), if the engine can efficiently cache data in the AoS setup, it could lead to the observed performance benefits.

### Alternatives to SoA and AoS

Other data structures and approaches exist that can cater to various needs:

- **Mixed Approaches**: Sometimes, a hybrid method might be useful, combining both structures based on specific use cases.
- **Entity-Component-System (ECS)**: This design pattern decouples data from behavior, which can be beneficial in game development and simulation scenarios.
- **FlatBuffer/Protocol Buffers**: When data interchanges occur (e.g., between services), binary formats can yield better performance while reducing overhead from JavaScript's object model.

Related benchmarks:

Classes SoA vs AoS (version: 1)

Same as usual Float Array base SoA vs AoS but with classes and objects instead of raw number. I was cursious if the benefit of SoA still holds true even with classes.

Comparing performance of: SoA vs AoS

Created: 9 days ago by: Guest

Jump to the latest result

SoA

AoS