You are on page 1of 7

Reliability Allocation

Yashwant K. Malaiya
Computer Science Dept.
Fort Collins CO 80523
USA

malaiya@cs.colostate.edu
Phone: 970-491-7031, 970-491-2466

Abstract---A system is generally designed as an assembly of subsystems, each with its own reliability
attributes. The overall system reliability is a function of the subsystem reliability metrics. The cost of
the system is the sum of the costs for all the subsystems. This article examines possible approaches to
allocate the reliability values such that the total cost is minimized. The problem is very general and is
applicable for mechanical systems, electrical systems, computer hardware and software. The problem
involves expressing the system reliability in terms of the subsystem reliability values and specifying the
cost function for each subsystem which allows setting up an optimization problem. Software reliability
allocation is examined as a detailed example. The article also examines some preliminary
apportionment approaches that have been proposed. In some cases, it is possible to use exact
optimization methods. In general, a complex case will require use of iterative approaches.

I. INTRODUCTION

Many systems are implemented by using a set of interconnected subsystems. While the architecture of the overall
system can often be fixed, individual subsystems may be implemented differently. A designer needs to either
achieve the target reliability while minimizing the total cost, or maximize the reliability while using only the
available budget. Intuitively, some of the lowest reliability components may need special attention to raise the
overall reliability level. Such an optimization problem may arise while designing a complex software or a computer
system. Such problems also arise in mechanical or electrical systems. A number of studies since 1960 have
examined such problems [kuo00].
In a non-redundant system, all the subsystems are essential, however often an individual subsystem can be made
more reliable by using a more costly implementation. This additional cost may represent wider columns in a
building or more thorough testing of software. In redundant implementations, higher reliability can sometimes be
achieved by using several copies of a subsystems, such that form a parallel or k-out-of-n configuration.
The next section consider the problem formulation, followed by approaches used for setting up an optimization
problem. As an example, software reliability allocation is examined in detail with two numerical illustrations. The
last section considers reliability allocation in complex systems.

II. Problem Formulation

We assume that a system has been designed at a higher level as an assembly of appropriated connected
subsystems. In general the functionality of each subsystems can be unique, however there can be several choices for
many of the subsystems providing the same functionality, but differently reliability levels.
Here we consider the problem formulation for a common and widely applicable case. Let there be n subsystems
SSi, i = 1,..,n, each with reliability Ri and cost Ci. Let the cost Ci be a function of the reliability given by fi( Ri). Let
Cs and Rs represent the total system cost and the overall reliability and RST be the specified target reliability. If all

1
the subsystems are essential to the system and if their failures are statistically independent, the system can be
modeled as a series system. The cost minimization problem can be stated as:

n n
Minimize Cs = Ci = f i ( Ri ) (1)
i =1 i =1
Subject to
RST ≤ Rs
n (2)
≤ ∏Ri =1
i

Note that equation (1) assumes that the cost of interconnecting the subsystems is negligible. An alternative problem
would be to maximize Rs while keeping Cs less than the allocated cost budget.

The ith subsystem SSi can may have several implementation choices with different reliability values:

A. By extending a continuous attribute (for example diameter of a column in building or time spent for
software testing) the subsystem can be made more reliable.
B. Different venders may offer their own implementations of SSi at different costs.
C. It may be possible to use multiple copies of SSi (for example double wheels of a truck) to achieve higher
reliability. Often the number of copies is constrained between a minimum (often one) and a maximum
number because of implementation issues.

Note that in the first case, both cost and the reliability can be varied continuously, where as in the other two cases,
the choices are discreet. In the first case, we can define a continuous cost function. In the second case too, the
market forces may impose a cost function. In the third case, the subsystem may be modeled as a parallel or k-out-of-
n system for reliability evaluation, provided the failures are statistically independent. A number of publications on
reliability allocation consider only the third case, where the optimization problem becomes an integer optimization
problem. It becomes a 0-1 optimization problem when choices are discreet and a component from a given list of
candidates is either used or not used [majety99].

III. Approaches for Problem Set-up

It is reasonable to assume that the cost function fi would satisfy these three conditions [mettas00]:

1) fi is a positive definite function

2) fi is non-decreasing
3) fi increases at a higher rate for higher values of Ri

The third condition suggests that the it can be very expensive to achieve the reliability value of 1. In fact for
software, it has be shown that under some assumptions, it is infeasible to achieve ultra-high reliability in software
[butler93].

In some cases, the cost function can be derived from basic considerations, as we will do below for software
reliability. In other cases it may derived empirically by compiling data for different choices. The cost function is
often stated in terms of the reliability, for example the cost function proposed by Mettas [mettas00] is given by

Ri − Ri ,min
Ci ( Ri , f i , Ri ,min , Ri ,max ) = exp (1 − f i )
Ri ,max − Ri

