UMLSlicer: A Tool for Modularizing the UML Metamodel using Slicing

Transcription

1 UMLSlicer: A Tool for Modularizing the UML Metamodel using Slicing Jung Ho Bae, Heung Seok Chae Department of Computer Science and Engineering Pusan National University 30 Jangjeon-Dong, Geumjeong-Gu Busan, South Korea {jhbae83,hschae}@pusan.ac.kr Abstract The UML metamodel defines model elements and their relationships for UML diagrams. The large size of the metammodel can prevent tool developers from understanding the UML metamodel and thus from developing UMLbased tools. In this paper, we propose an approach to managing the complexity of the UML metamodel by modularizing the metamodel into a set of small metamodels for each UML diagram type. To that goal, we propose a slicing algorithm for extracting diagram-specific metamodels from the UML metamodel and implement UML metamodel slicing tool, UMLSlicer. For seven UML diagrams, we have constructed separate metamodels of a considerably reduced size. To validate our approach, we also have successfully implemented a modeling tool by using the sliced metamodel and investigated its interoperability with other UML modeling tool. Keywords: UML metamodel, Model slicing, Verification and validation, Consistency Checking and UML modeling tool oped on the basis of the UML metamodel. Those tools include UML modeling tools [1, 2], UML-based measurement [12, 5], UML-based verification [7, 16], UML-based reverse engineering [11, 17, 13]. In addition, users can compose and integrate several tools for different purposes due to their standardized interface. Recently, UML has been increased in its size and complexity due to many needs for supporting various development phases and applications such as component-based systems, real-time systems and distributed systems [4]. MDT project [1] saves UML metamodel as ecore file. We can get the UML metamodel which expressed by UML class diagram using eclipse MDT plugin from this ecore file. Figure 1 shows the metamodel for all the model elements in UML 2.0. We found that there are 265 model elements and 763 relationships in the UML 2.0 metamodel. The large size of the metammodel can make it difficult to understand and thus to develop UML-based tools. 1 Introduction Unified Modeling Language (UML) defines a set of diagram types for describing various systems from different perspectives. The UML metamodel defines model elements and their relationships for UML diagrams. The clear and consistent definition of the UML metamodel helps us to unambiguously understand various UML diagrams based on it. In addition, many UML-based tools have been devel- This work was partially supported by Defense Acquisition Program Administration and Agency for Defense Development under the contract (2008-SW-32-IM-01) and the MKE(Ministry of Knowledge Economy), Korea, under the ITRC(Information Technology Research Center) support program supervised by the IITA(Institute of Information Technology Advancement) (IITA-2008-(C )) Figure 1. The metamodel of UML 2.0 In this paper, we propose an approach to manage the complexity of the UML metamodel by modularizing the metamodel into a set of small metamodels for each UML diagram type. In other words, the single UML metamodel /08/$ IEEE 772 CIT 2008

