Int. J. Innovative Computing and Applications, Vol. 2, No. 3, 2010

143

A GRASP for a resource-constrained scheduling problem Renaud Sirdey1* CEA LIST, Embedded Real Time Systems Lab, Point Courrier 94, 91191 Gif-sur-Yvette Cedex, France E-mail: [email protected] *Corresponding author

Jacques Carlier and Dritan Nace UMR CNRS Heudiasyc, Université de Technologie de Compiègne, Centre de Recherches de Royallieu, BP 20529, 60205 Compiègne Cedex, France E-mail: [email protected] E-mail: [email protected] Abstract: This paper is devoted to the approximate resolution of a strongly NP-hard real world resource-constrained scheduling problem, which arises in relation to the operability of certain high availability real time distributed systems. We present a fast and pragmatic algorithm based on the GRASP metaheuristic and, building on previous research on exact resolution methods, extensive computational results demonstrating its practical ability to find solutions within a few percents to optimality on a wide spectrum of hard instances. Keywords: combinatorial optimisation; scheduling; GRASP; distributed systems; OR in telecommunications. Reference to this paper should be made as follows: Sirdey, R., Carlier, J. and Nace, D. (2010) ‘A GRASP for a resource-constrained scheduling problem’, Int. J. Innovative Computing and Applications, Vol. 2, No. 3, pp.143–149. Biographical notes: Renaud Sirdey is a Researcher at Commissariat à l’Energie Atomique, the French atomic energy research agency. His main research interests include parallelism, compilation, graph theory and combinatorial optimisation. Prior to that, he held various R&D positions in the telecommunications industry. He received a diplôme d’ingénieur and a PhD in CS from Universitè de Technologie de Compiègne (UTC) as well as an MSc in Applied Maths from Cranfield University (UK). He teaches software engineering at Ecole Nationale Supérieure de Techniques Avancées (Paris) as well as operations research at UTC. Jacques Carlier is Professor of CS as well as the Head of Doctoral Studies in CS at the Université de Technologie de Compiègne. His main research interests include scheduling, combinatorial optimisation, graph theory and bin-packing. He received his PhD in CS as well as a Doctorat d’Etat both from Paris VI University and is an alumnus of Ecole Normale Supérieure de Cachan. Dritan Nace is Professor of CS at the Université de Technologie de Compiégne. His main research interests include networks optimisation, robustness, linear programming and combinatorial optimisation. He received his PhD in CS as well as his Habilitation à Diriger les Recherches both from the Université de Technologie de Compiègne.

1

Introduction

In this paper, we present a GRASP for the process move programming (PMP) problem. This problem arises in relation to the operability of certain high-availability distributed switching systems. For example, Sirdey et al. (2003), consider a telecom switch managing radio cells on a set of call processing modules, hereafter referred to as processors, of finite capacity in terms of erlangs, CPU,

Copyright © 2010 Inderscience Enterprises Ltd.

memory, ports, etc.; each radio cell being managed by a dedicated process running on some processor. During network operation, some cells may be dynamically added, modified (transreceivers may be added or removed) or removed, potentially leading to unsatisfactory resource utilisation in the system. This issue is addressed by first obtaining a better system configuration and by subsequently reconfiguring the system, without violation of the capacity constraints on the processors.

144

R. Sirdey et al.

Figure 1 provides an example of an instance of the PMP problem for a system with ten processors, one resource and 46 processes. The capacity of each of the processors is equal to 30 and the sum of the consumptions of the processes is 281. The top and bottom figures respectively represent the initial and the final system states. For example, process number 23 must be moved from processor 2 to processor 6. Figure 1

Example of an instance of the PMP problem

complexity slightly higher that an SA-based algorithm but an ability to provide reasonably (still not provably) good solutions at significantly lower computational costs. This makes GRASP a paradigm of choice for designing an optimisation algorithm for a real world problem with real world operational and software engineering constraints. This paper is organised as follows. First, Section 2 provides a formal statement of the problem and Section 3 succinctly discusses previous work on the PMP problem. Then, Section 4 provides background on GRASP and Section 5 presents our algorithm. Lastly, in Section 6, we provide extensive computational results which demonstrate the practical relevance of the approach.

2

