System Simulation Modeling and Analysis

eODL is the ITU component description language. Its current status is that it is defined textually and there are several transformation into other languages. There are also ideas about a graphical representation for eODL. In this article we present a graphical representation for some of the eODL language elements and discuss how such a graphical representation can be implemented using a high-level formal description language in comparison with a UML profile.

Creating and maintaining tools for domain-specific modeling languages (DSML) demands time and efforts that often discourage potential developers. However, several tools are now available that promise to accelerate the development of DSML environments. In this paper, we evaluate five such tools (GME, Tau G2, RSA, XMF-Mosaic, and Eclipse with GEF and EMF) by observing how well they can be used to create graphical editors for the Goal-oriented Requirement Language (GRL), for which a simplified metamodel is provided. We discuss the evaluation criteria, results, and lessons learned during the creation of GRL editors with these technologies.

This paper presents a new approach to TCP congestion control. The new scheme includes two parts: (1) the Smooth-Start algorithm, which replaces the Slow-Start algorithm at the start of a TCP connection or after a retransmission timeout, and (2) the Dynamic Recovery algorithm, which replaces the Fast Recovery algorithm to recover packet losses when a TCP connection is congested. Both algorithms require modifications only to the sender side of the TCP implementation. Simulation is used to evaluate the performance of the algorithms. The simulation experiments are conducted using the ns simulator, to facilitate comparisons with Tahoe, Reno, New-Reno, SACK, and FACK TCP. The simulation results show that the new scheme performs at least as well as SACK and FACK TCP, which in turn consistently outperform TCP Tahoe and Reno. Furthermore, the implementation of the new scheme is simpler than that of SACK and FACK.

The User Requirements Notation (URN) combines the Goaloriented Requirement Language (GRL) with the Use Case Map (UCM) scenario notation. Although tools exist in isolation for both views, they are currently not meant to work together, hence preventing one to exploit URN to its fullest extent. This paper presents jUCMNav, a new Eclipse-based tool that supports both UCM and GRL in an integrated way. jUCMNav supports links between the two languages that can be exploited during analysis. An overview of the current editing and analysis capabilities is given, with a particular emphasis on the new concept of GRL strategies, which simplify the evaluation of GRL models. The extensibility of the tool is also discussed.

Graphical system design techniques like Message Sequence Chart (MSC) and Unified Modelling Language (UML) are gaining more and more acceptance because they ease the development, understanding, and maintenance of software systems. In the testing area no accepted graphical test specification and implementation techniques exist. To overcome this shortcoming, a graphical presentation format for the Testing and Test Control Notation (GFT) has been defined. GFT supports the graphical design, implementation, visualization, documentation and tracing of test behaviour. GFT is based on MSC and extends it with test specific concepts like verdicts and defaults. GFT is also the basis for the definition of a UML testing profile to enable the integrated system and test development with UML models. This paper discusses GFT and its relation to MSC and to the UML testing profile.

Understanding software-based systems is a task essential not only for engineering new applications but also for evolving existing ones. For complex systems, the graphical representation of various attributes and projections contributes to such understanding. Also, scenarios have proven to greatly accelerate software understanding by capturing abstract system behavior. For existing software, abstraction based on architectural concepts is required to address the overflow of information generated by static code and dynamic executions. This paper explores a tool-supported technique for the extraction of abstract Use Case Map (UCMs) scenarios from code, and reports on work in progress through an example. UCMs, as part of the upcoming User Requirements Notation, help visualizing behavior combined with structure at the architecture level, above the level of message exchanges and component behavior. The unusual application of UCMs proposed here promises interesting visualization and abstraction benefits over conventional approaches to the reverse engineering of scenarios while maintaining traceability to the code.

A regeneration-theory approach is undertaken to analytically characterize the average overall completion time in a distributed system. The approach considers the heterogeneity in the processing rates of the nodes as well as the randomness in the delays imposed by the communication medium. The optimal one-shot load balancing policy is developed and subsequently extended to develop an autonomous and distributed load-balancing policy that can dynamically reallocate incoming external loads at each node. This adaptive and dynamic load balancing policy is implemented and evaluated in a two-node distributed system. The performance of the proposed dynamic load-balancing policy is compared to that of static policies as well as existing dynamic load-balancing policies by considering the average completion time per task and the system processing rate in the presence of random arrivals of the external loads.

