Powered by
Conference Publishing Consulting

Sixth International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS 2011), May 23–24, 2011, Waikiki, Honolulu, HI, USA

SEAMS 2011 – Proceedings

Contents - Abstracts - Authors

Preface

Title Page

Foreword
An increasingly important requirement for a software-based system is the ability to self-manage by adapting itself at run time to handle changing user needs, system intrusions or faults, a changing operational environment, and resource variability. Such a system must configure and reconfigure itself, augment its functionality, continually optimize itself, protect itself, and recover itself, while keeping its complexity hidden from the user. The topic of self-adaptive and self-managing systems has been studied in a large number of specific areas, including software architectures, fault-tolerant computing, robotics, control systems, programming languages, and biologically-inspired computing. The objective of this symposium is to bring together researchers and practitioners from many of these diverse areas to engage in stimulating dialogue regarding the fundamental principles, state of the art, and critical challenges of self-adaptive systems. Specifically, the symposium focuses on the software engineering aspects, including the methods, architectures, algorithms, techniques, and tools that can be used to support dynamic adaptive behavior that includes self-adaptive, self-managing, self-healing, self-optimizing, and self-configuring, and autonomic software.

Applications

Application of Software Health Management Techniques
Nagabhushan Mahadevan, Abhishek Dubey, and Gabor Karsai
(Vanderbilt University, USA)
The growing complexity of software used in large-scale, safety critical cyber-physical systems makes it increasingly difficult to expose and hence correct all potential defects. There is a need to augment the existing fault tolerance methodologies with new approaches that address latent software defects exposed at runtime. This paper describes an approach that borrows and adapts traditional 'System Health Management' techniques to improve software dependability through simple formal specification of runtime monitoring, diagnosis, and mitigation strategies. The two-level approach to health management at the component and system level is demonstrated on a simulated case study of an Air Data Inertial Reference Unit (ADIRU). An ADIRU was categorized as the primary failure source for the in-flight upset caused in the Malaysian Air flight 124 over Perth, Australia in 2005.
Article Search
Dynamic Updating of Online Recommender Systems via Feed-Forward Controllers
Valentina Zanardi and Licia Capra
(University College London, UK)
Recommender systems have become an essential software component of many online businesses, supporting customers in finding the items (e.g., books on Amazon, movies on Net- flix, songs on Last.fm) they are interested in. Key to their success is the level of accuracy they achieve: the more pre- cisely they can predict how much a customer will enjoy an item, the higher the profit that the business will make (e.g., in terms of more purchases). In quantifying the accuracy of recommender systems, the evaluation methodology followed by researchers has so far neglected an important aspect: that these businesses grow continuously over time, both in terms of users and items. The data structures used by the rec- ommender system to compute predictions become stale and thus have to be updated regularly. Intuitively, the more often the data structures are being updated, the higher the accuracy achieved, but the higher the computational cost af- forded, because of the extremely large volume of data being handled. System administrators often perform the update at fixed intervals of time (e.g., weekly, fortnightly), in an ef- fort to balance accuracy versus cost. We argue that such an approach benefits neither accuracy nor cost, as businesses do not grow linearly in time, thus risking the fixed update interval to be at times too coarse (with negative impact on accuracy), and at other times too fine grained (with nega- tive impact on cost). We thus advocate for a self-monitoring and self-adaptive approach, whereby the system monitors its own growth over time, estimates the loss in accuracy it would endure if an update were not being performed based on the observed growth, and dynamically decides whether the benefit of performing an update (accuracy) outweighs its computational cost. Using real data from the Bibsonomy website, we demonstrate how this simple technique enables system administrators to transparently balance these two conflicting requirements.
Article Search
Runtime Models for Automatic Reorganization of Multi-Robot Systems
Christopher Zhong and Scott A. DeLoach
(Kansas State University, USA)
This paper presents a reusable framework for developing adaptive multi-robotic systems for heterogeneous robot teams using an organization-based approach. The framework is based on the Organizational Model for Adaptive Computational Systems (OMACS) and the Goal Model for Dynamic Systems (GMoDS). GMoDS is used to capture system-level goals that drive the system. OMACS is an abstract model used to capture the system configuration and allows the team to organize and reorganize without the need for explicit runtime reorganization rules. While OMACS provides an implicit reorganization capability, it also supports policies that can either guide or restrict the resulting organizations thus limiting unexpected or harmful adaptation. We demonstrate our framework by presenting the design and implementation of a multi-robot system for detecting improvised explosive devices. We then highlight the adaptability of the resulting system.
Article Search

