Skip to main content
Journal of Advanced Research logoLink to Journal of Advanced Research
. 2014 Nov 26;6(6):987–993. doi: 10.1016/j.jare.2014.11.010

Sort-Mid tasks scheduling algorithm in grid computing

Naglaa M Reda a, A Tawfik b, Mohamed A Marzok b,⁎, Soheir M Khamis a
PMCID: PMC4642166  PMID: 26644937

Abstract

Scheduling tasks on heterogeneous resources distributed over a grid computing system is an NP-complete problem. The main aim for several researchers is to develop variant scheduling algorithms for achieving optimality, and they have shown a good performance for tasks scheduling regarding resources selection. However, using of the full power of resources is still a challenge. In this paper, a new heuristic algorithm called Sort-Mid is proposed. It aims to maximizing the utilization and minimizing the makespan. The new strategy of Sort-Mid algorithm is to find appropriate resources. The base step is to get the average value via sorting list of completion time of each task. Then, the maximum average is obtained. Finally, the task has the maximum average is allocated to the machine that has the minimum completion time. The allocated task is deleted and then, these steps are repeated until all tasks are allocated. Experimental tests show that the proposed algorithm outperforms almost other algorithms in terms of resources utilization and makespan.

Keywords: Grid computing, Heuristic algorithm, Scheduling, Resource utilization, Makespan

Introduction

Grid computing systems [1], [2] are distributed systems, enable large-scale resource sharing among millions of computer systems across a worldwide network such as the Internet. Grid resources are different from resources in conventional distributed computing systems by their dynamism, heterogeneity, and geographic distribution. The organization of the grid infrastructure involves four levels. First: the foundation level, it includes the physical components. Second: the middleware level, it is actually the software responsible for resource management, task execution, task scheduling, and security. Third: the services level, it provides vendors/users with efficient services. Fourth: the application level, it contains the services such as operational utilities and business tools.

The scheduling has become one of the major research objectives, since it directly influences the performance of grid applications. Task scheduling [3] is the main step of grid resource management. It manages jobs to allocate appropriate resources by using scheduling algorithms and polices. In static scheduling, the information regarding all the resources as well as all the tasks is assumed to be known in advance, by the time the application is scheduled. Furthermore, each task is assigned once to a resource. While in dynamic scheduling, the task allocation is done on the go as the application executes, where it is not possible to find the execution time. Tasks are entering dynamically and the scheduler has to work hard in decision making to allocate resources. The advantage of the dynamic over the static scheduling is that the system does not need to posse the run time behavior of the application before it runs.

Since the late nineties, several heuristic algorithms for grid task scheduling (GTS) [4], [5], [6] have been developed to improve grid performance. They are classified into task algorithms in which all tasks can be run independently and DAG algorithms, where a DAG represents the partial ordering dependence relation between tasks execution.

The main contribution of this work is to introduce an efficient heuristic algorithm for scheduling tasks to resources on computational grids with maximum utilization and minimum makespan. The proposed algorithm (Sort-Mid) depends on the minimum completion time and the average value AV of completion times for each task. It puts constrains to map the most appropriate task to the best convenient resource, which increases the grid efficiency. Performance tests show a good improvement over existing popular scheduling algorithms.

The most popular task GTS algorithms are surveyed in the following subsection. The rest of this paper is organized as follows. The proposed methodology with the suggested algorithm for the scheduling problem in grid computing system is introduced. Then, the used experimental materials followed by results and discussion are presented. Finally, the conclusion of the overall work is given.

Related work

Opportunistic load balancing (OLB) algorithm [7] assigns each task in arbitrary order to the next available machine regardless of the task’s expected execution time on the machine, while, minimum execution time (MET) algorithm [8] assigns each task in arbitrary order to the machine with the minimum execution time without considering resource availability. But, minimum completion time (MCT) algorithm [8] assigns each task in arbitrary order to the machine with the earliest completion time. On the other hand, Min-Min algorithm [9], [10] selects the machine with minimum expected completion time and assigns task with the MCT to it. Where, Max-Min algorithm [9], [10] selects the machine with minimum expected completion time and the task with the maximum completion time is mapped to it. And, switching algorithm (SA) [9] combines MCT and MET to overcome some limitations of both methods.

