Modeling event-based communication in component-based software architectures for performance predictions

Event-based communication is used in different domains including telecommunications, transportation, and business information systems to build scalable distributed systems. Such systems typically have stringent requirements for performance and scalability as they provide business and mission critical services. While the use of event-based communication enables loosely-coupled interactions between components and leads to improved system scalability, it makes it much harder for developers to estimate the system’s behavior and performance under load due to the decoupling of components and control flow. In this paper, we present our approach enabling the modeling and performance prediction of event-based systems at the architecture level. Applying a model-to-model transformation, our approach integrates platform-specific performance influences of the underlying middleware while enabling the use of different existing analytical and simulation-based prediction techniques. In summary, the contributions of this paper are: (1) the development of a meta-model for event-based communication at the architecture level, (2) a platform aware model-to-model transformation, and (3) a detailed evaluation of the applicability of our approach based on two representative real-world case studies. The results demonstrate the effectiveness, practicability and accuracy of the proposed modeling and prediction approach.     

Efficient deadlock analysis of component-based software architectures

Component-based development (CBD) is a promising approach to master the design complexity of huge software products. In addition, knowledge about the architecture of such component systems can help in establishing important system properties, which in general is computationally hard because of the state space explosion problem. Extending previous work, we here investigate the novel class of disjoint circular wait free component systems and show how we can use the architectural information to establish a condition for the property of deadlock-freedom in polynomial time. Furthermore, we emphasize the importance of this class by showing how to transform an arbitrary system into a disjoint circular wait free one in linear time and in a property preserving way and by providing various computational complexity results. A running example is included. We use the framework of interaction systems, but our results carry over to other CBD models.     

A component-based approach to telecommunication software

This article discusses a domain-specific component-based architecture called distributed feature composition. Based on the well-known pipe-and-filter architecture, DFC has been refined for use in the telecommunication domain. The authors also point to ways this approach might work in other domains, including data networks     

基于组件的软件可靠性计算方法

提出了一种基于组件的软件可靠性的计算方法。该方法首先利用各现成商用组件的说明信息,对组件的输入域进行划分,然后构建马尔可夫链,最终根据各组件之间的关系求出整个系统的软件可靠性。这种方法对基于组件的软件的可靠性进行了定量计算,是一种可行的方法。     

Failure-free coordinators synthesis for component-based architectures

One of the main problems in component assembly is how to establish properties on the assembly code by only assuming a limited knowledge of the single component properties. Our answer to this problem is an architectural approach in which the software architecture imposed on the assembly prevents black-box integration anomalies. The basic idea is to build applications by assuming a “coordinator-based” architectural style. We, then, operate on the coordinating part of the system architecture to obtain an equivalent version of the system which is failure-free. A failure-free system is a deadlock-free one and it does not violate any specified coordination policy. A coordination policy models those interactions of components that are actually needed for the overall purpose of the system. We illustrate our approach by means of an explanatory example and validate it on an industrial case study that concerns the development of systems for safeguarding, fruiting, and supporting the Cultural Heritage.     

构件软件的可靠性估算模型

把基于构件的软件看作是一个Markov过程,为弥补以往忽视连接件作用的情况,针对过程中不同状态类型,构建出基于不同状态的构件和连接件使用频率计算模型。在此基础上,提出了整个基于构件的软件可靠性计算方法,并将其实例化。与传统的方法相比,该方法不仅提供了一种更精确分析软件可靠性的方法,而且拓宽了模型的应用范围。     

A performance evaluation of distributed database architectures

The globally integrated contemporary business environment has prompted new challenges to database architectures in order to enable organizations to improve database applications performance, scalability, reliability and data privacy in adapting to the evolving nature of business. Although a number of distributed database architectures are available for choice, there is a lack of an in‐depth understanding of the performance characteristics of these database architectures in a comparison way. In this paper, we report a performance study of three typical (centralized, partitioned and replicated) database architectures. We used the TPC‐C as the evaluation benchmark to simulate a contemporary business environment, and a commercially available database management system that supports the three architectures. We compared the performance of the partitioned and replicated architectures against the centralized database, which results in some interesting observations and practical experience. The findings and the practice presented in this paper provide useful information and experience for the enterprise architects and database administrators in determining the appropriate database architecture in moving from centralized to distributed environments. Copyright © 2012 John Wiley & Sons, Ltd.     

基于组件的非线性软件开发过程研究

探讨了通过软件企业的组织结构再造和软件开发流程再造,实现基于组件的非线性软件开发过程的研究。     

Reengineering component-based software systems with Archimetrix

