A Real-Time Performance Evaluation Model for Distributed Software with Reliability Constrains

Transcription

1 The Journal of Supercomputing, 34, , 2005 C 2005 Springer Science + Business Media, Inc. Manufactured in The Netherlands. A Real-Time Performance Evaluation Model for Distributed Software with Reliability Constrains HAI JIN hjin@hust.edu.cn XIA XIE YUNFA LI ZONGFEN HAN ZHIHUA DAI PENG LU Cluster and Grid Computing Lab, Huazhong University of Science and Technology, Wuhan, , China Abstract. In this paper, we propose an approach for the real-time performance analysis of distributed software with reliability constraints, called Athena. The approach is based on the real-time and reliability performance analysis of distributed program. In Athena, two important factors, imperfect nodes and the links reliability, are introduced. The algorithms proposed in Athena generates sub-graphs, counts the reliability of each sub-graph, calculates the transmission time for all the transmission paths of each data file, and computes response time of each data file with reliability constraint. In this way, the real-time performance of distributed software with reliability constrains can be evaluated. Keywords: distributed software, reliability, real-time, performance evaluation 1. Introduction Distributed systems are regards as conventional networks of independent computers. They have multiple system images, as each node runs its own operating system. The individual machine in a distributed system could be combinations of MPPs, SMPs, clusters, and individual computers [1]. In a typical distributed system, all the resources are interconnected through a communication network. Distributed software has been widely used in many fields and different distributed systems have different configurations. Benchmark [5, 12] is often used to evaluate and analyze the performance of these systems. The performance of a distributed system includes reliability, real-time characteristics, scalability, expansibility, data consistency and etc. Many methods are developed for evaluation purpose. For reliability evaluation, researchers often design some algorithms to simplify Markov models, generate corresponding File Spanning Tree (FST) to evaluate the K-terminal reliability factoring theorems [2, 7, 9, 10] or the graph theories and probability synthetically. In [8], an algorithm is proposed which employs a different concept that requires one step to give the reliability expression. This algorithm is limited to the specific directed graph structure. This paper is supported by National Science Foundation of China under grant

2 166 JIN ET AL. But with the development of distributed systems, only testing one kind of characteristics is not enough. In some applications, distributed software is ineluctable connected with the time factor and reliability tightly. They want to get information before the deadline and the information must be reliable at the same time. So the real-time performance evaluation of distributed software with reliability constraint becomes a new research topic. With the reliability constraint, the real-time performance of distributed software (RTPDS) is very complex to evaluate. There are many influencing factors, such as the status of available programs and data files on nodes, the network topology, the transmission time, and the bandwidth [11]. Especially in real problems, the nodes as well as links may fail. Here reliability constraint is defined as the probability of successful execution of a distributed software that runs on multiple nodes and communicates with other nodes for remote file access. In this paper, we shoot for this problem and propose a new schema, called Athena. In Athena, some algorithms are designed to generate sub-graphs. Here, a sub-graph is a file transmission path with those nodes containing files needed in the execution of the distributed program. Then we calculate the reliability of each sub-graph, and the transmission time for all the transmission paths of each data file. At last, we compute the response time to access of each data file with reliability constraint. RTPDS with reliability constrains can be evaluated. The rest of this paper is structured as follows. We discuss related works in Section 2. In Section 3, we present theoretic foundation about real-time performance analysis, and propose transmission path generation algorithm. A modified Factoring Method (FM) algorithm and transmission time evaluating algorithm for each sub-graph are also discussed in this section. We sort the time of sub-graph transmission to get the evaluation result at last. Section 4 presents an case study of RTPDS with reliability constrains in detail. Finally, we draw conclusions in Section Related works There are three approaches for the evaluation of RTPDS: fine-grained benchmarks, simulation, and application-oriented benchmarks [17]. Many people devote to this area and try to find some novel methods for evaluation. An approach for generalization of real-time distributed systems benchmarking is described in [6]. In [3], elemental foundation details in the developing and evaluating a real-time distributed benchmarking proposal for possible future standardization are presented. The aim is to create a true real-time performance benchmark, which is platform independent, or at the very least can isolate, and exclude from impact upon analysis. Sanders [13] presents a unified approach to the specification of measures of performance, dependability, and performability. The unification is achieved by (1) using a model class suited for representing all three aspects of system behavior, and (2) defining a variable class, which allows for the specification of a wide range of measures of system behavior. The approach permits the specification of many non-traditional as well as traditional measures of system performance, dependability, and performability in a unified manner. In [14], the paper presents benchmarks that empirically demonstrate the predictability, latency, and utilization of real-time software architecture. The results demonstrate that it is

