development of object-based distributed applications: a UML profile (an extension to ... The Quality of Service (QoS) management of IT systems is one of the key ...
A UML Profile for QoS Management Information Specification in Distributed Object-based Applications J.I. Asensio† and V.A. Villagrá Department of Telematic Systems Engineering (DIT-UPM) Technical University of Madrid. Spain {jasensio,villagra}@dit.upm.es † Visiting researcher from University of Valladolid. Spain. Abstract. This paper focuses on the QoS management of IT systems based on object-oriented distributed applications. It presents a way of specifying application-level QoS information during the development of object-based distributed applications: a UML profile (an extension to the UML) based on QoS concepts and principles defined by ISO/ITU-T in their works on QoS in ODP, that can be applied to the specification of QoS management information independently of those particular details related to the distributed object-based distributed computing platform architecture used in each case. Keywords. QoS management, QoS specification, UML, distributed object-based applications, ODP.
1 Introduction The Quality of Service (QoS) management of IT systems is one of the key aspect for their success due to the great competitiveness of the environment in which they are deployed: no matter what technology they are based on, only those systems that increment the level of satisfaction of their users when using them will gain acceptance. Therefore, although lots of definitions of the term Quality of Service can be found, in the context of this paper Quality of Service will be understood as the set of non-functional aspects of a system that determine the satisfaction level of the users of the functionality they provide. Quality of Service Management refers to the set of activities devoted to the surveillance and control of the resources involved in the provision of an adequate QoS level. QoS Management is a global task in the sense that it takes into account all kind of resources that support the service(s) provided by an IT system: network resources, system resources, middleware resources, applications, etc. All of them must be coordinated in order to fulfil the overall goal of obtaining QoS levels that match the users’ needs. That way of understanding QoS is called “end-to-end QoS”. End-to-end QoS implies a top-down translation of user-level QoS requirements into lower level QoS requirements. This paper focuses its attention into the QoS Management of one particular type of resources: applications. Furthermore, it deals with one particular kind of applications: those supported by distributed object-based processing platforms. These applications are becoming more and more important in the IT world mainly because they can be easily deployed over heterogeneous environments, because they present important advantages for their developers and because they can integrate legacy application within new, upgraded systems. QoS Management of IT systems is a very broad and complex challenge, event when restricting its scope to the QoS Management of distributed object-based applications. Different architectures for structuring all the aspects QoS Management involves have been proposed. But when comparing these architectures [6,14], a fundamental question arises: what are the characteristics that an “ideal” QoS Management Architecture should have?. This question should be answered by means of QoS frameworks that precisely define the QoS concepts involved in the QoS Management domain and that provide architectural patterns and other tools that must be used as the basis for the development of QoS Management architectures. One of the more important and complete QoS frameworks is the one that is currently being jointly developed by ISO and ITU-T. The ITU-T X.641 Recommendation (ISO/IEC IS 13236) [17] provides a framework that defines the QoS basic principles, concepts and terminology that can be used in order to develop different contributions related to QoS. The goal of ISO/ITU-T is providing a framework whose contents are generic enough so as to be applied to basically all the aspects of IT. This generic framework has been refined in order to be used in two particular areas: communications based on architectures compliant with the OSI reference model and distributed object-based applications
compliant with the RM-ODP standards [16,15]. This last particularisation has been adopted as the conceptual base for the scope of this paper. One of the items identified in the work developed by ISO/ITU-T regarding QoS in ODP is the need for a QoS language capable of representing all the QoS information related to a system during all its life cycle. This is the concrete QoS problem this paper focuses on. It presents a QoS language that is compliant with the QoS concepts of the ISO/ITU-T QoS framework and that can be used for the application-level QoS information specification of a distributed object-based application. This QoS language is based on a set of extensions to the Unified Modelling Language (UML) [12] in order to take advantage of the great popularity of the notation adopted by OMG for object-oriented analysis and design. The paper is structured as follows: section 2 presents the ISO/ITU-T work on QoS which is the base for the content of the paper; section 3 gives an overview of the way UML has been extended in order to develop a QoS information specification language; section 4 presents the developed language which is called UML-Q (UML for QoS Information Specification); section 5 illustrates the usage of UML-Q in a simple example; section 6 compares the work presented in this paper with other existing proposals; and, finally, section 7 summarises the paper and presents some future research topics.
2 The ISO/ITU-T QoS Framework and its application to ODP The ITU-T Recommendation X.641 (ISO/IEC IS 13236) [17] defines the basic QoS terminology and concepts and identifies the most important QoS management functions for an IT environment. The main defined concept is that of “QoS Characteristic” which is defined as “a quantifiable aspect of QoS, which is defined independently of the means by which it is represented or controlled”. As it was mentioned in the introduction, the generic ISO/ITU-T QoS framework was refined in order to be applied to RM-ODP specific concepts. This particularisation is defined in the ITU-T Draft Recommendation X.906 (ISO/IEC CD 15935) [15]. It defines Specific ODP QoS concepts such as “QoS Relation” (mutual obligations of an object and its environment) which is the basic component of “QoS requirements”, “QoS capabilities”, “QoS offers” and “QoS contracts”. It also gives some ideas of how QoS aspects can be introduced into the five viewpoints prescribed by RM-ODP, it points out other important QoS management functions and, finally, it identifies the main requirements on notations for expressing QoS (representation of all the potential types of QoS characteristics, support for QoS aspects that depend on measurements coming from different places, etc.). As it has been already been mentioned before, this last aspect is the one covered by this paper: definition of a language capable of specifying quality of service information that is compliant with the concepts defined in the work of ISO/ITU-T on QoS in ODP. As this new language, called UML-Q, is based on UML, by using a specific way of extending it called “UML profile”, the next section introduces the concept of UML profile in order to prepare the introduction of UML-Q in section 4.
3 UML Profiles Although UML is a general purpose modelling language, it contains extensibility mechanisms that can be used to tailor it to specific domains (QoS information specification, for instance). These extensibility mechanisms can be understood as indirect modification, at the model level, of the UML meta-model [12]. The standard extensibility mechanisms of UML are stereotypes, tagged values and constraints. These extensibility mechanisms are called “lightweight extensibility mechanisms” [2] in contrast to the direct manipulation of the UML “meta-model” that can be interpreted as “heavyweight extensibility mechanisms” (addition of new meta-classes, meta-associations, etc.). In order to give support to the gradual adoption of “standard” UML extensions, OMG has introduced the concept of “UML profile” which, in spite of the lack of a normative definition, has already been used in several OMG technical workgroups (for instance, OMG is currently working on a “UML profile for CORBA” that defines how to represent CORBA IDL interfaces using UML [10,11]). A “profile” [13] might be defined as an specification that specialises one or several standard meta-models, called
“reference meta-models”. In the context of OMG, all those reference meta-models must be compliant with the meta-meta-model prescribed by MOF (Meta-Object Facility) [9] of OMG. A profile is characterised by the aggregation of a set of elements that refine the semantics of the reference metamodel. Basically, a profile might include a specification of lightweight extensibility mechanisms (stereotypes, tagged values and constraints when dealing with UML), a specification of heavyweight extensibility mechanisms (direct manipulation of the reference meta-model) a specification of new wellformedness rules that constraint the use of the new elements defined in the reference meta-model (this is the static semantics of the new extension that, as in the UML specification, is expressed by means of OCL, the Object Constraint Language [12,23]), a specification of the semantics of the new model elements by means of natural language, and a specification of a new notation for the new modelling elements. This paper defines a UML profile in order to use this modelling language for the specification of QoS information related to distributed object-based applications. Nevertheless, some problems have been identified when using the above concept of profile and UML [11] (mainly related to the reduced set of data types that can be used at the meta-model level) and it is not clear how to represent the UML metamodel extensions introduced by the profile. This paper has adopted the following approach so as to define the proposed UML extensions: •
New stereotypes and tagged-values are represented by means of elements of a new “virtual metamodel”. Stereotypes are represented by new meta-classes that maintain a generalisation relationship with the corresponding base meta-classes. Tagged-values are represented by means of metaattributes.
•
In the new virtual meta-model some new meta-associations are added. This addition might be considered as a heavyweight extension to the UML. Nevertheless, this new meta-associations can be considered as a way of representing meta-attributes whose type is the meta-class that is placed on the opposite end of the meta-association. This consideration implies that the tagged-values (that would represent those meta-attributes at the model level) should be allowed to use values whose types might correspond to elements of the meta-model.
All these ideas are used in the following section for describing UML-Q, the UML profile that has been defined in order to specify QoS information in distributed object-based applications.
4 UML-Q: A UML Profile for QoS Management Information Specification in Distributed Object-based Applications UML-Q (UML for the QoS information specification) is a UML extension (a UML profile is this case) for the specification of QoS information in distributed object-based applications. UML-Q is based on concepts coming from RM-ODP [16] and from the ISO/ITU-T framework on QoS and its refinement for ODP [17,15]. As UML-Q is based on RM-ODP concepts, it is independent from particular distributed object-oriented processing platforms (CORBA, RMI, etc.). UML-Q does not imply the use of any particular application development methodology. It only needs that the software engineering methods used in the chosen methodology include models with contents similar to those prescribed by the information and computational ODP viewpoints, and that those models are expressed using UML ([22] gives an overview of how UML can be used as ODP viewpoints language). UML-Q is defined in terms of a new “virtual meta-model” based on the UML meta-model, as it was described in the previous section. The new “virtual meta-model” is going to be described in terms of: • What types of QoS information can be specified • How QoS information can be combined • How QoS information is related to application models UML-Q defines a UML package structure that establishes a relationship between the UML meta-model and the new elements defined by UML-Q. One of the defined packages, the QOSCore package, contains those virtual meta-classes that represent the different types of QOS information supported by UML-Q as well as the necessary elements so as to establish relationships among their instances at the model level and the model of the application whose QoS has to be characterised. The QOSModelManagement package contains virtual meta-clases whose instances facilitate the organisation of QoS information specification and their reuse.
Figure 1 contains the abstract syntax (consisting of UML class diagrams as in the definition of the UML meta-model [12]) defined by the QOSCore package of the UML-Q virtual meta-model. The rest of this section tries to explain how the meta-classes shown in Figure 1 are used, what is their purpose and how they are represented at the model level. UML-Q has been developed in order to support the concepts defined in the ISO/ITU-T QoS framework. Those concepts are shown in table 1 with an indication of what UML-Q elements are used for their representation. The central concept of those defined in the table, is QoS Characteristic. The delay in the interchange of a message between two entities can be considered as a QoS Characteristic. Nevertheless, the concept of delay can be applied to many other situations (a delay due to the execution of an operation, delay associated to transmission of a message, etc.). In order to reuse (in this example) the concept of delay in any situation, UML-Q introduces the concept of QoS Characteristic Type that might therefore be defined as: “a quantifiable aspect of QoS, which is defined independently of the means by which it is represented or controlled and independently of the entity this QoS aspect can be applied to”. For supporting this idea, UML-Q defines the QOSCharacteristicType virtual meta-class. Instances of this virtual meta-class would define, at the model level, the data structures that represent a particular QoS Characteristic Type. In other words, in a UML-Q specification, delay, for instance, would be modelled as a class with the stereotype. 1..*
ModelElement (from Core)
{ordered}
+constrainedElement +ownedElement +importedElement * *
+type +feature
Feature (from Core)
+type
{ordered}
Classifier (from Core)
1 +owner
+namespace 0..1 Namespace (from Core)
1..* 1 +type
* Constraint (from Core)
+stereotypeConstraint
*
1 QOSConstraint
* *
StructuralFeature (from Core)
Package {ordered}
(from Model Management)
QOSCharacteristicType
+qosConstraint
isDerived : Boolean
{xor}
+qoscharacteristictype
Attribute (from Core)
*
*
1 +type
QOSConstraintContainerType +type QOSExpectationType
1
QOSType
QOSValue unit : String ordering : String
QOSObligationType
1
+qoscharacterisedfeature 1..*
+derived
0..1
+base 1..*
QOSExpectation
QOSOffer
QOSRequirement QOSObligation
QOSCharacteristic
QoSCharacterisedFeature
QOSConstraintContainer
QOSContract
QOSCapability
Figure 1: QOSCore::QOSBackbone class diagram (shadowed elements are defined by UML-Q. Non-shadowed elements belong to the UML meta-model).
Other important aspects of the contents of Figure 1 are summarised in the following list: • At the model level, all QOSCharacteristicType instances will have an attribute with the stereotype with two new attached tagged values (meta-attributes in the virtual metamodel): unit and ordering that are used to characterise the values that a QoS characteristic of a given type can have. • Instances of the QOSCharacteristic virtual meta-class are the result, at the model level, of characterising an application model element with a particular QoS Characteristic Type represented by the corresponding instance of the QOSCharacteristicType virtual meta-class. For instance, delay would be represented by an instance of QOSCharacteristicType but the delay associated to an operation would be represented by an instance of the QOSCharacteristic virtual meta-class. All the instances of QOSCharacteristic will have an attribute with the stereotype indicating what instance of QOSCharacteristicType is related to. An instance of QOSCharacteristic can be associated to more than one application model element (represented by the QOSCharacterisedFeature virtual meta-class) in order to represent, for instance, QoS that is “spatially distributed” as required by the ISO/ITU-T framework of QoS in ODP.
QoS Concept QoS Characteristic QoS Context
QoS Information QoS Measure QoS Requirement
QoS Relation
QoS Capability QoS Offer QoS Contract
•
Definition [15] A quantifiable aspect of QoS, which is defined independently of the means by which it is represented or controlled. QoS information that is retained, interpolated or extrapolated by one or more entities and used in managing QoS: it is further classified into requirement context and data context. Information related to QoS One or more observed values relating to a QoS characteristic.
UML-Q Corresponding element QOSCharacteristic instances A requirement context is represented by an instance of QOSConstraintContainer
A UML-Q specification An instance, at user model level, of an instance of QOSCharacteristic QoS information that expresses part or all of a requirement to Instances of QOSRequirement manage one or more QoS characteristics, e.g. a maximum value, a target, or a threshold; when conveyed between entities, a QoS requirement is expressed in terms of QoS parameters. It states mutual obligations of an object and its environment QoS Expectations are defined by means of It is a specific way of expressing a QoS requirement or a QoS instances of QOSExpectation and QoS offer, and of expressing what is agreed in a QoS contract Obligations are defined by means of instances of QOSObligation The set of QoS characteristics provided by an object Instances of QOSCapability QoS offers describe advertised QoS Instances of QOSOffer A contract that defines both the subsets of QoS capabilities Instances of QOSContract that objects of a configuration have agreed to provide to one another and the QoS requirements they are intending to satisfy. QoS contracts can be expressed in terms of sets of QoS relations Table 1: QoS Concepts from [15] supported by UML-Q.
In UML-Q, the representation of QoS characteristics that are statistically derived from other can be done by means of attributes of the instances of the QOSCharacteristic virtual meta-class. For other types of derivations, UML-Q defines a special type of association as it will be explained afterwards.
The above elements of Figure 1 are used to define QoS Characteristics. The rest of the elements contained in that figure are mainly used to define requirements on defined QoS characteristics (for instance, that the delay associated to an operation must not be greater than 10 ms). The QOSConstraint meta-class is derived from the UML Constraint meta-class and is used to specify restrictions over instances of QOSCharacteristic. In UML-Q, those restrictions consist of OCL (Object Constraint Language) [12,23] expressions. It is important to mention at this point that OCL is related to UML-Q in two senses: • It is used for expressing QoS requirements • It is used for detailing the well-formedness rules (the static semantics) of UML-Q itself (in the same way as it is used for defining the well-formedness rules of UML [12]). Thus, for instance, as it has just been mentioned, instances of QOSConstraint can only be applied to instances of QOSCharacteristic and that fact would be indicated, by means of OCL, in the following way: context QOSConstraint inv: self.constraintedElement->forAll( ce | ce.oclIsKindOf(QOSCharacteristic)) Instances of QOSConstraint can be grouped into instances of the QOSConstraintContainer virtual meta-class. Instances of QOSConstraintContainer are associated to instances of QOSConstraintContainerType that, at the same type, contain instances of QOSCharacteristicType. By means of these relationships, it is possible to indicate, at model level, what QoS Characteristics are of interest for a given model element without specifying concrete requirements on them at design time. QOSObligationType and QOSExpectation are used for representing the concepts of the same name defined by the ISO/ITU-T QoS framework for ODP. They are related to instances of QOSObligationType and QOSExpectationType so as to constraint the QoS Characteristics they can be applied to. Instances of QOSConstraintContainer can be grouped into instances of QOSOffer, QOSContract, QOSCapability, and QOSRequirement. These last virtual meta-classes are derived from the Package UML meta-class and are useful for indicating how potential QoS management mechanisms, intended to support the UML-Q specifications, should behave.
There are other important virtual meta-classes defined in the QOSCore UML-Q package that are used to reflect, at the model element, relationships among UML-Q modelling elements and the models of the application whose QoS is being defined. Therefore, instances of QOSAssignment (stereotyped UML dependencies) are used to relate instances of QOSConstraintContainerType (or instances of its derived virtual meta-classes) with application model elements (UML-Q defines several possibilities: interfaces, classes, operations, usage dependencies, implementation dependencies, etc.) and contains instances of QOSCharacteristic that are the result of applying instances of QOSCharacteristicType contained in the instance of QOSConstraintContainerType to features of the associated application model element. Instances of QOSDependency (stereotyped UML dependencies as well) are used to apply QOSConstraints (written in OCL) to the QOSCharacteristic contained in the instance of QOSAssignment. Finally, UML-Q defines the QOSCategory virtual meta-class whose instances are used, at the model element, to group QOSCharacteristicType definitions in order to facilitate its reuse.
5 Example In order to illustrated the usage of UML-Q, Figure 2 shows a UML model (a simplified computational viewpoint) of what might be a currency trading system (this example is extracted from [8]) whose QoS aspects have to characterised. Figure 3 shows how UML-Q can be used to define QoS Characteristic Types (numberOfFailures, delay, etc.) that are grouped into categories (reliability, performance, etc.). These QoS Characteristic Types are defined independently of the application they are going to be applied to (these definition therefore might be reused). RateService RateServiceI TradingStation
TradingService TradingServiceI latest(c1 : Currency, c2 : Currency) : Rates analysis(c : Currency) : Forecast
Figure 2: Simplified computational model (expressed in UML) of a distributed object-based application whose QoS management information has to be characterised.
Reliability numberOfFailures value : Integer
TTR mean : Real variance : Real percentile_100 : Real value : Integer
context numberOfFailures_RateServiceI inv: type.value < 10
{unit = fallos/año, ordering = decreasing}
context TTR_RateServiceI inv: type.percentile_100 < 2000 type.mean < 500 type.variance < 0.3 context availability_RateServiceI inv: type.value > 0.8
ReliabilityContainer (from QOSConstraintContainerTypes)
availability value : Integer
RateService RateServiceI
{ordering = increasing}
{unit = sec, ordering = decreasing}
TradingStation
TradingService
Performance
TradingServiceI
delay mean : Real percentile_50 : Real percentile_80 : Real percentile_100 : Real value : Integer
throughput value : Integer
{unit = ms, ordering = decreasing
{unit = mb/sec, ordering = increasing}
Figure 3: UML-Q specification of QoS Characteristic Types.
context delay_latest inv: type.percentile_50 < 10 type.percentile_80 < 20 type.percentile_100 < 40 type.mean < 15
context delay_analysis inv: type.value < 4000
PerformanceContainer (from QOSConstraintContainerTypes)
Figure 4: UML-Q specification of QoS information attached to the UML application model.
QoS Characteristic Types can be included into instances of QOSConstraintContainerType (in this example, they are going to be grouped into instances of QOSObligationType that are UML-Q virtual meta-classes inherited from QOSConstraintContainerType). All this defined QoS Information can be “attached” to the application UML model by means of instances of QOSAssignment virtual meta-class. Figure 4 shows how it can be done. Those instances of QOSAssignment contain the definition of instances of QOSCharacteristic (the result of assigning instances of QOSCharacteristicType to application model elements). All these instances of QOSCharacteristic are defined in Table 2. Table 2 shows how instances of QOSCharacteristic can be associated to application model elements with different granularity levels. Thus, for instance, scalability_RateServiceI refers to RateService as a whole while delay_latest is associated to just an operation defined within the TradingServiceI interface. In Figure 4 some QoS requirements (instances of QOSConstraint, which are OCL expressions) are grouped into instances of QOSConstraintContainer (or into instances of any UML-Q virtual metaclasses inherited from QOSConstraintContainer) and are associated to instances of QOSCharacteristic by means of QOSDependencies. Name NumberOfFailures_RateServiceI TTR_RateServiceI Availability_RateServiceI Delay_latest Delay_analysis
type qoscharacterisedfeature numberOfFailures observedElement TTR observedElement availability observedElement delay observedElement delay observedElement Table 2: Instances of QOSCharacteristic.
qoscharacterisedfeature.type RateServiceI RateServiceI RateServiceI TradingServiceI::latest() TradingServiceI::analysis()
6 Related Work There are other proposals for QoS specification languages and notations. Their scope covers simple syntactical extensions to computational languages [18, 4], combination of computational languages with other languages such as OCL [1], languages independent of the definition of functional interfaces but that are tied to particular object-oriented distributed processing platforms [8,20], and formal languages customised to QoS information specification [21,7,19]. UML-Q is conceptually similar to the language defined in [8] although is better integrated with UML and presents a greater degree of granularity and reusability in its specifications. UML-Q uses OCL in a way similar to [1]. The advantage of UML-Q is that its specifications can be made independent of the definition of computational objects. UML-Q presents the disadvantage of its lack of formality (as UML is not a formal language).
7 Conclusions and future work items This paper has presented UML-Q, a UML extension (a UML profile) that can be used for the definition of application-level QoS management information related to distributed object-based applications. UML-Q takes advantage of the adoption of UML as the de facto standard language for OO modelling and design. UML-Q has been used in the QoS management information specification of a distributed object-based electronic brokerage application [3]. By using UML-Q, the introduction of QoS aspects during the development of distributed object-based applications might be greatly simplified. This process can even be automated by introducing UML-Q support in existing UML-based development-oriented CASE tools (which is one of our future work items in the short-term).
References 1.
2.
J.O. Aagedal and A.-J. Berre. ODP-based QoS-support in UML. In Proceedings of the First International Enterprise Distributed Object Computing Workshop (EDOC'97), pages 310--321. Gold Coast, Australia, October 1997. S.S. Alhir. Extending the Unified Modeling Language (UML). Internet Document http://home.earthlink.net/~salhir/ExtendingTheUML.PDF, 1999.
3.
4.
5. 6. 7. 8. 9. 10. 11. 12. 13. 14.
15. 16. 17. 18. 19. 20.
21.
22. 23.
J.I. Asensio, V.A. Villagrá, J.E. López de Vergara, and J. Berrocal. Experiences with the SNMPbased integrated management of a CORBA-based electronic commerce application. In M. Sloman, S. Mazumdar, and E. Lupu, editors. Integrated Network Management VI: Distributed Management for the Networked Millenium. Proceedings of the sixth IFIP/IEEE International Symposium on Integrated Netork Management. Boston, MA, USA. May 1999. IEEE Publishing, 1999., pages 517--530. 1999. C. Becker and K. Geihs. MAQS - Management for Adaptive QoS-enabled Services. In Proceedings of the IEEE Workshop on Middleware for Distributed Real-Time Systems and Services, San Francisco, California, USA, December 1997. G. Booch, J. Rumbaugh, and I. Jacobson. The Unified Modeling Language User Guide. AddisonWesley, 1999. Campbell, C. Aurrecoechea, and L. Hauw. A review of QoS Architectures. ACM Multimedia Systems Journal, 1996. F. Dietrich, X. Logean, S. Koppenhofer, and J.-P. Hubaux. Modelling and Testing Object-Oriented Distributed Systems with Linear-time Temporal Logic. Technical report, EPFL, May 1998. S. Frolund and J. Koistinen. QML: A Language for Quality of Service Specification. Technical Report HPL-98-10, HP Laboratories, 1998. Object Management Group. Meta Object Facility (MOF). OMG document ad/99-09-05, September 1999. Object Management Group. DAC/GDC/Telelogic/UBS Joint Initial Submission to UML Profile for CORBA RFP. OMG document ad/99-08-01, August 1999. Object Management Group. DSTC Initial Submission to UML Profile for CORBA RFP. OMG document ad/99-08-02, August 1999. Object Management Group. OMG Unified Modeling Language Specification version 1.3. OMG document ad/99-06-08, June 1999. Object Management Group. White Paper on the Profile Mechanism. OMG document ad/99-04-07, April 1999. Hafid, G. von Bochmann, and R. Dssouli. Distributed Multimedia Applications and Quality of Service: a Review. The Electronic Journal on Networks and Distributed Processing, issue 6, February 1998. ISO. Working Draft for: Open Distributed Processing - Reference Model - Quality of Service. ISO/IEC JTC1/SC N 10979 Ed 6.4, January 1998. ITU-T. Information Technology - Open Distributed Processing - Reference Model: Overview. ITU-T Recommendation X.901 (ISO/IEC DIS 10746-1), December 1997. ITU-T. Information Technology - Quality of Service: Framework. ITU-T Recommendation X.641 (ISO/IEC IS 13236), December 1997. ITU-T. Object Definition Language. Draft ITU-T Recommendation Z.130, October 1998. S. Leue. QoS Specification based on SDL/MSC and Temporal Logic. In Proceedings fo the Montreal Workshop on Multimedia Applications and Quality of Service Verification. June 1994. J.P. Loyall, R.E. Schantz, J.A. Zinky, and D.E. Bakken. Specifying and Measuring Quality of Service in Distributed Object Systems. In Proceedings of the 1st International Symposium on object-Oriented Real-Time Distributed Computing (ISORC'98), 1998. G. Raeder and S. Mazaher. Quality-of-Service directed targeting based on the ODP engineering Model. In Proceedings of the IFIP International Conference on Open Distributed Processing (ICODP'95, Brisbane, Australia, February 1995. MCI Systemhouse. Relationship of the Unified Modeling Language to the Reference Model of Open Distributed Computing. MCI Systemhouse white paper, September 1997. J. Warmer and A. Kleppe. The Object Constraint Language. Addison-Wesley, 1999.
