Architecture Description Language Research Articles

Component-based Functional Integrated Circuit System Design and Its Straight Implementation

Component-based Functional Integrated Circuit System (FICS) refers to the design and implementation of FICS using the Integrated Circuit system components. This paper discusses two parts: the Component-based Services Framework (CSF), or rather, the FICS framework for component-based application services, and Functional Integrated Circuit System Architecture Description Language (FICSADL), or rather, the application layer language for FICS service framework. The paper defines the FICSADL language elements, descriptive methods and formal specification by means of mapping the components of the service layer onto the connectors of the semantic layer. Various FICS business and system requirements are met by adjusting the connector glue parts on the semantic layer. Finally, the paper demonstrates the FICSADL π-calculus. This component-based FICS design and implementation is a design and implementation straight and directly from the algorithm to chip.

Event B Development of a Synchronous AADL Scheduler

This paper presents the modelisation of the semantics of a subset of the architecture description language AADL using Event-B. Elements of the semantics of the considered subset are gradually introduced in order to make possible the traceability of the formal text against the informal specification. Starting from a very general computational model, we incrementally add elements of AADL by constraining or instantiating it and finally introduce a family of schedulers. The Rodin platform is used to prove the correctness of this development.

Formal description of the crossing social network system architecture based on temporal logic

How to organize crossing social network resources on a higher level of integration and address them to users’ desktops is an important difficult problem. Especially, there is a lack of efficient approaches to software architecture to build reusable system over the crossing social network. From the viewpoint of temporal logic XYZ/E, this paper proposes a kind of Architecture Description Language about the Crossing Social Network system (CSN_ADL), which can be used to depict the main key processes over the cross-social network system, and formally defines some key concepts, such as relation component, corelation component, override corelation connector, interaction connector, corelation network-oriented architecture, as well as system correctness, system activity, and system safety. Furthermore, some properties of correctness, activity, and safety under the frame CSN_ADL is discussed and depicted formally, which provides a formally theoretical instruction for architecture reuses.

Damon: A distributed AOP middleware for large-scale scenarios

Context The development of distributed applications in large-scale environments has always been a complex task. In order to guarantee non-functional properties like scalability or availability, developers are usually faced with the same problems over and over again. These problems can be separated in distributed concerns, as for example, distribution, load-balancing or replication, just to name a few. Nevertheless, none of the current solutions in adaptive middleware area, like Aspect-Oriented Programming (AOP), is capable of implementing these distributed concerns transparently. Objective In this article, we present a distributed AOP middleware for large-scale development, called Damon. Its main goal is to implement true distributed aspects, which enables the use of distributed concerns in applications that were not specifically designed for distributed or large-scale scenarios. Method Our middleware comprises two main layers: a distributed composition model and a scalable deployment platform. The distributed composition model envisages separation of distributed aspects, taking the necessary features from component models, like distribution facilities and connectors, and from computational reflection, like introspection and meta-levels. This recursive and fully distributed model provides its own Architecture Description Language (ADL), and thus allows low dependency and high cohesion among distributed aspects. Additionally, our model is built on top of a deployment platform where distributed aspects are disseminated and activated in individual or grouped hosts. This platform benefits from peer-to-peer and dynamic AOP substrates to implement its services in a decentralized, decoupled, and efficient way. Results Therefore, our middleware solution reduces the complexity of distributed application development, managing separated functionalities, and enabling necessary services like transparent reconfiguration and deployment at runtime. Finally, we have implemented a functional prototype and we conducted several experiments using the PlanetLab testbed. Conclusion Our distributed AOP approach fulfills the large-scale scenarios requirements, and represents a solid building block for future distributed transparent infrastructures.

T&D-Bench—Innovative Combined Support for Education and Research in Computer Architecture and Embedded Systems

Teaching and Design Workbench (T&D-Bench) is a framework aimed at education and research in the areas of computer architecture and embedded systems. It includes a set of features not found in other educational environments. This set of features is the result of an original combination of design requirements for T&D-Bench: that the framework should provide modeling capabilities similar to that of Architecture Description Languages (popular in embedded systems design), and that it should have the simulation capabilities found only in educational simulators. This paper highlights the main features and the latest achievements of the framework and of its didactic and research simulators. The results of a new didactic strategy, supported by the simulators, are presented and discussed. The design of a new architectural feature for embedded processors, using a research simulator, is introduced, and it is shown how to employ such a research work as an educational module to teach the complexities involved in embedded systems design.

