Autonomic Computing

Organic Computing systems are systems which have the capability to autonomously (re-)organize and adapt themselves. The benefit of such systems with self-x properties is that they are more dependable, as they can compensate for some failures. They are easier to maintain, because they can automatically configure themselves and are more convenient to use because of automatic adaptation to new situations. While Organic Computing systems have a lot of desired properties, there still exists only little knowledge on how they can be designed and built. In this paper an approach for specification and construction of a class of Organic Computing systems is presented, called the Restore Invariant Approach (RIA). The core idea is that the behaviour of an Organic Computing system can be split into productive phases and self-x phases. This allows for a generic description of how "organic" aspects can be specified and implemented. The approach will be illustrated by applying it to a design methodology for Organic Computing systems and further refining it to an explicit case study in the domain of production automation.

Code as an interaction mechanism for self-assembly of autonomous decentralised software components. Each autonomous software entity incorporates more information than its operational behaviour, and publishes more data than its signature. The idea is to provide separately, for each entity, a functional part implementing its behaviour -the traditional program code; and an abstract description of the entity's functional behaviour and necessary parameters -a semantic behavioural description under the form of a formal specification. Interactions are exclusively based on the specifications and occur among entities with corresponding specifications. In the case of autonomic computing systems, in addition to functional aspects, the specification may carry a semantic description of non-functional information related to self-management. This paper presents the principles of the Specification-Carrying Code paradigm, the associated Service-Oriented Architecture, and it explains how self-managed systems can benefit from this paradigm.

This paper proposes the notion of Specification-Carrying Code as an interaction mechanism for self-assembly of autonomous decentralised software components. Each autonomous software entity incorporates more information than its operational behaviour, and publishes more data than its signature. The idea is to provide separately, for each entity, a functional part implementing its behaviour -the traditional program code; and an abstract description of the entity's functional behaviour and necessary parameters -a semantic behavioural description under the form of a formal specification. Interactions are exclusively based on the specifications and occur among entities with corresponding specifications. In the case of autonomic computing systems, in addition to functional aspects, the specification may carry a semantic description of non-functional information related to self-management. This paper presents the principles of the Specification-Carrying Code paradigm, the associated Service-Oriented Architecture, and it explains how self-managed systems can benefit from this paradigm. Key characteristics of autonomic computing systems are their expected self-organised and decentralised nature. They consist of autonomous software entities which do not necessarily know each other in advance, but act together without any direct central control towards high-level goals defined by some human administrator. These software entities need advanced means of communication for: understanding each other, gathering and sharing knowledge, information and experience among each other, and ensuring self-managing functionalities. Therefore, such a technology needs an infrastructure supporting, in an intertwined way: mutual understanding, knowledge sharing and support for self-managing features. Current practices usually rely on pre-established common meanings: communication through shared APIs, usually already shared at design time and which are uniquely syntactic expressions of signatures; or communication through shared ontologies allowing run-time adequacy but requiring sharing of keywords. We foresee that future programming practice, especially in the case of autonomic computing systems, will consist in programming components and "pushing" them into an execution environment which will support their interactions. Therefore, future components will be developed so as to share a minimal design time common understanding. The idea advocated in this paper is that interactions should be based on a minimal common basis, merely concepts. Pragmatically, for artificial entities to understand each other, those concepts have to be expressed in some language. Therefore, the minimal common basis consists in a common specification language used for expressing the concepts. Concepts can then be expressed with different words, and with different properties, but equivalent concepts should share equivalent properties. Thus, there is

Autonomic computing is a very ambitious domain dealing with issues such as system self-management, proactive services and adaptation to unpredicted situations. The development of ubiquitous computing have shown also the importance of adapting the services to their context. In general, a service cannot adapt autonomously to its context beyond the limits fixed a priori by its developer. In order to overcome this limitation, we propose a dynamically updatable service-context model (knowledge representation) that enables an adaptation platform to diagnose the service adequacy to context and automatically search for solutions in order to correct the inadequacy.

Autonomic computing was intended to tackle the growing complexity of Information Technology infrastructure by making it self-managing and self-adaptive. The core idea is to endow the system with enough intelligence to monitor continuously all aspects of the changing environments and resources, and to control management decisions according to high-level policies. For several years, great efforts have been devoted to the study of system performance, security, and fault management issues, but without much attention paid to self-adaptive social-collaborative system development. This may be because it is difficult to create such autonomic systems, which must sense and adapt to ongoing social context changes and support cyber-physical collaborations with minimal human involvement. These collaborations will have interactions between human and non-human entities that need to be self-managing with adaptive goals. This paper tackles the problem by introducing a new Generic Autonomic Social-Co...