2
Where Ri,min and Ri,max are the minimum and maximum values of Ri and fi is parameter ranging between 0 and 1 that
represents the relative difficulty of increasing a component’s reliability. The cost function can also be given in terms
of the failure rate as illustrated below for software reliability allocation.

A useful transformation of equation (2) can be obtained by logarithms of the Ri values in equation [lakey96, lyu02,
elegbede03].
n
ln( RST ) ≤ ln( Ri ) (3)
i =1
The transformation in equation (3) can sometimes reduce the problem to a linear optimization problem. The term
ln(Ri) can also have a well defined physical significance in some cases as the failure rate. When the failure rate of a
subsystem SSi is constant, its reliability is given by an exponential relationship Ri(t) = exp( it), the system failure
rate is given by the summation of the subsystem failure rates and hence equation (3) can be restated as

n
λST ≥ λi (4)
i =1

The failure rate itself a major reliability attribute. In some cases such as in software reliability engineering, it is the
failure rate that is often specified [musa87, lyu97]. The cost function of a subsystem can also be given in terms of its
failure rate. If the cost Ci is given by the function fi( i), equation (1) can be restated as

n n
Minimize CS = Ci = f i (λi ) (5)
i =1 i =1

For example, when software reliability growth is given by the popular exponential reliability growth model (SRGM)
[goel79, musa87, lyu97], the failure rate as a function of testing time d is given by

λi (d ) = λ0i exp(− β i d )

Where 0 and 1 are the SRGM parameters. If we assume that the cost is dominated by the testing time, the cost is
given by the following function which satisfies the three conditions mentioned above.

1 λ0 i
d ( λi ) = ln (6)
βi λi

IV. Reliability Allocation Approaches for Basic Serial and Parallel Systems

The reliability allocation problem for two basic reliability structures series and parallel can be solved by linearizing
the constraints [kuo00, majety99, elegbede03]. In a series system, the constraint is given in equation 2 above, which
can be linearized by rewriting it as

n
ln( RST ) ≤ ln( Ri ) (7)
i =1

which may then be solved relatively easily. An example is given below for software reliability allocation.

In a parallel system, functionally identical subsystems are configured such that correct operation of at least one of
them assures a correctly functioning system. It is assumed that any overhead in implementing such a system is
negligible. In real systems, the overhead involved will result in a lower level of reliability. In a number of studies,

3
the problem assumes that the reliability of a subsystem can be increased by using a functionally identical
components in parallel [majety99, elegbede03]. For parallel systems, the constraint is given by

n
RST ≤ 1 − ∏ (1 − Ri ) (8)
i =1

The constraint can be linearized by using logarithms of the complements of reliability. Thus equation (8) can be
rewritten as
n
ln(1 − RST ) ≥ (ln(1 − Ri ) (9)
i =1

Elegbede et al. have recently shown [elegbede99] that if the cost function satisfies the three properties given above,
the cost is optimal if the all the parallel components have the same cost. For software, computer hardware and
mechanical systems, the number of discrete parallel component is likely to be very small.

V. Reliability Allocation for Software Systems

As a detailed example, we examine the problem of software reliability allocation [lyu02]. Typically a software
consists of a sequentially executed blocks, such that only one is under execution at a time. Each block can be
independently tested and debugged to reduce the failure rate below a target value. In some cases, the reliability of a
block can be further increased by replication. For replication to be effective each replicated version must be
developed independently such that the failures are relatively independent. The impact of replication can be evaluated
by assuming statistical independence. However it has been shown that the statistical correlation tends to be
significant requiring more complex analysis.

Here in this example we consider the common case, a non-redundant implementation of software, divided into n
sequential blocks [lyu02]. Let us assume that a block i is under execution for a fraction xi of the time where Σxi = 1
[lakey96]. Then the reliability allocation problem can be written as

n
1 λ0 i
Minimize C= ln (10)
i =1 β1i λi

n
Subject to λST ≤ x i λi (11)
i =1

Solution: let us solve the problem posed by equations 10 and 11 by using the Legrange multiplier approach by
finding the minimum of

F (λ1 ,...λn ) = C + θ (λ1 + ... + λn ) − λST )

where θ is the Legrange multiplier. The necessary conditions for the minimum to exist are (i) the partial derivatives
of the function F are equal to zero, (ii) θ > 0 and (iii) x1 1+x2 2+ … xn n = ST [lyu02]. Equating the partial
derivatives to zero and using the third condition, the solutions for the optimal failure rates are found as following

λST
x1 β1 x1 β1 x1
λ1 = λ2 = λ1 λn = λ1 (12)
n
β1 β 2 x2 β n xn
i =1 βi

4
The testing times of the individual modules are given by equation 10. The optimal values of d1 and di, i 1 are given
by

