Tasks assignment for Grid computing Meriem Meddeber Belabbas ...

Int. J. Web and Grid Services, Vol.

Tasks assignment for Grid computing Meriem Meddeber Department of Mathematics and Computer Science, University of Mascara, Mascara, Algeria E-mail: [email protected]

Belabbas Yagoubi* Department of Computer Science, University of Oran, Oran, Algeria E-mail: [email protected] *Corresponding author Abstract: A grid computing environment involves cooperation and sharing resources among distributed machines. Users may dispatch their tasks to remote computing resources instead of just computing locally. Hence, task assignment is an important issue in a grid computing environment. It plays a crucial role in achieving high utilisation of resources. Due to heterogeneity of resources, assigning an application is significantly complicated and challenging task in grid system. Tasks assignment becomes much more complex when it comes to assign tasks with precedence constraints represented by a Directed Acyclic Graph (DAG). In this paper, we propose a dependent task assignment strategy for Grids. Keywords: dependent tasks; grid computing; tasks assignment; DAG; directed acyclic graph; grid model; GridSim. Reference to this paper should be made as follows: Meddeber, M. and Yagoubi, B. (2011) ‘Tasks assignment for grid computing’, Int. J. Web and Grid Services, Vol. Biographical notes: Meriem Medebber received her Master’s Degree from the University of Mascara in 2008 and currently, she is a Doctor candidate, at the University of Oran, Algeria. Her research interests include scheduling and load balancing in Grid computing. Belabbas Yagoubi holds Bachelor in Mathematics, Master and PhD in Computer Science. His current research interests include Grid/Cloud computing and load balancing in distributed systems. He is currently, an Associate Professor at the Faculty of Computer Science, Oran University, Algeria.

Copyright © 2011 Inderscience Enterprises Ltd.

428

M. Meddeber and B. Yagoubi

1 Introduction In the last few years there has been a rapid exponential increase in computer processing power, data storage and communication. But still there are many complex and computation intensive problems, which cannot be solved by supercomputers. These problems can only be met with a vast variety of heterogeneous resources. The increased use and popularity of the internet and the availability of high-speed networks have gradually changed the way that we do computing. These technologies have enabled the cooperative use of a wide variety of geographically distributed resources as a single more powerful computer. This new method of pooling resources for solving large-scale problems is known as Grid computing (Baker et al., 2000). One of the most complicated task in Grid computing is the allocation of resources for a process; i.e., assigning jobs to various resources. This may be a NP-Complete (Non-deterministic Polynomial time) problem. The issue of an assignment has generally asked the following question: “Which will be the best method of organising the workloads, so that it can be ended as fastest as possible?” (Ungurean, 2010). Task assignment is an integrated part of parallel and distributed computing. In Grids, resources belong to multiple administrative domains. The resources are requested by a Grid application, which use to computing, data and network resources, etc. However, assigning an application of a Grid system is absolutely more complex than assigning an application of a single computer. Because to get the resources information of single computer and assignment is easy, such as CPU frequency, number of CPU’s in a machine, memory size, memory configuration and network bandwidth and other resources connected in the system. But Grid environment is dynamic resources sharing and distributing. Then an application is hard to get resources information, such as CPU load, available memory, available network capacity, etc. And Grid environment is also hard to classify jobs characteristic, that run in the Grid (Murugesan and Chellappan, 2010). Tasks include independent and dependent tasks, to which dynamic and static assignment methods are applied, respectively. Generally, applications could be decomposed into some dependent tasks and be described as DAGs to take advantage of the parallelism and cooperation capability of the distributed system. But parallelisation is limited owing to the communication latency and the iteration-dependent requirements. Thus there should be a trade-off between maximal parallelisation and minimal communication cost. Assigning dependent tasks under distributed environments is a strong NP-complete problem. It is very difficult to solve the problem by approximate algorithms because there is too many factors need to be considered (He and Zhao, 2007). In this paper, we consider the task assignment problem with the following characteristics. The tasks are modelled using a DAG. We propose a assignment strategy of dependent and independent tasks in Grids, which has the advantage of being able to divide the input task graph into set of connected component to reduce the response time of system application. The strategy takes into account the clusters capacity, and try to meet the following objectives:

Tasks assignment for Grid computing