Requirement Specification is gaining increasingly attention as a critical phase of software systems development. As requirement descriptions evolve, they quickly become error-prone and difficult to understand. Thus, the development of techniques and tools to support requirement specification development, understanding, testing, maintenance and reuse becomes an important issue. This paper extends the well-known technique of program slicing to Functional Requirement Specification based on Use Case Maps notation. This new application of slicing, called UCM Requirement Slicing is useful to aid requirement comprehension and maintenance. In contrast to traditional program slicing, requirement slicing is designed to operate on the requirement specification of a system, rather than the source code of a program. The resulting requirement slice provides knowledge about high-level structure of a system, rather than its low-level implementation details. In order to compute a UCM Requirement slice, we provide a three steps slicing algorithm.

Scenario-driven requirement specifications are widely used to capture and represent functional requirements. Use Case Maps are being standardized as part of the User Requirements Notation (URN), the most recent addition to ITU-T's family of languages. UCM models focus on the description of functional requirements and high-level designs at early stages of the development process. How a system is executed over time and how this may affect its correctness and performance, however, are introduced later in the development process which may require considerable changes in design or even worse at the requirement analysis level. We believe that timing aspects must be integrated into the system model, and this must be done already at an early stage of development. This paper introduces an approach to describe timing constraints in Use Case Maps specifications. We present a formal semantics of Timed UCM in terms of Clocked Transition Systems (CTS). We illustrate our approach using an example of a simplified wireless system.

Requirement Specification is gaining increasingly attention as a critical phase of software systems development. As requirement descriptions evolve, they quickly become error-prone and difficult to understand. Thus, the development of techniques and tools to support requirement specification development, understanding, testing, maintenance and reuse becomes an important issue. This paper extends the well-known technique of program slicing to Functional Requirement Specification based on Use Case Maps notation. This new application of slicing, called UCM Requirement Slicing is useful to aid requirement comprehension and maintenance. In contrast to traditional program slicing, requirement slicing is designed to operate on the requirement specification of a system, rather than the source code of a program. The resulting requirement slice provides knowledge about high-level structure of a system, rather than its low-level implementation details. In order to compute a UCM Requirement slice, we provide a three steps slicing algorithm.

This paper presents a new approach to TCP congestion control. The new scheme includes two parts: (1) the Smooth-Start algorithm, which replaces the Slow-Start algorithm at the start of a TCP connection or after a retransmission timeout, and (2) the Dynamic Recovery algorithm, which replaces the Fast Recovery algorithm to recover packet losses when a TCP connection is congested. Both algorithms require modifications only to the sender side of the TCP implementation. Simulation is used to evaluate the performance of the algorithms. The simulation experiments are conducted using the ns simulator, to facilitate comparisons with Tahoe, Reno, New-Reno, SACK, and FACK TCP. The simulation results show that the new scheme performs at least as well as SACK and FACK TCP, which in turn consistently outperform TCP Tahoe and Reno. Furthermore, the implementation of the new scheme is simpler than that of SACK and FACK.

In November 1999, the International Telecommunication Union (ITU-T, SG 17) initiated a question on the standardization of a User Requirements Notation (URN) for complex reactive, distributed, and dynamic systems and applications. URN is intended to be standardized by September 2003. This paper presents the motivations behind URN, its objectives, and the current proposal that combines two complementary languages. The first one, GRL (Goal-oriented Requirement Language), is used to describe business goals, nonfunctional requirements, alternatives, and rationales. The second one, UCM (Use Case Maps), enables the description of functional requirements as causal scenarios. The introduction of URN is likely to impact the development ans use of other SG 17 languages (especially MSC and SDL) as well as OMG's UML. This paper briefly explores several relations between these languages as well as potential for synergy and coordination. ous requirements to be expressed and clarified, thus reducing development costs caused by requirements problems and discussions that are repeated over and over again. The second aspect, important to a wide range of problem domains, will allow front-end software development activities to be tied more closely to the subsequent activities. This promises more complete life cycle round-trip engineering, a reduction of development time, and an increase in the software quality. Telecommunication systems based on recent and upcoming technologies such as agents, mobility, and IP are representative of dynamic systems as mentioned by the third aspect. These systems raise new modelling issues because of complex and sometimes unpredictable policy-driven negotiations between communicating entities and lead to protocols and entities more dynamic in nature and evolving at run time.

Abstracting the behaviour of a specification is a key technique for dealing with the complexity of such tasks as reachability analysis and test generation. We adapted classical data-flow analysis techniques to abstract variables in SDL processes and addressed the problem of finding conservative state abstractions. Prototype tools have been developed to implement those techniques and applied to simple applications from the field of telecommunications.