Component-based Systems Research Articles

Locating one pairwise interaction: Three recursive constructions

In a complex component-based system, choices (levels) for components (factors) may interact to cause faults in the system behaviour. When faults may be caused by interactions among few factors at specific levels, covering arrays provide a combinatorial test suite for discovering the presence of faults. While well studied, covering arrays do not enable one to determine the specific levels of factors causing the faults; locating arrays ensure that the results from test suite execution suffice to determine the precise levels and factors causing faults, when the number of such causes is small. Constructions for locating arrays are at present limited to heuristic computational methods and quite specific direct constructions. In this paper three recursive constructions are developed for locating arrays to locate one pairwise interaction causing a fault.

Contextual abstraction in a type system for component-based high performance computing platforms

HTS (Hash Type System) is a type system designed for component-based high performance computing (CBHPC) platforms, aimed at reconciling portability, modularity by separation of concerns, a high-level of abstraction and high performance. Portability and modularity are properties of component-based systems that have been extensively validated. For improving the performance of HPC applications, HTS introduces an automated approach for dynamically discovering, loading and binding parallel components tuned for the characteristics of the parallel computing platforms where the application will execute. To do so, it is based on contextual abstraction, where the performance of components that encapsulate parallel computations, communication patterns and data structures may be tuned according to the features of parallel computing platforms and the application requirements. In turn, for providing a higher level of abstraction in parallel programming, HTS supports an expressive approach for skeleton-based programming. A study of the safety properties of HTS using a calculus of component composition has provided solid foundations for the design of configuration languages for the safe specification and deployment of parallel components. The features of HTS are validated with three case studies that exercise the programming techniques behind contextual abstraction, including skeletons and performance tuning.

Analyzing and visualizing information flow in heterogeneous component-based software systems

Context: Component-based software engineering is aimed at managing the complexity of large-scale software development by composing systems from reusable parts. To understand or validate the behavior of such a system, one needs to understand the components involved in combination with understanding how they are configured and composed. This becomes increasingly difficult when components are implemented in various programming languages, and composition is specified in external artifacts. Moreover, tooling that supports in-depth system-wide analysis of such heterogeneous systems is lacking.Objective: This paper contributes a method to analyze and visualize information flow in a component-based system at various levels of abstraction. These visualizations are designed to support the comprehension needs of both safety domain experts and software developers for, respectively, certification and evolution of safety-critical cyber-physical systems.Method: We build system-wide dependence graphs and use static program slicing to determine all possible end-to-end information flows through and across a system’s components. We define a hierarchy of five abstractions over these information flows that reduce visual distraction and cognitive overload, while satisfying the users’ information needs. We improve on our earlier work to provide interconnected views that support both systematic, as well as opportunistic navigation scenarios.Results: We discuss the design and implementation of our approach and the resulting views in a prototype tool called FlowTracker. We summarize the results of a qualitative evaluation study, carried out via two rounds of interview, on the effectiveness and usability of these views. We discuss a number of improvements, such as more selective information presentations, that resulted from the evaluation.Conclusion: The evaluation shows that the proposed approach and views are useful for understanding and validating heterogeneous component-based systems, and address information needs that could earlier only be met by manual inspection of the source code. We discuss lessons learned and directions for future work.

Rigorous development of component-based systems using component metadata and patterns

Abstract In previous work we presented a CSP-based systematic approach that fosters the rigorous design of component-based development. Our approach is strictly defined in terms of composition rules, which are the only permitted way to compose components. These rules guarantee the preservation of properties (particularly deadlock freedom) by construction in component composition. Nevertheless, their application is allowed only under certain conditions whose verification via model checking turned out impracticable even for some simple designs, and particularly those involving cyclic topologies. In this paper, we address the performance of the analysis and present a significantly more efficient alternative to the verification of the rule side conditions, which are improved by carrying out partial verification on component metadata throughout component compositions and by using behavioural patterns. The use of metadata, together with behavioural patterns, demands new composition rules, which allow previous exponential time verifications to be carried out now in linear time. Two case studies (the classical dining philosophers, also used as a running example, and an industrial version of a leadership election algorithm) are presented to illustrate and validate the overall approach.