Modeling and Languages

Adapt Cases: Extending Use Cases for Adaptive Systems
Markus Luckey, Benjamin Nagel, Christian Gerth, and Gregor Engels
(University of Paderborn, Germany)
Adaptivity is prevalent in today's software. Mobile devices self-adapt to available network connections, washing machines adapt to the amount of laundry, etc. Current approaches for engineering such systems facilitate the specification of adaptivity in the analysis and the technical design. However, the modeling of platform independent models for adaptivity in the logical design phase remains rather neglected causing a gap between the analysis and the technical design phase. To overcome this situation, we propose an approach called Adapt Cases. Adapt Cases allow the explicit modeling of adaptivity with domain-specific means, enabling adaptivity to gather attention early in the software engineering process. Since our approach is based on the concept of use cases it is easy adoptable in new and even running projects that use the UML as a specification language, and additionally, can be easily incorporated into model-based development environments.
Article Search
gocc: A Configuration Compiler for Self-adaptive Systems Using Goal-oriented Requirements Description
Hiroyuki Nakagawa, Akihiko Ohsuga, and Shinichi Honiden
(The University of Electro-Communications, Japan; National Institute of Informatics, Japan)
Self-adaptive systems have recently attracted attention because of their ability to cope with changing environments, including system intrusions or faults. Such software must modify itself to better fit its environment, and one of the approaches by which we expect this capability to be achieved is the introduction of multiple control loops to assess the situation and to determine whether a change in behaviors or configurations is necessary and how to implement the change. Development of such systems with multiple control loops complicates the task of identifying components, and could be greatly aided by appropriate tool support. In this paper, we propose an architectural compiler for self-adaptive systems, which generates architectural configurations from the goal-oriented requirements descriptions. We also present a framework for generating such configurations with this compiler and a pattern in the requirements description. We evaluate the framework experimentally and show that it helps to generate suitable configurations that have high performance, and that the compiler scales well to large input models.
Article Search
An Evaluation of the Adaptation Capabilities in Programming Languages
Carlo Ghezzi, Matteo Pradella, and Guido Salvaneschi
(Politecnico di Milano, Italy)
In recent years the need for software applications to adapt to the environment in which they are situated has become common. Beside architectural approaches, language-level support for the development of adaptable and context-aware software have been investigated. Many existing solutions adopt ad hoc programming paradigms such as aspect oriented programming (AOP) or context oriented programming (COP). In this paper we investigate the use of the abstractions offered by traditional object-oriented and functional paradigms for the development of context-adaptable systems. We carry out our analysis along a set of conceptual directions which consider the requirement of functional adaptation beside non functional requirements such as safety and effective modularization. Our analysis were validated though the development of several prototypes of an adaptable cache server which is chosen as the running example through the paper. We provide an estimation of the performance advantages of the techniques based traditional programming languages compared with context-oriented programming.
Article Search

Monitoring and Evaluation

Awareness Requirements for Adaptive Systems
Vítor E. Silva Souza, Alexei Lapouchnian, William N. Robinson, and John Mylopoulos
(University of Trento, Italy; University of Toronto, Canada; Georgia State University, USA)
Recently, there has been a growing interest in self-adaptive systems. Roadmap papers in this area point to feedback loops as a promising way of operationalizing adaptivity in such systems. In this paper, we define a new type of requirement — called Awareness Requirement — that can refer to other requirements and their success/failures. We propose a way to elicit and formalize such requirements and offer a requirements monitoring framework to support them.
Article Search
Characterizing Problems for Realizing Policies in Self-Adaptive and Self-Managing Systems
Sowmya Balasubramanian, Ron Desmarais, Hausi A. Müller, Ulrike Stege, and S. Venkatesh
(University of Victoria, Canada)

Self-adaptive and self-managing systems optimize their own behaviour according to high-level objectives and constraints. One way for administrators to specify goals for such optimization problems effectively is using policies. Over the past decade, researchers produced various approaches, models and techniques for policy specification in different areas including distributed systems, communications networks, web services, autonomic computing, and cloud computing. Research challenges range from characterizing policies for ease of specification in particular application domains to categorizing policies for achieving solution qualities for particular algorithmic techniques.