Component-based approach for programming and running scientific applications on grids and clouds

This paper presents an approach to programming and running scientific applications on grid and cloud infrastructures based on two principles: the first one is to follow a component-based programming model, the second is to apply a flexible technology which allows for virtualization of the underlying infrastructure. The solutions described in this paper include high-level composition and deployment consisting of a scripting-based environment and a manager system based on an architecture description language (ADL), a dynamically managed pool of component containers, and interoperability with other component models such as Grid Component Model (GCM). We demonstrate how the proposed methodology can be implemented by combining the unique features of the Common Component Architecture (CCA) model together with the H2O resource sharing platform, resulting in the MOCCA component framework. Applications and tests include data mining using the Weka library, Monte Carlo simulation of the formation of clusters of gold atoms, as well as a set of synthetic benchmarks. The conclusion is that the component approach to scientific applications can be successfully applied to both grid and cloud infrastructures.

Changing attitudes towards the generation of architectural models

Architectural design is an important activity, but the understanding of how it is related to requirements modeling is rather limited. It is worth noting that goal orientation is an increasingly recognized paradigm for eliciting, modeling, specifying, and analyzing software requirements. However, it is not clear how goal models are related to architectural models. In this paper we present an approach based on model transformations to derive architectural structural specifications from system goals. The source and target languages are respectively the i* (iStar) modeling language and the Acme architectural description language. A real case study is used to show the feasibility of our approach.

Integrated safety and architecture modeling for automotive embedded systems*

EAST-ADL is an architecture description language (ADL) for model-based development of automotive embedded systems. The formalization of domain-specific engineering information and methodology brings a potential for a wide range of benefits for information management, system design and integration, tool interaction, documentation and communication. This paper describes the EAST-ADL language support for safety requirements, faults/failures, hazards and safety constraints in the context of ISO/DIS 26262 reference safety lifecycle. Based on the language support, the safety related information can be derived and managed seamlessly along with its target nominal system architecture model with multiple abstraction levels and view extensions. Through model transformation and tool integration, automated safety analysis is allowed.

A development methodology for variant-rich automotive software architectures

Ever accelerating product cycles together with multi-discipline engineering processes are typical for safety-critical automotive embedded systems development. This demands for both efficient and effective development and reuse strategies. A development process following the V-model incorporating model-driven prototyping and development, safety engineering, and verification (unit testing, integration testing, cosimulation, etc.) is commonly found. Product line engineering enables fast and efficient product configuration through systematic reuse. The V-model has been extended by an integrated product line engineering environment for automotive embedded systems. This ensures the consistent configuration across system architecture description (EAST-ADL2), model driven development (Matlab/Simulink), software component deployment on an ECU network (AUTOSAR-based), Simulink-based software unit testing, Simulink-based software integration testing, and co-simulation model variants. Using the automotive architecture description language EAST-ADL2 enables the integration of safety engineering aspects.

Multi-task Implementation of Multi-periodic Synchronous Programs

This article presents a complete scheme for the integration and the development of multi-periodic critical embedded systems. A system is formally specified as a modular and hierarchical assembly of several locally mono-periodic synchronous functions into a globally multi-periodic synchronous system. To support this, we introduce a real-time software architecture description language, named Prelude, which is built upon the synchronous languages and which provides a high level of abstraction for describing the functional and the real-time architecture of a multi-periodic control system. A program is translated into a set of real-time tasks that can be executed on a monoprocessor real-time platform with an on-line priority-based scheduler such as Deadline-Monotonic or Earliest-Deadline-First. The compilation is formally proved correct, meaning that the generated code respects the real-time semantics of the original program (respect of periods, deadlines, release dates and precedences) as well as its functional semantics (respect of variable consumption).

Specifying aspect-oriented architectures in AO-ADL