Editorial

This special issue of the Formal Aspects of Computing journal contains a selection of the best papers accepted at the 12 th edition of the international conference series on Software Engineering and Formal Methods (SEFM). This conference was held in Grenoble (France) on September 1-5, 2014. The aim of the conference was to bring together practitioners and researchers from academia, industry and government to advance the state of the art in formal methods, to scale up their application in the software industry and to encourage their integration with practical engineering methods. The SEFM'14 conference received 106 full submissions, and the programme committee of the conference decided to accept 29 papers. Out of these 29 papers, we selected the best six papers, and the authors of these papers were invited to submit a revised and extended version of their work to this special issue. After a meticulous review process, we finally accepted five of the six invited papers. The topics covered in this special issue are the following: Domain Specific Languages, Component-based Systems and Architectures, Learning Finite State Machines, Construction and Verification of Imperative Programs, and Partial Order Reduction in the context of Model Checking.

Decentralised LTL monitoring

Users wanting to monitor distributed or component-based systems often perceive them as monolithic systems which, seen from the outside, exhibit a uniform behaviour as opposed to many components displaying many local behaviours that together constitute the system's global behaviour. This level of abstraction is often reasonable, hiding implementation details from users who may want to specify the system's global behaviour in terms of a linear-time temporal logic (LTL) formula. However, the problem that arises then is how such a specification can actually be monitored in a distributed system that has no central data collection point, where all the components' local behaviours are observable. In this case, the LTL specification needs to be decomposed into sub-formulae which, in turn, need to be distributed amongst the components' locally attached monitors, each of which sees only a distinct part of the global behaviour. The main contribution of this paper is an algorithm for distributing and monitoring LTL formulae, such that satisfaction or violation of specifications can be detected by local monitors alone. We present an implementation and show that our algorithm introduces only a negligible delay in detecting satisfaction/violation of a specification. Moreover, our practical results show that the communication overhead introduced by the local monitors is generally lower than the number of messages that would need to be sent to a central data collection point. Furthermore, our experiments strengthen the argument that the algorithm performs well in a wide range of different application contexts, given by different system/communication topologies and/or system event distributions over time.

Components integration-effect graph: a black box testing and test case generation technique for component-based software

Testing plays a vital role in the evolution and establishment of any quality product as well as any quality system. Testing is essential to prove the correctness (valid output when input is valid, and proper handling techniques when input is invalid) of the system and it is crucial to prove the compatibility of the system with the operating environment. In component-based software systems, various components interact with each other to access as well as provide required functionalities. In such complex systems testing is one of the most important activities. Since component-based software engineering relies on the concept of “use of pre-built and pre-tested components”, our focus here, is on functional testing rather than structural testing. Functional testing emphasizes the behavioural attributes of the components when they interact with each other. Components interact through operands and parameters. In this paper we suggest functional testing strategy and test case generation technique for component-based software. When two components are integrated then they generate some specific effect. This strategy is named Integration-effect graph. This strategy is a black-box technique as it covers the input and output domains only. We have used the graph theory notations to show the integration and interaction among the components.

Fundamentals of safety management: The Offshore Helicopter Transportation System Model

A precondition for a holistic, systemic and systematic management of offshore helicopter operations’ safety is an in-depth understanding of the corresponding system. This is essential because the components and the interactions between these components largely shape system and human performance, with the potential to create safety hazards and risks. However, current techniques of system component description in aviation are poorly specified, which contributes to a silo approach to hazard identification and risk analysis, poor safety management and missed safety targets. This paper addresses this shortcoming by developing a novel process to characterise the component-based system architecture of commercial air operations and implementing the process to create the Offshore Helicopter Transportation System Model. The paper discusses the theoretical justifications for generating such a system model and the shortcomings of the techniques currently recommended. In order to redress these, the process combines two task analysis techniques to derive an unbiased seminal system model, which is then compared to relevant models in the safety literature to ensure completeness. The process and resulting system model are validated by carefully selected subject matter experts during training sessions in high-fidelity flight simulators. The process can be applied to describe, by means of a system model, the activities of other industries in the aviation domain. Moreover, the model derived provides, for the first time, the necessary anchoring for future safety analyses in offshore helicopter operations.

