TASK ALLOCATION MODEL FOR RELIABILITY AND

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

S179396231100044X

International Journal of Modeling, Simulation, and Scientific Computing Vol. 2, No. 2 (2011) 131–149 c World Scientific Publishing Company DOI: 10.1142/S179396231100044X

TASK ALLOCATION MODEL FOR RELIABILITY AND COST OPTIMIZATION IN DISTRIBUTED COMPUTING SYSTEM PRADEEP KUMAR YADAV∗,§ , M. P. SINGH†,¶ and KULDEEP SHARMA†,‡, ∗Central

Building Research Institute Roorkee-247667, Uttarakhand, India †Department

of Mathematics and Statistics Gurukula Kangri University Hardwar-249404, Uttarakhand, India ‡Department

of Mathematics Applied Sciences and Humanities Krishna Institute of Engineering and Technology Ghaziabad, India §prd yadav@rediffmail.com ¶mpsingh gku@rediffmail.com kkss [email protected] Received 22 April 2010 Revised 31 December 2010 Accepted 8 January 2011 A Distributed Computing System (DCS) is defined as a set of processing elements interconnected by communication links. Reliability analysis of these processing elements and communication links is one of the important parameters to achieve the system efficiency. The system efficiency can be improved by making the task allocation properly in DCS. In this paper, we have presented a mathematical model, considering DCS with heterogeneous processors in order to achieve optimal cost and optimal reliability by allocating the tasks to the processors, in such a way that the allocated load on each processor is balanced. The task allocation in DCS is known as NP-hard problem even in the best conditions, and based on the present model, an efficient algorithm have been proposed to obtain optimal solutions. To design the mathematical model, execution time of the tasks on each processor as well as communication time between the tasks has been taken in the form of matrices. Keywords: Heuristic approach; static task allocation; reliability, execution time; communication time.

1. Introduction The rapid progress in the technologies for many computer applications leads to the development of distributed computing system (DCS). A DCS consists of a set of Corresponding

author. 131

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

132

S179396231100044X

P. K. Yadav, M. P. Singh & K. Sharma

multiple processors interconnected by communication links over some configuration of processors, each with its own memory, control and arithmetic capability. They are increasingly being employed for critical applications, such as aircraft control, industrial process control and banking systems. In such a system, the performance of a parallel program on a DCS is mainly depending on the allocation of the tasks comprising the program onto the available processors in the system, referred to as task allocation problem. An allocation policy can be static1–5 or dynamic,6,7 depending upon the time at which the allocation decisions are made. Several approaches to the task allocation have been identified in the past with the main concern on the performance measures, such as minimizing the total sum of execution and communication cost,1,3–5 or minimizing the program turnaround time,2 and the maximization of the system reliability8–15 and safety.13 Distributed Computing System Reliability (DCSR) has been defined by Kumar et al.9 as the probability for successful completion of distributed programs, which requires that all the allocated processors and involved communication links are operational during the mission. Inherently, DCS are more complex than centralized systems. The added complexity could increase the potential for the system failures. Hence maximizing reliability of DCS is of critical importance along with the task allocation.10 In this paper, the authors investigate the problem of task allocation in which multiple objectives are considered, such as: minimizing the system cost, and maximizing the system reliability as well as the processor utilization of the system subject to the system constraints. Very few established task allocation models have considered the reliability property.8–16 Redundancy is the traditional technique for improving reliability of DCS. Inherently, redundancy is an expensive approach. Moreover, many times, the system redundancy is not available. In this case, a DCS may execute an application with high reliability if the task allocation is made carefully in this system taking into account the failure rates of both the processors and the communication links. Brannister and Trivedi17 gave a task allocation model for fault tolerant systems. The fault-tolerance is made possible through the introduction of redundant copies of modules. Their model does not provide an explicit system reliability measure. Also, it does not consider failures of communication links. Shatz et al.8 proposed another DCSR evaluation model, where failures from processors or communication links are time-dependent. Some work has been done in the past for maximizing the reliability of DCS’s without redundancy.8,10,12,15 In DCS, both the minimization of the system cost and the maximization of system reliability cost are NP-hard problems. As such, there exists a vast amount of literature for providing alternative solutions. They can be broadly classified into three categories: (a) mathematical programming approaches — such as linear programming branch and bound, and state-space algorithms are developed to solve small problems, (b) customized algorithms that take into account the specific system configuration, providing exact or approximate solutions under some scenarios, (c) meta heuristic algorithms such as Genetic

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

S179396231100044X

Task Allocation Model in Distributed Computing System

