| 1. |
|
|
| 2. |
|
|
| 3. |
- Arad, Cosmin, et al.
(författare)
-
Building and Evaluating P2P Systems using the Kompics Component Framework
- 2009
-
Ingår i: 2009 IEEE NINTH INTERNATIONAL CONFERENCE ON PEER-TO-PEER COMPUTING (P2P 2009). - NEW YORK : IEEE. - 9781424450664 ; , s. 93-94
-
Konferensbidrag (refereegranskat)abstract
- We present a framework for building and evaluating P2P systems in simulation, local execution, and distributed deployment. Such uniform system evaluations increase confidence in the obtained results. We briefly introduce the Kompics component model and its P2P framework. We describe the component architecture of a Kompics P2P system and show how to define experiment scenarios for large dynamic systems. The same experiments are conducted in reproducible simulation, in real-time execution on a single machine, and distributed over a local cluster or a wide area network. This demonstration shows the component oriented design and the evaluation of two P2P systems implemented in Kompics: Chord and Cyclon. We simulate the systems and then we execute them in real time. During real-time execution we monitor the dynamic behavior of the systems and interact with them through their web-based interfaces. We demonstrate how component-oriented design enables seamless switching between alternative protocols.
|
|
| 4. |
- Arad, Cosmin, et al.
(författare)
-
CATS: linearizability and partition tolerance in scalable and self-organizing key-value stores
- 2012. - 7
-
Rapport (övrigt vetenskapligt/konstnärligt)abstract
- Distributed key-value stores provide scalable, fault-tolerant, and self-organizing storage services, but fall short of guaranteeing linearizable consistency in partially synchronous, lossy, partitionable, and dynamic networks, when data is distributed and replicated automatically by the principle of consistent hashing. This paper introduces consistent quorums as a solution for achieving atomic consistency. We present the design and implementation of CATS, a distributed key-value store which uses consistent quorums to guarantee linearizability and partition tolerance in such adverse and dynamic network conditions. CATS is scalable, elastic, and self-organizing; key properties for modern cloud storage middleware. Our system shows that consistency can be achieved with practical performance and modest throughput overhead (5%) for read-intensive workloads.
|
|
| 5. |
- Arad, Cosmin, et al.
(författare)
-
GODS: Global Observatory for Distributed Systems
- 2007. - 1
-
Rapport (övrigt vetenskapligt/konstnärligt)abstract
- We propose GODS, an ecosystem for the evaluation and study of world-wide distributed and dynamic systems under a realistic emulated network environment. GODS allows the evaluation of a system's actual implementation in reproducible experiments, collecting global knowledge about the system state. Furthermore, GODS addresses the problems of debugging distributed algorithms, performance tuning, measuring bandwidth consumption, regression testing, and benchmarking similar systems, thus offering a complete evaluation environment for distributed applications. Our framework uses ModelNet for the network emulation and enhances that by (1) adding dynamism by varying link properties, partitioning the network and emulating churn, (2) offering global knowledge about the observed system by gathering statistics and events and (3) enabling the user to easily deploy, manage and monitor complex, large-scale distributed systems.
|
|
| 6. |
- Arad, Cosmin Ionel, 1981-
(författare)
-
Programming Model and Protocols for Reconfigurable Distributed Systems
- 2013
-
Doktorsavhandling (övrigt vetenskapligt/konstnärligt)abstract
- Distributed systems are everywhere. From large datacenters to mobile devices, an ever richer assortment of applications and services relies on distributed systems, infrastructure, and protocols. Despite their ubiquity, testing and debugging distributed systems remains notoriously hard. Moreover, aside from inherent design challenges posed by partial failure, concurrency, or asynchrony, there remain significant challenges in the implementation of distributed systems. These programming challenges stem from the increasing complexity of the concurrent activities and reactive behaviors in a distributed system on the one hand, and the need to effectively leverage the parallelism offered by modern multi-core hardware, on the other hand.This thesis contributes Kompics, a programming model designed to alleviate some of these challenges. Kompics is a component model and programming framework for building distributed systems by composing message-passing concurrent components. Systems built with Kompics leverage multi-core machines out of the box, and they can be dynamically reconfigured to support hot software upgrades. A simulation framework enables deterministic execution replay for debugging, testing, and reproducible behavior evaluation for largescale Kompics distributed systems. The same system code is used for both simulation and production deployment, greatly simplifying the system development, testing, and debugging cycle.We highlight the architectural patterns and abstractions facilitated by Kompics through a case study of a non-trivial distributed key-value storage system. CATS is a scalable, fault-tolerant, elastic, and self-managing key-value store which trades off service availability for guarantees of atomic data consistency and tolerance to network partitions. We present the composition architecture for the numerous protocols employed by the CATS system, as well as our methodology for testing the correctness of key CATS algorithms using the Kompics simulation framework.Results from a comprehensive performance evaluation attest that CATS achieves its claimed properties and delivers a level of performance competitive with similar systems which provide only weaker consistency guarantees. More importantly, this testifies that Kompics admits efficient system implementations. Its use as a teaching framework as well as its use for rapid prototyping, development, and evaluation of a myriad of scalable distributed systems, both within and outside our research group, confirm the practicality of Kompics.
|
|
| 7. |
- Arad, Cosmin, et al.
(författare)
-
Kompics: a message-passing component model for building distributed systems
- 2010. - 7
-
Rapport (övrigt vetenskapligt/konstnärligt)abstract
- The Kompics component model and programming framework was designedto simplify the development of increasingly complex distributed systems. Systems built with Kompics leverage multi-core machines out of the box and they can be dynamically reconfigured to support hot software upgrades. A simulation framework enables deterministic debugging and reproducible performance evaluation of unmodified Kompics distributed systems. We describe the component model and show how to program and compose event-based distributed systems. We present the architectural patterns and abstractions that Kompics facilitates and we highlight a case study of a complex distributed middleware that we have built with Kompics. We show how our approach enables systematic development and evaluation of large-scale and dynamic distributed systems.
|
|
| 8. |
- Arad, Cosmin, et al.
(författare)
-
Message-Passing Concurrency for Scalable, Stateful, Reconfigurable Middleware
- 2012
-
Ingår i: Middleware 2012. - Berlin, Heidelberg : Springer Berlin/Heidelberg. - 9783642351693 ; , s. 208-228
-
Konferensbidrag (refereegranskat)abstract
- Message-passing concurrency (MPC) is increasingly being used to build systems software that scales well on multi-core hardware. Functional programming implementations of MPC, such as Erlang, have also leveraged their stateless nature to build middleware that is not just scalable, but also dynamically reconfigurable. However, many middleware platforms lend themselves more naturally to a stateful programming model, supporting session and application state. A limitation of existing programming models and frameworks that support dynamic reconfiguration for stateful middleware, such as component frameworks, is that they are not designed for MPC.In this paper, we present Kompics, a component model and programming framework, that supports the construction and composition of dynamically reconfigurable middleware using stateful, concurrent, message-passing components. An added benefit of our approach is that by decoupling our component execution model, we can run the same code in both simulation and production environments. We present the architectural patterns and abstractions that Kompics facilitates and we evaluate them using a case study of a non-trivial key-value store that we built using Kompics. We show how our model enables the systematic development and testing of scalable, dynamically reconfigurable middleware.
|
|
| 9. |
- Arad, Cosmin, et al.
(författare)
-
Practical Protocol Composition, Encapsulation and Sharing in Kompics
- 2008
-
Ingår i: SASOW 2008. - LOS ALAMITOS : IEEE COMPUTER SOC. - 9781424434688 ; , s. 266-271
-
Konferensbidrag (refereegranskat)abstract
- At the core of any distributed system is a set of concurrent distributed algorithms that coordinate the functionality of the distributed system. We present a software architecture, Kompics that is component-based and compositional which facilitates building distributed protocols. The underlying computation model subsumes that of event-based systems, SEDA (staged event-driven architecture.) and thread-based models. We illustrate various salient features of Kompics such as ease of use, compositionality and configurability through a series of well chosen distributed protocols.
|
|
| 10. |
- Bordencea, D., et al.
(författare)
-
Efficient linearizable write operations using bounded global time uncertainty
- 2013
-
Ingår i: Proceedings - 2013 IEEE 12th International Symposium on Parallel and Distributed Computing, ISPDC 2013. - : IEEE. - 9780769550183 ; , s. 59-66
-
Konferensbidrag (refereegranskat)abstract
- Distributed key-value stores employed in data centers treat each key-value pair as a shared memory register. For fault-tolerance and performance, each key-value pair is replicated. Various models exist for the consistency of data amongst the replicas. While atomic consistency, also known as linearizability, provides the strongest form of consistency for read and write operations, various key-value stores, such as Cassandra, and Dynamo, offer only eventual consistency instead. One main motivation for such a decision is performance degradation when guaranteeing atomic consistency. In this paper, we use time with known bounded uncertainty to improve the performance of write operations, while maintaining atomic consistency. We show how to use the concept of commit wait in a shared memory register to perform a write operation in one phase (message round trip), instead of two. We evaluate the solution experimentally by comparing it to ABD, a well-known algorithm for achieving atomic consistency in an asynchronous network, which uses two phases for write operations. We also compare our protocol to an eventually consistent register. Our experiments show an improved throughput, and lower write latency, compared to the ABD algorithm.
|
|
| 11. |
- Haridi, Seif, 1953-, et al.
(författare)
-
Developing, simulating, and deploying peer-to-peer systems using the Kompics component model
- 2009
-
Ingår i: Proceedings of the 4th International Conference on COMmunication System softWAre and MiddlewaRE. - New York, NY, USA : ACM. - 9781605583532
-
Konferensbidrag (refereegranskat)abstract
- Currently, the development of overlay network systems typically produces two software artifacts: a simulator to model key protocols and a production system for a WAN environment. However, this methodology requires the maintenance of two implementations, as well as adding both development overhead and the potential for errors, through divergence in the different code bases. This paper describes how our message-passing component model, called Kompics, is used to build overlay network systems using a P2P component framework, where the same implementation can be simulated or deployed in a production environment. Kompics enables two different modes of simulation: deterministic simulation for reproducible debugging, and emulation mode for stress-testing systems. We used our P2P component framework to build and evaluate overlay systems, and we show how our model lowers the programming barrier for simulating and deploying overlay network systems.
|
|
| 12. |
- Haridi, Seif, 1953-, et al.
(författare)
-
Self-Distributing Software Updates through Epidemic Dissemination
- 2010
-
Ingår i: Proceedings - 2010 4th IEEE International Conference on Self-Adaptive and Self-Organizing Systems Workshop, SASOW 2010. - 9781424486847 ; , s. 243-246
-
Konferensbidrag (refereegranskat)abstract
- Peer-to-peer systems have recently received tremendous amount of popularity in both research and commercial endeavors. This paper argues for the systematic exploration of a hybrid of centralized and peer-to-peer system design. We give an example application of peer-to-peer architecture to an inherently centralized service and show how this application raises an interesting research question in the field of epidemic information dissemination. We propose a previously unexplored push mechanism for the distribution of updates for system software that exists in millions of copies.
|
|
| 13. |
- Roverso, Roberto, et al.
(författare)
-
DKS : Distributed k-ary system a middleware for building large scale dynamic distributed applications
- 2008
-
Ingår i: MAKING GRIDS WORK. - NEW YORK : SPRINGER. - 9780387784472 ; , s. 323-335
-
Konferensbidrag (refereegranskat)abstract
- This report presents the design and implementation of a middleware for building large-scale, dynamic, and self-organizing distributed applications for the Internet. First, we identify the challenges that are faced when building this type of applications and the constraints imposed on the middleware that is to support them. We derive a set of essential services that are to be provided by our middleware in order to facilitate the development of distributed applications. These services include scalable communication, failure detection, name-based overlay routing, group communication and a distributed hash table abstraction. We present the event-based component-oriented architecture of the system, discussing the design choices that we made in order to meet the aforementioned challenges and constraints while providing the essential services for distributed applications. We describe in detail the event scheduling mechanism, the communication and failure detection, as well as the interface to applications and other miscellaneous services.
|
|
