A dynamic scheduling approach is introduced that takes advantage of the simplicity of nonpreemptive priority list scheduling, yet allows the inclusion of dynamically arriving tasks into the hard realtime task system. In list scheduling, so-called timing anomalies can cause deadlines to be missed if one or more tasks finish early. Apriori and run-time stabilization algorithms have been developed that can avoid these instabilities. However, these approaches assume static task priorities. Any arrival of tasks in addition to the static workload has been dealt with using slack-time reclaiming arguments. We introduce feasibility tests that allow tasks and subgraphs to be inserted into the priority list at run-time, modifying the priority list. The result is a scheduling environment where task priorities are no longer fixed, yet stability of the dispatcher is guaranteed.

This paper considers non-preemptive scheduling and dispatching in distributed real-time applications where the workloads are executed repeatedly. Specifically, we consider periodic and end-to-end scheduling. In periodic scheduling workloads must execute once during each repeating fixed duration time slot. In contrast, in end-to-end scheduling the timing constraints of repeating instantiations of the workload are relative. We present a dispatching environment for these applications that takes advantage of two main properties of list scheduling, namely simplicity and low run-time overhead. However, an inherent problem in list scheduling are so-called timing anomalies, where early finishing tasks may cause other tasks to miss deadlines. By modifying workloads using special tasks called phantom tasks, one can derive task systems that are capable of implementing periodic or end-to-end behavior while taking advantage of a variety of adaptable existing safe algorithmic dispatching solutions with different run-time complexity.

This paper investigates the problem of guaranteeing stability and run-time feasibility in real-time systems containing coupled tasks, in the context of nonpreemptive priority scheduling. Instability is the result of so-called multiprocessor timing anomalies, where deadlines can be missed due to the reduction in task durations. Such reductions can also result in run-time infeasibility of coupled task pairs due to the inherent inter-task timing constraints. A scheduling environment, feasibility conditions and a general algorithm are presented that avoid both phenomena at run-time. 1

This paper introduces a new graph theoretical concept called strong precedence which is used to address the problem of scheduling instability in non-preemptive static list scheduling. Scheduling instability occurs when a reduction in task duration of one or more tasks causes other tasks to miss their deadline. This problem has been addressed in the past by introducing additional precedence constraints into the precedence graph representing the workload, or by limiting the depth the dispatchers scan at run-time. We present an alternative stabilization approach based on the concept of strong and weak precedence. By defining a strong precedence relation on selected subgraphs, the workload becomes inherently stable without requiring the introduction of new edges into the graph.