Showing papers on "Scheduling (computing) published in 1987"

Algorithms for the vehicle routing and scheduling problems with time window constraints

Abstract: This paper considers the design and analysis of algorithms for vehicle routing and scheduling problems with time window constraints. Given the intrinsic difficulty of this problem class, approximation methods seem to offer the most promise for practical size problems. After describing a variety of heuristics, we conduct an extensive computational study of their performance. The problem set includes routing and scheduling environments that differ in terms of the type of data used to generate the problems, the percentage of customers with time windows, their tightness and positioning, and the scheduling horizon. We found that several heuristics performed well in different problem environments; in particular an insertion-type heuristic consistently gave very good results.

Static Scheduling of Synchronous Data Flow Programs for Digital Signal Processing

Abstract: Large grain data flow (LGDF) programming is natural and convenient for describing digital signal processing (DSP) systems, but its runtime overhead is costly in real time or cost-sensitive applications. In some situations, designers are not willing to squander computing resources for the sake of programmer convenience. This is particularly true when the target machine is a programmable DSP chip. However, the runtime overhead inherent in most LGDF implementations is not required for most signal processing systems because such systems are mostly synchronous (in the DSP sense). Synchronous data flow (SDF) differs from traditional data flow in that the amount of data produced and consumed by a data flow node is specified a priori for each input and output. This is equivalent to specifying the relative sample rates in signal processing system. This means that the scheduling of SDF nodes need not be done at runtime, but can be done at compile time (statically), so the runtime overhead evaporates. The sample rates can all be different, which is not true of most current data-driven digital signal processing programming methodologies. Synchronous data flow is closely related to computation graphs, a special case of Petri nets. This self-contained paper develops the theory necessary to statically schedule SDF programs on single or multiple processors. A class of static (compile time) scheduling algorithms is proven valid, and specific algorithms are given for scheduling SDF systems onto single or multiple processors.

Guided Self-Scheduling: A Practical Scheduling Scheme for Parallel Supercomputers

Abstract: This paper proposes guided self-scheduling, a new approach for scheduling arbitrarily nested parallel program loops on shared memory multiprocessor systems. Utilizing loop parallelism is clearly most crucial in achieving high system and program performance. Because of its simplicity, guided self-scheduling is particularly suited for implementation on real parallel machines. This method achieves simultaneously the two most important objectives: load balancing and very low synchronization overhead. For certain types of loops we show analytically that guided self-scheduling uses minimal overhead and achieves optimal schedules. Two other interesting properties of this method are its insensitivity to the initial processor configuration (in time) and its parameterized nature which allows us to tune it for different systems. Finally we discuss experimental results that clearly show the advantage of guided self-scheduling over the most widely known dynamic methods.

Scheduling Tasks with Resource Requirements in Hard Real-Time Systems

Abstract: This paper describes a heuristic approach for solving the problem of dynamically scheduling tasks in a real-time system where tasks have deadlines and general resource requirements. The crux of our approach lies in the heuristic function used to select the task to be scheduled next. The heuristic function is composed of three weighted factors. These factors explicitly consider information about real-time constraints of tasks and their utilization of resources. Simulation studies show that the weights for the various factors in the heuristic function have to be fine-tuned in order to obtain a degree of success in the range of 75-88 percent of that obtained via exhaustive search. However, modifying the approach to use limited backtracking improves the degree of success substantially to as high as 99.5 percent. This improvement is observed even when the initial set of weights are not tailored for a particular set of tasks. Simulation studies also show that in most cases the schedule determined by the heuristic algorithm is optimal or close to optimal.

Force-Directed Scheduling in Automatic Data Path Synthesis

Abstract: The HAL system performs data path synthesis using a new scheduling algorithm that is part of an interdependent scheduling and allocation scheme. This scheme uses an estimate of the hardware allocation to guide and optimize the scheduling subtask. The allocation information includes the number, type, speed and cost of hardware modules as well as the associated multiplexer and interconnect costs. The iterative force-directed scheduling algorithm attempts to balance the distribution of operations that make use of the same hardware resources: * Every feasible control step assignment is evaluated at each iteration, for all operations. * The associated side-effects on all the predecessor and successor operations are taken into account. * All the decisions are global. * The algorithm has O(n/sup2/) complexity. We review and compare existing scheduling techniques. Moderate and difficult examples are used to illustrate the effectiveness of the approach.

Parallelism in production systems