The contributions of this paper are threefold. Firstly, we give a mathematical formulation for each of the three policy types, action, goal and utility function policies, introduced in the policy framework by Kephart and Walsh. In particular, we introduce a first precise characterization of goal policies for optimization problems. Secondly, this paper introduces a mathematical framework that adds structure to the underlying optimization problem for different types of policies. Structure is added either to the objective function or the constraints of the optimization problem. These mathematical structures, imposed on the underlying problem, progressively increase the quality of the solutions obtained when using the greedy optimization technique. Thirdly, we show the applicability of our framework by analyzing several optimization problems encountered in self-adaptive and self-managing systems, such as resource allocation, quality of service management, and SLA profit optimization to provide quality guarantees for their solutions.

Our approach is based on the algorithmic frameworks by Edmonds, Fisher et al., and Mestre, and the policy framework of Kephart and Walsh. Our characterization and approach will help designers of self-adaptive and self-managing systems formulate optimization problems, decide on algorithmic strategies based on policy requirements, and reason about solution qualities.


Article Search
A Framework for Evaluating Quality-Driven Self-Adaptive Software Systems
Norha M. Villegas, Hausi A. Müller, Gabriel Tamura, Laurence Duchien, and Rubby Casallas
(University of Victoria, Canada; INRIA Lille, France; University of Los Andes, Colombia)
Over the past decade the dynamic capabilities of self-adaptive software-intensive systems have proliferated and improved significantly. To advance the field of self-adaptive and self-managing systems further and to leverage the benefits of self-adaptation, we need to develop methods and tools to assess and possibly certify adaptation properties of self-adaptive systems, not only at design time but also, and especially, at run-time. In this paper we propose a framework for evaluating quality-driven self-adaptive software systems. Our framework is based on a survey of self-adaptive system papers and a set of adaptation properties derived from control theory properties. We also establish a mapping between these properties and software quality attributes. Thus, corresponding software quality metrics can then be used to assess adaptation properties.
Article Search
Model-based Self-Adaptive Resource Allocation in Virtualized Environments
Nikolaus Huber, Fabian Brosig, and Samuel Kounev
(Karlsruhe Institute of Technology, Germany)
The adoption of virtualization and Cloud Computing technologies promises a number of benefits such as increased flexibility, better energy efficiency and lower operating costs for IT systems. However, highly variable workloads make it challenging to provide quality-of-service guarantees while at the same time ensuring efficient resource utilization. To avoid violations of service-level agreements (SLAs) or inefficient resource usage, resource allocations have to be adapted continuously during operation to reflect changes in application workloads. In this paper, we present a novel approach to self-adaptive resource allocation in virtualized environments based on online architecture-level performance models. We present a detailed case study of a representative enterprise application, the new SPECjEnterprise2010 benchmark, deployed in a virtualized cluster environment. The case study serves as a proof-of-concept demonstrating the effectiveness and practical applicability of our approach.
Article Search

Run-­time Support

FlashMob: Distributed Adaptive Self-Assembly
Daniel Sykes, Jeff Magee, and Jeff Kramer
(Imperial College London, UK)
Autonomous systems need to support dynamic software adaptation in order to handle the complexity and unpredictability of the execution environment, and the changing needs of the end user. Although a number of approaches have been proposed, few address a key issue: that of distribution. In this paper we seek to overcome the limitations of centralised approaches. We build on our previous work on adaptive self-assembly within the three-layer model for autonomous systems to provide a decentralised technique for self-assembly. To achieve this in a fault-tolerant and scalable manner, we use a gossip protocol as a basis. While no central or leader node is aware of the full space of solutions, gossip ensures that agreement on a particular solution - in this case a component configuration - is reached in a logarithmic number of steps with respect to the size of the network.
Article Search
Supporting Service Composition and Real-Time Execution through Characterization of QoS Properties
Marisol García-Valls, Pablo Basanta-Val, and Iria Estévez-Ayres
(Universidad Carlos III de Madrid, Spain)

