Unit Execution Time Research Articles

Resource leveling: complexity of a unit execution time two-processor scheduling variant and related problems

Resource leveling: complexity of a unit execution time two-processor scheduling variant and related problems

Flow-shop scheduling with exact delays to minimize makespan

The flow-shop scheduling problem with exact delays is generalization of no-wait flow-shop scheduling in which an exact delay exists between the consecutive tasks of each job. The problem with distinct delays to minimize the makespan is strongly NP-hard even for the two-machine case with unit execution time tasks. Providing polynomial-time solutions for special cases of the problem, we show that the two-machine permutation flow-shop case is solvable in O(nlogn) time, while the case with more than two machines is strongly NP-hard. We also show that the multi-machine case with delays following the ordered structure possesses the pyramidal-shaped property and propose an O(n2)-time dynamic program to solve it. We further improve the time complexity of the solution algorithm to O(nlogn) under certain conditions.

A first Fit type algorithm for the coupled task scheduling problem with unit execution time and two exact delays

The considered coupled task problem (CTP) is to schedule n jobs, each consisting of two (sub)tasks, on a single machine. Exact delay times are between the subtasks of a job and the makespan has to be minimized. It has been proven that the problem is strongly NP-hard in general case (see Orman and Potts (1997)), even if the lengths of the subtasks are identical. This paper considers a special case of CTP where there are jobs with two different delay times only. The complexity status of this problem is unknown. We will present an algorithm – called First Fit Decreasing (FFD) – and we will prove that its approximation ratio is in the interval (1.57894,1.57916).

A note on labeling methods to schedule unit execution time tasks in the presence of delayed precedence constraints

There is some evidence that labeling schemes as employed for instance in the famous Coffman-Graham algorithm may provide superior worst-case approximation guarantees than purely path- or level-based list schedules in the presence of (delayed) precedence constraints. In 1989, Bernstein, Rodeh, and Gertner proved that this also holds true for their labeling scheme targeting unit execution time tasks on a single processor provided that all delays imposed by a single task on all of its successors are uniformly either zero or some fixed positive integer. They further conjectured that this superiority is preserved when allowing the delays imposed by a task to differ successor-wise. It is shown in this note however that their labeling scheme as well as more general ones may perform as bad as any list schedule in this case. Moreover, a new lower bound on the worst-case performance of labeling methods in the multiprocessor setting is derived.

A fixed-parameter algorithm for scheduling unit dependent tasks on parallel machines with time windows

This paper proves that the existence of a feasible schedule for a set of dependent tasks of unit execution times with release dates and deadlines on a limited number of processors is a fixed-parameter tractable problem. The parameter considered is the pathwidth of the interval graph associated with the time windows of the tasks. A fixed-parameter algorithm based on a dynamic programming approach is developed and proved to solve this decision problem.Fixed-parameter algorithms for the two classical problems P|prec,pi=1,ri|Cmax and P|prec,pi=1,ri|Lmax are then derived using a binary search. They are, as far as we know, the first fixed-parameter algorithms for these scheduling problems.

Optimal Makespan for the Coupled Task Ordered Flow-Shop

The ordered flow-shop scheduling problem deals with the case where processing times follow a specific structure. We extend the ordered flow-shop scheduling to the coupled tasks setting, i.e., the coupled task ordered flow-shop, in which an exact delay exists between the consecutive tasks of each job. The aim is to minimize the makespan. The coupled task flow-shop with distinct delays between the consecutive tasks of the jobs is known to be strongly NP-hard, even for two machines and the unit execution time tasks. We investigate the problem when delays follow the ordered structure and show that the optimal permutation schedule has the pyramidal-shaped property. We also introduce two polynomially solvable cases.

An algorithm with parameterized complexity of constructing the optimal schedule for the routing open shop problem with unit execution times

An algorithm with parameterized complexity of constructing the optimal schedule for the routing open shop problem with unit execution times

An <i>O</i>(<i>n</i>) Time Algorithm for Scheduling UET-UCT of Bipartite Digraphs of Depth One on Two Processors

Given n unit execution time (UET) tasks whose precedence constraints form a directed acyclic graph, the arcs are associated with unit communication time (UCT) delays. The problem is to schedule the tasks on two identical processors in order to minimize the makespan. Several polynomial algorithms in the literature are proposed for special classes of digraphs, but the complexity of solving this problem in general case is still a challenging open question. We present in this paper an O(n) time algorithm to compute an optimal schedule for the class of bipartite digraphs of depth one.

