Simulation Engine Architecture

• Simulation engine architecture is the foundational design that organizes simulation kernels, event schedulers, and resource modules to support diverse simulation models.
• It emphasizes modularity and extensibility through object-oriented abstraction and a clear separation of concerns, enabling seamless model extensions and integration.
• Key implementations include discrete-event scheduling, parallel execution, NUMA optimization, and rigorous validation measures to ensure scientific reliability and performance.

A simulation engine architecture is the foundational organizational structure, programmatic framework, and runtime environment that supports building, executing, and extending simulation models across diverse domains such as physics, engineering, power systems, autonomous control, statistical analysis, and more. Simulation engines must balance modularity, extensibility, performance, and reliability while supporting scalable execution on modern hardware and effective integration with modeling workflows.

1. Fundamental Architectural Principles

Common architectural principles underlie most simulation engines regardless of their specialization or performance profile:

• Core Simulation Kernel: All engines possess a main simulation loop or kernel responsible for advancing global simulation time, managing event queues (in discrete-event models), orchestrating system state updates, and collecting statistics. For example, in DESP‐C++, the Simulation class coordinates time, events, and replication logic (Darmont, 2016), while in SimEngine for statistical studies, a singular simulation object encapsulates all data generation, method evaluation, and result collation (Kenny et al., 8 Mar 2024).
• Object-Oriented Abstraction: Engines often employ an object-oriented approach, capturing system entities as objects or resources with well-defined interfaces. InterPSS uses a hierarchical model-centric OOP design to organize its entire simulation workflow (Zhou et al., 2017), while TorchSim defines a ModelInterface for plug-and-play with both classical and machine-learned interatomic potentials (Cohen et al., 8 Aug 2025).
• Modularity and Separation of Concerns: Clear division of modules—e.g., event handling, resource models, statistics, scheduling—enhances code maintainability and extensibility. In DESP‐C++, core logic (scheduling, kernel) and user-editable model/event definitions are strictly separated (Darmont, 2016). PARSIR achieves modularity through per-object calendars and disjoint-access event management (Quaglia, 1 Oct 2024).
• Explicit Support for Model Extensions and User-Defined Logic: Engines expose interfaces and coding patterns by which users can define domain-specific behaviors, resources, and events—e.g., DESP‐C++’s Events module or plugin-based extensions in Unreal Engine 5 (Cassaing, 2023).
• Scalability and Parallelism: Most modern simulation engines focus on maximizing throughput for large and/or complex models: batched processing (TorchSim (Cohen et al., 8 Aug 2025)), vectorized environments (Brax (Freeman et al., 2021)), and parallel simulation object partitioning (PARSIR (Quaglia, 1 Oct 2024); cluster-based execution in SimEngine (Kenny et al., 8 Mar 2024)).
• Validation and Reproducibility: Engines frequently integrate facilities for back-to-back tests, replication runs, confidence interval computation, and Monte Carlo error quantification to ensure scientific validity (e.g., DESP-C++’s statistical analysis, MiL verification in Renault’s virtualization (Wissel et al., 2018), SimEngine’s automated MC error (Kenny et al., 8 Mar 2024)).

2. Canonical Kernel and Main System Components

A typical simulation engine contains several tightly coordinated components:

Component	Representative Example	Function
Simulation Kernel	DESP-C++ Simulation class (Darmont, 2016)	Controls iteration, time, and global parameters
Scheduler/Event Q	DESP-C++ Scheduler; PARSIR’s per-object calendars	Processes and orders deferred discrete events
Resource Entities	Active/Passive Resources in DESP-C++; Object Models in InterPSS	Encapsulate system actors and stateful resources
Event Management	DESP-C++ EventManager; PDES engine event-processing	Mediates between the scheduler and resource state transitions
User API/Ext. Mod	Events module in DESP-C++; UE5 Plugin/Adapter (Cassaing, 2023)	Allows domain-level code, model definitions, or plugin loading
Statistics/Reporting	DESP-C++ statistics; SimEngine summaries	Cumulative statistics, confidence intervals, MC error, etc.

