DOD vs OOP ECS Benchmark Results – SIMD Performance Analysis (R1, R5, R10)

System & Benchmark Setup

# Run Timestamp: 2025-12-26 13:44:36
# ================== CPU INFO ====================
# Architecture       : x86_64
# Manufacturer       : GenuineIntel
# Model              : Intel(R) Xeon(R) CPU E3-1245 v6 @ 3.70GHz
# Logical Threads    : 8
# Physical Cores     : 4
# ================================================
# Compiler: MSVC Visual Studio 2022 1944
# Platform: Windows x64
# Optimization: O2
# Repetitions 1 per benchmark
# Repetitions 5 per benchmark
# Repetitions 10 per benchmark
# ================================================

Benchmark Summary Across Repetition Counts

Legend:

• OOP-Pure — Traditional object-oriented implementation
• DOD-Scalar — Data-Oriented Design, scalar version
• DOD-SSE — Data-Oriented Design with SSE SIMD
• DOD-AVX — Data-Oriented Design with AVX SIMD

Cell format:

Mean / Min / Max / StdDev — all times in seconds (s)
- Mean: Average execution time across N repetitions
- Min: Minimum execution time observed
- Max: Maximum execution time observed
- StdDev: Population standard deviation across repetitions

Reps column: Number of repetitions performed for that benchmark (1, 5, or 10) Cell format: Mean/Min/Max/StdDev — all times in seconds (s)

Comparative Analysis of Benchmark Results (1, 5, and 10 repetitions)

The benchmark dataset provides a detailed comparison between four approaches for updating large numbers of entities: OOP-Pure, DOD-Scalar, DOD-SSE, and DOD-AVX. The measurements are presented for 1, 5, and 10 repetitions and entity counts ranging from 10M to 50M. Each entry records Mean, Min, Max, and StdDev of execution times in seconds.

Observations on Execution Time

1. Single Repetition (1 run):

   • Even with a single run, there is a noticeable performance gap between OOP-Pure and all DOD-based approaches.
   • OOP-Pure scales poorly: at 50M entities, it takes 6.4114 s, while DOD-Scalar is 0.4151 s, DOD-SSE 0.1247 s, and DOD-AVX 0.1201 s.
   • SIMD acceleration (SSE and AVX) drastically reduces execution time, highlighting the efficiency of vectorized data processing.

2. Five Repetitions:

   • The mean values stabilize slightly compared to a single repetition.
   • Standard deviations indicate variability; OOP-Pure shows the largest fluctuations, particularly at 50M entities (StdDev = 2.0003 s), whereas DOD-AVX remains very consistent (0.0225 s).
   • The gap between DOD-Scalar, DOD-SSE, and DOD-AVX is clearer with increasing entities, emphasizing the importance of SIMD for high workloads.

3. Ten Repetitions:

   • Longer measurement sequences highlight performance consistency.
   • OOP-Pure still exhibits extreme variability at high entity counts (e.g., Max = 6.3149 s at 50M), confirming instability under large workloads.
   • DOD approaches maintain low variability; AVX consistently achieves the best mean performance across all entity counts.
   • DOD-SSE also improves over DOD-Scalar, but the difference is smaller than the jump from OOP-Pure to DOD-Scalar.

Trend Analysis

• Scalability:
  All DOD-based approaches scale significantly better than OOP-Pure. While DOD methods show an almost linear increase in execution time as the umber of entities grows, OOP-Pure experiences a disproportionate increase in execution time, particularly at 50 million entities. This indicates that the OOP-based implementation becomes increasingly inefficient as the workload grows.

• Effect of SIMD:
  Vectorization (SSE and AVX) further reduces execution time, particularly for larger datasets. DOD-AVX consistently outperforms DOD-SSE and DOD-Scalar, demonstrating that SIMD efficiently leverages CPU capabilities for parallel data updates.

• Stability:
  Standard deviation and Min/Max ranges reveal that DOD approaches are far more stable than OOP-Pure. Even with 10 repetitions, DOD-AVX shows minimal deviation, whereas OOP-Pure exhibits significant variability, which could cause unpredictable performance in real-world scenarios.

Benchmark Graphs

The following figures provide a visual understanding of the results:

Repetitions 1

Repetitions 5

Repetititons 10

1. Figure 1 - Execution Time vs Entities (Mean ± StdDev)

   • Error bars show stability across repetitions.
   • Highlights scalability of DOD approaches and volatility of OOP-Pure.

Repetitions 1

Repetitions 5

Repetititons 10

1. Figure 2 - Grouped Bar Chart (Mean Values)

   • Direct comparison of mean execution times per entity count.
   • Clearly shows the advantage of DOD over OOP and the incremental benefit of SIMD.

Repetitions 1

Repetitions 5

Repetititons 10

1. Figure 3 - Speedup Relative to OOP (×)

   • All DOD-based approaches consistently outperform OOP-Pure.
   • DOD-AVX achieves up to 50x speedup at 50M entities, demonstrating the dramatic impact of data-oriented design and SIMD.

Repetitions 1

Repetitions 5

Repetititons 10

1. Figure 4 - Line Plot with Min/Max Error Bars

   • Shows execution time ranges across repetitions.
   • Emphasizes stability differences: DOD-AVX lines are tightly clustered; OOP-Pure has wide fluctuation.

Conclusions

This benchmark study highlights several clear insights:

• Data-Oriented Design (DOD) dramatically improves performance over traditional OOP approaches.
• SIMD acceleration (SSE/AVX) further enhances throughput, especially for large workloads.
• Stability is critical: DOD-AVX not only runs faster but also produces more predictable execution times.
• Repetition analysis confirms that these performance trends are consistent across multiple runs, reinforcing the reliability of the DOD + SIMD approach.

Overall, for high-performance entity updates in CPU-bound applications, DOD combined with SIMD (AVX) provides the best combination of speed, scalability, and stability, making it the preferred choice over traditional OOP implementations.

Authored by: > Xavier Figuera - 2025 > LinkedIn