A Hybrid Algorithm for Scheduling Workflow Applications in Grid ...

A Hybrid Algorithm for Scheduling Workflow Applications in Grid Environments (ICPDP) Bogdan Simion, Catalin Leordeanu, Florin Pop, and Valentin Cristea Faculty of Automatics and Computer Science, University ”Politehnica” of Bucharest {bogdans,catalinl,florinpop,valentin}@cs.pub.ro http://www.acs.pub.ro

Abstract. In this paper, based on a thorough analysis of different policies for DAG scheduling, an improved algorithm ICPDP (Improved Critical Path using Descendant Prediction) is introduced. The algorithm performs well with respect to the total scheduling time, the schedule length and load balancing. In addition, it provides efficient resource utilization, by minimizing the idle time on the processing elements. The algorithm has a quadratic polynomial time complexity. Experimental results are provided to support the performance evaluation of the algorithm and compare them with those obtained for other scheduling strategies. The ICPDP algorithm, as well as other analyzed algorithms, have been integrated in the DIOGENES project, and have been tested by using MonAlisa farms and ApMon, a MonAlisa extension. Keywords: Grid Scheduling, DAG Scheduling, Tasks Dependencies, Workflow Applications, MonALISA.

1

Introduction

Scheduling applications on wide-area distributed systems like Grid environments is important for obtaining quick and reliable results in an efficient manner. Optimized scheduling algorithms are fundamentally important in order to achieve efficient resource utilization. The existing and potential applications include many fields of activity like satellite image processing [1] and medicine [2]. A distributed system consists of several machines distributed across multiple domains sharing their resources. The interconnected resources interact and exchange information in order to offer a shared environment for applications. A Grid is a large scale distributed system with an infrastructure that covers a set of heterogeneous machines located in various organizations and geographic locations. It is basically a collection of computing resources which are used by applications to perform tasks [3]. The Grid architecture must provide good support for resource management as well as adaptability and scalability for applications. The real problem consists in ”coordinated resource sharing” (computers, software, data and other resources) and ”problem solving in dynamic, multi-institutional virtual organizations” [4][5]. In most cases, heterogeneous distributed systems have proved to produce higher performance for lower costs than a single high performance computing machine. R. Meersman and Z. Tari et al. (Eds.): OTM 2007, Part II, LNCS 4804, pp. 1331–1348, 2007. c Springer-Verlag Berlin Heidelberg 2007 

1332

B. Simion et al.

Grid scheduling can be defined as the process of making decisions regarding resources situated in several locations. The scheduling process involves searching different domains before scheduling the current job in order to use multiple resources at a single or multiple sites. The Grid scheduler must consider the status of the available resources in order to make an appropriate schedule, especially because of the heterogeneity of machines included in the Grid. The scheduler must acquire information from GIS or Grid Information Service. GIS must gather detailed information on the resources of a site available at the moment, resources like memory size, network bandwidth, or CPU load. The objective of this paper is to present solutions for scheduling workflow applications on Grid resources. First, we analyze the workflow, the task dependencies (the DAG model) and a series of heuristics that serve a near optimal performance. We focus on the scheduling policies that solve specific problems in order to provide a benchmark based on a set of evaluation criteria. We present a series of algorithms for DAG scheduling which attempt to solve the scheduling problem for several types of applications containing tasks with different time and resource requirements. Next, we propose an improved algorithm for scheduling applications with dependencies: ICPDP (Improved Critical Path using Descendant Prediction), present the idea behind the algorithm and complexity analysis, the input data model, the output schedule and the DIOGENES testing platform. We conduct a comparative evaluation with the other implemented scheduling strategies, using a series of performance indicators. Experimental results are presented in order to support the conclusions regarding the performance of the ICPDP algorithm.

2

Related Work

Grid users submit complex applications to be executed on available resources provided by the Grid infrastructure, setting a number of restrictions like time (deadline), quality, and cost of the solution. These applications are split into tasks with data dependencies. Two types of workflows can be distinguished: static and dynamic. The description of a static workflow is invariant in time. A dynamic workflow changes during the workflow enactment phase due to circumstances unforeseen at the process definition time [6]. 2.1

Task Dependencies Model and DAG Scheduling

