We present our approach for deploying and managing distributed component-based applications. A Desired State Description (DSD), written in a high-level declarative language, specifies requirements for a distributed application. Our infrastructure accepts a DSD as input, and from it automatically configures and deploys the distributed application. Subsequent violations of the original requirements are detected and, where possible, automatically rectified by reconfiguration and redeployment of the necessary application components. A constraint solving tool is used to plan deployments that meet the application requirements.
The SmartFrog framework @cite_0 is similar to this work in its motivation, to address the problems of describing, deploying and managing complex, distributed assemblies of software components. SmartFrog consists of a declarative language for describing component collections and component configuration parameters, and a runtime environment which activates and manages the components to deliver and maintain running systems. In SmartFrog each component transitions through life-cycle states in lock-step with all other components in the deployment. The SmartFrog life-cycle service model is similar to @cite_16 which also utilizes constraint-based deployment. However, they advocate propagative deployment and maintain global constraints through the use of a consensus algorithm.
@cite_0 @cite_16
77896083 2165204405 2145834571 2083400053
Introduction SmartFrog was conceived to overcome the myriad issues related to incorrect configuration of complex, distributed systems. Applications such as multi-tier web-service systems are composed of multiple software components, typically running across multiple nodes. Several elements must be in place for the system to be considered correctly configured: first, each component of the system (e.g. database, application server) must be configured correctly with the required software settings. Secondly, each system component must be correctly bound to the other system components – e.g., the application server must be connected to the correct database. Thirdly, system components must be started in an appropriate sequence, such as starting the database before the application server. In addition, there are often setup tasks that must precede the startup of the main system, and cleanup tasks that must occur after the system is shut down. Incorrect configuration in one or more of these aspects is a very frequent source of system malfunction [1]. In general, such configuration aspects are found in multiple formats, in multiple places. Changes to configurations are made one-by-one, in many places in the system, without regard for how configuration parameters are interdependent. Configuration changes are made in an ad-hoc fashion, by multiple people at multiple times (e.g., setting factory defaults, making installation-time changes, making operation-time changes), and there is little traceability or repeatability. So, the problem is firstly how to express all of the configuration information in a consistent fashion, which recognizes the relationships between configuration parameters, avoids duplication, allows for correctness-checking, and allows the system configuration to be changed at different stages in its evolution. Secondly, how to take this more powerful expression of the system configuration and use it to automatically, repeatably and flexibly ignite the complete system. SmartFrog addresses these problems by offering a powerful and consistent way to capture system configurations, an automatic deployment infrastructure which can repeatably realize the systems described and a component model to manage the deployed applications though their lifecycle. Several recently proposed infrastructures permit client applications to interact with distributed network-accessible services by simply "plugging in" into a substrate that provides essential functionality, such as naming, discovery, and multi-protocol binding. However much work remains before the interaction can be considered truly seamless in the sense of adapting to the characteristics of the heterogeneous environments in which clients and services operate. This paper describes a novel approach for addressing this shortcoming: the partitionable services framework, which enables services to be flexibly assembled from multiple components, and facilitates transparent migration and replication of these components at locations closer to the client while still appearing as a single monolithic service. The framework consists of three pieces: (1) declarative specification of services in terms of constituent components; (2) run-time support for dynamic component deployment; and (3) planning policies, which steer the deployment to accomodate underlying environment characteristics. We demonstrate the salient features of the framework and highlight its usability and performance benefits with a case study involving a security-sensitive mail service. Wireless systems comprised of rechargeable nodes have a significantly prolonged lifetime and are sustainable. A distinct characteristic of these systems is the fact that the nodes can harvest energy throughout the duration in which communication takes place. As such, transmission policies of the nodes need to adapt to these harvested energy arrivals. In this paper, we consider optimization of point-to-point data transmission with an energy harvesting transmitter which has a limited battery capacity, communicating in a wireless fading channel. We consider two objectives: maximizing the throughput by a deadline, and minimizing the transmission completion time of the communication session. We optimize these objectives by controlling the time sequence of transmit powers subject to energy storage capacity and causality constraints. We, first, study optimal offline policies. We introduce a directional water-filling algorithm which provides a simple and concise interpretation of the necessary optimality conditions. We show the optimality of an adaptive directional water-filling algorithm for the throughput maximization problem. We solve the transmission completion time minimization problem by utilizing its equivalence to its throughput maximization counterpart. Next, we consider online policies. We use stochastic dynamic programming to solve for the optimal online policy that maximizes the average number of bits delivered by a deadline under stochastic fading and energy arrival processes with causal channel state feedback. We also propose near-optimal policies with reduced complexity, and numerically study their performances along with the performances of the offline and online optimal policies under various different configurations. The paper describes the design and implementation of an adaptive recompilation framework for Rotor, a shared source implementation of the common language infrastructure (CLI) that can increase program performance through intelligent recompilation decisions and optimisations based on the program's past behaviour. Our extensions to Rotor include a low overhead run-time-stack based sampling profiler that identifies program hotspots. At the first level of optimisation, the compiler uses a fast yet effective linear scan algorithm for register allocation. Hot methods can be instrumented to collect basic-block, edge and call-graph profile information. Profile-guided optimisations driven by online profile information are used to further optimise heavily executed methods at the second level of recompilation. An evaluation of the framework using a set of test programs shows that performance can improve by a maximum of 42.3 and by 9 on average. Our results also show that the overheads of collecting accurate profile information through instrumentation to an extent outweigh the benefits of profile-guided optimisations in our implementation, suggesting the need for implementing techniques that can reduce such overheads. A flexible and extensible framework design implies that additional profiling and optimisation techniques can easily be incorporated to further improve performance.