133

Algorithms (GA) and Simulated Annealing (SA) have also been applied to derive sub-optimal solutions with reasonable time. In Refs. 8, 12 and 14, optimal approaches were developed based on the wellknown A* algorithm. Such approaches may find an optimal solution, but they may demand heavy computing time. GA has emerged as a successful tool for optimization problems. In Ref. 15, a heuristic approach was developed based on the wellknown GA. This approach may quickly find a near optimal allocation, but final allocations may be far from optimality. In this paper, we focus on the task allocation for general program structure, considering the effect of inter-processor distances — for DCS having cycle free topology. Inter-processor communication (IPC) cost increases linearly as the inter processor distances increases. Most prevalent approaches for task allocation deal with a single objective only, but this paper tackles the problem of finding an optimal solution to the multi-objective task allocation problem. It first develops a mathematical model for system cost — caused by the execution of tasks on the system and IPC, subject to the constraints imposed on the system resources. Optimal reliability is achieved based on this model. To derive a simple and fast algorithm, it is essential to make use of the heuristic approach that provides a near optimal solution in a reasonable amount of time. In this paper, we propose a heuristic approach for assigning a set of “m” tasks of a program to a set of “n” processors, where m n in order to get the desired objectives discussed above. It is suitable for an arbitrary number of processors and for random program structures. The rest of the paper is organized as follows. Definitions and assumptions are defined first in Sec. 2. Tasks allocation problem has been discussed in Sec. 3. Task allocation model has been developed in Sec. 4. The proposed method and algorithm has been explained in Sec. 5. Implementation of the model and experimental results have been shown in Secs. 6 and 7 concludes this paper. 2. Notations, Definitions and Assumption The following are the set of notations, definitions and assumptions used in the description of the proposed algorithm. 2.1. Notations P : {p1 , p2 , . . . , pn } is the set of n-heterogeneous processors T : {t1 , t2 , . . . , tm } is the task set (a parallel program) having m-tasks eik : the accumulative execution time (AET) for the task ti , running on processor pk , during the mission (in hours) cij : inter-task communication time (ITCT) between ti and tj X: an allocation matrix of order m*n, where the entry xik = 1; if ith task is allocated to kth processor and 0; otherwise ti : ith task of a parallel program Pk : kth processor in the system

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

134

S179396231100044X


uk : execution cost per unit time of kth processor λk : the failure rate of kth processor µkb : the failure rate of communication link (or path) lkb between two processors Pk and Pb Wkb : the transmission rate of communication link (or path) lkb dkb : the distance between two processor pk and pb . 2.2. Definitions • Accumulative execution time (AET ): the accumulative execution time eik of a task ti , running on a processor pk , is the amount of the total time needed for the execution of ti on that processor during the mission. • Accumulative communication time (ACT ): the accumulative communication time cij is the total time needed for exchanging data between tasks ti and tj that are residing at separate processors during the mission. • Processor reliability (PR): it is the probability that the processor pk is operational during the execution of all tasks assigned to pk , under a given task allocation. • Communication links reliability (CLR): it is the probability that the communication link or path (i.e., the link or path between two different processors pk and pb ) is operational for communicating the data between tasks ti and tj that are residing at separate processors. 2.3. Assumptions (A1 ) The processors involved in the DCS are heterogeneous (i.e., they may have different processing speeds and failure rates) with circuit-less network topology, such as star, tree, connected star, linear, etc. Also, the communication links associated with DCS may have different failure rates and bandwidths. It is also assumed that the failure rates of each system components are constant. (A2 ) The state of the components of DCS (i.e., processors and communication links) is either operational or failed. Further, it is also assumed that the failures of components are statistically independent. (A3 ) The program is assumed to be the collection of m-tasks that are free in general, which are to be executed on a set of n-processors that may have different processor attributes. It is also assumed that the number of tasks to be allocated is more than the number of processors (m n) as in real life situation. (A4 ) A task of a program will execute on a particular processor only when it satisfies a constraint imposed on that processor, otherwise the task moves towards the next processor for getting execution. (A5 ) A task may take different execution time if it executes on different processors and an amount of data may take different communication time if it is transmitted through the different communication links. Therefore, the system cost and system reliability, both depend upon the execution and communication time.

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

S179396231100044X


135

