Protocol engineering using UML

2001

A specification of a software system involves several aspects. Two essential aspects are convenience in specification and possibility for formal analysis. These aspects are, to some extent, exclusive. This paper describes an approach to the specification of systems that emphasizes both aspects, by combining UML with a language for description of the observable behavior of object viewpoints, OUN. Whereas both languages are centered around object-oriented concepts, they are complementary in the sense that one is graphical and semi-formal while the other is textual and formal. The approach is demonstrated by a case study, focusing on the specification of an open communication infrastructure. In this paper, emphasis is placed on specification aspects. Verification aspects are discussed briefly at the end of the paper.

2001

Convenience in specification and possibility for formal analysis are, to some extent, exclusive aspects of system specification. This paper describes an approach that emphasizes both aspects, by combining UML with a language for observable behavior of interfaces, OUN. These are complementary in the sense that one is graphical and semi-formal while the other is textual and formal. The approach is demonstrated by a case study.

Science of Computer Programming, 2005

We define a subset krtUML of UML which is rich enough to express such modelling entities of UML, used in real-time applications, as active objects, dynamic object creation and destruction, dynamically changing communication topologies, combinations of synchronous and asynchronous communication, and shared memory usage through object attributes. We define a formal interleaving semantics for this kernel language by associating with each model M ∈ krtUML a symbolic transition system STS(M). We briefly outline how to compile models of industrial systems making use of generalisation hierarchies, weak and strong aggregation, and hierarchical state-machines into krtUML. The main aim of the paper is to provide an executable semantics for krtUML suitable for the formal verification of temporal model properties with existing model-checking tools.