This modular partitioning enables clear workflow separation: e.g., in DESP‐C++, the main loop collects completed simulation results, the scheduler orders events, while the event manager invokes the coded business logic of resources and client behaviors (Darmont, 2016).

Object-oriented schemes (InterPSS, TorchSim, Unreal-based platforms) make resource extensions plug-and-play via abstract base classes and concrete implementations, supporting multiple model domains (e.g., T&D networks in InterPSS (Zhou et al., 2017)).

3. Scheduling, Synchronization, and Parallel Execution

Performance and scalability require careful coordination of scheduling, memory locality, and parallel computations:

• Event Scheduling: In discrete-event engines, an event list (often a doubly linked list, as in DESP-C++ (Darmont, 2016)) or per-object calendar queue (PARSIR (Quaglia, 1 Oct 2024)) is maintained and traversed in timestamp order. Batch-scheduling within epoch windows, as in PARSIR, increases efficiency by maximizing cache locality (Quaglia, 1 Oct 2024).
• Task Scheduling in Real-Time Engines: SimSched introduces explicit real-time scheduling (fixed priority, rate-monotonic) in Simulink-based AUTOSAR automotive models to simulate actual WCETs and preemption behavior, departing from classic zero-time execution (Chen et al., 2023).
• Parallel and Batched Execution: TorchSim groups multiple atomistic systems into a single “batch” SimState for highly vectorized simulation on GPU, using auto-batching logic to maximize memory utilization and throughput (Cohen et al., 8 Aug 2025). Brax processes thousands of simulation scenes via JAX vmap and JIT compilation on accelerators (Freeman et al., 2021). SimEngine for statistical simulations supports parallel local and Slurm-based cluster execution (Kenny et al., 8 Mar 2024).
• NUMA-Optimized Allocation and Work-Stealing: PDES engines such as PARSIR and USE explicitly pin threads/workers to NUMA nodes, favor local access to minimize memory latency, and implement work-stealing schemes for dynamic load balancing while preserving memory affinity (Quaglia, 1 Oct 2024, Marotta et al., 25 Mar 2025).
• Optimistic vs. Conservative Parallelism: Optimistic engines (USE) use shared global event queues and aggressive synchronization (high RMW frequency), suitable for some CPU-bound tasks; conservative engines (PARSIR) exploit disjoint-access parallelism and local processing windows, excelling at memory-bound, parallelizable loads (Marotta et al., 25 Mar 2025).

4. Extensibility, Integration, and User Adaptation

Simulation engines prioritize extensibility for model evolution and integration with heterogeneous tools:

• User-Editable Modules/Plugins: Separation into kernel and user-editable extension modules (as with DESP‐C++'s Events module (Darmont, 2016) or Unreal Engine’s C++ plugin architecture (Cassaing, 2023)) facilitates adaptation for new simulation requirements with minimal core code changes.
• Model-Driven and Code-Generated Architectures: In InterPSS, a central EMF model defines object schemas with >50% of core code auto-generated, ensuring consistency and rapid propagation of design changes across a large, evolving system (Zhou et al., 2017).
• API and Adapter Pattern: Open interfaces permit integration with external analysis, data sources, or market simulators (InterPSS’s open API and adapter system (Zhou et al., 2017)), or direct protocol connections in UE5 via gRPC or REST/JSON (Cassaing, 2023).
• Incremental and Automated Build Pipelines: Renault’s EMS virtualization organizes Simulink modules into wrappers, configures interface types, and enables incremental compilation, addressing scale limitations (over 1500 runnables) and type conflicts (Wissel et al., 2018).
• Native Format Conversion and Interchange: TorchSim's support for direct I/O conversion with pymatgen, ASE, and phonopy models ensures seamless integration with materials informatics pipelines (Cohen et al., 8 Aug 2025).

5. Validation, Verification, and Performance Benchmarking

Reliable simulation results hinge on robust internal validation and consistent external benchmarking:

• Replication and Confidence Intervals: DESP‐C++ integrates replication handling and computes confidence intervals for all statistics (Darmont, 2016).
• Back-to-Back Model Verification: In Renault's virtualization architecture, every Simulink-generated module is validated via MiL comparison against C code to ensure model/production equivalence (Wissel et al., 2018).
• Monte Carlo Error Calculation: SimEngine automates MC error estimation and includes confidence intervals for statistical summary metrics, supporting robust inference even for complex simulation designs (Kenny et al., 8 Mar 2024).
• Performance Benchmarks: PDES platforms (PARSIR, USE) are systematically evaluated using standard benchmarks such as PHOLD and domain-realistic models to quantify event throughput and scalability with respect to NUMA node/cpu utilization (Quaglia, 1 Oct 2024, Marotta et al., 25 Mar 2025). Brax reports millions of simulation steps per second on TPU accelerators (Freeman et al., 2021). TorchSim demonstrates several orders-of-magnitude speedup for MLIP-based MD by batching on the GPU (Cohen et al., 8 Aug 2025).

6. Architectural Patterns in Domain-Specific Simulation

Unique architectural strategies are tailored for distinct scientific and engineering domains:

• Resource View (DESP-C++): Resource-centric abstraction (active and passive resource objects) enables flexible model composition and avoids thread-based complexity (Darmont, 2016).
• Object Model-Driven Simulation (InterPSS): Hierarchical, extensible object templates for power grid elements enable T&D and hybrid domain simulations, with clear inheritance and nesting (Zhou et al., 2017).
• Semantic Simulation (SUMO): Integration of ontological frameworks allows simulation of state transitions with explicit logical rules and validation probes, supporting dynamic model evolution and validation via software testing procedures (Allen, 2020).
• Differentiable and Batched Simulation (TorchSim, Brax): Full support for automatic differentiation (backpropagation through physics simulation) and extreme parallelization via batching allows modern learning and optimization workflows (Cohen et al., 8 Aug 2025, Freeman et al., 2021).
• Integrated Multimodality (Great-X): Single-engine simulation platforms (e.g., Unreal Engine-based Great-X) can orchestrate physically accurate multimodal (RF, RGB, LiDAR, Radar) data generation—synchronously, with customized ray-tracing and real-time sensor feedback (Huang et al., 11 Jul 2025).

7. Architectural Visualization, Analysis, and Maintainability

Systematic visualization and subsystem dependency analysis inform maintainability and refactoring decisions:

• Subsystem Detection and Dependency Graphs: Both SyDRA (Ullmann et al., 8 Jun 2024) and architectural recovery approaches (Ullmann et al., 2023) employ manual and automated fault clustering, include-graph generation, and quantitative metrics (in-degree, out-degree, betweenness centrality) to clarify module responsibilities, coupling, and emergent patterns across engines.
• Coupling Minimization and Folder Cohesion: Excessive in-degree or centrality in a subsystem may reveal architectural bottlenecks or maintainability risks, motivating refactoring to segregate concerns or flatten deep folder nestings (Ullmann et al., 8 Jun 2024).
• Visualization for Impact Analysis: Architectural maps derived from dependency graphs reduce development time for understanding and impact analysis tasks, improve correctness, and lower developer frustration (Ullmann et al., 8 Jun 2024).
• Common Lessons for Simulation Engines: Adopting subsystem detection, dependency graphing, and visualization (as pioneered in game engine architecture research) improves simulation engine modularity, maintainability, and resilience to evolution (Ullmann et al., 8 Jun 2024, Ullmann et al., 2023).

---

Simulation engine architectures consistently prioritize modularity, extensibility, and maintainability through well-defined kernel components, resource-centric abstractions, and scalable execution strategies tailored to both modern hardware and complex user models. Advanced capabilities such as automatic differentiation, real-time scheduling, efficient parallelism, and deep domain integration are increasingly central, with validation and performance benchmarking integral to scientific reliability. Continued development in architectural analysis, system visualization, and standardized interfaces ensures simulation engines remain robust platforms for both applied research and industrial deployment.