The model used to represent a Grid workflow is a DAG (Directed Acyclic Graph). A directed acyclic graph (DAG) is a graph G = (V, E), where V is a set of v nodes and E is a set of e directed edges. A node in the DAG represents a task which in turn is a set of instructions which must be executed sequentially in the same processor. The weight of a node ni is called the computation cost and is denoted by w(ni ). The edges in the DAG, each of which is denoted by a pair (ni , nj ), correspond to the communication messages and precedence constraints among the nodes. The weight of an edge is called the communication cost of the

A Hybrid Algorithm for Scheduling Workflow Applications

1333

edge and is denoted by c(ni , nj ). The source node of an edge is called the parent node while the destination node is called the child node. A node with no parent is called an entry node and a node with no child is called an exit node. The node and edge weights are usually obtained by estimation at compile time. The precedence constraints of a DAG dictate that a node cannot start execution before it gathers all of the messages and data from its parent nodes. The communication cost between two tasks assigned to the same processor is considered to be zero. After all the nodes have been scheduled, the schedule length is calculated as the time elapsed from the start time of the first scheduled task to the end time of the last task, across all processors. The goal of scheduling is to minimize the total schedule length. The main problem raised by the workflow consists of submitting the scheduled tasks to Grid resources without violating the structure of the original workflow [24]. The critical path is the weight of the longest path in the DAG and offers an upper limit for the scheduling cost. Algorithms based on ”critical path” heuristics produce the best results on average. They take into consideration the critical path of the scheduled nodes at each step. However, these heuristics can sometimes result in a local optimum, failing to reach the optimal global solution [12]. The DAG scheduling problem is an NP-complete problem [13][14]. A solution for this problem consists of a series of heuristics [7][8], where tasks are assigned priorities and placed in a list ordered by priority. The method through which the tasks are selected to be planned at each step takes into consideration this criterion, thus the task with higher priority receives access to resources before those with a lower priority. The heuristics used vary according to job requirements, structure and complexity of the DAG [9][10][11]. Most scheduling algorithms are based on the so-called list scheduling technique [15][16][17]. The basic idea of list scheduling is to make a scheduling list (a sequence of nodes for scheduling) by assigning them some priorities, and then repeatedly execute the following two steps until all the nodes in the graph are scheduled: 1. Remove the first node from the scheduling list ; 2. Allocate the node to a processor which allows the earliest start-time. Priorities of nodes can be determined in many ways such as: HLF (Highest Level First), LP (Longest Path), LPT (Longest Processing Time) or CP (Critical Path). Frequently used attributes for assigning priority include the t-level (top level), the b-level (bottom level), the ALAP (As Late As Possible) and CP(Critical Path) [12][15][17]. The t-level of a node ni is the length of a longest path (there can be more than one longest path) from an entry node to ni (excluding ni ). The length of a path is the sum of all the node and edge weights along the path. The b-level of a node ni is the length of a longest path from ni to an exit node. The b-level of a node is bounded from above by the length of a critical path. A critical path (CP) of a DAG is the longest path in the DAG. Clearly, a DAG can have more than one CP. The ALAP start-time of a node is a measure of how far the node’s start time can be delayed without increasing the schedule length.

1334

B. Simion et al.

Scheduling algorithms for dynamic workflows are based on a dynamic list scheduling. In a traditional scheduling algorithm, the scheduling list is statically constructed before node allocation begins, and most importantly, the sequencing in the list is not modified. In contrast, after each allocation, the dynamic algorithms re-compute the priorities of all unscheduled nodes, which are then used to rearrange the sequencing of the nodes in the list. Thus, these algorithms essentially employ the following three-step approaches: 1. Determine new priorities of all unscheduled nodes; 2. Select the node with the highest priority for scheduling; 3. Allocate the node to the processor which allows the earliest start-time. Scheduling algorithms that employ this three-step approach can potentially generate better schedules. However, a dynamic approach can increase the timecomplexity of the scheduling algorithm [12]. When tasks are scheduled to resources, there may be some holes between scheduled tasks due to dependences among the tasks of the application. When a task is scheduled to the first available hole, this is called the insertion approach. If the task can only be scheduled after the last task scheduled on the resource without considering holes, it is called a non-insertion approach. The insertion approach performs much better then the non-insertion one, because it utilizes idle times better. However, the complexity of the non-insertion approach is O(V P ) whereas that of the insertion approach is O(V 2 ), where V is the number of nodes and P is the number of processing resources.

