SREPT: Software Reliability Estimation and Prediction Tool

User Manual
6/30/1999
SREPT greets the user with a welcome screen consisting of the CACC (Center for Advanced Computing
and Communication) logo. The user can then choose a specific engine to use, depending on the data
available and type of analysis required.
The currently implemented modules in SREPT are :
1. Product/process metrics for early prediction of software fault content
2. ENHPP (Enhanced non-homogeneous Poisson process) - for analyses using inter failure times and
coverage information from testing
3. Debugging policies to analyze the effect of debugging policies

1. Product/Process metrics
SREPT currently offers the Fault density approach to obtain early estimates of software quality.
The Fault density module is chosen by selecting the appropriate engine in the menu as in Figure 1.

Figure 1

The interface for the fault density module lets the user enter a module name (for example, the name of a C
source file), and the number of lines in that module. The user needs to then enter Experience from past
projects. This consists of the number of faults observed in the past project and the number of lines of code
in that project. The table containing the module names and the number of lines can also be loaded from a
file, by clicking the button labeled Click to read data into table from file. To calculate the number of
expected faults in the current project, the user needs to click the button labeled Estimate the number of
faults. An example is shown in Figure 2.

Figure 2

If the table containing the module names and the number of lines in each module is to be loaded from a file,
the file should have the following format for each line:
Module_name blank spaces and/or tabs Number_of_lines
For example,
analyze.c
multpath.c

946
387

If there is a third field in a line of the file, that field is displayed under the column labeled Number of
faults. This could be the case for example, if the table was previously saved after the estimation of the
number of faults was done.

2. ENHPP
The ENHPP module is chosen from the menu as shown in Figure 3.
The ENHPP module allows the following types of input:
Inter failure times alone
Inter failure times and coverage data from testing
Estimate of the total number of faults in the software and coverage data from testing
The type of input data can be chosen using the ENHPP module interface , as shown in Figure 4.

Figure 3

Figure 4

When the type of input data chosen is Use inter failure times data only, the user should specify the file
containing the inter failure times. This file should contain one inter failure time per line. Thus the format is:
Inter failure time 1
Inter failure time 2
When inter failure times data alone are used as input, the user can either specify a coverage function to
use, or let SREPT help find the best of the four coverage models built into SREPT currently. These are :
Exponential (GO) model
Weibull
S-shaped
Log-logistic
coverage models.

The user can override the default initial values in the numerical solution of the models when a
configuration window (shown in Figure 5) pops up. SREPT reports the Kolmogorov distances for each
model based on the u-plot (Bias test) and also the sum of square errors (Goodness of fit test). The results of

choosing the Use best model under Coverage models to use in the interface and the u-plot generated
are shown in Figure 6 and Figure 7 respectively.

5
Figure
Figure6 5

Figure 6

7 set is the log-logistic coverage function. The

Figure 8
Figure 8 also shows that SREPT prints out the model parameters estimated in a textarea labeled
Messages. The Mean value function is also displayed. The coverage function fitted is shown in a separate
textfield. By clicking on the Obtain release time button, the user can now use SREPT to estimate the
release time for the software. When the button Obtain release time is clicked, a window with the release
criteria pops up. Figure 9 shows the interfaces when the Faults remaining criteria is chosen.

Figure 9
Plots of Mean value function, Failure intensity Faults remaining, Conditional reliabiulity,
Estimated coverage can be obtained by choosing Plots from the main menu. Figure 10 shows the
interface for the plots window with the mean value function plotted. The irregular line is the actual failure
data plotted, whereas the smooth curve is the fitted curve corresponding to the log-logistic coverage model
in this case.

Figure 10
In Figure 10, and everywhere the same plot package is used, the number of points to plot, as well as the
minimum and the maximum t values can be altered by the user. By clicking on the button labeled Plot
it!, the user can redraw the plot with the specified values. By dragging the mouse over a section of the
plot, the plot can be zoomed-in. Clicking on the Plot it! button resets the plot to how it was before any
zoom-in.
The ENHPP module also allows the input data to consist of the inter failure times and coverage information
from testing. This coverage information from actual measurements will yield better estimates than before.
The coverage information may be either in the form of a function (a distribution function, implying that it is
a function of time t, approaching 1.0 as t approaches infinity, and 0 at t = 0), or in the form of
coverage values.
If coverage information is supplied as coverage values, the values should be specified in a file. Each line
of the file should contain the inter failure time (which is also specified as an input separately) and the
coverage value at that time. So, the format of the file containing coverage information is,
Interfailure time 1 blank spaces and/or tabs coverage at this time
Interfailure time 2 blank spaces and/or tabs coverage at this time

10

The interface to choose the type of coverage information to be used is shown in Figure 11.

Figure 11
When the coverage information is specified as coverage values from a file, SREPT does not currently fit a
coverage function, and hence does not at this time allow estimates of release times. The plots also appear
different as can be seen from Figure 12.

11

Figure 12

The plot package shown in Figure 12 (it is also used in some other modules in SREPT), allows the user to
zoom in by dragging the mouse over a region while holding down the Shift key. Dragging the mouse
while holding down the Ctrl key translates the plot. Clicking on the Reset button restores the plot to its
default appearance.
When the type of input available to the ENHPP module is an estimate of the total number of faults and
the coverage information from testing, SREPT again allows the coverage information to be a coverage
function (of time variable t), or coverage values in a file. The format of this file is,
time 1 blank spaces and/or tabs coverage at this time
time 2 blank spaces and/or tabs coverage at this time

