Optimal task scheduler for multi-core processor

Objectives: Current state-of-the-art task scheduling algorithms were mainly focused on deadline, load and energy factors in centralized cloud context. So, the proposed research objective focuses on dynamic and decentralized context. Methods/Statistical Analysis: Multi-objective task scheduling has become an important criterion for the dynamic and decentralized nature of cloud environment. Moreover, existing research works assumes that the resource load, energy and task execution time are known due its homogeneous nature. In order to improve the cloud consumer’s satisfaction, a novel Locality-Load-Prediction Aware Multi-objective Task Scheduling (LLPAMTS) algorithm is proposed to eventually distribute the tasks according to dynamic nature of cloud virtual machines. Findings: Proposed LLPAMTS algorithm will effectively schedule the tasks in an optimized manner by VM Scheduler component. This scheduling algorithm exploits the various monitoring parameters like locality, load and prediction parameters. It outperforms the existing deadline, load and energy aware scheduling algorithms in terms of task transfer time, task waiting time, task execution time, and task completion time. Applications/Improvements: The proposed LLPAMTS algorithm provides an average of 5 to 10% less task completion time compared to the existing deadline, load and energy aware scheduling algorithms. Keywords: Cloud Environment, Heterogeneous Cloud, Locality-Load-Prediction Aware Scheduling, Multi-Objective, Task Scheduling

This paper studies the effects of overheads in massively parallel processing. The execution times for tasks on individual processors are modeled as independent and identically but arbitrarily distributed random variables. The time to execute a process fork is assumed to be distributed exponentially. The main result bounds (in expectation) the overhead time in forking a large number of tasks across n machines and then waiting for the join event. The model used is appropriate for massive parallelism (when n is large): in fact, the bound serves as a heavy traffic limit approached as n→ ∞ and for task times that are large in comparison to the time to execute a fork. In this model, the expected total time to reach the final join consists of a forking overhead that grows linearly with the number of processors n, a time for parallel execution of tasks that decreases in n, and finally a synchronization delay that is a concave sublinear function of ρ = EX/EA, which is the ratio of expected task time to the expected time needed to fork a new process. This overhead function is typically no worse than o(ρ). An interesting aspect of the analysis is that the original problem reduces to a previously studied problem in queueing theory: estimating total end-to-end delay in an infinite-server resequencing system. The new results thus provide new bounds and heavy-traffic approximations (in distribution and in expectation) for the theory of M/GI/∞ resequencing queues. INFORMS Journal on Computing, ISSN 1091-9856, was published as ORSA Journal on Computing from 1989 to 1995 under ISSN 0899-1499.

Multicores are becoming ubiquitous, not only in general-purpose but also embedded computing. This trend is a reflexion of contemporary embedded applications posing steadily increasing demands in processing power. On such platforms, prediction of timing behavior to ensure that deadlines of real-time tasks can be met is becoming increasingly difficult. While real-time multicore scheduling approaches help to assure deadlines based on firm theoretical properties, their reliance on task migration poses a significant challenge to timing predictability in practice. Task migration actually (a) reduces timing predictability for contemporary multicores due to cache warm-up overheads while (b) increasing traffic on the network-on-chip (NoC) interconnect.This paper puts forth a fundamentally new approach to increase the timing predictability of multicore architectures aimed at task migration in embedded environments. A task migration between two cores imposes cache warm-up overheads on the migration target, which can lead to missed deadlines for tight real-time schedules. We propose novel micro-architectural support to migrate cache lines. Our scheme shows dramatically increased predictability in the presence of cross-core migration.Experimental results for schedules demonstrate that our scheme enables real-time tasks to meet their deadlines in the presence of task migration. Our results illustrate that increases in execution time due to migration is reduced by our scheme to levels that may prevent deadline misses of real-time tasks that would otherwise occur. Our mechanism imposes an overhead at a fraction of the task's execution time, yet this overhead can be steered to fill idle slots in the schedule, i.e., it does not contribute to the execution time of the migrated task. Overall, our novel migration scheme provides a unique mechanism capable of significantly increasing timing predictability in the wake of task migration.

The number of processors is increasing, but the usefulness of parallel computation is not better leveraged due to the inflexibility of design and implementation for multiprocessor embedded system applications. A higher level abstraction (i.e., a parallel programming framework) can ease the programmers to define parallelism for tasks in an application but designers still face the complexity of mapping high-level requirements to the syntax and semantics of a parallel programming interface. Nevertheless, embedded system applications execute various periodic tasks that are carried out repeatedly within a certain time interval and these tasks may be able to run in parallel to utilize the system efficiently. Therefore, in this paper, we propose a parallel loop-based task construct approach to automate the design process of embedded system applications from AADL models for a parallel programming framework. To illustrate the applicability of our mechanism, we use a well-known parallel programming interface called OpenMP to demonstrate the automation process in mapping tasks over multiple processor cores. To ensure meeting high-level requirements of embedded system applications, we analyze the existing OpenMP scheduling mechanisms and propose a layer of adaptation. We show that our proposed adaptation layer facilitates a tighter execution time bound for time-sensitive tasks or a better throughput for tasks that require higher quality of service. Thus, the proposed design automation framework is applicable for a variety of applications with different quality of service (QoS) requirements preserved at the lower level.