Online dynamic power management with hard real-time guarantees

We consider the problem of online dynamic power management that provides hard real-time guarantees for multi-processor systems. In this problem, a set of jobs, each associated with an arrival time, a deadline, and an execution time, arrives to the system in an online fashion. The objective is to compute a non-migrative preemptive schedule of the jobs and a sequence of power on/off operations of the processors so as to minimize the total energy consumption while ensuring that all the deadlines of the jobs are met. We assume that we can use as many processors as necessary. In this paper we examine the complexity of this problem and provide online strategies that lead to practical energy-efficient solutions for real-time multi-processor systems.First, we consider the case for which we know in advance that the set of jobs can be scheduled feasibly on a single processor. We show that, even in this case, the competitive ratio of any online algorithm is at least 2.06. On the other hand, we give a 4-competitive online algorithm that uses at most two processors. For jobs with unit execution times, the competitive ratio of this algorithm improves to 3.59.Second, we relax our assumption by considering as input multiple streams of jobs, each of which can be scheduled feasibly on a single processor. We present a trade-off between the energy-efficiency of the schedule and the number of processors to be used. More specifically, for k given job streams and h processors with h>k, we give a scheduling strategy such that the energy usage is at most 4⋅⌈kh−k⌉ times that used by any schedule which schedules each of the k streams on a separate processor. Finally, we drop the assumptions on the input set of jobs. We show that the competitive ratio of any online algorithm is at least 2.28, even for the case of unit job execution times for which we further derive an O(1)-competitive algorithm.

Algorithms for scheduling with integer preemptions on parallel machines to minimize the maximum lateness

The paper is concerned with the problem of scheduling on parallel identical machines partially ordered tasks that can be preempted at integer points in time. The objective function is the maximum lateness. The well-known algorithms for scheduling unit execution time tasks and for scheduling with arbitrary preemptions are not directly applicable to the considered problem. The paper presents a new method for scheduling with integer preemptions and the worst-case analysis for several polynomial-time algorithms which have this method as a core scheduling routine.

Scheduling UECT trees with Communication Delays on Two Processors with Unavailabilities

In this paper a new polynomial scheduling algorithm is presented. It is used for scheduling Unit Execution and Communication Time (UECT) intrees on two identical processors where one of these is subject to periods of unavailabilities. The optimality criterion is the makespan.

Anytime QoS-aware service composition over the GraphPlan

Automatic service composition is the generation of a business process to fulfill business goals that cannot be fulfilled by individual services. Planning algorithms are frequently used to solve this problem. In addition to satisfying functional goals, recent research is geared toward selecting the best services to optimize the QoS of the result business process. Without considering QoS, the planning algorithm normally searches for the shortest plan, which actually implies the unit execution time for each service. With QoS, a longer plan may have better QoS values and thus is preferred over a shorter one. In this paper, we are motivated to combine a systematic search algorithm like Dijkstra's algorithm with a planning algorithm, GraphPlan, to achieve both functional goals and QoS optimization at the same time. The planning graph generated by GraphPlan is a compact representation of all execution paths, which makes it feasible to apply Dijkstra's principle. In our new QoSGraphPlan algorithm, we extend Dijkstra's algorithm from working on a single-source graph to working on the planning graph whose nodes have multiple sources. Using our method, we can get the best QoS value for throughput and response time in polynomial time when they are the single criteria. For the other QoS criteria, such as execution time, reputation, successful execution rate, and availability, our algorithm is exponential for both single criterion problem and multiple criteria problem. In this case, we extend QoSGraphPlan with beam search to solve the combination explosion problem. As our algorithms search for an optimal solution during the process of constructing the planning graph, they belong to the category of anytime algorithms that return better solutions if they keep running for a longer time.

Scheduling Partially Ordered UET Tasks on Dedicated Machines

The paper is concerned with scheduling partially ordered unit execution time tasks on dedicated machines. The considered scheduling model is important in control of different systems, in particular computer systems. The presented algorithm is an alternative to the conventional branch-and-bound method. In contrast to the branch-and-bound method with its single search tree, corresponding to partitioning of the feasible region, the presented method involves a sequence of search trees each associated with a certain portion of the domain of the objective function. The branching is based on a generalisation of the Garey-Johnson due date modification. The performance of the presented algorithm is compared by means of computational experiments with a version of the branch-and-bound algorithm.

Scheduling an interval ordered precedence graph with communication delays and a limited number of processors

