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

1/--страниц