3

ICPDP Algorithm

This paper presents ICPDP (Improved Critical Path using Descendant Prediction), a novel DAG scheduling mechanism for workflow applications. The algorithm has a quadratic polynomial time complexity. ICPDP provides efficient resource utilization, by minimizing the idle time on the processing elements. Several metrics, including scheduling time, schedule length and load balancing, exhibit improved behavior compared to the results obtained with other scheduling strategies from literature. We have implemented and integrated ICPDP in the DIOGENES project. Using the MonAlisa [18] and ApMon environments, we have carried out extended experiments that validate the performance evaluation of the ICPDP scheduling algorithm. 3.1

Static Scheduling ALGORITHMS

We have tested three of the most popular algorithms that perform well in most situations: HLFET, ETF and MCP, in order to provide a comparison for the proposed hybrid algorithm. The HLFET (Highest Level First with Estimated Times) algorithm [15] is one of the simplest scheduling algorithms. The algorithm schedules a node to a processor that allows the earliest start time, using the static blevel (or slevel) as

A Hybrid Algorithm for Scheduling Workflow Applications

1335

the scheduling priority. The main problem with HLFET is that in calculating the slevel of a node, it ignores the communication costs on the edges. The timecomplexity of the HLFET algorithm is O(V 2 ), where V is the number of nodes. The ETF (Earliest Time First) algorithm [19] computes, at each step, the earliest start times for all ready nodes and then selects the one with the smallest start time. The earliest start time of a node is computed by examining the start time of the node on all processors exhaustively. When two nodes have the same value of their earliest start times, the algorithm breaks the tie by scheduling the one with the higher static blevel. Therefore, a node with a higher slevel does not necessarily get scheduled first because the algorithm gives a higher priority to a node with the earliest start time. The time-complexity of the HLFET algorithm is O(P V 2 ). The MCP (Modified Critical Path) algorithm [20][21][22] uses the ALAP time of a node as a scheduling priority. The ALAP time of a node is computed by first computing the length of CP and then subtracting the b-level of the node from it. Thus, the ALAP times of the nodes on the CP are just their t-levels. The MCP algorithm first computes the ALAP times of all the nodes and then constructs a list of nodes in ascending order of ALAP times. Ties are broken by considering the ALAP times of the children of a node. The algorithm then schedules the nodes on the list one by one such that a node is scheduled to a processor that allows the earliest start time using the insertion approach. Basically, the MCP algorithm looks for an idle time slot for a given node. The time complexity of the MCP algorithm is O(V 2 log V ). These scheduling policies have certain advantages given by the strategy of allocating the next task to a resource. Overall, as deducted from the experimental results, the MCP and HLFET scheduling algorithms have a good time complexity therefore they offer a good schedule in a very short time. On the other hand, the ETF strategy is more complex and requires a significantly greater time for scheduling all nodes to the resources, but gives better performance than the HLFET and in some cases it performs almost as good as MCP. Taking this into consideration, the MCP scheduling algorithm offers the best scenario regarding the schedule length over all processors and the time spent for scheduling. Between the list scheduling algorithms HLFET and ETF the former performs faster but gives a relatively longer schedule, whereas the latter gives a better schedule length in a significantly greater amount of time. So, depending on the application requirements, a user may be interested in a schedule estimation quickly even if the result may not be that good, or wait longer for a better schedule over the processors. All in all, the MCP is the best solution in most cases. 3.2

Performance Trade-Off

There are a number of factors that determine which algorithm is more suitable for a type of application, for example the schedule length when the application needs to execute as fast as possible, and the load balancing when the application needs to make the most of the resources it can use by using an efficient schedule

1336

B. Simion et al.

with reduced idle times on the resources as much as possible. Taking too much time for the scheduling process is not always recommended especially in time critical applications, however if there is a chance that the resulted schedule were improved then there should be a compromise in order to allow a more complex and time consuming scheduling algorithm to obtain better results. 3.3

Premise

