Resolution of Resource Contentions in the CCPM-MPL Using Simulated Annealing and Genetic Algorithm

This research aims to plan a “good-enough” schedule with leveling of resource contentions. We use the existing critical chain project management-max-plus linear framework. Critical chain project management is known as a technique used to both shorten the makespan and observe the due date under limited resources; the maxplus linear representation is an approach for modeling discrete event systems as production systems and project scheduling. If a contention arises within a single resource, we must resolve it by appending precedence relations. Thus, the resolution framework is reduced to a combinatorial optimization. If we aim to obtain the exact optimal solution, the maximum computation time is longer than 10 hours for 20 jobs. We thus experiment with Simulated Annealing (SA) and Genetic Algorithm (GA) to obtain an approximate solution within a practical time. Comparing the two methods, the former was beneficial in computation time, whereas the latter was better in terms of the performance of the solution. If the number of tasks is 50, the solution using SA is better than that using GA.


Introduction
This research aims to plan a "good-enough" schedule with leveling of resource contentions.References [1] and [2] modified and extended a scheduling methodology referred to as critical chain project management-max-plus linear (CCPM-MPL), in which CCPM [3] [4] was applied to the max-plus algebra [5].CCPM is a technique for project management invented by E. M. Goldratt and developed by L. P. Leach.The objective of this method is to both shorten the makespan and observe the due date under a limited number of resources.The max-plus algebra is an algebraic system wherein the max and plus operations are defined as addition and multiplication, respectively.MPL [1] representation is an approach for modeling and analyzing a class of discrete-event systems such as production and project scheduling, in which the behavior of the target system is represented by linear equations in the max-plus algebra.MPL representation can formulate systems with structures of non-concurrency, synchronization, parallel processing of multiple tasks, and so on [1].We assume that a single resource cannot process multiple tasks simultaneously.If a contention arises within a single resource, we must resolve it by appending precedence relations.Thus, the resolution framework is reduced to a combinatorial problem.To level resource contentions, we developed a complete enumeration method by which an exact solution is obtained.In a numerical simulation, the maximum computation time was longer than 10 hours for 20 jobs.Reference [6] obtained a "good-enough" schedule by using Genetic Algorithm (GA) within a short computation time.On the other hand, we uncovered a preliminary design to obtain a "good-enough" schedule by using Simulated Annealing (SA) [7].However, it is not currently clear which of the two methods is better.Hence, this research compares the two methods in terms of the performances of their solutions, computation times, and values.

CCPM-MPL Framework
After defining the max-plus algebra, we define the CCPM-MPL framework with the help of [1] and [2].

Max-Plus Algebra
We define a set , where  is the whole real line.Then, for max , x y ∈  , we define the operators: The priority of operator ⊗ is higher than that of The zero and unit elements for operators ⊕ and ⊗ are denoted by ( ) ε = −∞ and ( ) 0 e = , respectively.ε is a matrix whose elements are all ε , and e is a matrix whose diagonal elements are e and whose off-diagonal elements are ε .If where ( )

Formulation of the CCPM-MPL Framework
We define the following relevant matrices and vectors: • n: number of tasks; • p : number of external outputs; • q : number of external inputs; The earliest task-completion times of all tasks, E x , are calculated using where ( ) Matrixes 0 A and 0 P are the transition and weight matrices, respectively.The ear- liest output times to all output transitions, E y , are then calculated by Then, the latest task-starting times, L x , are calculated using Equation ( 10): ( ) The latest input times, L u , are calculated in terms of L x : As a consequence, the total floats of all tasks can be calculated using Equations (( 5) and ( 8)): ( ) We then calculate two matrices, a b max , n n × ∈ P P  , as follows: ( ) In the CCPM framework, there are two types of buffers, referred to as feeding and project buffers.The size of each buffer is calculated by where Feeding buffers are inserted wherever a non-critical task joins into a critical one.A project buffer is inserted on the eve of an output to avoid tardiness of the project.To reflect the insertion of the two types of buffers, we incur weights to the adjacency matrix 0 F and the output matrix 0 C : Now we can calculate the earliest task-completion, E ′ x , and the output time, E ′ y , after inserting the time buffers.The earliest task-completion times of all nodes, E ′ x , are calculated using Matrix 0 ′ A is the transition matrix, in which the insertion of the two types of buffers is reflected.The earliest output times to all output transitions, E ′ y , are then calculated by We treat E ′ y as the objective function and consider minimizing [ ]

Resolution of Resource Contentions
We explain the resolution of resource contentions with the help of [8].We add relevant matrices and vectors as follows: • l : number of resources, • s : maximum number of tasks that a single resource processes, • l s × ∈ S  : processing order of tasks,