Fully automated runtime enforcement of component-based systems with formal and sound recovery

We introduce runtime enforcement of specifications on component-based systems (CBS) modeled in the behavior, interaction and priority (BIP) framework. Runtime enforcement is an increasingly popular and effective dynamic validation technique aiming to ensure the correct runtime behavior (w.r.t. a formal specification) of a system using a so-called enforcement monitor. BIP is a powerful and expressive component-based framework for the formal construction of heterogeneous systems. Because of BIP expressiveness, however, it is difficult to enforce complex behavioral properties at design-time. We first introduce a theoretical runtime enforcement framework for component-based systems where we delineate a hierarchy of enforceable properties (i.e., properties that can be enforced) according to the number of observational steps a system is allowed to deviate from the property (i.e., the notion of k-step enforceability). To ensure the observational equivalence between the correct executions of the initial system and the monitored system, we show that (i) only stutter-invariant properties should be enforced on CBS with our monitors, and (ii) safety properties are 1-step enforceable. Second, given an abstract enforcement monitor for some 1-step enforceable property, we define a series of formal transformations to instrument (at relevant locations) a CBS described in the BIP framework to integrate the monitor. At runtime, the monitor observes and automatically avoids any error in the behavior of the system w.r.t. the property. Third, our approach is fully implemented in RE-BIP, an available tool integrated in the BIP tool suite. Fourth, to validate our approach, we use RE-BIP to (i) enforce deadlock-freedom on a dining philosophers benchmark, and (ii) ensure the correct placement of robots on a map.

Classification-based Mining of Reusable Components on Software Product Lines

Software Product Lines and Component-based systems can be combined to maximize reuse in a predictable and opportunistic manner. When a product line is built for a certain subdomain within a more generic domain, future needs from a closely subdomain may be fulfilled by mining the line's internal components to build a new product line. In this work, we present an approach to classify internal and external (third party) reusable components into a repository, by applying a K-Nearest Neighbors strategy, as a support for building new product lines. Natural language techniques and the WordNet lexical database is also used to process information from software components. We validate the approach with an experiment based in a dataset of external third-party components and reusable components from a product line that we built in the geographic subdomain of marine ecology.

Optimum detecting arrays for independent interaction faults

The use of detecting arrays (DTAs) is motivated by the need to locate and detect interaction faults arising between the factors in a component-based system in software testing. The optimality and construction of DTAs have been investigated in depth for the case in which all the interaction faults are assumed to have the same strength; however, as a practical concern, the strengths of these faults are not always identical. For real world applications, it would be desirable for a DTA to be able to identify and detect faulty interactions of a strength equal to or less than a specified value under the assumption that the faulty interactions are independent from one another. To the best of our knowledge, the optimality and construction of DTAs for independent interaction faults have not been studied systematically before. In this paper, we establish a general lower bound on the size of DTAs for independent interaction faults and explore the combinatorial feature that enable these DTAs to meet the lower bound. Taking advantage of this combinatorial characterization, several classes of optimum DTAs meeting the lower bound are presented.

Synthesizing structural and behavioral control for reconfigurations in component-based systems

Abstract Correctness of the behavior of an adaptive system during dynamic adaptation is an important challenge to realize correct adaptive systems. Dynamic adaptation refers to changes to both the functionality of the computational entities that comprise a composite system, as well as the structure of their interconnections, in response to variations in the environment, e.g., the load of requests on a server system. In this research, we view the problem of correct structural adaptation as a supervisory control problem and synthesize a reconfiguration controller that guides the behavior of a system during adaptation. The reconfiguration controller observes the system behavior during an adaptation and controls the system behavior by allowing/disallowing actions in a way to ensure that a given property is satisfied and a deadlock is avoided. The system during adaptation is modeled using a graph transition system and properties to be enforced are specified using a graph automaton. We adapt a classical theory of supervisory control for synthesizing a controller for controlling the behavior of a system modeled using graph transition systems. This theory is used to synthesize a controller that can impose both behavioral and structural constraints on the system during an adaptation. We apply a tool that we have implemented to support our approach on a case study involving https servers.