EDF (Earliest Deadline First) has been proved to be optimal scheduling algorithm for single processor real-time system. It also performs well for multiprocessor system. Limitation of EDF is that its performance decreases exponentially when system becomes slightly overloaded. ACO (Ant Colony Optimization) based scheduling algorithm performs well in both underloaded and overloaded conditions. But its limitation is that it takes more time for execution compared to EDF. In this paper, an adaptive algorithm for multiprocessor real-time system is proposed, which is combination of both of these algorithms. The proposed algorithm along with EDF and ACO based algorithm is simulated for real-time multiprocessor system and the results are obtained. The performance is measured in terms of Success Ratio (SR) and Effective CPU Utilization (ECU). Execution Time taken by each scheduling algorithm is also measured. From analysis and experiments, it reveals that the proposed algorithm is fast as well as efficient in both underloaded and overloaded conditions for real-time multiprocessor systems.

Programmable multiprocessor systems-on-chip are becoming the preferred implementation platform for embedded streaming applications. This enables using more software components, which leads to large and frequent dynamic variations of data-dependent execution times. In this context, accurate and conservative prediction of execution times helps in maintaining good audio/video quality and reducing energy consumption by dynamic evaluation of the amount of on-chip resources needed by applications. To be effective, multiprocessor systems have to employ the available parallelism. The combination of task-level parallelism and task delay variations makes predicting execution times a very hard problem. So far, under these conditions, no appropriate techniques exist for the conservative prediction of execution times with the required accuracy. In this paper, we present a novel technique for this problem, exploiting the concept of scenario-based prediction, and taking into account the transient and periodic behavior of scenarios and the effect of scenario transitions. In our MPEG-4 shape-decoder case study, we observe no more than 11% average overestimation.

A parallelizable (or malleable) task is one which can be run on an arbitrary number of processors, with a task execution time that depends on the number of processors allotted to it. Consider a system of M independent parallelizable tasks which are to be scheduled without preemption on a parallel computer consisting of P identical processors. For each task, the execution time is a known function of the number of processors allotted to it. The goal is to find (1) for each task i, an allotment of processors β, and (2) overall, a non-preemptive schedule assigning the tasks to the processors which minimizes the average response time of the tasks. Equivalently, we can minimize the flow time which is the sum of the completion times of each of the tasks. In this paper we tackle the problem of finding a schedule with minimum average response time in the special case where each task in the system has sublinear speedup. This natural restriction on the task execution time means simply that the efficiency of a task decrease or remains constant as the number of processors allotted to it increases. The scheduling problem with sublinear speedups has been shown to be NP-complete in the strong sense. We therefore focus on finding a polynomial time algorithm whose solution comes within a fixed multiplicative constant of optimal. In particular, we given algorithm which finds a schedule having a response time that is within 2 times that of the optimal schedule and which runs in O(M(M2 + P)) time.

In the past few years, with the rapid development of heterogeneous computing systems (HCS), the issue of energy consumption has attracted a great deal of attention. How to reduce energy consumption is currently a critical issue in designing HCS. In response to this challenge, many energy-aware scheduling algorithms have been developed primarily using the dynamic voltage-frequency scaling (DVFS) capability which has been incorporated into recent commodity processors. However, these techniques are unsatisfactory in minimizing both schedule length and energy consumption. Furthermore, most algorithms schedule tasks according to their average-case execution times and do not consider task execution times with probability distributions in the real-world. In realizing this, we study the problem of scheduling a bag-of-tasks (BoT) application, made of a collection of independent stochastic tasks with normal distributions of task execution times, on a heterogeneous platform with deadline and energy consumption budget constraints. We build execution time and energy consumption models for stochastic tasks on a single processor. We derive the expected value and variance of schedule length on HCS by Clark's equations. We formulate our stochastic task scheduling problem as a linear programming problem, in which we maximize the weighted probability of combined schedule length and energy consumption metric under deadline and energy consumption budget constraints. We propose a heuristic energy-aware stochastic task scheduling algorithm called ESTS to solve this problem. Our algorithm can achieve high scheduling performance for BoT applications with low time complexity $O(n(M+\log n))$ , where $n$ is the number of tasks and $M$ is the total number of processor frequencies. Our extensive simulations for performance evaluation based on randomly generated stochastic applications and real-world applications clearly demonstrate that our proposed heuristic algorithm can improve the weighted probability that both the deadline and the energy consumption budget constraints can be met, and has the capability of balancing between schedule length and energy consumption.

Minimum execution time scheduling of unit execution time (UET) task systems with resources has been the subject of several papers over the past few years. Because such scheduling problems are, in general, NP-hard, a variety of heuristic methods for producing schedules have been studied, among them, critical path scheduling. The strongest results to date have been for systems where there is no processor constraint. These results may be utilized for systems with a processor constraint by treating the processors as an additional resource. Unfortunately, in those cases where the number of processors is close to the number of resources, this results in an upper bound which is somewhat misleading. In this paper we investigate the performance of critical path scheduling for UET task systems with resources and a fixed number of processors. An upper bound for the worst case performance of critical path scheduling is given. This bound depends both on the number of processors and on the number of different resources. Moreover, we show that this is the best possible (asymptotic) upper bound.