Article Search
On the Performance of UML State Machine Interpretation at Runtime
Edzard Hoefig, Peter H. Deussen, and Ina Schieferdecker
(Fraunhofer FOKUS, Germany; TU Berlin, Germany)
Modelling system behaviour by means of UML Behavioral State Machines is an established practice in software engineering. Usually, code generation is employed to create a system's software components. Although this approach yields software with a good runtime performance, the resulting system behaviour is static. Changes to the behaviour model necessarily provoke an iteration in the code generation workflow and a re-deployment of the generated artefacts. In the area of autonomic systems engineering, it is assumed that systems are able to adapt their runtime behaviour in response to a changing context. Thus, the constraints imposed by a code generation approach make runtime adaptation difficult, if not impossible. This article investigates a solution to this problem by employing interpretation techniques for the runtime execution of UML State Machines, enabling the adaptability of a system's runtime behaviour on the level of single model elements. This is done by devising concepts for behaviour model interpretation, which are then used in a proof-of-concept implementation to demonstrate the feasibility of the approach. For a quantitative evaluation we provide a performance comparison between the proof-of-concept implementation and generated code for a number of benchmark models. We find that UML State Machine interpretation has a performance overhead when compared with static code generation, but found it to be adequate for the majority of situations, except when dealing with high-throughput or delay-sensitive data.
Article Search
GRAF: Graph-based Runtime Adaptation Framework
Mahdi Derakhshanmanesh, Mehdi Amoui, Greg O'Grady, Jürgen Ebert, and Ladan Tahvildari
(University of Koblenz-Landau, Germany; University of Waterloo, Canada)
One approach for achieving runtime adaptability in software is to use application frameworks that are tailored for the development of self-adaptive systems. In this paper, we present the Graph-based Runtime Adaptation Framework (GRAF), which enables adaptivity by creating, managing, and interpreting graph-based models of software at runtime. Having a generic graph representation in our approach allows for flexible adaptation via query and transformation operations. The framework is especially suited for the migration of legacy applications towards adaptive software and attempts to reduce necessary changes to the original software. As a proof of concept, we conduct a comprehensive case study of migrating the legacy game Jake2 to achieve runtime adaptivity using GRAF.
Article Search

Assurance

Pairwise Testing of Dynamic Composite Services
Ajay Kattepur, Sagar Sen, Benoit Baudry, Albert Benveniste, and Claude Jard
(IRISA, France; INRIA Rennes, France; INRIA Sophia Antipolis, France; ENS Cachan, France)
Online services encapsulate enterprises, people, software systems and often operate in poorly understood environments. Using such services in tandem to predictably orchestrate a complex task is one of the principal challenges of service-oriented computing. A composite service orchestration soliciting multiple atomic services is plagued by a number of sources of variation. For instance, availability of an atomic service and its response time are two important sources of variation. Moreover, the number of possible variations in a composite service increases exponentially with increase in the number of atomic services. Testing such a composite service presents a crucial challenge as its often very expensive to exhaustively examine the variation space. Can we effectively test the dynamic behavior of a composite service using only a subset of these variations? This is the question that intrigues us. In this paper, we first model composite service variability as a feature diagram (FD) that captures all valid configurations of its orchestration. Second, we apply pairwise testing to sample the set of all possible configurations to obtain a concise subset. Finally, we test the composite service for selected pairwise configurations for a variety of QoS metrics such as response time, data quality, and availability. Using two case studies, Car crash crisis management and eHealth management, we demonstrate that pairwise generation effectively samples the full range of QoS variations in a dynamic orchestration. The pairwise sampling technique eliminates over 99 percent redundancy in configurations, while still calling all atomic services at least once. We rigorously evaluate pairwise testing for the criteria such as: a) ability to sample the extreme QoS metrics of the service b) stable behavior of the extracted configurations c) compact set of configurations that can help evaluate QoS tradeoffs and d) comparison with random sampling.
Article Search
Dynamic Plans for Integration Testing of Self-adaptive Software Systems
Carlos Eduardo da Silva and Rogério de Lemos
(University of Kent, UK)
Self-adaptive software systems are able to modify their own structure and/or behaviour at run-time in order to cope with changes. During software self-adaptation, new components may be incorporated to the software system. One crucial aspect when incorporating new components is to test them for guaranteeing that they can interoperate as specified. However, this aspect has been often neglected when considering architectural reconfiguration. To deal with this problem, this paper presents an approach for the dynamic generation of plans for conducting the integration testing of self-adaptive software systems. In order to evaluate our approach, we have developed a prototype application that has been used to conduct some experiments, and to demonstrate the feasibility of our approach.
Article Search
A CSP-based Framework for the Specification, Verification, and Implementation of Adaptive Systems
Björn Bartels and Moritz Kleine
(TU Berlin, Germany)
The process algebra CSP is tailored for the specification and verification of reactive systems. Such systems react upon external stimuli by adjusting their internal behavior, e.g., to recover from errors. Adaptive systems can be regarded as a subclass of reactive systems in the sense that such systems react by adapting to changes propagated by some stimulus. In this paper, we use CSP for the specification, verification and implementation of adaptive systems. This enables us to use standard CSP tools such as FDR, ProB or the CSP-Prover for the verification of such systems. Furthermore, we present an approach for the implementation of systems specified in CSP.
Article Search
A Model-Driven Approach to Develop Adaptive Firmwares
Franck Fleurey, Brice Morin, and Arnor Solberg
(SINTEF, Norway)
In a near future it is expected that most things we rely on in our everyday life will contain sensors and electronic based information, have computing power, run embedded software and connect to networks. A multitude of heterogeneous things will operate in a highly dynamic environment and will collaborate with other connected systems and things to provide users with adaptable services. Constructing and controlling such adaptive things is complex. A main challenge is to cope with the dynamicity which requires the things to autonomously adapt to various execution contexts. In this paper we present an approach to develop adaptive firmwares for devices which do not have the resources to rely on advanced operating systems, middlewares or frameworks to support runtime adaptation. The paper is illustrated with the example of an adaptive temperature sensor network running on a microcontroller platform.
Article Search