12

The user also needs to supply an estimate of the total number of faults in the software. Figure 13 shows the
interface for this input type.

Figure 13

3. Debugging policies
The Debugging policies module can be used to study the effect of non-zero fault removal times as well
as different debugging policies on the observed failure intensity and the number of faults remaining. An
example of this module is shown in Figure 14.
In the interface shown in this figure, it can be seen that the user has to specify a Truncation level. This is
the level at which the infinite state space of the underlying NHPP (non-homogeneous Poisson process) is
truncated. This is necessary for numerical solution. The truncation level should be chosen by trial and error,
for example by trying out a slightly higher truncation level and verifying that the results dont differ by too
much. An initial estimate of the truncation level could be the expected total number of faults in the
software. For example, this estimate could be got if inter failure times for this software was available and
was used to fit a coverage function using the ENHPP module. In that case, a truncation level that is greater
than the expected total number of faults can be used.
Next, the user needs to supply a failure intensity. This again can come from the ENHPP module. SREPT
reports the coverage function fitted (c(t)). If a is the expected total number of faults (given infinite testing
time), which is one of the parameters estimated for all the coverage functions fitted, then the failure
intensity is

13

a*c(t)
where c(t) is the derivative of c(t) with respect to time t.
The interface ensures that the failure intensity is of the form a*c(t), by having separate entry fields for a
and c(t).

Figure 14

The process of fault removal can be optionally specified as Delayed, in which case the Fault removal
rate will consist of two phases, each with possibly a different rate. The two phases represent the time
before debugging actually starts and the time it takes to debug, once debugging starts. If the Delayed
checkbox is not checked, the user needs to enter just one Fault removal rate.
The process of fault removal can also be Deferred. This option can be used to specify that debugging
does not start till the specified number of faults are logged.
Clicking the button labeled Solve brings up a configuration window that lets the user specify the time up
to which the solutions are required and the time steps to use in the solution. Choosing very small time steps
improves accuracy but slows down the solution, whereas choosing large time steps speeds up solution at
the cost of accuracy.

14

The plots of the faults remaining and the perceived and actual failure intensities can be got by choosing
Plots from the main menu. An example is shown in Figure 15.

Figure 15

15

4. Architecture of SREPT
The source files in the current version of SREPT and their function is indicated in Table 1.
File name

Function
GUI that brings up a configuration window to
specify initial values for the ENHPP coverage
function solvers
GUI spec. for the configuration window for the
Debugging policies module
Solves NHCTMC by invoking SHARPE
Starting point for the ENHPP engine
Routines for the coverage functions in the ENHPP
model
GUI spec for the dialog that pops when a ENHPP
coverage function is being fitted. The dialog
prompts for the estimation to be stopped if desired.
Interfaces for the "Fault density" module
Generates a "file viewer" window that displays the
contents of the file whose name is passed as an
argument to the constructor.
GUI that brings up a configuration window to
specify initial values for the Exponential (GO)
coverage function solver.
Specify help file names here
Construct the help window
Dialog to display messages. Mainly used to display
error messages.
Routines to determine the best coverage model
GUI that brings up a configuration window to
specify initial values for the Log-logistic coverage
function solver.
Used in association with InfoDIalog.java to generate
the message text.
Generates plots. Derived from the graph package.
GUI spec. for the "Plots" frame when data points
rather than functions are plotted.
GUI spec. for the "Plots" frame when functions
rather than data points are plotted.
Routines for computing the release times
based on the ENHPP coverage functions.
Starting point for SREPT.
Contains the interfaces for the main SREPT window
GUI spec. for the "Welcome screen"
GUI that brings up a configuration window to
specify initial values for the S-shaped coverage
function solver.
GUI spec. for plotting the u-plots
GUI that brings up a configuration window to
specify initial values for the Weibull coverage
function solver.

AllConfig.java
DebuggingConfig.java
DebuggingSolve.java
Enhpp.java
Enhpp_engine.java
EnhppEngineDialog.java
FaultDensity.java
FileViewer.java
GoelConfig.java
Help.java
HelpWindow.java
InfoDialog.java
KolmogorovDist.java
LogConfig.java
MultiLineLabel.java
mygraph.java
PlotChart.java
Plots.java
ReleaseTime.java
Srept_application.java
Srept_container.java
Srept_Welcome.java
SshapedConfig.java
Uplots.java
WeiConfig.java

Table 1

16

5. Acknowledgements
The following packages were obtained from the web and used in the SREPT software.
1. graph a graph plotting package authored by Leigh Brookshaw available under GPL from
http://www.sci.usq.edu.au/staff/leighb/graph/
2. lundin a package authored by Patrik Lundin that performs symbolic differentiation. Available from
http://www.javathings.com/mathpackage.html
The package is free for NON COMMERCIAL use, a license for commercial use is $30 and can be
payed online through a secure server
In addition a routine to obtain roots of equations by the bisection method was obtained from
http://www.nyx.net/~smanley/cs3113/4.html

17