In the real-time task scheduling of Cyber Physical System (CPS), the existing scheduling algorithms can’t effectively differentiate the importance level of random tasks, resulting in poor real-time scheduling of important random tasks and insufficient submission rate. This paper comprehensively considers the factors of recent available time, criticality and execution time, and then proposes a fuzzy scheduling algorithm of high priority random tasks (FSA-HPRT) for CPS. The algorithm first obtains the applicable time slice by maximizing delayed the execution time of the periodic task, and calculates the difference between the end time of the periodic task and the deadline time as the error time slice. Then use the fuzzy set to process the latest available time, criticality and execution time of the random task to decide the random task priority. Finally, the task-scheduling queue is established for the system to perform scheduling according to the priority of the random task by using the applicable time slice and the error time slice. The simulation results show that compared with the ISS algorithm, the proposed algorithm can significantly improve the submission rate of important random tasks. At the same time, high-priority random tasks can get responses preferentially.

Average-case performance analysis of scheduling random parallel tasks with precedence constraints on mesh connected multicomputer systems

Efficient scheduling algorithm is one of the key factors in determining the performance of distributed memory machines. This paper presents an enhanced Search and Du plication Based Scheduling (SDBS) algorithm which car schedule Directed Acyclic Graphs (DA Gs) with variable execution time tasks. Since the DAGs are based on data dependencies of the tasks, the control dependencies are clustered within each node. If the node encapsulates a loop or an if-then-else kind of statement, then assuming the execution times to be fixed would not be appropriate. It is assumed in this paper that the execution time varies between two time estimates. The complexity of this scheduling algorithm is in 0(V 4- E), where V is the number of node,- and E is the number of edges in the task graph. This algo rithm is based on some realistic assumptions and generates an optimal time schedule. If the assumptions cannot be completely satisfied then the algorithm provides a schedule which is close to optimal. The performance in these cases has been obtained using extensive simulation work which indicate the closeness of the results.

This paper deals with Intellectual Property (IP) core design for dynamic task scheduling to support Out-of-Order (OoO) execution in Multiprocessor System-on-Chip (MPSoC) environment. MPSoC is one of the most promising future processor architecture. But such systems have to face challenges in the context of OoO execution during dynamic scheduling due to data dependencies like Read-after-Write (RAW), Write-after-Write (WAW) and Write-after-Read (WAR). Due to these dependencies stalling problem occur during OoO execution. In order to solve this stalling problem and achieve task level parallelism (TLP), Scoreboarding algorithm with register renaming technique is designed. As these dependencies impose challenging constraints on the direct use of techniques like OoO execution, register renaming and dynamic scheduling, a synthesizable IP core is designed. The simulation results show that the design can analyze all the task dependencies during run-time and resolves them at TLP. This algorithm is able to resolve 100% RAW, WAW and WAR hazards which are not solvable at instruction level parallelism (ILP).

List based scheduling algorithms have been proven an optimistic strategy with a shorter response time to generate feasible solutions for the workflow scheduling problem. Data-intensive and computation-intensive workflow applications have different characteristics in terms of the ratio between data transfer time and task execution time. Workflow scheduling algorithms in a cloud-based environment should adequately consider the characteristics of the underlying cloud platform such as the on-demand resource provisioning strategy, the practically unlimited compute capacities, the booting times of virtual machines, the homogeneous network and the pay-as-you-go price model to produce an optimal scheduling solution within the deadline constraint of a given workflow. In this paper, a path based scheduling algorithm, named LPOD, is proposed to find the best workflow schedule solution with minimum monetary cost in a cloud computing environment. A series of case studies have been carefully conducted using synthetic workflows based on DATAVIEW, which is a popular open-source big data workflow management system. The experimental results show that the proposed algorithm is efficient and can generate better workflow schedules than the state-of-the-art algorithms such as IC-PCP and SGX-E2C2D.

Most real-time scheduling algorithms are open-loop algorithms as the scheduling decisions are based on the worst-case estimates of task parameters. In recent years, the scheduling has gained importance due to its applicability to many real-world problems wherein the feedback information can be exploited efficiently to adjust task and/or scheduler parameters, thereby improving the system's performance. In this paper, we discuss an open-loop dynamic scheduling algorithm that employs a notion of task overlap in the scheduler in order to provide some flexibility in task execution time. Then we present a novel closed-loop approach for dynamically estimating the execution time of tasks based on both deadline miss ratio and task rejection ratio in the system. This approach is highly preferable for firm/soft real-time systems since it provides a firm performance guarantee in terms of deadline misses while achieving a high guarantee ratio. We design the proportional-integral controller and H/sub /spl infin// controller for closed loop scheduling. We evaluate the performance of the open-loop and the closed-loop approaches using simulation studies. We show that the closed-loop dynamic scheduling offers a better performance over the open-loop scheduling under all practical conditions.