Developing graph-based co-scheduling algorithms on multicore computers

It is common that multiple cores reside on the same chip and share the on-chip cache. As a result, resource sharing can cause performance degradation of co-running jobs.Job co-scheduling is a technique that can effectively alleviate this contention and many co-schedulers have been reported in related literature. Most solutions however do not aim to find the optimal co-scheduling solution. Being able to determine the optimal solution is critical for evaluating co-scheduling systems. Moreover, most co-schedulers only consider serial jobs, and there often exist both parallel and serial jobs in real-world systems. In this paper a graph-based method is developed to find the optimal co-scheduling solution for serial jobs; the method is then extended to incorporate parallel jobs, including multi-process, and multithreaded parallel jobs. A number of optimization measures are also developed to accelerate the solving process. Moreover, a flexible approximation technique is proposed to strike a balance between the solving speed and the solution quality. Extensive experiments are conducted to evaluate the effectiveness of the proposed co-scheduling algorithms. The results show that the proposed algorithms can find the optimal co-scheduling solution for both serial and parallel jobs. The proposed approximation technique is also shown to be flexible in the sense that we can control the solving speed by setting the requirement for the solution quality

Toward Contention Analysis for Parallel Executing Real-Time Tasks

In measurement-based probabilistic timing analysis, the execution conditions imposed to tasks as measurement scenarios, have a strong impact to the worst-case execution time estimates. The scenarios and their effects on the task execution behavior have to be deeply investigated. The aim has to be to identify and to guarantee the scenarios that lead to the maximum measurements, i.e. the worst-case scenarios, and use them to assure the worst-case execution time estimates. We propose a contention analysis in order to identify the worst contentions that a task can suffer from concurrent executions. The work focuses on the interferences on shared resources (cache memories and memory buses) from parallel executions in multi-core real-time systems. Our approach consists of searching for possible task contenders for parallel executions, modeling their contentiousness, and classifying the measurement scenarios accordingly. We identify the most contentious ones and their worst-case effects on task execution times. The measurement-based probabilistic timing analysis is then used to verify the analysis proposed, qualify the scenarios with contentiousness, and compare them. A parallel execution simulator for multi-core real-time system is developed and used for validating our framework. The framework applies heuristics and assumptions that simplify the system behavior. It represents a first step for developing a complete approach which would be able to guarantee the worst-case behavior

Scheduling techniques to avoid contention in multi-core systems

One of the main problems in multi-core systems is the contention of shared resources such as cache, memory controller, pre-fetcher etc. among the cores. Due to the contention among shared resources, the processing unit's performance is degraded. Scheduling of applications in such a way that it reduces the contention among shared resources is one of the promising solutions. Scheduling is considered as an efficient and best technique as it doesn't require any extra hardware or any changes to be made to the OS or its underlying kernel. Scheduling can be implemented at user level by using system calls. In the prior works it was considered that the cache contention was the main cause of performance degradation and many hardware and software techniques were found to avoid or minimize it. But further experiments proved that the contention caused by pre-fetcher and memory controller is also having significant effect on performance degradation. Many scheduling policies and classification schemes have been designed to find out an efficient scheduling algorithm. Miss rate is considered to be simple yet efficient classification scheme to classify the threads as it not only considers contention due to cache but also the memory controller and pre-fetcher. Distributed Intensity is the first scheduling algorithm discussed which uses miss rate to classify threads and assign them to all cores in an efficient way so that miss rate is shared almost equally among the cores. Then Distributed Intensity is combined with Swap algorithm to further improve the performance by using dynamic optimization. Then by further studies it is found out that miss rate cant be efficient classification technique for memory intensive workloads. So the concepts of Contentiousness and Sensitivity are introduced to improve the efficiency of scheduling algorithm and to minimize the performance degradation due to contention

Co-Scheduling Algorithms for High-Throughput Workload Execution

This paper investigates co-scheduling algorithms for processing a set of parallel applications. Instead of executing each application one by one, using a maximum degree of parallelism for each of them, we aim at scheduling several applications concurrently. We partition the original application set into a series of packs, which are executed one by one. A pack comprises several applications, each of them with an assigned number of processors, with the constraint that the total number of processors assigned within a pack does not exceed the maximum number of available processors. The objective is to determine a partition into packs, and an assignment of processors to applications, that minimize the sum of the execution times of the packs. We thoroughly study the complexity of this optimization problem, and propose several heuristics that exhibit very good performance on a variety of workloads, whose application execution times model profiles of parallel scientific codes. We show that co-scheduling leads to to faster workload completion time and to faster response times on average (hence increasing system throughput and saving energy), for significant benefits over traditional scheduling from both the user and system perspectives