Position Papers

Elastic Executions from Inelastic Programs
Iulian Neamtiu
(UC Riverside, USA)
In this paper we present an approach and tool named ELASTIN for transforming inelastic programs---programs written with a specific platform or a fixed set of Cloud resources in mind---into elastic applications that run on elastic platforms by adapting, at runtime, to changes in the available resources. With ELASTIN, programmers can develop their applications with various specific configurations in mind, and let ELASTIN's compiler and runtime system take care of combining these configurations into a single elastic application that can safely switch between configurations on-the-fly, at runtime. We used ELASTIN to elastify two popular applications, the SQLite database engine and the Kiss FFT library, and found programmer burden to be very low. Benchmarks indicate that ELASTIN is effective in practice, and reconfigurations are in the sub-millisecond range. We envision this approach being useful in any domain where quick runtime adaptation is necessary due to changes in underlying resources. The approach can also be a stepping stone towards migrating legacy applications to the Cloud.
Article Search
A Model-Driven Framework for Runtime Adaptation of Web Service Compositions
Georg Grossmann, Michael Schrefl, and Markus Stumptner
(University of South Australia, Australia)
Many different approaches have been proposed towards the goal of flexible distributed heterogeneous interoperation of software systems using service composition techniques. Recent approaches are described in terms of higher level models rather than be coded at low level. Current practice, however, sees the service process specifications, written in BPEL or other languages, again as being largely hard-coded rather than exploiting the potential flexibility offered. We propose an approach that is influenced by related fields of model-driven development, conceptual modeling of business processes and workflows, semantic process descriptions and service matching through constraint satisfaction. They can be utilized in a complementary way to support dynamic, instance-based selection and composition of Web services, during runtime and extends this to provide self-modifying adaptation when circumstances change.
Article Search
Benchmarking the Resilience of Self-Adaptive Software Systems: Perspectives and Challenges
Raquel Almeida and Marco Vieira
(University of Coimbra, Portugal)
Self-adaptive systems are widely recognized as the future of com-puter systems. Due to their dynamic and evolving nature, the cha-racterization of self-adaptation and resilience attributes is of utmost importance, but also presents itself as a huge challenge. In fact, currently there is no practical way to characterize self-adaptation capabilities, especially when comparing alternative systems concerning resilience. In this position paper we discuss the problem of resilience benchmarking of self-adaptive software systems. We identify a set of key challenges and propose a roadmap to tackle those challenges. At the same time, we present some perspectives on the development of such a benchmark, taking Autonomic Database Management Systems (ADBMS) as an illustrative case.
Article Search
Approaching Runtime Trust Assurance in Open Adaptive Systems
Daniel Schneider, Martin Becker, and Mario Trapp
(Fraunhofer IESE, Germany)
In recent years it has become more and more evident that the ability of systems to adapt themselves is an increasingly important requirement. This is not least driven by emerging computing trends like Ubiquitous Computing, Ambient Intelligence, and Cyber Physical Systems, where systems have to react on changing user needs, service/device availability and resource situations. Despite being open and adaptive it is a common requirement for such systems to be trustworthy, whereas traditional assurance techniques for related system properties like safety, reliability and security are not sufficient in this context. We recently developed the Plug&Safe approach for composition time safety assurance in systems of systems. In this position paper we provide an overview on Plug&Safe, elaborate the different facets of trust, and discuss how our approach can be augmented to enable trust assurance in open adaptive systems.
Article Search
On Interacting Control Loops in Self-Adaptive Systems
Pieter Vromant, Danny Weyns, Sam Malek, and Jesper Andersson
(Katholieke Universiteit Leuven, Belgium; George Mason University, USA; Linnaeus University, Sweden)
Control loops in self-adaptive systems are typically conceived as a sequence of four computations: Monitor-Analyze-Plan-Execute (MAPE). During the development of a traffic monitoring system with support for self-healing, we have noticed that simple MAPE loops are not sufficient to deal with the more complex failure scenarios. To manage the adaptations in these scenarios, we extend MAPE loops with support for two types of coordination. First, we introduce support for intra-loop coordination enabling MAPE computations within one loop to coordinate with one another. Intra-loop coordination allows the execution of multiple sub-loops within one control loop. Second, we introduce support for inter-loop coordination enabling MAPE computations across multiple loops to coordinate with one another. Inter-loop coordination allows the MAPE computations of different loops to coordinate the various phases of adaptations. We show how we used the extensions to support self-healing in the traffic monitoring system. We discuss an implementation framework that supports coordination of MAPE loops, and from our experiences offer recommendations for future research in this area.
Article Search