The integration of third-party web services can solve complex business problems and can reduce risks, costs and time-to-market. However, the task of the integrators is challenged by services that are maintained by different organisations, and that may evolve dynamically and autonomously. The impossibility of statically determining which service implementation will be bound at runtime may lead to unexpected failures. This paper presents a novel approach for designing self-adaptive service-oriented applications, which autonomously react to changes in the implementation of the services, automatically detect possible integration mismatches and dynamically execute suitable adaptation strategies. The solution proposed in this paper is based on a taxonomy of integration faults that helps developers anticipate potential mismatches between discovered web services and applications, and design test cases and adaptors for each mismatch. A simple tool facilitates the deployment of a runtime infrastructure that embeds the test cases and the adaptors, automatically runs the test cases against newly discovered web services, uses the test results to diagnose service mismatches and executes the adaptors to overcome the revealed problems without user intervention.

Cada vez mais áreas do conhecimento podem tirar proveito de experimentos computacionais para formular e comprovar teorias. Assim, a reprodutibilidade destes experimentos passa a ser um requisito central do processo científico, uma vez que permite validar ou refutar as afirmações feitas em uma publicação. Neste contexto, no presente artigo discute-se a questão da reprodutibilidade de experimentos e propõe-se uma abordagem baseada em contêineres Docker e na ferramenta Spack, ambos projetos de código aberto, para garantir a replicação de ambientes de execução de experimentos.

The conclusion of this work is undoubtedly an important milestone in my life. It is the result of a path, marked by many moments and people who over the years have been with me and supported me to go on it. I would like to start by thanking my advisor, Professor Luís Silva, without whom I would not be concluding this work. He is responsible for the proposed theme and for opening my mind to this very interesting area of research. It is certainly a privilege to work with someone who never sees the work as done and finds always room for improvement. I also wish to thank Professor Paulo Marques for their support and pragmatism. There was a conversation between me and Professor Paulo Marques that I will never forget. It was this conversation that led me to reflect and define a work strategy that was essential to combine my professional activity with the PhD work. I am also truly grateful to Carlos Cunha, Carlos Vaz and Hugo Fonseca for their contribution to this dissertation. Carlos Cunha and Carlos Vaz were, during this time, a good traveling companions. Hugo Fonseca has performed some of the preparatory work essential to the implementation of the experimental studies conducted in this work. I am grateful to the School of Technology and Management of Felgueiras and to the Porto Polytechnic Institute for the conditions that allowed me to focus on research. Likewise, I would like to thank the Engineering Informatics Department, CISUC -Software and Systems Engineering Group and to CIICESI -Center for Research and Innovation in Business Sciences and Information Systems, by the financial and material support granted. Finally, I want to thank to my lovely wife Maria João, to my lovely daughter Sofia and to my lovely son João Pedro for making me happy. I am also deeply thankful to my parents for their amazing support and care. I also want to thank my friends for the support that each, in his own way, gave me.

We propose a reinforcement learning-based autoscaling algorithm integrated with Karpenter on AWS EKS. Unlike threshold-based scaling, our method anticipates workload surges by analyzing historical patterns using predictive analytics, thereby reducing cloud spend and improving service availability. Simulations and real deployment benchmarks from Rialtic Inc. validate the cost efficiency and reliability of this method. The proposed system achieves 34% reduction in cloud infrastructure costs while maintaining 99.7% service availability and reducing cold start latencies by 67%. Through Q-learning optimization and temporal pattern recognition, the system demonstrates superior performance compared to traditional Horizontal Pod Autoscaler (HPA) and Vertical Pod Autoscaler (VPA) mechanisms.

In this paper we describe how a set of autonomous computational agents can cooperate in providing coherent management of information in environments where there are many diverse information resources. The agents use models of themselves and of the resources that are local to them. Resource models may be the schemas of databases, frame systems of knowledge bases, or process models of business operations. Models enable the agents and resources to use the appropriate semantics when they interoperate. This is accomplished by specifying the semantics in terms of a common ontology. We discuss the contents of the models, where they come from, and how the agents acquire them. We then describe a set of agents for telecommunication service provisioning and show how the agents use such models to cooperate. Their interactions produce an implementation of relaxed transaction processing.