[ ] { }
: resource processes task in the th processing, 0 : otherwise We consider Figure 1 Tasks 1, 4, and 5 are processed by resource 1, whereas tasks 2 and 3 are processed by resource 2. If resource 2 processes tasks 2 and 3 simultaneously, a resource contention occurs.We avoid contentions between tasks 2 and 3 appending two precedence relations, which are expressed by broken arrows in Figure 2, which shows the project after the resource contention is leveled.We then reflect the leveling of the resource contentions using the following adjacency matrix, 0 ′ F : In addition, the processing order of tasks, S , is Our numerical simulation to level resource contentions shows that the maximum  computation time was longer than 10 hours for 20 jobs.We thus consider the development of approximate methods within a short computation time.

Two Metaheuristics
We experiment with an optimization based on Genetic Algorithm (GA) and Simulated Annealing (SA), both of which are common metaheuristics.

Genetic Algorithm
We experiment with an optimization based on the GA developed in [6], which is used to obtain an approximate solution. Algorithm

Simulated Annealing
SA [9] is known as an approach to efficiently obtain an approximate solution.We use the 2-opt neighborhood method [10] based on a local search to generate a neighboring solution.
Algorithm 2: Simulated Annealing STEP 1. Initialize the temperature and cooling parameters, 0 T and γ , respectively.

Approximate Ratio and Computation Time
We obtain solutions using the SA-and GA-based algorithms.We use a personal computer with the following execution environment: • machine: Dell Optiplex 9020; • CPU: Intel ® Core™ i7-4790 3.60 GHz; • OS: Microsoft Windows 7 Professional; • memory: 4.0 GB; • programming language: MATLAB R2015b.
The test cases for the numerical experiment are generated under the following conditions: • number of cases: 100; • number of resources, l : for 10, 15, and 20 tasks, we set the number of resources to 3, 5, and 7, respectively; • number of resources for task, i : uniformly random integer numbers; , respectively, for the GA-based algorithm.We compare the exact and approximate solutions.The performance of the solution is shown in Table 1 for the two metaheuristics.We can confirm that the performance of the solution using the GA-based algorithm is smaller than that using the SA-based algorithm.The average computation times are shown in Figure 3.We can confirm that the computation using the SA-based algorithm is faster than that using the GA-based algorithm.The computation time of the GA-based algorithm is more than16-fold longer than that of the SA-based algorithm.The average values of the solutions are shown in Table 2.If the number of tasks is 10 or 20, the values of the solutions using the two methods are not remarkably different; if the number of tasks is 30 or 40, the value of the solution using the GA-based algorithm is smaller than that of the SA-based algorithm.However, we should note  here that the solution using the SA-based algorithm is better than that using the GA if the number of tasks is 50.

Conclusions
This research has studied the planning of a "good-enough" schedule with leveling of resource contentions.We utilized an existing framework called the CCPM-MPL.The resolution framework was reduced to a combinatorial problem.We used SA-and GA-based algorithms to obtain approximate solutions within short time.Moreover, we used the 2-opt neighborhood to generate a neighboring solution in the SA-based algorithm.Comparing the two methods, the SA-based algorithm was beneficial in terms of computation time, whereas the latter was better in terms of the performance of the solution.In addition, when the number of tasks was 50, the value of the solution using the SA-based algorithm was better than that using the GA-based algorithm.
Developing an original heuristic to level resource contentions within a short computation time is our future work.

X
is the Kleene star: tasks can be classified into two types: [ ] 0 0 i = m and [ ] 0 0 i > m are a critical and a non-critical task, respectively.We define two vectors, 0 0 max , n ∈ a b  , to classify each task as either critical or non-critical:

[
as an example project with five tasks before the leveling of resource contentions.The duration time of each task is

Figure 1 .
Figure 1.Example of a fifth-task project before a resource contention is leveled.

Figure 2 .
Figure 2. Example of the fifth-task project after the resource contention is leveled.

STEP 2 . 3 .
Generate a random solution, S , and create the earliest output times, [ ] Generate a neighboring solution, ′ S , and create the new earliest output times, [ ] of γ is a cooling parameter which decreases the temperature parameter, 0 T .STEP 7. Repeat STEPS3-6.STEP 8. Terminate if the temperatures are sufficiently low.If otherwise, return to STEP3.

•
duration time, [ ] i d : uniformly random integer numbers.We obtain approximate solutions using two metaheuristics.The temperature and cooling parameter are set to 1 T = and 0.85 γ = , respectively, for the SA-based algorithm.The mutation parameter and the end condition are set to 0

Figure 3 .
Figure 3. Average computation times in seconds.
Focusing on a row vector of S that gives the list of tasks for a single resource, split the vector into two.We then swap the two vectors, followed by generating wise, i.e., if a mutation does not occur, then follow STEP 6. STEP 5. Swap two tasks of ′ S at the same resource randomly.STEP 6. Create the new earliest output times, [ ]

Table 1 .
Performance of the solutions.

Table 2 .
Average values of the solutions.