The 4C spectrum of fundamental behavioral relations for concurrent systems

The design of concurrent software systems, in particular process-aware information systems, involves behavioral modeling at various stages. Recently, approaches to behavioral analysis of such systems have been based on declarative abstractions defined as sets of behavioral relations. However, these relations are typically defined in an ad-hoc manner. In this paper, we address the lack of a systematic exploration of the fundamental relations that can be used to capture the behavior of concurrent systems, i.e., co-occurrence, conflict, causality, and concurrency. Besides the definition of the spectrum of behavioral relations, which we refer to as the 4C spectrum, we also show that our relations give rise to implication lattices. We further provide operationalizations of the proposed relations, starting by proposing techniques for computing relations in unlabeled systems, which are then lifted to become applicable in the context of labeled systems, i.e., systems in which state transitions have semantic annotations. Finally, we report on experimental results on efficiency of the proposed computations

Advanced SPIN Tutorial

Spin [9] is a model checker for the verification of distributed systems software. The tool is freely distributed, and often described as one of the most widely used verification systems. The Advanced Spin Tutorial is a sequel to [7] and is targeted towards intermediate to advanced Spin users

Methodology for object-oriented real-time systems analysis and design: Software engineering

Successful application of software engineering methodologies requires an integrated analysis and design life-cycle in which the various phases flow smoothly 'seamlessly' from analysis through design to implementation. Furthermore, different analysis methodologies often lead to different structuring of the system so that the transition from analysis to design may be awkward depending on the design methodology to be used. This is especially important when object-oriented programming is to be used for implementation when the original specification and perhaps high-level design is non-object oriented. Two approaches to real-time systems analysis which can lead to an object-oriented design are contrasted: (1) modeling the system using structured analysis with real-time extensions which emphasizes data and control flows followed by the abstraction of objects where the operations or methods of the objects correspond to processes in the data flow diagrams and then design in terms of these objects; and (2) modeling the system from the beginning as a set of naturally occurring concurrent entities (objects) each having its own time-behavior defined by a set of states and state-transition rules and seamlessly transforming the analysis models into high-level design models. A new concept of a 'real-time systems-analysis object' is introduced and becomes the basic building block of a series of seamlessly-connected models which progress from the object-oriented real-time systems analysis and design system analysis logical models through the physical architectural models and the high-level design stages. The methodology is appropriate to the overall specification including hardware and software modules. In software modules, the systems analysis objects are transformed into software objects

Correct Transformation of High-Level Models into Time-Triggered Implementations

A number of component-based frameworks have been proposed to tackle the complexity of the design of concurrent software and systems and, in particular, to allow modelling and simulation of critical embedded applications. Such design frameworks usually provide a capability for automatic generation of C++ or Java code, which has to be compiled for the selected target platform. Thus, guaranteeing hard real-time constraints is, at best, difficult. On the other hand, a variety of Real-Time Operating System (RTOS), in particular, those based on the Time-Triggered (TT) paradigm, guarantee the temporal and behavioural determinism of the executed software. However, such TT-based RTOS do not provide high-level design frameworks enabling the scalable design of complex safety-critical real-time systems. In this report, we combine advantages of the two approaches, by deriving correct-by-construction TT implementations from high-level componentised models. We present an automatic semantics-preserving transformation from RT-BIP (Real-Time Behaviour-Interaction-Priority) to PharOS—a safety-oriented RTOS, implementing the TT paradigm. The transformation has been implemented; we prove its correctness and illustrate it with a realistic case-study

Test case generation technique for concurrency in activity diagram

Presently, the application of Model-Based Testing (MBT) using Unified Modelling Language (UML) has attracted the attention of many practitioners to use UML diagrams for generation of test cases. By using this technique, early detection of faults can be achieved at the design phase. However, some UML diagrams have limitations in generating test cases such as the need for a loop combination fragment to describe looping, iteration process and combination fragment with the par operator to interpret concurrency activities. To overcome these issues, a feature analysis was conducted to observe the outcome of test case generation using similar cases but, by using different techniques and UML diagrams. Based on the results, a guideline for selecting UML diagrams in the generation of test cases based on the different features of software system in the cases was developed. However, system design of concurrent software is complex, leading to issues in system testing such as synchronization, non-deterministic, path explosion and deadlock. In this research, an enhancement of the generate-activity-paths algorithm as a test case generation technique was developed to solve the non-deterministic problem of concurrent system. As the test cases are generated in a random order, a prioritization technique using genetic algorithm was applied to find the critical path that must be tested first from the test paths produced. The technique was implemented on the Conference Management System case study and evaluated using cyclomatic complexity, branch coverage, mutation analysis and average percentage of fault detected (APFD) to measure the effectiveness and quality of the test cases in comparison to those using the original technique. Results indicated that the technique achieved 100% basis path and branch coverage criteria similar to the original technique. Moreover, it is also capable of revealing non-deterministic faults by injecting concurrency coverage criteria into the test paths, which was not possible using the original technique. Additionally, prioritization of test paths yielded an APFD value of 43% which is better and higher than the non-prioritized test paths (22%). This result signified that the usage of prioritization technique leads to an improve detection rate of severe faults as compared to applying random order