(A6 ) Once the tasks are allocated to the processors, they reside on those processors until the execution of the program is completed. Whenever a group of tasks is assigned to the same processor, the ITCT between them is zero. 3. Problem Statement The specific problem being addressed here can be decomposed into a large number of tasks that can be executed in any order, such as parameter sweep applications. Consider a set of m-tasks T = {t1 , t2 , . . . , tm } to be executed on n-processors P = {p1 , p2 , . . . , pn }, connected by a cycle free topology. These tasks are mutually independent, i.e., there is no precedence constraint among them. The processors involved in DCS have local memory only and do not share any global memory. It is due to our assumption (A6 ) — once a task has completed, the processor computing the task stores the output data in its local memory. If the data is needed by a task being completed on the same processor, it reads it from the local memory. The overhead incurred by this is negligible. Indeed, a failure rate is associated with each component (processor and link) in the system. The execution time of these tasks on all the processors is given in the form of Execution Time Matrix [ETM (,)], of order m∗ n. Note that, if a task cannot be executed at a particular processor, the corresponding element in ETM (,) is set to “∞”, i.e., very large value. The ITCT is taken in the form of symmetric matrix named as ITCT Matrix [ITCTM (,)], which is of order m∗ m. An allocation of tasks to processors is defined by a function A, from the tasks set “T ” to the set “P ” of processors such that: A : T → P , where A(i) = k if task ti is assigned to processors Pk , for all 1 ≤ i ≤ m and 1 ≤ k ≤ n. In general, the objective of tasks allocation is to find an optimal allocation AO that optimizes the system cost, system reliability and processor utilization (PU) by properly allocating the tasks to the processors. 4. Functional Design of Mathematical Model for System Cost and System Reliability Task allocation is an essential phase in DCS to obtain the desired objectives that are considered in this paper. For achieving these objectives from such systems, an efficient allocation of the program tasks to processor, is imperative. In order to allocate the tasks of a parallel program to processors in DCS, we should know the information about the input such as task attributes, processors attributes, etc. Since obtaining such information is beyond the scope of this paper, a deterministic model that the required information is available before the execution of the program is assumed. In this section, first we give a mathematical model for task allocation for DCS, which involves the following objectives: (i) the system cost function, to measure the IPC cost and execution cost, (ii) the system reliability function, to measure the CLR and the PR, (iii) increasing the PU to measure the system performance.

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

136

S179396231100044X


Task allocation problem

Dynamic

Static

Processor Attributes

Task attributes Determine: 1-Execution time of each

Determine: 1 - processors topology ,

tasks, 2-Inter-task communication time 2-Processors and communication links

with transmission rates,etc.

failure rates, 3-Inter processor distance,

Developing DS-Task allocation model Map the tasks to processor to satisfy;

1-System cost function with load balancing that minimize the system cost

2-Reliability function that maximize the system reliability

Fig. 1.

Computational structure of the allocation model and its supporting function.

The computational structure of the allocation model and its supporting function has been shown in Fig. 1.

4.1. System cost function This function basically consist of two costs, namely execution cost and communication cost. For given a task allocation A : T → P , A(i) = k; the execution cost eik represents to execute task ti on processor pk and is used to control the corresponding processor assignment. But the execution cost depends upon time, i.e., the longer execution time will incur heavier cost on the involved processor of the DCS. If uk is the execution cost of the processor pk per unit time, then the execution cost of the processor pk , under assignment A can be computed by: Ecost (pk ) =

m

uk ei,k xik .

(4.1)

i≈1

IPC cost is incurred when the data are transferred from task to task if they are residing on different processors due to the inter-task communication (ITC).4,5 Therefore, IPC cost is proportional to ITC cost, but ITC cost is a function of ITCT and the inter-processor distance.

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

S179396231100044X


137

The total IPC cost for a processor pk , for an assignment A is defined as follows: m m (ci,j ) dkb xik xjb . (4.2) Ccost (pk ) = i≈1 j>i

In this model, both costs, i.e., execution cost and communication cost are application dependent. These two costs play important roles in task allocation. Now, the total cost on a processor “k” is the sum of execution cost and communication cost for a given assignment A: T cost(pk ) = Ecost (pk ) + Ccost (pk ),

(4.3)

and the total cost of the system is computed by: Scost =

n

T cost(pk).

(4.4)

k≈1

4.2. Reliability analysis In this section, we provide the reliability function for the underlying DCS. In DCS, both system cost and system reliability are time dependent. Basically in a DCS, each component has two states: operational and failed. To evaluate the system reliability; we follow Shatz’s formulation8 in order to compute the probability that all the system components are operational during the mission. The reliability of system components (i.e., processors and communication t links) during a time interval [0, t] follows the Poisson distribution R(t) = exp( 0 λdt), and it reduces to exp(−λt) due to our assumption (A1 ) during the successful mission.8,10–13,15 The execution reliability of the processor pk during AET, for executing the tasks assigned to it under the allocation A is calculated by: m eik xik . (4.5) ERpk = exp −λk i≈1

