close

Вход

Забыли?

вход по аккаунту

?

978-981-10-5577-5 6

код для вставкиСкачать
Analysis of Module-Based Software Reliability
Growth Model Incorporating Imperfect
Debugging and Fault Reduction Factor
Madhu Jain, Anuradha Jain, and Ritu Gupta
1 Introduction
In the context of software development life cycle, testing has a vital role for
the assessment of the quality metrics which may be helpful in fault detection
and removal process. The prime objective of any level of testing is to detect
software failures so that the defects may be identified and corrected or removed
from the software. The software testing mainly involves module testing, integration
testing, and system and acceptance testing. Initially software modules are tested
independently, and then after the interfaces among modules are tested during the
integration testing which is performed by the developers as well as test engineers.
System testing is performed by professional testing engineers on the completed
software product including all the external interfaces before it is introduced to the
market. The acceptance testing is mainly done during the operational phase. The
prediction of the system reliability of the complex software system has been turned
out as a most important quality metric in present scenario, and thus reliability of
the software modules or the system software as a whole needs to be quantified
under certain reliability requirements subject to testing schedule and resource
constraints. In recent past, the performance prediction of the software system
M. Jain
Department of Mathematics, Indian Institute of Technology Roorkee, Roorkee 247667,
Uttarakhand, India
e-mail: madhufma@iitr.ernet.in
A. Jain
Institute of Basic Science, Khandari, Agra 282002, UP, India
e-mail: anujain_ibs@yahoo.com
R. Gupta ()
AIAS, Amity University, 125, Noida 201303, UP, India
e-mail: rgupta@amity.edu
© Springer Nature Singapore Pte Ltd. 2018
P.K. Kapur et al. (eds.), Quality, IT and Business Operations, Springer Proceedings
in Business and Economics, DOI 10.1007/978-981-10-5577-5_6
69
70
M. Jain et al.
as far as software reliability is concerned was done by Kumar et al. [1]. They
considered fault detection phenomenon in the testing phase when modification can
be made to the software during the testing phase. To allocate the available testing
resources, software developer divides the software into modules to allocate the
testing resources. Reference [2] has described the optimal allocation problem in
modular software systems during the testing phase. They elaborated the problem of
how to allocate and optimize the specified testing resources among all the modules.
In this direction, reference [3] developed a model for large software systems by
integrating a number of relatively small and independent modules that are tested
independently during module testing phase and discussed optimal testing resource
allocation problem too. Quasi renewal process which can be used to estimate the
time delay period and to check the priority of the observed faults has been employed
in order to integrate the information about the software testing and fault debugging
activities in the software testing environment [4]. Reference [5] has discussed the
software modularity and investigated how metrics for high level abstractions of
complex and large module-based system can help to inform on the composition
of high level modules.
In the software reliability modeling and analysis, fault detection and correction
activities reflect the failure occurrence rate directly. Some faults which are not
detected during development phase may produce software unreliability and create
unexpected problems for the users. To overcome such types of problems, reference
[6] proposed pre-compiled fault detection technique to detect and correct faults
before a source code is compiled. Generally it is assumed that the fault removal
time becomes a constant, but fault removal time usually changes with the moment
when the fault occurs. A time-dependent delay function has also been proposed that
is used for the delay of fault removal process [7]. In the literature, the effect of
imperfect debugging is prevalent in favor of removal of the faults during software
reliability modeling. In this context, reference [8] presented discrete and continuous
time models under software failure occurrence phenomenon incorporating imperfect
debugging and fault generation with learning practice. The software reliability
growth models with imperfect debugging have also been studied subject to some
other failure factors like fault reduction factor and multiple change point [9]. The
consumption of testing resources in the testing is important for the developers
and to be measured from cost view point. Keeping this concern in attention,
reference [10] discussed the testing effort-dependent model which includes fault
detections and corrections under imperfect debugging. A recent application on
mobile software has been presented to study the reliability analysis and to examine
the effect of the debugging process on mobile software for the network traffic in
mobile clouds [11]. Moreover, for estimating the number of remaining faults and
measuring the reliability of the software, an imperfect software debugging model
has been proposed which incorporates a log-logistic distribution-based fault content
function [12]; it can be helpful to capture the increasing and decreasing nature or
characteristics of the fault introduction rate per fault.
For the software reliability assessment, some factors besides the imperfect
debugging which are directly related to the environmental factors are debugging
Analysis of Module-Based Software Reliability Growth Model Incorporating. . .
71
time lag and human learning process. Any changes on these factors show the
influence on the fault reduction factor. Fault reduction factor (FRF) is defined by
the ratio of net fault reduction to failure experienced (in terms of ratio of faults
and failures) or net number of faults removed in the proportion to the failure
experienced. Reference [13] analyzed the effect of various parameters which are
needed for the modeling of the software reliability. They studied some parameters
like fault reduction factor which may be used to control the growth of the software
reliability. The fault reduction factor (FRF) plays significant role to handle the
situation of failure occurrence while studying the growth of software reliability.
In this direction, reference [14] has presented an inflection S-shaped software
reliability model that incorporates fault reduction function.
Optimization problem related to software release with the reliability and absolute/optimal cost of the system is a major concern from the developer as well as
customer view point. The problem of determining the optimal time at which the
system testing is stopped and then it is ready for the use in the operational phase
has attracted many researchers who have developed software reliability models
to propose the software release policies in different contexts. References [15–19]
and many others have investigated software release policies in variant contexts to
minimize the development cost while satisfying a reliability objective. Reference
[20] developed the software cost model by incorporating the logistic-exponential
testing coverage function and suggested the optimal release policy based on the
number of remaining faults. As per the requirement in global competition, reference
[21] explored multiple optimal release policies to confine the effect of high levels of
severe faults generated in the software.
In this paper, we develop a software reliability model which consists of Nindependent modules. The modules are different from each other and have different
kinds of faults. The faults are considered as simple, hard, and complex faults in
each module and are tested individually for removing the faults that remain in the
modules of the software. A flexible software reliability growth model is proposed by
considering the imperfect debugging and fault reduction factor during the software
testing in the module phase of the software. We derive explicit expression for the
mean value function for N-independent module-based system which is categorized
from the different kinds of faults. The rest of the paper is organized as follows.
Section 2 describes the software reliability growth model by stating the requisite
assumptions and notations. Section 3 contains governing equations and reliability
analysis. For the prediction of reliability indices, some formulae are derived in Sect.
4. To validate the analytical results, numerical results are provided in Sect. 5. The
concluding remarks and significance of the work done are stated in the final Sect. 6.
2 Model Description
Consider a software system consisting of N modules; each module has different
characteristics from the other module and has different types of faults contents.
To develop a module-based software reliability growth model, it is assumed that
72
M. Jain et al.
the software has K-types of faults. The three-stage time-dependent processes (fault
observation, fault isolation, and fault removal) are considered for each module to
develop module-based software reliability growth model. To make more versatile
model, we incorporate more realistic features by incorporating the concepts of fault
reduction factor and imperfect debugging.
To develop the module-based software reliability growth model (SRGM) which
incorporates the imperfect debugging and fault reduction factor (FRF), we consider
the nonhomogeneous Poisson process (NHPP). For mathematical formulation, the
following assumptions are made:
• The software system is composed of N-independent modules that are tested
individually. The software faults in each module are categorized as simple-,
hard-, and complex-type faults which can be estimated by SRGM by including
the concepts of the imperfect debugging and fault reduction factor.
• Each time when the failure occurs, the corresponding faults are removed
immediately, but besides it, some faults are introduced during the testing process
as such imperfect debugging of faults is taken into account.
• Each module has different types of faults as simple-, hard-, and complex-type
faults; the different type faults have the different failure characteristics.
• When detected, faults are removed at time t; it is possible to introduce some new
.n/
faults with introduction rate kn .t/ in the nth module.
Notations
m(t)
.n/
mobs;kn .t/
.n/
miso;kn .t/
.n/
mrem;kn .t/
a(t)
.n/
akn
.n/
kn .t/
.n/
kn .t/
.n/
rkn .t/
Expected number of total faults removed in the given time interval (0,
t] from the module-based software.
Expected number of kn types (simple, hard, and complex) faults
observed in the nth module at time t.
Expected number of kn (simple, hard, and complex) types of faults
isolated from the nth module.
Expected number of kn -types of faults removed from nth module at
time t.
Sum of the number of faults to be eventually detected and the number
of new faults introduced by time t.
Initial number of kn -types of faults (as simple, hard, and complex faults)
in the nth module.
Imperfect debugging factor for kn -types of faults in the nth module at
time t.
Time-variable fault reduction factor for kn -types of faults for nth
module at time t.
Fault observation (detection)/isolation/removal rate function for kn types of faults for nth module at time t.
Fault introduction rate.
Analysis of Module-Based Software Reliability Growth Model Incorporating. . .
x
P
C0
C1
C2
C3
C4 (T)
T
Tc
˛0
˛
˛2
73
Mission time of the software.
Additional fraction of faults observed during testing.
Cost of setup for the software.
Cost of removing a fault during software testing before releasing.
Cost of removing a fault after releasing the software.
Loss due to software failure or risk cost.
Opportunity cost function.
Testing time of the software.
Software life cycle length.
The scale coefficient.
The intercept value.
The degree of opportunity loss in time.
3 Governing Equations and Analysis
All faults which are presented in the module-based software system have been categorized by simple-, hard-, and complex-type faults of the software. The reliability
of each module will be different due to the different failure characteristics of fault
contents. These faults may require different fault reduction factor and different error
detection rate for each module. Software system consists of the N modules which
are different from each other from the fault content and testing requirement point
of view. Each module has different initial number of faults and dissimilar type of
faults of different severity. There are total K-types of faults in the software whereas
nth (n D 1,2, : : : ,N) module has kn type of faults (kn D 1 , 2 , : : : , Kn ) which may
be simple, hard, and complex. Each nth module consists of pn , simple type faults;
qn , hard type faults; and rn , complex type faults, i.e.:
KD
N
X
2
pn
pn Cqn
N
X
X
X .n/
.n/
4
Kn D
ki C
kj C
nD1
.n/
where kn D
Ppn
.n/
iD1 ki
nD1
C
jDpnC1
iD1
Ppn Cqn
.n/
jDpn C1 kj
C
Ppn Cqn Crn
pn Cqn Crn
X
3
.n/
kk 5
(1)
kDpn CqnC1
.n/
kDpn Cqn C1 kk
and Kn D
PN
.n/
nD1 kn :
Mean Value Function
Mean value function for the software reliability growth model (SRGM) with fault
reduction factor under imperfect debugging environment for observation, isolation,
and removal processes of nth (n D 1, 2, : : : ,N) module can be expressed in terms of
the following differential equations:
74
M. Jain et al.
h
i
@ .n/
.n/
.n/
.n/
mobs;kn .t/ D rkn .t/ akn .t/ mobs;kn .t/
@t
(2)
h
i
@ .n/
.n/
.n/
.n/
miso;kn .t/ D rkn .t/ mobs;kn .t/ miso;kn .t/
@t
(3)
h
i
@ .n/
.n/
.n/
.n/
mrem;kn .t/ D rkn .t/ miso;kn .t/ mrem;kn .t/
@t
(4)
.n/
.n/
.n/
where rkn .t/ D rkn kn .t/
(5)
It is assumed that the fault reduction factor is a constant, so that:
.n/
.n/
.n/
kn .t/ D kn ; 0 < kn 1:
When the detected faults are removed, then there is a possibility that the new
.n/
faults are introduced with rate kn .t/I the imperfect debugging fault analysis for nth
module is taken as:
.n/
@akn .t/
@t
.n/
.n/
.n/
D kn .t/
@mobs;kn .t/
@t
(6)
.n/
where kn .t/ D kn is considered to be constant. The initial condition is imposed
.n/
0; mobs;kn
.n/
.n/
.t D 0/ D 0 and akn .0/ D akn . Now the number of faults to be
as t D
eventually detected is determined by:
.n/
.n/
.n/
.n/
akn .t/ D akn C kn mobs;kn .t/
(7)
By substituting the values of imperfect debugging parameter from (7) to (2), we
.n/
.n/
.n/
obtain: t D 0; mobs .0/ D miso .0/ D mcorr .0/ D 0
.n/
mobs;kn .t/ D
D
.n/
a
kn .n/
1kn
ankn
u.n/
h
.n/ .n/
.n/
r t 1kn
1 e kn kn
v .n/ u.n/ t
1e
i
(8)
Analysis of Module-Based Software Reliability Growth Model Incorporating. . .
.n/
miso;kn .t/
D
.n/
1kn
.n/
akn
u.n/
D
mrem;kn .t/ D
n
.n/
a
kn .n/
1kn
C
D
n
o
.n/ .n/
kn rkn t
1
e
.n/
.n/
akn
.n/
akn
u.n/
1 ev
hn
.n/
kn
.n/ t
ev
.n/
kn
n
.n/
eu
.n/
kn 1
e
1
(9)
o
1
o
.n/ .n/
1 ekn rkn t .1 C t/
v .n/ t
1e
.n/
.n/
.n/ .n/
1
1 e kn
tekn rkn t
.n/ .n/
rkn kn
n
.n/ t
o
.n/ .n/
k rk t
n n
.n/
kn
e
75
o
.1 C t/ C
v .n/
.n/
kn
(10)
n
o
u.n/
v .n/ t
1e
te
.n/ .n/
where 1 kn D u.n/ and kn rkn D v .n/ .
The mean value function for our proposed model that incorporates the fault
reduction factor under imperfect debugging environment is obtained by using:
m .t/ D
N
X
.n/
mobs;kn .t/ C
Kn h
N X
i
X
.n/
.n/
miso;kn .t/ C mrem;kn .t/
(11)
nD1 kn D1
nD1
Here, our main interest is to evaluate the total expected number of faults removed
from each of the modules. The mean value function for the software reliability
growth model based on module-based system consisting of the fault reduction factor
and operating under imperfect debugging environment is:
m.t/ D
D
PN
nD1
PN
.n/
nD1
PKn
kn D1
PKn
h
i
.n/
mrem;kn .t/
.n/
akn
kn D1 u.n/
.n/
n
o
.n/
1 ev t .1 C t/ C
.n/
v .n/
.n/
kn
n
.n/
1 eu
tev
.n/ t
o (12)
.n/
where kn > 0,kn > 0,rkn > 0,akn > 0.
4 Performance Measures
We assume the modules of the software system are independent from the software
testing point of view. Software testing is carried out at the modular level. Now we
obtain the software reliability and expected maintenance cost for modular-based
SRGM as follows:
76
M. Jain et al.
4.1 Software Reliability
Environment factors are directly related to the fault reduction factor. Imperfect
debugging and debugging time lag between fault detection and correction process
affect the fault reduction factor. The impact of changes in environment factors is
directly related to fault reduction factor that affects the software testing time.
The software reliability function is given by:
R .x=T/ D exp Πfm .T C x/ m.T/g
D exp
C
PN
PKn
nD1
v .n/
.n/
kn
Te
.n/
akn
kn D1 u.n/
v .n/ T
hn
ev
.n/ T
n .n/
oo
ev x .1 C T C x/ .1 C T/
n
o
n
o u.n/
v .n/ .TCx/
u.n/
1e
.T C x/ e
1e
(13)
4.2 Expected Maintenance Cost
The objective of our model is to find the reliability of each module so that the
reliability of the system will be maximized within a given budget. For evaluating
the expected maintenance cost of the software, various cost factors, viz., risk cost
and opportunity cost, are important from the customer’s point of view. The total
expected maintenance cost includes the setup cost, cost of removing a fault before
and after releasing a software, risk cost, and opportunity cost.
The total expected maintenance cost of the module-based software is given by:
E fC.T/g D C0 C C1 .1 C P/ m.T/ C C2 Œm .Tc /
.1 C P/ m.T/ C C3 .T/ C C4 .T/
(14)
where the risk cost due to software failure after releasing the software is computed
using:
C3 .T/ D C3 f1 R .x=T/g
(15)
The opportunity cost of the software is computed in the form of power law as:
C4 .T/ D ˛0 .˛1 C T/˛2
By using (12), (13), (15), and (16), (14) gives:
(16)
Analysis of Module-Based Software Reliability Growth Model Incorporating. . .
PN PK
E fC.T/g D C0 C .1 C P/ .C1 C2 / nD1 knnD1
n
o
.n/
.n/
.n/
Tev T
C v.n/ 1 eu
kn
CC2
PN
PKn
nD1
CC3 1 exp
C
v .n/
.n/
kn
.n/
akn
kn D1 u.n/
Tev
PN
hn
1 ev
n
o
.n/
1 ev Tc .1 C Tc / C
PKn
nD1
.n/ T
.n/
akn
u.n/
.n/
akn
kn D1 u.n/
.n/ T
v .n/
.n/
kn
.1 C T/
n
o
.n/
1 eu
77
Tc ev
.n/ T
c
o
oo
hn
n
.n/
.n/
ev T ev x .1 C T C x/ .1 C T/
n
o
n
o .n/
.n/
.n/
1 eu
.T C x/ ev .TCx/ 1 eu
CC4 ˛0 .˛1 C T/˛2
(17)
The prime goal of present investigation is to determine the optimal software
release time which minimizes the total expected maintenance cost of the software
to achieve the desired level of reliability. The prespecified minimum achieved
reliability objective is R0 . Therefore the optimization problem to determine the
optimal release time for the proposed model can be formulated as follows:
Minimize EfC(T)g
Subject to R .x=T/ R0 ; 0 < R0 < 1
(18)
5 Numerical Illustration
In this section, we perform the numerical experiments to examine the effect
of different parameters on the reliability of the module-based software system
by varying testing time T. We set the default parameters as a(1) D50, a(2) D200,
a(3) D300, (1) D0.4, K1 D 2, K2 D 3, (2) D0.6, (3) D0.7, (1) D0.7, (2) D0.8,
(3) D0.9, r(1) D0.5, r(2) D0.6, r(3) D0.7, and x D 0.005.
Figures 1, 2, 3, and 4 illustrate the software reliability R by varying testing time
T for different values of initial number of faults (a(1) ), fault removal rate (r(1) ), fault
reduction factor ((1) ) in module 1, and fault introduction rate ((2) ) in module 2,
respectively. It is noted that initially reliability increases sharply up to T D 15 then
it becomes almost constant. In Fig. 1, as we increase the initial number of faults
(a(1) ), a decreasing pattern of software reliability is observed. We see in Fig. 2 that
the reliability of the software increases on increasing the fault removal rate (r(1) ).
Figure 3 depicts that there is no significant effect of fault reduction factor (1) on
the reliability with the variation in testing time. The effect of fault introduction
rate (2) on the reliability by varying T is shown in Fig. 4. It is found that on
increasing the testing time T, reliability decreases significantly for higher values
of fault introduction rate.
78
M. Jain et al.
1
Fig. 1 Software reliability
by varying a(1)
0.8
0.6
R
a1=50
0.4
a1=100
a1=150
0.2
0
0
5
10
15
T
20
25
30
1
Fig. 2 Software reliability
by varying r(1)
R
0.9
r1=.5
0.8
r1=.7
r1=.9
0.7
0.6
0
5
10
15
T
20
25
30
1
Fig. 3 Software reliability
by varying (1)
R
0.9
μ1=.5
0.8
μ1=.6
μ1=.7
0.7
0.6
0
5
10
15
T
20
25
30
Analysis of Module-Based Software Reliability Growth Model Incorporating. . .
79
1
Fig. 4 Software reliability
by varying (2)
0.9
R
0.8
η2=.4
0.7
η2=.6
0.6
η2=.8
0.5
0.4
0
5
10
15
T
20
25
30
Based on the numerical results, we conclude that the reliability of module-based
software system increases on increasing the fault removal rate (r(1) ) but decreases
on increasing the initial number of faults (a(1) ) and fault reduction factor ((2) ).
6 Conclusion
To analyze the realistic scenarios of testing process for complex software system,
the module-based software reliability growth model is developed by incorporating
the key factors, namely, fault reduction factor and imperfect debugging. From the
software testing point of view, by using these factors together, our investigation
portrays the more versatile and practical issues of the software testing and debugging
processes. We have formulated the expressions for the mean value function and
software reliability. The optimal release time is established by minimizing the
total expected maintenance cost of the software subject to reliability constraints
of a modular software system. Our model provides valuable insight to improve the
reliability of modular system wherein failure is an unavoidable phenomenon due
to imperfect debugging. Numerical illustration provided exhibits the tractability of
testing issues of the complex modular-based software system.
References
1. Kumar S, Zeephongsekul P, Balasubramanian S (1995) Modelling and analysis of a software
system with improvements in the testing phase. Math Comput Model 22:183–191
2. Huang CY, Lo JH (2006) Optimal resource allocation for cost and reliability of modular
software systems in the testing phase. J Syst Softw 79:653–664
80
M. Jain et al.
3. Jha PC, Gupta D, Yang B, Kapur PK (2009) Optimal testing resource allocation during module
test considering cost, testing effort and reliability. Comput Ind Eng 57:1122–1130
4. Jain M, Jain A (2013) Quasi renewal analysis of software reliability growth model incorporating testing efforts and time delay. Int J Maths Oper Res 5:721–742
5. English M, Buckley J, Collins JJ (2016) Chapter 8- Investigating software modularity using
class and module level metrics. Soft Qual Assur pp 177–200
6. Deeprasertkul P, Bhattarakosol P, O’Brien F (2005) Automatic detection and correction of
programming faults for software applications. J Syst Softw 78:101–110
7. Yang X, Sang N, Lei H (2008) An improved NHPP model with time- varying fault removal
delay. J Elec Sci Tech China 6:270–273
8. Satnawi O (2009) Discrete time NHPP models for software reliability growth phenomenon. Int
Arab J Info Tech 6:124–131
9. Jain M, Manjula T, Gulati TR (2012) Software reliability growth model (SRGM) with
imperfect debugging, fault reduction factor and multiple change point concepts. Adv Intel Soft
Comput 131:1027–1037
10. Peng R, Li YF, Zhang WJ, Hu QP (2014) Testing effort dependent software reliability model
for imperfect debugging process considering both detection and correction. Reliab Eng Syst
Saf 126:37–43
11. Tamura Y, Yamada S (2015) Air application for reliability analysis considering debugging
process and network traffic in mobile clouds. Simul Model Pract Theo 50:165–175
12. Wang J, Wu Z, Shu Y, Zhang Z (2015) An imperfect software debugging model considering
log-logistic distribution fault content function. J Syst Softw 100:167–181
13. Hsu CJ, Huang CY, Chang JR (2011) Enhancing software reliability modeling and prediction
through the introduction of time-variable fault reduction factor. Appl Math Model 35:506–521
14. Pachauri B, Dhar J, Kumar A (2015) Incorporating inflection S-shaped fault reduction factor
to enhance software reliability growth. Appl Math Model 39:1463–1469
15. Jain M, Priya K (2002) Optimal policies for software testing time. J Comp Soc Ind 32:25–30
16. Jha PC, Gupta A, Kapur PK, Gupta D (2009) Release time decision policy of software
employed for the safety of critical system under uncertainty. Opsearch 45:209–224
17. Kapur PK, Singh O, Bardhan A (2005) A software reliability growth model for operational use
with testing coverage. Qual Reliab Inform Tech, pp 61–73
18. Pham H, Zhang X (1999) Software release policies with gain in reliability justifying the cost.
Ann Softw Eng 8:147–166
19. Singh O, Kapur PK, Anand A (2012) A multi-attribute approach for release time and reliability
trend analysis of a software. Int J Syst Assur Eng Manag 3(3):246–254
20. Chatterjee S, Singh JB (2014) A NHPP based software reliability model and optimal release
policy with logistic-exponential test coverage under imperfect debugging. Int J Syst Assur Eng
Manag 5(3):399–406
21. Singh O, Aggrawal D, Anand A, Kapur PK (2015) Fault severity based multi-release SRGM
with testing resources. Int J Syst Assur Eng Manag 6(1):36–43
Документ
Категория
Без категории
Просмотров
0
Размер файла
261 Кб
Теги
978, 5577, 981
1/--страниц
Пожаловаться на содержимое документа