2 of a huge size can be decomposed into a set of small metamodels for each diagram type, i.e., use case diagram, class diagram, sequence diagram, etc. Diagram-specific metamodels can be useful for constructing UML-based tools that support only a subset of UML diagrams, not all the UML diagrams. For example, only activity diagrams have been commonly used for modeling and verifying business processes [15]. State machine diagrams can be independently used for describing dynamic behaviors of an object, a component and a system [6, 14]. In addition, a modeling tool for the all UML diagrams can be constructed by composing a set of a separate editor for each UML diagram. We have developed a UML modeling tool by aggregating individual diagram editors for a particular diagram type. To manage the complexity of the UML metamodel and to help construct UML-based tools, this paper proposes an approach to extracting diagram-specific metamodels from the UML metamodel. Since the UML metamodel addresses all the UML diagrams, it need to contain all the elements for all the UML diagrams. On the other hand, diagram-specific metamodels can be considerably reduced by including elements and relationships that are actually relevant to the diagram. By using the simplified diagram-specific metamodels, we can easily build a tool for supporting the particular diagram. That is, a set of diagram-specific metamodels can be used individually as for all the original purposes of the UML metamodel. For example, the class diagram - specific metamodel can be used for visualizing and analyzing class diagrams. In addition, multiple metamodels for two or more diagrams can be collectively used for checking consistency between those diagrams. Since diagram-specific metamodels can be defined by the relevant model elements and relationships among the entire UML metamodel elements, we can modularize the UML metamodel applying slicing technique to the UML metamodel. We propose a slicing algorithm for extracting diagram-specific metamodels from the UML metamodel. Although program slicing [18] has been widely studied in literatures, little work is done with UML models. Wu and Yi [8] applied their dependency algorithm to slicing class diagrams and Kagdi et al. [10] also proposed a slicing algorithm for class diagrams. However, both are designed for a general-purpose boal in mind; that is, simply finding all the relevant classes for a given class. We found that just a simple use of their algorithms to our problem can lead to incomplete diagram-specific metamodels; that is, it is not possible to develop a UML-based tool based on metamodel slices obtained from their approaches. For example, if we slice the Class with their approach, Class can t have attributes. Because Class doesn t have attributes directly in UML metaclass, and StructuralClassifier which is a super class of Class has attributes. This is because that they do not consider classes for data types and transitive generalization and/or association relationships. This paper proposes a slicing algorithm to extract diagram-specific metamodels from the entire UML metamodel. We have developed UML metamodel slicing tool, UMLSlicer, implementing the slicing algorithm and constructed a set of separate metamodels of a considerably reduced size for seven UML diagrams. To validate our approach, we also have successfully implemented a modeling tool by using the sliced metamodel and investigated its interoperability with other UML modeling tool. 2 The UML Meta-Model UML is formally described by a metamodelization approach using four layers: the data layer (M0), the model layer (M1), the metamodel or language layer (M2) and the meta-metamodel or meta-language layer (M3). Each feature of a given layer is an instance of a feature of the upper layer. As a Layer M2, the UML metamodel can define the Layer M1, UML diagrams. In other words, the UML metamodel defines all the elements and their relationships which are allowed in UML diagrams. For example, Figure 2 shows a part of the UML metamodel relevant to use case diagrams. From the part of the metamodel we can clearly understand the major concepts with regard to use cases. For example, it is obvious that two use cases can have two types of relationships: Include and Extend. A use case can have extension points. As illustrated in Figure 2, the metamodel itself is usually expressed in UML class diagrams. That is, the metamodel is expressed by three concepts of classes, associations (including composition) and generalizations. A metamodel of a model M is represented by a directed multigraph, MM M =(E M, A M G M ). E M is a set of model elements in M. A M is a set of associations. That is, A M = {< e 1,e 2 > e 1,e 2 E M such that there is an association(including composition) from e 1 to e 2 }. G M is a set of generalizations. G M = {< e 1,e 2 > e 1,e 2 E M such that e 1 is a subclass of e 2 }. The parameter M is used to denote the UML itself as well as each diagram type; for example, MM UML for the metamodel for the UML and MM UsecaseDiagram for the metamodel only for Usecase Diagram. Therefore, the problem can be formulated as generation of a MM dt (dt DT) from the MM UML,whereDT = {Usecase Diagram, Class Diagram, Sequence Diagram,...}. 3 UML Meta-Model Slicing Our UML metamodel slicing is designed so that a diagram-specific metamodel can not only be used for vi- 773

3 Figure 2. A part of the UML metamodel: use case sualizing and analyzing the individual UML diagram but also for supporting inter-diagram verification such as intermodel consistency [9]. This section describes a metamodel slicing algorithm for extracting diagram-specific metamodels. Figure 3 shows an overview of modularization of the UML metamodel by the concept of model slicing. Figure 3. A conceptual overview of UML metamodel slicer The UML Metamodel Slicer generates a metamodel, MM dt for a diagram type dt by a given set of key elements KE dt. KE dt, a subset of E UML, is initially given as slicing criteria. That is, the elements in KE dt are used for identifying the model elements relevant to the diagram type dt. Obviously, KE dt may contain the major concepts of the diagram type. For example, UseCase, Actor, Extend and Include are naturally candidates for KE UsecaseDiagram.Key elements for each diagram type can be selected by investigating several sources on UML such as UML specification [3] and some excellent texts. Figure 4 shows an algorithm for metamodel slicing in order to generate diagram-specific metamodels. The algorithm consists of two phases: Basic Slicing and Extended Slicing. Figure 5 illustrates the process of slicing by a key element Usecase. There are two boxes for depicting two slicing phases. Initially, the given key elements constitute the slice. The slice is extended by including the related elements through associations and generalizations. From a set of given key elements for a diagram type dt, KE dt, the Basic Slicing adds all the model elements that have a direct association from any element in KE dt into E dt. The navigational direction of associations is considered because the source elements of the associations with the key elements are not necessary for visualizing and analyzing the diagram. Next, all the existing associations and generalizations among E dt into A dt and G dt, respectively. Whenever an element is added into the slice, its attribute types are also included (AddElementAndAttributeTypes()). Initially, the given key element Usecase is added into the slice. Classes Classifier, ExtensionP oint, Extend and Include are added since each of them has a direct association from the Usecase. Since those 5 elements have no attributes, no attribute types are included. Next the slice 774