We consider the scheduling of an interval order precedence graph of unit execution time tasks with communication delays, release dates and deadlines. Tasks must be executed by a set of processors partitioned into K classes; each task requires one processor from a fixed class. The aim of this paper is to study the extension of the Leung–Palem–Pnueli (in short LPP) algorithm to this problem. The main result is to prove that the LPP algorithm can be extended to dedicated processors and monotone communication delays. It is also proved that the problem is NP–complete for two dedicated processors if communication delays are non monotone. Lastly, we show that list scheduling algorithm cannot provide a solution for identical processors.

Multilayer Bus Optimization for Real-Time Embedded Systems

A major challenge in the design of multicore embedded systems is how to tackle the communications among tasks with performance requirements and precedence constraints. In this paper, we consider the problem of scheduling real-time tasks over multilayer bus systems with the objective of minimizing the communication cost. We show that the problem is NP-hard and determine the best possible approximation ratio of approximation algorithms. First, we propose a polynomial-time optimal algorithm for a restricted case where one multilayer bus, and the unit execution time and communication time are considered. The result is then extended as a pseudopolynomial-time optimal algorithm to consider multiple multilayer buses with arbitrary execution and communication times, as well as different timing constraints and objective functions. We compare the performance of the proposed algorithm with that of some popular heuristics, and provide further insights into the multilayer bus system design.

An efficient algorithm for finding ideal schedules

We study the problem of scheduling unit execution time jobs with release dates and precedence constraints on two identical processors. We say that a schedule is ideal if it minimizes both maximum and total completion time simultaneously. We give an instance of the problem where the min-max completion time is exceeded in every preemptive schedule that minimizes total completion time for that instance, even if the precedence constraints form an intree. This proves that ideal schedules do not exist in general when preemptions are allowed. On the other hand, we prove that, when preemptions are not allowed, then ideal schedules do exist for general precedence constraints, and we provide an algorithm for finding ideal schedules in O(n 3) time, where n is the number of jobs. In finding such ideal schedules we resolve a conjecture of Baptiste and Timkovsky (Math. Methods Oper. Res. 60(1):145–153, 2004) Further, our algorithm for finding min-max completion-time schedules requires only O(n 3) time, while the most efficient solution to date has required O(n 9) time.

Batch scheduling on a two-machine jobshop with machine-dependent setup times

The problem of minimum makespan on an m machine jobshop with unit execution time (UET) jobs (m ≥ 3) is known to be strongly NP-hard even with no setup times. We focus in this article on the two-machine case. We assume UET jobs and consider batching with batch availability and machine-dependent setup times. We introduce an efficient \documentclass{article}\usepackage{mathrsfs}\usepackage{amsmath}\pagestyle{empty}\begin{document} \begin{align*}(O(\sqrt{n}))\end{align*} \end{document} algorithm, where n is the number of jobs. We then introduce a heuristic for the multimachine case and demonstrate its efficiency for two interesting instances. © 2011 Wiley Periodicals, Inc. Naval Research Logistics, 2011

Minimizing the total weighted completion time in the relocation problem

This paper studies the minimization of total weighted completion time in the relocation problem on a single machine. The relocation problem, formulated from an area redevelopment project, can be treated as a resource-constrained scheduling problem. In this paper, we show four special cases to be NP-hard in the strong sense. Problem equivalence between the unit-weighted case and the UET (unit-execution-time) case is established. For two further restricted special cases, we present a polynomial time approximation algorithm and show its performance ratio to be 2.

Scheduling multiprocessor UET tasks of two sizes

In this paper we study task scheduling problems on m identical parallel processors, where each task has unit execution time, and needs either a single processor, or q processors concurrently, and it has a release date and a due date. Under the assumption that the release dates and due dates of the q -processor tasks are agreeable, we describe a polynomial time algorithm for minimising the number of tardy tasks. In addition, we apply this result for minimising the maximum lateness, and the maximum tardiness. We also discuss the combinatorial background of the polynomial time solvability of all these problems under the ‘agreeable’ assumption.

A graph coloring approach to scheduling of multiprocessor tasks on dedicated machines with availability constraints

We address a generalization of the classical 1- and 2-processor unit execution time scheduling problem on dedicated machines. In our chromatic model of scheduling machines have non-simultaneous availability times and tasks have arbitrary release times and due dates. Also, the versatility of our approach makes it possible to generalize all known classical criteria of optimality. Under these stipulations we show that the problem of optimal scheduling of sparse tree-like instances can be solved in polynomial time. However, if we admit dense instances then the problem becomes NP-hard, even if there are only two machines.