Autonomic computing is the solution proposed to cope with the complexity of today's computing environments. Self-management, an important element of autonomic computing, is also characteristic of single and multiagent systems, as well as systems based on service-oriented architectures. Combining these technologies can be profitable for all -in particular, for the development of autonomic computing systems.

The administrator of current IT environments is facing a continuous increase in the complexity that s/he needs to handle. S/he can be compared to a power jet pilot sitting in front of a console with a plenty of gouges, leds, counters, each of them measuring or showing a particular part of the overall aircraft status. The pilot looks to all these indications, correlate each other these data sources, provide them a context (the air craft is landing, is taking off, and so forth) and, on the light of his knowledge and experience, he can ...

In addition, I would like to thank Professor Ali Akoglu, Professor Janet Wang, Professor Ivan Djordjevic, and Professor Ferenc Szidarovszky for serving on my written and oral committees and offering valuable suggestions to improve this dissertation. My fellow lab mates in Professor Hariri's group, I am indebted to my friend, instructor, critique, and mentor Professor Youssif Al-Nashif, for all what he did for me during the course of my Ph.D. studies. Last but not least, I am indebted to my parents, brothers and sisters, my wife, and my daughter "Ayah" for always being there for me. My achievements would not have been possible without their emotional support and encouragement.

We present ADONIS, which stands for Aggregator/Disaggregator for Optical Network equIpmentS, a novel open device agent able to construct logical network devices from (dis)aggregation of physical components in order to expose meaningful network devices to the SDN controller. We experimentally assess it by means of a control closed-loop involving ADONIS, a Software Defined Network controller, a Monitoring and Data Analytics system, and a novel reconfiguration tool, SMART-A.

This article examines database performance monitoring and analysis tools, including their classification, data collection methods, and analysis techniques. It analyzes built-in solutions provided by DBMS developers as well as third-party platforms that offer greater versatility and advanced functionalities. The importance of such tools is emphasized in the context of system stability, efficiency of resources, and overall performance. The future technology trends of AI integration, automation, and multi-cloud support are also addressed in the paper. Special attention is given to the integration monitoring of other IT systems and process automation so that the requirements of modern business scenarios could be met.

Humans are lazy. They want to get as much support and assistance in their daily life as possible. To provide sophisticated digital butler functionality a system has to monitor the humans and their environment to understand their desires. It has to control all devices to translate the deduced wills into actions. To provide an integrated intelligent environment to the residents it is necessary to overcome the borders of different manufacturers, devices and access technologies. A management and control middleware is needed that shields users as well as high level management services from the technical details of the network of devices by providing a standardized, resilient and secure communication channel. We present a knowledge-based middleware as base for that purpose in this paper. The novel approach is the transparent connection of highly heterogeneous home devices by requiring only very limited functionality per device. Our design allows the desired high autonomicity in a secure and efficient way.

As the distributed energy resource (DER) penetrance increasing, future power system will be more largescale with much complexity and uncertainty. Taking an active approach, active distribution network (ADN) can deal with future complex and uncertain challenges to some extent. However, too much re-lying on information exchange of each layer, ADN will lack global adaptability and stability. To make up for the deficiency, this paper proposes a new smart grid control and operation concept, namely autonomic power system (APS). Based on goal-directed mechanism, APS obtains global self-adaptive management. Meanwhile, under the concept of distributed coordination and autonomic control, autonomic units (AUs) in APS coordinate each other and make their own autonomic operation. APS takes not only an optimally and co-ordinately active control of power system, but also brings more intelligence with characteristics of self-configuration, self-optimization, self-protection and self-healing, i.e. self-management and overall self-adaption. Thus, APS completes real-time dynamic goals and makes the operation of future power system more intelligent, effective, safe and reliable.

The use of Complex Event Processing (CEP) and Stream Processing (SP) systems to process high-volume, high-velocity Big Data has renewed interest in procedures for managing these systems. In particular, self-management and adaptation of runtime platforms have been common research themes, as most of these systems run under dynamic conditions. Nevertheless, the research landscape in this area is still young and fragmented. Most research is performed in the context of specific systems, and it is difficult to generalize the results obtained to other contexts. To enable generic and reusable CEP/SP system management procedures and self-management policies, this research introduces the Attributed Graph Rewriting for Complex Event Processing Management ( AGeCEP ) formalism. AGeCEP represents queries in a language- and technology-agnostic fashion using attributed graphs. Query reconfiguration capabilities are expressed through standardized attributes, which are defined based on a novel classi...