Furthermore, Suffrage heuristic [9] maps the machine to the task that would suffer most in terms of expected completion time according to an evaluated suffrage value. Switcher heuristic [11] switches between the Max-Min and Min-Min algorithms by taking a scheduling decision based on the standard deviation of minimum completion time of unassigned jobs. RASA heuristic [12] has built a matrix representing the completion time of each task on every resource, and applies Min-Min if the number of available resources is odd, otherwise it applies Max-Min. Min-mean heuristic [13] reschedules the Min-Min produced schedule by considering the mean makespan of all the resources. Load balanced Min-Min (LBMM) heuristic [14] has reduced the makespan and has increased the resource utilization by choosing the resources with heavy load and reassigns them to the resources with light load. Mact-mini heuristic [15] maps the task with the maximum average completion time to the machine with minimum completion time. Recently, a new heuristic algorithm based on Min-Min has been presented [16]. It selected resources according to a new makespan value and the maximum value of possibilities tasks (MVPT).

Methodology

In this section, we present a new idea for solving the scheduling problem in a grid. Scheduling is the main step of grid machines management [17]. Machines may be homogeneous or heterogeneous. A grid scheduler selects the best machine to a particular job and submits that job to the selected machine [18]. The main aim of suggested heuristic algorithm for scheduling a set of tasks on a computational grid system is to maximize the machines utilization and to minimize the makespan. Given a grid G with a finite number, m, of machines (resources); M1, M2, ... , Mm, m > 1. Let T be a finite nonempty set of n tasks; T1, T2, ... , Tn, n > 1 that needs to be executed in G.

In the following work, the proposed algorithm called Sort-Mid is given. It’s steps to assign each task to a suitable machine are summarized below. It uses assignment function S: T → G which is defined as follows. For every positive integer i ⩽ n; ∃ a positive integer j ⩽ m s.t. S (Ti) = Mj. The first step is to sort the completion times (SCT) of each task Ti in T in increasing order. The introduced scheduling decision is based on computing the average value AV of two consecutive completion times in SCT for each Ti. AV is computed by (SCTK + SCTK+1)/2, where k=⌈m/2⌉. In the second step, the task having the maximum AV is selected. In the third step, the task is assigned to the machine possessing minimum completion time. Next, the assigned task is deleted from T. Finally, the waiting time for the machine that executes this task is updated. These steps are repeated until all n tasks are scheduled on m machines. The pseudo code of the algorithm is as listed below.