Experimental results have shown that the MCP [21] performs very well in overall situations, offering a good quality with a reasonable low complexity. The MCP algorithm is presented as follows: Step 1. Compute the ALAP time of each node. Step 2. 2.1 For each node, create a list which consists of the ALAP times of the node itself and all its children in a descending order. 2.2 Sort these lists in an ascending lexicographical order. 2.3 Create a node list according to this order. Step 3. Repeat 3.1 Schedule the first node in the node list to a processor that allows the earliest execution, using the insertion approach. 3.2 Remove the node from the node list. Until the node list is empty. It uses a scheduling strategy by using the ALAP where ties are broken by all the descendants of the node. The complexity is O(V 2 log V ). Experiments showed that it is not necessary to use all descendants to break ties [22]. Instead, breaking ties by differentiating one level of descendants can produce almost the same result. 3.4

Improved Critical Path Using Descendant Prediction (ICPDP)

The ICPDP scheduling algorithm also uses the ALAP as the scheduling priority, as well as a number of improvements considering the descendants of the nodes along the critical path in determining the best candidate to be scheduled next. Nodes are sorted in the ascending order of ALAP times and ties are broken by the critical child that has the smallest ALAP time. In classical scheduling algorithms[21] there is some randomness involved because if the critical children have the same priority, ties are broken randomly. In this case, we must establish a criteria for eliminating the degree of randomness in the algorithm. In ICPDP, if nodes have the same ALAP the strategy is to take into consideration the static blevel of the nodes. The node with the greatest static level from the candidate nodes with identic ALAP times is the one scheduled at the current step.

A Hybrid Algorithm for Scheduling Workflow Applications

1337

Furthermore, we must take into consideration the following situation. Let’s say that we have two nodes ni and nj with very close ALAP times, node ni having a smaller ALAP than node nj . If node nj has more descendants on the critical path than node ni than perhaps scheduling node nj first will open a larger part of the DAG by breaking more dependencies ”freeing” more descendants and thus giving a better schedule length in the long run. This idea is implemented in the ICPDP. Considering the previous aspects, the ICPDP is described as follows: Step 1. Compute the ALAP time of each node. Step 2. Sort the nodes in the ascending order of ALAP times. Ties are broken by the child that has the smallest ALAP time, considering the following aspects: a. If there are several nodes with the same smallest ALAP time, the scheduled node is the one with the greater static blevel. b. If the ALAP times of several nodes are very close within a certain threshold T, the scheduled node is the one with the greatest number of descendants. Step 3. Repeat 3.1 Schedule the first node in the node list to a processor that allows the earliest execution, using the insertion approach. 3.2 Remove the node from the node list. Until the node list is empty. The improved algorithm (ICPDP) mentions that if ALAP times are very close within a certain threshold, the node with the greatest number of direct descendants should be considered. The proximity of ALAP times is measured by a threshold T limit. This limit was first considered to be 0.98, meaning that if the ALAP of node ni is 0.98 times smaller than the ALAP of node nj and node nj has more descendants than node ni , than node nj is the next scheduled task. The value of the threshold varies according to the number of tasks, the number of dependencies and of course the number of processors available. More details regarding the influence of the threshold on the schedule length can be found in the experimental results section of this document. Taking into consideration these aspects, the complexity of Step1 is O(E), the complexity of Step2 is O(E + V log V ), and the complexity of Step3 with the insertion approach is O(V 2 ), where V is the number of nodes and E is the number of edges. Therefore, the complexity of the ICPDP algorithm is O(V 2 ). The ICPDP algorithm has demonstrated to offer the best schedule length over all resources in a slightly shorter time than the other scheduling algorithms.

1338

4

B. Simion et al.

DIOGENES DAG Framework

In order to employ the scheduling techniques presented in the previous sections in a real testing and monitoring system, we have used the DIOGENES platform [23]. DIOGENES (DIstributed Optimal GENEtic algorithm for grid application Scheduling) is a task scheduler that uses an agent platform and the monitoring service from MonALISA [18]. It utilizes the Jini technology for discovery and lookup services [25][26]. The objectives behind this project are to allocate a group of various different tasks on resources and to provide a near-optimal solution to an NP-Complete problem. In order to provide a near-optimal solution for the scheduling problem it takes into consideration the following goals: efficient planning, minimize the total execution time of the tasks, uniform loading of computing resources, successful completion of tasks. The structure of the scheduler is presented in figure 1.

