Understanding Performance Tradeoffs in Algorithms for Solving Oversubscribed Scheduling

In recent years, planning and scheduling research has paid increasing attention to problems that involve resource oversubscription, where cumulative demand for resources outstrips their availability and some subset of goals or tasks must be excluded. Two basic classes of techniques to solve oversubscribed scheduling problems have emerged: searching directly in the space of possible schedules and searching in an alternative space of task permutations (by relying on a schedule builder to provide a mapping to schedule space). In some problem contexts, permutation-based search methods have been shown to outperform schedule-space search methods, while in others the opposite has been shown to be the case. We consider two techniques for which this behavior has been observed: TaskSwap (TS), a schedule-space repair search procedure, and Squeaky Wheel Optimization (SWO), a permutation-space scheduling procedure. We analyze the circumstances under which one can be expected to dominate the other. Starting from a real-world scheduling problem where SWO has been shown to outperform TS, we construct a series of problem instances that increasingly incorporate characteristics of a second real-world scheduling problem, where TS has been found to outperform SWO. Experimental results provide insights into when schedule-space methods and permutation-based methods may be most appropriate. Introduction and Motivation As research in automated planning and scheduling has moved into problem domains that more accurately model real-world concerns, one issue that has garnered increasing interest has been that of oversubscription (Kramer & Smith 2004; Barbulescu et al. 2006; Smith 2004; Nigenda & Kambhampati 2005). Generally speaking, an oversubscribed problem is one in which the resources available (e.g., time, capacity) are not sufficient to permit accomplishment of all stated tasks or goals, and hence the problem solver must decide which subset of tasks or goals to carry out. The basic objective is to maximize the number of tasks accommodated or goals satisfied, subject in some cases to associated task or goal priorities. Oversubscribed problems arise in a broad range of application domains, including rover task planning (Smith 2004; Joslin et al. 2005), satellite and telescope scheduling (Bresina 1996; Copyright c © 2007, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved. Frank et al. 2001; Barbulescu et al. 2006) and military airlift allocation (Kramer & Smith 2004). With respect to solving oversubscribed scheduling problems, two basic classes of solution techniques have emerged: those that search directly in the space of possible schedules, and those that search in an alternative space of task permutations (in which case a schedule builder is used to provide a mapping to schedule space). Both permutation-space and schedule-space methods have been shown to perform effectively in specific problem domains. This raises the question of whether there are problem characteristics that might suggest the appropriateness of one over the other. In this paper, we attempt to gain insight into this general question by analyzing the performance tradeoffs between two specific methods on a common set of problem instances. Our starting point is two oversubscribed scheduling problems that are quite similar in character, the USAF Satellite Control Network (AFSCN) problem previously studied in (Barbulescu et al. 2006) and the USAF Air Mobility Command (AMC) airlift scheduling problem described in (Kramer & Smith 2005a). Prior research with the AFSCN problem has shown permutation-space scheduling procedures such as Squeaky Wheel Optimization (SWO) to dominate schedule-space methods. Other prior work (Kramer & Smith 2004; 2005b) has demonstrated the effectiveness of a schedule-space method called TaskSwap (TS) in solving the AMC scheduling problem, and in fact TS can be shown to outperform SWO in this domain. Given these results, we attempt to understand what problem characteristics set these domains and solution techniques apart. We define a series of problem sets which generalize from the AFSCN problem and increasingly incorporate characteristics of the AMC problem. Our experimental results indicate that problem hardness and the presence or absence of task priorities are two distinguishing performance factors. Before describing the AFSCN and AMC domains and presenting our experimental analysis, we briefly summarize prior approaches to oversubscribed scheduling problems and the two specific methods of interest to our study. Permutation Space vs. Schedule Space Search As indicated above, we can distinguish two basic classes of approaches to solving oversubscribed scheduling problems based on the search space representation that is used. Permutation-based methods emphasize search in the space of task permutations, where a given permutation specifies a scheduling order and is transformed into an actual schedule by a “schedule builder”. Search in the permutation space has been effectively employed in many scheduling applications (Whitley, Starkweather, & Fuquay 1989; Syswerda 1991; Globus et al. 2004; Barbulescu et al. 2006). The main advantage of a permutation representation is that generalpurpose search algorithms can be employed while all the particular constraints of the domain are encapsulated in a schedule builder. The main disadvantage is that in general it is not possible to predict the effect of permutation changes until the schedule builder computes the new schedule. Also, the schedules reachable via the schedule builder might represent a suboptimal subset of all possible schedules. A second class of techniques, referred to generally as repair-based search techniques, operate directly in the space of possible schedules (Johnston & Miller 1994; Rabideau et al. 1999; Kramer & Smith 2004). Searching the schedule space directly is sometimes an attractive alternative. Powerful domain-specific heuristics are usually available (e.g., various resource contention measures), and such measures can direct the search in an efficient but effective manner. In continuous domains where schedule stability is important, search operators for the schedule space can be defined to generate new solutions in a controlled manner (and minimize changes to the current schedule). While generalpurpose search operators can still be defined, efficient search algorithms in the schedule space will typically exploit domain knowledge to decide how to reorganize the schedule. The challenge is in defining the right search operators. Squeaky Wheel Optimization The permutation-based method we consider in this paper incorporates Squeaky Wheel Optimization (SWO) (Joslin & Clements 1999) as the core search procedure. SWO has been used effectively in a number of oversubscribed domains (Globus et al. 2004; Joslin et al. 2005; Frank & Kürklü 2005; Barbulescu et al. 2006). Once an initial permutation (scheduling order) of the input tasks to be scheduled is established, SWO proceeds by repeatedly iterating through a three step cycle. In the first step, a greedy constructive technique (the schedule builder) uses the permutation to produce an actual solution (schedule). The permutation represents a prioritization of the tasks, since the earlier tasks are considered earlier by the schedule builder. In the second step, the solution is analyzed and those tasks causing “trouble” (i.e., those tasks that the schedule builder was not able to get on the schedule) are ranked according to their contribution to the objective function. Finally in the third step, the ranking of current “trouble makers” is used to modify the permutation, by moving them earlier in the scheduling order. This cycle is repeated until a termination condition is met. For the analysis performed in this paper, the schedule builder used by SWO places tasks into the schedule one by one (in the order specified by the current permutation), using a look-ahead heuristic based on predicted resource contention to assign a specific start time and resource to each task. This heuristic, max-availability, is described in some detail in (Kramer & Smith 2005b). If a given task cannot be feasibly added to the schedule at the time it is considered, it is marked as unassignable and the schedule builder simply moves on to the next task. This schedule builder is also employed to generate initial seed solutions for the other method analyzed in this paper, TaskSwap (see below).