Electrical Engineering
      and Computer Sciences

Electrical Engineering and Computer Sciences

COLLEGE OF ENGINEERING

UC Berkeley

Distributed Schedule Carrying Code

Thomas A. Henzinger, Christoph M. Kirsch and Slobodan Matic

EECS Department
University of California, Berkeley
Technical Report No. UCB/CSD-04-1360
2004

http://www.eecs.berkeley.edu/Pubs/TechRpts/2004/CSD-04-1360.pdf

We present an approach for the design and implementation of embedded real-time software running on a distributed platform. The approach consists of a high-level specification layer instantiated by Giotto programs and a low-level verification and execution layer instantiated by Schedule carrying code (SCC). We explain a methodology in which several code suppliers, coordinated by a resource manager, independently generate and verify portions of the software system to be implemented on different hosts. A scheme for compiling Giotto programs by taking into account task (port) allocation to suppliers and hosts is described. After semantics of distributed SCC is presented we investigate composability properties. Since SCC executable carries its schedule as code, in order for distributed SCC to be composable we introduce a type for it, that for each supplier specifies time instants in which it is allowed to use computation or communication resources. We formally prove that if supplier SCC programs individually satisfy certain properties, namely type conformance and time safety, then the distributed SCC program correctly implements the original Giotto program specification. We demonstrate composability by showing that time to check these properties is proportional to the size of individual Giotto program portions. Although we assume static (time-triggered) computation and communication we make sure that the approach is valid also for the multi-modal Giotto programs.


BibTeX citation:

@techreport{Henzinger:CSD-04-1360,
    Author = {Henzinger, Thomas A. and Kirsch, Christoph M. and Matic, Slobodan},
    Title = {Distributed Schedule Carrying Code},
    Institution = {EECS Department, University of California, Berkeley},
    Year = {2004},
    URL = {http://www.eecs.berkeley.edu/Pubs/TechRpts/2004/6506.html},
    Number = {UCB/CSD-04-1360},
    Abstract = {We present an approach for the design and implementation of embedded real-time software running on a distributed platform. The approach consists of a high-level specification layer instantiated by Giotto programs and a low-level verification and execution layer instantiated by Schedule carrying code (SCC). We explain a methodology in which several code suppliers, coordinated by a resource manager, independently generate and verify portions of the software system to be implemented on different hosts. A scheme for compiling Giotto programs by taking into account task (port) allocation to suppliers and hosts is described. After semantics of distributed SCC is presented we investigate composability properties. Since SCC executable carries its schedule as code, in order for distributed SCC to be composable we introduce a type for it, that for each supplier specifies time instants in which it is allowed to use computation or communication resources. We formally prove that if supplier SCC programs individually satisfy certain properties, namely type conformance and time safety, then the distributed SCC program correctly implements the original Giotto program specification. We demonstrate composability by showing that time to check these properties is proportional to the size of individual Giotto program portions. Although we assume static (time-triggered) computation and communication we make sure that the approach is valid also for the multi-modal Giotto programs.}
}

EndNote citation:

%0 Report
%A Henzinger, Thomas A.
%A Kirsch, Christoph M.
%A Matic, Slobodan
%T Distributed Schedule Carrying Code
%I EECS Department, University of California, Berkeley
%D 2004
%@ UCB/CSD-04-1360
%U http://www.eecs.berkeley.edu/Pubs/TechRpts/2004/6506.html
%F Henzinger:CSD-04-1360