Frameworks

A Self-Adaptive Deployment Framework for Service-Oriented Systems
Sander van der Burg and Eelco Dolstra
(Delft University of Technology, Netherlands)
Deploying components of a service-oriented system in a network of machines is often a complex and labourious process. Usually the environment in which such systems are deployed is dynamic: any machine in the network may crash, network links may temporarily fail, and so on. Such events may render the system partially or completely unusable. If an event occurs, it is difficult and expensive to redeploy the system to the take the new circumstances into account. In this paper we present a self-adaptive deployment framework built on top of Disnix, a model-driven distributed deployment tool for service-oriented systems. This framework dynamically discovers machines in the network and generates a mapping of components to machines based on non-functional properties. Disnix is then invoked to automatically, reliably and efficiently redeploy the system.
Article Search
A Multi-model Framework to Implement Self-managing Control Systems for QoS Management
Tharindu Patikirikorala, Alan Colman, Jun Han, and Liuping Wang
(Swinburne University of Technology, Australia; RMIT University, Australia)
Many control theory based approaches have been proposed to provide QoS assurance in increasingly complex software systems. These approaches generally use single model based, fixed or adaptive control techniques for QoS management of such systems. With varying system dynamics and unpredictable environmental changes, however, it is difficult to design a single model or controller to achieve the desired QoS performance across all the operating regions of these systems. In this paper, we propose a multi-model framework to capture the multi-model nature of software systems and implement self-managing control systems for them. A reference-model and extendable class library are introduced to implement such self-managing control systems. The proposed approach is also validated and compared to fixed and adaptive control schemes through a range of experiments.
Article Search
Inflation and Deflation of Self-Adaptive Applications
Ryan W. Moore and Bruce R. Childers
(University of Pittsburgh, USA)
Autonomic multicore systems dynamically adapt themselves in response to run-time conditions and information for a variety of purposes, such as fault tolerance, power conservation, and performance balancing. Multiple application processes must coordinate their efforts and share resources to achieve system goals. In this paper, we present our inflate/deflate programming model for building autonomic processes and systems. The inflate/deflate programming model provides application-specific knowledge and reactions to a central resource coordinator. The central resource coordinator distributes and revokes resources at runtime to achieve a system goal. We discuss the overall design and challenges involved in our model. We test our design for adaptable programs by modifying programs from the PARSEC benchmark suite. The programs are tested in two sample situations to explore the difficulties of modification and the rewards gained. We find that the first modified program (blackscholes) fairly shares CPU time with other system workloads in an energy conservation scenario (up to 50% more efficient than an unmodified blackscholes). The second modified program (dedup) dynamically takes advantage of core resources as they become available (17% faster performance). If no new cores become available, it is able to more efficiently use existing resources (9% faster performance).
Article Search

proc time: 1.66