The growing complexity of applications, huge data volume and the data structures to process massive data are becoming challenging issue. Query optimizer is a major component of a Database Management System (DBMS) that executes queries through different strategies and techniques efficiently. These techniques select the best optimal execution plan from the candidate plans according to the available resources and environment. Traditionally, skilled database administrators are required to tune DBMS for efficient query processing. Recently it has been realized to develop DBMSs having autonomic capabilities. Autonomic DBMS (ADBMS) are now being developed to reduce this dependency on an expensive skilled human resource. The paper analyzes the autonomic capabilities of query optimizers in three wellknown DBMSs -DB2, Oracle and SQL Server being used in the industry. The research is focused to find and earmark those areas in query optimizers where the human intervention is required. Query Optimizers are compares with their autonomic capabilities; explores their strengths and weaknesses; and provides the basis for improving the current state of autonomic computing in query optimizers. The autonomic behavior of query optimizers is observed by designing and executing different queries through experiments and some recommendations are given.

A Distributed Computing Systems (DCS) calls for proper partitioning of tasks into modules and allocating them to various nodes so as to enable parallel execution of their modules by individual different processors of the system. A number of algorithms have been proposed for allocation of tasks in a Distributed Computing System. Most of the models proposed in literature consider modules of a single task for static allocation, for the purpose of allocation onto a DCS. Moreover, they did not consider the architectural capability of the processing nodes and the way of connectivity among them. This work considers allocation of disjoint multiple tasks with their corresponding modules and proposes a parallel algorithm for a realistic situation wherein multiple disjoint tasks with their modules compete for execution on an arbitrarily connected DCS based on well-known A* technique. The proposed algorithm also considers a load balanced allocation for the purpose. The paper justifies the effectiveness of the algorithm with the experimental results by comparing with previously reported works.

The CASA@ECSA 2020 workshop aims to bring together researchers and practitioners interested in modern systems implementing the required features for managing contextawareness, dynamicity, autonomy, and smart behaviour. These features may be associated with small devices such as mobile phones and their related applications, as well as with big systems concerning transportation, airports, and cities. They are useful for a wide range of application domains including healthcare, e-government communication and social networks, smart grids, energy management systems, finance, conference management systems and learning, just to make some examples. The development of such solutions involves interdisciplinary and trendy concepts and skills concerning context-awareness, autonomy, adaptiveness, machine learning, Internet-of-Things, Big Data, integration and communication, networks, green and efficient energy consumption, user-friendly access. In this context, software architectures play a fundamental role in the quality of development of such systems and the success of their deployment. This workshop aims to discuss the fundamental principles of context-aware, autonomous, and smart solutions, the current architectural trends, the future issues and challenges to be addressed at the architectural level. The workshop invites experts from industry and academic environments to share their solutions, ideas, visions, and questions about the design of software architectures for such solutions. We aim to enable discussions, partnerships, and collaborations among the software architects working on these topics. CASA@ECSA 2020 has received very interesting contributions from authors belonging to 7 distinct countries, and the four best papers have been accepted to be presented during this virtual event in September 2020 in the context of the 14 th European Conference on Software Architecture. The first paper entitled "State of the Practice Survey: Predicting the Influence of AI Adoption on System Software Architecture in Traditional Embedded Systems" is authored by Jasmin Jahic and Robin Roitsch. It investigates the perception of the Artificial Intelligence in industry and its impact, especially in embedded systems from an architectural point of view. The authors have interviewed various practitioners in different companies for the proposed survey. The second paper entitled "Composition Algorithm Adaptation in Service Oriented Systems" is authored by Niranjana Deshpande and Naveen Sharma. It proposes the adaptation of composition techniques of services in Service Oriented Architectures. The adaptation is performed for each user request. This solution leads to significant resource savings at runtime.

Software is becoming more and more aware of its execution context. Decisions made at design time are moved at run time to enhance the services offered by the software. The Context-aware, Autonomous, and Smart Architectures (CASA) workshop aims to address the issues and challenges raised by the development and evaluation of software that is context-aware, dynamic, autonomous, smart, adaptive, self-managed. Novel approaches are needed to face the new issues raised by such software. Further, existing architectural solutions should be adapted and improved to meet the dynamic requirements of today systems.

