Static Simulation State

The compiler runs through a static simulation of the program at compile time. A static simulation state captures a conservative approximation of the corresponding dynamic simulation state as follows:

• contains all events that may or must be sensitized ( and ). An event can not be paired with and simultaneously.

• contains all events that may or must be ready to be executed currently ( and ). An event can not be paired with and simultaneously.

• contains all events that may or must be waiting to be executed in a future simulation time ( and ). An event can not be paired with and simultaneously.

• is the memory store that maps each variable to its current value. If we do not know the value of a variable at compile time, it maps to . (For each mapping var val in such that val , var val is in .)

We modify the functions from the dynamic simulation as follows:

• deterministically chooses a tuple from the set of ready events .

• applies the code associated with event to the memory store and returns a new memory store. If , any variable written by can be stored in if it is known to be a constant at the end of , subject to the restrictions outlined earlier. Otherwise, any variable written by must map to in .

• evaluates the boolean expression using the memory store and returns (), (some variable in maps to in ), or ().

• indicates if the execution of event with initial memory store changes the value of expression and returns (), (some variable in maps to in ) or ().

We define the operator for , , and as follows:

We define a function , where and are sets of tuples . We assume the existence of a similar function for .

Finally, we extend the state transition function to static states. The definition of ensures that the set of sensitized events, currently waiting events and delayed events are a superset of the corresponding event sets in dynamic simulation. We define by , where

(Type I Transition)

This represents the execution of an event in the current simulation time step:

if , then
Let in

(Type II Transition)

This represents incrementing the simulation time to the next time during which an event can occur.

if and , then
Let

in

(Type III Transition)

This represents the end of simulation:

if and , then

The static simulation of an event graph is a sequence of states, , where

• , and
•