Similarly, the CLR for a processor pk , during an assignment A incurred due to the IPC is:   m m (4.6) (ci,j /wkb )xik xjb . CRk = exp−µkb i≈1 j>i

Therefore, the total optimal reliability of a processor pk is the product of PR and CLR associated with pk ; for a given assignment A, this is computed by: TRpk = ERpk ∗ CRk ,

(4.7)

TRpk = exp(−Z), (4.8) m m where Z = λk i≈1 eik xik + µkb i≈1 j>i (ci,j /wkb )xik xjb , gives the unreliability cost of DCS. The first term in Z represents the unreliability due to the execution of m

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

138

S179396231100044X


tasks on the system processors, and the second term reflects the unreliability caused by the inter processor communication. As such, the system reliability wherein all involved system components are operational during the mission is computed as follows: n

TRpk . (4.9) SRel = k=1

4.3. Processor utilization One of the most important problems in DCS is the maximization of processor utilization (PU). This may increase by balancing the load on each processor. The processor utilization of a processor, say Pk , is obtained by dividing the load on that processor, incurred due to the execution of the tasks assigned to it only, to the heaviest loaded processor. Let the calculated load on each of the processor pk be wk , and it is given by: m wk = i≈1 eik xik . Now, the utilization of each processor is calculated as: PU(Pk ) = wk / max(wk ),

(4.10)

and the average PU is calculated as: APU = [PU(P1 ) + PU(P2 ) + · · · + PU(Pn )]/n.

(4.11)

5. Proposed Method and Algorithm 5.1. Proposed method In DCS, the allocation of program tasks is to be carried out so that each task is assigned to a processor whose capabilities are most appropriate for the task and the inter-processor cost is minimized. The allocation procedure has been shown in Fig. 2. Our task allocation scheme that we present here has three major steps: (1) Task selection order (2) Average processor load (3) Processor selection criteria The order in which the tasks in a program are considered for allocation is a critical factor, affecting the optimality of the resulting allocations. The task selection list, TSO {} is generated by sorting the tasks according to increasing order of their selection order SO(ti ), that are calculated as: n

SO(ti ) = 1≤i≈m

k≈1

|eik |

|n|

+ max {cij }. 1≤j≈m

Tie breaking is done randomly, i.e., one of the tasks with equal SO(ti ) is selected randomly. There can be alternative polices for tie breaking such as select the task

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

S179396231100044X


139

m1

m2

Execution cost

S m3

System cost

Y

Communication cost

S

Allocation Scheme

T Processor reliability

E

System reliability

M

mn-1

Communication links reliability

mn

Fig. 2.

Task allocation scheme for calculating system performance.

whose overall communication cost with other tasks is minimum. Since this kind of policy increases the time complexity of the algorithm, we prefer a random selection strategy. After selection the order of task, a next criterion is the average processor load. Total load of a processor is defined as the sum of execution costs of the tasks being assigned to it. The average load on a processor, say Pk , is calculated as: m

Load(pk ) =

i≈1

eik

|n|

(k = 1, 2, 3, . . . , n).

Because strictly balanced load distribution may not be possible to achieve, a system is considered to be balanced if the load on each processor is less or equal to the average load, i.e., m

eik ≤ Load(pk ).

i≈1

In this model, we take a linear array TSO {} to store those tasks that are to be assigned to the processors. Initially, we assume that the linear array Tassign {} = Φ, and TSO {} ← Tnon ass {}. Pick up the first task tu from Tnon-assign {}, and assign tu to that processor at which euk is minimum and satisfy the constraint m i≈1

euk ≤ Load(pk ), imposed on Pk in the system.

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

140

S179396231100044X


If this condition is satisfied, then the current allocation is valid, otherwise tu goes to next processor for getting execution. Let the valid allocation of tu is on Pk . We store task tu in a linear array Tassign {} and the linear array Tnon-assign {} is modified by deleting the task tu from Tnon-assign {}. The detailed process of allocating the task to the processors is given below in the form of algorithm. 5.2. Algorithm The algorithm consists of the following steps: Step 1: input: m, n, ETM (,), ITCTM (,), uk , dkb , λk , µkb Step 2: output: a task allocation schedule that optimizes system cost, system reliability and PU. Step 3: compute: 3.1. Selection order of each task n

