Reactive Synchronous model

Nowadays a big number of applications react with another systems, this interaction led to the construction of systems specially adapted to this kind of behavior and to the development of new techniques to build it, for instance the synchronous approach. The notion of reactive system was introduced by D. Harel and A. Pnueli [1] who were the first that identified these systems. Using this definition, there were created an important number of languages that use the reactivity, for example Esterel, Lustre, Signal, etc.

This section presents the general concepts of one of the implementations of the synchronous approach which is used for implementing REJO, Junior. In fact Junior presents some important differences with the Synchronous model that allows it to eliminates causalities problems, for instance the delayed reaction to the absence and the weak preemption. For more information about Junior and the Synchronous approach read [3, 4 , 5] and respectively [2, 12].

1. Execution model

The reactive approach was designed in order to program systems that combine two main characteristics:

They are cyclic because they do not stop. They do not correspond to the traditional notion of program that we execute with data and that, after some time, finishes giving a result. The reactive system reacts with its environment.
They must be sufficiently fast so as to follow the environment evolutions. Actually we consider that the environment determines the rhythm of its activations: a reactive system reacts to each activation according to the environment state, transforming them, then it waits the following activation and so on.

The evolution of a reactive system through the time may be represented by the following figure:

As you can see, each activation of the system defines a step in the evolution of it. This notion of step is called instant and defines a sort of virtual clock in which each instant can take any time.

2 Reactive instructions and reactive machines

A reactive instruction defines a reactive behavior. In Junior, for example, there are 16 reactive instructions that allow programmers to describe a widely set of behaviors, for instance, to wait for an event, to implement loops, to preempt instructions and soon. The set of reactive instructions used in REJO is described in detail in the following section.

Each reactive instruction can be activated or restarted. Each activation returns one of the following codes:

TERM (by terminate) means that the instruction is completely terminated. There isn't anything to execute neither for the actual instant nor for the followings. So activating an instruction that returns TERM, doesn't have any effect and returns TERM.

STOP (by stop) means that the execution of an instruction is finished for the actual instant but there is code to execute in the following instants. The execution isn't definitively stopped, like TERM, but only for the actual instant.

SUSP (by suspend) means that the execution of an instruction has not achieved a stable state and that it must follow its execution in the following instant. It's the case when an instruction waits for an event that has not been generated; the execution is suspended so as to allow the other instructions the possibility of generating it.

The activation of a set of instructions, that we'll call reactive program or just program, is performed by a Java program called reactive machine. At the beginning, the reactive machine contains the reactive instruction Nothing that doesn't do anything and finishes instantaneously. The new instructions, added dynamically to the program, are executed in parallel with the others.

A reactive machine has two main roles: to define the instants of its program and to carry out its events. A machine finishes the actual instant when all the parallel instructions of the program are finished or stopped (any instruction of the program is suspended). Otherwise, while there are suspended instructions, the machine activates cyclically the program. At the end of each activation, the machine tests whether there was a change during the activation (in fact the machine tests if there was generated a new event), if there isn't anyone, there is no possibility that other activations unblock the situation. In that case a flag is set for defining the end of instant, this allows the suspended instructions to be stopped.

The next figure shows the syntactic tree generated by a reactive program as well as the first phase of the instruction's activation.

Syntactic tree of a reactive program.