Flexible Static Scheduling of Software with Logical Execution Time Constraints

Various programming models for embedded, time-triggered software employ the logical execution time (LET) abstraction in order to achieve time- and value-determinism. In these models, the application software is partitioned into tasks and a LET is associated with every task. In every execution, a task reads input values at the beginning of the LET and writes output values at the end of the LET. To achieve this behavior, existing implementations of LET models impose execution constraints where every physical execution of a task must take place between the corresponding LET bounds. In this paper we investigate a more efficient implementation paradigm in which LET-based execution constraints are relaxed by allowing tasks to execute outside of their LET bounds while preserving their I/O LET behavior. We present a modified runtime operational semantics where scheduling operations are decoupled from data transfer operations. Moreover, we propose a way to statically determine task release times that may precede LET start times, by using information about tasks connectivity (available in the LET model) and about task execution times (required for schedulability analysis). The consequences of using the relaxed constraints on the schedulability of the system are explored. We address sustainability of preemptive scheduling with respect to variations in release times and propose bounds on such variations that preserve schedulability for Fixed Priority (FP) scheduling. Moreover, we describe an application of Dual Priority scheduling which guarantees schedulability for any release time variation of a system that is originally FP-schedulable. Relaxing execution constraints leads to increased processor utilization. Some of the benefits thereof are illustrated on a typical control application.