429

•

reducing, whenever possible, the average response time of tasks submitted to the Grid

•

respecting the constraints of dependency between tasks

•

reducing communication costs by using a static tasks assignment based on the connected components algorithm to minimise the delay cij between taski and taskj and by favouring a dynamic tasks placement within the cluster rather than the entire Grid.

The rest of this paper is organised as follows. Some related works are described in Section 2. In Section 3, we present some characteristics of Grid computing. A general presentation Of the DAG of tasks assignment is done in Section 4. The mapping of any Grid architecture into a forest is explained in Section 5. Section 6 describes the main steps of the associated assignment strategy. We evaluate the performance of our scheme in Section 7. Finally, Section 8 concludes the paper and gives some perspectives.

2 Related works There have been many heuristic algorithms proposed for the static and dynamic tasks assignment problem. Many of these algorithms apply only to the special case where the tasks are independent i.e., there are no precedence constraints (Leal et al., 2009; Salcedo-Sanz et al., 2006; Maheswaran et al., 1999; Camelo et al., 2011). Many heuristic algorithms have been proposed for static scheduling of dependent tasks where task precedence constraints are modelled as a DAG (Lin, 2011; Hirales-Carbajal et al., 2010). Qu et al. (2007), target dependent task models and propose three static schedulers that use different problem solving strategies. The first is a heuristic approach developed from traditional list based schedulers. It presents high efficiency but the least accuracy. The second is based on a full-domain search using constraint programming. It can guarantee to produce optimal solutions but requires significant searching effort. The last is a guided random search technique based on a genetic algorithm, which shows reasonable efficiency and much better accuracy than the heuristic approach. Boyer and Hura (2005), proposes a non-evolutionary Random Scheduling (RS) algorithm for efficient matching and scheduling of inter-dependent tasks in a DHC system. RS is a succession of randomised task orderings and a heuristic mapping from task order to schedule. Randomised task ordering is effectively a topological sort where the outcome may be any possible task order for which the task precedent constraints are maintained. However static tasks assignment is performed off-line, or in a predictive manner and can be used whenever the task information is known a priori such as at compile time of a parallelised application. Although the good results that this approaches provides, they stay limited to a static assignment. Large and non dedicated computing platforms as Grids may require dynamic task assignment methods to adapt to the run-time changes such as increases in the workload or resources, processor and link failures (Uçar et al., 2006; Murugesan and Chellappan, 2010).

430

M. Meddeber and B. Yagoubi

In Meddeber and Yagoubi (2010), We have proposed a hybrid assignment strategy for Grid computing. However, it does not take into account the resources capacity in the static assignment. In this paper, we address these issues.

3 Characteristics of a computational grid Grid is a fast evolving distributed computing architecture (Taniar and Goel, 2007). There are many desirable properties and features that are required by a Grid to provide users with a computing environment (Germain et al., 2000; Foster et al., 2001). They are as follows: •

Heterogeneity: Grid architecture is heterogeneous in nature (Goel et al., 2005); The Grid involves a number of resources that are varied in nature and can encompass a large geographical distance through various domains.

•

Scalability: The Grid should be tolerant to handle a large number of nodes without any performance degradation.

•

Adaptability or Fault Tolerant: In a Grid unexpected computational aborts, hardware or software faults etc., are high. These faults are generally handled by Resource Managers. Many works have been made in this sense (Uehara, 2011).

•

Security: All the user participating computers should be protected from any malicious manipulations or interventions.

Mobile device capabilities have been steadily increasing in the past years (Li and Li, 2010; Rodriguez et al., 2011). Researchers have identified several issues, such as energy consumption, that steam from using mobile devices because they are small computers that run on battery and can move outside of the wireless coverage area.

4 General presentation of the DAG of tasks assignment 4.1 Tasks properties We consider that tasks arrive randomly with a random computation length, an arrival time and precedence constraints. Urban et al. (2009) presented an approach for using incremental data changes known as deltas to dynamically discover data dependencies among concurrent processes that execute over autonomous Grid services. In our work, we generate randomly precedence constraints between tasks. Also, we believe that tasks can be executed on any Computing Element (CE) and each CE can only execute one task at each time point, the execution of a task cannot be interrupted or moved to another CE during execution. We also assume that a task cannot start execution before it gathers all of the messages from its parent tasks. The communication cost between two tasks assigned to the same processor is supposed to be zero.

