Polynomial Algorithms for MPSP Using Parametric Linear Programming

This paper is concerned with the grain-size problem; how can we partition a program into tasks (concurrent modules) for parallel processing. Multiprocessor scheduling problem has long been studied by a number of researchers, and several scheduling algorithms have also been proposed. However, the effect of parallel processing strictly attributes of the given tasks such as the topology of task graph (directed acyclic graph representing precedence relations among tasks) and the balance of grain-size (computational time of each task) as well as the available number of processors. In order to improve the solution of multiprocessor scheduling problem, this paper proposes an excellent method for restructuring a given task graph. Analyzing the topology of the task graph, adequate tasks are divided one by one for increasing the parallelism of the task graph. The effect of task division is evaluated by scheduling tasks, where communication delays between distinct processors are considered. As a result, an appropriate task graph could be derived from the initially given task graph with respect to the designated number of processors. The proposed method is successfully applied to the parallel processing of robot-arm control computation on a multiprocessor system.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

A new polynomial algorithm is developed for the classical multiprocessor scheduling problem in which independent jobs are nonpreemptively scheduled on identical parallel machines with the objective of minimizing the makespan, i.e. the latest job finishing time. The algorithm at first generates and merges a set of partial solutions in order to obtain a feasible solution for the multiprocessor scheduling problem. Then a set of bin packing problems are solved in order to improve the solution, by iteratively using a MultiFit type procedure on different job sets. The effectiveness of this approach is evaluated by solving a large number of benchmark instances. The results indicate that the proposed algorithm, called PSMF, is very competitive with well known constructive algorithms for a wide range of instances. Furthermore, PSMF is competitive with respect to some of the best heuristics for parallel machine scheduling problems only when it uses a 2-exchange procedure.

On the computational complexity of periodic scheduling

Multiprocessor scheduling problems are hard because of the numerous constraints on valid schedules to take into account. This paper presents new schedule representations in order to overcome these difficulties, by allowing processors to be fractionally allocated. We prove that these representations are equivalent to the standard representations when preemptive scheduling is allowed. This allows the creation of scheduling algorithms and the study of feasibility in the simpler representations. We apply this method throughout the paper. Then, we use it to provide new simple solutions to the previously solved implicit-deadline periodic scheduling problem. We also tackle the more general problem of scheduling arbitrary time-triggered tasks, and thus in particular solve the open multiprocessor general periodic tasks scheduling problem. Contrary to previous solutions like the PFair class of algorithms, the proposed solution also works when processors have different speeds. We complete the method by providing an online schedule transformation algorithm, that allows the efficient handling of both time-triggered and event-triggered tasks, as well as the creation of online rate-based scheduling algorithms on multiprocessors.

Wireless sensor networks have been a very active research field in the past few years. However, most of extant research has focused on wireless sensing, such as environmental and habitat monitoring [6]. In this paper, we investigate the feasibility of applying wireless technologies in industrial real-time process control systems. We define a minimum set of assumptions about the underlying sensor networks in order to achieve realtime support for process control. These assumptions are necessary and practical from an industrial perspective. We formulate the modeling of a wireless process control configuration as a multi-processor scheduling problem. The resulting scheduling problem is solved by the scheduler synthesis tool MSP.RTL [7] to produce a valid configuration for deployment. The deployment, because of the way it is derived, will provide real-time wireless support for the controlled processes. Simulation results on data from real plant configurations show that this approach can also drastically reduce potential interferences between wireless transfers.

In this paper, we address a logistics problem that a manufacturer of auto parts in the north of Spain described to the authors. The manufacturer stores products in its warehouse until customers retrieve them. The customers and the manufacturer agree upon an order pickup frequency. The problem is to find the best pickup schedule, which consists of the days and times during the day that each customer is expected to retrieve his/her order. For a given planning horizon, the optimization problem is to minimize the labor requirements to load the vehicles that the customers use to pick up their orders. Heuristically, we approach this situation as a decision problem in two levels. At the first level, customers are assigned to a calendar, consisting of a set of days with the required frequency during the planning horizon. Then, for each day, the decision at the second level is to assign each customer to a time slot. The busiest time slot determines the labor requirement for a given day. Therefore, once customers have been assigned to particular days in the planning horizon, the second-level decision is a multiprocessor scheduling problem, where each time slot is the equivalent of a processor, and where the objective is to minimize the makespan. A metaheuristic procedure is developed for the problem of minimizing labor requirements in this periodic vehicle-loading problem and artificial as well as real data are used to assess its performance.

