Citation
Tom Henzinger, Christoph Kirsch, Slobodan Matic. "Schedule Carrying Code". Proc. EMSOFT, LNCS 2855, 241-256, 2003.

Abstract
To guarantee the correct execution of a hard real-time program on a given platform, the scheduler must ensure that all deadlines are met. We introduce the paradigm of schedule-carrying code (SCC), where the compiler proves the existence of a feasible schedule by generating such a schedule, which is then attached to the generated code in the form of executable instructions that remove the need for a system scheduler. In this way, the schedule is produced once, and revalidated and executed with each use. We evaluate SCC both in theory and practice. In theory, we give two scenarios, of nonpreemptive and distributed scheduling for Giotto programs, where the generation of a feasible schedule is hard, while the validation of scheduling instructions that are attached to the code is easy. In practice, we implement SCC and show that explicit scheduling instructions can reduce the scheduling overhead up to 35 percent, and can provide an efficient, flexible, and verifiable means for compiling Giotto on complex architectures, such as the TTA.

Electronic downloads

• http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.10.7227

• HTML

  Tom Henzinger, Christoph Kirsch, Slobodan Matic. <a
  href="http://chess.eecs.berkeley.edu/pubs/738.html"
  >Schedule Carrying Code</a>, Proc. EMSOFT, LNCS
  2855, 241-256, 2003.

• Plain text

  Tom Henzinger, Christoph Kirsch, Slobodan Matic.
  "Schedule Carrying Code". Proc. EMSOFT, LNCS 2855,
  241-256, 2003.

• BibTeX

  @inproceedings{HenzingerKirschMatic03_ScheduleCarryingCode,
      author = {Tom Henzinger and Christoph Kirsch and Slobodan
                Matic},
      title = {Schedule Carrying Code},
      booktitle = {Proc. EMSOFT, LNCS 2855},
      pages = {241-256},
      year = {2003},
      abstract = {To guarantee the correct execution of a hard
                real-time program on a given platform, the
                scheduler must ensure that all deadlines are met.
                We introduce the paradigm of schedule-carrying
                code (SCC), where the compiler proves the
                existence of a feasible schedule by generating
                such a schedule, which is then attached to the
                generated code in the form of executable
                instructions that remove the need for a system
                scheduler. In this way, the schedule is produced
                once, and revalidated and executed with each use.
                We evaluate SCC both in theory and practice. In
                theory, we give two scenarios, of nonpreemptive
                and distributed scheduling for Giotto programs,
                where the generation of a feasible schedule is
                hard, while the validation of scheduling
                instructions that are attached to the code is
                easy. In practice, we implement SCC and show that
                explicit scheduling instructions can reduce the
                scheduling overhead up to 35 percent, and can
                provide an efficient, flexible, and verifiable
                means for compiling Giotto on complex
                architectures, such as the TTA.},
      URL = {http://chess.eecs.berkeley.edu/pubs/738.html}
  }
  

Posted by Christopher Brooks on 4 Nov 2010.
For additional information, see the Publications FAQ or contact webmaster at chess eecs berkeley edu.