Dynamic AOP has been identified as a useful technique to implement an auto-adaptive framework. To supplement this policies based upon Event-Condition-Action rules are used to specify when adaptations should be applied to the underlying system. However, for use in auto-adaptive systems it is advantageous if these policies allow certain relationship information to be specified to ensure the system never encounters undesirable interactions and adaptations are applied in a correct manner. This paper highlights the need for these relationships by giving a series of examples followed by a proposed solution to these problems.
Complex software systems, like operating systems and middleware, have to cope with a broad range of requirements as well as strict resource constraints. Family-based software development is a promising approach to develop application-specific systems from reusable components. However, once statically configured, these systems still need to adapt at runtime according to the dynamics of the environment. The majority of the concerns in the complex systems, that need to be adaptable, are crosscutting. With the application of Aspect-oriented Programming (AOP), these concerns can be cleanly encapsulated, and then dynamic AOP can be applied for the adaptations to be contained, and applied at runtime. An efficient dynamic aspect weaver is needed for the dynamic weaving and unweaving of these crosscutting concerns into the system. None of the currently available dynamic weaver can be optimized according to specific application requirements. In this paper we present the family-based dynamic weaver framework that supports the static as well as dynamic weaving and unweaving of the aspects to the components. By applying the program family concept, the system itself as well as the dynamic weaver, built on top of it, is tailored down to provide only the features or services required by any particular application.
On the one hand, traits are a powerful way of structuring classes. Traits support the reuse of method collections over several classes. However, traits cannot be used when specifying unanticipated changes to an application. On the other hand, classboxes are a new module system that supports the local redefinition of classes: a collection of classes can be locally extended with variables and/or methods and the existing clients do not get impacted by changes. However, an extension applied to a class by a classbox cannot be reused for other classes. This paper describes how combining Traits and Classboxes supports the safe introduction of crosscutting collaborations: safe because the existing clients of the classes do not get impacted, crosscutting because collaborations between several classes can be put in place in a unanticipated manner. In the resulting system, a collaboration is represented by a classbox and a role by a trait.
Access to Grid services is currently limited to devices having significant computing, network resources etc. such as desktop computers. On the other hand, most of mobile devices do not have the potential resources to be either direct clients or to host services in the Grid environment. Yet, extending the potential of the Grid to a wider audience promises increase in its flexibility and productivity. In this paper we present the MAGI middleware architecture that addresses the issues of job delegation to a Grid service, adaptive management by including support for offline processing, secure communication, interaction with heterogeneous mobile devices and presentation of results formatted in accordance with the device profiles and limitations. This is achieved by out-sourcing the resource intensive tasks from the mobile device to the middleware. We also demonstrate through formal modeling using Petri Nets that the addi-tion of such a middleware causes minimum overhead and the benefits attained outweigh this overhead.
Automatic Grid resource discovery and brokerage shields the Grid middleware complexities from the Grid users and leads towards an invisible but simple and robust Grid. Realizing this vision requires a machine understandable resource description and powerful correlation 1 mechanism. Semantic technologies like ontologies provide vocabularies with explicitly defined, unambiguously understandable and automatically machine-interpretable meanings which make the process of automatic resource brokerage possible. We propose a fully Ontology-based resource description, discovery and correlation mechanism. For the resource description model we have replaced the classical symmetric attribute based resource description model with an extensible asymmetric resource description model. This model provides foundation to our flexible and extensible discovery and correlation mechanism.
This paper presents a portable framework to profile memory allocation in standard Java Virtual Machines. We extended our exact profiler JP, which generates a method call tree (MCT) for each thread in the system, in order to store information concerning object allocation in the MCT. Our primary design goals were to use platform-independent metrics for memory allocation and to minimize the extra overhead caused by memory profiling. For each method invocation context, the profiler preserves the number of allocated objects of each type. We exploit the fact that an object allocation is usually followed by a constructor invocation, in order to compute the number of object allocations from the MCT. A static analysis of constructor code allows to distinguish between the invocation of an alternate or superclass constructor and object allocation within the constructor. Arrays are treated specially, as we instrument array allocation instructions in order to preserve accumulated information on the type, number, and size of allocated arrays for each method invocation context. A performance evaluation shows that the extra overhead due to memory profiling is small.
The challenge of finding services or resources in Web services and Grid environments has recently been the subject of a lot of attention. Different solutions to this problem were proposed, each with its specific model and realization. Although all solutions address the same problem, it is very difficult for a non-expert and even for an expert in the field to decide if one solution is better then another and why. In this paper we propose a systematic set of criteria, a framework, that can help in the evaluation of different discovery approaches. We exemplify the use of our framework on some of the most relevant discovery approaches in Web services and Grid areas.
In times of increasing grid oriented computing environments, the integration and orchestration of business services become more and more emergent. This challenge is taken in the context of the EU project Adapative Services Grid. As a base for the execution of workflow specifications a distributed execution environment for simple business services and service managment is needed. This paper shows how such environments can be designed and implemented as a result of the Adapative Services Grid research.
Integration projects involve expert groups with different backgrounds and skills. Coordination mechanisms that manage the close collaborative work are given through the concepts of procedure models. An effective use of procedure models re- quires tool support that covers easy-to-use documentation aspects as well as sophisti- cated run time support for the complete development life cycle. Therefore we intro- duce a multi-layer tool architecture capable of supporting all stages of the application of procedure models. In particular we focus on the transformation of models between different abstraction layers. The practicability of our approach is discussed on the base of a prototypical implementation of its tool components.
In grid workflow systems, existing typical checkpoint selection strategies, which are used to select checkpoints for verifying fixed-time constraints at run-time execution stage, are not effective and/or efficient for fixed-time constraint verification because they often ignore some necessary checkpoints and select some unnecessary checkpoints. To improve such status, in this paper, we develop a new checkpoint selection strategy. Specifically, we first address a new concept of minimum proportional time redundancy which can be used to tolerate certain time deviation incurred by abnormal grid workflow execution. Then, we discuss relationships between minimum proportional time redundancy and fixed-time constraint consistency. Based on the relationships, we present our new strategy. With the strategy, we can avoid the omission of necessary checkpoints and the selection of excess unnecessary checkpoints. Consequently, our strategy is more effective and efficient for fixed-time constraint verification than the existing typical strategies. The final evaluation further demonstrates this result.
This document presents an architecture for autonomous quality of service (QoS) management using a proxy-like approach. Service Level Agreements, as presented here, can be exploited to define certain QoS parameters that a service is to maintain during its interaction with a specific customer. As such, they provide a means of defining electronic contracts. Within this paper, a way is presented to autonomously manage such forms of contracts. Since this requires an accordingly designed framework, the relevant objectives that have to be respected in this context have been analysed. Most of these requirements are explicitly put forward by service providers, respectively customers and cover issues that such a framework ideally should support. On this basis, an architecture for a management system has been developed. The main innovation of this framework consists in the introduction of a third-party "proxy" that allows for easy, "plug'n'play" management of SLAs. Using the architecture, an implementation guideline has been sketched that will provide some insight into how such a system may be set up and reused. The proxy-like approach presented here has been critically analysed and possible improvements for further development and research in this area have been identified.
This article describes an original approach for the optimized execution of computational tasks in Grid environments. Tasks are represented as workflows that define interactions between different services. Functional service descriptions written in OWL-S are extended with non-functional properties, allowing to specify the resource requirements of services depending on given inputs. Based on such annotations, a mathematical model is derived to estimate the execution costs of a workflow. Moreover, an optimization algorithm is presented that distributes the execution of a workflow in a Grid, supporting the dynamic deployment of software components on demand, in order to fulfill user requirements, such as a limit on the total workflow execution time. Workflows are executed in a fully decentralized way, avoiding inefficient triangular routing of messages.
Aspect-oriented languages provide means to superimpose aspectual behavior on a given set of join points. It is possible that not just a single, but several units of aspectual behavior need to be superimposed on the same join point. Aspects that specify the superimposition of these units are said to "share" the same join point. Such shared join points may give rise to issues such as determining the exact execution order and the dependencies among the aspects. In this paper, we present a detailed analysis of the problem, and identify a set of requirements upon mechanisms for composing aspects at shared join points. To address the identified issues, we propose a general and declarative model for defining constraints upon the possible compositions of aspects at a shared join point. Finally, by using an extended notion of join points, we show how concrete aspect-oriented programming languages, particularly AspectJ and Compose*, can adopt the proposed model.
Traditionally in aspect-oriented languages, pointcut designators select joinpoints of a program based on lexical information such as explicit names of program elements. However, this reduces the adaptability of software, since it involves too much information that is hard-coded, and often implementation-specific. We claim that this problem can be reduced by referring to program units through their design intentions. Design intention is represented by annotated design information, which describes for example the behavior of a program element or its intended meaning. In this paper, we analyze four techniques that are regularly used in state-of-the-art object-oriented languages in associating design information with program elements. Also, the usage of design information in the weaving process of aspect-oriented languages is illustrated and their deficiencies are outlined. Accordingly, we formulate requirements for the proper application of design information in aspect-oriented programming. We discuss how to use design information for the superimposition of aspects, and how to apply superimposition to bind design information to program elements. To achieve this, we propose language abstractions that support semantic composition: the ability to compose aspects with the elements of the base program that incorporate certain design information. Based on this proposal, we show how the aspect-oriented language Compose* can be extended to support design information. We demonstrate the application of design information to improve the reusability of aspects. The paper ends with related works, a discussion, and conclusions.