Tasks assignment for Grid computing

431

4.2 Directed acyclic graph Partitioning a job into tasks can lead to dependent tasks. one task communicating with other tasks, and often one has to wait for others to be ready for communication (Taniar et al., 2008). There is three types of data dependencies: 1

Read-after-write

2

Write-after-read

3

Write-after-write

But only ‘Read-after-write’ is called true dependence. To represent a set of task and their dependencies we can use a DAG where the tasks are represented by nodes and the dependencies are represented by arcs. If starting the execution of the task B depends on terminating the execution of the task A then an arc (directed edge) from A to B exists in the associated DAG. Obviously, one task may depend on several other tasks. Figure 1, shows a task precedence graph constituted by five tasks, with one entry task T1 and three exit tasks T3 , T4 , T5 . Figure 1 Directed Acyclic graph (DAG)

4.3 Connected component A connected component CCk of the graph D = (V, E) is defined as a collection of dependent tasks with inter-task data dependencies. graph D can be divided into some disjoint subsets CC1 , CC2 , . . . , CCp such as CCk ⊆ D. Figure 2 shows a graph composed of three connected component.

4.4 Task dependency assignment algorithms Tasks’ dependencies have a major role in the design of assignment algorithms. The taxonomy of Grid assignment algorithms for dependent tasks is shown in Figure 3. In the sequel, by DAG assignment we denote the assignment of tasks with dependencies (Pop and Cristea, 2007).

432

M. Meddeber and B. Yagoubi

Figure 2 Example with three connected components

Figure 3 Taxonomy of task dependency assignment algorithms in grid environments

5 Mapping a Grid into a forest-based model 5.1 Grid topology From the topological point of view, a Grid computing is a set of clusters in a multi-nodes platform. Each cluster owns a set of worker nodes (storage and CEs) and belongs to a local domain, i.e., a Local Area Network (LAN). Every cluster is connected to the global network or World Area Network (WAN) by a switch. Figure 4 describes this topology (Yagoubi and Meddeber, 2010). Figure 4 Example of Grid topology

Tasks assignment for Grid computing

433

5.2 Mapping a Grid into a forest-based model The load balancing strategy proposed in this paper is based on mapping of any Grid architecture into a forest structure. This forest is built by aggregation as follows:

5.3 Basic model The basic model (Figure 5) represents a logical view of the smallest possible Grid, namely only one cluster. This model, is defined by a two levels tree. The leaves of this tree correspond to the nodes of the cluster. Its root, called Cluster Manager (CM), represents a virtual tree node associated with the cluster, of which role is to manage the cluster workload. Figure 5 Basic model associated to cluster

5.4 Generic model As illustrated by Figure 6, a Grid topology is represented as a forest structure by aggregating several basic models. Figure 6 Representation model of Grid

Level 0:

At this level, we find the Resource Broker to which every CM (CM) connects and the Grid clients send their tasks to the resource broker. The resource broker is responsible for:

434

Level 1:

Level 2:

M. Meddeber and B. Yagoubi •

receiving dependent and independent tasks from the Grid users

•

partitioning the waiting tasks into x connected component

•

duplicating some tasks if there is no cluster capable to receive the connected component

•

sending tasks among CMs.

Each cluster manager of this level is associated with a physical cluster of the Grid. In our load balancing strategy, this manager is responsible for: •

receiving connected components from the resource broker

•

duplicating some tasks if there is no CE capable to receive the connected component

•

sending tasks among CEs

•

maintaining the workload information related to each one of its CEs

•

estimating the workload of associated cluster and diffusing this information to other CMs

•

deciding to start a local load balancing, which we will call intra-cluster load balancing

•

sending the load balancing decisions to the CEs which they manage for execution

•

initiating a global load balancing, which we will call inter-clusters load balancing.

At this level, we find the computing elements of a Grid linked to their respective clusters. Each node at this level is responsible for •

maintaining its workload information

•

sending this information to its CM

•

performing the load balancing decided by its CM.