Many software development, planning, or analysis tasks require an up-to-date software architecture documentation. However, this documentation is often outdated, unavailable, or at least not available as a formal model which analysis tools could use. Reverse engineering methods try to fill this gap. However, as they process the system’s source code, they are easily misled by design deficiencies (e.g., violations of component encapsulation) which leaked into the code during the system’s evolution. Despite the high impact of design deficiencies on the quality of the resulting software architecture models, none of the surveyed related works is able to cope with them during the reverse engineering process. Therefore, we have developed the Archimetrix approach which semiautomatically recovers the system’s concrete architecture in a formal model while simultaneously detecting and removing design deficiencies. We have validated Archimetrix on a case study system and two implementation variants of the CoCoME benchmark system. Results show that the removal of relevant design deficiencies leads to an architecture model which more closely matches the system’s conceptual architecture.     

Optimization of software components selection for component-based software system development

During the last two decades, there has been a growing interest in component-based software system (CBSS) development both in academia and in industry. In CBSS development, it is common to identify software modules first. Once they are determined, we need to select appropriate software components for each software module. However, very few research works so far have addressed the theoretical aspect especially in the optimization of software component selection for CBSS development. Previous studies of CBSS development seldom considered the influence of software components on coupling and cohesion of software modules. In this paper, the formulation of an optimization model of software components selection for CBSS development is described. The model has two objectives: maximizing the functional performance of the CBSS and maximizing the cohesion and minimizing the coupling of software modules. A genetic algorithm (GA) is introduced to solve the optimization model for determining the optimal selection of software components for CBSS development. An example of developing a financial system for small- and medium-size enterprises is used to illustrate the proposed methodology.     

Multiple-parameter coupling metrics for layered component-based software

Coupling represents the degree of interdependence between two software components. Understanding software dependency is directly related to improving software understandability, maintainability, and reusability. In this paper, we analyze the difference between component coupling and component dependency, introduce a two-parameter component coupling metric and a three-parameter component dependency metric. An important parameter in both these metrics is coupling distance, which represents the relevance of two coupled components. These metrics are applicable to layered component-based software. These metrics can be used to represent the dependencies induced by all types of software coupling. We show how to determine coupling and dependency of all scales of software components using these metrics. These metrics are then applied to Apache HTTP, an open-source web server. The study shows that coupling distance is related to the number of modifications of a component, which is an important indicator of component fault rate, stability and subsequently, component complexity.

Editorial to theme issue on model-driven engineering of component-based software systems

Software and Systems Modeling - This theme issue aims at providing a forum for disseminating latest trends in the use and combination of model-driven engineering (MDE) and component-based software...     

Web server software architectures

Web site scalability depends on several things - workload characteristics, security mechanisms, Web cluster architectures as we discussed previously. Another important item that can affect a site's performance and scalability is the Web server software architecture. We provide a classification of Web server architectures, offer a quantitative analysis of some possible software architectural options, and discuss the importance of software contention on overall response time.     

Stateful component-based performance models

The accuracy of performance-prediction models is crucial for widespread adoption of performance prediction in industry. One of the essential accuracy-influencing aspects of software systems is the dependence of system behaviour on a configuration, context or history related state of the system, typically reflected with a (persistent) system attribute. Even in the domain of component-based software engineering, the presence of state-reflecting attributes (the so-called internal states) is a natural ingredient of the systems, implying the existence of stateful services, stateful components and stateful systems as such. Currently, there is no consensus on the definition or method to include state-related information in component-based prediction models. Besides the task to identify and localise different types of stateful information across component-based software architecture, the issue is to balance the expressiveness and complexity of prediction models via an effective abstraction of state modelling. In this paper, we identify and classify stateful information in component-based software systems, study the performance impact of the individual state categories, and discuss the costs of their modelling in terms of the increased model size. The observations are formulated into a set of heuristics-guiding software engineers in state modelling. Finally, practical effect of state modelling on software performance is evaluated on a real-world case study, the SPECjms2007 Benchmark. The observed deviation of measurements and predictions was significantly decreased by more precise models of stateful dependencies.     

Testing component-based software: a cautionary tale

Components designed for reuse are expected to lower costs and shorten the development life cycle, but this may not prove so simple. The author emphasizes the need to closely examine a problematic aspect of component reuse: the necessity and potential expense of validating components in their new environments     

Towards UML-based formal specifications of component-based real-time software

UML-RT is achieving increasing popularity as a modeling language for real-time applications. Unfortunately UML-RT is not formally well defined and it is not well suited for supporting the specification stage: e.g., it does not provide native constructs to represent time and non-determinism. UML+ is an extension of UML that is formally well defined and suitable for expressing the specifications of real-time systems (e.g., the properties of a UML+ model can be formally verified). However, UML+ does not support design and development. This article addresses the translation of UML+ into UML-RT, thus posing the basis for a development framework where UML+ and UML-RT are used together, in order to remove each other’s limitations. Specifications are written using UML+, they are automatically verified by means of formal methods, and are then converted – through a semi-automatic process – in an equivalent UML-RT model that becomes the starting point for the implementation.