SO(ti ) =

|eik |

k≈1

|n|

1≤i≈m

+ max {cij } 1≤j≈m

and average processor’s load m

Load(pk ) =

eik

i≈1

|n|

(k = 1, 2, 3, . . . , n)

3.2. Sort the tasks in a linear array TSO {} in the increasing order of their SO(ti ) values. 3.3. If two tasks are having the same SO(ti ), then select one of them randomly. Step 4: initialize: TSO {} ← Tnon ass {} Tass {} ← Φ Step 5: pick up the task tu from Tnon ass {} Step 6: find min{euk } from ETM (,) for k = 1, 2, 3, . . . , n 6.1. If min{euk } is for k = r with the constraint m

euk ≤ Load(pk ) imposed on each Pk ,

i≈1

then assign tu → Pk=r ; i.e., current allocation is valid. Or else, 6.2. Assign tu to the next processor Pk=s (distinct from Pk ) on which euk is minimum.

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

S179396231100044X


141

Step 7: add the effect of the communication cost of the executing task tu → Pk with other task residing on P − {Pk } as: 7.1. Select uth column [ciu ]T of the ITCTM(,). 7.2. For k = {1, 2, 3, . . . , n} − {k = r or s}, add column [ciu ]T to rth or sth column of the matrix ETM(,) 7.3. Reduce ETM (,) and ITCTM (,) by removing task tu . Step 8: Tnon ass {} ← Tass {}/{tu} Tass {} ← Tass {}U {tu} Step 9: repeat Steps 6–8, until and unless we get Tnon ass {} ← Φ Tso {} ← Tass {} Step 10: compute: 10.1. T cost (pk ) = Ecost (pk ) + Ccost (pk ) 10.2. TRpk = exp(−Z) 10.3. PU(Pk ) = wk / max(wk ) Step 11: compute:

n 11.1. Scost = k≈1 Tcost (pk ) n 11.2. SRel = k=1 TRpk 11.3. APU = [PU(P1 ) + PU(P2 ) + · · · + PU(Pn )]/n

Step 12: End. 6. Implementation of the Model Two illustrative examples have been considered to show the performance of our method for better allocation, as well as to test the proposed algorithm on these examples. Example 1. The efficacy of the proposed algorithm has been illustrated by solving the same running example as in Refs. 8 and 12. The complete details of the example are given in Ref. 8. The results obtained for this example, with the proposed algorithm, Shatz et al.8 algorithm and Kartik et al.12 algorithm have been given below in Table 1. In Table 1, our algorithm shows that most of the tasks are concentrated on P2 in comparison to Refs. 9 and 13, as the failure rate of P2 is minimum; and also P2 communicates with P3 , because the failure rate of the link l23 is minimum. Therefore, the proposed algorithm produces lower system cost and higher system reliability (i.e., 29 and 0.9967054, respectively) in comparison to both Shatz’s et al. (i.e., 33 and 0.9953) and Kartik et al. (i.e., 33 and 0.9953) algorithms. Hence, we conclude that in the proposed algorithm, the system cost is minimized by 13% and

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

142

S179396231100044X

P. K. Yadav, M. P. Singh & K. Sharma Table 1. Comparative results with our algorithm, Shatz et al. algorithm and Kartik et al. algorithm. Tasks

Processors

System cost

System reliability

Nil t1 , t2 , t4 t3 Nil

P1 P2 P3 P4

29

0.9967054

Shatz et al. algorithm Ref. 8

Nil t1 , t2 t3 , t4 Nil

P1 P2 P3 P4

33

0.9953

Kartik et al. algorithm Ref. 12

Nil t1 , t2 t3 , t4 Nil

P1 P2 P3 P4

33

0.9953

Proposed algorithm

P3

P1

P2 P4

Fig. 3.

Processor topology.

system reliability is maximized by 0.14% versus that in the algorithms of Refs. 8 and 12. Thus, the proposed algorithm produces optimal allocation at all times, unlike the algorithms presented in Refs. 8 and 12. Example 2. In this example, a typical program made up of eight tasks {t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 } to be executed on the DCS having four processors {p1 , p2 , p3 , p4 } as shown in Fig. 3, is considered. Each component in DCS has some failure rates. The failure rate of the processors p1 , p2 , p3 , and p4 are 0.0002, 0.0001, 0.0003, and 0.0002, respectively. The execution time of each task at different processors is given in Table 2. Here, we assume that all the communication links have the same transmission rate “wkb ”, and hence we give the ITCT directly in time units as shown in Table 3. Table 4 gives the failure rates of all the communication paths generated by links and the inter-processor distances. It is also assumed that the execution cost of all the processors per unit time in DCS is unity. Applying the proposed algorithm to this example, the algorithm traces the following output: The selection priorities of tasks are TSO {t5 , t2 , t1 , t6 , t3 , t4 , t7 , t8 }, which is an increasing order of TSO (ti ). The average processor’s load of p1 , p2 , p3 and

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