n
β1
λ10 x1
1 i =1 βi 1 λi 0 β i xi
d1 = ln and di = ln (13)
β1 λST βi λ1β1 x1

Note that di is positive if i i0. The testing time for a block must be non-negative. If any of the testing times in (13)
are negative, the optimization problem must be solved iteratively [lyu02].

In software reliability engineering, the assumptions involved in formulation of the exponential model imply that the
parameter i is inversely proportional to the software size [musa87, malaiya97], when measures in terms of the lines
of code. The value of xi can be reasonably assumed to be proportional to the code size. The values of i and i0 do
not depend on size but depend on the initial defect densities [malaiya97]. Thus if the exponential model indeed
holds, the equation in (12) state that the optimal values of the post-test failure rates 1, … n are equal. Also if the
initial defect densities are also all equal for all the blocks, then the optimal test times for each module is proportional
to its size.

Example 1: A software system uses five functional blocks B1-B5. We construct this example assuming sizes 1,
2,3,10 and 20 KLOC (thousand lines of code) respectively, and the initial defect densities of 20,20, 20, 25 and 30
defects per KLOC respectively. Let us assume that measured parameter values are given in the top three rows,
which are the inputs to the optimization problem. The solution obtained using equations (12) and (13) are given in
the two bottom rows. Let us now minimize the test cost such the overall failure rate is less than or equal to 0.06 per
unit time.

Block B1 B2 B3 B4 B5
i 7×10-3 3.5×10-3 2.333×10-3 7×10-4 3.5×10-4
i0 0.14 0.14 0.14 0.175 0.21
xi 0.028 0.056 0.083 0.278 0.556
Optimal i 0.06 0.06 0.06 0.06 0.06
Optimal di 121.043 242.085 363.128 1.529×103 3.579×103

Note that the optimal values of i for the five modules are equal, even though they start with different initial values.
This requires a substantial part of the test effort allocated to largest blocks. The total cost is 5.835×103.

Example 2: This is identical to the previous example with one difference, the numbers in the second row for i0 are
obtained assuming all the five module have the same defect density value of 20/KLOC.

Block B1 B2 B3 B4 B5
i 7×10-3 3.5×10-3 2.333×10-3 7×10-4 3.5×10-4
i0 0.14 0.14 0.14 0.14 0.14
xi 0.028 0.056 0.083 0.278 0.556
Optimal i 0.06 0.06 0.06 0.06 0.06
Optimal di 121.043 242.085 363.128 1.21×103 2.421×103

We note that for this example the optimal testing time is exactly proportional to the software size, block B5 is tested
for 20 times the time used for B1. The final failure rates are identical for the five blocks.

5
The above discussion suggest some preliminary rules may be used for obtaining initial apportionments. Some
apportionment rules have been suggested in the literature [lakey96].

Equal reliability apportionment: For example applied to sequential software blocks, such that they each
have the failure rate equal to the target failure rates.

Complexity based apportionment: For example, the software size itself is a complexity metric. Thus the
available test time can be apportioned in proportion to the software size.

Impact based apportionment: A block that is executed more frequently, or is more critical in terms of
failures, should be assigned more resources.

VI. Reliability Allocation for Complex Systems

In practice, many cases can be complex and may require an iterative approach [nasa04, kuo00, majety99,
elegbede03]. Such an approach is also needed if the objective function is multi-objective and includes both total cost
and the system reliability [kuo00]. These steps are based on [nasa04]:

1) Design the system using functional subsystems.

2) Perform an initial apportionment of cost or reliability attributes based on suitable apportionment rules or
preliminary computation.

3) Predict system reliability.

4) Determine if reallocation is feasible and will enhance the objective function. If so, perform reallocation.

5) Repeat until optimality is achieved.

6) See if this meets the objectives. If not, consider returning to step 1 and revising the design.

7) Finalize the design with recommended reliability allocation and the cost projections.

The optimization methods used in steps 2-5 above can be classified into three approaches [kuo00].

1) Exact methods: When the problem is not large, exact methods can be desirable. In general, the problem can
be a non-linear optimization problem. In a few cases, the problem can be transformed into a linear problem,
as shown in the example above.
2) Heuristics based methods: Several heuristics for reliability allocation have been developed. Many of them
are based on identifying the variable to which the solution is most sensitive and incrementing its value.
3) Metaheuristic algorithms: These algorithms are based on artificial reasoning. The best known of them are
genetic algorithms, simulated annealing and tabu-search. These algorithms can be useful when the search
space is large and approximate results are sought.

Some general purpose [reliasoft03] and special purpose [lyu03] software tools have been developed that can
simplify setting up and solving the optimal allocation problem. Reliability allocation problem can also be
formulated to address other reliability attributes like availability [gurov95] or maintainability.