4 function META MODEL SLICER (KE dt E UML) return MM dt =(E dt, A dt G dt ) begin E dt = ; A dt = ; G dt = // Phase 1 : Basic Slicing // add 1) elements that have direct associations from // key elements and 2) relations among them for each ke KE dt begin // add element ke and its attributes types AddElementAndAttributeTypes(ke) // add associations and generalizations with ke AddRelationsByElement(ke) // T is a set of elements associated from ke let T be { t E UML E dt <ke,t> A UML } for each t T begin // add the associated element t and its attributes types AddElementAndAttributeTypes(t) // add associations and generalizations with t AddRelationsByElement(t) end for end for // Phase 2 : Extended Slicing // add 1) all the ancestors from E dt and // 2) relations among E dt and the ancestors // Find a set of ancestors from E dt let AN 1 = {p E UML <es,p> G UML and es E dt } repeat AN k = AN k 1 {e E UML < es,e > G UML and es AN k 1 } until AN k = AN k 1 // add associations and generalizations with ancestors for each s AN begin // add each ancestor and its attributes types AddElementAndAttributeTypes(s) AddRelationsByElement(s) // add relations with each ancestor end for end function function AddRelationsByElement( e E UML) // add associations and generalizations with e into the slice begin AE = {< e,s> A UML s E dt } {<s,e> A UML s E dt } A dt = A dt AE element in E dt GE = {< e,s> G UML s E dt } {<s,e> G UML s E dt } G dt = G dt GE end function function AddElementAndAttributeTypes(e E UML) // add e and its attribute types begin E dt = E dt {e} AT = {at E UML at is used as a type in any attribute of e} E dt = E dt AT end function Figure 4. An algorithm for metamodel slicing is extended by adding all the 11 associations among those 5 elements. The Extended Slicing extends the slice by including all the ancestors of the current slice and their relationships. This is intended to allow the consistency verification between different diagram types. Classes RedefinableElement, BehavioredClassifier, Namespace, DirectedRelationship, Relationship and NamedElement are added into E dt since each of them is an ancestor of the elements in the Basic Slicing. Next, the inclusion of relationships and attribute types are repeated on the newly added model elements. At this phase, the elements VisibilityKind and String are additionally added since they are used as the types of attributes in the element NamedElement. Figure 5. Slicing the UML metamodel by Use- Case 4 UMLSlicer and its Validation We have developed an automated tool for generating diagram-specific metamodels by the metamodel slicing algorithm. The UML2 Project has been used for constructing the whole metamodel of the UML. The file UML2.ecore in the UML2 Project contains all the model elements in UML 2.0 Specification. Table 1 summarizes the slicing result for 7UMLdiagrams. The first column lists the number of key elements used for each diagram type. The key elements have been initially collected by adding all the model elements mentioned in the UML 2.0 Specification and then refined by excluding key elements that do not contribute to the slice. The second and the third column shows the number and the ratio of the model elements that constitute the metamodel slice. 775

