Reinhard Gotzhein

The formal semantics of SDL-2000: status and perspectives

In November 1999, the current version of specification and description language (SDL), commonly referred to as SDL-2000, passed through ITU-T. In November 2000, the formal semantics of SDL- 2000 was officially approved to become part of the SDL language definition. It covers both the static and the dynamic semantics, and is based on the formalism of abstract state machines (ASMs). To support executability, the formal semantics defines, for each SDL specification, reference ASM code, which enables an SDL-to-ASM-compiler.In this paper, we briefly survey and compare existing approaches to define the semantics of SDL formally. The ITU-T approach is then outlined in more detail, addressing the following steps: (1) mapping of non-basic language constructs to the core language, (2) checking of static semantics conditions, (3) definition of the SDL abstract machine (SAM), and (4) definition of the SDL virtual machine (SVM). The paper concludes with experiences from the SDL-to-ASM-compiler project. It is proposed that the SDL-2000 semantics can be adapted and extended to formally define the meaning of UML 2.0 class, composite structure, and statechart diagrams.

System Analysis and Modeling: Language Profiles

Language Profiles.- A UML Profile for Communicating Systems.- Implementing the eODL Graphical Representation.- Distributed Real-Time Behavioral Requirements Modeling Using Extended UML/SPT.- Formal Operations for SDL Language Profiles.- Evolution of Development Languages.- Automating Scenario Merging.- Timed High-Level Message Sequence Charts for Real-Time System Design.- Timed Use Case Maps.- Model-Driven Development.- Application of Stuck-Free Conformance to Service-Role Composition.- A Simulator Interconnection Framework for the Accurate Performance Simulation of SDL Models.- Refactoring and Metrics for TTCN-3 Test Suites.- SDL Design of a Radio Resource Control Protocol for 3G Evolution Systems with Two Different Approaches.- Language Implementation.- Evaluation of Development Tools for Domain-Specific Modeling Languages.- Towards Integrated Tool Support for the User Requirements Notation.- ConTraST - A Configurable SDL Transpiler and Runtime Environment.

Configuring Communication Protocols Using SDL Patterns

Publisher Summary This chapter presents an approach that has the potential of substantially reducing the effort for designing customized protocols. The approach is based on the concept of design patterns. The chapter uses Specification and Description Language (SDL)-92 and message sequence charts (MSCs) to formally specify protocol design patterns, as well as rules for their instantiation and composition. To illustrate the approach, a resource reservation protocol is configured in the chapter. Each of the selected SDL patterns is applied several times when configuring the reservation protocol. Some of these patterns resemble protocol components employed by approaches for automatic configuration of protocol implementations. This provides some evidence that the predesigned patterns are well chosen. A very large portion of the final specification results from the application of SDL patterns.

ns +SDL: the network simulator for SDL systems

Today, simulators for the performance evaluation of networked systems are seldom integrated with tool environments used for system development and maintenance. This requires the system developer to establish and maintain separate code bases for simulation and production purposes, a tedious and error-prone task. In this paper, we present ns+SDL, an extension of the network simulator ns-2 to combine SDL design specifications with ns-2 network models. ns+SDL enables the developer to use SDL design specifications as a common base for the generation of simulation and production code. Furthermore, the same SDL-to-C code generator is used to generate this code. Both measures increase confidence that the results of the performance evaluation hold for the networked system in operation. Another important aspect is the composition of SDL systems and existing ns-2 simulation components, in particular, components implementing detailed timed models of existing communication technologies. We illustrate the application of ns+SDL by a simulation of DSDV, the Destination-Sequenced Distance-Vector routing protocol, over WLAN.

Collaboration-Based Design of SDL Systems

The concept of collaborations capturing dynamic aspects of a distributed system across agent boundaries is elaborated in the context of SDL-2000. Several ways of composing collaborations are introduced, with collaborations being implicitly represented as SDL fragments. A new language for their explicit formal description, called CoSDL (Collaborations in SDL systems) is then introduced and illustrated.

Realization of Try-Once-Discard in Wireless Multihop Networks

