As systems complexities continue to increase, new modeling frameworks are required that can faithfully model the different representational granularities. Large-scale multi-domain simulation involves real application code (procedural codes), event driven state machines and environment models – all within an integrated environment. While frameworks such as POEMS and Weaves provide automated systems support to create interface bindings, fundamental issues remain in creating a representation of time that unifies the real-time requirements of application codes with the controllability and resolution of virtual time representations used in models.
The two main representations of time are (a) simulation time or virtual time and (b) real time or wall clock time. Traditionally, simulation has relied on a virtual time model, where a simulation engine maintains and updates an internal representation of time. In this representation, a virtual clock is forced “forward” by the simulation engine to create a virtual timeline. This results in a highly controllable representation of time. The simulation model consists of events and event handlers, which are associated with time-instants in the virtual timeline. The simulation engine executes events in its timeline by calling the associated event-handler function, in non-decreasing timestamp order. The event-handler function is assumed to execute instantaneously, i.e. virtual time does not progress during the execution of an event-handler function. The intuition here is events cause time to go forward. More fundamentally, the progress of time is dependent on the system being simulated - time is an emergent property and thus cannot progress independently.
In a parallel simulation consisting of multiple distributed memory processors, each processor has an independent timeline and an event queue. The basic problem here is that the event-density is different on the various physical processors participating in a parallel simulation. Hence, virtual time progresses at different rates. In order to maintain strict time-ordering, - a requirement for temporal causality - parallel discrete event simulation (PDES) algorithms spend an inordinate amount of effort synchronizing the various independent timelines to create the illusion of a single global timeline that moves forward in time. In a large-scale multi-domain simulation, since the granularity of time is the very small, it is not unusual for parallel simulations to progress significantly slower than their sequential counterparts.
Real-time (or natural time) representation is commonly used in continuous time domains such as direct-code execution (procedural application codes). In these models, events occur in real-time and time intervals are measured against wall-clock time, which progresses independent of the simulation. Some systems – for instance protocols such as TCP in network simulation - even incorporate wall-clock time as a parameter of a feedback control system.
The main drawback of the real-time representation is that it is not controllable to the same degree as a forced clock. However, it has its advantages. The independent progress of real-time leads to automatic synchronization in parallel simulation, in that no additional effort needs to be expended to move time forward in a consistent manner. If a local measurement of time indicates the elapse of a certain interval, it may safely be assumed that a similar interval has elapsed on another distributed memory processor. This leads to an intuitive observation. Natural time can be treated as a function that orders state such that only events that commutatively affect state occur at the same instant of time. Put simply, in natural time the ordering of events that occur at the same instant of time does not affect the result. If it does, it is the result of either insufficient precision in the representation of time (roundoff error) or the system being modeled has a race condition leading to non-deterministic behavior.
In this work, we are developing a new system of time called To solve this problem, I developed a system of time called relativistic time, which reconciles real time and virtual time by creating a model of time that flows naturally, and yet is highly controllable. There are two basic intuitions behind relativistic time. First, all physical measures of time are non-decreasing and ordinal in nature, relying on a periodic waveform, where the length of each period is controlled by the fundamental nature of space-time. Second, within a single frame of reference, all clocks agree on the measure of time. I use these properties to mathematically derive a new non-inertial frame of reference from real-time through a set of non-linear functions. The main property of this frame of reference is that it is ordinally equivalent to real-time. Since the functions deriving the frame of reference are controllable, it enables us to exercise arbitrary control over a naturally flowing clock. To take an analogy, if you could arbitrarily control the acceleration of an object, you can exercise control over the individual periods of its clock, while still retaining a model of time that preserves the number of periods.
This solution also reconciles a basic causality problem in parallel simulation. A parallel simulation system executes events in temporal order, since temporal order guarantees state causality. However, practically, a parallel simulation system has to find the oldest temporal event in the entire system – which requires a global coordination operation – before executing each event. This behavior leads to largely sequential operation of a parallel simulation system resulting in poor performance. Relativistic time solves this problem by reducing temporal consistency to the consistency of the equations that derive the frame of reference. This enables a simulation system to look at its local relativistic clock and be guaranteed that every other node of the parallel system is executing at exactly the same instant of time. Since the simulation system models a physically realizable entity governed by limits imposed by the speed of light, the relativistic time model thereby guarantees the accuracy of the simulation.
This work is supported by a NSF medium ITR grant (CNS-0325410). We thank the National Science Foundation for their support.