Reliability assessment using UML models.
The role of satisfying of non-functional requirements is at least important as it is for functional requirements. The non-functional requirements are often evaluated in the end of the whole software development process which might cause the additional costs and also the inevitable requirement for redesigning the whole system architecture. Therefore, the evaluation of non-functional requirements at early stages of software development process is the topic of our research.
One of the most important non-functional requirements, which cannot be missed out when designing software system, is the reliability. The software reliability (Shooman, 1983) is the probability that a software system is performing successfully its required functions for the duration of a specific mission profile. In the past years there were introduced several approaches to evaluate reliability of software systems (Shooman, 1983). The (Zarras & Issarny, 2000) presents that evaluating the reliability at the architecture level is possible.
Although there were introduced several techniques for reliability evaluation, we think there are still some challenges and problems to solve. Goal of this paper is to critically review these techniques, define the problems and outline the steps to develop new software reliability evaluation technique.
2. Related work
There exist several traditional approaches for reliability assessment of software systems but they common these facts:
* Reliability is evaluated on system as whole.
* Various reliability modelling techniques (reliability block diagrams, fault trees, Markov chains, etc.)
As nowadays the Unified Modelling Language (UML) is becoming the standard for specification and design of object oriented software, the question is if UML is a suitable tool for reliability modelling. (OMG, 2009)
UML provides notations describing the static and the dynamic aspects of software from analysis stages to design and implementation. It is desirable to provide reliability assessment from UML notations.
Next we introduce three approaches or techniques which use software specification in UML diagrams for reliability evaluation purposes.
2.1 Approach of Cortellessa et al.
This approach (Cortellessa et al., 2002) can assess reliability from early stage of software development lifecycle. It uses annotated UML diagrams:
1. Use Case diagram
2. Sequence diagram
3. Deployment diagram.
Use Case diagram is annotated as follows:
* [q.sub.1] and [q.sub.2] represent the probabilities of requesting services from system for users [u.sub.1] and [u.sub.2],
* [P.sub.11] and [P.sub.12] represent that user [u.sub.1] requests the functionality [f.sub.1] represented by use case [uc.sub.1] or [f.sub.2] represented by use case [uc.sub.2].
[FIGURE 1 OMITTED]
Then the probability of executing general use case x is:
[MATHEMATICAL EXPRESSION NOT REPRODUCIBLE IN ASCII.] (1)
where m is the number of user types.
Then they assume that for each use case there are specified all relevant Sequence Diagrams representing main scenarios each use case. These sequence diagrams have the non-uniform probability distribution according to following equation:
P([k.sub.j]) = p(j)*[f.sub.j](k) (2)
where [f.sub.j](k) is the frequency of the k-th overall the sequence diagrams referring to the j-th use case and parameter P([k.sub.j]) represents the probability of a scenario execution.
In sequence diagram, the approach focuses on the interval where the component is busy. For example, in Figure 2 the interval, when component [C.sub.3] is busy, is between the moment when interaction [l.sub.1] enters the component and interaction [l.sub.2] leaves the component. The total number of busy periods of component [C.sub.3] is 2.
Then the estimate of the probability of failure [[theta].sub.ij] of the component [C.sub.i] in the scenario j represents the next equation:
[MATHEMATICAL EXPRESSION NOT REPRODUCIBLE IN ASCII.] (3)
where [bp.sub.ij] the number of busy periods that component [C.sub.i] has in the scenario j.
[FIGURE 2 OMITTED]
[FIGURE 3 OMITTED]
The deployment diagram in Figure 3 includes the same components from the sequence diagram. The subject of failure probability [[psi].sub.i] is every communication between components (l, m) through the connector i and |Interact(l, m, j)| represents the number of interactions between components l and m from the scenario (sequence diagram) j. Table 1 shows the number of interactions which are exchanged between all possible pair of components from the scenario (component diagram) in Figure 2.
Then the contribute [[psi].sub.lmj] to the reliability of communication between all these components over the connector i in the scenario j is:
[[psi].sub.lmj] = [(1 - [[psi].sub.i]).sup.Interact(l,m,j)|] (4)
Finally the reliability of the whole system is combination of equation (3) and (4).
[MATHEMATICAL EXPRESSION NOT REPRODUCIBLE IN ASCII.] (5)
2.2 Technique of Leangsuksun's et al.
This approach introduces the concept how to model the reliability using UML deployment diagram and then transform it to reliability modelling tool such as SHARPE tool (Leangsuksun et al., 2003). Next figure shows the simple framework of the technique:
[FIGURE 4 OMITTED]
First step is to model the system using UML deployment diagram. Each node in the deployment diagram has additional attributes--the failure rate and the repair rate as tagged values. Then it is generated XMI file as output from UML model. This file is used for mapping from UML to Markov chain models or Fault trees by proprietary tool which create the configuration file for SHARPE tool. In last step the SHARPE tool is used to open the configuration file and to compute the reliability.
2.3 Approach of Rodrigues et al.
This approach can also be used in early stages of software development lifecycle for component-based systems. As basic modelling techniques, the scenarios and a Message Sequence Charts (MSC) are used (Rodrigues et al., 2005). The framework of the approach shows the Figure 5.
[FIGURE 5 OMITTED]
First step is annotation the MSCs with two kind probabilities:
1. Probability of transitions between scenarios PT[S.sub.ij]
2. Reliability of the components RC.
PTS is simply the probability that scenario [S.sub.j] will be executed after executing scenario [S.sub.i] which value comes from an operational profile for the system (Musa, i993). It is annotated on High-level Message Sequence Charts (HMSC).
The component reliability [R.sub.C] is the probability that component C will successfully perform its service which is invocated by message from another component. The execution time of the service is not significant for component reliability assessment. Component reliability is annotated on Basic Message Sequence Charts (BMSC).
Second step is to made synthesis of Labelled Transition System (LTS) from annotated scenarios. This step consists of several sub-steps to construct the architecture model of the system.
In the third step the architecture model is interpreted as Markov model. First the mapping of the probability weights from architecture model into a square transition matrix is constructed.
In the fourth step, the Cheung approach (Cheung, i980) is used to determine the reliability prediction of the whole system.
In last step, the implied scenarios are searching. These scenarios can be found as the result of the fact that in the system there can exist such set of components that don't communicate exclusively through the interfaces described and that can exhibit via unspecified traces when running in parallel (Uchitel, 2004). Founding of these scenarios has impact on step 1 and 2 of the approach's framework.
When comparing selected approaches, we have to point out that (Leangsuksun et al., 2003) technique is mostly useable for reliability assessment of hardware components but not for software. For this reason, we can skip this approach in aour further research. The main advantage of this technique we have observed is that, it fills the gap between the UML modelling to traditional reliability models (Markov chains and Fault trees).
The (Cortellessa et al., 2002) and (Rodrigues et al., 2005) are more applicable for software reliability evaluation. We observed some common features:
1. The reliability should be evaluated in very early stages of software development lifecycle. The model used are from analysis and design stages of software development lifecycle.
2. UML Sequence diagrams are used for system reliability evaluation. The UML sequenced diagrams, as the model for capturing the behaviour of the system, are extended for reliability prediction purposes.
3. They have well developed theoretical and formal background. They used previous methods and techniques (e.g. Markov Models,
4. They need some level of UML extension for reliability evaluation purposes. UML reliability profile is developed here.
5. The failure is defined as the failure of any individual component within the software.
4. Research course
After the opening research we declare following steps which should help us to accomplish our goal--to develop new reliability evaluation technique for software systems, especially for software of control systems:
1. Extend UML (UML profile) for reliability evaluation purposes by UML standard extension techniques--stereotypes and tagged values.
2. Use OCL (object Constraint Language) for reliability determination.
3. Use UML Sequence diagrams for describing the system behaviour combing with new developed UML profile.
4. Automating transformation of the UML to Markov model.
5. Compute the reliability prediction value.
Following all the presented steps we wish to provide the level of automation of the whole technique as much as possible.
Reliability is a necessity since the first machines came into existence. The importance of reliability of software systems increases with the fact that software is part of many technical systems. Furthermore, the complexity of the software in such systems is increasing very rapidly and designers of such software like to know the reliability before source-code production. Raising popularity of UML as the basis modelling approach for object oriented software analysis and design directly leads to UML usage also for system architecture modelling for purposes of reliability assessment.
In this paper we discuss the area of software reliability and its support in UML. We also introduce the today's main approaches and concepts in this field, make the short evaluation of them and outlook the basis of our future work in this area.
Cheung, R. C. (i980). A User-Oriented Software Reliability Model. IEEE Transactions on Software Engineering, Vol. 6, No. 2, March i980, pp. ii8i25, ISSN 0098-5589
Cortellessa, V.; Singh H. & Cukic, B. (2002). Early reliability assessment of UML based software models, Proceedings of the 3rd international workshop on Software and performance, pp. 302-309, ISBN:i-58ii3-563-7, Rome, Italy, July 2002, ACM
Leangsuksun, Ch., Song S., Shen, L. (2003). Reliability Modeling using UML, The 2003 International Conference on Software Engineering Research and Practice, pp. 528-558, ISBN: i-9324i5-i9-X, Las Vegas, Nevada, June 2003, CSREA Press
Musa, J. D. (i993). Operational profiles in software-reliability engineering. IEEE Software, Vol. i0, No. 2, i993, pp. i4-32, ISSN 0740-7459
Rodrigues, G. N.; Rosenblum, D. S. & Uchitel, S. (2005). Reliability prediction in model-driven development, Proceedings of the 8* international conference MoDELS, Briand, Lionel; Williams, Clay (Eds.), pp. 339-354, ISBN: 3-540 290i0-9, Montego Bay, Jamaica, October 2005, Springer
Shooman, M. (i983). Software Engineering--Design/Reliability/Management. McGraw-Hill, ISBN 0-070-5702i-3, New York
Uchitel, S.; Kramer, J. & Magee, J. (2004). Incremental Elaboration of Scenario Based Specifications and Behavior Models Using Implied Scenarios. ACM Transactions on Software Engineering and Methodologies, Vol. i3, No. i, 2004, pp. 37-85, ISSN i049-33iX
Zarras, A. & Issarny, V (2000). Assessing Software Reliability at the Architectural Level, Proceedings of the 4th International Software Architecture Workshop (ISAW-4), Limerick, Ireland, June 2000
*** OMG--Object Management Group (2009). OMG Unified Modeling Language (UML OMG), Infrastructure, version 2.2, http://www.omg.org/spec/UML/2.2/ Infrastructure/PDF/, Accessed: 2009-05-i0
This Publication has to be referred as: Jedlicka, M[artin]; Moravcik, O[liver]; Schreiber, P[eter] & Tanuska, P[avol] (2009). Reliability Assessment Using UML Models, Chapter 07 in DAAAM International Scientific Book 2009, pp. 053-060, B. Katalinic (Ed.), Published by DAAAM International, ISBN 978-3-901509-69-8, ISSN 1726-9687, Vienna, Austria
Authors' data: Ing. Jedlicka, M[artm] *; Prof. Dr. Ing. Moravcik, Oliver]**; doc. Ing. CSc., Schreiber, P[eter] **; doc. Ing. PhD. Tanuska, P[avol]**, * University of SS. Cyril and Methodius in Trnava, Namestie Jozefa Herdu 2, 91701, Trnava, Slovak Republic, ** Slovak University of Technology, Paulinska 16, 917 24 Trnava, Slovak Republic, email@example.com, firstname.lastname@example.org, email@example.com, firstname.lastname@example.org
Tab.1. Number of interactions for scenario pair (l, m) scenario 1 (C1, C2) 1 (C2, C1) 2 (C1, C3) -- (C3, C1) -- (C2, C3) 2 (C3, C2) 2
|Printer friendly Cite/link Email Feedback|
|Title Annotation:||Chapter 7; Unified Modelling Language|
|Author:||Jedlicka, M.; Moravcik, O.; Schreiber, P.; Tanuska, P.|
|Publication:||DAAAM International Scientific Book|
|Date:||Jan 1, 2009|
|Previous Article:||Algorithm for choosing factory planning methods and tools.|
|Next Article:||User interface design in distance learning system.|