Fig. 1. DIOGENES architecture

The components shown in the previous figure are as follows: Discovery Service offers initial state of resources, Grid Monitoring Service offers feedback information of task execution, Execution Service is represented by local scheduler in a cluster, and Scheduler is a meta-scheduler for different type of tasks. The system architecture is based on an agent platform. The agents framework include two types of entities: brokers and agents. Brokers collect user requests, the groups of tasks to be scheduled (the input of the algorithm). A broker can be

A Hybrid Algorithm for Scheduling Workflow Applications

1339

remote or on the same workstation with the agents [27]. Agents run the scheduling algorithm using monitoring information and the tasks from the brokers. They also take care of the migration of the best current solution. The agent’s anatomy has a two-layered structure: the Core which runs the scheduling algorithm and the Shell which provides for the Core [23]. Currently, DIOGENES doesn’t support tasks with dependencies, therefore our aim was to cover that aspect and provide the possibility of scheduling application workflows using the agent platform, by integrating the DAG scheduling algorithms in DIOGENES. 4.1

Input Data Model

The scheduler must take into consideration what resources are available, their capabilities (e.g. memory and CPU) and schedule the incoming tasks. The representation of resources is done using an XML description file, containing records for each resource regarding the location of the resources (the farm, cluster and node names used in MonALISA) and the parameters like CPU power, memory and CPU occupation. An example of such a record is given as follows: 1 DIOGENESFarm DIOGENESCluster P01 2730.8MHZ 512MB 93.7 The representation of the applications is also offered in an XML description file containing the tasks of the application. Each task is represented by a record containing the task properties, the communication costs for direct children of that task and parent tasks (subtasks depend on data which is available only after the parent task has finished its execution), and the task requirements like memory, CPU power, processing time, deadline and priority. An example of the task description is given below: 2 /home/DIOGENES/applications/loop500.sh 2007/01/05 01:20:00

1340

B. Simion et al.

1 4 7 1 128.0MB 2745.9MHZ 51 2007/01/06 22:20:30 -1 1 4.2

The Output Schedule

The scheduler takes into consideration the application requirements, the data dependencies and resource capabilities and allocates the tasks to the resources using the ICPDP algorithm. The output is a configuration of mappings between tasks and resources representing the schedule. Thus, each processor has been given a number of tasks to be executed and the start times of each task according to the schedule. The schedule tries to minimize the number of ”holes” and at the same time to offer a good load balancing.

5 5.1

Experimental Results Improvements Relative to Other Scheduling Algorithms

After a series of experiments on a large number of tasks ranging between 100 and 1000 tasks, the ICPDP has shown better results than the other algorithms, especially regarding the schedule length. The times obtained were rather similar to the MCP but slightly better due to the reduced complexity of the ICPDP. The threshold value was established to be over 0.75 for a small number of tasks, and increasing to over 0.94 for a larger number of tasks. Overall, using a value in the interval [0.94, 0.99] depending on the number of tasks and link complexity, has resulted in significant improvements in most cases. 5.2

Performance Indicators

The performance of a scheduling algorithm can be usually estimated using a number of standard parameters, like total time or the schedule length. In the tests

A Hybrid Algorithm for Scheduling Workflow Applications

1341

performed we have used the following indicators: Total time for the scheduling process, Total schedule length (SL), Normalized schedule length (NSL). First, the total time is vital for applications with high priority which need scheduling right away, or applications that need only a fair estimation of the total schedule length as soon as possible. Secondly, the total schedule length is the time span between the start time of the first scheduled node (the root node in the DAG) and the finish time of the last leaf node in the DAG, considering that all the resources are synchronized on the same timeline. The last parameter, the NSL of an algorithm is defined as: N SL = 

SL

ni ∈CP

w(ni )

=

SL CP