REFERENCES

[kuo00] Kuo W, Prasad VR, An Annotated Overview of System-Reliability Optimization, IEEE Transactions on
Reliability, June 2000, 49: 176-187.
[majety99] Majety SRV, Dawande M, Rajgopal J, Optimal Reliability Allocation with Discrete Cost-Reliability
Data for Components. Operations Research, Nov-Dec 1999, 47: 899-906.

6
[mettas00] Mettas A, Reliability allocation and optimization for complex systems. Proceedings Annual Reliability
and Maintainability Symposium, Los Angeles, CA, January 2000, 216-221
[butler93] Butler RW, Finelli GB, The infeasibility of quantifying the reliability of life-critical real-time software,
IEEE Trans. Software Engineering, 1993, 19:3—12.
[lakey96] Lakey PB, Neufelder AM, System and Software Reliability Assurance Notebook; Rome Laboratory,
1996, Rome NY, 6.1-6.24
[lyu02] Lyu, MR, Rangarajan S, van Moorsel, APA, Optimal allocation of test resources for software reliability
growth modeling in software development. IEEE Transactions on Reliability, Jun 2002, 51: 183-192
[elegbede03] Elegbede AOC, Chengbin C, Adjallah KH, Yalaoui F, Reliability allocation through cost
minimization, IEEE Transactions on Reliability, March 2003, 52:106- 111.
[musa87] Musa JD, Iannini A, Okumoto K, Software Reliability, Measurement, Prediction, Application, McGraw-
Hill, 1897.
[lyu97] Lyu, MR, Ed., Handbook of Software Reliability Engineering, McGraw-Hill, 1995.
[malaiya97] Malaiya YK, Denton J, What Do the Software Reliability Growth Model Parameters Represent? Int.
Symp. on Software Reliability Engineering, 1997, 124-135.
[goel79] Goel AL, Okumoto K, Time-Dependent Error Detection Rate Model for Software and Other Performance
Measures, IEEE Trans. on Reliability, August 1979, 28: 206-211.
[nasa04] NASA Document, Reliability Allocation, Oct 1, 2004, foia.msfc.nasa.gov/docs/NAS8-00179/S&MAOI/R-
Reliability/QD-R-008.pdf
[gurov95] Gurov SV, Utkin LV, Shubinsky IB, Optimal reliability allocation of redundant units and repair facilities
by arbitrary failure and repair distributions. Microelectronics Reliability, Volume 35, Number 12, December 1995,
1451-1460
[reliasoft03] ReliaSoft, Reliability Importance and Optimized Reliability Allocation (Analytical)
http://www.weibull.com/SystemRelWeb/blocksimtheory.htm, 2003.
[nasa04] NASA Document, Reliability Allocation, Oct 1, 2004, foia.msfc.nasa.gov/docs/NAS8-00179/S&MAOI/R-
Reliability/QD-R-008.pdf
{"ft_lang_label":"__label__en","ft_lang_prob":0.8728186,"math_prob":0.9559372,"size":18537,"snap":"2019-26-2019-30","text_gpt3_token_len":4559,"char_repetition_ratio":0.15976906,"word_repetition_ratio":0.030070163,"special_character_ratio":0.23908938,"punctuation_ratio":0.11993195,"nsfw_num_words":0,"has_unicode_error":false,"math_prob_llama3":0.98961157,"pos_list":[0],"im_url_duplicate_count":[null],"WARC_HEADER":"{\"WARC-Type\":\"response\",\"WARC-Date\":\"2019-06-26T00:44:08Z\",\"WARC-Record-ID\":\"<urn:uuid:2ad43434-158c-48ab-8059-9c4598a74722>\",\"Content-Length\":\"271596\",\"Content-Type\":\"application/http; msgtype=response\",\"WARC-Warcinfo-ID\":\"<urn:uuid:ea6b8d27-e12f-4023-9df7-7e861597e00c>\",\"WARC-Concurrent-To\":\"<urn:uuid:dceec531-69a0-41c4-afe8-b169372d5e68>\",\"WARC-IP-Address\":\"151.101.250.152\",\"WARC-Target-URI\":\"https://de.scribd.com/document/37663341/Reliability-Allocation\",\"WARC-Payload-Digest\":\"sha1:34VS574QWAMO5YNULT4GIPPVUUWNVEUF\",\"WARC-Block-Digest\":\"sha1:QFJDEOTIRYWBISYIYRV7NA4IN6J6ISKI\",\"WARC-Identified-Payload-Type\":\"application/xhtml+xml\",\"warc_filename\":\"/cc_download/warc_2019/CC-MAIN-2019-26/CC-MAIN-2019-26_segments_1560627999964.8_warc_CC-MAIN-20190625233231-20190626015231-00371.warc.gz\"}"}