The joint 1st Workshop on Evaluations and Measurements in Self-Aware Computing Systems (EMSAC 2019) and Workshop on Self-Aware Computing (SeAC) was held as part of the FAS* conference alliance in conjunction with the 16th IEEE International Conference on Autonomic Computing (ICAC) and the 13th IEEE International Conference on Self-Adaptive and Self-Organizing Systems (SASO) in Umeå, Sweden on 20 June 2019. The goal of this one-day workshop was to bring together researchers and practitioners from academic environments and from the industry to share their solutions, ideas, visions, and doubts in self-aware computing systems in general and in the evaluation and measurements of such systems in particular. The workshop aimed to enable discussions, partnerships, and collaborations among the participants. This special issue follows the theme of the workshop. It contains extended versions of workshop presentations as well as additional contributions.

The joint 1st Workshop on Evaluations and Measurements in Self-Aware Computing Systems (EMSAC 2019) and Workshop on Self-Aware Computing (SeAC) was held as part of the FAS* conference alliance in conjunction with the 16th IEEE International Conference on Autonomic Computing (ICAC) and the 13th IEEE International Conference on Self-Adaptive and Self-Organizing Systems (SASO) in Umeå, Sweden on 20 June 2019. The goal of this one-day workshop was to bring together researchers and practitioners from academic environments and from the industry to share their solutions, ideas, visions, and doubts in self-aware computing systems in general and in the evaluation and measurements of such systems in particular. The workshop aimed to enable discussions, partnerships, and collaborations among the participants. This special issue follows the theme of the workshop. It contains extended versions of workshop presentations as well as additional contributions.

The 2017 1st International Workshop on Context-aware, Autonomous and Smart Architectures (CASA 2017) was held in conjunction with the 11th European Conference on Software Architecture (ECSA 2017), on September, 12th, 2017 in Canterbury, United Kingdom. The goal of this one-day workshop was to bring together researchers and practitioners from academic environment and from the industry to share their solutions, ideas, visions, and doubts in the design of software architectures for context-aware, autonomous, and smart solutions. The workshop focused on architectural aspects offering a complementary vision of such solutions with respect to the available application- and user-oriented perspectives on context-awareness, autonomy, and smartness. Furthermore, the workshop aimed to enable discussions, partnerships, and collaborations among the software engineers interested in these solutions.

Large computing clusters used for scientific processing suffer from systemic failures when operated over long continuous periods for executing workflows. Diagnosing job problems and faults leading to eventual failures in this complex environment is difficult, specifically when the success of an entire workflow might be affected by a single job failure. In this paper, we introduce a model-based, hierarchical, reliable execution framework that encompass workflow specification, data provenance, execution tracking and online monitoring of each workflow task, also referred to as participants. The sequence of participants is described in an abstract parameterized view, which is translated into a concrete data dependency based sequence of participants with defined arguments. As participants belonging to a workflow are mapped onto machines and executed, periodic and on-demand monitoring of vital health parameters on allocated nodes is enabled according to pre-specified rules. These rules specify conditions that must be true pre-execution, during execution and post-execution. Monitoring information for each participant is propagated upwards through the reflex and healing architecture, which consists of a hierarchical network of decentralized fault management entities, called reflex engines. They are instantiated as state machines or timed automatons that change state and initiate reflexive mitigation action(s) upon occurrence of certain faults. We describe how this cluster reliability framework is combined with the workflow execution framework using formal rules and actions specified within a structure of first order predicate logic that enables a dynamic management design that reduces manual administrative workload, and increases cluster-productivity.

This article present a compact proposed patch antenna for impedance matched for simple two horizontal slot is placed in a active patch with a via hole in sandwiched between radiated patch and bottom plane of an microstrip patch antenna for a band of 4 to 12Ghz application. The planned antenna is synthesized by using glass reinforced epoxy laminated material (FR4) and electromagnetic 3D view (IE3D) software. The software based design is suitable for a band of 3.3//5.5 Wi-Max and 5.3/5.8 WLAN frequency band. It is also suitable for satellite application The ground and exciting patch is separated by 1.5mm thickness. The proposed antenna parameter is design for 10Ghz..For such design the achieved Bandwidth for an antenna is 53 % at a VSWR<2, acceptable return loss (S11) = - 22.5dB, and the directivity of an antenna is 6 dBi. The antenna is appropriate for an application of X band. The designs of an antenna and its result have been discussed in detail.

