132 IEEE TRANSACTIONS ON RELIABILITY, VOL. 44, NO. 1, 1995 MARCH

An 0 ( n (log2(n) ) 2, Algorithm for Computing the Reliability of k-out-of-n:G & k-to-Z-out-of-n:G Systems

Lee A. Belfore 11, Member IEEE Marquette University, Milwaukee

Key Words - k-out-of-n system, k-to-1-out-of-n system, generating function, computational efficiency, fast Fourier transform.

Reader Aids - General purpose: Present a more efficient algorithm Special math needed for explanations: Probability theory, discrete

Special math needed to use results: Probability Results useful to: Reliability theoreticians & analysts.

mathematics

Summary & Conclusions - This paper presents the RAFFT- GFP (Recursively Applied Fast Fourier Transform for Generator Function Products) algorithm as a computationally superior algorithm for expressing & computing the reliability of k-out-of- n:G & k-to-Z-out-of-n:G systems using the fast Fourier transform. Originally suggested by Barlow & Heidtmann (1984), generating functions provide a clear, concise method for computing the reliabilities of such systems. By recursively applying the FlT to computing generator function products, the RAFlT-GFP achieves an overall asymptotic computational complexity of O(n. Oog,(n))’) for computing system reliability. Algebraic manipulations suggested by Upadhyaya & Pham (1993) are reformulated in the context of generator functions to reduce the number of computations. The number of computations and the CPU time are used to compare the performance of the RAFliT-GFP algorithm to the best found in the literature. Due to larger overheads required, the RAFFI- GFP algorithm is superior for problem sizes larger than about 4OOO components, in terms of both computation and CPU time for the examples studied in this paper. Lastly, studies of very large systems with unequal reliabilities indicate that the binomial distribution gives a good approximation for generating function coefficients, allowing algebraic solutions for system reliability.

1. INTRODUCTION

Acronyms’

FLOP floating point operation CPU central processing unit FFT fast Fourier transform GF generator function RAFFT-GFP recursively applied FFT for computing GF

products.

’The singular & plural of an acronym are always spelled the same.

Definitions

k-out-of-n:G system: n components such that the system is good iff at least k components are good. k-to-Z-out-of-n:G system: n components such that the system is good iff at least k and at most 1 components are good.4

