Showing papers on "Scheduling (computing) published in 1986"
TL;DR: A heuristic algorithm is described for a time-constrained version of the advance-request, multi-vehicle, many-to-many Dial-A-Ride Problem (DARP).
Abstract: In this paper we describe a heuristic algorithm, Advanced Dial-A-Ride with Time Windows (ADARTW), for the advance-request version of the multi-vehicle, many-to-many Dial-A-Ride Problem (DARP) with service quality constraints. DARP is concerned with developing a set of routes for a fleet of vehicles carrying customers between specified origins and destinations. “Many-to-many” means that each customer can have a distinct origin and destination, while “advance-request” means that all the requests are received well before the time of vehicle dispatching. Finally, “service quality constraints” guarantee that (1) customers’ ride times will not exceed a prespecified maximum and (2) the time of pick-up or delivery of customers will not deviate from the most-desired pick-up or delivery time of these customers by more than pre-specified amounts (“the time windows”). The algorithmic approach to be described is interesting for two reasons. First, it addresses what is probably the most applicable and realistic version of the real-world problem in a way that avoids excessive abstraction and simplification and emphasizes flexibility and convenience to the algorithm’s user. Second, it can generate at low computation cost what are apparently high-quality solutions to much larger problems (e.g. 2500 customers and 30 simultaneously active vehicles) than have hitherto been attempted. Many North American systems serving elderly and handicapped passengers require reservations a day in advance, while in other cases return trips may be scheduled as immediate requests. This second scenario can also be handled with an extension of the algorithm presented in this paper. The DARP was first examined by Wilson et al. (1971, 1976, 1977) in connection with the development of real-time algorithms for the Dial-A-Ride systems of Haddonfield, NJ, and Rochester, NY. ADARTW derives some of its fundamental concepts (building tours through sequential insertion of customers, general form of the objective function) from that work. A paper by Roy et al. (1983) which appeared as this paper was being completed also uses similar concepts and solves essentially the same version of DARP. Hung et al. (1982) have been tackling the same problem but have adopted an entirely different approach involving processing (scheduling and routing) one vehicle at a time rather than all vehicles simultaneously, as is done by ADARTW. Psaraftis (1983a) has developed a dynamic programming algorithm for solving the single-vehicle DARP optimally for a small number of customers in the presence of time windows, and Solomon (1983) has recently published an excellent review of the vehicle routing problem (not DARP) with time-window constraints. Descriptions of several versions of DARP without time-window constraints can be found
528 citations
TL;DR: This work describes the relationship between the general employee scheduling problem and related problems, and reports computational results for a procedure that solves these more complex problems within 98–99% optimality and runs on a microcomputer.
298 citations
TL;DR: The problem considered in this paper is the deterministic scheduling of tasks on a set of identical processors, but the model presented differs from the classical one by the requirement that certain tasks need more than one processor at a time for their processing.
Abstract: The problem considered in this paper is the deterministic scheduling of tasks on a set of identical processors. However, the model presented differs from the classical one by the requirement that certain tasks need more than one processor at a time for their processing. This assumption is especially justified in some microprocessor applications and its impact on the complexity of minimizing schedule length is studied. First we concentrate on the problem of nonpreemptive scheduling. In this case, polynomial-time algorithms exist only for unit processing times. We present two such algorithms of complexity O(n) for scheduling tasks requiring an arbitrary number of processors between 1 and k at a time where k is a fixed integer. The case for which k is not fixed is shown to be NP-complete. Next, the problem of preemptive scheduling of tasks of arbitrary length is studied. First an algorithm for scheduling tasks requiring one or k processors is presented. Its complexity depends linearly on the number of tasks. Then, the possibility of a linear programming formulation for the general case is analyzed.
275 citations
TL;DR: A discrete-time, continuous-flow model is proposed and developed for studying the operation of a job shop that sees a stationary input mix of job types and it is shown how to use the model not only to evaluate a choice of the controls but also to find a good specification that results in acceptable shop behavior.
Abstract: We propose and develop a discrete-time, continuous-flow model for studying the operation of a job shop that sees a stationary input mix of job types. We are not concerned with issues of detailed scheduling, but rather hope to develop a tactical planning tool for a job-shop operation. With the model, we are able to characterize the operational behavior of each work center in the job shop for a given control policy. The control rule sets the production rate at a work center as a fixed proportion of its queue level in each time period, and is consistent with the assignment of a planned lead time to each work center. For these control rules, the model gives the steady-state distribution of the production levels at each work center, as well as the distribution of queue lengths. We show how to use the model not only to evaluate a choice of the controls but also to find a good specification that results in acceptable shop behavior. An example for a factory that produces grinding machines illustrates the use of the model.
239 citations
01 May 1986
TL;DR: An architectural concept called guarded instructions to reduce the penalty of conditional branches in deeply pipelined processors is proposed and a code generation heuristic, the decision tree scheduling technique, reorders instructions in a complex of basic blocks so as to make efficient use of guarded instructions.
Abstract: High speed scalar processing is an essential characteristic of high performance general purpose computer systems. Highly concurrent execution of scalar code is difficult due to data dependencies and conditional branches. This paper proposes an architectural concept called guarded instructions to reduce the penalty of conditional branches in deeply pipelined processors. A code generation heuristic, the decision tree scheduling technique, reorders instructions in a complex of basic blocks so as to make efficient use of guarded instructions. Performance evaluation of several benchmarks are presented, including a module from the UNIX kernel. Even with these difficult scalar code examples, a speedup of two is achievable by using conventional pipelined uniprocessors augmented by guard instructions, and a speedup of three or more can be achieved using processors with parallel instruction pipelines.
224 citations
Proceedings Article•
01 Jan 1986TL;DR: A processor self-scheduling scheme for a single-nested parallel loop is presented, and the scheme is extended to multiple-nesting parallel loops by using efficient synchronization primitives.
Abstract: Processor self-scheduling is a useful scheme in a multiprocessor system if the execution time of each iteration in a parallel loop is not known in advance and varies substantially, or if there are multiple nestings in parallel loops which makes static scheduling difficult and inefficient. By using efficient synchronization primitives, the operating system is not needed for loop scheduling. The overhead for the processor self-scheduling is small. We presented a processor self-scheduling scheme for a single-nested parallel loop, and extend the scheme to multiple-nested parallel loops. Barrier synchronization mechanisms in the processors self-scheduling schemes are also discussed. 12 references, 2 figs.
213 citations
01 Jul 1986
TL;DR: By using a dag representation which prevents scheduling deadlocks and a selection method that requires no lookahead, the resulting algorithm reorganizes instructions almost as effectively in practice, while having an O(n2) worst-case runtime.
Abstract: As part of an effort to develop an optimizing compiler for a pipelined architecture, a code reorganization algorithm has been developed that significantly reduces the number of runtime pipeline interlocks. In a pass after code generation, the algorithm uses a dag representation to heuristically schedule the instructions in each basic block.Previous algorithms for reducing pipeline interlocks have had worst-case runtimes of at least O (n4). By using a dag representation which prevents scheduling deadlocks and a selection method that requires no lookahead, the resulting algorithm reorganizes instructions almost as effectively in practice, while having an O (n2) worst-case runtime.
192 citations
Book•
02 Jan 1986
TL;DR: Several operating system services are examined with a view toward their applicability to support of database management functions.
Abstract: Several operating system services are examined with a view toward their applicability to support of database management functions. These services include buffer pool management; the file system; scheduling, process management, and interprocess communication; and consistency control.
172 citations
TL;DR: Six heuristic scheduling rules are compared on 80 test problems that include large-scale engineering construction projects as well as 50 resource constrained problems from the literature.
Abstract: The problem addressed in this paper is the scheduling of activities in a project to maximize net present value given cash inflows, outflows, and resource restrictions. Although optimization procedures exist for small problems of this type, they generally cannot solve large-scale problems and may not be widely available. Six heuristic scheduling rules are compared on 80 test problems. The test problems include large-scale engineering construction projects as well as 50 resource constrained problems from the literature.
154 citations
01 Jul 1986
TL;DR: In this paper, the authors present compile-time partitioning and scheduling techniques to achieve a trade-off between parallelism and communication and synchronization overhead for parallel languages on multiprocessors.
Abstract: Partitioning and scheduling techniques are necessary to implement parallel languages on multiprocessors. Multiprocessor performance is maximized when parallelism between tasks is optimally traded off with communication and synchronization overhead. We present compile-time partitioning and scheduling techniques to achieve this trade-off.
148 citations
TL;DR: This paper considers the problem of scheduling jobs on a single machine when the desirability of a schedule is evaluated using more than one performance measure, and develops procedures to construct trade-off curves among selected performance measures.
Abstract: Most scheduling research has considered optimizing a single performance measure criterion. In this paper we consider the problem of scheduling jobs on a single machine when the desirability of a schedule is evaluated using more than one performance measure. The procedures developed here can be used to construct trade-off curves among selected performance measures. The importance of the trade-off curve is that it provides the complete set of possibly optimal solutions for any objective function cost function involving only the selected performance measures. With this information, a manager can concentrate on selecting the most preferred schedule from the set.
Algorithms are presented for the three two-criteria problems utilizing mean flow time, maximum tardiness, and number of tardy jobs and the three-criteria problem involving all of these criteria. Computational results for the four algorithms are provided. The most striking result is that the number of efficient solutions is very small in comparison to the number of permutation schedules for all three two-criteria problems and only modestly larger for the three-criteria problem. This has the managerial significance that, irrespective of the individual manager's specific trade-offs between the criteria, the number of possibly optimal schedules that need to be considered is relatively small.
Several research directions on heuristic approaches, man-machine interactive approaches, computational efficiency, etc. are possible for the type of problem studied. The work reported here has the potential to stimulate research incorporating multiple performance measures in more complex scheduling models.
TL;DR: The hot-set model, characterizing the buffer requirements of relational queries, is presented and it can be used by the query optimizer to derive efficient execution plans accounting for the available buffer space, and by a query scheduler to prevent thrashing.
Abstract: The hot-set model, characterizing the buffer requirements of relational queries, is presented. This model allows the system to determine the optimal buffer space to be allocated to a query; it can also be used by the query optimizer to derive efficient execution plans accounting for the available buffer space, and by a query scheduler to prevent thrashing. The hot-set model is compared with the working-set model. A simulation study is presented.
TL;DR: The methodology outlined here serves two purposes: one, it provides a way of choosing the appropriate architecture for a class architecture for an class of applications and, two, it gives a method of determining how good this choice was by actually doing the mapping of the algorithm on the architecture and performing a simulation of the execution.
Abstract: Steps to optimize the performance of a multicomputer system (MCS) are discussed Three aspects are emphasized: (1) the interconnection scheme that ties all the processors together, (2) the scheduling and mapping of the algorithm on the architecture, and (3) the mechanism for detecting parallelism and partitioning the algorithm into modules which achieve computational speedup when run on an MCS Mapping and scheduling issues are addressed, and an application example is given
01 May 1986
TL;DR: This paper addresses several problems of hard real-time bus scheduling, including the evaluation of scheduling algorithms and the issues of message packet pacing, preemption, priority granularity and buffering.
Abstract: When periodic tasks with hard deadlines communicate over a bus, the problem of hard real-time bus scheduling arises This paper addresses several problems of hard real-time bus scheduling, including the evaluation of scheduling algorithms and the issues of message packet pacing, preemption, priority granularity and buffering
TL;DR: The Linear Scheduling Method (LSM) as mentioned in this paper is a method for scheduling roadways, pipelines, and high-rise buildings, where repetitive activities are plotted as lines of constant or varying slopes on two axes, distance versus time.
Abstract: Many projects, such as the construction of roadways, pipelines, and high‐rise buildings, involve repetitive activities. A method for scheduling such work, the Linear Scheduling Method (LSM) is presented. In an LSM schedule, the repetitive activities are plotted as lines of constant or varying slopes on two axes, distance versus time. Discrete activities may be shown at their appropriate times and locations and then referenced to a network schedule for additional detail. The Linear Scheduling Method is illustrated by applying it to an actual roadway construction project. The simplicity of the system and advantages for certain types of projects are revealed. A sample schedule is used to derive information that is comparable to what may be obtained from an equivalent CPM network.
TL;DR: An exact algorithm is described which exploits the structure of the single-vehicle routing and scheduling problem with time windows, partial loads, and dwell times, and a route improvement heuristic is constructed based on the master problem.
Abstract: SYNOPTIC ABSTRACTWe apply Benders' decomposition procedure to the single-vehicle routing and scheduling problem with time windows, partial loads, and dwell times. We provide a formulation and demonstrate that the scheduling subproblem is the dual of a network flow problem. We describe an exact algorithm which exploits its structure, and construct a route improvement heuristic based on the master problem. A heuristic for building an initial route is also presented.
TL;DR: In this paper, the scheduling of n jobs around a common due date, so as to minimize the average total earliness plus total lateness of the jobs, is studied. And the model is extended to allow for the availability of multiple parallel processors and an efficient algorithm is developed for that problem.
Abstract: This article concerns the scheduling of n jobs around a common due date, so as to minimize the average total earliness plus total lateness of the jobs. Optimality conditions for the problem are developed, based on its equivalence to an easy scheduling problem. It seems that this problem inherently has a huge number of optimal solutions and an algorithm is developed to find many of them. The model is extended to allow for the availability of multiple parallel processors and an efficient algorithm is developed for that problem. In this more general case also, the algorithm permits great flexibility in finding an optimal schedule.
01 Mar 1986
TL;DR: In this paper, round robin link scheduling, in conjunction with conventional window flow control, is used to achieve throughput fairness in point-to-point packet networks with virtual circuit routing, where each user session is assigned a fixed path (often called a virtual circuit) through the network, and data for the session are sent in packets along this path.
Abstract: : Round robin link scheduling, in conjunction with conventional window flow control, can be used to achieve throughput fairness in point-to-point packet networks with virtual circuit routing. Consider a data communication network consisting of store-and-forward nodes joined by point-to-point links. Each user session is assigned a fixed path (often called a virtual circuit) through the network, and data for the session are sent in packets along this path. In such a network it is possible for the incoming traffic rate at a node to exceed the outgoing rate, causing a data queue to build up a at that node. This queue may eventually overflow the node's storage space, or the delay of acknowledgements may cause transmitters to assume that data were lost. These problems result in wasteful retransmission that effectively reduce the capacity of the network. Flow control procedures attempt to prevent or alleviate this degradation by regulating the appropriate traffic sources.
TL;DR: It is shown that a feasible schedule can be obtained by determining the maximum flow in a network, thus permitting the use of standard network flow codes and a bound is developed which compares even more favorably to the best previous bound.
Abstract: We consider the problem of scheduling n jobs, each with a specific processing requirement, release time and due date on m uniform parallel machines. It is shown that a feasible schedule can be obtained by determining the maximum flow in a network, thus permitting the use of standard network flow codes. Using a specialized maximum flow procedure, the complexity reduces to Otn3 operations when t is the number of distinct machine types. Previous algorithms solve the feasibility problem in Om + log nm2n3 + n4 operations. In addition to the feasibility problem, we describe algorithms for the maximum lateness criterion. Here we develop a bound which compares even more favorably to the best previous bound. We also show how other criteria with respect to the amount of work completed on each job prior to its due date or the amount of work scheduled in each of a sequence of periods can be optimized by similar path augmenting techniques.
TL;DR: This paper presents an extension of an earlier model developed by the authors, formulating the generalized N job, M machine standard flow-shop problem as a mixed-integer goal-programming model, which allows the incorporation of the makespan as well as the mean flow-time criteria, instead of optimization being based on a single objective.
Abstract: Until recently, the majority of models used to find an optimal sequence for the standard flow-shop problem were based on a single objective, typically makespan. In many applications, the practitioner may also want to consider other criteria simultaneously, such as mean flow-time or throughput time. As makespan and flow-time are equivalent criteria for optimizing machine idle-time and job idle-time, respectively, these additional criteria could be inherently considered as well. The effect of job idle-time, measuring in-process inventory, could be of particular importance.
TL;DR: In this paper, the authors define a new class of scheduling problems, for which due dates are specified in terms of the position in which a job appears in an ordered sequence, rather than by that job's identity.
Abstract: We define a new class of scheduling problems, for which due dates are specified in terms of the position in which a job appears in an ordered sequence, rather than by that job's identity. This problem class appears rich both in applications and in theoretical issues. For many traditional scheduling problems there exists an equivalent problem within the new class. We examine the algorithmic complexity of several of these problems, and attempt to provide an efficient solution technique, or alternatively to demonstrate that such a technique is highly unlikely to exist. In two cases, the complexity of the problem being discussed remains open.
TL;DR: It is shown that the optimal task-assignment policy for a random-graph model of a distributed program exhibits an extremal characteristic in the special case when there is a uniform degradation of processing speed.
Abstract: An investigation is made of an optimal task-assignment policy for a random-graph model of a distributed program. The model of the distributed computer system assumes that communications overhead adds to total run time and that total run time decreases as the number of processors running the program is increased. When the processors are homogeneous, the optimal task-assignments are external in the sense that tasks are totally distributed among all processors as evenly as possible or not distributed at all. The point at which the policy shows a sharp change of behavior depends upon the ratio of run times to communication times. The authors derive two important properties of the optimal task-assignments for heterogeneous processors. The first property is that an optimal policy distributes the cost of processing among the processors as evenly as possible so that a processor with higher speed gets more tasks and vice versa. The second property determines the number of processors among which to distribute the tasks evenly. In the special case when there is a uniform degradation of processing speed, it is shown that the optimal policy again exhibits an extremal characteristic.
01 Jan 1986
TL;DR: This dissertation discusses several software and hardware aspects of program execution on large-scale, high-performance parallel processor systems, with a single goal: maximizing program speedup, or equivalently, minimizing parallel execution time.
Abstract: This dissertation discusses several software and hardware aspects of program execution on large-scale, high-performance parallel processor systems. The issues covered are program restructuring, partitioning, scheduling and interprocessor communication, classification and utilization of program parallelism, and synchronization and hardware design issues of specialized units. All this work was performed focusing on a single goal: maximizing program speedup, or equivalently, minimizing parallel execution time. Parafrase, a Fortran restructuring compiler was used to transform programs in a parallel form and conduct experiments. Two new restructuring techniques are presented, loop coalescing and subscript blocking. Compile-time and run-time scheduling schemes are covered extensively. Depending on the program construct, these algorithms generate optimal or near-optimal schedules. Techniques for program partitioning and minimization of interprocessor communication for idealized program models and for real Fortran programs are also discussed. The close relationship between scheduling, interprocessor communication, and synchronization becomes apparent at several points in this work. Finally, the impact of various types of overhead on program speedup and experimental results are presented.
01 Apr 1986
TL;DR: A software implementation in PROLOG of a constraint-based analysis module is presented which may be used either in a static way in order to generate a plan over a certain horizon or in a dynamic way inorder to help in making real time decisions.
Abstract: This paper deals with operation scheduling on machines in a job shop. The jobs which consist of a set of related operations are supposed to be constrained by limit times (earliest starting times and due dates). The approach aims at generating restrictions on local scheduling decisions by only considering limit times and resource availability constraints (constraint based analysis). This is achieved through an inference process which is defined from generic knowledge arising in scheduling problems : limit times associated with each operation, logical sequencing conditions between operations, inference rules relating to limit times and sequencing conditions. A software implementation in PROLOG of a constraint-based analysis module is presented. Such a module may be used either in a static way in order to generate a plan over a certain horizon or in a dynamic way in order to help in making real time decisions. In this last case it can be held to act the part of a flexible planning function.
01 Apr 1986
TL;DR: Air traffic control simulations have established that the automated air-traffic-management concept provides an efficient method for controlling various mixes of 4D-equipped and unequipped aircraft, as well as low- and high-performance aircraft.
Abstract: An automated air-traffic-management concept that has the potential for significantly increasing the efficiency of traffic flows in high-density terminal areas is discussed. The concept's implementation depends on the techniques for controlling the landing time of all aircraft entering the terminal area, both those that are equipped with on-board four dimensional guidance systems as well as those aircraft types that are conventionally equipped. The two major ground-based elements of the system are a scheduler which assigns conflict-free landing times and a profile descent advisor. Landing times provided by the scheduler are uplinked to equipped aircraft and translated into the appropriate four dimensional trajectory by the on-board flight-management system. The controller issues descent advisories to unequipped aircraft to help them achieve the assigned landing times. Air traffic control simulations have established that the concept provides an efficient method for controlling various mixes of four dimensional-equipped and unequipped, as well as low-and high-performance, aircraft.
TL;DR: It is illustrated that it is possible to design a learning controller that is able to dynamically acquire relevant job scheduling information by a process of trial and error, and use that information to provide good performance.
Patent•
24 Feb 1986
TL;DR: In this paper, an interactive remote controlled scheduling system for enabling a caller at one end of a telephone line, or other channel, to automatically schedule an appointment with an electronic scheduling machine at a receiving end in the absence of human intervention at the receiving end.
Abstract: An interactive remote controlled scheduling system for enabling a caller at one end of a telephone line, or other channel, to automatically schedule an appointment with an electronic scheduling machine at a receiving end in the absence of human intervention at the receiving end. Upon the caller dialing and reaching the electronic scheduler, a sequential series of interactive audible instruction messages are received to initially instruct the caller to dial back the day desired for appointment, and in reply to receive back from the electronic scheduler, a subschedule of the times available for appointment on this day as an audible announcement. The caller is then instructed to dial back a desired time-of-day from those announced as available, and this dialed time is received and automatically entered into the electronic scheduler to complete the appointment. Additionally, the caller can be instructed to dial other numbers, and in reply, to receive back any audible messages that have been stored for the caller at the receiving end. In an alternative system, the caller merely obtains a schedule or subschedule of available times upon dialing the number of the electronic scheduler and subsequently dialing the day of interest.
TL;DR: This paper contains a brief discussion of why loading of multiple flexible manufacturing cells is important, and a discussion of the number of variables and constraints necessary to solve the program for a real world sized system.
TL;DR: In this article, the authors consider a set of trips where each trip is specified a priori by a place of origin, a destination, a duration, a cost and a time interval within which the trip must begin.
TL;DR: Partitioning and scheduling techniques are necessary to implement parallel languages on multiprocessors as discussed by the authors, and performance is maximized when parallelism between tasks is optimally traded off.
Abstract: Partitioning and scheduling techniques are necessary to implement parallel languages on multiprocessors. Multiprocessor performance is maximized when parallelism between tasks is optimally traded o...