Remark: Although we have presented the nodes and the forest interconnection as virtual, each virtual node corresponds to a physical CE of which role is to manage the load of the cluster or Grid. For example, if a cluster contains N CEs then (N − 1) nodes will be used to perform the tasks and the N th node (considered as a virtual node in the model) manages the load of the cluster in question. This manager can either be dedicated or have a dual role (performing tasks and managing cluster).

5.5 Model characteristics The proposed model is characterised by the following:

Tasks assignment for Grid computing •

435

It facilitates the information flow through the Grid. We distinguish three types of information flows: 1

Ascending flow: This flow is related to the workload information flow to get current workload status of Grid resources.

2

Horizontal flow: It concerns the inputs used to perform load-balancing operations.

3

Descending flow: This flow concerns the resources broker decision and conveys the load balancing decisions made by CMs to their corresponding resources.

•

It supports heterogeneity and scalability of Grids: Connecting/disconnecting Grid resources correspond to adding/removing leaves or sub trees from the tree model.

•

It is totally independent of any physical Grid architecture.

6 Assignment strategy To reduce the global response time of the system and respect the tasks dependencies, this study proposed a tasks assignment policy. When a user sends his tasks, they will be assigned to appropriate CEs to achieve the goal of assignment. Our goal is to maximise the dependencies of tasks within each cluster and to minimise it between clusters. Initial phase is represented by an idle resource broker waiting for tasks to arrive in the Grid. Incoming tasks are lined up in the waiting queue initially empty. The tasks from the head of the Waiting queue are assigned one by one to the machines. Tasks assignment: The resource broker will assign tasks to CMs which will assign them to the different CE containing in the cluster. The resource broker (resp. cluster manager) will performs the following steps: •

Receives the state of each CM (resp. computing element)

•

Partition the tasks graph of all tasks waiting in the queue to x connected component by executing the connected component algorithm

•

Sends each connected component CCk to a CMi (resp. computing element CEj ), using one of the following method: 1

Selects the connected component CCk with the maximum length

2

Receives the average execution time of each CM (resp. computing element)

3

Sends the connected component to the CM (resp. computing element) which has the lowest execution time

436

M. Meddeber and B. Yagoubi 4

If the capacity of the CM (resp. computing element) is less than the size of the connected component, the resource broker (resp. cluster manager) must decompose the connected component to obtain different components with a smaller size. The graph partitioning (resp. connected component) is done by duplicating some tasks using the following steps:

5

•

Each connected component is decomposed on multiple levels where each level consists of independent tasks. Level 0, contains entry tasks (with no precedence constraints). Tasks of level 0 generate data files used as the inputs to the tasks in level 1. Figure 7 shows a connected component of 3 levels where level 0 consists of one task:

•

Browse the graph from the root to find a node (Ni ) which is characterised by [only one entry, more than one output (at least 2 output)]

•

Replicate the graph from the node (Ni ) to build several connected components such as: •

Each subtree successor of this node (Ni ) is a connected component

•

The subtree predecessor of this node (Ni ) is added to the first connected component. The result would be a set of connected components (see Figure 8).

Repeat the previous steps until the assignment of all connected components.

Figure 7 Connected component levels

Below the algorithm associated to the assignment of tasks.

Tasks assignment for Grid computing

437

Figure 8 Tasks replication example (see online version for colours)

Load Balancing: The system will be adjusted dynamically according to the clusters workload. In accordance with the structure of the proposed model, we distinguish between two load balancing levels: Intra-cluster (Inter-computing elements) and Inter-clusters (Intra-Grid) load balancing. It is natural to have different communication costs between clusters, because of the heterogeneity of WANs. However, in intra-cluster communication costs are the same, since each cluster has a network (LAN) providing similar bandwidths for all its CEs.

438

M. Meddeber and B. Yagoubi

6.1 Intra-cluster load balancing Depending on its current load, each CM decides to start a load balancing operation. In this case, the CM tries, in priority, to balance its workload among its CEs. At this level, communication costs are not taken into account in the task transfer since the CEs of the same cluster are interconnected by a LAN network, of which communication cost is constant. The CM receives periodically the execution time of each resource of the cluster and performs the next steps: •

In this step, each manager sorts the nodes table in ascending order relative to their execution time TEX. Lodi
+ T comj Spdi j=1 p

T exi =

(1)

