Communicating sequential processes
Communicating sequential processes
LUSTRE: a declarative language for real-time programming
POPL '87 Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
The C programming language
A communicating Petri net model for the design of concurrent asynchronous modules
DAC '94 Proceedings of the 31st annual Design Automation Conference
Real-time multi-tasking in software synthesis for information processing systems
ISSS '95 Proceedings of the 8th international symposium on System synthesis
Derivation of formal representations from process-based specification and implementation models
ISSS '97 Proceedings of the 10th international symposium on System synthesis
Compiling Esterel into sequential code
Proceedings of the 37th Annual Design Automation Conference
Petri Net Theory and the Modeling of Systems
Petri Net Theory and the Modeling of Systems
Embedded software in real-time signal processing systems: design technologies
Readings in hardware/software co-design
Compilers: Principles, Techniques, and Tools (2nd Edition)
Compilers: Principles, Techniques, and Tools (2nd Edition)
Hi-index | 0.00 |
Embedded applications are often more naturally modeled as a set of concurrent tasks, but yet they are often implemented using a single embedded processor. Traditionally, run-time operating systems have been used to simulate concurrency by timesharing the underlying processor and to facilitate inter-process communication amongst the concurrent tasks. However, this run-time approach to multi-tasking and inter-process communication can often introduce significant overhead to execution times and memory requirements, prohibitive in many cases for embedded applications where processor and memory resources are scarce. In this paper, we present compilation techniques that can statically resolve concurrency at compile-time so that the resulting code produced can be sequentially executed on an embedded processor without the need for a run-time scheduler. Our techniques are based on a novel Petri net theoretic framework. In particular, we show how a concurrent program specification can be transformed into an intermediate Petri net representation. We then show how the intermediate Petri net may be statically scheduled to produce a sequential state machine model that can be sequentially executed directly on an embedded processor without a run-time operating system. In practice, this technique produces efficient results. However, theoretically, it is possible for the resulting state machine to become very large, resulting in code explosion. To circumvent this limitation, we describe a compositional approach that can scale well to large applications and is immune to code explosion.