In networked control systems, the Try-Once-Discard (TOD) protocol is of high interest because its properties can be characterized by Lyapunov functions. This feature makes it practical to incorporate TOD into Lyapunov-based design of linear and nonlinear control systems, yielding a self-contained theory for system stabilization. In previous work, candidates for TOD realizations for single-hop (wired and wireless) networks have been proposed. However, it has been a hitherto open question whether TOD can be realized in wireless multihop networks. In fact, it is far from obvious how dynamic value-based competition with deterministically bounded maximum delay, as required by TOD, is achievable in wireless multihop networks. In this paper, we give a positive answer to this question, by presenting a functionally complete realization of TOD in wireless multihop networks. Our solution is based on highly accurate multihop tick synchronization, and applies an algorithm for collision-protected network-wide value arbitration with deterministic delay. We provide experimental evidence for the feasibility of our solution on existing micro controller platforms, and assess our TOD realization in a batch reactor scenario.

On the Formal Semantics of SDL-2000: A Compilation Approach Based on an Abstract SDL Machine

In November 1999, a new version of SDL (Specification and Description Language) called SDL-2000 has passed ITU, an international standardization body for telecommunication. SDL is a fairly complex, graphical formal description technique for the development of distributed systems, and has been broadly used in industry for many years. Efforts to define the semantics of SDL-2000 formally have started early in 1998. By now, a draft formal semantics is available, which is determined to become the official formal SDL semantics after its approval in 2000. It is based on the formalism of Abstract State Machines (ASMs), which has been selected for several reasons including intelligibility and executability. The formal semantics of SDL addresses the static semantics, transformation rules, and the dynamic semantics. The approach taken to define the dynamic semantics is particularly interesting. Although basically being operational, it differs from existing approaches in several ways. In this paper, we address and highlight some of these differences, using a simplified specification language called SSL instead of SDL. In defining a formal dynamic semantics for SSL, we formally describe an abstract machine, a compilation function mapping SSL specifications to code of this machine, and an operational definition of the set of initial states, using ASM as the underlying formalism. Furthermore, we present in some detail the semantics of SSL procedure calls.

Towards a New Formal SDL Semantics based on Abstract State Machines

With the year 2000 approaching, a new version of SDL called SDL-2000 is currently reaching maturity, and is expected to pass the standardization bodies shortly. Apart from the usual language maintenance, SDL-2000 will offer new features for exception handling and object-oriented data types. To capture these features formally, a new formal SDL semantics is being devised. In several meetings of ITU-T SG10/Q6, the essential design objectives have been clarified, and an outline of the behaviour model for SDL has been presented and discussed. A major concern in this discussion has been the demand for an executable model, which calls for an operational formalism with readily available tool support. Subsequent investigations have shown that Abstract State Machines (ASMs) meet this and all other design objectives, and therefore have been chosen as the underlying formalism. In this paper, ASMs are applied to define the behaviour model of a sample SDL specification formally, thereby illustrating the approach in general.

Model-Driven development with SDL – process, tools, and experiences

Model-Driven Development is a challenge and a promising methodology for creating next-generation software systems. In this paper, we present SDL-MDD, a model-driven development process that is based on the ITU-T design language SDL. We present a semantically integrated tool suite, especially supporting model-driven code generation and model-driven simulation. Both production and simulation code are entirely generated from SDL models and automatically instrumented to interface with different operating systems and communication technologies. The use of SDL-MDD and of the tool suite is illustrated by an extensive case study from the ubiquitous computing domain.

Consolidating and applying the SDL-pattern approach: a detailed case study

Abstract This paper is on design methodology for communication systems. The SDL-pattern approach proposed recently is consolidated and applied rigorously and in detail to the design of a typical communication system on two levels of abstraction. The design is decomposed into a number of steps, each of which is carried out systematically, building on well-proven, generic pieces of solutions that have proven useful in previous projects. These generic solutions—termed SDL patterns —support reuse-driven design of communication systems, raise the vocabulary of protocol engineer to a problem-oriented level, assist the discovery and exploitation of commonalities, and lead to well-justified designs. The selection and use of SDL patterns is supported by a fine-grained incremental design process, the pattern definition takes advantage of formal design languages, and a set of heuristics addresses the decomposition of communication requirements. All these elements are presented and applied in detail to the design of a simple, but functionally complete communication system.