Algorithm Sort-Mid:
Input: Number of tasks n, Number of machines m, Grid G = {M1, M2, ... , Mm}, Tasks T = {T1, T2, ... , Tn}, Machines availability R; Estimated time of computation ETC.
Output: The result of the assignment function S: S(T1), S(T2), … , S(Tn).
Begin
Initialization: A ← {1, 2, … , n}, K ← ⌈m/2⌉, CT ← ETC;
1. WhileA ≠ Ø do
2.  If |A| ≠ 1 Then
3. Max_value ← 0, Index_machine ← 0, Index_task ← 0;
4. For all i ∈ Ado
5.  SCT ← sort CT[i] in ascending order;
6.   AV ← (SCTK + SCTK+1) / 2;
7.  IfAV > Max_valueThen
8.   Max_value ← AV;
9.   Index_task ← i;
10.   Index_machine ← index of machine whose completion time equals SCT1;
11. End If
12. End For
13.  S(TIndex_task) ← MIndex_machine;
14. A ← A − {Index_task};
15.  RIndex_machine(RIndex_machine + ECTIndex_task,Index_machine;
16. For all i ∈ Ado
17.  CTi,Index_machine ← ECTi,Index_machine + RIndex_machine;
18. End For
19. Else
  Assign the remaining task to the machine having the minimum completion time and delete it;
20.     Update waiting time of machine executing it;
21.   End If
22.  End While
End.

It is clear that Sort-Mid algorithm is correct, since at the end, the set of tasks indices are vanished, i.e., all tasks are assigned to appropriate machines.

In the following, we analyze the time complexity of the above given algorithm.

Lemma

The time complexity of Algorithm Sort-Mid is in O(n2m log n), where n and m are the numbers of tasks and machines in a grid computing system, respectively.

Proof

It is obvious that the first For-loop starting from step 4 to step 12 iterates n time. Each iteration costs at least (m log m), which is one run of step 5 to sort the elements at row number i of CT in an ascending order. Also, the second For-loop starting from step 16 to step 18 which updates the wait time, costs O (n). □

And, one run to select task and delete it and update time take n + m + n, respectively. Since the while-loop (Starting from step 1 to step 22) executes n time, each run of them costs of (nm log m + 2n + m). This implies that the total time complexity of the algorithm is in O (n2m log n).

An illustrative example

To clarify how the proposed algorithm Sort-Mid schedules tasks perfectly, consider the following example for a grid environment with three machines and three tasks. Its ETC matrix with special form is given in Fig. 1.

Fig. 1.

Fig. 1

The matrix ETC of the given.

The initialization step initializes the CT by ETC and machines availability vector R by zeros.

At first iteration, Max_value = Index_machine = Index_task = 0 and A = {1, 2, 3}, then the number of elements |A| = 3, and the created SCT after sorting illustrates as follows.

SCT=M3:22M2:23M1:45M3:22M1:45M2:70M3:23M1:25M2:63

For the first row of SCT, the average value (AV) of the first task is AV (1) = (SCT2 + SCT3)/2 = (23 + 45)/2. After that, the new value 34 is compared with the value of Max_value = 0, so the Max_value = 34, Index_task = 1 and Index_machine = 3.

For the second row, the average value is AV (2) = (SCT2 + SCT3)/2 = (45 + 70)/2. Then after comparison, Max_value = 57.5, hence Index_task = 2 and Index_machine = 3.

For the third row, the average value AV (3) = (SCT2 + SCT3)/2 = (25 + 63)/2. And, the values of Max_value are still maximum value, Index_task and Index_machine will not change.

At the end of the first iteration, the task having Index_task (= 2) is deleted from the set A, then A = {1, 3}. And R3 = 0 + 22 = 22. And so, CT updates to the following matrix:

CT=M1:45M2:23M3:44M1:25M2:63M3:45

At the second iteration for while-loop, first put Max_value = Index_machine = Index_task = 0, A = {1, 3} and |A| = 2. Then, SCT is arranged as follows:

SCT=M2:23M3:44M1:45M1:25M3:45M2:63

For the first row, the average value of the first task is AV (1) = (SCT2 + SCT3)/2 = (44 + 45)/2 in SCT. After comparing 44.5 with 0, then Max_value = 34, Index_task = 1 and Index_machine = 2.

For the second row, AV (3) = (SCT2 + SCT3)/2 = (45 + 63)/2. Then Max_value = 54, Index_task = 3 and Index_machine = 1.

At the end of second iteration, the task with index Index_task (= 3) is deleted and A = {1}, R1 = 0 + 25 = 25, CT

CT=M1:70M2:23M3:44

In the third iteration, A = {1} and |A| = 1, so the task with index 1 is assigned to the machine having the minimum completion time M2. i.e., Index_task = 1 and Index_machine = 2.

Finally, at the end of third iteration, the remaining task is deleted, then A = Ø. And R2 = 0 + 23 = 23.

As a result of the above execution, the makespan for the above example equals Max (22, 25 and 23) = 25. The makespan produced by other previous algorithms compared to the result of Sort-Mid algorithm is shown in Table 1.

Table 1.

A comparison between algorithms in makespan and tasks scheduling.

Algorithms M1 M2 M3 Makespan
MET T1, T2, T3 67
OLB T1 T2 T3 70
MCT T3 T1, T2 44
Max-Min T1 T2, T3 45
Min-Min T3 T1, T2 44
Sort-Mid T3 T1 T2 25

Experimental materials

For comparison of our proposed heuristic with other scheduling algorithm, various heuristic algorithms have been developed to compare with Sort-Mid algorithm. In this section, the benchmark description is given, and the ETC model used as in benchmark experiments [14], [15], [16], [17], [18], [19], [20] is specified.

In this paper, we used the benchmark model [4]. The simulation model is based on expected time to compute (ETC) matrix for 512 tasks and 16 machines. An ETC matrix is said to be consistent (C) if whenever a machine mj executes any task ti faster than machine mk, then machine mj executes all tasks faster than machine mk. In contrast, inconsistent matrices (I) characterize the situation where machine mj may be faster than machine mk for some tasks and slower for others. Semi-consistent matrices (S) happen when some machines are consistent while others are inconsistent. Also, different ETC matrix task and machine heterogeneity are studied, each one has two cases high (hi) or low (lo). Thus, the twelve matrices are tested and abbreviated as shown in Table 2.

Table 2.

The ETC model.

Consistency Heterogeneity
Task (High) Task (Low)
Machine
Machine
High Low High Low
Consistent C_hihi C_hilo C_lohi C_lolo
Inconsistent I_hihi I_hilo I_lohi I_lolo
Semi-consistent S_hihi S_hilo S_lohi S_lolo

In addition, a computer program in VB language is developed for seven existing and proposed heuristic methods mentioned above. This program produces a schedule that maps tasks to available resources and calculates the objectives based on the ETC matrix supplied to it. The twelve different ETC matrices suggested by Braun et al. [4] for different scenarios mentioned in Table 2 are used as inputs to the computer program, and the results are analyzed in the following section.

Results and discussion

There are several performance metrics to evaluate the quality of a scheduling algorithm [3]. This section tests Sort-Mid algorithm mentioned in Section ‘Methodology’ according to these criteria. It considers the problem of scheduling n tasks on a heterogeneous grid system of m machines. It presents in the following a comparison of most recent and efficient algorithms against Sort-Mid in regard to each criterion for emphasizing its strength. In the following, we compare our heuristic algorithm with other scheduling algorithms via using benchmark experiments [4], [19].

Computational complexity

The complexity is an essential metric in theoretical analysis of algorithms that asymptotically estimate their performance. It determines the amount of time to solve the given computational problem using selected mathematical notation such as the Big O. In our case, it indicates how fast the scheduling algorithm will be in finding a feasible solution in a highly dynamic heterogeneous grid system. Table 3 illustrated the complexity of Sort-Mid algorithm and other important ones. It is worth to remark that the number of machines in a grid m is much less than the number of tasks n and so log m. Therefore, in practical, the running time of Sort-Mid algorithm is approximately equal to the running time of Max-Min, Min-mean, Min-Min and suffrage algorithm.

Table 3.

Complexity comparison for Sort-Mid with other algorithms.

Algorithm MET OLB Mact-min Max-min Min-mean Min-Min Suffrage Sort-Mid
Complexity O(nm) O(nm) O(nm) O(n2m) O(n2m) O(n2m) O(n2m) n2m log m

Resource utilization

The grid’s resource utilization is the most essential performance metric for grid managers. The Machine’s Utilization (MU) is defined as the amount of time at which a machine is busy in executing tasks, while the grid’s resource utilization (GU) is the average of machines’ utilization. They are computed as follows:

GU=∑j=1mMUjm

where,

MUj=rjmakespan,forj=1,2,…,m.

Fig. 2 and Table 4, Table 5, Table 6 show the values of GUs for the eight mentioned algorithms. Sort-Mid gives the second maximum resource utilization for ten instances and third maximum resource utilization for two instances. The Max-Min gives the highest maximum resource utilization for all instances but the difference is very small, while the computed makespan of Sort-Mid algorithm is better than that of Max-Min in all instances.

Fig. 2.

Fig. 2

A comparison of the GU values for 12 instances.

Table 4.

Grid’s resource utilization (consistent instance).

C_hihi C_hilo C_lohi C_lolo
Sort-Mid 0.99432 0.99542 0.9853 0.996616
Min-Min 0.89648 0.94337 0.8823 0.941213
Max-min 0.99882 0.99950 0.9989 0.999504
Suffrage 0.94325 0.97425 0.9595 0.976099
MET 0.0625 0.0625 0.0625 0.0625
MCT 0.95386 0.97069 0.9690 0.95151
OLB 0.94671 0.92035 0.9285 0.923213
LJFR-SJFR 0.96715 0.97862 0.9728 0.980576

Table 5.

Grid’s resource utilization (inconsistent instance).

I_hihi I_hilo I_lohi I_lolo
Sort-Mid 0.98453 0.99326 0.9756 0.991719
Min-Min 0.84491 0.93694 0.9179 0.953698
Max-Min 0.99367 0.99819 0.9959 0.998497
Suffrage 0.91986 0.97672 0.9744 0.955264
MET 0.62863 0.75058 0.5366 0.740376
MCT 0.93287 0.95978 0.9496 0.965665
OLB 0.95119 0.95589 0.9340 0.979608
LJFR-SJFR 0.97782 0.98267 0.9819 0.978605

Table 6.

Grid’s resource utilization (semi-consistent instance).

S_hihi S_hilo S_lohi S_lolo
Sort-Mid 0.9874 0.9941 0.9799 0.9888
Min-Min 0.87799 0.92539 0.8868 0.924657
Max-Min 0.99875 0.99917 0.9938 0.999145
Suffrage 0.96339 0.95712 0.9663 0.951159
MET 0.11088 0.12048 0.1219 0.124449
MCT 0.92827 0.93834 0.9539 0.951856
OLB 0.96709 0.92459 0.962 0.951005
LJFR-SJFR 0.98550 0.98387 0.9824 0.981659

Makespan

The makespan is an important performance criterion of scheduling heuristics in grid computing systems. It is defined as the maximum completion time of application tasks executed on grid resources. Formally, it is computed by using the following equation. Note that C is the matrix of the completion times after executing given tasks in grid computing system and R is the vector of waiting times of m machines.

Makespan=max{cij|∀1⩽i⩽n,1⩽j⩽m},or
Makespan=max{rj|∀1⩽j⩽m}.

The makespan of the scheduling algorithms for the twelve different instances of the ETC matrices is shown in Table 7, Table 8, Table 9, Table 10. Furthermore, Fig. 3 illustrates a comparison of the makespan between Sort-Mid and other algorithms for the above case study. In addition, Table 11 gives the rank of all heuristics based on grid’s resources utilization and makespan value of respective schedule for different instances.

Table 7.

Makespan values of high task, high machine heterogeneity in case of C, I, and S benchmark models, respectively.

C_hihi I_hihi S_hihi
Sort-Mid 9683148.7 3724452.312 5632995.76
Min-Min 9037587.109 4024444.672 5377382.055
Max-Min 12255384.79 7146473.427 9213627.859
Suffrage 11990851.28 4809887.958 7442261.93
MET 47472299.43 4508506.792 25162058.14
MCT 11422624.49 4413582.982 6693923.896
OLB 14376662.18 26102017.62 19464875.91
LJFR-SJFR 12368381.53 6129579.87 8295806.53

Table 8.

Makespan values of high task, low machine heterogeneity in case of C, I, and S benchmark models, respectively.

C_hilo I_hilo S_hilo
Sort-Mid 175920.6628 87965.99592 116233.14
Min-Min 166828.8663 83379.01434 110333.114
Max-Min 207680.683 143476.485 167058.1754
Suffrage 188756.6255 99838.9465 136540.7513
MET 1185092.969 96610.48102 605363.7727
MCT 185887.4041 94855.91348 126587.5914
OLB 221051.8236 272785.2008 250362.1138
LJFR-SJFR 200846.4618 128909.6339 153719.3364

Table 9.

Makespan values of low task, high machine heterogeneity in case of C, I, and S benchmark models, respectively.

C_lohi I_lohi S_lohi
Sort-Mid 325366.0837 134330.3048 169284.5168
Min-Min 291711.0926 124644.635 153307.7354
Max-min 398822.906 255370.7475 272001.9739
Suffrage 397193.1733 140382.7428 179748.7113
MET 1453098.004 185694.5945 674689.5356
MCT 378303.6246 143816.0937 186151.2863
OLB 477357.0195 833605.6545 603231.4673
LJFR-SJFR 390605.4791 212557.6419 246246.4265

Table 10.

Makespan values of low task, low machine heterogeneity in case of C, I, and S benchmark models, respectively.

C_lolo I_lolo S_lolo
Sort-Mid 5884.438158 3041.923489 4008.148616
Min-Min 5670.939533 2835.886811 3943.347953
Max-min 7020.853442 4967.738767 6176.0686
Suffrage 6052.637899 2947.256655 4081.267844
MET 39582.29732 3399.284768 21042.41343
MCT 6360.054945 3137.350329 4436.117532
OLB 7306.595595 8938.026908 8938.389213
LJFR-SJFR 6767.322547 4321.483534 5584.607333

Fig. 3.

Fig. 3

Makespan comparison for 12 instances.

Table 11.

Rank of heuristics based on resources utilization and makespan.

Grid’s resources utilization
Makespan
I II III I II II
C_hihi Max-Min Sort-Mid LJFR-SJFR Min-Min Sort-Mid MCT
C_hilo Max-Min Sort-Mid LJFR-SJFR Min-Min Sort-Mid MCT
C_lohi Max-Min Sort-Mid LJFR-SJFR Min-Min Sort-Mid MCT
C_lolo Max-Min Sort-Mid LJFR-SJFR Min-Min Sort-Mid Suffrage
I_hihi Max-Min Sort-Mid LJFR-SJFR Sort-Mid Min-Min MCT
I_hilo Max-Min Sort-Mid LJFR-SJFR Min-Min Sort-Mid MCT
I_lohi Max-Min LJFR-SJFR Sort-Mid Min-Min Sort-Mid Suffrage
I_lolo Max-Min Sort-Mid OLB Min-Min Suffrage Sort-Mid
S_hihi Max-Min Sort-Mid LJFR-SJFR Min-Min Sort-Mid MCT
S_hilo Max-Min Sort-Mid LJFR-SJFR Min-Min Sort-Mid MCT
S_lohi Max-Min LJFR-SJFR Sort-Mid Min-Min Sort-Mid Suffrage
S_lolo Max-Min Sort-Mid LJFR-SJFR Min-Min Sort-Mid Suffrage

Conclusions

Selecting the appropriate resource for a specific task is one of the challenging work in computational grid. This work introduces a new task scheduling algorithm called Sort-Mid. The implementation of Sort-Mid algorithm and various existing algorithms are tested using a benchmark simulation model. Min-Min is the simplest and common scheduling algorithm for grid computing. But, it works poorly when the number of large tasks is less than the number of small tasks. Also, the computed makespan by Min-Min in this case is not good. The computed grid’s resources utilization by Min-Min is not good. To avoid the disadvantages of grid’s resources utilization and makespan, Sort-Mid is designed to maximize grid’s resources utilization and to minimize the makespan. This algorithm overcomes the affection of large varies of task’s execution times. A comparison of makespan values between our algorithm and other seven scheduling algorithm has been conducted. Obviously, the result of Sort-Mid is better than all algorithms in the eleven underling instances except for Min-Min. Nevertheless, Sort-Mid is the best in case of inconsistent high task and high machine heterogeneity. On the other hand, experimental results indicate that Sort-Mid utilizes the grid by more than 99% at 6 instances and more than 98% at 4 instances.

In conclusion, the rank of the proposed Sort-Mid algorithm regarding both makespan and utilization is very good.

Conflict of Interest

The authors have declared no conflict of interest.

Compliance with Ethics Requirements

This article does not contain any studies with human or animal subjects.

Footnotes

Peer review under responsibility of Cairo University.

References

  • 1.Magoulès F., Pan J., Tan K., Kumar A. CRC Press; London, New York: 2009. Introduction to grid computing. [Google Scholar]
  • 2.Amalarethinam, George D.I., Muthulakshmi P. An overview of the scheduling policies and algorithms in grid computing. Int J Res Rev Comput Sci. 2011;2(2):280–294. [Google Scholar]
  • 3.Chandak A., Sahoo B., Turuk A. An overview of task scheduling and performance metrics in grid computing. Int J Comput Appl. 2011:30–33. [Google Scholar]
  • 4.Braun T.D., Siegel H.J., Beck N., Boloni L.L., Maheswaran M., Reuther A.L. A comparison of eleven static heuristics for mapping a class of independent tasks onto heterogeneous distributed computing systems. J Parallel Distrib Comput. 2011;61(6):810–837. [Google Scholar]
  • 5.Ma T., Yan Q., Liu W., Guan D., Lee S. Grid task scheduling: algorithm review. IETE Tech Rev. 2011;28(2):158–167. [Google Scholar]
  • 6.Elzeki O.M., Rashad M.Z., Elsoud M.A. Overview of scheduling tasks in distributed computing systems. Int J Soft Comput Eng. 2012;2(3):470–475. [Google Scholar]
  • 7.Maheswaran M, Ali S, Siegel HJ, Hensgen D, Richard FF. Dynamic matching and scheduling of a class of independent tasks onto heterogeneous computing systems. HCW ‘99, DC, USA; 1999. p. 30–44.
  • 8.Freund RF, Gherrity M, Ambrosius S, Campbell M, Halderman M, Hensgen D, et al. Scheduling resources in multi-user, heterogeneous, computing environments with SmartNet. HCW ‘98, Orlando, FL; 1998. p. 184–99.
  • 9.Maheswaran M., Ali S., Siegel H.J., Hensgen D., Richard F.F. Dynamic mapping of a class of independent tasks onto heterogeneous computing systems. J Parallel Distrib Comput. 1999;59(2):107–131. [Google Scholar]
  • 10.Anousha S, Ahmadi M. An improved Min-Min task scheduling algorithm in grid computing. LNCS 7861; 2013. p. 103–13.
  • 11.Singh M., Suri P.K. QPSMax-Min<>Min-Min: a QoS based predictive Max-Min, Min-Min switcher algorithm for job scheduling in a grid. Inform Technol J. 2008;7(8):1176–1181. [Google Scholar]
  • 12.Parsa S., Entezari-Maleki R. RASA: a new grid task scheduling algorithm. Int J Digital Content Technol Appl. 2009;3(4):91–99. [Google Scholar]
  • 13.Kamalam G.K., Bhaskaran V. A new heuristic approach: Min-Mean algorithm for scheduling meta-tasks on heterogeneous computing systems. Int J Comput Sci Network Secur. 2010;10(1):24–31. [Google Scholar]
  • 14.Kokilavani T., Amalarethinam D.I. Load balanced Min-Min algorithm for static meta-task scheduling in grid computing. Int J Comput Appl. 2011;20(2):43–49. [Google Scholar]
  • 15.Alharbi F. Multi objectives heuristic algorithm for grid computing. Int J Comput Appl. 2012;46(18):39–45. [Google Scholar]
  • 16.Anousha S., Anousha S., Ahmadi M. A new heuristic algorithm for improving total completion time in grid computing. Lect Notes Electr Eng. 2014;308:17–26. [Google Scholar]
  • 17.Chaturvedi A.K., Sahu R. New heuristic for scheduling of independent tasks in computational grid. Int J Grid Distrib Comput. 2011;4(3):25–36. [Google Scholar]
  • 18.Kousalya K., Balasubramanie P. Ant algorithm for grid scheduling powered by local search. Int J Open Probl Compt Math. 2008;1(3):222–240. [Google Scholar]
  • 19.Braun TD, Siegel HJ, Beck N, Boloni LL, Maheswaran M, Reuther AL, et al. A comparison study of static mapping heuristics for a class of meta-tasks on heterogeneous computing systems. HCW’99, DC, USA; 1999. p. 15–29.
  • 20.Merajiand S., Salehnamadi M.R. A batch mode scheduling algorithm for grid computing. J Basic Appl Sci Res. 2013;3(4):173–181. [Google Scholar]

Articles from Journal of Advanced Research are provided here courtesy of Elsevier

RESOURCES