3 REAL-TIME PERFORMANCE EVALUATION MODEL 167 possible to strike an effective balance between architectural flexibility and real-time quality of service. The above researches just pay attention to the single performance issue, such as realtime or reliability. They do not study the comprehensive performance, such as real-time performance with reliability constraints. There are very few well-known approaches for performing measurements on real-time distributed environments, none of which can be considered as widely accepted at this point with reliability constrains. In Athena, we first analyze the related factors on reliability and real-time performance. We then collect all the data files needed for program executions and their distributed status of distributed software. Finally, we use the algorithms to evaluate RTPDS with reliability constraints. 3. Real-time performance analysis In a distributed system, the execution time of a program is consisted of two parts: the data transmission time from other nodes and the real running time of the program. If all the files needed for execution are stored in the same node with the program, the program runs more quickly than getting needed files from other nodes. For Athena schema, we suppose the actual running time of the program is approximately constant and the program runs when all the files needed for the execution arrive to the node running the program. In this section, we first give some definitions and notations. Then we study the effect of reliability constraint for the real-time performance of distributed software in detail. Based on the traditional evaluation algorithms for RTPDS, such as EOG and GEX [16], we propose Athena. In Athena, some algorithms are designed to generate sub-graphs, calculate the reliability of each sub-graph and the transmission time for all the transmission paths of each data file, and then compute response time of each data file with reliability constraints. In this way, the real-time performance for distributed software can be evaluated Definitions and notations A distributed system is composed of more than one node, in which many components are included, such as a series of processing elements, memories, available data files and programs. Beside these, communication devices are also included in a distributed system, such as a network adapter and network switch. Data files and programs flow between nodes. In order to describe the distributed system conveniently, we define an undirected graph G to describe a distributed system: G = (V, E, F, P) (1) Here V is a set of nodes on which the processing elements run.e is a set of edges between nodes. Each edge represents a communication link between two nodes.f is a set of available data files. P is a set of available programs. Suppose that each program can be performed on more than one node. It accesses data files from other nodes if needed. Each program or available data file may have more than

