Abstract
In this paper, we propose an algorithm to construct the Ordered Binary Decision Diagram (OBDD) representing the cut function of a terminal-pair network. The algorithm recognizes isomorphic sub-problems and thus avoids re-dundant computations. The system reliability could be ef-ficiently computed by the OBDD. Finally, we propose an approach to compute the importance measures for multiple components by traversing the OBDD only once. The cor-rectness and the effectiveness of our approach are demon-strated by experiments on 30 benchmark networks. The experimental results on a 2-by-100 lattice network, which has 299 paths or 10,000 cuts, show an impressive im-provement compared to the previous works using the sum of disjoint products method that have exponential complexity. The CPU time of our method, including the calculation of not only the reliability but also the importance measures, for a 100-stage lattice network is only about 0.24 seconds. Thus, this approach is very helpful for the reliability and sensitivity analysis of large networks.
1. Introduction
In recent literature [1-7], the existing algorithms for computing the terminal-pair reliability of a network can be grouped into two categories according to their approaches. The algorithms in the first category require enumeration of all the simple paths. These methods deal with a complete set of non-disjoint events and bring a lot of computation com-plexity. The algorithms in the second category are based on decomposing a network into a disjoint event tree. Since all the paths of the tree are disjoint, the network reliability is the sum of the probabilities of these disjoint paths. However, identifying all the disjoint paths in a network is difficult and
† Y.R. Chang is also with Institute of Nuclear Energy Research, Atomic Energy Council, Taiwan.
‡ I.Y. Chen is with Department of Computer Science and Information Engineering of National Taipei University of Technology, Taipei, Taiwan. Acknowledgment: This research was supported by the National Sci-ence Council, Taiwan, R.O.C. under Grant NSC 92-2623-7-002-004-NU.
is a well-known NP-hard problem [4]. Hence, determining the terminal-pair reliability of a network is thus very time-consuming.
Most of previous works [1-7] focused on speeding up calculations by reducing the computation as much as pos-sible. In general, these algorithms lack effective methods to enumerate all the simple paths and do not support efficient manipulation of Boolean algebra. Although these algo-rithms have been demonstrated with a reasonable efficiency on medium-scale networks, they have two inherent draw-backs. First, the sum of disjoint product forms is inefficient in dealing with larger Boolean functions. Second, the tree-based partition algorithm does not consider the merg-ing of isomorphic sub-problems, so that redundant compu-tations cannot be avoided.
Since 1986, when Bryant [8] first proposed the Ordered Binary Decision Diagram (OBDD) representations of Boolean functions and proved some fundamental results on OBDDs, lots of researches have been developed based on this structure and its variations. OBDD is based on the Shannon expansion and can be recognized as a graph-based set of disjoint products. Based on this property, Kuo [9] first proposed a feasible OBDD-based algorithm for computing the terminal-pair reliability of a large network. The main idea, which makes the approach in [9] much more efficient than previous works, is that the OBDD can be automatically constructed by converging isomorphic sub-problems during traversing the network from source to sink. Therefore, the reliability can be quickly derived from the OBDD. The method in [9] focused on the path set of a terminal-pair network. However, in this paper we try to use the cut method to construct the OBDD.
Moreover, identifying the critical components is also an important issue for the reliability analysis and the optimi-zation design of network topology. In this paper, we will propose an OBDD-based algorithm to compute the impor-tance measures of multiple components of a network during a single-pass traversal of the OBDD. The experimental re-sults on a 2-by-100 lattice network show that our method is much better than previous algorithms, which have
expo-A Cut-Based expo-Algorithm for Reliability expo-Analysis of Terminal-Pair Network
Using OBDD
Yung-Ruei Chang
̙, Hung-Yau Lin, Ing-Yi Chen
̚, and Sy-Yen Kuo
Department of Electrical Engineering, National Taiwan University
nential complexity by using the sum of disjoint products. The proposed algorithm will be useful for the terminal-pair reliability and sensitivity analysis of large networks.
Section 2 illustrates the preliminaries of OBDD. A cut-based method for constructing the OBDD of a termi-nal-pair network is proposed in Section 3. This method avoids the redundant calculations on isomorphic sub-problems. Section 4 presents several OBDD-based algorithms to compute the reliability measures including the reliability (availability) and the Birnbaum importance measures of a terminal-pair network. Section 5 shows the experimental results on 30 benchmark networks. Section 6 gives the conclusions.
2. Preliminaries
OBDD [8] is based on a disjoint decomposition of a Boolean function called the Shannon expansion. Given a Boolean function f(x1,,xn), then for any i{1,,n};
i i i x x x { 1 : 0 1 xi i xi i f x f x f (1)
In order to express the Shannon decomposition concisely, the if-then-else (ite) format [10][11] is defined as:
) , , (xi fxi 1 fxi 0 ite f
The way that OBDDs are used to represent logical op-erations is simple. Let Boolean expressions f and g be:
) , , ( ) , , ( ) , , ( ) , , ( 0 1 0 1 0 1 0 1 G G x ite g g x ite g F F x ite f f x ite f j x x j i x x i j j i i
A logic operation between f and g can be represented by OBDD manipulations as:
° ¯ ° ® ! ¡ ¡ ¡ ¡ ¡ ¡ ¡ ) ( ordering ) ( ordering ) , , ( ) ( ordering ) ( ordering ) , , ( ) ( ordering ) ( ordering ) , , ( ) , , ( ) , , ( 0 1 0 1 0 0 1 1 0 1 0 1 j i j j i i j i i j i x x G f G f x ite x x g F g F x ite x x G F G F x ite G G x ite F F x ite
where ¸ represents a logic operation such as AND or OR. For more details on using the operations of OBDD, please refer to [8]. In practice, using logical operations on vari-ables generates the OBDD.
A useful property of OBDD is that all the paths from the root to the leaves are mutually disjoint. If f represents the system reliability expression, based on the property of the disjoint decomposition of OBDD, the reliability (or avail-ability) of the system can be recursively evaluated by (1).
} Pr{ } Pr{ } Pr{ } Pr{ } Pr{f xi fxi 1 xi fxi 0 (2)
where Pr{·} means Pr{·=1} for simplification. For example, if Pr{xi} is the reliability Ri of component i and Ui is the
unreliability of component i, then the system reliability R is
0 1 0 1 (1 ) } Pr{f RiRxi UiRxi RiRxi Ri Rxi R (3)
whereRxi 1andRxi 0representPr{fxi 1}andPr{fxi 0}
respec-tively. Similarly, the unreliability of a system can be
cal-culated as: 0 1 } Pr{g UiUxi RiUxi U (4)
where g is the system unreliability expression and the dual of f ; i.e. f(x1,x2,,xn){1g(1x1,1x2,,1xn){ ) , , , ( 1g x1 x2 xn , Uxi 1 and Uxi 0 represent Pr{gxi 1}
andPr{gxi 0} respectively. In this paper, we will focus on the unreliability expression g based on the cut-set method.
3. Constructing OBDD Based on Cut Method
This section presents a cut-based method to construct the OBDD that represents the cut function of a terminal-pair network. The OBDD is automatically constructed with the convergence of isomorphic sub-problems during traversing the network from the source to the target in edge reduction diagrams. Therefore, our approach avoids redundant cal-culations and reduces the execution time significantly. Notation
Gk a graph representing a terminal-pair network in
the edge reduction diagram. Ck the cut function corresponding to Gk.
sk, tk the [source, target] of Gk.
Ek the index set of edges connected to sk in Gk.
ei an edge connected to sk in Gk, iEk.
Gk*i the sub-graph of Gk obtained by deleting all edges
connected to sk and moving sk to the node where ei
is connected.
RN(Gk*i) eliminating the redundant nodes from Gk*i; the
redundant node is the node which has only one edge connected with.
i i x
x , event variables, [xi 1,xi 1] represents the edge ei to be [functional, failed].
, Boolean [AND, OR]: [conjunction, disjunction]. A terminal-pair network means a network with a given source vertex and a given target vertex. For a terminal-pair network, the graph Gk in the edge reduction diagram is
composed of the union of the sub-graph Gk*i and the edge ei
connected to the source. Therefore,
i ki
E i k e G G k * (5)
To avoid redundant calculation, except sk and tk in Gk*i,
some redundant nodes which are connected with only one edge can be eliminated. For example, G1 is equivalent to
RN(G0*1) and G8 is equivalent to RN(G5*6) in Fig. 1. Since
only redundant nodes are eliminated, the cuts of RN(Gk*i) is
equivalent to the cuts of the original graph Gk*i. Fig. 1 shows
the complete edge reduction diagram of an example ter-minal-pair network G0. Each rectangle Gk represents a
network that is constructed from the parent graph by de-leting all edges connected to the source node and elimi-nating the redundant nodes. Each Gk has a corresponding
cut function Ck that is composed of a set of cuts. Therefore,
network G0. We need to construct an OBDD to represent C0.
A dash line in Fig. 1 represents a cut of the network since it separates the terminal graph t from the root graph G0. That
means if we cannot reach the target, then the system has failed. To find all of the cuts (dash lines) of G0, we found
that there exist some relationships between the cut function of a graph and that of its sub-graphs. For G0, there are two
edges, x1 and x2, connected to the source of G0. That means
there are two branches of G0 in the edge reduction diagram.
A branch will fail if its corresponding edge or sub-graph fails. Therefore, the rule to find a cut of G0 is to let both
branches fail. Hence, the cuts of G0 are {x1x2, x1the
cuts of G2, x2the cuts of G1, the cuts of G1the cuts of
G2} as the dash lines in Fig. 1. Note that, for simplification,
not all of the cuts (dash lines) of G0 are shown in Fig. 1. This
forms the recursive relationship of the cut function, i.e.
i thecutsof RN( k*i)
E i k x G C k (6)
For example, C0 is:
) ( ) ( 1 1 2 2 0 x C x C C (7)
Based on the disjoint property of OBDD, the cut func-tion of a given terminal-pair network could be easily con-structed by using the AND, OR manipulations of OBDD. Additionally, the ordering of the variables is determined by the breadth-first searching method [9] for a compact size of the OBDD.
Moreover, instead of the conventional tree-based parti-tions, our diagram-based reduction can avoid the redundant computations of isomorphic sub-graphs. Fig. 1 contains nine non-terminal nodes and one shared isomorphic graph
G8. In our algorithm, we use a hash table to record the
network topology and its corresponding cut function (i.e. cut-based OBDD) for each shared isomorphic graph. This hash table can avoid the redundant computations on iso-morphic graphs. If we get a hit in the hash table, we do not need to recalculate the information of this graph. We can retrieve it from the hash table. A proper hash table can re-duce the time to compare network topologies. When the network becomes larger and more complex, it brings a sig-nificant growth on the number of isomorphic graphs. The benefit of using the hash table becomes significant. Fig. 2
shows the cut-based OBDD of G0 derived by our method.
The cut-based algorithm for constructing the OBDD of a terminal-pair network using edge reduction diagram is shown in Fig. 3.
4. Reliability Analysis Using OBDD
4.1. Reliability (Availability)
In the previous section, the cut-based OBDD of a given terminal-pair network, g, is obtained. Based on the disjoint
property of OBDD, we can efficiently derive the reliability (R) or availability (A) of a network system from the use of
t t 1 x x2 3 x x4 x5 6 x x7 x8 x6 x6 x4 x8 3 x 7 x 8 x 2 1 x x 2 4 3 ) (xx x 5 1 x x 5 4 3 ) (xx x x3 x4 x6 x7 x8 s t G1 x6 x7 x8 s t G3 G4 x6 x7 x8 s t x8 s t G7 x 7 s t G8 x3 x7 s t G6 x5 x3 x4 x6 x7 x8 s t G2 G5 x3 x4 x6 x7 x8 s t G0 s t x1 x2 x3 x4 x5 x8 6 x7 x6 t t 1 x x2 3 x x4 x5 6 x x7 x8 x6 x6 x4 x8 3 x 7 x 8 x 2 1 x x 2 4 3 ) (xx x 5 1 x x 5 4 3 ) (xx x x3 x4 x6 x7 x8 s t G1 x6 x7 x8 s t G3 G4 x6 x7 x8 s t x8 s t G7 x 7 s t G8 x3 x7 s t G6 x5 x3 x4 x6 x7 x8 s t G2 G5 x3 x4 x6 x7 x8 s t G0 s t x1 x2 x3 x4 x5 x8 6 x7 x6
Figure 1. Edge reduction diagram for a terminal-pair network.
1 0 1 x 8 x 2 x x2 3 x 3 x x3 4 x x4 x4 x4 x4 5 x 5 x 5 x 6 x 6 x 7 x 7 x 1 0 1 x1 x 8 x8 x 2 x2 x xx22 3 x3 x 3 x3 x xx33 4 x4 x xx44 xx44 xx44 xx44 5 x5 x 5 x5 x 5 x5 x 6 x6 x 6 x6 x 7 x7 x 7 x7 x
Figure 2. The cut-based OBDD of G0 in Figure 1. Procedure bdd Cut_BDD_Construct(Gk)
bdd bdd_op, bdd_result;
sk= the source vertex of Gk;
if (Gkis the target) then return (bdd_one);
if ( ( bdd_result = find_hash_table(Gk) ) is a hit) then return (bdd_result);
bdd_result = bdd_one;
For each eiconnected to the skin Gk{
compute Gk*i;
eliminate redundant nodes in Gk*i; // i.e. RN(Gk*i)
bdd_op = Cut_BDD_Construct(Gk*i);
bdd_op = BDD_or(Ɲi, bdd_op);
bdd_result = BDD_and(bdd_result, bdd_op); }
insert_hash_table(Gk, bdd_result);
free temp bdd nodes during manipulations; return(bdd_result);
}
Figure 3. The cut-based algorithm for constructing the OBDD of a network.
the reliability or availability of each component in prob-ability calculation, respectively.
} Pr{
1 g
R or A 1Pr{g} (8)
4.2. Importance Measure
The Birnbaum importance measure of a component (say component k) represents the probability that a system is in a critical state with respect to that component, i.e. the prob-ability that the system is initially in a good state and the failure of component k causes the system to fail. In [12] two algorithms are proposed to compute the Birnbaum impor-tance measure using OBDD. However, the algorithms pre-sented in [12] take more computational time and calculate only one component’s importance measure at a time. They need to be run again to obtain the importance measure of another component. In this section, we propose an algorithm to compute multiple components’ importance measures with only a single-pass OBDD traversal.
The Birnbaum importance measure is defined as the partial derivative of the system unreliability with respect to the failure probability of component k:
} Pr{ } Pr{ ) ( ) ( ) ( 1 0 w w { xk xk k B k g g t F t F t I (9)
where F(t) is the system failure probability at time t, Fk(t) is
the failure probability of component k at time t; Fk(t)
= Pr{gxk 1} where xk 1(0) means component k is faulty
(good). g is the system structure function and Pr{gxk 1}
(Pr{gxk 0}) is the unreliability of the system given that
component k has failed (not failed).
A) Two-pass traversal
This method traverses the OBDD twice to obtain the importance measure for component k [12].
x Find Pr{gxk 1}using OBDD; i.e., find the system
unre-liability by assuming component k has failed.
x Find Pr{gxk 0}using OBDD; i.e., find the system
unre-liability by assuming component k is not faulty.
x Pr{gxk 1}Pr{gxk 0} gives the Birnbaum importance
measure for component k.
B) Modified single-pass traversal
There are two steps in a single traversal. In the first step, from definition (9), the importance measure depends on the probability of state transition of component k. Therefore, a disjoint path, which goes to terminal one and does not in-clude component k in it, will not contribute to the impor-tance measure of component k. We should delete this type of paths or let the probabilities of the paths be 0 when trav-ersing the OBDD.
The second step is similar to the procedure in Method A for nodes in finding Pr{gxk 1}and Pr{gxk 0} except for the
node corresponding to component k. Therefore, we combine
the two calculations at the node corresponding to compo-nent k and compute the probability of each node (say i) in OBDD using the following rules:
x If node i is corresponding to component k, then
} Pr{ } Pr{ } Pr{gk gxk 1 gxk 0 (10)
x If node i is not corresponding to component k and
or-dering(i) > ordering(k), then
1 Pr{ }
Pr{ } } Pr{ } Pr{ } Pr{gi xi gxi 1 xi gxi 0 (11)
x If node i is not corresponding to component k and
or-dering(i) < ordering(k), then also use (11) to calculate
Pr{gi} except that let the probability of sub-tree
Pr{gxi 1}(Pr{gxi 0})be 0 in (11) if the right (left) sub-tree is independent of component k. To check if the sub-tree of node i is independent of component k is simple. Let node j be the sub-node of node i. If ordering(j) > order-ing(k) then the sub-tree is independent of component k.
Finally, when we have finished traversing the OBDD, we get the probability of the root, Pr{g}. Pr{g} gives the Birnbaum importance measure of component k.
C) Single-pass traversal for multiple components
This method traverses the OBDD only once to get the importance measures of multiple components. This method
is extended from Method B. If : is the set of components
whose Birnbaum importance measures are to be calculated, Pr{g(0)} is the system unreliability, and Pr{g(k)} is the Birnbaum importance measure of component k, then we can compute the following at each node (say i):
x For each node i
1 Pr{ }
Pr{ (0)} )} 0 ( Pr{ } Pr{ )} 0 ( Pr{gi xi gxi1 xi gxi 0 (12) x For eachk:
– If node i is corresponding to component k, )} 0 ( Pr{ )} 0 ( Pr{ )} ( Pr{gi k gxi 1 gxi 0 (13)
– If node i is not corresponding to component k and or-dering(k) > ordering(i), then let the probability of sub- tree Pr{gxi 1(k)} (Pr{gxi 0(k)})be 0 in (14) if the right (left) sub-tree is independent of component k. Then cal-culate Pr{gi(k)} using (14).
1 Pr{ }
Pr{ ( )} )} ( Pr{ } Pr{ )} ( Pr{gi k xi gxi1 k xi gxi 0 k (14)
– Otherwise, do nothing since Pr{gi(k)} is equivalent to
Pr{gi(0)}.
Finally, the probabilities, Pr{g(k)} for all k:, at the
root in the OBDD gives the Birnbaum importance measure of component k. Fig. 4 illustrates the OBDD-based algo-rithm for the calculation of Birnbaum importance measures of multiple components by traversing the OBDD only once.
5. Experimental Results
Our algorithm has been implemented on a Linux Red Hat 7.3 operating system with Pentium-III CPU and 128 Mbytes memory. All of our programs are written in C
lan-guage. In the evaluation, we used 30 benchmark networks collected in [1-7][9] as shown in Fig. 5. All the unsuccess probabilities of links are 0.1. The results for terminal-pair network reliability match the results reported in [1-7][9]. It should be noted that our method does not assume the cuts or the minimum cutest to be given previously while the pre-vious works [1-7] generally assumed that and finding them is very time-consuming.
Table 1 illustrates the reliability and the execution time obtained by our method as well as the comparison of the SDP methods [5][7] and the OBDD-based methods. The comparison of results between the SDP and the OBDD size is not straightforward because the OBDD representation represents a Boolean function as a graph-based set of
dis-joint products, which differs from the SDP of two-level forms. However, we still compare the number of disjoint cuts in [5] with the number of nodes in OBDD as a reference. The EED-ISO [9] column is the size of OBDD nodes based on path-set method. To the best of our knowledge, [5] has the best result in minimizing the number of disjoint products using an SDP generating method with a random and pre-processed list of cut-sets. For networks #17 to #19, the OBDD representations are more compact for large disjoint cut sets when the number of cuts > 200. However, compared with EED-ISO [9], the number of nodes using OBDD based on path-set method or cut-set method is of the same order.
The computation time in [5] is CPU time in seconds on an FPS 500 system and does not include the cut-set gen-eration time. The approach in [7] is an efficient method to computing the terminal-pair reliability, but no disjoint cuts were generated. The time in [7] is the CPU time in IBM RISC System/6000. The EED-ISO [9] based on the path-set method using OBDD is run on a SPARC 20 workstation with 128 Mbytes memory. The execution time of our algo-rithm includes the times for the construction of OBDD and the reliability evaluation from the OBDD. For a large-scale network, especially network #19 and #30, the effectiveness of our algorithm becomes significant. Our cut-based ap-proach has a great improvement over the previous works. Although, compared with EED-ISO [9], the performance is the same order as that based on the path-set method; how-ever, we propose a new method based on the cut-set method using OBDD.
Table 2 shows the Birnbaum importance measure of each component in network #2 and #19. When the cut-based OBDD of a network have been constructed, we only need to traverse the OBDD once to get all the Birnbaum importance measures. Therefore, by our method, we can efficiently identify the critical components of a network for the sensi-tivity analysis.
6. Conclusions
This paper has two main contributions. First, we have proposed an algorithm to construct an OBDD representing the cut function of a network. The algorithm recognizes isomorphic sub-problems and thus avoids redundant com-putations. Therefore, the system reliability can be efficiently derived based on the OBDD. Second, we have proposed an approach to compute the importance measures for multiple components by traversing the OBDD only once. This technique could be applied to systems whose system structure function is represented by an OBDD. The ex-perimental results showed that our method is very efficient and can handle very large complex terminal-pair networks. Based on this approach, researches on sensitivity analysis, importance measures, failure frequency analysis or optimal
struct imp { // Importance Measure
double g[m]; // the set of components whose Birnbaum’s importance } // measure is to be evaluated
main() {
static imp bim, bdd_one, bdd_zero; for k = 0 to m
bdd_one.g[k] = 1; bdd_zero.g[k] = 0; next
bim = measure(root);
// bim.g[0] is the system unreliability;
// bim.g[k] is the Birnbaum’s importance measure of component k; }
Procedure imp measure(bdd xi) { // xiis a node in Fig. 2
imp result, n_true, n_false;
if ( xi= BDD_one ) then return (bdd_one);
if ( xi= BDD_zero ) then return (bdd_zero);
if ( result = get_computed_node(xi) is a hit ) then return (result);
n_true = measure(sub_node_true(xi));
n_false = measure(sub_node_false(xi));
result.g[0] = q * n_true.g[0] + p * n_false.g[0]; // q = 1 – p
for k = 1 to m // the set of components whose Birnbaum’s importance if (xiis component k ) then // measure is to be evaluated
result.g[k] = n_true.g[0] – n_false.g[0]; elseif ( ordering(xi) < ordering(k) ) then
sub_true = n_true.g[k]; sub_false = n_false.g[k];
if n_true is independent of component k then sub_true = 0; if n_false is independent of component k then sub_false = 0; result.g[k] = q * sub_true + p * sub_false;
end if next
insert_computed_node(xi, result);
return (result); }
Figure 4. The OBDD-based algorithm for calculating the Birnbaum importance measure of multiple components.
s t s t s t s t s t s t s t s t s t s t s t s t s t s t s t s t s t t s s t t s t s 16 3u t s 12 3u t s 20 2u t s 100 2u s t t s s t A complete network with 10 nodes (1) (6) (11) (16) (21) (26) (2) (7) (12) (17) (22) (27) (3) (8) (13) (18) (23) (28) (4) (9) (14) (19) (24) (29) (5) (10) (15) (20) (25) (30) s t s t s t s t s t s t ss tt ss tt ss tt s t s t ss tt s t s t s t s t s t s t s t s t s t s t s t s t ss tt s t s t s t s t s t s t t s t s s t s t t s t s t s 16 3u t s 16 3u t s 12 3u t s 12 3u t s 20 2u t s 20 2u t s 100 2u t s 100 2u s t s t t s t s s t s t A complete network with 10 nodes (1) (6) (11) (16) (21) (26) (2) (7) (12) (17) (22) (27) (3) (8) (13) (18) (23) (28) (4) (9) (14) (19) (24) (29) (5) (10) (15) (20) (25) (30) (1) (6) (11) (16) (21) (26) (2) (7) (12) (17) (22) (27) (3) (8) (13) (18) (23) (28) (4) (9) (14) (19) (24) (29) (5) (10) (15) (20) (25) (30) s t s t s t s t
design issues of multi-state systems will be the focus of our future works.
References
[1] S. Rai and K.K. Aggarwal, “An efficient method for reli-ability evaluation of a general network”, IEEE Trans.
Reli-ability, vol. R-27, pp. 206-211, Aug. 1978.
[2] J.A. Abraham, “An improved algorithm for network reli-ability”, IEEE Trans. Reliability, vol. R-28, pp. 58-61, 1979. [3] S. Rai, A. Kumar, and E.V. Prasad, “Computer terminal
re-liability of computer network”, Rere-liability Engineering, vol. 16, pp. 109-119, Jan. 1986.
[4] S. Harri and C.S. Raghavendra, “SYREL: A symbol reli-ability algorithm based on path and cut-set methods”, IEEE
Trans. Computers, vol. C-36, pp.1224-1232, Oct. 1987.
[5] S. Soh and S.Rai, “Experimental results on preprocessing of path/cut term in the sum of disjoint products technique”,
IEEE Trans. Reliability, vol. 42, pp. 24-33, Mar. 1993.
[6] S. Soh and S. Rai, “CAREL: Computer Aided RELiability evaluator for distributed computing networks”, IEEE Trans.
Parallel and Distributed Systems, vol. 2, pp. 199-213, Apr.
1991.
[7] Y.G. Chen and M.C. Yuang, “A cut-based method for ter-minal-pair reliability”, IEEE Trans. Reliability, vol. 45, pp. 413-41, Sept. 1996.
[8] R.E. Bryant, “Graph-based algorithms for Boolean function manipulation”, IEEE Trans. Computers, vol. C-35, pp. 677-691, Aug. 1986.
[9] S.Y. Kuo, S.K. Lu, and F.M. Yeh, “Determining Termi-nal-Pair Reliability Based on Edge Expansion Diagrams Using OBDD”, IEEE Trans. Reliability, vol. 48, no. 3, pp. 234-246, Sept. 1999.
[10] A. Rauzy, “New algorithms for fault tree analysis”,
Reli-ability Engineering and System Safety, vol. 40, pp. 203-211,
1993.
[11] R.M. Sinnamon and J.D. Andrews, “Improved efficiency in qualitative fault tree analysis”, Quality and Reliability
En-gineering Int’l., vol. 13, pp. 293-298, 1997.
[12] R.M. Sinnamon and J.D. Andrews, “Fault Tree Analysis and Binary Decision Diagrams,” Proc. Ann. Reliability and
Maintainability Symp., (RAMS ’96), pp.215-222, Jan. 1996.
Table 1. The comparison of the SDP and OBDD methods.
–: no data, Dcut: number of disjoint cuts, Nodes: size of OBDD nodes.
Lex: lexicographic ordering used to minimize Dcut, C&L: lexicographic ordering and cardinality used to minimize Dcut.
Time: CPU time, including the times required by Cut_BDD_Construct(), and Reliability(). 0.00 if the CPU time consumed < 0.01. The sampling period is 0.00195312 second.
Network # of cuts Reliability Lex
[5] C&L [5] EED-ISO [9] Our Method Lex [5] CUT [7] EED-ISO [9] Our Method
Dcut Dcut Nodes Nodes Time Time Time Time
1 4 0.978480 5 4 10 9 0 0.00 0.00 0.00 2 9 0.968425 16 12 15 20 0 0.00 0.00 0.00 3 8 0.997632 13 10 26 24 0 0.00 0.00 0.00 4 9 0.977184 21 14 22 17 0 0.00 0.00 0.00 5 28 0.964855 82 50 50 68 0 0.00 0.00 0.00 6 18 0.996664 25 23 39 49 0 0.00 0.00 0.00 7 20 0.997494 62 43 51 61 0 0.00 0.00 0.00 8 29 0.996217 115 73 66 53 0.1 0.00 0.00 0.00 9 19 0.975116 76 42 36 31 0 0.00 0.00 0.00 10 20 0.984068 78 43 68 50 0 0.00 0.00 0.00 11 24 0.969112 120 38 48 67 0 0.00 0.00 0.00 12 396 0.997186 4496 1386 548 621 0.2 0.02 0.03 0.00 13 110 0.994076 315 150 157 153 0.1 0.01 0.00 0.00 14 528 0.904577 11443 3854 126 131 0.3 0.02 0.00 0.00 15 25 0.974145 157 81 40 43 0 0.00 0.00 0.00 16 78 0.997506 321 202 407 351 0.1 0.03 0.02 0.00 17 1300 0.985928 61651 16194 643 589 3.8 0.20 0.05 0.01 18 214 0.987390 11198 2319 292 260 0.2 0.15 0.03 0.00 19 7376 0.997024 1126719 281453 3591 3324 189.3 3.00 0.35 0.07 20 105 0.987831 – – 177 179 – 0.02 0.02 0.01 21 8742 0.975557 – – 1148 1148 – 0.55 0.43 0.16 22 1721 0.998059 – – 1505 1681 – 0.20 0.08 0.02 23 16 0.959624 – – 46 45 – 0.00 0.00 0.00 24 436 0.995744 – – 250 441 – 0.03 0.03 0.01 25 256 1.000000 – – 49785 46257 – 5.40 14.10 2.17 26 – 0.975224 – – 4970 4970 – – 15.75 4.74 27 34241 0.961730 – – 317 317 – – 3.65 0.98 28 – 0.956266 – – 437 437 – – 70.73 18.16 29 400 0.784482 – – 115 115 – – 0.02 0.01 30 10000 0.304317 – – 595 595 – – 2.52 0.24
Table 2. The Birnbaum importance measure of network #2 and #19.
–: no data, BI: Birnbaum importance.
Network #2 Network #19
Edge BI Edge BI Edge BI
1 0.186567 1 0.012377 16 0.000656 2 0.097548 2 0.002033 17 0.001322 3 0.025377 3 0.001590 18 0.000877 4 0.018816 4 0.001625 19 0.000425 5 0.097548 5 0.001517 20 0.001507 6 0.010716 6 0.001490 21 0.001495 7 0.098277 7 0.002213 22 0.000422 8 0.107106 8 0.000484 23 0.001524 – – 9 0.000548 24 0.001521 – – 10 0.000650 25 0.000513 – – 11 0.000654 26 0.001624 – – 12 0.000753 27 0.001592 – – 13 0.001186 28 0.012396 – – 14 0.012377 29 0.012400 – – 15 0.002033 30 0.012420
![Table 1 illustrates the reliability and the execution time obtained by our method as well as the comparison of the SDP methods [5][7] and the OBDD-based methods](https://thumb-ap.123doks.com/thumbv2/9libinfo/8821408.232386/5.918.88.442.103.461/table-illustrates-reliability-execution-obtained-comparison-methods-methods.webp)
