BULETINUL INSTITUTULUI POLITEHNIC DIN IAŞI Publicat de Universitatea Tehnică „Gheorghe Asachi” din Iaşi Tomul LIX (LXIII), Fasc. 2, 2013 SecŃia AUTOMATICĂ şi CALCULATOARE
THE EFFICIENCY OF USING GENETIC ALGORITHMS TO MAP TASKS WITH PRIORITIES, DEADLINES AND DEPENDENCIES BY
ADRIAN ALEXANDRESCU* “Gheorghe Asachi” Technical University of Iaşi, Faculty of Automatic Control and Computer Engineering
Received: May 6, 2013 Accepted for publication: June 10, 2013
Abstract. An important problem in computational systems is the processing of a large number of tasks in an efficient manner. There are several methods of determining good solutions to this problem but their efficiency depends on several factors, which are discussed in this paper. Genetic algorithms have been applied to solving the task mapping problem because these methods can determine nearoptimal solutions in a very large search-space. This paper makes an analysis on the situations where it is efficient to use genetic algorithms to map tasks according to the performance of existing algorithms and depending on the types of tasks that have to be mapped (e.g., with priorities, deadlines, dependencies). Also, it is proposed a variation of the classic genetic algorithm that uses a fitness function that is better suited for the considered task characteristics. The tests that have been performed showed that the genetic algorithm approach is better than traditional approaches in situations where a very short duration of the mapping process is not imperative. Also, based on the task characteristics, several optimizations are suggested to be applied to the genetic algorithm in order to significantly speed-up and improve the solution. Key words: genetic algorithm, task mapping. 2010 Mathematics Subject Classification: 68M14, 68M20, 68T20. *
Corresponding author; e-mail: [email protected]
1. Introduction Computational systems are widely used in different scenarios to process large amounts of data or to execute a large number of tasks. One of the most important problems found in these systems in how to efficiently allocate tasks to the system’s processing nodes and how to schedule the allocated tasks on each node. The process of allocating and then scheduling the tasks is called mapping and is the subject of several research papers (Omara & Arafa, 2009; Dey & Majumder, 2002; Braun et al., 2001). The efficiency of a mapping algorithm depends on a number of factors such as the system characteristics, the types of tasks that have to be mapped, or the possibility of estimating the execution time of a task on a specific system node. There are several algorithms for solving the mapping problem, e.g., Opportunistic Load Balancing, Minimum Completion Time, Min-Min, MaxMin, Max-Max or Slack Suffrage, but probably the most flexible, when it comes to customizing and applying constraints, is the genetic algorithm. Genetic algorithms are considered to be efficient methods for finding very good solutions in a very large solution search space, but they have the drawback of a high algorithm execution time, which is important in some situations. The goal of this paper is to highlight the situations that can occur in regards to task mapping, and where, when and how it is efficient to use a genetic algorithm to solve the mapping problem. This paper starts by presenting the environment elements that have to be considered in the mapping process and the performance metrics that are used to evaluate the mapping heuristics. A variation of a genetic algorithm designed to solve the problem of mapping tasks with priorities, deadlines and dependencies is described in Section 3, and the related work on the subject of task mapping is presented in Section 4. Three variations of the genetic algorithm along with the Min-Min and Max-Max heuristics are then evaluated and compared, and the results and the improvements that can be made are discussed in Section 5. Finally, the conclusions of the research and the future work are presented in the last section. 2. Problem Statement Two aspects are discussed in order to determine the efficiency of a mapping algorithm. Firstly, the problem context is defined in regards to real task mapping situations considering the system type and the task characteristics. Secondly, the metrics that can be used to determine the efficacy of an algorithm are discussed for the considered context.
Bul. Inst. Polit. Iaşi, t. LIX (LXIII), f. 2, 2013
2.1. System Type
Usually, the tasks are mapped to the processing nodes of a computational system. A node can be a computer that uses its CPU or its GPU, a cluster, a computational grid or cloud, or even another computational system. In this paper, a processing node is considered to be any entity that can sequentially process tasks. The system can be homogeneous, in the sense that a task can be processed, at any point, in the same amount of time on any node of the system. This is achievable only if all the nodes have the same specifications, the communication time between nodes is the same and if the entire system is solely dedicated to processing tasks. If the system is made out of processing nodes that have different specifications, then that system is considered to be heterogeneous. In the scope of task mapping, if the communication times between nodes vary, e.g., because the nodes are geographically distributed, then a task is not processed in the same amount of time on any node, therefore this system is also considered to be heterogeneous. Taking into account the aforementioned, one of the criteria for choosing the mapping algorithm is the type of the system, homogeneous or heterogeneous. This is because certain algorithms perform better for a type of system compared to the other. The tasks can be mapped either statically or dynamically to the processing nodes. In static mapping, the problem consists of mapping n tasks to m processing nodes as efficiently as possible. The execution time of each task on each processing node is considered known and these times are kept in an Estimated Execution Time (ETC) matrix. For the purpose of evaluating static mapping heuristics, the method of computing the execution time does not influence the performance comparison between the different mapping methods. In dynamic mapping, the problem is that the computational system receives different tasks to be processed at different times and, also, the execution time of each task on each processing node is not necessarily known. For this scenario, the simplest, but not that effective, method of mapping tasks is to assign the tasks one by one as they arrive to the least used processing node. The mapping algorithm that can be used in the dynamic scenario depends on the system characteristics and on what is, or can be known, about the tasks that need to be processed by the system. If no time estimations can be made then the aforementioned mapping method can be used, but the performance can be significantly increased if certain assumptions can be made regarding the computational environment. 2.2. Task Characteristics
Depending on the task characteristics, the mapping algorithm must account for the resulting constraints. A task can be more or less important,
i.e., it can have a priority (e.g., low, medium, high and critical). Usually, critical tasks must be scheduled to be executed before any other tasks, whereas a high priority task may be scheduled after a medium priority task if the algorithm would obtain a better efficiency according to the performance metric that was used. Sometimes tasks must be processed before a specific point in time, i.e., a deadline. There are two types of deadlines: soft and hard. If a task has a hard deadline, then that task must be processed before that time, otherwise the execution of that task is worthless. Therefore, that task can be skipped from the mapping process if the algorithm estimates that the task will miss its deadline. However, this will incur a significant penalty regarding the performance metric. A task with a soft-deadline is always executed but it can receive a penalty if the deadline is missed; the penalty is proportionate to the time by how much the deadline is exceeded. Another task characteristic that has a significant impact on the complexity of the mapping algorithm is the task dependency. There are cases in which sets of interdependent tasks have to be mapped for processing; such a set of tasks form a job. Usually, a job is represented as a directed acyclic graph as shown in the example from Fig. 1. All the tasks that form a job have to be mapped in their topological order, but some of the tasks can be executed in parallel, while some tasks have to wait for other tasks to finish their execution. For the example from Fig. 1, tasks T1, T2 and T3 can be executed in parallel since they do not have any dependencies, while task T4 depends on T2 and T3 and it can be processed only after the two tasks have finished their execution. Task T5 depends on T1 and T4, task T6 on T4 and, finally, task T7 depends on T5 and T6.
Fig. 1 – Job representation example (topologically sorted).
There are two approaches to mapping a job. Firstly, the job can be considered as a single task and, in this case, any algorithm that maps independent tasks can be used. The problem is that the entire job is scheduled to a single processing node, which can lead to a less efficient mapping
Bul. Inst. Polit. Iaşi, t. LIX (LXIII), f. 2, 2013
because of the loss in the granularity of the entities that have to be mapped. Secondly, corresponding to the more efficient method, the tasks that can be executed in parallel are assigned to different nodes. The most important problem when mapping a task from a job is to know when all the task dependencies have finished processing and getting the output data from the dependencies to the input of that task. This problem and solutions to this problem are discussed in Section 5. 2.3. Performance Metrics
The most used method of evaluation the performance of a static mapping heuristic is the makespan, which represents the time that it takes the system to finish all the assigned tasks. Using only the makespan when evaluating a mapping algorithm can lead to an imbalance of the loads on the processing nodes. This can lead to the situation where one or more nodes are overused, which increases the possibility of faults in the system and decreases the system’s reliability over time. Therefore, a performance metric that fixes the aforementioned problem is the load imbalance time difference (∆) (Alexandrescu & Craus, 2011). The ∆ value is defined as the difference between the latest and the earliest time when a node finishes executing its assigned tasks. If the tasks have priorities and deadlines, it is not enough to consider the makespan and the load imbalance, because these values do not take into account the two task characteristics. To overcome this problem, in Braun et al. (2008), the authors propose a performance metric called the solution’s worth, which is defined as the sum of the tasks’ worth. The worth of a task is the priority multiplied by a deadline factor, where the deadline factor is 1 if the task finishes before its deadline or, otherwise, the deadline time divided by the task completion time. The makespan, the load imbalance and the solution’s worth can be used to evaluate a static mapping algorithm, but in regards to the dynamic mapping there is another critical performance metric: the duration of running the mapping algorithm. In a dynamic situation the tasks have to be mapped in near real time, therefore the mapping algorithm must be executed as fast as possible. Selecting the appropriate metric or metrics for evaluating a mapping algorithm depends on the considered computational environment and, in practice, using a single metric is not enough to obtain a very good solution. 3. The Genetic Algorithm in Task Mapping This section proposes an approach that uses a genetic algorithm to solve the problem of mapping interdependent tasks with priorities and deadlines. Each
element of a genetic algorithm is discussed in regards to three task situations: simple tasks, tasks with deadlines and priorities and interdependent tasks. Genetic algorithms are used to obtain a very good solution in a large solution search space at the expense of taking longer to run than other methods. In task mapping, genetic algorithms are usually used to improve upon a solution that was provided by another less time consuming mapping algorithm. Using this approach significantly improves the performance of a genetic algorithm and decreases the time it takes to obtain an acceptable solution. The steps of a genetic algorithm are as follows: 1. Initial population. 2. Evaluation. 3. While the stop condition is not met, do: a. Selection, b. Crossover, c. Mutation, d. Evaluation. 4. Output solution. The initial population is made out of randomly generated chromosomes, which represent candidate solutions. A chromosome from the initial population is initialized with the solution of another mapping algorithm in order to increase the solution convergence. The chromosome representation used in this paper is presented in Fig. 2, where 9 tasks are assigned to 3 processing nodes: tasks T1, T3, and T5 are assigned, in this order, to node M1, tasks T9, T6, T7 and T2 are assigned to node M2 and tasks T4 and T8 are assigned to node M3.
T5 T3 T1 M1
T2 T7 T6 T9 M2
T8 T4 M3
Fig. 2 − Chromosome representation for 3 nodes and 9 tasks.
This chromosome representation has the advantage of keeping the order in which the tasks are to be executed on their assigned nodes. This is imperative for mapping tasks with priorities and deadlines because the determination if a task exceeded or not its deadline requires knowledge of the task execution order on that node. There are two approaches when it comes to interdependent tasks: one is to allow chromosomes that do not satisfy the dependency constraint and the other approach is to consider that those chromosomes are valid but they incur a bigger penalty in the evaluation stage. Both of these approaches require the detection of the tasks that are scheduled for execution before their
Bul. Inst. Polit. Iaşi, t. LIX (LXIII), f. 2, 2013
dependencies. The proposed representation has the disadvantage that it needs extra memory and time in order to determine the aforementioned tasks. Also, this chromosome representation does not support periods of inactivity between task executions at the processing nodes. The presence of these periods can lead to a more efficient mapping algorithm especially in a highly heterogenic environment. The evaluation function computes the fitness of each chromosome: the higher the fitness of the chromosome, the better the corresponding candidate solution. For simple tasks, the best fitness function is 1 divided by the makespan, whereas, for tasks with priorities and deadlines, the fitness must be directly proportional with the solution’s worth and indirectly proportional with the makespan. In the case of interdependent tasks, the fitness function used in this paper only penalizes the invalid chromosomes, which are kept in the population for a higher individual diversity. The algorithm ends after a fixed number of iterations (1000) or if the best solution has not improved during 300 iterations of the algorithm. The selection operator used by the genetic algorithm is roulette wheel selection, which favors the selection of the fittest chromosomes. One-point crossover and two mutation operators are also used. The first mutation operator randomly selects a task and moves it to a randomly selected position on a randomly selected node while the second mutation implies the swapping of the positions and nodes for two selected tasks. After the genetic algorithm finishes its execution, the resulting solution is represented by the chromosome with the highest fitness value. 4. Related Work The majority of the related work in the task mapping field deals with assigning a set of independent tasks to a fixed number of processing machines or nodes. Algorithms like Opportunistic Load Balancing, Minimum Completion Time, Min-Min, Max-Min are considered to be good methods for solving the task mapping problem, and a comparison of these heuristics and other mapping methods is presented Braun et al. (2001). These approaches to the mapping problem do not consider the particularities that a task can have, and they become less effective in certain situations. In Braun et al. (2008) the problem of mapping tasks having dependencies, priorities, deadlines and multiple versions is discussed and several approaches are proposed. One of the tested methods is a genetic algorithm that uses the same chromosome representation as the one used in this paper. The difference compared to this paper, is that in Braun et al. (2008) the authors use a fitness function that is similar to the solution’s worth from this paper which does not focus on improving the makespan and on obtaining a more balanced load. Also, the crossover and mutation operators are designed to
task into account the fact that the tasks can have different versions, and there is no discussion on the possibility of using targeted operators to speed-up the convergence and on the applicability of genetic algorithms in dynamic environments. A paper that deals with dynamically mapping tasks having priorities and deadlines is Kim et al. (2007). Although a genetic algorithm is proposed in the paper, it is similar to the one from Braun et al. (2008) and it is used only in a static situation in order to evaluate the dynamic methods. The proposed algorithms are evaluated using the solution’s worth in different scenarios: low and high heterogeneity, and light and heavy task priority. In Alexandrescu & Craus (2010), it is proposed a Genetic Algorithm with a Smart Mutation that speeds-up the convergence by not having a crossover operator, and in Alexandrescu et al. (2011), it is presented a Genetic Algorithm with a 3-Step Mutation that obtains a very good solution in a shorter time by applying a targeted mutation. Both genetic algorithms are designed to solve the problem of mapping simple independent tasks to processing nodes. Another paper that tests the efficiency of a genetic algorithm for task scheduling is Daoud & Kharma (2006). The authors evaluate the mapping of a set of interdependent tasks using a genetic algorithm with a simplified fitness function against the Heterogeneous Earliest Finish Time and the Dynamic Level Scheduling algorithms. The dynamic approach to mapping simple tasks with genetic algorithms is discussed in Gonnade & Bodkhe (2012), where the authors use a fitness function that improves the algorithm in the considered dynamic scenario. Also, in Nedunchelian et al. (2006), the authors propose a parallel approach to the genetic algorithm, in Page & Naughton (2005) batches of tasks are efficiently mapped, and in Page et al. (2010), the genetic algorithm is combined with eight heuristics to minimize the total execution time. 5. Experimental Results 5.1. Simulation Setup
Five mapping algorithms were evaluated by computing the mean values for three performance metrics, i.e., the makespan, the load imbalance (∆ time difference) and the solution’s worth, over 20 runs in low and high heterogeneity scenarios. Each algorithm had to obtain a solution to the problem of mapping 100, 250, 500 and 1000 tasks each to 10 processing nodes. The algorithms that were tested are Min-Min, Max-Max and three variations of the genetic algorithm, each with a different fitness function. The Min-Min heuristic was chosen because it is a well-known and efficient mapping heuristic in terms of the execution time of the algorithm and it was also used to produce a candidate solution in the initial population of the genetic algorithm.
Bul. Inst. Polit. Iaşi, t. LIX (LXIII), f. 2, 2013
The Max-Max heuristic described in Kim et al. (2007) was chosen because it is a variation of the Min-Min method that was adapted for the problem of mapping tasks with priorities and deadlines, and it is a good comparison to the proposed genetic algorithm. Three variations of a genetic algorithm were evaluated against the MinMin and Max-Max mapping heuristics. All the variations contained in the initial population the solution provided by the Min-Min heuristic and they all used the elitism principle so that the best individuals are kept between populations. Each variation used a different fitness function: the first fitness function (f1) is 1 divided by the makespan, the second (f2) is the solution’s worth and the third (f3) is the solution’s worth divided by the makespan. The simulation was performed with the Task Mapping Simulation Framework presented in Alexandrescu et al. (2012). All the tasks were randomly generated and the values for the performance metrics are expresses in generic time units (t.u.). The goals of the algorithms were to obtain a low makespan, a low ∆ time difference value and a high solution worth in the shortest time possible. 5.2. Results
The first performance metric used in comparing the five algorithms is the makespan (Figs. 3 a and 3 b). Regardless of the number of tasks that had to be mapped, the Min-Min heuristic obtained a lower (better) makespan value than the Max-Max heuristic for both low and high heterogeneity. The best makespan was obtained by the GA-f1 because it used a fitness function that specifically targeted the improvement of the makespan. For 100 tasks the GA-f1 improved the Min-Min algorithm by 8% for low heterogeneity and by 10% for high heterogeneity. The makespan obtained by the Max-Max heuristic was 20% worse than GA-f1 for low heterogeneity and 30% worse for high heterogeneity. The worse makespan in all the situations was obtained by the GA-f2, due to the fact that its fitness function doesn’t take into consideration the makespan. As the number of tasks increases, the differences between the algorithms became smaller. The proposed GA-f3 was less than 0.7% worse than GA-f1 for 100 tasks and the difference became less significant as the number of tasks that have to be mapped increased. As it was the case with the makespan, the ∆ time difference values followed the same pattern as can be seen from Figs. 3c and 3d. The lowest load imbalance was obtained by GA-f1, closely followed by GA-f3, then Min-Min and Max-Max, and, lastly, GA-f2. The load became more balanced as the number of tasks increased for GA-f1, while GA-f3 has a slightly increasing trend towards 1000 tasks. For 100 tasks, the lowest ∆ time difference was 3.81 t.u., corresponding to a makespan of 493.30 t.u. for low heterogeneity, and 16.14 t.u, corresponding to a makespan of 231.57 t.u. for high heterogeneity.
For 1000 tasks the situation was even better: a ∆ time difference of 2.66 t.u. with a makespan of 4989.59 t.u. for low heterogeneity, and a ∆ time difference of 8.70 t.u. with a makespan of 2115.68 t.u. for high heterogeneity.
Fig. 3 − The makespan, the ∆ time difference and the solution worth means obtained from running five algorithms that mapped 100, 250, 500 and 1000 tasks to ten processing node (the values are expresses in genetic time units).
Bul. Inst. Polit. Iaşi, t. LIX (LXIII), f. 2, 2013
In regards to the solution’s worth, the GA-f1 was the worst among the five mapping algorithms, because the fitness did not account for the task’s worth. Although GA-f2 focused solely on improving the solution’s worth, it did not always produce the best solution as it was, for a large number of tasks, outperformed by the Max-Max heuristic. This was due to the fact that the genetic algorithms were initialized with the solution of the Min-Min heuristic and not the Max-Max method. The GA-f3 obtained a solution’s worth that was close to the one produced by the GA-f2 and, also, a makespan and a ∆ time difference that was close to the best algorithm in regards to the two performance metrics, the GAf1. Taking the aforementioned into account, the GA-f3 was the best algorithm when considering all three performance metrics because it obtained very good values for the metrics at a small expense. The biggest problem that the genetic algorithms had was the duration of running the algorithm. In addition to the time it took to run the Min-Min heuristic for the chromosome in the initial population, the genetic algorithm had to perform the evaluation, selection, crossover and mutation steps multiple times, which led to a significant increase in the execution time of the algorithm. Although the rate with which the duration increased was the same as for the Min-Min and the Max-Max heuristics, still the final duration of the genetic algorithm was of over 1000 times higher even for a small number of tasks. 6. Discussions The tests that were performed used randomly generated tasks that had to be mapped to processing node in a static mapping environment. The tested mapping methods used estimations of the execution time of each task on each node. In practice, the method of computing these times depends on what is known about the system and the tasks that have to be mapped, and in some situations it is nearly impossible to give these time estimations. An important thing to consider is the time it takes to transmit the task from a node to another; there are related papers that consider that the system uses a high speed network and the transfer times are negligible, but this is not always the case. Between the five tested methods, GA-f3 performed overall the best in regards to the makespan, the load imbalance and the solution worth, but it was at a clear disadvantage when it came to the duration of the algorithm. The genetic algorithm is efficient only if there is not a tight algorithm execution time constraint and if specific improvements are made to the evaluation, selection, crossover and mutation operators. For example, in Alexandrescu & Craus (2010), the absence of the crossover operator, collaborated with a targeted mutation, lead to a significant decrease in the duration of the algorithm and an increase in the convergence to a very good solution. An important advantage of genetic algorithms over traditional methods is the possibility of easily adding
restrictions to the candidate solutions (e.g., task dependencies) by accordingly modifying the fitness function. In static environments the algorithm duration constraint is usually not taken into consideration but in a dynamic situation this is a critical problem. Mapping tasks in a dynamic environment requires the tasks to be mapped in near real-time, therefore, a compromise has to be reached between the execution time of the mapping heuristic and the actual moment when a task is assigned to a processing node. If there are tasks that have tight deadlines, then it is possible that running a mapping algorithm can make that task miss its deadline. In Kim et al. (2007), the authors propose a method of applying static heuristics in a dynamic environment by using mapping events, which means that, at specific moments in time, a mapping heuristic runs for the tasks that are in the system but they have not yet been mapped. This approach has the same aforementioned problem of tasks missing their deadline. A solution to use mapping heuristics in a dynamic environment is to presort the tasks as they arrive based on criteria like the deadline (depending if it is a soft or hard deadline) and the priority of a task (a critical task has to take precedence over all other tasks). Another improvement that can be made is to apply a more time consuming algorithm only if the number of tasks in the queue reached an imposed threshold. 7. Conclusions and Future Work Tests have shown that genetic algorithms are efficient in solving the task mapping problem if the execution time of the algorithm is not an important factor. Depending of the computational environment, several improvements can be made to shorten the duration of the algorithm and to improve the obtained solution, e.g., a targeted mutation, an evaluation function that considers all the performance metrics, or even the absence of the crossover operator in order to significantly shorten the algorithm’s execution time. The goal of this research was also to preface the development of a dynamic system that uses a hybrid approach to task mapping depending on the task characteristics and on the number of tasks that are queuing in the computational system. The system will dynamically employ different mapping techniques according to the current state of the system and will decide when and which algorithm is going to be used. REFERENCES Alexandrescu A., Agavriloaei I., Craus M., A Task Mapping Simulation Framework for Comparing the Performance of Mapping Heuristics in Various Scenarios. Proceedings of the 16th International Conference on System Theory Control and Computing, October 14-16, 2012, Sinaia, România, 1-6, 2012.
Bul. Inst. Polit. Iaşi, t. LIX (LXIII), f. 2, 2013
Alexandrescu A., Agavriloaei I., Craus M., A Genetic Algorithm for Mapping Tasks in Heterogeneous Computing Systems. Proceedings of the 15th International Conference on System Theory Control and Computing, October 14-16, 2011, Sinaia, România, 1-6, 2011. Alexandrescu A., Craus M., Improving Mapping Heuristics in Heterogeneous Computing. In Proceedings ECIT2010 6th European Conference on Intelligent Systems and Technologies, October 7-9, Iaşi, 1–12, 2010. Braun T.D. et al., A Comparison of Eleven Static Heuristics for Mapping a Class of Independent Tasks onto Heterogeneous Distributed Computing Systems. Journal of Parallel and Distributed Computing, Vol. 61, 810–837, June 2001. Braun T.D. et al., Static Resource Allocation for Heterogeneous Computing Environments with Tasks Having Dependencies, Priorities, Deadlines and Multiple Versions. Journal of Parallel and Distributed Computing, Vol. 68, 1504-1516, 2008. Dey S., Majumder S., Task Allocation in Heterogeneous Computing Environment by Genetic Algorithm. In Proceedings of the 4th International Workshop on Distributed Computing, Mobile and Wireless Computing, ser. IWDC ’02. London, UK, UK: Springer-Verlag, 348–352, 2002. Daoud M.I.; Kharma N., An Efficient Genetic Algorithm for Task Scheduling in Heterogeneous Distributed Computing Systems, Evolutionary Computation, CEC 2006, IEEE Congress, 3258−3265, 2006. Gonnade P., Bodkhe S., Genetic Algorithm for Task Scheduling in Distributed Heterogeneous System. International Journal of Advanced Research in Computer Science and Software Engineering, Vol. 2, 9−12, 2012. Kim J.K., Shivle S., Siegel H.J., Maciejewski A.A., Braun T.D., Dynamically Mapping Tasks with Priorities and Multiple Deadlines in a Heterogeneous Environment. Journal of Parallel and Distributed Computing, Vol. 67, 154−169, 2007. Nedunchelian R., Koushik K., Meiyappan N., Raghu V., Dynamic Task Scheduling Using Parallel Genetic Algorithms for Heterogeneous Distributed Computing. Proceedings of the 2006 International Conference on Grid, Las Vegas, Nevada, USA, 2006. Omara F.A., Arafa M.M., Genetic Algorithms for Task Scheduling Problem. Journal of Parallel and Distributed Computing, Oct. 2009. Page A.J., Keane T.M., Naughton T. J., Multi-Heuristic Dynamic Task Allocation Using Genetic Algorithms in a Heterogeneous Distributed System. Journal of Parallel and Distributed Computing, Vol. 70, 758−766, 2010. Page A.J., Naughton T.J., Dynamic Task Scheduling using Genetic Algorithms for Heterogeneous Distributed Computing. In Proceedings of the 19th IEEE International Parallel and Distributed Processing Symposium (IPDPS'05) Workshop 6 - Volume 07 (IPDPS '05), Vol. 7, 2005.
EFICIENłA UTILIZĂRII ALGORITMILOR GENETICI ÎN MAPAREA TASKURILOR CU PRIORITĂłI, TERMENE LIMITĂ ŞI DEPENDENłE (Rezumat) O problemă importantă a sistemelor computaŃionale o reprezintă procesarea unui număr mare de taskuri într-un mod cât mai eficient. Există mai multe metode de a obŃine soluŃii satisfăcătoare pentru această problemă, dar eficienŃa acestei metode depinde de mai mulŃi factori care sunt discutaŃi în această lucrare. Algoritmii genetici au fost aplicaŃi pentru rezolvarea problemei mapării taskurilor deoarece aceşti algoritmi pot obŃine soluŃii aproape optimale într-un spaŃiu de căutare foarte mare. Această lucrare face o analiză a situaŃiilor în care este eficientă utilizarea algoritmilor genetici pentru maparea taskurilor. Analiza este bazată pe eficienŃa algoritmilor existenŃi şi în funcŃie de tipurile de taskuri care trebuie asignaŃi (e.g., având priorităŃi, termene limită sau dependenŃe). De asemenea, este propusă o variantă a algoritmului genetic clasic care utilizează o funcŃie de fitness mai potrivită pentru caracteristicile considerate ale taskurilor. Testele efectuate au arătat că abordarea folosind algoritmi genetici este mai potrivită faŃă de abordările tradiŃionale în situaŃiile în care nu este absolut necesar un timp scurt de execuŃie a algoritmului de mapare. De asemenea, în funcŃie de caracteristicile taskurilor, sunt sugerate o serie de optimizări aplicate algoritmului genetic pentru a mări gradul de convergenŃă şi pentru a îmbunătăŃi soluŃia obŃinută.