Context Architecture description languages (ADLs) are a well-accepted approach to software architecture representation. The majority of well-known ADLs are defined by means of components and connectors. Architectural connectors are mainly used to model interactions among components, specifying component communication and coordination separately. However, there are other properties that cut across several components and also affect component interactions (e.g. security). Objective It seems reasonable therefore to model how such crosscutting properties affect component interactions as part of connectors. Method Using an aspect-oriented approach, the AO-ADL architecture description language extends the classical connector semantics with enough expressiveness to model the influences of such crosscutting properties on component interactions (defined as ‘aspectual compositions’ in connectors). Results This paper describes the AO-ADL language putting special emphasis on the extended connectors used to specify aspectual and non-aspectual compositions between concrete components. The contributions of AO-ADL are validated using concern-oriented metrics available in the literature. Conclusion The measured indicators show that using AO-ADL it is possible to specify more reusable and scalable software architectures.

Reconfigurable Multiagent Embedded Control Systems: From Modeling to Implementation

The paper deals with reconfigurable embedded control systems following different component-based technologies and/or Architecture Description Languages used today in industry. We define a Control Component as a software unit to support control tasks of the system, which is assumed to be a network of components with precedence constraints. We define an agent-based architecture to handle automatic reconfigurations under well-defined conditions by creating, deleting, or updating components to bring the whole system into safe and optimal behaviors. To cover all possible reconfiguration forms, we model the agent by nested state machines according to the formalism Net Condition/Event Systems (NCESs), which is an extension of Petri nets. In addition, we apply a model checking to verify functional and extra-functional properties according to the temporal logic Computation Tree Logic” (CTL). The goal is to check the agent reactivity after any evolution of the environment. Several complex networks can implement the system, where each one is executed at a given time when a corresponding reconfiguration scenario is automatically applied by the agent. To check the correctness of each one of them, we apply in several steps a refinement-based approach that automatically specifies feasible Control Components according to NCES. The model checker SESA is automatically applied in each step to verify deadlock properties of new generated components, and it is manually used to verify CTL-based properties according to user requirements. We implement the reconfiguration agent by three modules that allow interpretations of environment evolutions, decisions of useful reconfiguration scenarios, and finally, their applications. Two Industrial Benchmark Production Systems FESTO and EnAS available in our research laboratory are applied to explain the contributions of the paper.

Design and Simulation of High Performance Parallel Architectures Using the ISAC Language

Most of modern embedded systems for multimedia and network applications are based on parallel data stream processing. The data processing can be done using very long instruction word processors (VLIW), or using more than one high performance application-specific instruction set processor (ASIPs), or even by their combination on single chip. Design and testing of these complex systems is time-consuming and iterative process. Architecture description languages (ADLs) are one of the most effective solutions for single processor design. However, support for description of parallel architectures and multi-processor systems is very low or completely missing in nowadays ADLs. This article presents utilization of new extensions for existing architecture description language ISAC. These extensions are used for easy and fast prototyping and testing of parallel based systems and processors.

Internetware Structure Description and Research of the Petri Net Method

Architecture design and specification is more important than algorithm or data structure establishment for a complex system, existing Architecture Description Languages are difficult to support the complete Internetware developing process. Petri nets describe system graphically and mathematically, provide a way to solve the problems in Internetware description and development. In this paper we investigate Internetware architecture description methods, current application of Petri nets in Internetware and the deficiency; present basic principles to describe Internetware architecture using Petri nets, the possible architecture model and architecture evolution mechanisms; discuss subnet based Web services composition description technologies; present the idea of developing Internetware using Petri nets as a whole process unified model. The Petri net method helps to transfer among different stages of Internetware developing easily; the smooth transition from architecture description to code implementation makes sure a good design can deduce a good realization.

Reasoning About Quantitative Architectural Attributes (Invited Paper)

It is widely accepted that software architectures represent non functional attributes of software systems. Yet we know of no Architectural Description Language that provides automated support for reasoning about such attributes. In this paper we discuss our ongoing research in representing and reasoning about non functional properties of software architectures.

Formal approach for the development of intelligent industrial control components

