An Object-Oriented Approach to a Parallel Tabu Search Algorithm for the TaskSheduling Problem

Mariangela L. SilvaInstituto de Pesquisa da Marinha

Ministerio da MarinhaRua Ipiru 2, Ilha do Governador, Rio de Janeiro, Brazil

loureiro@ccard.com.br

Stella C.S. Porto�

Instituto de ComputacaoUniversidade Federal Fluminense

Rua Passo da Patria, 156, 24210-240 Niteroi, RJ, Brazilstella@ic.uff.br

Abstract

This work presents a parallel object-oriented tabu search(TS) algorithm for static task scheduling. The schedulingproblem and the TS method are separately modeled underan object-oriented approach. The TS parallelization followsa strategy based on multi-search threads and the algorithmis fully implemented using the Java language. Besides pro-viding a new scheduling algorithm, this work contributesto demonstrate: (i) the strength of object-orientation alsoin this field of applications; (ii) the adaptability of TS toasynchronous parallelization; (iii) the significance of diver-sification in TS algorithms and (iv) the potential of the Javalanguage in implementing highly portable object-orientedparallel software.

1. Introduction

A parallel program can be viewed as a collection of tasks,which execute cooperatively. The goal of scheduling is todetermine an assignment of tasks to processing elements andan order in which tasks should execute. Task scheduling (orprocessor assignment) is one of the most challenging prob-lems in parallel and distributed computing and is known tobe NP-hard [5] in its general form, as well as in severalrestricted cases. The intractability of the scheduling prob-lem has led to a large number of heuristics, each of which

�Partially supported by: Project SIAM/DCC/UFMG (grantMCT/FINEP/PRONEX 76.97.1016.00), Project FINEP – Recope/SAGEand CNPq Research Scholarship

may work under different circumstances. These heuristicsdo not guarantee an optimal solution to the problem, but in-stead they try to find near optimal solutions. Straightforwardheuristics tend to have well-defined termination rules. Morecomplex algorithms, such as tabu search (TS) and simulatedannealing metaheuristics, may not have standard termina-tion rules and generally search for improved solutions untilan arbitrary stopping point is reached. Typically, these meth-ods are problem independent. They are described as tem-plates, which are fully developed when the target problemis formally defined. Besides, metaheuristics are in generalintrinsicly dependent on parameters, whose values are deter-mined after a fine tuning process, according to the probleminstance under consideration. In this sense, these algorithmsstrongly benefit from any software engineering approachwhich promotes high modularity, software reuse and welldefined module interfaces, such as object-orientation.

Recently, there has been some effort [2, 13] in provid-ing tools in different levels of complexity, which help theprogrammer elaborate and implement metaheuristic-basedalgorithms for generic problems. Another important trendin this field has been the development of parallelizationstrategies in order to speedup execution and overcome theunreasonable computing times reached by this class of algo-rithms, specially when the problem instance is sufficientlylarge.

The task scheduling problem (with and without commu-nication costs) in a heterogeneous multiprocessor with ap-plications represented by task precedence graphs was con-sidered by Porto and Menasce in [8, 9] using fast greedyalgorithms. Porto and Ribeiro [10] then applied the tabu

search metaheuristic to the task scheduling problem usinga simple tabu list-based implementation, improving by ap-proximately 25% the makespan of the parallel applications.Recently, Porto and Ribeiro [11] have presented differentparallel implementations for this tabu search algorithm, us-ing synchronous message-passing strategies based on do-main decomposition.

This work presents an object-oriented parallel tabu searchalgorithm for static task scheduling using the Java program-ming language. Next section presents the task schedulingproblem and its respective object-oriented model. Section 3introduces the tabu search method applied to the schedul-ing problem and the asynchronous parallelization strategy,both described under an object-oriented approach. Section 4summarizes the experimental testing framework and a rep-resentative set of preliminary numerical results. Section 5finalizes the paper with conclusive remarks and future worksuggestions.

2. The Task Scheduling Problem

A scheduling system consists of a parallel application, atarget machine, a processor assignment (final schedule) anda certain performance criterion [4]. A parallel application Πwith a set of n tasks T = ft1; : : : ; tng and a heterogeneousmultiprocessor system composed by a set of m intercon-nected processors P = fp1; : : : ; pmg can be represented bya task precedence graph G(Π), an n �m matrix �, where�kj = �(tk; pj) is the execution time of task tk 2 T at pro-cessor pj 2 P , a n � n matrix D, where Dkl = D(tk; tl)is the communication demand between tasks tk and tl and aan m�m matrix R, where Rij = R(pi; pj) is the commu-nication delay between processors pi and pj .