Comparability graph augmentation for some multiprocessor scheduling problems

In the classical load balancing or multiprocessor scheduling problem, we are given a sequence of jobs of varying sizes and are asked to assign each job to one of the m empty processors. A typical objective is to minimize makespan, the load on the heaviest loaded processor. Since in most real world scenarios the load is a dynamic measure, the initial assignment may be not remain optimal with time. Motivated by such considerations in a variety of systems, we formulate the problem of load rebalancing --- given a possibly suboptimal assignment of jobs to processors, relocate a set of the jobs so as to decrease the makespan. Specifically, the goal is to achieve the best possible makespan under the constraint that no more than k jobs are relocated. We also consider a generalization of this problem where there is an arbitrary cost function associated with each job relocation. Since the problem is clearly NP-hard, we focus on approximation algorithms. We construct a sophisticated algorithm which achieves a 1.5-approximation, with near linear running time. We also show that the problem has a PTAS, resolving the complexity issue. Finally, we investigate the approximability of several extensions of the rebalancing model.

We consider the problem of scheduling tasks on multiprocessor architectures in the presence of communication delays. Given a set of dependent tasks, the scheduling problem is to allocate the tasks to processors such that the pre-specified precedence constraints among the tasks are obeyed and certain cost-measures (such as the computation time) are minimized. Several cases of the scheduling problem have

The problem of optimal scheduling n tasks in a parallel processor system is studied. The tasks are malleable, i.e., a task may be executed by several processors simultaneously and the processing speed of a task is a nonlinear function of the number of processors allocated to it. The total number of processors is m and it is an upper bound on the number of processors that can be used by all the tasks simultaneously. It is assumed that the number of processors is sufficient to process all the tasks simultaneously, i.e. n≤m. The objective is to find a task schedule and a processor allocation such that the overall task completion time, i.e. the makespan, is minimized. The problem is motivated by real-life applications of parallel computer systems in scientific computing of highly parallelizable tasks. An O(n) algorithm is presented to solve this problem when all the processing speed functions are convex. If these functions are all concave and the number of tasks is a constant, the problem can be solved in polynomial time. A relaxed problem, in which the number of processors allocated to each task is not required to be integer, can be solved in O(nmax {m,nlog 2 m}) time. It is proved that the minimum makespan values for the original and relaxed problems coincide. For n=2 or n=3, an optimal solution for the relaxed problem can be converted into an optimal solution for the original problem in a constant time.

In this paper we investigate a semi on-line multiprocessor scheduling problem. The problem is the classical on-line multiprocessor problem where the total sum of the tasks is known in advance. We show an asymptotic lower bound on the performance ratio of any algorithm (as the number of processors gets large), and present an algorithm which has performance ratio at most ({\sqrt 6} + 1)/2 < 1.725 for any number of processors. When compared with known general lower bounds, this result indicates that the information on the sum of tasks substantially improves the performance ratio of on-line algorithms.

In this paper we present several new results in the theory of homogeneous multiprocessor scheduling. We start with some assumptions about the behavior of tasks, with associated precedence constraints, as processor power is applied. We assume that as more processors are applied to a task, the time taken to compute it decreases, yielding some speedup. Because of communication, synchronization, and task scheduling overhead, this speedup increases less than linearly with the number of processors applied. We also assume that the number of processors which can be assigned to a task is a continuous variable, with a view to exploiting continuous mathematics. The optimal scheduling problem is to determine the number of processors assigned to each task, and task sequencing, to minimize the finishing time. These assumptions allow us to recast the optimal scheduling problem in a form which can be addressed by optimal control theory. Various theorems can be proven which characterize the optimal scheduling solution. Most importantly, for the special case where the speedup function of each task isp α , wherep is the amount of processing power applied to the task, we can directly solve our equations for the optimal solution. In this case, for task graphs formed from parallel and series connections, the solution can be derived by inspection. The solution can also be shown to be shortest path from the initial to the final state, as measured by anl 1/α distance metric, subject to obstacle constraints imposed by the precedence constraints.

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.

Converging to periodic schedules for cyclic scheduling problems with resources and deadlines

Static scheduling of directed acyclic data flow graphs onto multiprocessors using particle swarm optimization