Abstract: Production system programs, on the surface, appear to be capable of using large amounts of parallelism--it is possible to match each production in a program to the data memory in parallel. The thesis shows that in practice, however, the speed-up obtainable from parallelism is quite limited, around 15-fold as compared to initial expectations of 100-fold to 1000-fold. The main reasons for the limited speed-up from parallelism are: (1) there are only a small number of productions that require significant processing as a result of a change to working memory; and (2) there is a large variation in the processing requirement of these productions. To obtain a large fraction of the limited speed-up that is available, the thesis proposes a parallel version of the Rete match algorithm which exploits parallelism at a very fine grain. It further suggests that a suitable architecture to exploit the fine-grained parallelism is a shared-memory multiprocessor, with 32-64 high performance processors. For scheduling the fine grained tasks (consisting of about 50-100 instructions), a hardware task scheduler is proposed. The thesis presents a large set of simulation results for production systems exploiting different sources of parallelism. The thesis points out the features of existing programs that limit the speed-up obtainable from parallelism and suggests solutions for some of the bottlenecks. The simulation results show that using the suggested multiprocessor architecture (with individual processors performing at 2 MIPS), it is possible to obtain execution speeds of 5000-27000 working memory element changes per second. This corresponds to a speed-up of 5-fold over the best known sequential implementation using a 2 MIPS processor. This performance is also higher than that obtained by other proposed parallel implementations of production systems.

Job scheduling method and system

Abstract: A job scheduling method for scheduling of job allocation to various resources, wherein each workload of a job is allocated to each time unit along a time axis in units of job and resource type. Based on the workload allocated in units of resource type, an initial workload for all resources at each time unit is calculated. A first workload balancing is performed for an initial workload at a time unit exceeding a resource capacity so as to balance the initial workload within the resource capacity. Thereafter, a second workload balancing is performed so as to balance a workload allocated in units of resource type within its resource capacity.

Scheduling real-time, periodic jobs using imprecise results

Abstract: A process is called a monotone process if the accuracy of its intermediate results is non-decreasing as more time is spent to obtain the result. The result produced by a monotone process upon its normal termination is the desired result; the error in this result is zero. External events such as timeouts or crashes may cause the process to terminate prematurely. If the intermediate result produced by the process upon its premature termination is saved and made available, the application may still find the result unusable and, hence, acceptable; such a result is said to be an imprecise one. The error in an imprecise result is nonzero. The problem of scheduling periodic jobs to meet deadlines on a system that provides the necessary programming language primitives and run-time support for processes to return imprecise results is discussed. This problem differs from the traditional scheduling problems since the scheduler may choose to terminate a task before it is completed, causing it to produce an acceptable but imprecise result. Consequently, the amounts of processor time assigned to tasks in a valid schedule can be less than the amounts of time required to complete the tasks. A meaningful formulation of this problem taking into account the quality of the overall result is discussed. Three algorithms for scheduling jobs for which the effects of errors in results produced in different periods are not cumulative are described, and their relative merits are evaluated.

The Fixed Job Schedule Problem with Working-Time Constraints

Abstract: We consider a generalization of the fixed job schedule problem where a bound is imposed on the total working time of each processor. It is shown that the problem is NP-hard but polynomially solvable in the preemptive case. We introduce several lower bounds. One is determined through definition of a special class of graphs, for which the maximum clique problem is shown to be polynomial. Lower bounds and dominance criteria are exploited in a branch-and-bound algorithm for optimal solution of the problem. The effectiveness of the algorithm is analyzed through computational experiments.

Scheduling to a common due date on parallel uniform processors

Abstract: We consider scheduling a set of jobs on parallel processors, when all jobs have a common due date and earliness and lateness are penalized at different cost rates. For identical processors, the secondary criteria of minimizing makespan and machine occupancy are addressed. The extension to different, uniform processors is also solved.

Preemptive Scheduling Under Time and Resource Constraints

Abstract: We consider the problem of scheduling a set of n preemptable tasks in a system having r resources. Each task has an arbitrary, but known, worst case processing time and a deadline, and may request simultaneous use of a number of resources. A resource can be used either in shared mode or exclusive mode. In this paper, we develop and evaluate algorithms for determining whether or not a set of preemptive tasks is schedulable in such a real-time system, and if so, determining a schedule for it. This scheduling problem is known to be computationally intensive. In many real-time application environments, tasks are scheduled dynamically, and hence the scheduling algorithms used must have low run-time costs. To keep run-time costs low, we propose the use of suboptimal but practical algorithms that employ computationally simple heuristics. The computational complexity of our algorithms for scheduling n tasks in a system having r resources is O(rn2), which is very much lower than that of known optimal algorithms. We report on the results of simulation studies performed on such heuristic preemptive scheduling algorithms and the sensitivity of the performance of the algorithms with respect to various scheduling parameters. These studies show that due to the complexity of the problem, straightforward heuristics do not perform satisfactorily. However, an algorithm that uses combinations of such heuristics in conjunction with limited backtracks works very well.

Task scheduler for a fault tolerant multiple node processing system