Component-based Systems Reconfigurations Using Graph Grammars

Dynamic reconfigurations can modify the architecture of component-based systems without incurring any system downtime. In this context, the main contribution of the present article is the establishment of correctness results proving component-based systems reconfigurations using graph grammars. New guarded reconfigurations allow us to build reconfigurations based on primitive reconfiguration operations using sequences of reconfigurations and the alternative and the repetitive constructs, while preserving configuration consistency. A practical contribution consists of the implementation of a component-based model using the GROOVE graph transformation tool. Then, after enriching the model with interpreted configurations and reconfigurations in a consistency compatible manner, a simulation relation is exploited to validate component systems’ implementations. This sound implementation is illustrated on a cloud-based multitier application hosting environment managed as a component-based system.

A facial component-based system for emotion classification

Smart environments with ubiquitous computers are the next generation of information technology, which requires improved human--computer interfaces. That is, the computer of the future must be aware of the people in its environment; it must know their identities and must understand their moods. Despite the great effort made in the past decades, the development of a system capable of automatic facial emotion recognition is still rather difficult. In this paper, we challenge the benchmark algorithm on emotion classification of the Extended Cohn-Kanade (CK$+)$ database, and we present a facial component-based system for emotion classification, which beats the given benchmark performance: using a 2D emotional face, we searched for highly discriminative areas, we classified them independently, and we fused all results together to allow for facial emotion recognition. The use of the sparse-representation-based classifier allows for the automatic selection of the two most successful blocks and obtains the best results by beating the given benchmark performance by six percentage points. Finally, using the most promising algorithms for facial analysis, we created equivalent facial component-based systems and we made a fair comparison among them.

Estimating age from the pubic symphysis: A new component-based system

The os pubis is one of the most widely used areas of the skeleton for age estimation. Current pubic symphyseal aging methods for adults combine the morphology associated with the developmental changes that occur into the mid-30s with the degenerative changes that span the latter portion of the age spectrum. The most popular methods are phase-based; however, the definitions currently used to estimate age intervals may not be adequately defined and/or accurately understood by burgeoning researchers and seasoned practitioners alike. This study identifies patterns of growth and maturation in the pubic symphysis to derive more precise age estimates for individuals under 40 years of age. Emphasis is placed on young adults to provide more informative descriptions of epiphyseal changes associated with the final phases of skeletal maturation before degeneration commences. This study investigated macroscopic changes in forensically relevant modern U.S. samples of known age, sex, and ancestry from the Maricopa County Forensic Science Center in Phoenix, Arizona as well as donated individuals from the William M. Bass Forensic and Donated Collections at the University of Tennessee, Knoxville (n=237). Age-related traits at locations with ontogenetic and biomechanical relevance were broken into components and scored. The components included the pubic tubercle, the superior apex of the face, the ventral and dorsal demifaces, and the ventral and dorsal symphyseal margins. Transition analysis was applied to elucidate the transition ages between the morphological states of each component. The categorical scores and transition analysis ages were subjected to multinomial logistic regression and decision tree analysis to derive accurate age interval estimates. Results of these analyses were used to construct a decision tree-style flow chart for practitioner use. High inter-rater agreement of the individual component traits (linear weighted kappa values ≥0.665 for all traits in the decision tree) indicates that the method offers unambiguous scoring for age-related changes of the pubic symphysis. Validation of the flow chart on a sample of 47 individuals provided by the Montana State Crime Lab yielded 94% accuracy overall, indicating that the method has the potential to deliver precise and accurate age estimates of individuals prior to the onset of advanced degenerative changes. A pubic symphysis that exhibits epiphyseal changes and/or billowing is suitable for this method; a pubic symphysis that exhibits degenerative changes (i.e. porosity and/or rim erosion) is not suitable.

Automatic synthesis of communication and concurrency for exploring component-based system implementations considering UML channel semantics