4 168 JIN ET AL. one copy in the whole distributed system. Data file is independent to each other for file transmission. The communication ability including reliability and capacity for each link is known. Moreover, the reliability of each node is known. The notations used in this paper are listed below: X k : Node k in the distributed system F j : The available data file j L j : The size of file F j P i : Program i l i = (e i, u i, v i ): The link i that contains the edge e i and its two endpoints u i and v i FN p : The set of data files needed for the execution of program P R i : The ith transmission path of data file FA i : The set of files and programs available at node i p i : Reliability of node, edge or link i q i = 1 p i H: The programs to be executed and all data files needed for the execution of these programs G H : Graph G with a set H of needed files R(G H ): The Distributed Program Reliability (DPR) of G H G jh : The jth sub-graph of G H G e : The graph G with edge e deleted G + e : The graph G with edge e = (u,v) contracted so that node u and v are merged into a single node. This new merged node contains all data files and programs that were in nodes u and v. T : The transmission time T (G kh ): The transmission time of G kh T (F j G kh ): The transmission time of F j in G kh. Figure 1 is an example of a simple distributed system. There are six circles. Each circle represents a node. Each node has a processing element. It communicates with others by communication links (edges). For example, node X 1 has one data file F 7.Itruns program P 2, which directly communicate with other nodes (X 2, X 3 )bytwo links (e 1, e 2 ). Using these notations, we represent the DPR of program P 1 that needs data files F 1, F 2 and F 3 for its execution in the example of Figure 1 by R(G H ) where G = (V, E, F, P) and V = (X 1, X 2, X 3, X 4, X 5, X 6 ), E ={e 1 = (X 1, X 2 ), e 2 = (X 1, X 3 ), e 3 = (X 2, X 3 ), e 4 = (X 2, X 4 ), e 5 = (X 3, X 5 ), e 6 = (X 4, X 6 ), e 7 = (X 5, X 6 ), F ={F 1, F 2, F 3, F 4, F 5, F 6, F 7, P ={P 1, P 2, P 3, P 4, P 5, P 6, FA X1 ={P 2, F 7, FA X2 ={P 1, F 6, FA X3 ={P 4, F 2, F 5, FA X4 ={P 3, F 3, F 6, FA X5 ={P 5, F 3, F 5, FA X6 ={P 6, F 1, F 4, and H ={P 1, F 1, F 2, F 3

5 REAL-TIME PERFORMANCE EVALUATION MODEL 169 Figure 1. A simple distributed system with different file distributions Theoretic model Symbolic Method (SM) and Factoring Method (FM) algorithms were proposed to compute the reliability of a distributed computing system with imperfect nodes [10]. FM algorithm first selects a working set of nodes, then applies the factoring technique used in [15] to compute reliability for every sub-graph G jh. R(G H )isthe sum of reliability for every sub-graph G jh. Suppose program P i is on node X k ; data file F i is on node X k or other nodes and these nodes can reach X k through n paths for one sub-graph G jh. Each path includes a working set of nodes. These n paths are from R 1 to R n.for each path, the transmission time for data file F i can be calculated by the capacity of communication link. Suppose data file F 1 (the size of F 1 is L 1 )istransmitted from X k to X 2 through path R i. R i is composed of l 1, l 2,...,l k. The capacity for e 1 is C e1, e 2 is C e2, and so on. The transmission time T (R i )ofr i is: T (R i ) = L 1 C e1 + L 1 C e2 + + L 1 C ek (2) For the sub-graph G jh, transmission time of F i is the minimum value of the transmission time of n different paths. The transmission time of the sub-graph G jh is the maximum value of transmission time of every data file in the FN i.inorder to get this, when a program is running in a distributed environment, we create and maintain a static table to store the status of all needed files for the program execution in other nodes. They are sorted by the transmission time in increasing order in the list. When the program is running, we first set a timer and send a request to a node, which has the smallest transmission time for needed file and is in the first place of the list. If till the timeout, we still can not get the needed file, then we send a request to the second node in the list. Repeat this step until the program gets the needed files.

6 170 JIN ET AL. We use π to represent the list sorting operation, sorting each transmission time of subgraphs from G 1H to G jh : (T 1, T 2, T 3,...,T j ) = π(t (G 1H ), T (G 2H ),...,T(G jh )), (T 1 T 2 T 3 T j ) (3) We use the notation pr(a) to indicate the reliability constraint of A. For program P i,in order to guarantee the reliability constraint of P i is pr(p i ) = λ, R(G jh ) must meet: b R(G jh ) <λ j=1 b+1 R(G jh ) λ j=1 b {1, 2, 3,...,n (4) Successful transmission of data files is the precondition of successful execution of the distributed program. When the reliability of program P i is λ in node X k, T (G H ) = T (G (b+1)h ) is the execution time of P i with reliability λ Algorithms We calculate transmission time of each data file in each sub-graph, and evaluate real-time performance with reliability constraints. This is based on the distributed software with imperfect nodes. The reliability and capacity of communication links are also taken into account as well as the size of data files transmitted. First, we use the modified FM algorithm to get all sub-graphs and compute their reliability for distributed software without time-constrained. Then we calculate transmission time of data files and sub-graphs. At last, we evaluate RTPDS with reliability constraints. When we calculate transmission time of data files for each sub-graph, we first regard the node, which supports the available P i running on it, as the root. Then we locate data files needed for the program execution in the sub-graph, try to find all the possible transmission paths to the root with depth-first method, and then map the transmission paths and capacity of communication links to file Path1. According to Path1, we calculate transmission time for all transmission paths of each data file. The minimal value for all the transmission paths is the transmission time of the data file. In order to describe algorithms conveniently, we use the following notations. TRY: The set of nodes needed to be checked CL: The record of communication links passed when checking data files. R i.capacity: The capacity set of each communication link in R i. R i.size: The size set of data file through each communication link in R i.

7 REAL-TIME PERFORMANCE EVALUATION MODEL Modified FM algorithm. The modified FM algorithm is based on the FM algorithm [8] and also suitable for multi-node distributed computing system. The major improvement is to add a Degree-n Reduction algorithm. The first step in the modified FM algorithm is to select a working set of nodes. We can choose a set of nodes including the programs to be executed (the size of the working set we choose can be very small) as a working set. After we have identified the perfect nodes in each sub-graph, the DPR of each sub-graph with a set Hof needed files can be computed as follow: R(G H ) = pl1 R(G H + e 1 ) + ql1 p l2 R(G H e 1 + e 2 ) + + ql1 q l2...pld R(G H e 1 + e 2 e d 1 + e d ) (5) Moreover, the modified FM algorithm can be used to record each sub-graph so that we can compute transmission time of every file in the sub-graph. Algorithm: FM Input: the original distributed system graphg = (V, E, F, P) and the set H of needed files Output: the distributed program reliability DPR and sub-graphs { do // reduce the original graph G // { perform the Degree-1 and Parallel reductions; perform the Series and Degree-2 reduction; perform Degree-n reduction [14]; until no reductions can be made; Let G H be the distributed system graph after the reduction step; Output(factoring(G H )) Function factoring(g) { if there are no FSTs in G then return (0) if there exists one node n in G such that p n 1 (node n is an imperfect node) and contains the programs to be executed {G 1H G with setting p n = 1; G 2H G with deleting node n and its adjacent edges; Record G 1H and G 2H ; // output sub-graphs // return (p n *factoring(g 1H ) + q n *factoring(g 2H )); return(e factoring(g)); Function e factoring(g H ) { if there exists one node n such that FA n H then return (1); if there are no FSTs in G H then return (0);

8 172 JIN ET AL. do { perform Degree-1 and Parallel reductions; perform Series and Degree-2 reductions; perform Degree-n reductions; until no reductions can be made; let G be the distributed system graph after the reduction step M 0 N 1 // M and N are two variables // for all links l i = (e i, u i,v i ) containing the programs to be executed do M M + N p ei p ui p vi e factoring(g H + e i ); N N(1 p ei p ui p vi ); G H G H e i ; p vi (p vi q ei)/(q vi + p vi q ei); p ui (p ui q ei)/(q ui + p ui q ei); Remove the irrelevant components from G H ; if there are no FSTs in G H then return (M); return (M); The following reduction methods developed for the DPR problem with imperfect nodes can reduce the original distributed system graph to a smaller size. Degree-1 reduction. A node is referred to as a degree-1 node if it has only one incident edge. Degree-1 reduction removes degree-1 nodes that contain no needed data files and programs under consideration and their incident edges. Irrelevant component deletion. Let G be a connected component of G that is not connected to the rest of the components of G.Ifthere are no FSTs in G, then the component G is irrelevant and can be deleted. Parallel reduction. Let e a = (u,v) and e b = (u,v)betwo parallel edges in G. G is obtained by replacing e a and e b with a single edge e c = (u,v)sothat p ec = 1 qea q eb(orp ec = p ea + p eb pea p eb). The parallel reduction for the DPR problem is the same as the parallel reduction for the K-terminal network reliability problem. Series reduction. Let e a = (u,v) and e b = (v, w) betwo series edges in a graph G such that degree (v) = 2 and FA v H = φ, i.e. node v contains no needed data files or programs to be executed. Then a graph G is obtained by replacing e a and e b with a single edge e c = (u,w)sothat p ec = pea p v p eb. Degree-2 reduction. Suppose node v is a reducible node, then one can apply series reduction on node v and move data files and programs within node v to a node u or w. Degree-n(n > 2) reduction. Degree-n reduction is derived from theory of Degree-2 reduction, using probability theory and isomorphism theory of graph to reduce unnecessary nodes. It is suitable for the distributed computing system with complex topology.

9 REAL-TIME PERFORMANCE EVALUATION MODEL Data file transmission path generation. A distributed software often uses data files on other nodes when it is running. The precondition of successful execution is the available scheduler and transmission of data file. The transmission path and the transmission time cost are important to the whole system. In this section, we present a data file transmission path generation algorithm. The main idea is: (1) regards the node, where the available program is, as the root; (2) gives other nodes a symbol which means these nodes are to be checked; (3) starts from the root, performs the depth-first search, at the same time, gets the capacity of communication links about this transmission path and size of data files. The detail algorithm is shown below: Algorithm: Data File Transmission Path Generation Step 1:/*Initialization*/ G = undirected distributed system graph; CL = φ; /*CL is null at beginning */ TRY = a set of all node in G; Step 2:/*Search G and get all transmission paths of data file needed for the execution of available program */ For all program P X i and X i G do {For all file of F j FN P do {TRY = TRY -{X i ;/*Delete the X i from TRY. */ For all node X j G and X j X i do X root = X i ; File Transmission Path(X root, TRY, F j ); Map F j and capacity of each communication link in transmission path R i into file Path1; TRY = a set of all nodes in G; CL = φ; Return Path 1; Function File Transmission Path is used to describe steps to generate file transmission path. The function detail is shown below: Function File Transmission Path(X root, TRY, F j ) { For all adjacent nodes X k of node X root do { if (F j X k ) then { R i = CL {X root,k ; ++i; /*If data file F j is in node X k, the communication link X i,k is in the communication path of data file F j.*/ else if (TRY = φ) then return all paths R i ; /*Return all the transmission paths of data file F j */ else { X root = X k ; CL = CL {X root,k ;

10 174 JIN ET AL. File Transmission path(x root, TRY-{X k, F j ); TRY = a set of all nodes in G except {X i ; This algorithm needs to do a depth-first search and analysis before each transmission path is determined. The overhead may be higher. We can use powerful workstations or clusters to solve this problem Transmission time evaluation algorithm based on data file transmission path. For sub-graph G kh, when the program executes, the time cost for the same data file in different path may be not equivalent. The effect to RTPDS is different. Therefore, how to calculate the transmission time of data file based on the transmission path is the key issue. In Athena, based on the capacity of links and the size of data files transmitted, we first compute the transmission time in each link and add up them together to get the transmission time of data file on this path. The detail of the algorithm is shown below. From this algorithm, we can get the node with the needed file and the smallest transmission time. We then send a request to this node to access the needed file. Algorithm: Transmission Time Evaluation Step 1: /*Initialization*/ j = 1; Step 2: Get all the transmission paths of data file F j in the FN i from file Path1, from R 1 to R n ; Step 3: m = 1; h = 1; Step 4: if (m n) {goto step 5; else { goto step 11; Step 5: T (R m ) = 0; /*Initialize T (R m )*/ Step 6: Get the transmission links of R m (Just like e 1, e 2,...,e g ); Step 7: if (h g) {goto step 10; Step 8: // Calculate file transmission time. // T (R m ) = T (R m ) + L j C eh Step 9: h = h + 1; go to step 7; Step 10: h = 1; m = m + 1; go to step 4; Step 11: store T (R m ) into file TimePath1. The range of m is from 1 to n. T (R m )isthe transmission time of data file F j in mth path; Step 12: T (F j G kh ) = min{t (R 1 ), T (R 2 ),...,T(R n ); Store T (F j G kh ) into file TimePath2; Step 13: j = j + 1; go to step 1;

11 REAL-TIME PERFORMANCE EVALUATION MODEL Real-time performance evaluation algorithm of distributed software with reliability constraint. For simplicity, we assume that the transmission time of the whole sub-graph is the sum of the transmission time of each file. For each sub-graph G kh recorded in the modified FM algorithm, the first step is to calculate the T (G kh )byusing Equation 6: T (G kh ) = max{t (F 1 G kh ), T (F 2 G kh ),...,T (F j G kh ) (6) Now we calculate the time cost of the program. We use real-time performance evaluation algorithm of distributed software with reliability constraint. The main idea is: with the reliability constraint of distributed software, assesses the reliability of each sub-graph file needed for the execution. Based on this, we compute the actual time for the distributed software with reliability constraint. The detail of the algorithm is shown below: Algorithm: Real-time Performance Evaluation Step 1: j = 1; b = 1; Get the transmission timetable of sub-graph; Get Pr(P i ) = λ; Step 2: if ( b j=1 R(G jh) <λand b+1 j=1 R(G jh) λ) Step 3: return T (G H ) = T (G (b+1)h ); Step 4: else {b = b + 1; go to step 2; 4. Case study For the example in Figure 1, the size of F 1 to F 7 is 30 KB, 70 KB, 50 KB, 30 KB, 45 KB, 40 KB and 55 KB, respectively. The capability of e 1 to e 7 is 1 MB/s, 0.5 MB/s, 0.5 MB/s, 1 MB/s, 0.5 MB/s, 1 MB/s, 1 MB/s, respectively. Now we evaluate the real-time performance of program P 1 with the reliability λ (λ = 0.6) on node X i. At first, program P 1 executes with data file F 1 to F 3 on node X 2. The sub-graphs and their reliability can be computed with modified FM algorithm. Transmission paths of data file F 1 to F 3 can be gotten accordingly with every sub-graph. Then we calculate transmission time for all transmission paths and sort them by increasing order. In this way, we get transmission time of the sub-graphs and sort that of all sub-graphs by increasing order. Based on the reliability constraint of program P 1,weget the reliability of each sub-graph. Finally, we can evaluate the RTPDS. The detail evaluation process for program P 1 is as below: Step 1: Assume the reliability of all the nodes and links is 0.9. The complete computation tree of FM is shown in Figure 2. Here W means working set. G is an undirected graph used to describe a distributed system e i is the deleted edge e i. G 1H = G + e 4 + e 6 G 2H = G + e 4 e 6 G 3H = G e 4

12 176 JIN ET AL. Figure 2. The computation tree of modified FM for the example in Figure 1. R(G 1H ) = = R(G 2H ) = = R(G 3H ) = = Step 2:For three sub-graphs G 1H, G 2H, and G 3H,asprogram P 1 is on node X 2,weregard X 2 as the root. Based on the file transmission protocol, we can get the correct place for F 1 to F 3.

13 REAL-TIME PERFORMANCE EVALUATION MODEL 177 Table 1. The data files needed for the execution of P 1 on node X 2, the transmission paths and the transmission time Sub-graph Data file Start End Trans. path Trans. time (ms) G 1H F 1 X 6 X 2 e 6 e 4 60 e 7 e 5 e e 7 e 5 e 2 e F 2 X 3 X 2 e e 2 e e 5 e 7 e 6 e F 3 X 4 X 2 e 4 50 e 6 e 7 e 5 e e 6 e 7 e 5 e 2 e X 5 X 2 e 5 e e 5 e 2 e e 7 e 6 e G 2H F 1 X 6 X 2 e 7 e 5 e e 7 e 5 e 2 e F 2 X 3 X 2 e e 2 e F 3 X 4 X 2 e 4 50 X 5 X 2 e 5 e e 5 e 2 e G 3H F 1 X 6 X 2 e 7 e 5 e e 7 e 5 e 2 e F 2 X 3 X 2 e e 2 e F 3 X 4 X 2 e 6 e 7 e 5 e e 6 e 7 e 5 e 2 e X 5 X 2 e 5 e e 5 e 2 e Step 3:Take the place of F 1 to F 3 as the start node. We search all the transmission paths for F 1, F 2 and F 3. The result is stored in column 4 of Table 1. Step 4: Calculate transmission time for all the transmission paths of each data file and store the result in column 5 of Table 1. Step 5: Calculate the transmission time of data file F 1, F 2 and F 3 for each sub-graph. T (F 1 G 1H ) = min{60, 150, 180 =60 ms T (F 2 G 1H ) = min{140, 210, 350 =140 ms T (F 3 G 1H ) = min{50, 300, 350, 200, 250, 150 =50 ms T (F 1 G 2H ) = min{150, 180 =150 ms T (F 2 G 2H ) = min{140, 210 =140 ms T (F 3 G 2H ) = min{50, 200, 250 =50 ms T (F 1 G 3H ) = min{150, 180 =150 ms

14 178 JIN ET AL. Table 2. Transmission time for all of the transmission paths of data file F 1 to F 3 Transmission time Sub-graph (sorted by increasing order) Reliability G 1H 250 ms G 2H 340 ms G 3H 490 ms T (F 2 G 3H ) = min{140, 210 =140 ms T (F 3 G 3H ) = min{300, 350, 200, 250 =200 ms Step 6: Calculate the transmission time of each sub-graph and sort them in increasing order. See Table 2. T (G 1H ) = T (F 1 G 1H ) + T (F 2 G 1H ) + T (F 3 G 1H ) = 250 ms T (G 2H ) = T (F 1 G 2H ) + T (F 2 G 2H ) + T (F 3 G 2H ) = 340 ms T (G 3H ) = T (F 1 G 3H ) + T (F 2 G 3H ) + T (F 3 G 3H ) = 490 ms Step 7:Evaluate the real-time performance of program P 1 with reliability constraint. Based on Table 1 and 2, when λ = 0.6, T (G H ) = T (G 2H ) = 340 ms. When we evaluate the real-time performance of distributed software with reliability constraint, we must add the file transmission time with the execution time of the program, which is supposed to be a constant in this paper. 5. Conclusions and future works Because the real-time distributed software with reliability constrains is used in extensive areas, it is important to analyze the reliability-constrained RTPDS. In this paper, we propose Athena schema. In this schema, some algorithms are designed to count the transmission time for sub-graphs, and calculate time cost of each data file transmission with reliability constraint. In this way, the RTPDS with reliability constrains can be evaluated. For the time being, we do not take the influence of heterogeneity and communication traffic into the reliability analysis. Besides this, in Athena, we suppose the communication ability of each link is known before ahead. Based on the file transmission path, our next goal is to evaluate the RTPDS addressed reliability with the network traffic influence. At same time, we will try to study how to test the communication ability of each link before using Athena.

15 REAL-TIME PERFORMANCE EVALUATION MODEL 179 References 1. R. Buyya. High Performance Cluster Computing: Architectures and Systems, Vol. 1, Prentice Hall PTR C. C. Chin, Y. S. Yeh, and J. S. Chou. A fast algorithm for reliability-oriented task assignment in a distributed system. Computer Communication, 25: , J. Drummond. Establishing a real-time distributed benchmark. Proceedings of the 4th International Workshop on Parallel and Distributed Real-Time Systems, pp , H. Hu and S. Jin. Reliability model of distributed systems. Computer Engineering and Applications, 8:1 3, D. Jutla, P. Bodorik, and Y. Wang. Developing internet e-commerce benchmarks. Information Systems, 24: , N. I. Kamenoff. One approach for generalization of real-time distributed systems benchmarking. In Proceeding of the 4th International Workshop on Parallel and Distributed Real-Time Systems, pp , A. Kumar and D. P. Agrawal. A generalized algorithm for evaluating distributed program reliability. IEEE Transactions on Reliability, 42: , W. J. Ke and S. D. Wang. Reliability evaluation for distributed computing networks with imperfect nodes. IEEE Transactions on Reliability, 46: , M. S. Lin. The Reliability Analysis on Distributed Computing Systems, PhD dissertation, National Chiao Tung University, Hsinchu, Taiwan, M. S. Lin, D. J. Chen, and M. S. Horng. The reliability analysis of distributed computing systems with imperfect nodes. Computer Journal, 42: , M. S. Lin, M. S. Chang, D. J. Chen, and K. L. Ku. The distributed program reliability analysis on ring-type topologies. Computer & Operation Research, 28: , D. A. Menascé. TPC-W: A benchmark for e-commerce. IEEE Internet Computing, 6:86 87, W. H. Sanders and J. F. Meyer. A unified approach for specifying measures of performance, dependability, and performability. Dependable Computing and Fault-Tolerant Systems, 4: , D. C. Schmidt and C. O Ryan. Patterns and performance of distributed real-time and embedded publisher/subscriber architectures. Journal of Systems and Software, 66: , O. R. Theologou and J. G. Carlier. Factoring and reductions for networks with imperfect vertices. IEEE Transactions on Reliability, 40: , H. Thane and H. Hansson. Testing distributed real-time systems. Microprocessors and Microsystems, 24: , N. H. Weideman and N. I. Kamenoff. Hartstone uniprocessor benchmark: Definitions and experiments for real-time systems. The Journal of Real-Time System, 4: , 1992.