S179396231100044X

Task Allocation Model in Distributed Computing System Table 2.

Execution time matrix.

Processors tasks

ETM = [eik ]

t1 t2 t3 t4 t5 t6 t7 t8

Table 3.

Table 4.

P2

P3

P4

2 10 8 14 3 12 16 20

8 3 13 4 8 2 8 11

7 8 5 10 7 9 6 10

10 5 7 3 6 8 10 4

ITCTM = [cij /wkb ] t1

t2

t3

t4

t5

t6

t7

t8

0 2 1 3 2 3 0 2

2 0 2 1 3 2 0 1

1 2 0 2 3 2 1 3

3 1 2 0 1 2 4 3

2 3 3 1 0 3 1 2

3 2 2 2 3 0 2 1

0 0 1 4 1 2 0 2

2 1 3 3 2 1 2 0

Inter-processor distances and communication failure rate.

Processors

P1 P2 P3 P4

P1

Inter-task communication time matrix.

Tasks

t1 t2 t3 t4 t5 t6 t7 t8

143

IPDM = [dkb ]

CPFRM = [µkb ]

P1

P2

P3

P4

P1

P2

P3

P4

0 0.8 1.2 1.5

0.8 0 0.4 0.7

1.2 0.4 0 1.1

1.5 0.7 1.1 0

— 0.0003 0.0004 0.0005

0.0003 — 0.0001 0.0002

0.0004 0.0001 — 0.0003

0.0005 0.0002 0.0003 —

IPDM — Inter-processor distance matrix. CPFRM — Communication path failure rate matrix.

P4 are 21.25, 14.25, 15.50, and 13.25, respectively. Table 5 shows the optimal assignment of tasks to the processors for the present task allocation model, where t1 , t3 , t5 → P1 , t2 , t4 , t6 → P2 , t7 → P3 , and t8 → P4 . The optimal values of the following: system cost, system reliability and APU are 69.80, 0.9815, and 0.6153, respectively. This problem also addresses the same conclusion as in Example 1. From Table 4, we can see t1 , t3 , t5 → P1 and t2 , t4 , t6 → P2 , because of the failure rates of these processors being minimum compared to p3 and p4 . Thus, the proposed algorithm shows that the system cost and system reliability are optimized if the tasks of the program are assigned carefully to the appropriate processors in the system, taking

(2)

P1 P2 P3 P4

(1)

t1 , t3 , t5 t2 , t4 , t6 t7 t8

13 9 6 4

EC 3(a) 4.80 12 4.80 16.20

IPCC 3(b) 17.80 21.00 10.80 20.20

3(a+b)

Total processor’s cost (3)

EC — Execution cost. IPCC — Inter-processor communication cost. PU — Processor utilization. APU — Average processor’s utilization.

Processors

Tasks

0.00420 0.00540 0.00340 0.00570

unreliability cost (4)

Total processor’s

0.99581 0.99461 0.99661 0.99432

reliability (5)

Total processor’s

Optimal system cost and reliability.

0.9815

69.80

System reliability (7)

System cost (6)

1 0.6923 0.4615 0.3077

(8)

PU

0.6153

(9)

APU

144

Table 5.

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623 S179396231100044X


May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

S179396231100044X


145

1.2 Utlization

1 0.8 0.6 0.4 0.2 0 p1

p2

p3

p4

Processors Fig. 4.

Optimal processor utilization.

into account the failure rates of the processors and the communication links. The optimal utilization of each processor has been given in Fig 4. 6.1. Applications The rapid development of very large scale integration (VLSI) circuits and communication techniques makes DCS economically practical.18 Owing to its advantages such as high performance, resource sharing extensibility, fault tolerance and high reliability, DCS has evolved to play an important role in the following areas: 6.1.1. Telecommunication networks (a) Telephone networks and cellular networks. (b) Computer networks such as internet. (c) Wireless sensor networks. 6.1.2. Network applications (a) World Wide Web and peer to peer networks. (b) Network files systems. (c) Distributed information processing systems, such as banking and airline reservation systems. 6.1.3. Real-time process control (a) Aircraft control systems. (b) Industrial control systems. 6.2. Algorithm complexity The run time complexity of the proposed algorithm can be analyzed as follows: Step 3 can be done in O(m logm) comparisons in the worst case, also Step 5 needs

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