Abstract: A task scheduler for a fault tolerant multiple node processing system having a task activity list storing a set of application tasks, a priority scan list storing a selected portion of the set of application tasks, a completion status list also storing the same selected portion of the set of application tasks. A wake-up sequencer transfers the application tasks from the task activity list to the priority scan list, and a priority scanner transfers the application tasks ready for execution from the priority scan list to a selection queue. A next task selector selects the next application task that its node will execute, and a task started register stores the identity of the application tasks completed by the other nodes. A task interactive consistency (TIC) handler updates the status of the application tasks stored in the task activity list, the priority scan list, and the completion status list in response to messages received from the other nodes identifying which nodes completed tasks. The task interactive consistency handler checks the scheduling process of each node by comparing the application tasks it reported to have started with the highest priority application task scheduled for that node in its selection queue.

Single machine scheduling research

Abstract: This paper reviews static scheduling research on single machine for the last three decades One hundred seventy one papers were found on this topic after an extensive search in the English language periodicals These papers are classified on the basis of the objective functions and constraints Contribution of each paper is analyzed in terms of its theoretical and computational results An analysis of the literature on the basis of number of articles published in each year, in each category, in different journals and by different authors has also been provided This reveals several interesting facts about the developments in single machine scheduling (SMS) research and its future

Tighter bounds for LPT scheduling on uniform processors

Abstract: We examine the nonpreemptive assignment of independent tasks to a system of uniform processors with the objective of minimizing the makespan The worst case bound for the largest processing time first algorithm for this problem is tightened to be in the interval (152, 167)

The ZS-1 central processor

Abstract: The Astronautics ZS-1 is a high speed, 64-bit computer system designed for scientific and engineering applications. The ZS-1 central processor uses a decoupled architecture, which splits instructions into two streams---one for fixed point/memory address computation and the other for floating point operations. The two instruction streams are then processed in parallel. Pipelining is also used extensively throughout the ZS-1.This paper describes the architecture and implementation of the ZS-1 central processor, beginning with some of the basic design objectives. Descriptions of the instruction set, pipeline structure, and virtual memory implementation demonstrate the methods used to satisfy the objectives. High performance is achieved through a combination of static (compile-time) instruction scheduling and dynamic (run-time) scheduling. Both types of scheduling are illustrated with examples.

Selected Topics in Scheduling Theory

Abstract: Publisher Summary This chapter discusses the deterministic problems of scheduling tasks on machines (processors), which is one of the most rapidly expanding areas of combinatorial optimization. These problems are stated as follows: A given set of tasks is to be processed on a set of available processors, so that all processing conditions are satisfied and a certain objective function is minimized (or maximized). It is assumed, in contrast to stochastic scheduling problems, that all task parameters are known a priori in a deterministic way. This assumption is well justified in many practical situations. On the other hand, it permits the solving of scheduling problems having a different practical interpretation from that of the stochastic approach. This interpretation is a valuable complement to the stochastic analysis and is often imposed by certain applications as—for example, in computer control systems working in a hard-real-time environment and in many industrial applications. The chapter focuses on the applications of this model in computer systems. It also points out some other interpretations, because tasks and machines may also represent ships and dockyards, classes and teachers, patients and hospital equipment, or dinners and cooks.

Modelling of Computer and Communication Systems

Abstract: Preface 1. Introduction to probability theory 2. Stochastic processes 3. Simple queueing methods 4. General service times and different scheduling strategies 5. Queueing networks 6. Packet-switching networks Bibliography Index.

Comparing the Performance of Two Dynamic Load Distribution Methods

Abstract: Parallel processing of symbolic computations on a message-passing multi-processor presents one challenge: To effectively utilize the available processors, the load must be distributed uniformly to all the processors. However, the structure of these computations cannot be predicted in advance. go, static scheduling methods are not applicable. In this paper, we compare the performance of two dynamic, distributed load balancing methods with extensive simulation studies. The two schemes are: the Contracting Within a Neighborhood (CWN) scheme proposed by us, and the Gradient Model proposed by Lin and Keller. We conclude that although simpler, the CWN is significantly more effective at distributing the work than the Gradient model.

Performance analysis of parallel processing systems

