Iterative task division method or multiprocessor scheduling problem

Optimal schedules for d-D grid graphs with communication delays

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

This paper presents a static scheduler which selects, from a set of scheduling algorithms, a subset of those which carry out the best assignment of a DAG representing an application program. To make that selection, some characteristics of the DAG, a decision model, and the evaluation parameters for choosing the best solution provided by the selected scheduling algorithms are defined. The selection of the scheduling algorithms is based on five decision levels. At each level, a subset of scheduling algorithms is selected. The final decision is made by carrying out an intersection operation between the subsets. When the scheduler was tested with a series of DAGs having different characteristics, the scheduler's decision was right 95% of the time in those cases in which the number of available processors is known, and 75% of the time when the number of processors is unbounded.

Compact DAG representation and its symbolic scheduling

For better utilization of computing resources, it is important to consider parallel programming environments in which the number of available processors varies at runtime. In this paper, we discuss runtime support for data parallel programming in such an adaptive environment. Executing data parallel-programs in an adaptive environment requires redistributing data when the number of processors changes, and also requires determining new loop bounds and communication patterns for the new set of processors. We have developed a runtime library to provide this support. We also present performance results for a multiblock Navier-Stokes solver run on a network of workstations using PVM for message passing. Our experiments show that if the number of processors is not varied frequently, the cost of data redistribution is not significant compared to the time required for the actual computations. >

We present an O((log log N)/sup 2/) -time algorithm for computing the distance transform of an N /spl times/ N binary image. Our algorithm is designed for the common concurrent read concurrent write parallel random access machine (CRCW PRAM) and requires O(N/sup 2+/spl epsi///log log N) processors, for any /spl epsi/ such that 0 < /spl epsi/ < 1. Our algorithm is based on a novel deterministic sampling scheme and can be used for computing distance transforms for a very general class of distance functions. We also present a scalable version of our algorithm when the number of processors is available p/sup 2+/spl epsi///log log p for some p < N. In this case, our algorithm runs in O((N/sup 2//p/sup 2/)+(N/p) log log p + (log log p)/sup 2/) time. This scalable algorithm is more practical since usually the number of available processors is much less than the size of the image.

The multiprocessor scheduling problem(MPSP), P|prec,p j =1|C max , is known to be NP-complete. The problem is polynomially solvable, however, if the precedence relations are of the intree(outtree) type, P|intree(outtree),p j =1|C max , or if the number of processors is two, P2|prec,p j =1|C max . In this paper, we introduce a parametric linear program which gives a lower bound for the makespan of MPSP and retrieves the makespans of the two polynomially solvable problems.

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

We address the parallelization of the determination of all optimal solutions (DAOS) for the 1D array partitioning problem, an easy combinatorial optimization problem that may be solved by dynamic programming. It turns out that the designed DAOS algorithm is a polyhedral algorithm (PA), i.e. a FOR-loop nest with affine loop bounds, whose iteration space that has to be scanned may be of exponential cardinality in the array size hence too time consuming. Thus, after a cardinality reducing procedure leading to an improved PA (IPA), we propose to parallelize the IPA through a specific approach. This latter first consists in a dependence analysis within the IPA leading to detect that all its loops are parallel. We then apply a loop interchange on the IPA in order to have a new IPA whose first loop has the largest number of parallel iterations. Another alternative consists in moving to the first position the loop whose number of iterations is the closest to the number of available processors. We detail an analysis of the theoretical performances of the derived parallel IPA by proposing several versions fitting the number of available processors and reducing the overhead due to processor synchronizations.

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.

In a heterogeneous system, processor and network failure are inevitable and can have adverse effect on the complex applications executing on the systems. To reduce the rate of these failures, matching and scheduling algorithms should take into account the objectives of minimizing schedule length (makespan) and reducing the probability of failure. Equitable distribution of workload over resources contributes in reducing the probability of failure. The Heterogeneous Earliest Finish Time (HEFT) algorithm has been proved as a performance effective task scheduling algorithm, addressing the objective of minimizing makespan. Reliable Dynamic Level Scheduling (RDLS) algorithm is a bi-objective scheduling algorithm that maximizes the reliability more effectively. Though the reliable version of HEFT algorithm (RHEFT) considers failure rate in scheduling decision, the improvement in reliability is less, compared to that of RDLS. To overcome this deficiency, we propose to incorporate the task–processor pair finding step of RDLS in HEFT algorithm, since it meets both the objectives of minimizing the makespan and maximizing the reliability. We define the load on a processor as the amount of time the processor is engaged in completing the scheduled subtasks. In this paper, a modification to the HEFT is proposed as a new algorithm called Improved Reliable HEFT (IRHEFT) for minimizing the schedule length, balancing the load and maximizing the reliability of schedule. The algorithm is compared for its performance with RDLS algorithm for randomly generated task graphs and a real application task graph.

Researches for more reliable arrangement graphs in multiprocessor computer system

Recent advances in the power of parallel computers have made them attractive for solving large computational problems. Scalable parallel programs are particularly well suited to Massively Parallel Processing (MPP) machines since the number of computations can be increased to match the available number of processors. Performance tuning can be particularly difficult for these applications since it must often be performed with a smaller problem size than that targeted for eventual execution. This research develops a performance prediction methodology that addresses this problem through symbolic analysis of program source code. Algebraic manipulations can then be performed on the resulting analytical model to determine performance for scaled up applications on different hardware architectures. >

Some radar image processing algorithms such as shape-from-shading are particularly compute-intensive and time consuming. If, in addition, a data set to be processed is large, then it may make sense to perform the processing of images on multiple workstations or parallel processing systems. We have implemented shape-from-shading, stereo matching, resampling, gridding and visualization of terrain models in such a manner that they execute either on parallel machines or on clusters of workstations. We were motivated by the large image data set from NASA's Magellan mission to planet Venus, but received additional inspiration from the European Union's Center for Earth Observation program (CEO) and Austria's MISSION initiative for distributed processing of remote sensing images on remote workstations, using publicly accessible algorithms. We have developed a multi-processor approach that we denote as CDIP for Concurrent and Distributed Image Processing. The speedup for image processing tasks increases nearly linearly with the number of processors, be they on a parallel machine or arranged in a cluster of distributed workstations. Our approach adds benefits for users of complex image processing algorithms: the efforts for code porting and code maintenance are reduced and the necessity for specialized parallel processing hardware is eliminated.

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.