146

S179396231100044X


O(m) comparisons in the worst case, Step 6 can be done in O(mn) comparisons, and Step 7 needs O(n) comparisons. Since m n, the time complexity of our algorithm is O(mn). 6.3. Experiments and results To evaluate the performance of our algorithm, we have conducted a simulation study by implementing the algorithm in Borland C++ and have tested for a large number of randomly generated task graphs that are allocated onto a DCS. The performance of our algorithm is dependent on many factors. For conducting a simulation study, we selected three factors that we considered most important, and observed the effects of varying each of these independently. These factors are: (i) number of processors in the system (n), (ii) number of tasks in a program (m), (iii) the average task connectivity (i.e., average number of neighbors of a task in ITCT graph or in ITCT matrix). The simulation program has two major parts. The first part reads as input: the number of task and number of processors. It then generates a task graph and equivalent parameters: task execution times, ITCTs and average processing load. For generating the parameters, the program uses the following test data, which are similar to the ones used in Refs. 8 and 12: The failure rates of the processors and communication links are given in the ranges 0.0001–0.0005 and 0.00015–0.00030, respectively; task execution time: 2–25; ITCT: 0–25, and the transmission rate of the communication link and inter processor distance between the allocated processor has been used as unity. The second part of the simulation program applies the proposed algorithm to derive a task allocation for achieving the desired objectives. For simulation study, we have tried out 300 examples. The system configurations are considered as follows: number of processors in the system are four to six, the average task connectivities are three and five and five sets of randomly generated problems with sizes m = 8, 12, 16, 20, and 24 are used. Hence a total of 30 input configurations are obtained, each with a unique set of parameters. For each input configuration, 10 problem instances are generated randomly. Thus the program runs 300 times totally, computing the average values of desired objectives, which we have discussed in this paper, over these problem instances. Table 6 summarizes the simulation results by deploying the proposed algorithm to solve the generated problems. The result shows that as the average task connectivity or number of processors increases, the average values of the following: system cost, APU and the unreliability cost will increase simultaneously, whereas the system reliability values are going to be decreased in all the corresponding problem instances respectively. Same situation occurs when the problem size increases. The reasoning behind this study is that as the average task connectivity or number of processors increases, the result will increase respectively in communication

8 12 16 20 24

8 12 16 20 24

8 12 16 20 24

n=4

n=5

n=6

163 331 416 794 889

112 293 384 731 852

105 272 356 683 762

S cost

0.6910340 0.7603451 0.8160230 0.8642010 0.9001420

0.5302820 0.7410350 0.7903540 0.8210340 0.8702310

0.4285710 0.7105260 0.7423210 0.7531200 0.7942130

APU

0.0380120 0.0572010 0.0720143 0.0798070 0.0843041

0.0321050 0.0521220 0.0613010 0.0691210 0.0780130

0.0214100 0.0490560 0.0587997 0.0604321 0.0715324

Unreliability cost

0.9627010 0.9444040 0.9305180 0.9232950 0.9191520

0.9684050 0.9492130 0.9405400 0.9332140 0.9249520

0.9788270 0.9521280 0.9412030 0.9413580 0.9309660

S reliability

248 394 493 879 903

213 342 416 846 876

172 285 387 713 799

S cost

Simulation results.

Average task connectivity = 3

S cost — average system cost. APU — average processor utilization. S reliability — average system reliability.

No. of tasks ‘m’

No. of processors

Table 6.

0.7012320 0.7893620 0.8501840 0.8903450 0.9340630

0.5763910 0.7854820 0.8002540 0.8549210 0.8702560

0.4990320 0.7643010 0.7913290 0.8100130 0.8687210

APU

0.0534030 0.0647210 0.0680090 0.0960020 0.0987010

0.0436020 0.0598460 0.0630010 0.0940210 0.0970020

0.0398340 0.05012023 0.0588220 0.0890450 0.0902476

Unreliability cost

Average task connectivity = 5

0.9479980 0.9373290 0.9342520 0.9084620 0.9060140

0.9573350 0.9419100 0.9389430 0.9102640 0.9075540

0.9609490 0.9511150 0.9428750 0.9148040 0.9137050

S reliability

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623 S179396231100044X

Task Allocation Model in Distributed Computing System 147

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

148

S179396231100044X