The paper deals with reconfigurable embedded control systems following component-based technologies and/or Architecture Description Languages (ADL). A Control Component is defined as a software unit of the system which is assumed to be a network of components with precedence constraints. We define an agent-based architecture to handle automatic reconfigurations under well-defined conditions by creating, deleting or updating components to dynamically bring the whole system into safe and optimal behaviors. To cover all reconfiguration forms, we model the agent by nested state machines according to the formalism Net Condition/Event Systems (NCES), and apply a model checking to verify properties of NCES according to the temporal logic Computation Tree Logic (CTL). The goal is to check the agent's reactivity after any environment's evolution. Several complex networks can implement the system such that each one is executed at a given time when a corresponding reconfiguration scenario is automatically applied by the agent. To check the correctness of each one of them, we apply in several steps a refinement-based approach that automatically specifies feasible Control Components according to NCES. The model checker SESA is automatically applied in each step to verify deadlock properties of new generated components, and is manually used to verify CTL-based properties according to user requirements. We implement the proposed agent by three modules that allow interpretations of environment's evolutions, decisions of useful reconfiguration scenarios before their real applications.

CSOM/PL — A Virtual Machine Product Line.

CSOM/PL is a software product line (SPL) derived from apply- ing multi-dimensional separation of concerns (MDSOC) techniques to the domain of high-level language virtual machine (VM) implementations. For CSOM/PL, we modularised CSOM, a Smalltalk VM implemented in C, using VMADL (virtual machine architecture description language). Several features of the original CSOM were encapsulated in VMADL modules and composed in various combinations. In an evaluation of our approach, we show that applying MDSOC and SPL principles to a domain as complex as that of VMs is not only feasible but beneficial, as it improves under- standability, maintainability, and configurability of VM implementations without harming performance.

An Architectural Framework for the Development of Secure Mobile Payment System

The Research in software architecture is an emerging field which emphasis on development methodologies, building theory, models of architecture, quality requirements, architectural description languages, and verification of architectural properties. Researchers put on efforts to elicit the state-of-the art technology framework in software architecture models in diversified fields. The high market penetrations of mobile personal devices including mobile phones, PDAs have paved a way for the development of new models in Mobile Commerce. Mobile phones are well suited with mobile commerce to reach the customers anywhere and at any time. Mobile Payments are a natural evolution of e-payment schemes that facilitate mobile commerce. A study reveals that there are wide ranges of mobile payment solutions and models available with the aid of various services. This paper provides a panoramic view of research in Software Architecture framework. A framework is to perform secure mobile payment system with the aim of achieving end-to-end security using asymmetric-key operations to provide convenient payment solutions. The development of secured mobile payment system for macro payments is a hot research topic for the research community and telecommunication industry. This paper proposes an effective framework to carry out the financial transactions from the customer to the merchant. It helps the application designers, developers and researchers to develop and manage the future payment applications and technologies.

Point/Counterpoint

The authors of this issue's "Point/Counterpoint" department debate the merits of UML as a useful tool. Eoin Woods and David Emery, in "Is UML Sufficient for Describing Architectures?", posit that although widely used, UML has some serious limitations as an architecture description language, while Bran Selic, in "UML 2: Designed for Architects," states that contrary to widespread misconceptions, UML 2 includes a very powerful set of language features intended specifically for software architects.

A domain-specific approach to architecturing error handling in pervasive computing

The challenging nature of error handling constantly escalates as a growing number of environments consists of networked devices and software components. In these environments, errors cover a uniquely large spectrum of situations related to each layer ranging from hardware to distributed platforms, to software components. Handling errors becomes a daunting task for programmers, whose outcome is unpredictable. Scaling up error handling requires to raise the level of abstraction beyond the code level and the try-catch construct, approaching error handling at the software architecture level. We propose a novel approach that relies on an Architecture Description Language (ADL), which is extended with error-handling declarations. To further raise the level of abstraction, our approach revolves around a domain-specific architectural pattern commonly used in pervasive computing. Error handling is decomposed into components dedicated to platform-wide, error-recovery strategies. At the application level, descriptions of functional components include declarations dedicated to error handling. We have implemented a compiler for an ADL extended with error-handling declarations. It produces customized programming frameworks that drive and support the programming of error handling. Our approach has been validated with a variety of applications for building automation.