Each processor can run one task at a time, all tasks canbe processed by any processor, and processors are said tobe uniform in the sense that �(tk;pj)

�(tk;pi)=

�(tl;pj)�(tl;pi)

8tk; t` 2

T;8pi; pj 2 P . This implies that processors may be rankedaccording to their processing speeds. In a framework witha single heterogeneous processor, the heterogeneity maybe expressed by a unique parameter called processor powerratio,PPR, which is the ratio between the processing speedof the fastest processor, and that of the remaining ones (thosein the subset of homogeneous processors). Moreover, themodel may be further simplified if we consider a uniformcommunication network, where messages sent between anypair of processors experience the same delay. In this case,communication costs may be calculated based strictly on thecommunication demand information contained in matrixD.

Given a solution s for the scheduling problem,a processorassignment function is defined as the mappingAs : T ! P .A task tk 2 T is said to be assigned to processor pj 2 P insolution s ifAs(tk) = pj . The task scheduling problem canthen be formulated as the search for an optimal assignment

of the set of tasks onto that of the processors, in termsof the makespan c(s) of the parallel application, i.e., thecompletion time of the last task being executed. At the endof the scheduling process, each processor ends up with anordered list of tasks that will run on it as soon as they becomeexecutable.

The Object-Oriented Model. The main class modelingthe task scheduling problem is named SchedulingProblemand is composed of three other classes, namely: Task-Graph, Multicomputer, and Evaluator, representing re-spectively the parallel application (task graph), the processorinterconnection network and an evaluator which calculatesthe parallel execution time according to a given schedule.The class diagram of the task scheduling problem is givenin Figure 11. Each processor is modeled as a Java-thread.Concurrent Java threads “simulate” the parallel execution ofthe given task graph, where service demands and commu-nication delays are constant values characterizing the prob-lem instance, as previously described. The deterministiccomputing of the overall execution time of this task graphrepresents the cost of a certain schedule.

Figure 1. Class Diagram of the Task Schedul-ing Problem

3. The Algorithm

This section presents the task scheduling algorithm iden-tifying the tabu search strategy, the parallelization schemeand their respective object-oriented models.

1We have used the Unified Modeling Language representation in thediagrams throughout the paper.

3.1. The Tabu Search Approach

To describe the tabu search algorithm, we first consider ageneral combinatorial optimization problem (P ) formulatedas to

minimize c(s)subject to s 2 S;

where S is a discrete set of feasible solutions. A hill-descending heuristic procedure for solving problem (P )starts from an initial solution s0 2 S and at each itera-tion, a heuristic is used to obtain a new solution s0 in theneighborhoodN(s) of the current solution s, through slightchanges in s. A move is an atomic change which transformsthe current solution, s, into one of its neighbors, say s. Everyfeasible solution s 2 N(s) is evaluated according to the costfunction c(:), which is eventually optimized. The currentsolution moves smoothly towards better neighbor solutions,enhancing the best obtained solution s�.

Tabu search [6] may be described as a higher level heuris-tic for solving minimization problems, designed to guideother hill-descending heuristics in order to escape from localoptima. In the case of the task scheduling problem, the costof a solution is given by its makespan, i.e., the overall ex-ecution time of the parallel application. The neighborhoodN(s) of the current solution s is the set of all solutions dif-fering from it by only a single assignment. If s 2 N(s), thenthere is only one task ti 2 T for which As(ti) 6= As(ti).Each move may be characterized by a simple representa-tion given by (As(ti); ti; pl), as far as the position task tiwill occupy in the task list of processor pl is uniquely de-fined. If the best move takes the current solution s to abest neighbor solution s0 degenerating its cost function, i.e.c(s0) � c(s), then the reverse move must be prohibited dur-ing a certain number of iterations (tabu tenure) in order toavoid cycling. However, an aspiration criterion is used tooverride this prohibition, enabling the move to be executed,when this becomes interesting. In addition, differently fromthe work described in [11] a diversification strategy usingfrequency-based memory structures was implemented. Thediversification stage, based on long-term frequency mem-ories, encourages the search process to examine unvisitedregions and to generate solutions that differ in various signif-icant ways from those seen before. In our case, we have alsoused an elite memory, composed of elite solutions, whichare employed during diversification in order to effectivelyencounter a high-quality diversified solution.

The Object Oriented Model. We have also modeled thetabu search metaheuristic using an object-oriented approach.The TabuSearch class is composed of three other classes,namely: TabuGuide, TabuList and LocalOptimum. Fig-ure 2 presents the class diagram of the tabu search strategy,described in what follows. Class TabuGuide has the goal

of exploring the solution space and finding the best costsolution. It maintains the information concerning best andcurrent solutions and termination rules. Termination rules(or termination conditions) determine when a search threadshould end, starting a diversification phase or finalizing thealgorithm. Termination rules are based on the number ofiterations with no improvement of the best found solution,s�. The LocalOptimum class maintains the best foundsolutions during the search. Finally, the TabuList class im-plements the short term memory, frequently called tabu list.Fixed tabu tenures were used, based on values obtained fromfine-tuning experiments performed in [10].

Figure 2. Class Diagram of the Tabu SearchMetaheuristic

3.2. Parallelization Strategy

Parallelism has been recently considered in algorithmsbased on guided iterative local search methods, such as tabusearch with a twofold purpose: (i) reduce execution times,making possible to tackle instances of greater size and (ii)increase solution quality in a parallel search performed inplausible time. Toulouse et. al [14] identify basically threestrategies often used to create parallel tabu search proce-dures: (i) functional decomposition, where some or all op-erations within an iteration of the corresponding sequen-tial solution method are executed in parallel; (ii) domaindecomposition, where the problem domain or the searchspace is decomposed [11]; and (iii) multi-search threads [1],which consists of coordinating several concurrent searches.Functional decomposition depends on the available controlparallelism during each tabu search iteration, which is intrin-sically related to the problem at hand. In the case of the taskscheduling problem, the makespan calculation is inherentlysequential, thus the functional decomposition approach isnot efficiently applicable. Domain decomposition, mainlyimplemented as neighborhood partitioning has been consid-ered in [11], where the parallel algorithm provides the exactsolutions as the sequential algorithm with an almost linearspeedup in most of the studied problem instances. Introduc-ing as a novelty the diversification aspect in the tabu search

approach for this task scheduling problem gives rise to newpossibilities of cooperation between parallel processes aim-ing a broader search of distinct solution space regions. Inthis sense, a strategy based on multi-search threads is mostappropriate, enabling processes to search independently andcommunicate asynchronously while cooperating in the con-struction of new good quality solutions.

In our multi-search approach, certain number of indepen-dent search threads operate over the same solution space,starting from different random initial solutions and employdifferent tabu search strategies, obtained as a result of thefine-tuning procedure performed in [10] for the task schedul-ing problem without communication. The parallel algorithmis composed of several local search processes and a centralprocess, which manages the memory structures and con-ducts the diversification phases of each local search process.Communication is performed solely between local searchprocesses and the central process as in an asynchronousmaster-slave model. Each local search process performs anunique tabu search thread over the whole solution space.After each search iteration, the local process sends the bestneighbor solution found to the central process, which up-dates its memory structures. Local search threads are char-acterized by their own tabu list and initial solution, whichis randomly obtained. Aspiration criteria and terminationrules are the same for all local search processes, althoughthey operate in an entirely asynchronous mode. A localtermination rule is used to determine when a local searchprocess should enter a diversification stage, while a globaltermination rule is used by the central process to determinethe end of the overall algorithm. When a local terminationcondition is met by a local search process, it will enter adiversification phase, demanding a new solution from thecentral process. A new solution is generated based on theexisting information in the memory structures within thecentral process. Algorithm finalization is also performedasynchronously. After the global termination condition ismet, the central process signals the end of the algorithmto each local search process, when each of these processestries to initiate a new diversification stage. An additionalemergency local termination rule is used to correctly final-ize local search processes in cases where there is a failurewith the central process or communication links.

The Object Oriented Model. The parallel algorithm isalso modeled according to an object-oriented approach. Twomain classes compose the algorithm, as explained earlier:CentralProcess and LocalProcess.

The Local Search Process. The LocalProcess class is in-stantiated according to the number of local search pro-cesses that work in parallel, and is composed of twoother classes, namely: LocalSearch and Communi-cationClient, as seen in Figure 3. The LocalSearch

class is built upon two other classes, SchedulingProb-lem and TabuSearch, which were described in Sec-tions 2 and 3.1. These two classes determine two ob-jects which work in parallel and thus are activated asdistinct Java threads. The class LocalSearch imple-ments the interface between classes TabuSearch andthe central process, and is also responsible for deter-mining the initial solution randomly. When an objectfrom class TabuSearch demands or sends a new so-lution, it uses an object of class LocalSearch, whichrequires service from an object of class Communi-cationClient. In summary, the main activities of anobject of class LocalProcess are: (i) initialization, (ii)sending the best neighbor solution, (iii) demanding anew solution for diversification and (iv) local processfinalization.

Figure 3. Class Diagram of the Local SearchProcess

The Central Process. The class CentralProcess is respon-sible for initiating and finalizing the parallel algorithm.It also maintains and manages the memory structureswhich acumulate information on the solutions visitedby the local search processes. The CentralProcessclass is composed of two other classes: Commu-nicationServer and SolutionServer, which managecommunications of the central process and memorystructures respectively. The class Communication-Server is responsible for the communication interfacebetween the central process and all local search pro-cesses. This class provides services such as: receiv-ing local solutions and sending new solutions to localsearch processes. The class SolutionServer maintainsa global frequency memory with information from alllocal search processes and an elite solution memorywith the so far best visited solutions by all local searchprocesses. Besides properly updating these memo-ries, the SolutionServer uses these structures in orderto build a new solution each time a demanding localsearch process has entered a diversification phase ofthe tabu search algorithm. Figure 4 presents the class

diagram of the class CentralProcess.

Figure 4. Class Diagram of the Central Pro-cess

To build a diversified new solution requested by a lo-cal search process, the central process uses the globalfrequency memory and the elite solution memory. Al-though the first requirement to be fullfilled is that thenew solution should belong to an univisited region, it isalso important that this solution demonstrate a certainquality level. In this sense, we have used a so calledquality factor to assure that the new solution is not apoor solution which would probably start a long searchmaybe towards inferior results. In order to assure thatthe new solution has not been visited so far by anyof the local processes, a hash table is maintained withhash codes of all the diversification solutions alreadysent by the central process. Before sending the diver-sification solution, this table is checked. If the hashcode of this solution is not found in the table, the so-lution is sent to the requesting local process. On thecontrary, another solution is built. If there are no othersolutions, the finalization procedure is initiated by thecentral process.

4. Implementation Issues and Experiments

The parallel tabu search algorithm was implemented us-ing the Java language due to its portability and object-oriented paradigm. Compared to other possible languages,such as C++, which is in fact a hibrid language due toits heritage from C, Java on the contrary was conceivedoriginally as a pure object-oriented language. Thus, imple-menting object-oriented models in Java is a straightfowardprocedure, without violating any of the principles of theobject-oriented programming paradigm. In addition to theobject-orientation aspect, this work was elaborated with theimplicit intention of subjectively evaluating the use of Javain the quite unusual implementation of a parallel algorithmdedicated to a high-performance computing issue.

Implementation Features. Java threads were employedin classes which implement the scheduling problem (proces-sors are Java threads), in classes which implement the tabu

search algorithm, and in classes implementing communica-tion in the central process (sending and receiving solutions toand from local processes are done concurrently). It is worthnoticing that the parallelization strategy although named asmulti-search threads strategy was in fact implemented usingfully-defined Java processes, which are separately started indifferent machines. Java threads were also used in internalimplementations of these processes. Communication wasaccomplished either by sockets or Java-RMI, not demon-strating significant performance differences. We have useda network of 5 PC’s 133MHz over a Windows NT platformfully dedicated to these experiments.

Test Configurations. Two distinct configurations of thealgorithm were tested for different problem instances: (i)div+4local – tabu search with diversification and 4 localsearch processes; (ii) nodiv+4local – tabu search withoutdiversification and 4 local search processes. In the latter con-figuration, the central process has no special role, becausediversification does not come into play. Local processesrun independently until their private tabu search algorithmreaches the end.

Problem Instances. We have used three different in-stances of the scheduling problem characterized by: (i) theparallel application and (ii) the multicomputer system. Thelatter was considered fixed with m = 5, one single hetero-geneous processor, and the processor power ratio (PPR)equal to 5. Three different task graphs with unitary serviceand communication demands were used [7], namely: Dia-mond with 218 tasks, DivConq (divide-and-conquer) with190 tasks and FFt with 194. These task graphs were em-ployed by Kitajima and Porto [7] during experiments with asynchronous parallel tabu search algorithm for the schedul-ing problem without communication between tasks.

Tabu Search Strategies. Each local process has its owntabu seach strategy, characterized by an initial solution ran-domly obtained and a constant distinct tabu list size, equal to7, 10, 15 and 20 respectively. The values of the tabu list sizewere determined based on the study presented in [10]. In theconfiguration without diversification, each local search pro-cess terminates its search independently after 200 iterationswithout improvement of the best found solution, there is noneed of any intervention of the central process. In the con-figuration with diversification, each local process demandsa new diversified solution to the central process after 30 iter-ations without improvement of the best found solution. Onemay notice, that in this case, searches are shorter than inthe case without diversification. These stopping rules werechosen considering that in the configuration with diversi-fication each local process re-initiates the search processseveral times, and finalization is signaled asynchronously

by the central process when it reaches 800 iterations with-out improvement of the best found global solution. Eachlocal search process terminates when it demands a diversi-fied solution after this termination condition is satisfied.

Numerical Results. Comparative numerical results withalready published work were not possible, because thetask scheduling problem considering task precedence con-straints, heterogeneous processors and non-null communi-cation costs was first considered in this work, except forthe greedy algorithms proposed by [9], whose presentedperformance results were restricted to unrealistic small taskgraphs compared to those studied in our work. Moreover,these greedy algorithms were in fact extensions of thosealso proposed by Menasce and Porto in [8], which werelater compared to the tabu search algorithm proposed byPorto and Ribeiro in [10]. The latter demonstrated 40% ofrelative improvement compared to the greedy approach inmost of the studied cases.

A test trial may be defined by the composition of a certainproblem instance and test configuration. For each test trial,three executions of the algorithm were performed, with threedifferent initial solutions, randomly generated. These initialsolutions were used as starting points for test trials withthe same problem instance under study for the different testconfigurations. This was the way found to establish fairnessin the comparison procedure. For each execution we havecalculated the percentual improvement (best%) in solutioncost, given by: best% =

c(si)�c(sf )c(si)

� 100, where si is theinitial solution and s is the final best solution found by thealgorithm.

Tables 1 and 2 show a set of results which demon-strate the most significant conclusions based on our prac-tical experiments, comparing the two configurations understudy: nodiv+4local and div+4local. We report the best%for three executions performed for each configuration andproblem instance (namely: DivConq, FFt and Diamond).It is interesting to notice, that for the DivConq probleminstance both configurations achieve the same best result.This occurs because this is the case of a very loose taskprecedence graph, in the sense that fewer precedence re-lations hold tasks together. Thus, although differences inthe algorithm strategy may lead to different schedules, theseschedules produce identical makespan values. The solutionspace in this case, may be seen as composed of large sets ofdistinct solutions with identical cost. This characteristic isnot present in the case of the FFt and Diamond task graphs,which have more intricate precedence relations: differentmoves during the tabu search generate different solutionswith distinct costs. It is the same as saying that in these twolatter cases, the search is performed over a more diversifiedsolution. Moreover, we also conclude that diversification iseffectively an important feature in the tabu search strategy.

All executions with the diversification have produced better(or at least equal) cost improvements from initial to finalsolutions.

Best Percentual Improvement(best%)

Problem nodiv+4localInstances 1st exec. 2nd exec. 3rd exec.DivConq 33.11 27.34 20.78

FFt 10.43 10.0 14.52Diamond 28.88 28.13 26.49

Table 1. Comparing best percentual improve-ment for distinct problems instances.

Best Percentual Improvement(best%)

Problem div 4localInstances 1st exec. 2nd exec. 3rd exec.DivConq 33.11 27.34 20.78

FFt 14.78 10.0 14.52Diamond 29.16 32.31 26.49

Table 2. Comparing best percentual improve-ment for distinct problems instances.

5. Final Remarks

This work introduced a parallel object-oriented tabusearch-based algorithm for the static task scheduling prob-lem for heterogeneous processors and parallel applicationsdescribed by task graphs with non-zero communicationcosts. The scheduling problem was modeled independentlyfrom the tabu search method, both under an object-orientedapproach. The tabu search approach has diversification as akey feature to fully search the extensive solution space. Theparallelization scheme follows a strategy based on multi-search threads, where a central process works as a long-termmemory manager, and delivers high quality new solutions tolocal processes during their diversification phases. The al-gorithm was fully implemented using the Java programminglanguage, which provides platform independence, the nec-essary object-oriented constructs and communication prim-itives. Experiments were performed over a parallel PC-based platform for distinct problem instances. Thus, thenovelty and versatility of the proposed algorithm relies on:(i) the new tabu search approach with alternating diversi-fication phases; (ii) the parallelization strategy based onmulti-search threads; (iii) the asynchronous cooperation of

parallel processes while building new good quality solu-tions independently; (iv) the object-oriented modeling of theproblem and the solution method; (v) the makespan calcula-tion based on multiple threads running concurrently, whichpromotes software reuse and possibilities of adaptation forother scheduling models and finally (vi) the utilization ofthe Java language in a very unusual field of applicationwith good performance results. Besides providing this newversatile scheduling algorithm, the work consequently con-tributes to demonstrate: (i) the adaptability of parallelizationand object-orientation to tabu search based algorithms; (ii)the easiness during implementation using the Java language;(iii) the influence of precende relations of task graphs in theachievable improvements with local search heuristics; and(iv) the significance of the tabu search diversification strat-egy in obtaining high-quality solutions. As future work,we already envision new experiments considering irregu-lar task graphs or different TS diversification strategies, amore profound analyses of cost improvements due exclu-sively to parallel cooperation during the TS execution, andthe parallelization of other metaheuristics applied to the taskscheduling problem according the a similar object-orientedmodel.

References

[1] R.M. AIEX, S.L. MARTINS, C.C. RIBEIRO and N.R.RODRIGUEZ, “Cooperative Multi-Thread Parallel TabuSearch with an Application to Circuit Partitioning”,Lecture Notes in Computer Science 1457, Proceedingsof IRREGULAR’98 - 5th International Symposium onSolving Irregularly Structured Problems in Parallel,310–331, 1998.

[2] A.A. ANDREATTA, S. E. R. CARVALHO and C.C.RIBEIRO, “An Object-Oriented Framework for LocalSearch Heuristics”, 26th Conference on Technologyof Object-Oriented Languages and Systems (TOOLSUSA’98), 1998, IEEE Computer Society, 33-45.

[3] T.G. CRAINIC, M. TOULOUSE and M. GENDREAU,“Towards a Taxonomy of Parallel Tabu Search Al-gorithms”, Research Report CRT-933, Centre deRecherche sur les Transports, Universite de Montreal,1993.

[4] H. EL-REWINI, “Partitioning and Scheduling”, Chap-ter 9 in Parallel and Distributed Handbook (A.Y.H.Zomaya, ed.), 239 – 273, McGraw-Hill, 1996.

[5] M.R. GAREY and D.S. JOHNSON, Computers andIntractability: A Guide to the Theory of NP-Completeness, W.H. Freeman and Company, San Fran-cisco, 1979.

[6] F. GLOVER and MANUEL LAGUNA, Tabu Search, Ed.Kluwer, 1998.

[7] J.P.W. KITAJIMA and S.C.S. PORTO, “Using SyntheticWorkloads for Parallel Task Scheduling ImprovementAnalysis”, 3rd International Meeting on vector andParallel Processing (VecPar’98), 73–86, Porto, June1998.

[8] D.A. MENASCE and S.C.S. PORTO, “Processor Assign-ment in Heterogeneous Parallel Architectures”, Pro-ceedings of the IEEE International Parallel ProcessingSymposium, 186–191, Beverly Hills, 1992.

[9] S.C.S. PORTO and D.A. MENASCE, “Processor Assign-ment in Heterogeneous Message Passing Parallel Ar-chitectures”, Proceedings of the Hawaii InternationalConference on System Science, Kauai, 1993.

[10] S.C.S. PORTO and C.C. RIBEIRO, “A Tabu Search Ap-proach to Task Scheduling on Heterogeneous Pro-cessors under Precedence Constraints”, InternationalJournal of High-Speed Computing 7 (1995), 45–71.

[11] S.C.S. PORTO and C.C. RIBEIRO, “Parallel Tabu SearchMessage-Passing Synchronous Strategies for TaskScheduling under Precedence Constraints”, Journal ofHeuristics 1 (1996), 207–233.

[12] C.R. REEVES and J.E. BEASLEY, “Introduction”, Chap-ter 1 in Modern Metaheuristic Techniques for Combi-natorial Problems, Edited by C.R. Reeves, Ed. JohnWiley & Sons, 1993.

[13] M.G. VASCONCELLOS, “Um Framework Orientado-a-Objetos para Aplicacoes Baseadas em Busca Tabu”,Master Thesis, Computacao Aplicada & Automacao,Universidade Federal Fluminense, Niteroi, Brazil, Au-gust 1998.

[14] M. TOULOUSE, T.G. CRAINIC and M. GENDREAU, “Is-sues in Designing Parallel and Distributed Search Al-gorithms for Discrete Optimization Problems”, Tech-nical Report CRT-96-34, Centre de Recherche sur lestransports, Universit de Montral, 1996.