The emergence of clusters of multi-core multiprocessors has created a challenge for software developers who use concurrency to gain performance. The challenge lies in the application's dependence on both the hardware and the deeply integrated communication infrastructure for performance improvements. This integration of the communication and parallelism in the user's application reduces flexibility by adding complexity when switching to different communication and parallel infrastructures. In this paper, we present a retargetable compiler framework for a subset of X10 that abstracts the hardware details, parallelism, and communication away from the application, allowing for portability and easier retargeting of the communication and parallelism. The retargetable compiler framework uses asynchronous computation and communication, as well as the concept of places to abstract away hardware details and to provide scalability. The framework offers performance, functionality, and flexibility because of our separation of tasks into layers and because of source code level serialization. To illustrate the ease of retargeting the communication and the patterns of parallelism, our framework is implemented with two different communication APIs (DUP and MPI-2) and two different patterns of parallelism (thread pooling and thread spawning). Retargeting the communication infrastructure using our framework required fewer code changes than changing the pattern of parallelism. The minimal code change needed to retarget these components offers developers a reasonable way to retarget without recompiling their application or sacrificing performance.
Model-driven performance engineering allows software architects to reason on performance characteristics of a software system in early design phases. In recent years, model-driven analysis techniques have been developed to evaluate performance characteristics of self-adaptive software systems. These techniques aim to reason on the ability of a self-adaptive software system to fulfill performance requirements in transient phases. A transient phase is the interval in which the behavior of the system changes, e.g., due to a burst in user requests. However, the effectiveness and efficiency with which a system is able to adapt depends not only on the time when it triggers adaptation actions but also on the time at which they are completed. Executing an adaptation action can cause additional stress on the adapted system. This can further impede the performance of the system in the transient phase. Model-driven analyses of self-adaptive software do not consider these transient effects. This paper outlines an approach for evaluating transient effects in model-driven analyses of self-adaptive software systems. The evaluation applied our approach to a horizontally scaling media hosting application in three experiments. By considering the delay in booting new Virtual Machines (VMs), we were able to improve the accuracy of predicted response times. The second and third experiment demonstrated that the increased accuracy enables an early detection and resolution of design deficiencies of self-adaptive software systems.
Reliability prediction methods support early decision on software development by offering means for architects to reason and test their own designs. However, most of today's reliability prediction methods model the failure behavior as two states: functioning properly or failed, neglecting other failure modes. In addition, the lack of realistic case-studies and actual failure data make testing and validation difficult tasks. With this in mind, we propose a reliability modeling approach describing the behavior of a software component taking into account error occurrences and their associated impacts in terms of error masking, error propagation, error recovery and failures modes. To validate our approach we present a real case-study based on Xen where we injected faults at different virtualization layers. The experiments show close results between our modeling approach and the realistic values obtained from the experiment.
Enterprise applications are typically implemented as distributed systems composed of several components. Deciding where to deploy which component is a difficult task that today is usually assisted by logical topology recommendations. Choosing inefficient topologies allocates the wrong amount of resources, leads to unnecessary operation costs, or results in poor performance. Testing different topologies to find good solutions takes a lot of time and might delay productive operations. Therefore, this work introduces a software based deployment topology optimization approach for distributed enterprise applications. We use an enhanced performance model generator that extracts models from running applications. The extracted model is used to simulate performance metrics (e.g., resource utilization, response times, throughput) of an enterprise application. Subsequently, we introduce a deployment topology optimizer, which selects an optimized topology for a specified workload. The following two optimization goals are presented in this work: (i) minimum response time for an optimized user experience and (ii) maximize resource utilization for cost-effective topologies. To evaluate the approach we use the SPECjEnterpriseNEXT industry benchmark as distributed enterprise application. The evaluation demonstrates the accuracy of the simulation compared to the actual deployment and the pre-eminence of the selected topology compared to runner-up topologies.
The problem of handling emergency situations (e.g., earthquakes, tornados, hurricanes, political rebellions, etc.) is very challenging since the fixed network infrastructures can become unusable, and it is fundamental to build a peer-to-peer network intended to spread information among people involved in the emergency. The goal of this paper is to propose an approach that enables an adaptive behavior of ungoverned communication networks with the purpose of maximizing the information diffusion and minimizing the energy consumption of the communication devices (e.g., smartphones). We introduce an energy-aware gossip algorithm to adapt the message passing methodology among the involved devices on the basis of their battery level, while guaranteeing the information diffusion within a certain geographical area and minimizing the overall energy consumption. The approach is implemented in a simulation context that allows to quantify the percentage of area coverage within a certain interval of time by adapting the process of message passing on the basis of devices' battery level. Experimental results demonstrate that our approach outperforms classic broadcast algorithms up to 85.58% in terms of energy consumption.
Architecture engineering is essential to achieve dependability of critical embedded systems and affects large parts of the system life cycle. There is consequently little room for faults, which may cause substantial costs and devastating harm. Verification in architecture engineering should therefore be holistically and systematically managed in the development of critical embedded systems, from requirements analysis and design to implementation and maintenance. In this paper, we address this problem by presenting AQAF: an Architecture Quality Assurance Framework for critical embedded systems modeled in the Architecture Analysis and Design Language (AADL). The framework provides a holistic set of verification techniques with a common formalism and semantic domain, architecture flow graphs and timed automata, enabling completely formal and automated verification processes covering virtually the entire life cycle. The effectiveness and efficiency of the framework are validated in a case study comprising a safety-critical train control system.
In a software design process, the quality of the resulting software system is highly driven by the quality of its software architecture (SA). In such a process trade-off decisions must be made between multiple quality attributes (QAs), such as performance or security, that are often competing. Several approaches exist to improve SAs either quantitatively or qualitatively. The first group of approaches requires to quantify each single QA to be considered in the design process, while the latter group of approaches are often fully manual processes. However, time and cost constraints often make it impossible to either quantify all relevant QAs or manually evaluate candidate architectures. Our approach to the problem is to quantify several most important quality requirements, combine them with several not-quantified QAs and use them together in an automated design space exploration process. As our basis, we used the PerOpteryx design space exploration approach, which requires quantified measures for its optimization engine, and extended it in order to combine them with not-quantified QAs. By this, our approach allows optimizing the design space by considering even QAs that can not be quantified due to cost constraints or lack of quantification methodologies. We applied our approach to two case studies to demonstrate its benefits. We showed how performance can be balanced against not-quantified QAs, such as security, using an example derived from an industry case study.
Cloud controllers support the operation and quality management of dynamic cloud architectures by automatically scaling the compute resources to meet performance guarantees and minimize resource costs. Existing cloud controllers often resort to scaling strategies that are codified as a set of architecture adaptation rules. However, for a cloud provider, deployed application architectures are black-boxes, making it difficult at design time to define optimal or pre-emptive adaptation rules. Thus, the burden of taking adaptation decisions often is delegated to the cloud application. We propose the dynamic learning of adaptation rules for deployed application architectures in the cloud. We introduce FQL4KE, a self-learning fuzzy controller that learns and modifies fuzzy rules at runtime. The benefit is that we do not have to rely solely on precise design-time knowledge, which may be difficult to acquire. FQL4KE empowers users to configure cloud controllers by simply adjusting weights representing priorities for architecture quality instead of defining complex rules. FQL4KE has been experimentally validated using the cloud application framework ElasticBench in Azure and OpenStack. The experimental results demonstrate that FQL4KE outperforms both a fuzzy controller without learning and the native Azure auto-scaling.
Failures in software systems during operation are inevitable. They cause system downtime, which needs to be minimized to reduce or avoid unnecessary costs and customer dissatisfaction. Online failure prediction aims at identifying upcoming failures at runtime to enable proactive maintenance actions. Existing online failure prediction approaches focus on predicting failures of either individual components or the system as a whole. They do not take into account software architectural dependencies, which determine the propagation of failures. In this paper, we propose a hierarchical online failure prediction approach, HORA, which employs a combination of both failure predictors and architectural models. We evaluate our approach using a distributed RSS reader application by Netflix and investigate the prediction quality for two representative types of failures, namely memory leak and system overload. The results show that, overall, our approach improves the area under the ROC curve by 10.7% compared to a monolithic approach.
Evolution of work and load is required for investigating elasticity and cost-efficiency of cloud computing applications as well as their underlying architecture. Existing modelling environments have fixed load and work, therefore rendering model-and-analyse approaches infeasible for such applications. This deficiency particularly leads to high risks that applications will violate their service level objectives. Therefore, this article describes how we can model and analyse the evolution of both work and load. We have created a corresponding meta model for usage evolution, and describe how we have integrated our meta model with Palladio, a common model-and-analyse environment. To model evolution we use the Descartes Load Intensity Model (DLIM). DLIM is coupled with the scenario model in the Palladio Component Model (PCM). We illustrate evolution of both work and load within Palladio simulations using a simple image server example.
Context: Performance models allow software architects to conduct what-if analyses, e.g., to assess deployment scenarios regarding performance. While a typical scenario is the redeployment to Infrastructure-as-a-Service (IaaS) environments, there is currently no empirical evidence that architects can apply performance models in such scenarios for accurate performance analyses and how much effort is required. Objectives: Therefore, we explore the applicability of software performance engineering for planning the redeployment of existing software applications to IaaS environments. Methods: We conduct a case study in which we apply performance engineering to redeploy a realistic existing application to IaaS environments. We select an online book shop implementation (CloudStore) as existing application and engineer a corresponding Palladio performance model. Subsequently, we compare analysis results with measurements gathered from operating CloudStore within (I) a classical on-premise setup, (II) OpenStack, and (III) Amazon EC2. Results: Our case study shows that performance models have a relative accuracy error of less than 12% even for IaaS environments (scenarios (II) and (III)). For scenarios (II) and (III), we saved up to 98% model creation effort by reusing the model from scenario (I), we just re-calibrated processing rates of CPUs within our deployment model. Conclusions: Software architects can plan redeployments by reusing performance models of their existing system, thus, with only minor effort. This is particularly possible for virtualized third-party environments like for Amazon EC2.
Increasingly, software applications are being deployed in clouds because cloud computing offers several advantages -- for example, it relieves the application service providers from buying and maintaining data centers thereby reducing the operational costs, it allows dynamic scaling of virtual machines as required on a pay-per-use basis, and, it promotes easy deployment in multiple geographic locations at minimal cost. A key challenge in deploying a multi-tier web application in cloud is to achieve low variability in its response time. In this paper, we analyze the behaviour of a 3-tier cloud-based web application. We propose a hierarchical model to compute the response-time distribution that considers performance degradation of the application due to VM failures. Our model applies order statistics to describe the application's availability behavior and open queueing network to describe its performance behavior. We solve the open queueing network using discrete event simulation. The results show that in a 3-tier system, a configuration with large number of virtual machines (VMs) does not necessarily perform better than a configuration with smaller number of VMs. Moreover, for a given set of performance and availability parameters, the results further show that different system configurations containing the same number of VMs yield different performance depending on the replication level of the VMs in different tiers. We demonstrate that our model can be exploited to support the selection of appropriate number of replicas for different tiers that would meet the service-level agreement specified in terms of response-time percentiles.
Hadoop is an open source implementation of the MapReduce programming model, and provides the runtime infrastructure for map and reduce functions programmed in individual applications. Commercial clouds such as Amazon Elastic MapReduce provides the Hadoop architecture with IaaS support. In this architecture, the map and reduce functions are major determinants of end-to-end application latency, along with the framework components responsible for data access and exchange. In this paper, we aim to explore modeling methods that capture the performance characteristic and the semantics of a Hadoop architecture. We present our early results for modeling the performance of a Hadoop application given the design of map and reduce functions using Layered Queueing Network (LQN). We build two different LQN models to represent the data parallel computing of these functions and calibrate both models using monitored performance data. The output of both models produces converging results that are within ~10% of observed performance. From our modeling experience, we further discuss the issues of modeling Hadoop architecture using LQN in general and describe our future work.
Conducting (big) data analytics in an organization is not just about using a processing framework (e.g. Hadoop/Spark) to learn a model from data currently in a single file system (e.g. HDFS). We frequently need to pipeline real time data from other systems into the processing framework, and continually update the learned model. The processing frameworks need to be easily invokable for different purposes to produce different models. The model and the subsequent model updates need to be integrated with a product that may require a real time prediction using the latest trained model. All these need to be shared among different teams in the organization for different data analytics purposes. In this paper, we propose a real time data-analytics-as-service architecture that uses RESTful web services to wrap and integrate data services, dynamic model training services (supported by big data processing framework), prediction services and the product that uses the models. We discuss the challenges in wrapping big data processing frameworks as services and other architecturally significant factors that affect system reliability, real time performance and prediction accuracy. We evaluate our architecture using a log-driven system operation anomaly detection system where staleness of data used in model training, speed of model update and prediction are critical requirements.
In order to reduce human involvement in repetitive and dangerous tasks, innovative approaches are increasingly sought and explored. One of these approaches is represented by the Mobile Multi-Robot systems (MMRSs). The introduction of this kind of systems opens a collection of new business and societal opportunities, but also raises many new challenges. Such systems are exposed to various spheres of uncertainty, spanning from software and hardware variability of a single robot to the one associated to mission planning and execution in possibly unforeseeable environments. In this proposal, we aim to identify how to preserve safety while enabling adaptability at run-time in MMRSs. The objective is to provide a modelling framework based on a methodology which explicitly takes into account safety and adaptability properties at run-time. In order to reach our goal, we plan to use Model-driven engineering(MDE) methods and techniques. Motivated from positive results from the application of MDE in other domains (e.g. avionics, automotive and telecommunications) we postulate that many methods used in this methodology are also relevant for MMRSs. With our work, we expect to give a contribution towards the assurance of safety and adaptability properties for MMRSs in a dynamic run-time context.
Technical debt has been the subject of numerous studies over the last few years. To date, most of the research has concentrated on management (detection, quantification, and decision making) approaches ?most performed at code and implementation levels through various static analysis tools. However, if practitioners are to adopt model driven techniques, then the management of technical debt also requires that we address this problem during the specification and architectural phases. This position paper discusses several questions that need to be addressed in order to improve the quality of software architecture by exploring the management of technical debt during modeling, and suggests various lines of research that are worthwhile subjects for further investigation.
The Service Oriented Architecture is boosting a fast move from developing applications as stand-alone systems, to developing applications as composition of autonomous and heterogeneous services. Service compositions are required to adapt dynamically to changing workloads, scenarios and objectives, and to achieve a certain Quality of Service (QoS). Guaranteeing such requirements is not a trivial task, since run-time variability makes the process of devising service compositions challenging for software designers. In this paper, we exploit the QoS analysis at run time to support software design, highlighting service compositions where QoS predictions are not reliable enough. To this end, we propose a QoS-based feedback framework that makes use of design-time and run-time knowledge to manage QoS data over time, and support software architect while devising a service composition that best fits QoS requirements. We illustrate the feasibility and effectiveness of the approach on a case study from the e-health domain.
Software architecture reflects important decisions on structure, used technology and resources. Architecture decisions influence to a large extent requirements on software quality. During software evolution change requests have to be implemented in a way that the software maintains its quality, as various potential implementations of a specific change request influence the quality properties differently. Software development processes involve various organisational and technical roles. Thus, for sound decision making it is important to understand the consequences of the decisions on the various software engineering artefacts (e.g. architecture, code, test cases, build, or deployments) when analysing the impact of a change request. However, existing approaches do not use sufficient architecture descriptions or are limited to software development without taking management tasks into account. In this paper, we present the tool-supported approach Karlsruhe Architectural Maintainability Prediction (KAMP) to analyse the change propagation caused by a change request in a software system based on the architecture model. Using context information annotated on the architecture KAMP enables project members to assess the effects of a change request on various technical and organisational artefacts and tasks during software life cycle. We evaluate KAMP in an empirical study, which showed that it improves scalability of analysis for information systems due to automatically generated task lists containing more complete and precise context annotations than manually created ones.
Industrial standards are used to formalize procedures, rules and guidelines for the industry to follow. Following a standard requires continuous adoption of the new standardized features where only their subset is required by individual companies. Therefore the prioritization of the features and the assessment of their impact on the development projects is crucial for the success of the project. In software engineering, industrial standards are used increasingly often to standardize a language for designing architectural components of the system by defining domain-specific meta-models. The purpose is to assure the interoperability between a number of software tools exchanging the architectural models. In this paper, we present a method for identifying optimal sets of new standardized architectural features to be adopted in the development projects. The optimization is done based on the assessment of their benefit for the projects and the estimated cost of re-work in the modeling tools according to the changes in the standardized meta-model. We evaluate the method by applying it on 14 new architectural features of a new release of the AUTOSAR standard which is followed in the development of the automotive software systems.
This paper is part of a larger research project aiming to integrate dependability analysis in the early phases of the software development process, by generating and analyzing Stochastic Reward Net (SRN) models from UML software models. The paper is focused on adding fault tolerance to software designs by using Aspect-Oriented Modeling. More specifically, single-version fault tolerance tactics are modeled as generic reusable aspects annotated with dependability attributes. The paper describes how the generic aspects are instantiated, bound to the context and composed with the original UML software model. Since an SRN analysis model is generated from the UML model, the paper discusses what kind of transformation rules are necessary for translating fault tolerance tactics from UML to SRN, giving as an example the transformation rule for checkpoint synchronization. A case study illustrates the proposed approach.
