Performance bounds on multiprocessor scheduling strategies for statically allocated programs

In multiprocessors with static allocation of processes to processors, scheduling can be done locally for each processor. The scheduling strategy may have dramatic effect on the execution time of a parallel program. It is an NP-hard problem to find an optimal schedule, and very little is known of how close the heuristic solutions get.The major result here is a theorem stating that if certain program parameters, which can be obtained from an execution of the program on a single-processor, are known, the execution time of the optimal schedule can be calculated within a factor equal to the largest number of border processes on one processor. Border processes are processes which communicate with other processors. The program parameters are obtained using a previously developed tool.Due to the generality of this theorem, the proof is rather complex because it has to cover a large range of situations. The theorem itself, however, is easy to apply, making it possible to compare the performance of different scheduling strategies with the optimal case. The proof also gives important hints on how to design efficient scheduling algorithms for statically allocated programs.     

On the two-phase method for preemptive scheduling

Preemptive scheduling problems on parallel processors may in some cases be solved by a two-phase method: forst solve a LP problem which will give the minimum total completion time T and the processing times of the jobs on the various processors; second construct a feasible schedule using T time units. Some extensions of this procedure are discussed. A general model for preemptive scheduling is described with a two-phase method for solving problems of this type.     

Trading grid services – a multi-attribute combinatorial approach

The Grid is a promising technology for providing access to distributed high-end computational capabilities. Thus, computational tasks can be performed spontaneously by other resources in the Grid that are not under the user’s control. However, one of the key problems in the Grid is deciding which jobs are to be allocated to which resources at what time. In this context, the use of market mechanisms for scheduling and allocating Grid resources is a promising approach toward solving these problems. This paper proposes an auction mechanism for allocating and scheduling computer resources such as processors or storage space which have multiple quality attributes. The mechanism is evaluated according to its economic and computational performance as well as its practical applicability by means of a simulation.     

多机排序问题pm｜fix_j，pmtn｜C_（max）的多项式时间算法

在经典排序论中，一般都作以下两条假设：其一是每台机器在任一时刻至多加工一个零件，其二是每个零件在任一时刻至多被一台机器加工．在这篇文章中，研究多台机器可同时加工一个零件的多机排序问题，且每个零件可在固定的一个机器的子集上加工．本文在机器总数确定，零件加工可间断的条件下，设计出求这类问题最优解的计算方法，并研究了这种问题的计算复杂性．     

Metaheuristics for scheduling jobs with incompatible families on parallel batching machines

In this paper, we discuss the scheduling of jobs with incompatible families on parallel batching machines. The performance measure is total weighted tardiness. This research is motivated by a scheduling problem found in the diffusion and oxidation areas of semiconductor wafer fabrication where the machines can be modelled as parallel batch processors. Given that this scheduling problem is NP-hard, we suggest an ant colony optimization (ACO) and a variable neighbourhood search (VNS) approach. Both metaheuristics are hybridized with a decomposition heuristic and a local search scheme. We compare the performance of the two algorithms with that of a genetic algorithm (GA) based on extensive computational experiments. The VNS approach outperforms the ACO and GA approach with respect to time and solution quality.     

A polynomial feasibility test for preemptive periodic scheduling of unrelated processors

We consider the problem of preemptive scheduling a set of periodically occurring jobs on a set of unrelated processors, that is, processors having different speeds for different jobs. We assume that each occurrence of a job has to be completely processed before the next occurrence of the same job. We provide a system of linear inequalities for testing the existence of a feasible schedule which can be solved in polynomial time. We then use the solution to this linear system, if any, for constructing a feasible schedule in a straightforward way.     

Scheduling tasks and communications on a virtual distributed system

A set of tasks has to be scheduled on identical parallel processors subject to precedence constraints and small communication delays. A polynomial algorithm is known to exist if task duplication is allowed and the number of available processors is not limited. However the problem of communications scheduling is not taken into account. In this paper, we prove that this algorithm also never saturates communication channels and always delivers messages on time, if slightly stronger constraints are imposed on the tasks.     

Computational complexity of some scheduling problems with multiprocessor tasks