5 dt KE dt E dt E dt E UML R dt R dt R UML Use case % % Class % % Sequence % % State machine % % Activity % % Component % % Deployment % % Table 1. The size of the sliced metamodels As seen from the table, each diagram-specific metamodel can be defined by a very small portion of the whole UML metamodel. The last two columns show the reduction in the number of relationships. This table points to our view that each diagram type can be defined by only a portion of the UML metamodel. Actually, Figure 2 is a sliced metamodel by UMLSlicer. And Figure 6 shows sliced component diagram metamodel. To validate the diagram-specific metamodels, we have implemented a modeling tool for two UML diagrams: Usecase Diagram and Sequence Diagram. The UML modeling tool is designed on the Eclipse Platform using the EMF and GEF technologies. First, two separate metamodels (i.e., Usecase Metamodel and Sequence Metamodel) for each diagram type have been extracted from the UML2.ecore inthe EMF Project. Based on the Usecase Metamodel / Sequence Metamodel, Use case diagram / Sequence diagram editor has been individually implemented. Figure 7 and Figure 8 show screen shots of the UML modeling tool. Figure 7 shows a Use case diagram editor with a tool box for editing a Use case diagram. Figure 8 shows an example of a Sequence diagram. Figure 8. A screen shot of a UML modeling tool : sequence diagram We have investigated interoperabilities with Borland Together Architect by (1) loading XMI files generated by our tool into Together and (2) loading XMI files of Together into our tool. In addition, our tool can verify consistency between Use case diagrams and Sequence diagrams. We have checked two constraints between two diagrams that are expressed in OCL. Usecase diagram should contain an actor for every lifeline in sequence diagram. context Lifeline inv : Actor.allInstances() exists( a : Actor a.name = self.represents.type.name) Sequence diagram should contain a lifeline for every actor in usecase diagram. context Actor inv : Lifeline.allInstances() exists( l : Lifeline l.represents.type.name = self.name) 5 Conclusion and Future Work Figure 7. A screen shot of a UML modeling tool : usecase diagram The understanding and manipulation of the UML metamodel is essential for developing UML-based tools. To manage the complexity of the UML metamodel and to help construct UML-based tools, we proposed an approach to extracting diagram-specific metamodels from the UML metamodel. We found that the diagram-specific metamodels consist of a considerable small number of elements and relationships. To verify the extracted metamodels, we have built a modeling tool based on diagram-specific metamod- 776

6 Figure 6. A sliced metamodel: component els and investigated its interoperabilities with other UML modeling tool. As future work, we plan to develop various tools for modeling and analyzing UML diagrams based on the extracted metamodels. We will implement editors for other UML diagrams and include various methods for verifying inter-diagram consistency using common element extracted by metamodel slicing and user-defined constraint rules. References [1] MDT. [2] Together. [3] UML specificaition. [4] UML [5] J. Alghamdi, R. A. Rufai, and S. M. Khan. OOMeter: A software quality assurance tool. In CSMR, pages , [6] A. David, M. O. Moller, and W. Yi. Formal verification of UML statecharts with real-time extensions. In FASE, pages , [7] G. Engels, R. Heckel, and J. M. Küster. Rule-based specification of behavioral consistency based on the UML metamodel. In UML, pages , [8] W. Fangjun and Y. Tong. Dependence analysis for UML class diagrams. Journal of Electronics, 21(3): , [9] Z. Huzar, L. Kuzniarz, G. Reggio, and J.-L. Sourrouille. Consistency problems in UML-based software development. In UML Satellite Activities, pages 1 12, [10] H. H. Kagdi, J. I. Maletic, and A. Sutton. Context-free slicing of UML class models. In ICSM, pages , [11] E. Korshunova, M. Petkovic, M. G. J. van den Brand, and M. R. Mousavi. CPP2XMI: Reverse engineering of UML class, sequence, and activity diagrams from c++ source code. In WCRE, pages , [12] C. F. J. Lange, M. A. M. Wijns, and M. R. V. Chaudron. MetricViewEvolution: UML-based views for monitoring model evolution and quality. In CSMR, pages , [13] S. Li and L. Tahvildari. A service-oriented componentization framework for Java software systems. In WCRE, pages , [14] Y. L. Lionel C. Briand, Massimiliano Di Penta. Assessing and improving state-based class testing: A series of experiments. IEEE TSE, 30(11): , [15] Y. Qin, H. Hao, L. Jun, G. Jidong, and L. Jian. An approach to ensure service behavior consistency in osgi. apsec, 0: , [16] J. Simmonds and M. C. Bastarrica. A tool for automatic UML model consistency checking. In ASE 05, pages ACM Press, [17] G. Sunyé, D. Pollet, Y. L. Traon, and J.-M. Jézéquel. Refactoring UML models. In UML, pages , [18] M. Weiser. Program slicing. In ICSE, pages ,