In this paper, we introduce a new mathematical structure: fractal hypergraph. Due to the hierarchical and compositional nature of fractal hypergraphs, representations based on fractal hypergraphs can capture and abstract the object-oriented nature of SystemC. We propose a formal semantics of Sys-temC components based on fractal hypergraphs that has already be used in a formal debugger of SystemC components.

Dagstuhl seminar 10381 on robust query processing (held 19.09.10 -24.09.10) brought together a diverse set of researchers and practitioners with a broad range of expertise for the purpose of fostering discussion and collaboration regarding causes, opportunities, and solutions for achieving robust query processing. The seminar strove to build a unified view across the loosely-coupled system components responsible for the various stages of database query processing. Participants were chosen for their experience with database query processing and, where possible, their prior work in academic research or in product development towards robustness in database query processing. In order to pave the way to motivate, measure, and protect future advances in robust query processing, seminar 10381 focused on developing tests for measuring the robustness of query processing. In these proceedings, we first review the seminar topics, goals, and results, then present abstracts or notes of some of the seminar break-out sessions. We also include, as an appendix, the robust query processing reading list that was collected and distributed to participants before the seminar began, as well as summaries of a few of those papers that were contributed by some participants.

Companies’ operations have become over-dependent on their supporting enterprise software applications. This situation has placed a heavy burden onto software maintenance teams who are expected to keep these applications up and running optimally in varying execution conditions. However, this high human intervention drives up the overall costs of software ownership. In addition, the current dynamic nature of enterprise applications constitutes challenges with respect to their architectural design and development, and the guarantee of the agreed quality requirements at runtime. Efficiently and effectively achieving the adaptation of enterprise applications requires an autonomic solution. In this paper we present SHIFT, a framework that provides (i) facilities and mechanisms for managing self-adaptive enterprise applications through the use of an autonomic infrastructure, and (ii) automated derivation of self-adaptive enterprise applications and their respective monitoring infrastructur...

Java Agent Development Framework (JADE) is a software in JAVA, which is used for the development of agents, implemented in JAVA. It is a distributed agents platform, which has a container for each host where we run the agents. Additionally the platform has various debugging tools, mobility of code and content agents, the possibility of parallel execution of the behavior of agents, as well as support for the definition of languages and ontologies. In this paper, we will be having a detailed study on the functioning of JADE and we will put forward our conclusions on how its functioning can be enhanced.

This paper describes Service Clouds, a distributed infrastructure designed to facilitate rapid prototyping and deployment of services that enhance communication performance, robustness, and security. The infrastructure combines adaptive middleware functionality with an overlay network substrate in order to support dynamic instantiation and reconfiguration of services. The Service Clouds architecture includes a collection of lowlevel facilities that can be either invoked directly by applications or used to compose more complex services. After describing the Service Clouds architecture, we present results of two experimental case studies conducted on the PlanetLab Internet testbed, the first to improve throughput of bulk data transfer, and the second to enhance the robustness of multimedia streaming.

In pervasive computing environments, conditions are highly variable and resources are limited. In order to meet the needs of applications, systems must adapt dynamically to changing situations. Since adaptation at one system layer may be insufficient, crosslayer, or vertical approaches to adaptation may be needed. Moreover, adaptation in distributed systems often requires horizontal cooperation among hosts. This cooperation is not restricted to the source and destination(s) of a data stream, but might also include intermediate hosts in an overlay network or mobile ad hoc network. We refer to this combined capability as universal adaptation. We contend that the model defining interaction between adaptive middleware and the operating system is critical to realizing universal adaptation. We explore this hypothesis by evaluating the Kernel-Middleware eXchange (KMX), a specific model for crosslayer, cross-system adaptation. We present the KMX architecture and discuss its potential role in supporting universal adaptation in pervasive computing environments. We then describe a prototype implementation of KMX and show results of an experimental case study in which KMX is used to improve the quality of video streaming to mobile nodes in a hybrid wired-wireless network.