The paper is concerned with scheduling problems with multiprocessor tasks and presents conditions under which such problems can be solved in polynomial time. The application of these conditions is illustrated by two quite general scheduling problems. These results are complemented by a proof of NP-hardness of the problem with a UET task system, two parallel processors, the criterion of total completion time, and precedence constraints in the form of out-trees.     

Scheduling groups of tasks with precedence constraints on three dedicated processors

We study the problem of scheduling groups of tasks with precedence constraints on three dedicated processors. Each task requires a specified set of processors. Up to three precedence constraints are considered among groups of tasks requiring the same set of processors. The objective of the problem is to find a nonpreemptive schedule which minimizes the maximum completion time (makespan). This scheduling problem is equivalent to the problem of finding an extension of the constraint graph (i.e. the graph which represents the conflicts between tasks and the precedence constraints) to a comparability graph with minimum (over all the extensions) maximum clique weight. The problem is NP-hard in the strong sense. A normal schedule is such that all the tasks requiring the same set of processors are scheduled consecutively. With a normal schedule the problem reduces to the quotient graph of the constraint graph. In this paper we obtain tight approximation results for the minimum makespan of a normal schedule through tight results on the minimum increase of the maximum clique weight when the (partially oriented) quotient graph is extended to a comparability graph.     

Idle regulation in non-clairvoyant scheduling of parallel jobs

The optimization of parallel applications is difficult to achieve by classical optimization techniques because of their diversity and the variety of actual parallel and distributed platforms and/or environments. Adaptive algorithmic schemes, capable of dynamically changing the allocation of jobs during the execution to optimize global system behavior, are the best alternatives for solving this problem. In this paper, we focus on non-clairvoyant scheduling of parallel jobs with known resource requirements but unknown running times, with emphasis on the regulation of idle periods in the context of general list policies. We consider a new family of scheduling strategies based on two phases which successively combine sequential and parallel execution of jobs. We generalize known worst-case performance bounds by considering two extra parameters, in addition to the number of processors and maximum processor requirements considered in the literature, namely, job parallelization penalty and idle regulation factor. Furthermore, we prove that under certain conditions of idle regulation, the performance guarantee of parallel job scheduling in space-sharing mode can be improved.     

Scheduling Malleable Tasks on Parallel Processors to Minimize the Makespan

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 ² 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.     

The resource-constrained modulo scheduling problem: an experimental study

In this paper, we focus on the resource-constrained modulo scheduling problem (RCMSP), a general periodic scheduling problem, abstracted from the problem solved by compilers when optimizing inner loops at instruction level for VLIW parallel processors. Heuristic solving scheme have been proposed since many years to solve this problem, among which the decomposed software pipeling method. In this method, a cyclic scheduling problem ignoring resource constraints is first considered and a so-called legal retiming of the operations is issued. Second, a standard acyclic problem, taking this retiming as input, is solved through list scheduling techniques. In this paper, we propose a novel hybrid approach, which uses the decomposed software pipeling method to obtain a good retiming. Then the obtained retiming is used to build an integer linear programming formulation of reduced size, which allows to solve it exactly. Experimental results show that a lot more problems are solved with this new approach. The gap to the optimal solution is less than 1 % on most of the tested problem instances and the method appears to be competitive with a recently proposed constraint programming algorithm (Bonfietti et al., Lect. Notes Comput. Sci. 6876:130–144, 2011).     

A multiple-tree search procedure for the resource-constrained project scheduling problem

For over three decades, researchers have sought effective solution procedures for PERT/CPM types of scheduling problems under conditions of limited resource availability. This paper presents a procedure for this problem which takes advantage of the emerging technology provided by multiple parallel processors to find and verify an optimal schedule for a project under conditions of multiple resource constraints. In our approach, multiple solutions trees are searched simultaneously in the quest for a minimum duration schedule. Global upper and lower bound information in common memory is shared among processors, enabling one or several processors to prune potentially significant portions of its search tree based upon bounds discovered by a processor using a different search tree. Computational experience is reported both for problems in which resources are available in constant amounts per period, as well as the much more difficult problem in which the resources available are allowed to vary over the schedule horizon (e.g., travel, sick leave, assignment to other tasks or projects, and so forth). The modular multiple-tree search procedure described in this paper is quite general, permitting most types of existing serial search strategies to be adapted to this approach where multiple processors are available.     