where Tcom : Communication time of the dependencies transfer. P : Number of dependencies. The CM transmits some connected components from the overloaded node to the under loaded node and so on (Figure 9). •

Computes the execution time of cluster as follow: T exi =




T exij .

j∈R

•

Sends workload information of to other CMs.

Figure 9 Intra-cluster load balancing (see online version for colours)

(2)

Tasks assignment for Grid computing

439

6.2 Inter-clusters load balancing Each overloaded CM transfers connected components from its overloaded CE to under loaded clusters. In contrast to the intra-cluster level, we should consider the communication cost among clusters. Knowing the global state of each cluster, the overloaded CM can distribute its overloaded tasks between under-loaded clusters. The chosen under-loaded clusters are those that need minimal communication cost for transferring connected components from overloaded clusters. A connected components can be transferred only if the sum of its latency in the source cluster and cost transfer is lower than its latency on the receiver cluster. This assumption will avoid making useless task migration. We define a threshold β, such as: If T exi > T exk + β) then transfer some connected components from Ci to Ck until T exi ≤ T exk + β.

7 Experimental study GridSim (Buyya and Murshed, 2002) has been used to create the simulation environment. The inputs to the simulations are total number of Gridlets, average MI of Gridlets. The MIPS of each resource is also specified. GridSim is used in different studies (Flahive et al., 2009). The performance of our strategy has been compared with HEFT (Topcuoglu et al., 2002) algorithm. The HEFT algorithm has two phases: a task prioritising phase, where the upward rank attribute is computed for each task and a task list is generated by sorting the tasks in decreasing order of the upward rank. The second phase is the machine selection phase, where tasks are selected in order of their priorities and are scheduled to the best machine that minimises the task finish time in an insertion based manner. This paper adopts GridSim to simulate the strategy of tasks assignment given above. GridSim provides a series of core function for the establishment and simulation of heterogeneous distributed computing environment, particularly suitable for simulation and research of task scheduling on Grid (Selvaran et al., 2010). We simulated a Grid computing platform with 2, 4, 6, 8, 10 clusters. We have generated dependent and independent tasks of number of 100, 200, 400, 600, 800, 1000, 2000. We supposed that each cluster involves 30 CEs. For each node we randomly generate associated speed varying between 5 and 30 MIPS. We also generate randomly precedence constraints between tasks. Table 1 shows the results of the simulation. From the above table it can be seen that the proposed strategy allowed to reduce in a very clear way the average response time of tasks. We obtain a gain varying between 2% and 90%. Figure 10 illustrates the improvement of the mean response time for four clusters:

440

M. Meddeber and B. Yagoubi

Table 1 Simulation results No. tasks

No. clusters

2

4

6

8

10

100

HEFT Our strategy Gain

290464 72070 75%

53718 3616 93%

103168 56184 45%

76342 74996 17%

59704 34858 41%

200

HEFT Our strategy Gain

1287316 200242 84%

486850 328042 90%

381442 335830 80%

311428 167172 46%

145618 40484 72%

400

HEFT Our strategy Gain

5913456 3258700 44%

2465990 2291830 90%

718012 429500 56%

1331782 833474 62%

884340 194038 78%

600

HEFT Our strategy Gain

12332870 8676588 29%

5912542 2679792 54%

4494312 498488 80%

1860650 933266 50%

2091732 1953062 66%

800

HEFT Our strategy Gain

20440142 16426624 19%

6188550 2996620 51%

4200090 3695354 12%

4447120 3372422 24%

3687465 2822994 23%

1000

HEFT Our strategy Gain

25425340 6073052 76%

23643074 19658900 16%

4294508 2718603 36%

6996562 6979880 2%

5838096 4915094 15%

2000

HEFT Our strategy Gain

1346394 5454608 90%

663386414 41624936 34%

33161388 19160774 42%

26882992 7799554 57%

22908334 21346986 7%

Figure 10 Waiting time results (see online version for colours)

We observe that our strategy reduce considerably the average waiting time of tasks submitted to the system. When increasing the tasks number, response time benefits increase.

8 Conclusion In this paper, we have proposed a tasks assignment strategy in Grids, which has the advantage of being able to divide the input task graph into set of connected

Tasks assignment for Grid computing

441

