Tick-Based Deterministic Scheduling
This interactive visualization demonstrates how tick-based architecture achieves deterministic multi-core execution. Watch events flow through the system in real-time, then compare with conventional non-deterministic scheduling.
Note: This visualization presents a simplified model of tick-based scheduling to illustrate architectural principles. Actual system behaviour depends on implementation details, hardware configuration, and integration context. Deterministic execution improves reproducibility under defined conditions but does not eliminate all classes of defects.
How to Use This Tool
Click Run to begin. Watch as events are processed at discrete tick boundaries (t₀, t₁, t₂...). Each tick represents a deterministic execution window—events arriving within a tick are queued and processed in the next cycle.
Notice how events align to tick boundaries across all four cores. The Event Queue shows pending events with their assigned cores and arrival ticks. In tick-based mode, assignment is deterministic—the same event sequence produces consistent core allocation under defined system conditions.
Toggle to Conventional mode and click Reset. Events now scatter randomly across cores with no tick alignment. Run it again—notice the execution pattern differs. This variability illustrates why conventional systems face challenges achieving reproducible execution.
The System State panel displays a cryptographic hash of execution. In tick-based mode, this hash remains constant across replays—strong evidence of reproducible, byte-identical execution under defined conditions. In conventional mode, the hash changes, illustrating non-deterministic execution behaviour.
Click Add Event to inject sensor reads, network packets, or control signals. Watch them enter the queue, await their tick, then execute deterministically. This demonstrates how real-world asynchronous events are transformed into synchronous, reproducible state transitions.
Key Observations
- ▸ Event alignment: All events snap to tick boundaries, reducing timing-dependent race conditions by constraining execution order.
- ▸ Deterministic hashing: The cryptographic hash provides evidence that execution is reproducible—supporting certification and debugging workflows.
- ▸ Multi-core coordination: Four cores execute in parallel without shared memory or locks—coordination is achieved through event ordering alone.
- ▸ Replay capability: Given initial state and event sequence, execution is constrained to reproducible paths—enabling deterministic replay for debugging and incident analysis.
Interactive Tick-Based Scheduler
Watch deterministic execution in real-time • Compare conventional vs. tick-based scheduling
Understanding the Visualization
Tick Timeline
The timeline shows discrete execution windows (ticks) at which state transitions occur. In MDCP, ticks typically run at 1-100µs intervals depending on application requirements. The green indicator marks the current tick.
Core Execution
Four cores represent a typical multi-core safety-critical system. Color-coded events show different operation types: sensor reads (📡), network I/O (🌐), computation (⚡), control outputs (🎮), memory operations (💾), and safety checks (⚠️). Cores show IDLE when no events are assigned for that tick.
Event Queue
Pending events await their designated tick. In tick-based mode, core assignment is shown—this assignment is deterministic based on event properties and system state. Events cannot execute until their tick arrives, transforming asynchronous events into synchronous processing.
System State
Real-time metrics show system progression. The Determinism Hash is computed from complete system state at each tick. In tick-based mode, this hash enables replay verification—if the hash matches after replay, execution was reproducible. In conventional mode, the hash differs across runs, illustrating variability across executions.
Explore the Technical Details
Read our in-depth technical articles on deterministic architecture and certification considerations.
View Insights