Multiprocessor scheduling under precedence constraints: Polyhedral results

We consider the problem of scheduling a set of tasks related by precedence constraints to a set of processors, so as to minimize their makespan. Each task has to be assigned to a unique processor and no preemption is allowed. A new integer programming formulation of the problem is given and strong valid inequalities are derived. A subset of the inequalities in this formulation has a strong combinatorial structure, which we use to define the polytope of partitions into linear orders. The facial structure of this polytope is investigated and facet defining inequalities are presented which may be helpful to tighten the integer programming formulation of other variants of multiprocessor scheduling problems. Numerical results on real-life problems are presented.     

Graph models for scheduling systems with machine saturation property

Let be a set of n independent tasks and a set of m processors. During each time instant, each processor can be used by a single task at most. A schedule is for each task an allocation of one or more time intervals to one or more processors. A schedule is said to be optimal if it minimizes the maximum completion time. We say a schedule S has the machine saturation property (MS property) if, at any time instant of task execution, all the machines are simultaneously busy. In this paper, we analyze the conditions under which a parallel scheduling system allows a schedule with the MS property. While for some simple models the analytical conditions can be easily stated, a graph model approach is required when conflicts of processor usage are present. For this reason, we define the class of saturated graphs that correspond to scheduling systems with the MS property. We present efficient graph recognition algorithms to verify the MS property directly on some classes of saturated graphs     

Scheduling real-time tasks for dependability

Real-time systems are increasingly used in applications whose failure may result in large economic and human costs. Since many such systems operate in environments that are non-deterministic, and possibly hazardous, it is extremely important that the systems be dependable, namely the deadlines of tasks must be met even in the presence of particular failures. In order to enhance the dependability of a real-time system, we study the problem of scheduling a set of real-time tasks to meet their deadlines in the presence of processor failures. We first prove that the problem of scheduling a set of non-preemptive tasks on more than two processors to tolerate one arbitrary processor failure is NP-complete even when the tasks share a common deadline. Heuristic algorithms are then proposed to solve this problem. The schedules generated by the heuristic algorithms can tolerate one arbitrary processor failure in the worst case. The analysis and experimental data show that the performance of the algorithms is near-optimal.     

Scheduling tasks on two processors with deadlines and additional resources

The deterministic scheduling model studied in this paper involves a finite set of identical processors, a finite set of additional resources and a finite set of tasks to be executed, each requiring one processor and specified amounts of additional resources during a known amount of time. Each task is to be completed before its deadline. We establish the complexity status of the two major open nonpreemptive scheduling problems of this type. That is, we prove NP-hardness of two scheduling problems with two processors and unit processing times of all the tasks; the first one has one resource type available in a specified amount, the second one has an arbitrary number of resourcers, each available in amount of one unit. These results are complementary to a previous paper by the first author, where a polynomial-time algorithm was presented for an arbitrary number of processors, one resource type and zero-one resource requirements of the tasks. In addition, in the present paper new restricted versions of One-in-three 3 Sat are also proved to be NP-hard. These heavily restricted versions promise to be useful in other NP-hardness proofs.     

Solving the resource constrained deadline scheduling problem via reduction to the network flow problem

In this paper the problem of the equivalence of scheduling tasks on processors with the presence of deadlines and additional resources and the network flow problem is studied. This equivalence permits it to be proven that the problem of finding a maximal flow in a binary network with multipliers equal to 1 or 2 is NP-complete.     

WDM网络中的排序与波长分配问题的一个多项式时间近似方案

本文考虑基于波分复用技术 (WDM)的光学网络中的排序与波长分配问题 .在波长数目固定的情况下 ,我们证明此问题是NP 困难问题 ,并且给出一个多项式时间近似方案 .若波长数目不固定 ,我们证明此问题不存在多项式时间近似方案