component to reduce the response time of system application. This strategy meets the following objectives: •

Reducing, whenever possible, the average response time of tasks submitted to the Grid.

•

Respecting the constraints of dependency between tasks.

•

Reducing communication costs by using a static tasks placement based on the connected components algorithm to minimise the delay cij between tasks i and j and by favouring a dynamic tasks placement within the cluster rather than the entire Grid.

•

It take into account the resources capacity in the static assignment. To test and evaluate the performance of our model, we developed our strategy under the GridSim simulator written in Java. We have randomly generated clusters with different characteristics and a set of dependent tasks. Comparing with the HEFT algorithm, the first experimental results are encouraging since we can significantly reduce the average response time and the average waiting time.

In future we want to improve the proposed strategy by integrating the multi-agent systems. We will also define other metrics of performance to evaluate and compare our approach with other already existing. To measure the efficiency of the strategy, we plan to compare its performance with other Grid simulators such as SimGrid (Legrand et al., 2003), HyperSim (Xhafa et al., 2009) . We also plan to integrate our strategy to the middleware GLOBUS (Foster, 2005; Xhafa et al., 2010).

References Baker, M.A., Buyya, R. and Laforenza, D. (2000) ‘The Grid: international efforts in global computing’, SSGRR 2000 The Computer and eBusiness Conference, l’Aquila, Italy. Boyer, W.F. and Hura, G.S. (2005) ‘Non-evolutionary algorithm for scheduling dependent tasks in distributed heterogeneous computing environments’, J. Parallel Distrib. Comput., Vol. 65, pp.1035–1046. Buyya, R. and Murshed, M. (2002) ‘Gridsim: a toolkit for the modeling and simulation of distributed resource management and scheduling for grid computing’, The Journal of Concurrency and Computation: Practice and Experience (CCPE), Vol. 14, pp.13–15. Camelo, M., Donoso, Y. and Castro, H. (2011) ‘MAGS – an approach using multi-objective evolutionary algorithms for grid task scheduling’, International Journal Of Applied Mathematics And Informatics, Vol. 5, No 2, pp.117–126. Flahive, A., Taniar, D., Rahayu, W. and Apduhan, B. (2009) ‘Ontology tailoring in the Semantic Grid’, Computer Standards and Interfaces, Vol. 31, No. 5, pp.870–885. Foster, I., Kesselman, C. and Tuecke, S. (2001) ‘The anatomy of the grid: enabling scalable virtual organizations’, International Journal of High Performance Computing Applications, Vol. 15, No. 3, pp.200–222. Foster, I. (2005) ‘Globus toolkit version 4: software for service oriented systems’, IFIP: International Conference on Network and Parallel Computing, Beijing, China.

442

M. Meddeber and B. Yagoubi