Proceedings First International Symposium on Object-Oriented Real-Time Distributed Computing (ISORC '98), 1998

We introduce the de nition of a language of distributed reactive objects, a Behaviour Description Language (Bdl), as a uni ed medium for specifying, verifying, compiling and validating object-oriented, distributed reactive systems. One of the novelties in Bdl is its seamless integration into the Uni ed Modeling Language approach (Uml). Bdl supports a description of objects interaction which respects both the functional architecture of system designs and the declarative style of diagram descriptions. This support is implemented by means of a partial-order theoretical framework. This framework allows to specify both the causality and the control models of object interactions independently of any hypothesis on the actual con guration of the system. Given the description of such a con guration, the use of Bdl offers new perspectives for a exible veri cation of systems by modeling them as an asynchronous network of synchronous components. It allows an optimized code generation by using compilation techniques developed for synchronous languages. It permits an accurate validation and test of applications by supporting the manipulation of both causal and control dependencies. Bdl aims at maximizing the re-usability of high-level speci cations while minimizing programming e ort and test-case based validation of distributed systems. (R sum : tsvp)

The object-oriented paradigm is widely applied in designing and implementing communication systems. The Unified Modeling Language (UML) is a standard language used to model the design of object-oriented systems. A protocol state machine is a UML adopted diagram that is widely used in designing communication protocols. It has two key attractive advantages over traditional finite-state-machines: modeling concurrency and modeling nested hierarchical states. In a distributed communication system, each entity of the system has its own protocol that defines when and how the entity exchanges messages with other communicating entities in the system. The order of the exchanged messages must conform to the overall service specifications of the system. In object-oriented systems, both the service and the protocol specifications are modeled in UML protocol state machines. Protocol specification synthesis methods have to be applied to automatically derive the protocol specification from the service specification. Otherwise, a time-consuming process of design, analysis, and error detection and correction has to be applied iteratively until the design of the protocol becomes error-free and consistent with the service specification. Several synthesis methods are proposed in the literature for models other than UML protocol state machines, and therefore, because of the unique features of the protocol state machines, these methods are inapplicable to services modeled in UML protocol state machines. In this paper, we propose a synthesis method that automatically synthesizes the protocol specification of distributed protocol entities from the service specification, given that both types of specifications are modeled in UML protocol state machines. Our method is based on the latest UML version (UML2.3), and it is proven to synthesize protocol specifications that are syntactically and semantically correct. As an example application, the synthesis method is used to derive the protocol specification of the H.323 standard used in Internet calls.

Communications in Computer and Information Science, 2018

UML2.X sequence diagrams (SD) are equipped with high structures: the combined fragments (CF) that permit to model complex behaviours of systems. CF can be nested to allow more sophisticated behaviours, however they complicate the interpretation of the SD and the computation of precedence relations between the events. In a previous work, we proposed a causal semantics for UML2.X SD. It is based partial order theory, its well-defined relations allow the computation of all precedence relations for the events of UML2.X SD with nested CF. We considered the most popular CF of control-flow alt, opt, loop, seq allowing to model respectively alternative, optional, iterative and sequential behaviours. In this work, we improve that previous work to consider a par CF allowing to model parallel behaviours, and we propose an operational semantics that is based on the causal semantics. The proposed operational semantics is a substantial step towards the refinement checking and the analysis of some properties of SD.

2015

This article introduces formal relations between UML Protocol State Machines in order to support their incre-mental construction. This is based on the use of confor-mance relations. Protocol State Machines (ProSMs) intro-duced in UML2.0 are means to model external behaviors of objects and/or components in a service oriented way. These machines are specializations of generic UML State Machines without actions nor activities. In previous works, we adapted Labeled Transition System conformance rela-tions to UML usual State Machines. Going further, ProSMs allow us to be more formal thanks to the presence of log-ical propositions such as state invariants, pre and post-conditions. Hence, we define a conformance relation as a specialization of the informal notion of Protocol Confor-mance of UML2.0 and we illustrate it on an example. 1.

1996

We use Maude as our speci cation language and the modal -calculus as our logic. We apply to speci cations in Maude a framework of abstraction and veri cation based on property-preserving mappings between transition systems. Firstly, we demonstrate how to employ abstraction in veri cation of object-oriented speci cations of distributed systems. Secondly, we use this framework to nd classes of properties preserved by Maude's inheritance relation.

Traditionally, real-time software system development focuses on low-level programming techniques to increase timeliness and operate within constraints; however, more recently higher-level, object-oriented methodologies are being used to create real-time software systems. This increase in object-oriented design for realtime systems is due to the improved use of active objects and concurrency in object-oriented languages. Real-time aspects have not only improved in many programming languages, but these real-time constraints are becoming more essential in general object-oriented software development. Consequently, the specification of real-time object-oriented systems is becoming important in software development processes. One of the many tools used to specify software is an executable specification language called Descartes. Descartes relates output data to input data as a function of the input data through a tree structure notation called "Hoare trees." This useful specification structure has been extended and supported for several types of systems since the language's creation in 1977. In particular, Descartes has been extended for the specification of real-time systems and for object-oriented designed systems. In spite of this, the combination of the two extensions for specification of real-time object oriented (RTOO) systems has not been tested. Thus, the main objective was to validate that the combination of the two Descartes extensions either satisfied the needed specification for RTOO systems or that the language needed to be additionally extended. To gain further verification of these united Descartes extensions, the Unified Modeling Language (UML) was used for comparison in aspects of design and effectiveness. In this research effort, UML 2.0, a widely used modeling language was used and analyzed to model security requirements along with the application requirements for real time object oriented systems. The outcome from this research effort was efficient modeling notations included to UML 2.0 modeling notations that can be used to specify security requirements in the beginning phase of software engineering, when application requirements are specified.

1990

A protocol specification technique that relates concurrent system behaviour to agent activity and interation at a high level of abstraction is described. This expoits a concurrent programming technique based upon a synthesis of two new programming paradigms: "agent-oriented" and "definition-based" programming. Application of the method to modelling and simulating activity at a railway station is described. Its potential for concurrent systems software requirements specification is assessed.

Lecture Notes in Computer Science, 2005

Model-driven development has gained increasing acceptance in the engineering community. Via abstraction and gradual model transformation, it offers an efficient way to cope with complexity of modern software-intensive systems, typical examples of which are distributed telecommunicating systems and communication protocols. However, variety of models representing the system structure and behaviour from different viewpoints and at different levels of abstraction raise the question of model consistency and their adherence to the predefined architectural rules. In this paper we formalize a development flow of distributed telecommunicating systems and communication protocols as an architectural profile in UML. We specify and formally verify this profile. The profile allows us to check adherence of models to the predefined architectural rules. Furthermore, by formalizing and verifying intra-and interconsistency rules, we ensure that the models do not contradict to each other. We use the B Method as our formal framework. The presented work establishes a basis for automating model-driven development of telecommunicating systems and communication protocols.

Proceedings Euromicro Workshop on Parallel and Distributed Processing

In this paper we show how an object-oriented specification language is usefvl for the specification of distributed systems. The main constructors in this language are the objects. A n object consists of a state, a behaviour and a set of transition rules between states. The specification is composed by three sections: definition of algebraic data types t o represent the domain of object attributes, definition of classes that group objects with common features, and definition of relationships among classes. W e show two possible styles for defining the behaviour of objects, in one hand we use a transition system (state oriented) and in the other hand we use an algebraic model of processes description (constraint oriented). W e illustrate the paper with the specification of the dining philosophers problem, a typical example in distributed programming.

NASA Formal Methods Symposium, 2013

One of the challenges in concurrent software development is early discovery of design errors which could lead to deadlocks or race-conditions. For safety-critical and complex distributed applications, traditional testing does not always expose such problems. Performing more rigorous formal analysis typically requires a model, which is an abstraction of the system. For object-oriented software, UML is the industry-adopted modeling language. UML offers a number of views to present the system from different perspectives. Behavioral views are necessary for the purpose of model checking, as they capture the dynamics of the system. Among them are sequence diagrams, in which the interaction between components is modeled by means of message exchanges. UML 2.x includes rich features that enable modeling code-like structures, such as loops, conditions and referring to existing interactions. We present an automatic procedure for translating UML into mCRL2 process algebra models. Our prototype is able to produce a formal model, and feed model-checking traces back into any UML modeling tool, without the user having to leave the UML domain. We argue why previous approaches of which we are aware have limitations that we overcome. We further apply our methodology on the Grid framework used to support production activities of one of the LHC experiments at CERN.

The object-oriented concurrent paradigm demands for a new object model and for reconsidering object-oriented techniques. We present an abstract, object-oriented style of modeling distributed systems and propose a collection of techniques and methods for modeling, for reasoning about the models in veri cation, for re nement and for reuse. Rewriting Logic and Maude are seminal to our approach.

The Journal of Object Technology, 2009

Activity Diagram is an important component of the set of diagrams used in UML. The OMG document on UML 2.0 proposes a Petri net based semantics for Activity Diagrams. While Petri net based approach is useful and interesting, it does not exploit the underlying inherent reactive behaviour of activity diagrams. In the first part of the paper, we shall capture activity diagrams in synchronous language framework to arrive at executional models which will be useful in model based design of software. This also enables validated code generation using code generation mechanism of synchronous language environments such as Esterel and its programming environments. Further, the framework leads to scalable verification methods. The traditional semantics proposed in OMG standard need enrichment when the activities are prone to failure and need compensating actions. Such extensions are expected to have applications in modelling complex business processes. In the second part of the paper, we propose an enrichment of the UML Activity Diagrams that include compensable actions. We shall use some of the foundations on Compensable Transactions and Communicating Sequential Processes due to Tony Hoare. This enriched formalism allows UML Activity Diagrams to model business processes that can fail and require compensating actions.