The Experts below are selected from a list of 5244 Experts worldwide ranked by ideXlab platform
Antony Rowstron - One of the best experts on this subject based on the ideXlab platform.
-
using mobile code to provide fault tolerance in Tuple Space based coordination languages
Science of Computer Programming, 2003Co-Authors: Antony RowstronAbstract:Tuple Space based coordination languages suffer from poor fault tolerance to agent failure. Traditionally, transaction type mechanisms have been adopted in them to provide this type of fault tolerance. However, transactions change the semantics of the Tuple Space access primitives performed within them and do not provide a sufficient level of flexibility.We propose using mobile coordination, which utilises mobile code, as an alternative mechanism for providing better fault tolerance to agent failure. The use of mobile code is transparent to the application programmer. Mobile coordination provides the same level of fault tolerance as transactions, but it also introduces the concept of agent wills. This allows coordination patterns to be performed in a fault tolerant manner which cannot be performed in a fault tolerant manner using transactions.Mobile coordination is described in detail. The API for a prototype centralised implementation is presented. It is shown that mobile coordination provides better support and better performance than the traditional approach of using transactions. Implementation strategies for a distributed implementation are also discussed.
-
optimising the linda in primitive understanding Tuple Space run times
ACM Symposium on Applied Computing, 2000Co-Authors: Antony RowstronAbstract:ABSTRACT In this paper we examine Tuple Space systems from a distributed viewpoint. We show that current implementations are pessimistic about the timing of removal of Tuples from a Tuple Space when an in is performed; this leads to agents having to unnecessarily block and to lowering systems performance. After providing evidence of the problem by examining distributed execution traces we then describe an implementation strategy that is highly e cient and is more optimistic about Tuple removal. We discuss also the generalisation of the approach to support other primitives, which have been proposed as additions to Linda, such as the collect and copy-collect primitives.
-
mobile co ordination providing fault tolerance in Tuple Space based co ordination languages
International Conference on Coordination Models and Languages, 1999Co-Authors: Antony RowstronAbstract:In this paper we describe the concept of mobile co-ordination, a general purpose approach to overcoming failure of agents when using distributed Tuple Spaces. We demonstrate why mobile co-ordination is better than using existing techniques such as transactions, how mobile co-ordination can provide extra functionality in the form of agent wills, and how the framework to provide this can be implemented in Java and can be used with multiple different Tuple Space co-ordination languages. Experimental results are presented to show performance gains made when mobile co-ordination is used.
-
using asynchronous Tuple Space access primitives bonita primitives for process co ordination
International Conference on Coordination Models and Languages, 1997Co-Authors: Antony RowstronAbstract:In this paper an interactive talk program is used to demonstrate the difference between the Linda primitives and the recently proposed Bonita primitives. Both use the concept of shared Tuple Spaces for inter-agent communication, but the Bonita primitives provide asynchronous Tuple Space access. The paper demonstrates the performance gains and the novel co-ordination patterns achievable using the Bonita primitives.
-
an efficient distributed Tuple Space implementation for networks of workstations
European Conference on Parallel Processing, 1996Co-Authors: Antony Rowstron, Alan WoodAbstract:In this paper an overview of a novel run time system for the management of Tuple Spaces, which utilises implicit information about Tuple Space use in Linda programs to maximise its performance. The approach is novel compared to other Tuple Space implementations because they either ignore the information, or expect the programmer to provide the information explicitly. A number of experimental results are given to demonstrate the advantages of using the our approach.
Alysson Bessani - One of the best experts on this subject based on the ideXlab platform.
-
an efficient byzantine resilient Tuple Space
IEEE Transactions on Computers, 2009Co-Authors: Alysson Bessani, Miguel Correia, Joni Da Silva Fraga, Lau Cheuk LungAbstract:Open distributed systems are typically composed by an unknown number of processes running in heterogeneous hosts. Their communication often requires tolerance to temporary disconnections and security against malicious actions. Tuple Spaces are a well-known coordination model for this kind of systems. They can support communication that is decoupled both in time and Space. There are currently several implementations of distributed fault-tolerant Tuple Spaces but they are not Byzantine-resilient, i.e., they do not provide a correct service if some replicas are attacked and start to misbehave. This paper presents an efficient implementation of a linearizable Byzantine fault-tolerant Tuple Space (LBTS) that uses a novel Byzantine quorum systems replication technique in which most operations are implemented by quorum protocols while stronger operations are implemented by more expensive protocols based on consensus. LBTS is linearizable and wait-free, showing interesting performance gains when compared to a similar construction based on state machine replication.
-
bft services programming with a dependable Tuple Space
2009Co-Authors: Francois Aubry, Alysson Bessani, Paulo SousaAbstract:In the last decade there has been a large body of work in how to make Byzantine fault-tolerant (BFT) systems more practical. Most of these works aim to provide efficient implementations of abstractions such as state machine replication, consensus and read-write registers. These abstractions are well regarded as important building blocks to architect dependable distributed systems. In this paper we advocate the idea of using a new abstraction for programming dependable systems: the coordination service. The idea is to have one or more shared memory objects providing some synchronization power that allows distributed problems to be solved. The final objective is to make dependable services programming more simple. The idea is not only interesting from a theoretical point of view, but is also very practical since coordination services are already being used by Google and Yahoo! to coordinate crash fault-tolerant services. In this paper we evolve this idea to deal with Byzantine faults and show how we can use a coordination service based on an abstraction called PEATS (Policy Enforced Augmented Tuple Space) [2] to implement BFT services. The PEATS is a simple object that provides operations to insert, read, remove and conditionally insert generic data structures called Tuples. The execution of these operations is protected by a fine-grained security policy that allows or denies them based on the operation arguments, its caller and the state of the PEATS. Given the limited number of operations provided by the PEATS, it may seem hard to implement a system just by using it. However, these operations are powerful enough to solve any distributed computing problem [1], [2]. In a previous work [2], it was showed that the PEATS can be used to build BFT algorithms that are very efficient and almost as simple as crash fault-tolerant algorithms. In this paper we want to exploit this abstraction to build practical BFT services. To illustrate the effectiveness of our approach we present a set of algorithms to implement a LDAP-like Naming and Directory Service (NDS) using the PEATS abstraction. In order to do this, we start by defining a way to represent the directory tree structure using Tuples. Then, we develop directory service’s algorithms using only the PEATS’ operations presented before. 2. A PEATS-based Naming Service
-
depSpace a byzantine fault tolerant coordination service
European Conference on Computer Systems, 2008Co-Authors: Alysson Bessani, Eduardo Pelison Alchieri, Miguel Correia, Joni Da Silva FragaAbstract:The Tuple Space coordination model is one of the most interesting coordination models for open distributed systems due to its Space and time decoupling and its synchronization power. Several works have tried to improve the dependability of Tuple Spaces through the use of replication for fault tolerance and access control for security. However, many practical applications in the Internet require both fault tolerance and security. This paper describes the design and implementation of DepSpace, a Byzantine fault-tolerant coordination service that provides a Tuple Space abstraction. The service offered by DepSpace is secure, reliable and available as long as less than a third of service replicas are faulty. Moreover, the content-addressable confidentiality scheme developed for DepSpace bridges the gap between Byzantine fault-tolerant replication and confidentiality of replicated data and can be used in other systems that store critical data.
-
design and implementation of an intrusion tolerant Tuple Space
2007Co-Authors: Alysson Bessani, Eduardo Pelison Alchieri, Joni Da Silva Fraga, Lau Cheuk LungAbstract:The Tuple Space coordination model is one of the most interesting communication models for open distributed systems due to its Space and time decoupling and its synchronization power. Several works have tried to improve the dependability of Tuple Spaces. Some have made Tuple Spaces fault-tolerant while others have focused on security. However, many practical applications in the Internet require both these dimensions. This paper describes the design and implementation of DEPSpace, a dependable communication infrastructure based on the Tuple Space coordination model. DEPSpace is dependable in a strong sense of the word: it is secure, fault-tolerant and intrusion-tolerant, i.e. it behaves as expected even if some of the machines that implement it are successfully attacked. Moreover, it is a policy-enforced augmented Tuple Space, a shared memory object that we have recently proven to be universal, i.e., capable of implementing any other shared memory object.
-
bts a byzantine fault tolerant Tuple Space
ACM Symposium on Applied Computing, 2006Co-Authors: Alysson Bessani, Joni Da Silva Fraga, Lau Cheuk LungAbstract:Generative coordination is one of the most prominent coordination models for implementing open systems due to its spatial and temporal decoupling. Recently, a coordination community effort have been trying to integrate security mechanisms to this model aiming to improve its robustness. In this context, this paper presents the BTS coordination model, which provides a Byzantine fault-tolerant Tuple Space. Byzantine faults are commonly used to represent both process crashes and intrusions. As far as we know. BTS is the first coordination model that supports this dependability level.
Lau Cheuk Lung - One of the best experts on this subject based on the ideXlab platform.
-
on the practicality to implement byzantine fault tolerant services based on Tuple Space
Advanced Information Networking and Applications, 2014Co-Authors: Aldelir Fernando Luiz, Lau Cheuk Lung, Luciana RechAbstract:A major challenge of computer systems is making these more robust, reliable and secure. In recent years, it has been found that the state machine replication is one of the most common techniques for designing systems that need high reliability. This paper introduces a new architecture for replication of Byzantine fault tolerant service, based on the Tuple Space model. The proposed model requires only 2f+1 replicas for one service, and is generic enough to accommodate a different set of services at the same execution infrastructure. Use of Tuple Space supports communication and coordination, as well as a storage medium for sharing of data between service replicas. In addition, the paper also presents an experimental evaluation of some protocols for replication of Byzantine fault tolerant systems for practical purposes.
-
an efficient byzantine resilient Tuple Space
IEEE Transactions on Computers, 2009Co-Authors: Alysson Bessani, Miguel Correia, Joni Da Silva Fraga, Lau Cheuk LungAbstract:Open distributed systems are typically composed by an unknown number of processes running in heterogeneous hosts. Their communication often requires tolerance to temporary disconnections and security against malicious actions. Tuple Spaces are a well-known coordination model for this kind of systems. They can support communication that is decoupled both in time and Space. There are currently several implementations of distributed fault-tolerant Tuple Spaces but they are not Byzantine-resilient, i.e., they do not provide a correct service if some replicas are attacked and start to misbehave. This paper presents an efficient implementation of a linearizable Byzantine fault-tolerant Tuple Space (LBTS) that uses a novel Byzantine quorum systems replication technique in which most operations are implemented by quorum protocols while stronger operations are implemented by more expensive protocols based on consensus. LBTS is linearizable and wait-free, showing interesting performance gains when compared to a similar construction based on state machine replication.
-
design and implementation of an intrusion tolerant Tuple Space
2007Co-Authors: Alysson Bessani, Eduardo Pelison Alchieri, Joni Da Silva Fraga, Lau Cheuk LungAbstract:The Tuple Space coordination model is one of the most interesting communication models for open distributed systems due to its Space and time decoupling and its synchronization power. Several works have tried to improve the dependability of Tuple Spaces. Some have made Tuple Spaces fault-tolerant while others have focused on security. However, many practical applications in the Internet require both these dimensions. This paper describes the design and implementation of DEPSpace, a dependable communication infrastructure based on the Tuple Space coordination model. DEPSpace is dependable in a strong sense of the word: it is secure, fault-tolerant and intrusion-tolerant, i.e. it behaves as expected even if some of the machines that implement it are successfully attacked. Moreover, it is a policy-enforced augmented Tuple Space, a shared memory object that we have recently proven to be universal, i.e., capable of implementing any other shared memory object.
-
bts a byzantine fault tolerant Tuple Space
ACM Symposium on Applied Computing, 2006Co-Authors: Alysson Bessani, Joni Da Silva Fraga, Lau Cheuk LungAbstract:Generative coordination is one of the most prominent coordination models for implementing open systems due to its spatial and temporal decoupling. Recently, a coordination community effort have been trying to integrate security mechanisms to this model aiming to improve its robustness. In this context, this paper presents the BTS coordination model, which provides a Byzantine fault-tolerant Tuple Space. Byzantine faults are commonly used to represent both process crashes and intrusions. As far as we know. BTS is the first coordination model that supports this dependability level.
-
towards a dependable Tuple Space
2006Co-Authors: Alysson Bessani, Miguel Correia, Joni Da Silva Fraga, Lau Cheuk LungAbstract:The Tuple Space coordination model is one of the most interesting communication models for open distributed systems due to its Space and time decoupling and its synchronization power. Several works have tried to improve the dependability of Tuple Spaces. Some have made Tuple Spaces fault-tolerant, using mechanisms like replication and transactions. Others have put the emphasis on security, with mechanisms like access control and cryptography. However, many practical applications in the Internet require both these dimensions. This paper describes how a set of commercial off-the-shelf (COTS) Tuple Spaces can be used to implement a dependable (distributed) Tuple Space. This Tuple Space is dependable in a strong sense of the word: it is secure, fault-tolerant and intrusion-tolerant, i.e. it behaves as expected even if some of the machines that implement it are successfully attacked.
Joni Da Silva Fraga - One of the best experts on this subject based on the ideXlab platform.
-
an efficient byzantine resilient Tuple Space
IEEE Transactions on Computers, 2009Co-Authors: Alysson Bessani, Miguel Correia, Joni Da Silva Fraga, Lau Cheuk LungAbstract:Open distributed systems are typically composed by an unknown number of processes running in heterogeneous hosts. Their communication often requires tolerance to temporary disconnections and security against malicious actions. Tuple Spaces are a well-known coordination model for this kind of systems. They can support communication that is decoupled both in time and Space. There are currently several implementations of distributed fault-tolerant Tuple Spaces but they are not Byzantine-resilient, i.e., they do not provide a correct service if some replicas are attacked and start to misbehave. This paper presents an efficient implementation of a linearizable Byzantine fault-tolerant Tuple Space (LBTS) that uses a novel Byzantine quorum systems replication technique in which most operations are implemented by quorum protocols while stronger operations are implemented by more expensive protocols based on consensus. LBTS is linearizable and wait-free, showing interesting performance gains when compared to a similar construction based on state machine replication.
-
depSpace a byzantine fault tolerant coordination service
European Conference on Computer Systems, 2008Co-Authors: Alysson Bessani, Eduardo Pelison Alchieri, Miguel Correia, Joni Da Silva FragaAbstract:The Tuple Space coordination model is one of the most interesting coordination models for open distributed systems due to its Space and time decoupling and its synchronization power. Several works have tried to improve the dependability of Tuple Spaces through the use of replication for fault tolerance and access control for security. However, many practical applications in the Internet require both fault tolerance and security. This paper describes the design and implementation of DepSpace, a Byzantine fault-tolerant coordination service that provides a Tuple Space abstraction. The service offered by DepSpace is secure, reliable and available as long as less than a third of service replicas are faulty. Moreover, the content-addressable confidentiality scheme developed for DepSpace bridges the gap between Byzantine fault-tolerant replication and confidentiality of replicated data and can be used in other systems that store critical data.
-
design and implementation of an intrusion tolerant Tuple Space
2007Co-Authors: Alysson Bessani, Eduardo Pelison Alchieri, Joni Da Silva Fraga, Lau Cheuk LungAbstract:The Tuple Space coordination model is one of the most interesting communication models for open distributed systems due to its Space and time decoupling and its synchronization power. Several works have tried to improve the dependability of Tuple Spaces. Some have made Tuple Spaces fault-tolerant while others have focused on security. However, many practical applications in the Internet require both these dimensions. This paper describes the design and implementation of DEPSpace, a dependable communication infrastructure based on the Tuple Space coordination model. DEPSpace is dependable in a strong sense of the word: it is secure, fault-tolerant and intrusion-tolerant, i.e. it behaves as expected even if some of the machines that implement it are successfully attacked. Moreover, it is a policy-enforced augmented Tuple Space, a shared memory object that we have recently proven to be universal, i.e., capable of implementing any other shared memory object.
-
bts a byzantine fault tolerant Tuple Space
ACM Symposium on Applied Computing, 2006Co-Authors: Alysson Bessani, Joni Da Silva Fraga, Lau Cheuk LungAbstract:Generative coordination is one of the most prominent coordination models for implementing open systems due to its spatial and temporal decoupling. Recently, a coordination community effort have been trying to integrate security mechanisms to this model aiming to improve its robustness. In this context, this paper presents the BTS coordination model, which provides a Byzantine fault-tolerant Tuple Space. Byzantine faults are commonly used to represent both process crashes and intrusions. As far as we know. BTS is the first coordination model that supports this dependability level.
-
towards a dependable Tuple Space
2006Co-Authors: Alysson Bessani, Miguel Correia, Joni Da Silva Fraga, Lau Cheuk LungAbstract:The Tuple Space coordination model is one of the most interesting communication models for open distributed systems due to its Space and time decoupling and its synchronization power. Several works have tried to improve the dependability of Tuple Spaces. Some have made Tuple Spaces fault-tolerant, using mechanisms like replication and transactions. Others have put the emphasis on security, with mechanisms like access control and cryptography. However, many practical applications in the Internet require both these dimensions. This paper describes how a set of commercial off-the-shelf (COTS) Tuple Spaces can be used to implement a dependable (distributed) Tuple Space. This Tuple Space is dependable in a strong sense of the word: it is secure, fault-tolerant and intrusion-tolerant, i.e. it behaves as expected even if some of the machines that implement it are successfully attacked.
Sirio Capizzi - One of the best experts on this subject based on the ideXlab platform.
-
a Tuple Space service for large scale infrastructures
Workshops on Enabling Technologies: Infrastracture for Collaborative Enterprises, 2008Co-Authors: Sirio Capizzi, Antonio MessinaAbstract:Coordinating tasks is one of the main activities of every grid middleware. There are several ways to achieve this goal, for example using publish/subscribe systems or workflow engines. In this article we will analyse another possible model: Tuple Spaces. The Tuple Space model has been successfully used for years for coordinating tasks in computational applications and has interesting characteristics like the support to open systems, allowing an application to scale without the need to reimplement it. This article will describe our experience in developing a Tuple Space system for the Globus Toolkit using Web services.
-
grinda a Tuple Space service for the globus toolkit
International Conference on Algorithms and Architectures for Parallel Processing, 2008Co-Authors: Sirio Capizzi, Antonio MessinaAbstract:In this article we present a service for the Globus Toolkit that implements the Tuple Space model, allowing applications to use it to coordinate their activities.
-
a Tuple Space implementation for large scale infrastructures
2008Co-Authors: Sirio CapizziAbstract:Coordinating activities in a distributed system is an open research topic. Several models have been proposed to achieve this purpose such as message passing, publish/subscribe, workflows or Tuple Spaces. We have focused on the latter model, trying to overcome some of its disadvantages. In particular we have applied spatial database techniques to Tuple Spaces in order to increase their performance when handling a large number of Tuples. Moreover, we have studied how structured peer to peer approaches can be applied to better distribute Tuples on large networks. Using some of these result, we have developed a Tuple Space implementation for the Globus Toolkit that can be used by Grid applications as a coordination service. The development of such a service has been quite challenging due to the limitations imposed by XML serialization that have heavily influenced its design. Nevertheless, we were able to complete its implementation and use it to implement two different types of test applications: a completely parallelizable one and a plasma simulation that is not completely parallelizable. Using this last application we have compared the performance of our service against MPI. Finally, we have developed and tested a simple workflow in order to show the versatility of our service.
-
a Tuple Space implementation for large scale infrastructures phd thesis
2008Co-Authors: Sirio CapizziAbstract:Coordinating activities in a distributed system is an open research topic. Several models have been proposed to achieve this purpose such as message passing, publish/subscribe, workflows or Tuple Spaces. We have focused on the latter model, trying to overcome some of its disadvantages. In particular we have applied spatial database techniques to Tuple Spaces in order to increase their performance when handling a large number of Tuples. Moreover, we have studied how structured peer to peer approaches can be applied to better distribute Tuples on large networks. Using some of these result, we have developed a Tuple Space implementation for the Globus Toolkit that can be used by Grid applications as a coordination service. The development of such a service has been quite challenging due to the limitations imposed by XML serialization that have heavily influenced its design. Nevertheless, we were able to complete its implementation and use it to implement two different types of test applications: a completely parallelizable one and a plasma simulation that is not completely parallelizable. Using this last application we have compared the performance of our service against MPI. Finally we have developed and tested a simple workflow in order to show the versatility of our service.