As discussed in Section 3, the PMP problem has already been tackled with both combinatorial (branch-and-bound) and polyhedral (branch-and-cut) exact resolution methods as well as computationally intensive heuristic approaches such as simulated annealing. Still, for real-time constraints related to the industrial context of the present work, there is a need for fast, pragmatic approximate resolution algorithms with reasonable implementation complexity. Our motivation for using the GRASP paradigm to design such an algorithm is based on software engineering considerations. Indeed, the GRASP paradigm allows to achieve an interesting trade-off between the following criteria: implementation complexity (which should be understood as a measure of how difficult it is to write and, more importantly, to subsequently maintain the resulting software2), calculation time and performance (in terms of quality of the provided solutions). Usually, the operations research literature focuses on the two latter criteria and largely omits the first one which in many real world situations is at least as important [see Sirdey (2006) for a more thorough discussion]. A polyhedral exact resolution method, e.g., requires fairly advanced mathematical skills to be understood (a prerequisite for maintaining the software) as well as high computation times to provide optimum or provably high-quality solutions. A simulated annealingbased algorithm, still e.g., usually achieves a very different trade-off: understanding and programming it is simple however it still requires fairly important computation times to provide reasonably (and certainly not provably) good solutions. The GRASP approach to combinatorial optimisation problems attempts (in the authors’ opinion) to achieve yet another trade-off with an implementation

Formal problem statement

Let us consider a distributed system composed of a set U of processors, each processor offering an amount C u ∈ ` of a given resource. We are also given a set P of applications, hereafter referred to as processes, which consume the resources offered by the processors. The set P is sometimes referred to as the payload of the system. For each process p ∈ P , w p ∈ ` denotes the amount of resource which is consumed by process p. Note that neither C u nor w p vary with time. An admissible state for the system is defined as a mapping f : P → U ∪ {u ∞ }, where u∞ is a dummy processor having infinite capacity, such that for all u ∈U we have:

∑

w p ≤C u ,

(1)

p∈P (u ; f )

where P (u ; f ) = {p ∈ P : f (p ) = u}. The processes in P ( f ) = P (u∞ ; f ) are not instantiated and, when this set is non-empty, the system is in degraded mode. An instance of the PMP problem is then specified by two arbitrary system states fi and ft respectively referred to as the initial system state and the final system state or, for short, the initial state and the final state.3 A process may be moved from one processor to another in two different ways: either it is migrated, in which case it consumes resources on both processors for the duration of the migration and this operation has virtually no impact on service, or it is interrupted, that is removed from the first processor and later restarted on the other one. Of course, this latter operation has an impact on service. Additionally, it is required that the capacity constraints (1) are always satisfied during the reconfiguration and that a process is moved (i.e., migrated or interrupted) at most once. This latest constraint is motivated by the fact that a process migration is far from being a lightweight operation [for reasons related to distributed data consistency which are out of the scope of this paper, see e.g., Jalote (1994)] and, as a consequence, it is desirable to avoid processes hopping around processors. Throughout this paper, when it is said that a move is interrupted, it is meant that the process associated to the

145

A GRASP for a resource-constrained scheduling problem

move is interrupted. This slightly abusive terminology significantly lightens our discourse. For each processor u , a process p in P (u ; fi ) \ P (u ; ft ) must be moved from u to ft (p ). Let M denote the set of process moves thus induced by the initial and final states. Then for each m ∈ M , wm , sm and tm respectively denote the amount of resource consumed by the process moved by m , the processor from which the process is moved that is the source of the move and the processor to which the process is moved that is the target of the move. Lastly, S (u ) = {m ∈ M : sm = u} and T (u ) = {m ∈ M : tm = u}. A pair (I,σ), where I ⊆ M and σ : M \ I → {1,...,| M \ I |} is a bijection, defines an admissible process move programme, if provided that the moves in I are interrupted (for operational reasons, the interruptions are performed at the beginning) the other moves can be performed according to σ without inducing any violation of the capacity constraints (1). Formally, (I , σ ) is an admissible programme if for all m ∈ M \ I we have: wm ≤ Ktm +

∑w

m′

+

m ′∈I sm ′ =tm

∑

m ′∈S (tm )\ I σ (m ′)