Modular code generation from synchronous block diagrams: modularity vs. code size
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
An automated semantic-based approach for creating tasks from Matlab Simulink models
FMICS'11 Proceedings of the 16th international conference on Formal methods for industrial critical systems
Separate compilation of hierarchical real-time programs into linear-bounded Embedded Machine code
Science of Computer Programming
Semantic Translation of Simulink Diagrams to Input/Output Extended Finite Automata
Discrete Event Dynamic Systems
Compositionality in synchronous data flow: Modular code generation from hierarchical SDF graphs
ACM Transactions on Embedded Computing Systems (TECS)
FORMAL MODELLING OF REAL-TIME EMBEDDED AUTOMOTIVE ARCHITECTURE
Journal of Integrated Design & Process Science
Hi-index | 0.00 |
In previous work we have shown how modular code can be automatically generated from a synchronous block diagram notation where all blocks fire at all times. Here, we extend this work to triggered and timed diagrams, where some blocks fire only when their trigger is true, or at statically specified times. We show that, although triggers can be eliminated, this is not desirable since it destroys modularity and may also result in rejecting some diagrams that could be accepted. To avoid this we propose a modular code generation method that directly accounts for triggers. We also propose methods specialized to timed diagrams. Although timed diagrams are special cases of triggered diagrams, treating them directly allows us to obtain efficient code. We achieve this by enriching the interface of a macro block with firing time information and using this information to avoid firing the block unnecessarily. Existing firing time representations are generally conservative, in the sense that they cannot represent the exact set of firing times of a macro block, but a super-set. To remedy this, we devise a novel and accurate (exact) representation. This representation uses finite automata and is amenable to algebraic manipulation and generation of efficient code.