Techniques to Tighten the Upper Bound on the ExecutionTime of Task-based Parallel Applications

Sammanfattning: To use multiprocessors in hard real-time systems, schedulability analysis is needed to provide formally proven guarantees for the timing behavior of the system. Programming models for parallel applications, such as OpenMP, use pragmas to specify parts of the application as parallel tasks, for example, a function or a body of a loop. Worst-case-execution-time (WCET) analysis is used to find a safe upper bound of the execution time of a task (i.e., sequential code). However, determining a safe upper bound on the execution time of the entire parallel application on a multiprocessor platform, called the makespan, is a challenging problem. Parallel applications can be modeled as directed acyclic graphs (DAG) (nodes are tasks and edges dependencies) where every node is characterized by its WCET. On a homogeneous platform, the simulation of a greedy, i.e., work-conserving schedule cannot be used as a safe upper bound on the execution time due to timing anomalies. Timing anomalies is the main obstacle to calculate a safe upper bound of the makespan which is necessary to provide timing guarantees for parallel real-time applications. In the presence of timing anomalies, analytical approaches, with pessimistic assumptions for the schedule of the tasks, are commonly used by related work to calculate a safe upper abound of the makespan on a homogeneous platform. This thesis first provides a simulation based approach to calculate the makespan, with the use of time predictable and dynamic schedulers. A first contribution is a scheduler called Strict Lazy that fulfills the basic requirements to provide a timing anomaly-free schedule. As a result, a safe estimation of the makespan for homogeneous multiprocessors is calculated. Furthermore, the thesis builds upon Strict Lazy to develop another scheduler, called the Lazy scheduler that, has proven to be timing anomaly-free. As a result, the simulation of the schedule of a DAG with Lazy where all the nodes are executed for their WCET calculates a safe upper bound of the makespan. The proposed approach provides tighter and more scalable (to the number of processors) makespan estimations compared to the state-of-the-art. A heterogeneous multiprocessor model is more general than a homogeneous multiprocessor model as it can cover a broad range of multiprocessor platforms including platforms with single instruction set architecture (ISA) but different microarchitectures, coexistence of processors with different ISAs and architectures with special-purpose accelerators. To the best of our knowledge, no earlier work considers the problem of how to calculate the makespan for schedules on unrelated multiprocessor platforms. This thesis finally proposes a polynomial time complexity, closed-form, combinatorial method to calculate a safe upper bound of the makespan of DAGs for the unrelated multiprocessor model. The proposed method is applicable to a wide range of already used and future coming schedulers and is reducible to the state-of-art for homogeneous and related models.