3 research outputs found
Byzantine Lattice Agreement in Synchronous Systems
In this paper, we study the Byzantine lattice agreement problem in
synchronous systems. The lattice agreement problem in crash failure model has
been studied both in synchronous and asynchronous systems, which leads to the
current best upper bound of rounds in both systems. However, very
few algorithmic results are known for the lattice agreement problem in
Byzantine failure model. The paper [Nowak et al., DISC, 2019] first gives an
algorithm for a variant of the lattice agreement problem on cycle-free lattices
that tolerates up to Byzantine faults, where is the
number of processes and is the height of the input lattice . The
recent preprint by Di et al. studies this problem with a slightly modified
validity condition in asynchronous systems. They present a rounds
algorithm by using the reliable broadcast primitive as a first step and
following the similar algorithmic framework as the algorithms in crash failure
model.
In this paper, we propose three algorithms for the Byzantine lattice
agreement problem in synchronous systems. The first algorithm takes rounds and
messages, where is the height of the input lattice , is the total
number of processes. The second algorithm runs in rounds and
takes messages. The third algorithm takes rounds
and takes messages. All algorithms can tolerate up to Byzantine failures
Amortized Constant Round Atomic Snapshot in Message-Passing Systems
We study the lattice agreement (LA) and atomic snapshot problems in
asynchronous message-passing systems where up to nodes may crash. Our main
result is a crash-tolerant atomic snapshot algorithm with \textit{amortized
constant round complexity}. To the best of our knowledge, the best prior result
is given by Delporte et al. [TPDS, 18] with amortized complexity if
there are more scans than updates. Our algorithm achieves amortized constant
round if there are operations, where is the number of
actual failures in an execution and is bounded by . Moreover, when there is
no failure, our algorithm has round complexity unconditionally. To
achieve amortized constant round complexity, we devise a simple
\textit{early-stopping} lattice agreement algorithm and use it to "order" the
update and scan operations for our snapshot object. Our LA algorithm has
round complexity. It is the first early-stopping LA algorithm in
asynchronous systems
Transactions on Red-black and AVL trees in NVRAM
Byte-addressable non-volatile memory (NVRAM) supports persistent storage with
low latency and high bandwidth. Complex data structures in it ought to be
updated transactionally, so that they remain recoverable at all times.
Traditional database technologies such as keeping a separate log, a journal, or
shadow data work on a coarse-grained level, where the whole transaction is made
visible using a final atomic update operation. These methods typically need
significant additional space overhead and induce non-trivial overhead for log
pruning, state maintenance, and resource (de-)allocation. Thus, they are not
necessarily the best choice for NVRAM, which supports fine-grained,
byte-addressable access.
We present a generic transaction mechanism to update dynamic complex data
structures `in-place' with a constant memory overhead. It is independent of the
size of the data structure. We demonstrate and evaluate our approach on
Red-Black Trees and AVL Trees with a redo log of constant size (4 resp. 2 cache
lines). The redo log guarantees that each accepted (started) transaction is
executed eventually despite arbitrary many system crashes and recoveries in the
meantime. We update complex data structures in local and remote NVRAM providing
exactly once semantics and durable linearizability for multi-reader
single-writer access. To persist data, we use the available processor
instructions for NVRAM in the local case and remote direct memory access (RDMA)
combined with a software agent in the remote case