cost or in execution cost. Furthermore, both execution and communication costs will increase, if the number of tasks increases. However, in each of the problem instances, we get the optimal results at all times. 7. Conclusion In this paper, we have considered the static task allocation problem, an essential phase in DCS with the goal of minimizing system cost, and maximizing the system reliability and PU. The present model is based on a cost function, which represents the unreliability caused by execution of tasks on processors and that caused by the IPC. We present a simple and efficient algorithm to obtain optimal values of the objectives that we have considered in this paper. In order to evaluate the performance of our algorithm, we have solved the same example, present in Refs. 8 and 12. In this case, our algorithm shows that the system cost is minimized by 13% and the system reliability is maximized by 0.14%. Thus our algorithm shows that: (i) reliability of a DCS depends not only on the reliability of the system components, but also on the distribution of the tasks on the processors in the system; (ii) it obtains optimal solution at all the times. A number of opportunities exist for future work. In future, we will improve our study on this topic by making task clusters around the maximally linked tasks, and then assigning these task clusters to the processors in such a way that the allocated load on each processor is balanced. We shall address this work in our future research too. Acknowledgments We sincerely thank all the anonymous referees for many helpful comments and suggestions. The authors are also thankful to Prof. Vipin Kumar, Prof. C. M. Batra, Dr. Ritu Gupta, Dr. S. N. Swain and Ms. Shikha Bansal, for their technical assistance. References 1. Perng-YI Richard M. A., Edward Y. S. Lee, Tsuchiya M., A task allocation model for distributed computing systems, IEEE Transactions on Computers C-31(1):41–46, 1982. 2. Muhammad I. A., Dhodhi K., Arif G., Task assignment in distributed computing systems, IEEE Concurrency, 3:49–53, 1995. 3. Lee C.-H., Lee D., Kim M., Optimal task assignment in linear array networks, IEEE Transactions on Computers, 41(7):877–880, 1992. 4. Sarje A. K., Sagar G., Heuristic model for task allocation in distributed computer systems, IEE Proceedings-E, 138(5):313–318, 1991. 5. Chu W. W., Task allocation in distributed data processing, IEEE Concurrency, pp. 57–69, November 1980. 6. Yadav P. K., Singh M. P., Kumar H., Scheduling algorithm: Tasks scheduling algorithm for multiple processors with dynamic reassignment, Journal of Computer Systems, Networks and Communications, 2008, Article ID-578180, 9.

May 20, 2011 14:17 WSPC/262-IJMSSC/S1793-9623

S179396231100044X


149

7. Chu S. Y. et al., Dynamic task assignment in heterogeneous linear array networks meta computing, Proceedings of the Heterogeneous Computing Workshop, Cancun, Mexico, pp. 66–71, April 1994. 8. Shatz S. M., Wang J.-P., Goto M., Task allocation for maximizing reliability of distributed computer systems, IEEE Transactions on Computers 41(9), September 1992. 9. Kumar V. K. P., Raghavendra C. S., Hariri S., Distributed program reliability analysis, IEEE Transactions on Software Engineering 12:42–50, 1986. 10. Attiya G., Hamam Y., Task allocation for maximizing reliability of distributed systems: A simulated annealing approach, Journal of Parallel and Distributed Computing 66:1259–1266, 2006. 11. Yin P. Y. et al., Task allocation for maximizing reliability of a distributed system using hybrid particle swarm optimization, The Journal of Systems and Software 80:724–735, 2007. 12. Kartik S., Murthy C. S. R., Task allocation algorithms for maximizing reliability of distributed computing system, IEEE Transactions on Computers 46(6), June 1997. 13. Srinivasan S., Jha N. K., Safety and reliability driven task allocation in distributed systems, IEEE Transactions on Parallel and Distributed Systems 10(3), March 1999. 14. Dogan A., Ozguner F., Optimal and suboptimal reliable scheduling of precedenceconstrained tasks in heterogeneous distributed computing, IEEE Concurrency, 8:429– 436, 2000. 15. Vidayarthi D. P., Tripathi A. K., Maximizing reliability of distributed computing system with task allocation using simple genetic algorithm, Journal of System Architecture 47:549–559, 2001. 16. Yang B., Hu H., Guo S., Cost oriented task allocation and hardware redundancy polices in heterogeneous distributed computing system considering software reliability, Computers and Industrial Engineering 56:1687–1696, 2009. 17. Bannister J. A., Trivedi K. S., Task allocation in fault- tolerant distributed systems, Acta Informatica 20:261–281, 1983. 18. Distributed System. http//en.wikipedia.org/wiki/Distributed Computing.