Many researchers have searched for efficient methods for com- puting the reliabilities of k-out-of-n:G & k-to-l-out-of-n:G systems. In particular, [l - 31 address computational efficien- cies for k-out-of-n:G system reliability computation. In addi- tion, several methods also exist for computing the reliability of k-to-Z-out-of-n:G systems [4 - 71 where the Upadhyaya & Pham [5] is the most efficient existing method in terms of the total number of additions & multiplications. With the excep- tion of [3], all methods cited are formulated in terms of algebraic manipulations of the appropriate reliability expression. A great deal of effort has been expended, ultimately achieving a time complexity of o ( n2 ) .

This paper presents an algorithm for computing the reliabilities of k-out-of-n:G & k-to-Z-out-of-n:G systems based on GF and the FFT. The GF are polynomials whose coefficients represent the probability that a specific number of components is good or failed. The degree associated with a coefficient is the number of components that are good or failed. The GF ap- proach for computing reliabilities is not new; it was first sug- gested by Barlow & Heidtmann [3]. Indeed, GF provide a clear, concise representation for system reliability expressions. The basic GF formulation is:

the coefficient for z i is: Pr(exact1y i components are good}.

The k-to-Z-out-of-n:G system reliability is simply the sum of the coefficients of P (2) over the system parameters k to 1. The RAFFT-GFP algorithm uses the FFT to compute GF products for both intermediate & final results. The product of two GF is the same as the convolution of two sequences [9], allowing the more efficient FFT to be used rather than direct methods, as in [3]. Application of the FFT results in an overall o ( n . (Iog2(n))2) asymptotic computational complexity for computing system reliabilities. The notion of using the FFT to compute efficiently the GF product for a collection of GF was suggested in [lo] but not pursued.

Notation

k, I, n p i , qi

parameters of the system (see Definitions) [reliability, unreliability] of component i ; pi + qi E 1

P , C L = , pi

0018-9529/95/$4.00 01995 IEEE

BELFORE: AN O(N(LOG2(N))2) FOR COMPUTING RELIABILITY OF K-OUT-OF-N:G SYSTEMS

-

133

ai qilPi 2

T ( n ) P ( z ) A ( z ) defined in (2) Al ( z ) , A2 ( z ) Other, standard notation is given in "Information for Readers & Authors" at the rear of each issue.

dummy variable associated with a generating function number of FLOP for a problem size n basic GF formulation, defined in (1)

particular manifestations of A ( 2 ) .

Assumptions

1. Components can be in one of two states, either good

2. Component reliabilities may vary. 3. Component failures are s-independent. 4. Component reliabilities, unreliabilities, and their in-

5. Time complexity is nominally measured as the total

or failed (not good).

verses are available at no computational cost [5].

number of FLOP.

2. ALGORITHM OUTLINE

The starting point for describing the RAFFT-GFP algorithm is (1). Rather than computing the GF products term by term with a resulting time complexity of O ( n 2 ) , the FFT is used - resulting in a time complexity of only 0 ( n . (log2(n))). By factoring out the products of the compo- nent reliabilities [5 ] , (1) can be reformulated as:

n

~ ( 2 ) = P,* ( I + (qi/pi)*z) i = 1

n

= P; n ( l + a i . z ) = P,*(l + A ( z ) ) . (2)

Factoring out the product of component reliabilities in (2) nor- malizes probabilities and confers both computational & memory- storage advantages [5 ] . The RAFFT-GFP algorithm in this paper can be applied to either (1) or (2) , and it is important to note that the 0 ( n - (log2(n))2) complexity of the algorithm is not af- fected by this manipulation. Empirically comparing a formula- tion based on (1) with one based on (2) results in an average reduction in floating point computations of 4% for problem sizes ranging from 8 to 4096, with a worst case increase of 0.7% for certain problem sizes within that range. A formulation based on (2) results in fewer computations for two reasons:

i = 1

1. Multiplications by 1 are implicit. 2 . FFT size increases are delayed since the FFT is applied

to A(z).

Section 2.1 presents the RAFFT-GFP algorithm. The motiva- tion for using the FFT in the algorithm is presented and justified. Section 2.2 presents the RAFFT-GFP algorithm. Section 2.3 establishes a proof of the asymptotic time complexity for the RAFFT-GFP algorithm.

2.1 Computing GF Products with Conventional and FFT Methods

Computing the product of two (%n + 1)-degree GF, (1 + A I ( z ) ) & ( 1 + A2 ( z ) ) , using direct multiplication requires %n2 FLOP. Importantly, computing the product of two GF is identical to that of computing the convolution of two sequences formed from the GF coefficients. Thus, the FFT can be used to compute the product [9]. The advantage in using the FFT is that it has a time complexity of O(n.log,(n)) FLOP [8], resulting in a GF product computation with the same time com- plexity. Computing the product of two GF, ( l + A l ( z ) ) & ( 1 +A2 ( z ) ) , using the FFT is a 3-step process:

1. The FFT for A , ( z ) & A 2 ( z ) are computed, where the FFT size must be large enough to hold the resulting product.

2 . The resulting FFT are convolved in the frequency do- main by taking product of the Fourier coefficients computed for A l ( z ) & A2(z ) .

3. The resulting GF product is constructed by computing the inverse FFT for the result from step #2 and then adding in A I ( z ) & A ~ ( z ) . 4

Using probability normalized GF and assuming that n is a power of 2, the number of FLOP necessary to multiply two (%n+ 1)-degree GF using the FFT is:

(3) T d n ) = 15n.log2(n) + I ln - 2 ,

for the implementation used in this paper. Clearly, it is not desirable to apply the FFT for smaller problems since large overheads are involved. To determine the threshold where us- ing the FFT is more efficient, the FLOP necessary to perform the GF product using conventional algorithms need to be com- pared with the RAFFT-GFP algorithm. The GF (1 +A ( 2 ) ) can be computed with the following algorithm which is essentially an unoptimized version of [ 5 ] , described in terms of GF:

pMul(doub1e *a,double *Az,int n) { int i,j; I* ANSI C *I Az[O] = a[O]; for(i=l;i<n;i+ +) {

Az[i] = Az[i - l]*a[i]; for(j=i- l;j>O;j--) Az[j]=Az[j]+Az[j-l]*a[i]; Az[O] = Az[O] + a[i];

I

The reader is reminded that in ANSI C, element #1 in an array is index 0. Memory storage for a & Az must be allocated by the calling routine. pMul computes the system GF by suc- cessively multiplying the intermediate GF, stored in Az, with component GF stored in a. The computation can be performed in place in a single array, but for clarity, two are used. The time complexity for pMul is:

TpM"l(n) = n . (n-1). (4)

134 IEEE 'TRANSACTIONS ON RELIABILITY, VOL. 44, NO. 1, 1995 MARCH

Using the FFT to compute the product of two (%n + 1)-degree GF and pMul to compute (%n+ 1)-degree GF intermediate results, the time complexity for producing an n-degree result is:

Tproduct(n) = 15n.log2(n) + l l n - 2 + 2 ( % n . (%n-1)).

( 5 )

Equating (4) & (5) and then solving for n gives a transition point of n = 264, where the FFT approach is more efficient for n L 264. Because radix-2 FFT have lengths that are discrete powers of 2, the FFT is applied for n L 512 to achieve im- proved efficiencies.

2.2 The RAFFT-GFP Algorithm

To compute reliabilities of large systems, the FFT is ap- plied using a divide & conquer approach. The component GF products are recursively divided into approximately equal pieces, until a threshold is reached where pMul is more effi- cient. Algorithm RAFFT-G FP summarizes this process.

RAFFT-GFP(double *a,double *Az,int n,complex templ ,complex temp2)

{ int size; if(n e =threshold) pMul(a,Az,n); else {

RAFFT-GFP( a, Az, nl2,templ ,temp2); compute lower

RAFFT-GFP(a + nl2,Az + n12,n - n/2,templ ,temp2); half

compute upper half

Tfl(.F FTs ize) the following segment of code has time complexity

FFTsize = liub(log2(n)), initialize templ , temp2 for(i = 0;i e n/2;i + +) templ [$real = Az[i]; for(i = n/2;i < n;i + +) temp2[i - n/2].real= Az[i]; compute FFT of templ and temp2 for(i = 0;i < 2FFTsize;i + + ) templ [i] = templ [i] x

compute inverse FFT of templ add in products with 1 and move results to AZ

temp2[i];

1 1

The system reliability can be computed using RAFFT-GFP and pMul with the routine sysRelFFT.

double sysRelFFT(doub1e *p,double *q,int n,int k,int I) { int i; complex t l [MAX],t2[MAX]; double Rel,P,;

P, = p[O]; for(i = 1 ;i < n;i + +) P,* = p[i]; for(i = 0;i < n;i + +) q[i]/ = p[i]; RAFFT-GFP(q,p,n,tl ,t2); alias array p as a and array q

as Az Re1 = p[k]; for(i = k + 1 ;i < = I;i + +) Re1 + = p[i]; Rel* = P,; return Rel;

1

2.3 Time Complexity Bounds

Theorem 1 establishes upper & lower bounds on the time complexity.

Theorem 1. The upper & lower bounds on the time complexity of sysRelFFT for a threshold of 2 are:

Proof: See appendix.

Further improvements in the time complexity can be achieved by formulating the FFT with a radix larger than 2 or by using a threshold in the range (2,5121.

3. MEASURED PERFORMANCE

The RAFFT-GFP algorithm is compared with the best ap- proach described in the literature [5] in terms of FLOP and the actual CPU time required to compute the reliability for several system configurations. The systems considered are cf. n) -to- (n-2)-out-of-n:G, where 2/n 5 f 5 1 - 2/n, to avoid special cases in the algorithms. Three results are presented, including: a) the experimentally measured time complexity, b) the ex- perimentally measured CPU time, and c) the analysis of large systems.

3.1 Experimentally Measured Time Complexity

I I I I 1

Iei.08 ... ./'

F ..( I I I I I 612 1024 2048 4096 8192 16384

System Size. n

Figure 1. Computation Comparison: [5] vs Our RAFFT-GFP Algorithm

Figure 1 compares the methods. The system reliability is computed with the approach in [5] for various system sizes and f=0.5, 0.75, 0.875. In addition, results for the RAFFT-GFP

BELFORE: AN o(N(Loc~(N))~) FOR COMPUTING RELIABILITY OF K-OUT-OF-N:G SYSTEMS 135

algorithm are plotted for thresholds of 2 and 5 12 as well as up- per & lower bounds for a threshold of 2. For the threshold of 2, the RAFFT-GFP algorithm ultimately becomes more effi- cient than [5] for all cases examined. The sawtooth pattern in the measured time complexity of the RAFFT-GFP algorithm results from requiring an FFT size of 2"'l for 2" < n I 2"". The plot also indicates further improvement is possible by com- paring time complexity bounds of the RAFFT-GFP algorithm with the time complexities of conventional approaches, and then selecting the most efficient approach, as described in [ 5 ] .

3.2 Experimentally Measured CPU Time

lo00

100

10

1

I I I I I

a

256 512 1024 2048 4096 8192 16384 System Size n

Figure 2. CPU-Time Comparison: [5] vs Our RAFFT-GFP Algorithm

Since using the FFT results in more data assignments, data movements, subroutine calls, and transcendental function calls, the CPU time is a fairer performance comparison. Figure 2 plots the CPU time, in seconds, for a Motorola Delta Series 8000 Model 8640 computer system on the same cases examined in figure 1. The times are intended as a comparison of the methods and not as an absolute measure of the CPU time because all programs have been instrumented to count the FLOP perform- ed. The behavior of the RAFFT-GFP algorithm is very similar to that observed in figure 1. The difference is that the RAFFT- GFP algorithm is more efficient for slightly larger system sizes. In addition, for a threshold of 512, the CPU time increases more than anticipated at that point due to increased overhead necessary to compute the FFT. Otherwise, a comparison of results using the time-complexity (measured in FLOP) and those using ac- tual CPU time are consistent.

3.3 Application to Large Systems

Using the RAFFT-GFP algorithm, the reliabilities of very large systems can be computed. Figure 3 plots the probability density of a system having 65 536 components vs the exact number of good components. Comparing the results forp=O.8

and p = [0.78, 0.8212 indicates that variations in component reliabilities for this case are not important, provided that the component average reliability, p7 is known. Two additional cases are included to verify this observation:

component reliabilities are distributed over the range p = [0.6,1 .O] components come from two populations: half with reliabilities o f p = [0.68,0.72] and the other half withp = [0.88,0.92].

N

k' 4

-5

-10

-15

-20

-25

-30

-35

51 500 62WO 62600 63000 63600 Number d working component.

Figure 3. Probability Distribution of Good Components

In both cases, the results are virtually identical to the constant componerd reliabilities of p =O. 8. The differences between these cases are difficult to see in the figure; however, the differences indicate that the distributions for two populations and p = [0.6,1 .O] are slightly narrower than the constant component- reliability cases. For cases shown here and others not presented, the probability distributions peak at 65536F with a shape ap- proaching that of the constant component-reliabilities case. In reality, the constant component-reliabilities case is the binomial distribution. Thus, for very large systems the binomial distribu- tion based on average component-reliabilities is a reasonable approximation.

ACKNOWLEDGMENT

This work was supported by the US National Science Foun- dation under Grant MIP-9 1 1044 1 .

APPENDIX

Proof of Theorem 1

An inductive proof is used to establish the bounds in (6) l!?i (7).

'p is uniformly & randomly distributed over the range [0.78,0.82].

136 IEEE TRANSACTIONS ON RELIABILITY, VOL. 44, NO. 1, 1995 MARCH

Basis: Tow&) = Tsys~el~m (2) = TpMul(2) +2+2+2 = 8, where the additions to TpMul(2) are the computation of the ai,

[2] K.D. Heidtmann, “Improved method of inclusion-exclusion applied to k-out-of-n systems”, IEEE Trans. Reliability, vol R-31, 1982 Apr, pp

[3] R.E. Barlow, K.D. Heidtmann, “Computing k-out-of-n system reliabili- ty”, IEEE Trans. Reliability, vol R-33, 1984 Oct, pp 322-323.

[4] A.M. Rushdi, “Efficient computation of k-to-1-out-of-n system reliabili-

P,, and the computation of the reliability, respectively. 36-40,

Inductive hypothesis: Assume that,

~ ty”, Reliability Engineering,-vol 17, 1988, pp 157-163. qower(n) = ?h ‘15n’(10g2(n) ) 2 -k ?h ‘37n‘log2(n) -23n+2, [5] S.J. Upadhyaya, H. Pham, “Analysis of noncoherent systems and an

for n=2’, u=2,3 ,..., v. architecture for the computation of the system reliability”, IEEE Trans. Computers, vol 42, 1993 Apr, pp 484-493.

[6] S.P. Jain, K. Gopal, “Efficient computation of k-to-1-out-of-n system reliability”, Reliability Engineering,-vol 12, 1985, pp 175-179.

[7] K.D. Heidtmann, “A class of noncoherent systems and their reliability analysis”, Proc. I I’h Ann. Int ’1 Symp. Fault Tolerant Computing,

Inductive step: Find the expression for qower(2n)7 where 2n = 2 ”+ ’.

FTCS-11, 1981 Jun, pp 96-98. [8] J.W. Cooley, J.W. Tukey, “An algorithm for the machine calculation

of complex Fourier series”, Mathematics qf Computation, vol 19, 1965 ( ~ - 1 )

- - Apr, pp 297-301.

of Computation, vol 25, 1971 Apr, pp 365-374.

PhD Dissenation, 1990; Univ. of Virginia.

= 15(2n) ‘10g2(2n) + 11(2n) -2+ 2(,?h’15n*(10g2(n))2 [9] J.M. Pollard, “ThefastFouriertransforminafinitefield”, Marhematics

+ %.37n*log2(n) -23n+2) (A-2) [lo] L.A. Belfore, “Modeling the performance of faulty neural network”,

= 15n.(log2(n))2 + 67n*log2(n) + 6n + 2 (A-3)

= ‘/2-15.(2n).(10g~(2n))~ + %.37(2n)-log2(2n) AUTHOR

Dr. Lee A. Belfore II; Dept. of Electrical & Computer Engineering; Marquette University; POBox 1881; Milwaukee, Wisconsin 53201-1881 USA.

Lee A. Belfore U (M’89) was born (1960 Sep 17) in New Jersey. He has been an Assistant Professor in the Dept. of Electrical & Computer Engineer- ing at Marquette University since 1990. He worked as a Member of the Technical Staff with AT&T Information Systems in 1982-1985 and as a Research Scien- tist with the Dept. of Electrical Engineering, University of Virginia in 1987-1988. He received the BS (1982) in Electrical Engineering from Virginia Tech; the MSE (1983) in Electrical Engineering and Computer Science from Princeton University; and the PhD (1990) in Electrical Engineering from the University

(A-4)

Thus proving the inductive hypothesis on the lower bound. The lower bound is exact for n=2“ and integral v 2 2.

- 23(2n) + 2.

The upper bound Tupper(n) = qOwer(2n), since, worst all computations are performed the next larger FFT’

E. D.

REFERENCES of Virginia. His research interests include fault-tolerant computing and fault analysis of neural networks.

[l] H. Pham, S.J. Upadhyaya, “The efficiency of computing the reliability of k-out-of-n systems”, IEEE Trans. Reliability, vol 37, 1988 Dec, pp 521-523. IEEE Log Number 94-10958

Manuscript received 1994 June 28.

4 T R b

1996 Annual Reliability & Maintainability Symposium 1996 Plan now to attend. January 22 - 25 Las Vegas, Nevada USA

For further information, write to the Managing Editor. Sponsor members will receive more information in the mail.