Abstract: A centralized parallel processing system with job splitting is considered. In such a system, jobs wait in a central queue, which is accessible by all the processors, and are split into independent tasks that can be executed on separate processors. This parallel processing system is modeled as a bulk arrival MX/M/c queueing system where customers and bulks correspond to tasks and jobs, respectively. Such a system has been studied in [1, 3] and an expression for the mean response time of a random customer is obtained. However, since we are interested in the time that a job spends in the system, including synchronization delay, we must evaluate the bulk response time rather than simply the customer response time. The job response time is the sum of the job waiting time and the job service time. By analyzing the bulk queueing system we obtain an expression for the mean job waiting time. The mean job service time is given by a set of recurrence equations.To compare this system with other parallel processing systems, the following four models are considered: Distributed/Splitting (D/S), Distributed/No Splitting (D/NS), Centralized/Splitting (C/S), and Centralized/No Splitting (C/NS). In each of these systems there are c processors, jobs are assumed to consist of set of tasks that are independent and have exponentially distributed service requirements, and arrivals of jobs are assumed to come from a Poisson point source. The systems differ in the way jobs queue for the processors and in the way jobs are scheduled on the processors. The queueing of jobs for processors is distributed if each processor has its own queue, and is centralized if there is a common queue for all the processors. The scheduling of jobs on the processors is no splitting if the entire set of tasks composing that job are scheduled to run sequentially on the same processor once the job is scheduled. On the other hand, the scheduling is splitting if the tasks of a job are scheduled so that they can be run independently and potentially in parallel on different processors. In the splitting case a job is completed only when all of its tasks have finished execution.In our study we compare the mean response time of jobs in each of the systems for differing values of the number of processors, number of tasks per job, server utilization, and certain overheads associated with splitting up a job. The MX/M/c system studied in the first part of the paper corresponds to the C/S system. In this system, as processors become free they serve the first task in the queue. D/. systems are studied in [2]. We use the approximate analysis of the D/S system and the exact analysis of the D/NS system that are given in that paper. For systems with 32 processors or less, the relative error in the approximation for the D/S system was found to be less than 5 percent. In the D/NS system, jobs are assigned to processors with equal probabilities. The approximation we use for the mean job response time for the C/NS system is found in [4]. Although an extensive error analysis for this system over all parameter ranges has not been carried out, the largest relative error for the M/E2/10 system reported in [4] is about 0.1 percent.For all values of utilization, r, our results show that the splitting systems yield lower mean job response time than the no splitting systems. This follows from the fact that, in the splitting case, work is distributed over all the processors. For any r, the lowest (highest) mean job response time is achieved by the C/S system (the D/NS system). The relative performance of the D/S system and the C/NS system depends on the value of r. For small r, the parallelism achieved by splitting jobs into parallel tasks in the D/S system reduces its mean job response time as compared to the C/NS system, where tasks of the same job are executed sequentially. However, for high r, the C/NS system has lower mean job response time than the D/S system. This is due to the long synchronization delay incurred in the D/S system at high utilizations.The effect of parallelism on the performance of parallel processing systems is studied by comparing the performance of the C/NS system to that of the C/S system. The performance improvement obtained by splitting jobs into tasks is found to decrease with increasing utilization. For a fixed number of processors and fixed r, we find that by increasing the number of tasks per job, i.e. higher parallelism, the mean job response time of the C/NS system relative to that of the C/S system increases. By considering an overhead delay associated with splitting jobs into independent tasks, we observe that the mean job response time is a convex function of the number of tasks, and thus, for a given arrival rate, there exists a unique optimum number of tasks per job.We also consider problems associated with partitioning the processors into two sets, each dedicated to one of two classes of jobs: edit jobs and batch jobs. Edit jobs are assumed to consist of simple operations that have no inherent parallelism and thus consist of only one task. Batch jobs, on the other hand, are assumed to be inherently parallel and can be broken up into tasks. All tasks from either class are assumed to have the same service requirements. A number of interesting phenomena are observed. For example, when half the jobs are edit jobs, the mean job response time for both classes of jobs increases if one processor is allocated to edit jobs. Improvement to edit jobs, at a cost of increasing the mean job response time of batch jobs, results only when the number of processors allocated to edit jobs is increased to two. This, and other results, suggest that it is desirable for parallel processing systems to have a controllable boundary for processor partitioning.

A Modular Approach to Optimal Multiple-Shift Manpower Scheduling

Abstract: This paper introduces a practical approach to multiple-shift manpower scheduling by presenting an algorithm that applies the approach to a large and common class of problems. The algorithm constructs schedules that utilize no more than the minimum number of workers necessary for a schedule satisfying constraints that include two offdays each week, a specified number of offweekends in any fixed number of consecutive weekends, a maximum of six consecutive work shifts and different staffing demands for each type of shift. We discuss the application of the approach to several other classes of manpower scheduling problems.

Perspectives on parallel computing

Abstract: Most scheduling research has treated individual job processing times as fixed parameters. In many practical situations, however, a manager may exert processing time control through the allocation of a limited resource. We consider the problem of joint sequencing and resource allocation when the scheduling criterion of interest is the number of tardy jobs. Theoretical results are derived that aid in developing the tradeoff curve between the number of tardy jobs and the total amount of allocated resource.