In pervasive computing environments, conditions are highly variable and resources are limited. In order to meet the needs of applications, systems must adapt dynamically to changing situations. Since adaptation at one system layer may be insufficient, crosslayer, or vertical approaches to adaptation may be needed. Moreover, adaptation in distributed systems often requires horizontal cooperation among hosts. This cooperation is not restricted to the source and destination(s) of a data stream, but might also include intermediate hosts in an overlay network or mobile ad hoc network. We refer to this combined capability as universal adaptation. We contend that the model defining interaction between adaptive middleware and the operating system is critical to realizing universal adaptation. We explore this hypothesis by evaluating the Kernel-Middleware eXchange (KMX), a specific model for crosslayer, cross-system adaptation. We present the KMX architecture and discuss its potential role in supporting universal adaptation in pervasive computing environments. We then describe a prototype implementation of KMX and show results of an experimental case study in which KMX is used to improve the quality of video streaming to mobile nodes in a hybrid wired-wireless network.

The Software Engineering and Network Systems (SENS) Laboratory supports research in software engineering, formal methods, distributed computing, fault tolerance, and computer networking. In addition to projects within each area, the diversity in faculty expertise enables SENS researchers to address challenging problems that span multiple areas. Examples include: automated development of software for embedded systems in automobiles and aircraft; adaptive software for protecting critical infrastructures from cascading failures and cyber-attack; robust software for networks of sensors used in military reconnaissance; adaptive protocols for pervasive computing via handheld and wearable computers; and providing security and privacy in peer-to-peer computing systems. Current SENS research projects are supported by grants from NSF, ONR, and DARPA. Several projects also involve industrial support and collaboration; partners include Motorola, Lucent, Cisco, Siemens, NASA/JPL, and Texas Instr...

This paper addresses the design of adaptive middleware to support autonomic computing in pervasive computing environments. The particular problem we address here is how to support self-optimization to changing network connection capabilities as a mobile user interacts with heterogeneous elements in a wireless network infrastructure. The goal is to enable self-optimization to such changes transparently with respect to the core application code. We propose a solution based on the use of the generic proxy, which is a specific CORBA object that can intercept and process any CORBA request using rules and actions that can be introduced to the knowledge base of the proxy during execution. To explore its design and operation, we have incorporated the generic proxy into ACT , an adaptive middleware framework we designed previously to support adaptation in CORBA applications. Details of the generic proxy are presented. A case study is described in which a generic proxy is used to support self-optimization in an existing image retrieval application, when executed in a heterogeneous wireless environment.

Increasingly, computer software must adapt dynamically to changing conditions. The correctness of adaptation cannot be properly addressed without precisely specifying the requirements for adaptation. In many situation, these requirements involve absolute time, in addition to a logical ordering of events. This paper introduces an approach to formally specifying such timing requirements for adaptive software. We introduce TA-LTL, a timed adaptation-based extension to linear temporal logic, and use this logic to specify three timing properties associated with the adaptation process: safety, liveness, and stability. A dynamic adaptation of interactive audio streaming software is used to illustrate timed temporal logic.

Increasingly, computer software must adapt dynamically to changing conditions. The correctness of adaptation cannot be rigorously addressed without precisely specifying the requirements for adaptation. In many situations, these requirements involve absolute time, in addition to a logical ordering of events. This paper introduces an approach to formally specifying such timing requirements for adaptive software. We introduce TA-LTL, a timed adaptation-based extension to linear temporal logic, and use this logic to specify three timing properties associated with the adaptation process: safety, liveness, and stability. A dynamic adaptation scenario involving interactive audio streaming software is used to illustrate the timed temporal logic.

Increasingly, software systems are constructed by composing multiple existing applications. The resulting complexity increases the need for self-management of the system. However, adding autonomic behavior to composite systems is difficult, especially when the existing components were not originally designed to support such interactions. Moreover, entangling the code for integrated selfmanagement with the code for the business logic of the original applications may actually increase the complexity of the system, counter to the desired goal. In this paper, we propose a technique to enable self-managing behavior to be added to composite systems transparently, that is, without requiring manual modifications to the existing code. The technique uses transparent shaping, developed previously to enable dynamic adaptation in existing programs, to weave self-managing behavior into existing applications, which interact through Web services. A case study demonstrates the use of this technique to construct a fault-tolerant surveillance application from two existing applications, one developed in .NET and the other in CORBA, without the need to modify the source code of the original applications.