The NSL is very important because it offers a good estimation of the performance of an algorithm since the Critical Path gives a lower bound to the schedule length. In order to evaluate the hybrid algorithm, we also analyzed the threshold T limit and its influence on the total schedule length. Usually, the threshold did not influence the total time, but in many cases varying the threshold value slightly resulted in a significant improvement in the overall schedule length over all processors. Usually, the main performance measure of an algorithm is the schedule length of its output schedule. Nevertheless, one must always take into account what the application is aimed at, if it requires immediate scheduling on the available resources, or if its priority is relatively low and therefore a scheduling estimation can be done during a longer period of time. 5.3

Test Scenarios

In practice, application complexity with respect to the computation cost and the communication cost can vary according to the nature of the application (computational intensive, communication intensive and mixed), for example satellite image processing or bio-imaging workflow applications. Therefore, a series of tests have been performed using the ICPDP on a variety of DAGs simulating the characteristics of real application workflows. The ICPDP algorithm has been tested using various complex configurations and using several values for the threshold T limit. The testing was concentrated mainly on bringing up the following characteristics of the ICPDP: – Performance relative to the other algorithms implemented: HLFET, ETF and MCP – Schedule length variation with the threshold Tlimit and the optimal interval for the threshold – Normalized Scheduled Length evaluation – Total time for obtaining the schedule – Load balancing statistics and Efficiency of resource utilization

1342

B. Simion et al.

During the testing process, many configurations have been tested in order to obtain an accurate view regarding the performance of the scheduling algorithm. After the preliminary tests, we expanded the testing to much larger DAGs containing a large number of tasks (up to 1000 tasks) and different levels of dependencies complexity and communication costs. We implemented a test generator called TestGen, in order to obtain certain types of DAGs frequently used in real applications. Usually, applications can be grouped in: computational intensive applications, communication intensive applications, both computational and communication intensive applications. The computational intensive applications have large processing times for the component tasks and reduced communication cost between tasks. Therefore, in this case it generates tasks with a high computational cost and a small number of dependencies with a reduced cost. On the other hand, communication intensive applications contain tasks with rather small processing times and significantly greater cost for the dependencies and/or a large number of dependencies among them. The mixed computational and communication intensive applications have both characteristics, requiring large processing times for their tasks and having large data dependencies on the dependency graph. The parameter used to characterize the type of application is called CCR (Communication-to-Computation Ratio). The CCR is defined as the ratio between the average communication cost and the average processing time. If this ratio is below 1 the application is considered computational intensive and if it is above 1 the application is communication intensive.

Fig. 2. Total time for the scheduling process

5.4

Comparative Evaluation

A. Analysis of the total time. As it can be deducted from figure 2, the ETF performs the worst with a total time much greater than any of the other algorithms, due to its higher time complexity. The other scheduling algorithms have quite similar values for the total time, ICPDP slightly better than MCP and HLFET.

A Hybrid Algorithm for Scheduling Workflow Applications

1343

Fig. 3. Total schedule length

B. Analysis of the total schedule length. Experiments performed using several test scenarios representing different application types suggest that ICPDP obtains the best schedule length from all implemented scheduling algorithms. The closest to it is MCP which has a slightly larger schedule especially when testing on a less communicational intensive application. Results are shown in figure 3. C. Evaluation of the threshold variation. Threshold evaluation was performed taking into consideration the number of tasks and the number of processors, in order to estimate the impact the threshold has upon the schedule length. A slight variation can cause significant changes in the total schedule, since a smaller threshold can cause another task to be allocated thus resulting in a little better or worse schedule in the long run. Furthermore, the results show that taking the T limit threshold somewhere between 0, 95 and 0, 99 generally results in better schedules than any of the other classic algorithms, better than MCP in particular. The chart in figure 4 shows the schedule length variation with the threshold on three test scenarios using 500 tasks and 10 processors: D. Normalized schedule length. The NSL is important offering a very good estimation of the algorithm performance since the sum of computation costs on the CP represents a lower bound on the schedule length. Such a lower bound is not possible to achieve, therefore the optimal schedule length is usually larger. Tests have been performed on DAGs with a number of nodes ranging from 100 to 1000 in a 50 nodes increment. The results obtained are presented in the graph from figure 5.

1344

B. Simion et al.

Fig. 4. Threshold influence on total schedule length

Fig. 5. Normalized schedule length evaluation

