34,227 research outputs found
ARES: Adaptive, Reconfigurable, Erasure coded, atomic Storage
Atomicity or strong consistency is one of the fundamental, most intuitive,
and hardest to provide primitives in distributed shared memory emulations. To
ensure survivability, scalability, and availability of a storage service in the
presence of failures, traditional approaches for atomic memory emulation, in
message passing environments, replicate the objects across multiple servers.
Compared to replication based algorithms, erasure code-based atomic memory
algorithms has much lower storage and communication costs, but usually, they
are harder to design. The difficulty of designing atomic memory algorithms
further grows, when the set of servers may be changed to ensure survivability
of the service over software and hardware upgrades, while avoiding service
interruptions. Atomic memory algorithms for performing server reconfiguration,
in the replicated systems, are very few, complex, and are still part of an
active area of research; reconfigurations of erasure-code based algorithms are
non-existent.
In this work, we present ARES, an algorithmic framework that allows
reconfiguration of the underlying servers, and is particularly suitable for
erasure-code based algorithms emulating atomic objects. ARES introduces new
configurations while keeping the service available. To use with ARES we also
propose a new, and to our knowledge, the first two-round erasure code based
algorithm TREAS, for emulating multi-writer, multi-reader (MWMR) atomic objects
in asynchronous, message-passing environments, with near-optimal communication
and storage costs. Our algorithms can tolerate crash failures of any client and
some fraction of servers, and yet, guarantee safety and liveness property.
Moreover, by bringing together the advantages of ARES and TREAS, we propose an
optimized algorithm where new configurations can be installed without the
objects values passing through the reconfiguration clients
CATS: linearizability and partition tolerance in scalable and self-organizing key-value stores
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
Reconfigurable Lattice Agreement and Applications
Reconfiguration is one of the central mechanisms in distributed systems. Due to failures and connectivity disruptions, the very set of service replicas (or servers) and their roles in the computation may have to be reconfigured over time. To provide the desired level of consistency and availability to applications running on top of these servers, the clients of the service should be able to reach some form of agreement on the system configuration. We observe that this agreement is naturally captured via a lattice partial order on the system states. We propose an asynchronous implementation of reconfigurable lattice agreement that implies elegant reconfigurable versions of a large class of lattice abstract data types, such as max-registers and conflict detectors, as well as popular distributed programming abstractions, such as atomic snapshot and commit-adopt
Atomic commitment in transactional DHTs
We investigate the problem of atomic commit in transactional database systems
built on top of Distributed Hash Tables. DHTs provide a decentralized way to
store and look up data. To solve the atomic commit problem we propose to
use an adaption of Paxos commit as a non-blocking algorithm. We exploit the
symmetric replication technique existing in the DKS DHT to determine which
nodes are necessary to execute the commit algorithm. By doing so we achieve a
lower number of communication rounds and a reduction of meta-data in contrast
to traditional Three-Phase-Commit protocols. We also show how the proposed
solution can cope with dynamism due to churn in DHTs. Our solution works
correctly relying only on an inaccurate failure detection of node failure which is
necessary for systems running over the Internet
Enhanced Failure Detection Mechanism in MapReduce
The popularity of MapReduce programming model has increased interest in the research community for its improvement. Among the other directions, the point of fault tolerance, concretely the failure detection issue seems to be a crucial one, but that until now has not reached its satisfying level. Motivated by this, I decided to devote my main research during this period into having a prototype system architecture of MapReduce framework with a new failure detection service, containing both analytical (theoretical) and implementation part. I am confident that this work should lead the way for further contributions in detecting failures to any NoSQL App frameworks, and cloud storage systems in general
- …