This paper describes TRAP/J, a software tool that enables new adaptable behavior to be added to existing Java applications transparently (that is, without modifying the application source code and without extending the JVM). The generation process combines behavioral reflection and aspect-oriented programming to achieve this goal. Specifically, TRAP/J enables the developer to select, at compile time, a subset of classes in the existing program that are to be adaptable at run time. TRAP/J then generates specific aspects and reflective classes associated with the selected classes, producing an adapt-ready program. As the program executes, new behavior can be introduced via interfaces to the adaptable classes. A case study is presented in which TRAP/J is used to introduce adaptive behavior to an existing audio-streaming application, enabling it to operate effectively in a lossy wireless network by detecting and responding to changing network conditions.

We recently introduced Service Clouds, a distributed infrastructure designed to facilitate rapid prototyping and deployment of autonomic communication services. In this paper, we propose a model that extends Service Clouds to the wireless edge of the Internet. This model, called Mobile Service Clouds, enables dynamic instantiation, composition, configuration, and reconfiguration of services on an overlay network to support mobile computing. We have implemented a prototype of this model and applied it to the problem of dynamically instantiating and migrating proxy services for mobile hosts. We conducted a case study involving data streaming across a combination of PlanetLab nodes, local proxies, and wireless hosts. Results are presented demonstrating the effectiveness of the prototype in establishing new proxies and migrating their functionality in response to node failures.

The need for adaptability in software is growing, driven in part by the emergence of pervasive and autonomic computing. In many cases, it is desirable to enhance existing programs with adaptive behavior, enabling them to execute effectively in dynamic environments. In this paper, we propose a general programming model called transparent shaping to enable dynamic adaptation in existing programs. We describe an approach to implementing transparent shaping that combines four key software development techniques: aspect-oriented programming to realize separation of concerns at development time, behavioral reflection to support software reconfiguration at run time, component-based design to facilitate independent development and deployment of adaptive code, and adaptive middleware to encapsulate the adaptive functionality. After presenting the general model, we discuss two specific realizations of transparent shaping that we have developed and used to create adaptable applications from ex...

Recomposable software enables a system to change its structure and behavior during execution, in response to a dynamic execution environment. This paper proposes an approach to ensure that such adaptations are safe with respect to system consistency. The proposed method takes into consideration dependency analysis for target components, specifically determining viable sequences of adaptive actions and those states in which an adaptive action may be applied safely. We demonstrate that the technique ensures safe adaptation (insertion, removal, and replacement of components) in response to changing external conditions in a wireless multicast video application.

Adaptive and autonomic systems often must be able to detect and respond to errant behavior or changing conditions with little or no human intervention. Decision making is a critical issue in such systems, which must learn how and when to invoke corrective actions based on past experience. This paper describes the design, implementation and evaluation of a perceptual memory system, called MESO, that supports online decision-making in adaptive systems. MESO uses clustering and pattern classification methods while addressing the needs of online, incremental learning.

A distributed system is modeled as a set of communicating components running on one or more processes. -Adaptive actions: insert, remove, or replace SW elements • Atomic communication: -An interaction, either within a component or between components, that cannot be interrupted. -Otherwise, it would potentially yield erroneous or unexpected results. • Dependency invariants: -relationships among the components that should be held true throughout the program's execution.

Increasingly, applications need to be able to selfreconfigure in response to changing requirements and environmental conditions. Autonomic computing has been proposed as a means for automating software maintenance tasks. As the complexity of adaptive and autonomic systems grows, designing and managing the set of reconfiguration rules becomes increasingly challenging and may produce inconsistencies. This paper proposes an approach to leverage genetic algorithms in the decision-making process of an autonomic system. This approach enables a system to dynamically evolve target reconfigurations at run time that balance tradeoffs between functional and non-functional requirements in response to changing requirements and environmental conditions. A key feature of this approach is incorporating system and environmental monitoring information into the genetic algorithm such that specific changes in the environment automatically drive the evolutionary process towards new viable solutions. We have applied this geneticalgorithm based approach to the dynamic reconfiguration of a collection of remote data mirrors, demonstrating an effective decision-making method for diffusing data and minimizing operational costs while maximizing data reliability

This paper describes a study where small computer programs called digital organisms are evolved to construct communication networks in a virtual environment. Through the application of various selection pressures, we show how these organisms first evolve to build, and subsequently use, these networks for a collective communication task, specifically the efficient distribution of data among organisms. The results of our experiments demonstrate that evolutionary algorithms can discover behaviors for constructing networks that solve communication tasks, potentially leading to a new family of distributed algorithm where the underlying logical structure of the network automatically self-adapts to suit the application.