As already mentioned, there are several models of computation that all have particular advantages and disadvantages. For the efficient design of embedded systems, it is therefore necessary to translate MoCs into others that lend themselves better for the selected architectures. For example, we translate the original synchronous model into a data flow process network to generate a distributed embedded system or a multithreaded software.
To this end, we need an intermediate representation of the embedded systems. In our research, it turned out that guarded actions are a convenient data structure for this purpose. Recall that model of computation determines why, when, which atomic action of a system is executed. This is represented by guarded actions (g,a) that consist of a boolean condition g called the guard and an atomic action a of the system. The guarded actions alone do not yet determine a model of computation, they are essentially only syntax that has to be interpreted wrt. a MoC. For example, in the synchronous MoC, all guards are evaluated in each macro step, and then all enabled actions are executed (we ignore causality in this rough view here). In an asynchronous MoC, one could instead select a subset of the enabled actions for execution. Moreover, depending on the MoC, the guards may consist of only boolean program expressions or also clocks or progress of time.
The intermediate representation of systems in our Averest design framework is essentially given by a set of synchronous guarded actions. Translations from synchronous guarded actions to synchronous hardware circuits is very simple: We essentially just have to reorganize the guarded actions into equations and to bit-blast the finite data types to reduce them to the bit-level.
We already presented translations from the synchronous MoC to the discrete event MoC, in particular, a translation of Quartz to SystemC. This is useful for efficient simulation and also to integrate Quartz designs in available SystemC models.
We are particularly interested in the translation of synchronous guarded actions (e.g. obtained from Quartz programs) to data flow process networks. This translation is the key to the efficient synthesis of distributed embedded systems as well as multithreaded software for embedded systems. To this end, we consider recent results on endo/isochronous systems that allow us to avoid the communication of irrelevant data. We developed special code optimizations to identify passive code that is then disabled to reduce the energy consumption and the communication costs, which typically improves the performance of the system.