E. Load balancing and resource allocation efficiency. An important study of the schedule resulted from the implemented algorithms concerns the load balancing on the available resources, which is important in determining the degree of efficient resource usage. The list scheduling algorithms usually perform the worst regarding load balancing, the results from our tests show that in some cases a number of resources aren’t even used. Therefore, we concentrate on comparing the critical path based algorithms: MCP and ICPDP (figure 6). The results are represented using Gantt charts which represent the tasks mapped to each processor. Analyzing the results from table 1, it can be seen that ICPDP offers good load balancing, taking advantage the most of the resources it can use. MCP also

A Hybrid Algorithm for Scheduling Workflow Applications

1345

(a)

(b) Fig. 6. Gantt chart representing the schedule for the MCP (a) and ICPDP (b) algorithms

offers efficient distribution of tasks over the resources but it generates a slightly longer schedule. The number of tasks scheduled on each processor is in many cases not as relevant as the level of resource occupation. This means that one resource can be occupied for the whole schedule length with a small number of tasks which have very large computational costs, while another resource is occupied with very many tasks which have reduced processing times, both resources having the same degree of occupation. Therefore, in order to properly evaluate the efficiency we must represent the idle times per resource, that is the sum of all holes in the schedule on every

1346

B. Simion et al.

Table 1. Load balancing for MCP and ICPDP using 500 tasks and 10 processors MCP Algorithm Resource Id P1 P2 P3 P4 P5 P6 P7 No of tasks 57 54 51 56 51 43 48 ICPDP Algorithm Resource Id P1 P2 P3 P4 P5 P6 P7 No of tasks 54 54 55 57 52 45 47

P8 P9 P10 47 49 44 P8 P9 P10 44 50 42

Fig. 7. Resource usage efficiency - representation of wasted idle time (holes)

resource. As it can be deducted from the chart in figure 7, the ICPDP offers a better schedule regarding the total idle times, minimizing the size and number of the holes in the schedule, thus gaining valuable processing time for the utilized resources.

6

Conclusions and Future Work

Scheduling applications on wide-area distributed systems is useful for obtaining quick and reliable results in an efficient manner. Optimized scheduling algorithms are fundamentally important in order to achieve optimized resources utilization. The existing and potential applications include many fields of activity like satellite image processing and medicine. In this paper, we have presented the Grid scheduling issues, the stages in Grid scheduling and a general classification of schedulers with examples, the problems of DAG scheduling and the solutions that perform well in most cases. Further, we introduced an improved algorithm: ICPDP, with better performance concerning the schedule length, the total time needed for obtaining the tasks-to-resources mapping solution, a good load balancing and an efficient resource utilization. The testing has been conducted on several test scenarios representing different types of applications with respect to computational cost and communication

A Hybrid Algorithm for Scheduling Workflow Applications

1347

cost. Scheduling results were gathered from applications with up to 1000 tasks and a high dependencies complexity, in order to offer a good estimation of the hybrid algorithm performance. The ICPDP algorithm has demonstrated to offer the best schedule length over all resources in a slightly shorter time than the other scheduling algorithms. The complexity of the ICPDP is O(V 2 ), where V is the number of nodes. The polinomial complexity eliminates the need for aproximations or compromise in case of very large DAGs. Furthermore, the distribution of the tasks to the available resources has proved to accomplish good load balancing and efficient resource allocation by minimizing the idle times on the processing elements. The solution presented comes as an extension for tasks with dependencies to the genetic algorithms used in DIOGENES and as future work we intend to conduct further testing on MonAlisa farms using ApMon. Additional calibrations of the algorithm can be done and testing can be extended to different architectures and production Grids on SEEGRID and EGEE, like the MedioGrid cluster [1] and GridMOSI. Another idea is to develop a Web Service over the agent platform from DIOGENES in order to offer a transparent access to the scheduler.