Germain, C., Nri, V., Fedak, G. and Cappello, F. (2000) ‘Xtrem web : building an experimental platform for global computing’, Grid2000 (Worshop in HIPC2000), Bangalore India. Goel, S., Sharda, H. and Taniar, D. (2005) ‘Replica synchronisation in grid databases’, International Journal of Web and Grid Services, Vol. 1, No. 1, pp.87–112. He, k. and Zhao, Y. (2007) ‘Clustering and scheduling method based on task duplication’, Wuhan University Journal of Natural Sciences, Vol. 12, No. 2, pp.260–266. Hirales-Carbajal, A., Tchernykh, A., Roblitz, T. and Yahyapour, R. (2010) ‘A grid simulation framework to study advance scheduling strategies for complex workflow applications’, IEEE International Symposium on Parallel and Distributed Processing, Workshops and PhD Forum (IPDPSW), Atlanta, GA. Leal, K., Huedo, E. and Llorente, I.M. (2009) ‘A decentralized model for scheduling independent tasks in Federated Grids’, Future Generation Comp. Syst., Vol. 25, pp.840–852. Legrand, A., Marchal, L. and Casanova, H. (2003) ‘Scheduling distributed applicaitons: The simgrid simulation framework’, Proceedings of the 3rd IEEE/ACM International Symposium on Cluster Computing and the Grid (CCGRID’03), Tokyo, Japan. Li, C. and Li, L. (2010) ‘Energy efficient resource management in mobile grid’, Mobile Information Systems, Vol. 6, No. 2, pp.193–211. Lin, J.F. (2011) ‘Scheduling parallel tasks with intra communication overhead in a grid computing environnment’, International Journal of Innovative Computing, Information and Control, Vol. 7, No. 2, pp.881–896. Maheswaran, M., Ali, S., Siegel, H.J., Hensgen, D. and Freund, R.F. (1999) ‘Dynamic mapping of a class of independent tasks onto heterogeneous computing systems’, J. Parallel Distrib. Comput., Vol. 59, pp.107–121. Meddeber, M. and Yagoubi, B. (2010) ‘Dynamic dependent tasks assignment for grid computing’, Lecture Notes in Computer Science, Springer, Berlin, Heidelberg, Vol. 6082, pp.112–120. Murugesan, G. and Chellappan, C. (2009) ‘An economic-based resource management and scheduling for grid computing applications’, Proceedings of the World Congress on Engineering and Computer Science, Vol. I, San Francisco, CA. Pop, F. and Cristea, V. (2007) ‘Intelligent strategies for DAG scheduling optimization in grid environments’, Proceedings of the 16th international conference on control systems and computer sciences, Bucharest, pp.98–103. Qu, Y., Soininen, J-P. and Nurmi J. (2007) ‘Static scheduling techniques for dependent tasks on dynamically reconfigurable devices’, Journal of Systems Architecture, Vol. 53, pp.861–876. Rodriguez, J.M., Zunino, A. and Campo, M. (2011) ‘Introducing mobile devices into Grid systems: a survey’, International Journal of Web and Grid Services, Vol. 7, No. 1, pp.1–40. Salcedo-Sanz, S., Xu, Y. and Yao, X. (2006) ‘Hybrid meta-heuristics algorithms for task assignment in heterogeneous computing systems’, Computers and OR, Vol. 33, pp.820–835. Selvaran, S., Sudha, G. and Kingsy, G. (2010) ‘Static heuristic task scheduling in tree based Environment’, IJCSNS International Journal of Computer Science and Network Security, Vol. 10, No. 6, pp.63–70. Taniar, D. and Goel, S. (2007) ‘Concurrency control issues in Grid databases’, Future Generation Computer Systems, Vol. 23, No. 1, pp.154–162. Taniar, D., Leung, C., Rahayu, W. and Goel, S. (2008) High Performance Parallel Database Processing and Grid Databases, John Wiley and Sons, Hoboken NJ, USA.

Tasks assignment for Grid computing

443

Topcuoglu, H., Hariri, S. and Wu, M.Y. (2002) ‘Performance-effective and low-complexity task scheduling for heterogeneous computing’, IEEE Transactions on Parallel and Distributed Systems, Vol. 13, No. 3, pp.260–274. Uehara, M. (2011) ‘Composite RAID for rapid prototyping data grid’, International Journal of Web and Grid Services, Vol. 7, No. 1, pp.58–74. Urban, S.D., Xiao, Y., Blake, L. and Dietrich, S.W. (2009) ‘Monitoring data dependencies in concurrent process execution through delta-enabled grid services’, International Journal of Web and Grid Services, Vol. 5, No. 1, pp.85–106. Uçar, B., Aykanat, C., Kaya, K. and Ikinci, M. (2006) ‘Task assignment in heterogeneous computing systems’, J. Parallel Distrib. Comput., Vol. 66, pp.32–46. Ungurean, L. (2010) ‘Job scheduling algorithm based on dynamic management of resources provided by grid computing systems’, Electronis and Electrical Engineering, No. 7, pp.57—60. Yagoubi, B. and Meddeber, M. (2010) ‘Distributed load balancing model for grid computing’, Revue Africaine de la Recherche en Informatique et Math´ematiques Appliquées (ARIMA), Vol. 12, pp.43–60. Xhafa, F., Barolli, L. and Martos, D. (2009) ‘A web interface for the HyperSim-G Grid simulation package’, International Journal of Web and Grid Services, Vol. 5, No. 1, pp.17–29. Xhafa, F., Paniagua, C., Barolli, L. and Caball´e, S. (2010) ‘A parallel grid-based implementation for real-time processing of event log data of collaborative applications’, International Journal of Web and Grid Services, Vol. 6, No. 2, pp.124–140.