Nowadays, multi-processor systems play a critical role in embedded system engineering. As a result, the generation of optimal concurrent implementations is an unavoidable but difficult task. Correct concurrent codes achieving maximum performance on the target platform are hard to obtain. On the one hand, dependencies on concurrent computations, such as shared variables or synchronizations, are extremely difficult to analyze from source code. On the other hand, it is completely unfeasible for designers to manually generate multiple implementations in order to evaluate and compare all the possible design alternatives. To overcome these limitations, this paper presents an automatic code generation approach focusing on communication channel semantics. The approach proposes the use of UML/MARTE models to enable designers to graphically handle dependencies and concurrency of the models. As a result, the automatic generation process enables multiple design alternatives to be easily obtained and evaluated without adding manual effort to the design process. To demonstrate these capabilities, the methodology is tested with two large examples.

A general framework for blaming in component-based systems

In component-based safety-critical embedded systems it is crucial to determine the cause(s) of the violation of a safety property, be it to issue a precise alert, to steer the system into a safe state, or to determine liability of component providers. In this paper we present an approach to blame components based on a single execution trace violating a safety property P. The diagnosis relies on counterfactual reasoning (“what would have been the outcome if component C had behaved correctly?”) to distinguish component failures that actually contributed to the outcome from failures that had little or no impact on the violation of P.

Bottom-Up Fault Management in Service-Based Systems

Service Oriented Architecture (SOA) enables the creation of distributed applications from independently developed and deployed services. As with any component-based system, the overall performance and quality of the system is an aggregate function of its component services. In this article, we present a novel approach for managing bottom-up faults in service-based systems. Bottom-up faults are a special case of system-wide exceptions that are defined as abnormal conditions or defects occurring in component services, which if not detected and/or managed, may lead to runtime failures. Examples of bottom-up faults include network outage, server disruption, and changes to service provisioning (e.g., new operation parameter required) that may have an impact on the way component services are consumed. We propose a soft-state signaling-based approach to propagate these faults from participants to composite services. Soft-state refers to a class of protocols where the state of a service is constantly refreshed by periodic messages, and user/service takes up the responsibility of communicating and maintaining its state. Soft-state-based protocols have a number of advantages including implicit error recovery and easier fault management, resulting in high availability for systems. Although soft-state has been widely used in various Internet protocols, this work is the first (to the best of our knowledge) to adopt soft-state for fault management in composite services. The proposed approach includes protocols for fault propagation (pure soft-state and soft-state with explicit removal) and fault reaction (rule-based). We also present experiment results to assess the performance and applicability of our approach.

An approach based on feature models and quality criteria for adapting component-based systems

Feature modeling has been widely used in domain engineering for the development and configuration of software product lines. A feature model represents the set of possible products or configurations to apply in a given context. Recently, this formalism has been applied to the runtime (re-)configuration of systems with high variability and running in changing contexts. These systems must adapt by updating their component assembly configuration at runtime, while minimizing the impact of such changes on the quality of service. For this reason the selection of a good system configuration is seen as an optimization problem based on quality attribute criteria. We propose an approach for system adaptation based on the specification, measurement and optimization of quality attribute properties on feature models. Furthermore, we describe its integration into a platform for supporting the self-adaptation of component-based systems. Feature models are annotated with quality attribute properties and metrics, and then an efficient algorithm is used to deal with the optimization problem. Two performance properties –frame processing time and reconfiguration time– are estimated with our model against measurements obtained from the running system to show the accuracy of metrics on feature models for estimating quality attribute properties. The results show evidence that these metrics are reasonably accurate for measuring performance properties on a realistic component-based computer vision system.

COMPOSITION OF AUGMENTED MARKED GRAPHS AND ITS APPLICATION TO COMPONENT-BASED SYSTEM DESIGN

Augmented marked graphs possess some structural characteristics which are especially desirable for modelling systems with common resources. This paper first investigates the composition of augmented marked graphs via common resource places. Special focus is placed on preservation of four properties, namely, liveness, boundedness, reversibility and conservativeness. It is then applied to component-based system design, where the system components are specified as augmented marked graphs and composed via their common resource places. Based on the preservation of properties of this composition, the liveness, boundedness, reversibility and conservativeness of the integrated system can be readily derived. Examples of manufacturing system integration are used for illustration.