| 1. |
- Al-Shishtawy, Ahmad, et al.
(författare)
-
A design methodology for self-management in distributed environments
- 2009
-
Ingår i: IEEE International conference on Computational Science and Engineering. - 9780769538235 ; , s. 430-436
-
Konferensbidrag (refereegranskat)abstract
- Autonomic computing is a paradigm that aims at reducing administrative overhead by providing autonomic managers to make applications selfmanaging. In order to better deal with dynamic environments, for improved performance and scalability, we advocate for distribution of management functions among several cooperative managers that coordinate their activities in order to achieve management objectives. We present a methodology for designing the management part of a distributed self-managing application in a distributed manner. We define design steps, that includes partitioning of management functions and orchestration of multiple autonomic managers. We illustrate the proposed design methodology by applying it to design and development of a distributed storage service as a case study. The storage service prototype has been developed using the distributing component management system Niche. Distribution of autonomic managers allows distributing the management overhead and increased management performance due to concurrency and better locality.
|
|
| 2. |
- Al-Shishtawy, Ahmad, 1978-, et al.
(författare)
-
Distributed Control Loop Patterns for Managing Distributed Applications
- 2008
-
Ingår i: SASOW 2008. - LOS ALAMITOS : IEEE Computer Society. - 9781424434688 ; , s. 260-265
-
Konferensbidrag (refereegranskat)abstract
- In this paper we discuss various control loop patterns for managing distributed applications with multiple control loops. We introduce a high-level framework, called DCMS, for developing, deploying and managing component-based distributed applications in dynamic environments. The control loops, and interactions among them, are illustrated in the context of a distributed self-managing storage service implemented using DCMS to achieve various self-* properties. Different control loops are used for different self-* behaviours, which illustrates one way to divide application management, which makes for both ease of development and for better scalability and robustness when managers are distributed. As the multiple control loops are not completely independent, we demonstrate different patterns to deal with the interaction and potential conflict between multiple managers.
|
|
| 3. |
- Al-Shishtawy, Ahmad, et al.
(författare)
-
Enabling Self-Management Of Component Based Distributed Applications
- 2008
-
Ingår i: FROM GRIDS TO SERVICE AND PERVASIVE COMPUTING. - Boston, MA : Springer-Verlag New York. - 9780387094557 ; , s. 163-174
-
Konferensbidrag (refereegranskat)abstract
- Deploying and managing distributed applications in dynamic Grid environments requires a high degree of autonomous management. Programming autonomous management in turn requires programming environment support and higher level abstractions to become feasible. We present a framework for programming self-managing component-based distributed applications. The framework enables the separation of application’s functional and non-functional (self-*) parts. The framework extends the Fractal component model by the component group abstraction and one-to-any and one-to-all bindings between components and groups. The framework supports a network-transparent view of system architecture simplifying designing application self-* code. The framework provides a concise and expressive API for self-* code. The implementation of the framework relies on scalability and robustness of the Niche structured p2p overlay network. We have also developed a distributed file storage service to illustrate and evaluate our framework.
|
|
| 4. |
- Brand, Per
(författare)
-
The design philosophy of distributed programming systems: the Mozart experience
- 2005. - 2
-
Doktorsavhandling (övrigt vetenskapligt/konstnärligt)abstract
- Distributed programming is usually considered both difficult and inherently different from concurrent centralized programming. It is thought that the distributed programming systems that we ultimately deploy, in the future, when we've worked out all the details, will require a very different programming model and will even need to be evaluated by new criteria. The Mozart Programming System, described in this thesis, demonstrates that this need not be the case. It is shown that, with a good system design, distributed programming can be seen as an extended form of concurrent programming. This is from the programmer's point-of-view; under the hood the design and implementation will necessarily be more complex. We relate the Mozart system with the classical transparencies of distributed systems. We show that some of these are inherently on the application level, while as Mozart demonstrates, others can and should be dealt with on the language/system level. The extensions to the programming model, given the right concurrent programming base, are mainly concerned with non-functional properties of programs. The models and tuning facilities for failure and performance need to take latency, bandwidth, and partial failure into account. Other than that there need not be any difference between concurrent programming and distributed programming. The Mozart Programming System is based on the concurrent programming language Oz, which integrates, in a coherent way, all three known concurrency or thread-interaction models. These are message-passing (like Erlang), shared objects (like Java with threads) and shared data-flow variables. The Mozart design philosophy is thus applicable over the entire range of concurrent programming languages/systems. We have extracted from the experience with Mozart a number of principles and properties that are applicable to the design and implementation of all (general-purpose) distributed programming systems. The full range of the design and implementation issues behind Mozart are presented. This includes a description of the consistency protocols that make transparency possible for the full language, including distributed objects and distributed data-flow variables. Mozart is extensively compared with other approaches to distributed programming, in general, and to other language-based distributed programming systems, in particular.
|
|
| 5. |
- Brand, Per, 1952-
(författare)
-
The design philosophy of distributed programming systems : the Mozart experience
- 2005
-
Doktorsavhandling (övrigt vetenskapligt/konstnärligt)abstract
- Distributed programming is usually considered both difficult and inherently different from concurrent centralized programming. It is thought that the distributed programming systems that we ultimately deploy, in the future, when we've worked out all the details, will require a very different programming model and will even need to be evaluated by new criteria. The Mozart Programming System, described in this thesis, demonstrates that this need not be the case. It is shown that, with a good system design, distributed programming can be seen as an extended form of concurrent programming. This is from the programmer's point-of-view; under the hood the design and implementation will necessarily be more complex. We relate the Mozart system with the classical transparencies of distributed systems. We show that some of these are inherently on the application level, while as Mozart demonstrates, others can and should be dealt with on the language/system level. The extensions to the programming model, given the right concurrent programming base, are mainly concerned with non-functional properties of programs. The models and tuning facilities for failure and performance need to take latency, bandwidth, and partial failure into account. Other than that there need not be any difference between concurrent programming and distributed programming. The Mozart Programming System is based on the concurrent programming language Oz, which integrates, in a coherent way, all three known concurrency or thread-interaction models. These are message-passing (like Erlang), shared objects (like Java with threads) and shared data-flow variables. The Mozart design philosophy is thus applicable over the entire range of concurrent programming languages/systems. We have extracted from the experience with Mozart a number of principles and properties that are applicable to the design and implementation of all (general-purpose) distributed programming systems. The full range of the design and implementation issues behind Mozart are presented. This includes a description of the consistency protocols that make transparency possible for the full language, including distributed objects and distributed data-flow variables. Mozart is extensively compared with other approaches to distributed programming, in general, and to other language-based distributed programming systems, in particular
|
|
| 6. |
- Brand, Per, et al.
(författare)
-
The Role of Overlay Services In a Self-Managing Framework for Dynamic Virtual Organizations
- 2008
-
Ingår i: Making Grids Work. - Boston, MA : Springer-Verlag New York. - 9780387784489 ; , s. 153-164
-
Konferensbidrag (refereegranskat)abstract
- We combine and extend recent results in autonomic computing and structuredpeer-to-peer to build an infrastructure for constructing and managing dynamic vir-tual organizations. The paper focuses on the middle layer of the proposed infras-tructure, in-between the Niche overlay system on the bottom, and an architecture-based management system based on Jade on the top. The middle layer, theoverlay services, are responsible for all sensing and actuation carried out by theVO management. We describe in detail the API of the resource and componentoverlay services both on the management node and the nodes hosting resources.We present a simple use case demonstrating resource discovery, initial deploy-ment, self-configuration as a result of resource availability change, self-healing,self-tuning and self-protection. The advantages of the design are 1) the overlayservices are in themselves self-managing, and sensor/actuation services they pro-vide are robust, 2) management can be dealt with declaratively and at a high-level,and 3) the overlay services provide good scalability in dynamic VOs.
|
|
| 7. |
- de Palma, Noel, et al.
(författare)
-
Tools for Architecture Based Autonomic Systems
- 2009
-
Ingår i: ICAS. - : IEEE Communications Society. - 9781424436842 ; , s. 313-320
-
Konferensbidrag (refereegranskat)abstract
- Recent years have seen a growing interest in autonomic computing, an approach to providing systems with self managing properties. Autonomic computing aims to address the increasing complexity of the administration of large systems. The contribution of this paper is to provide a generic tool to ease the development of autonomic managers. Using this tool, an administrator provides a set of alternative architectures and specifies conditions that are used by autonomic managers to update architectures at runtime. Software changes are computed as architectural differences in terms of component model artifacts (components, attributes, bindings, etc.). These differences are then used to migrate into the next architecture by reconfiguring only the required part of the running system.
|
|
| 8. |
- De Palma, Noel, et al.
(författare)
-
Tools for Autonomic Computing
- 2009. - 10
-
Ingår i: 5th International Conference on Autonomic and Autonomous Systems (ICAS 2009). - : IEEE Computer Society. ; , s. 313-320
-
Konferensbidrag (refereegranskat)
|
|
| 9. |
- Popov, Konstantin, et al.
(författare)
-
An efficient incremental marshaling framework for distributed systems
- 2005
-
Ingår i: Future generations computer systems. - : Elsevier BV. - 0167-739X .- 1872-7115. ; 21:5, s. 717-724
-
Tidskriftsartikel (refereegranskat)abstract
- We present an efficient and incremental (un)marshaling framework designed for distributed applications. A marshaler/ unmarshaler pair converts arbitrary structured data between its host and network representations. This technology can also be used for persistent storage. Our framework simplifies the design of efficient and flexible marshalers. The network latency is reduced by concurrent execution of (un)marshaling and network operations. The framework is actually used in Mozart, a distributed programming system that implements Oz, a multi-paradigm concurrent language.
|
|