References 1. Muresan, O., Pop, F., Gorgan, D., Cristea, V.: Satellite Image Processing Applications in MedioGRID. In: ISPDC 2006 (2006) 2. Mandal, A., Dasgupta, A., Kennedy, K., Mazina, M., Koelbel, C., Marin, G., Cooper, K., Mellor-Crummey, J., Liu, B., Johnsson, L.: Cluster Computing and the Grid. In: CCGrid 2004, IEEE International Symposium (2004) 3. Walton, D.: The Simulation of Dynamic Resource Brokering in a Grid Environment, B.Comp.Sc., Department of Computer Science, The University of Adelaide, South Australia (November 2002) 4. Foster, I., Kesselman, C.: The Grid: Blueprint for a New Computing Infrastructure. Morgan Kaufmann, San Francisco (1999) 5. Foster, I., Kesselman, C., Tuecke, S.: The Anatomy of the Grid: Enabling Scalable Virtual Organizations. International J. Supercomputer Applications (2001) 6. Dong, F., Akl, S.G.: Scheduling Algorithms for Grid Computing: State of the Art and Open Problems, Technical Report (2006) 7. El-Rewini, H., Lewis, T.G.: Scheduling parallel programs onto arbitrary target machines. J. Parallel Distrib. Comput. (June 1990) 8. Gerasoulis, A., Yang, T.: A comparison of clustering heuristics for scheduling DAGs on multiprocessors. J. Parallel Distrib. Comput. (December 1992) 9. Ibarra, O.H., Kim, C.E.: Heuristic algorithms for scheduling independent tasks on nonidentical processors. J. Assoc. Comput. Mach. 24(2), 280–289 (1977) 10. Fernandez Baca, D.: Allocating modules to processors in a distributed system. IEEE Trans. Software Engrg. 15(11), 1427–1436 (1989) 11. Shen, C.-C., Tsai, W.-H.: A graph matching approach to optimal task assignment in distributed computing system using a minimax criterion. IEEE Trans. Comput. 34(3), 197–203 (1985) 12. Kwok, Y.K., Ahmad, I.: Static Scheduling Algorithms for Allocating Directed Task Graphs to Multiprocessors. ACM Computing Surveys 31(4) (December 1999)

1348

B. Simion et al.

13. Ullman, J.: NP-complete scheduling problems. J. Comput. System Sci. 10 (1975) 14. Kafil, M., Ahmad, I.: Optimal task assignment in heterogeneous distributed computing systems. IEEE Concurrency 6(3), 42–51 (1998) 15. Adam, T.L., Chandy, K.M., Dickson, J.: A comparison of list scheduling for parallel processing systems. Comm. ACM 17 (December 1974) 16. Ahmad, I., Kwok, Y.K.: On parallelizing the multiprocessor scheduling problem. IEEE Trans. Parallel Distrib. Systems 11 (April 1999) 17. Yang, T., Gerasoulis, A.: List scheduling with and without communication delays. Parallel Comput. (1993) 18. MonALISA Web page (accessed on June 27, 2007), http://monalisa.cacr.caltech.edu 19. Hwang, J.J., Chow, Y.C., Anger, F.D., Lee, C.Y.: Scheduling precedence graphs in systems with interprocessor communication times. SIAM J. Comput. 18 (April 1999) 20. Wu, M.-Y., Gajski, D.D.: Hypercool: a programming aid for message-passing systems. IEEE Trans. Parallel Distrib. Systems (July 1990) 21. Kwok, Y.-K., Ahmad: Dynamic critical-path scheduling: An effective technique for allocating task graphs to multiprocessors. IEEE Trans. Parallel Distrib. Syst. 7 (1996) 22. Wu, M.-Y.: MCP revisited - Department of Electrical and Computer Engineering, The University of New Mexico 23. Iordache, G.V., Boboila, M.S., Pop, F., Stratan, C., Cristea, V.: A Decentralized Strategy for Genetic Scheduling in Heterogeneous Environments. In: GADA 2006, Montpellier, France, November(2-3) (2006) 24. El-Rewini, H., Lewis, T., Ali, H.: Task Scheduling in Parallel and Distributed Systems. Prentice Hall, Englewood Cliffs (1994) 25. Waldo: The Jini architecture for network-centric computing. Communications of the ACM (July 1999) 26. Gupta, R., Talwar, S., Agrawal, D.P.: Jini Home Networking: A Step toward Pervasive Computing. Computer, 34–40 (August 2002) 27. Venugopal, S., Buyya, R., Winton, L.: A Grid Service Broker for Scheduling Distributed Data-Oriented Applications on Global Grids. In: ACM International Conference Proceeding Series, vol. 76, pp. 75–80 (2004)