515 research outputs found
Let It TEE: Asynchronous Byzantine Atomic Broadcast with n ≥ 2f + 1
Asynchronous Byzantine Atomic Broadcast (ABAB) promises, in comparison to partially synchronous approaches, simplicity in implementation, increased performance, and increased robustness. For partially synchronous approaches, it is well-known that small Trusted Execution Environments (TEE), e.g., MinBFT\u27s unique sequential identifier generator (USIG), are capable of reducing the communication effort while increasing the fault tolerance. For ABAB, the research community assumes that the use of TEEs increases performance and robustness. However, despite the existence of a fault-model compiler, a concrete TEE-based approach is not directly available yet. In this brief announcement, we show that the recently proposed DAG-Rider approach can be transformed to provide ABAB with processes, of which are faulty. We leverage MinBFT\u27s USIG to implement Reliable Broadcast with processes and show that the quorum-critical proofs of DAG-Rider still hold when adapting the quorum size to
A Lossy, Synchronization-Free, Race-Full, But Still Acceptably Accurate Parallel Space-Subdivision Tree Construction Algorithm
We present a new synchronization-free space-subdivision tree construction algorithm. Despite data races, this algorithm produces trees that are consistent enough for the client Barnes-Hut center of mass and force computation phases to use successfully. Our performance results show that eliminating synchronization improves the performance of the parallel algorithm by approximately 20%. End-to-end accuracy results show that the resulting partial data structure corruption has a neglible effect on the overall accuracy of the Barnes-Hut N-body simulation. We note that many data structure manipulation algorithms use many of the same basic operations (linked data structure updates and array insertions) as our tree construction algorithm. We therefore anticipate that the basic principles the we develop in this paper may effectively guide future efforts in this area
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
O2-tree: a shared memory resident index in multicore architectures
Shared memory multicore computer architectures are now commonplace in computing.
These can be found in modern desktops and workstation computers and also in High
Performance Computing (HPC) systems. Recent advances in memory architecture and
in 64-bit addressing, allow such systems to have memory sizes of the order of hundreds of
gigabytes and beyond. This now allows for realistic development of main memory resident
database systems. This still requires the use of a memory resident index such as T-Tree,
and the B+-Tree for fast access to the data items.
This thesis proposes a new indexing structure, called the O2-Tree, which is essentially
an augmented Red-Black Tree in which the leaf nodes are index data blocks that store
multiple pairs of key and value referred to as \key-value" pairs. The value is either the
entire record associated with the key or a pointer to the location of the record. The
internal nodes contain copies of the keys that split blocks of the leaf nodes in a manner
similar to the B+-Tree. O2-Tree structure has the advantage that: it can be easily
reconstructed by reading only the lowest value of the key of each leaf node page. The size
is su ciently small and thus can be dumped and restored much faster.
Analysis and comparative experimental study show that the performance of the O2-Tree
is superior to other tree-based index structures with respect to various query operations
for large datasets. We also present results which indicate that the O2-Tree outperforms
popular key-value stores such as BerkelyDB and TreeDB of Kyoto Cabinet for various
workloads. The thesis addresses various concurrent access techniques for the O2-Tree for
shared memory multicore architecture and gives analysis of the O2-Tree with respect to
query operations, storage utilization, failover and recovery
Brief Announcement: Let It TEE: Asynchronous Byzantine Atomic Broadcast with n ≥ 2f+1
Asynchronous Byzantine Atomic Broadcast (ABAB) promises simplicity in implementation as well as increased performance and robustness in comparison to partially synchronous approaches. We adapt the recently proposed DAG-Rider approach to achieve ABAB with n ≥ 2f+1 processes, of which f are faulty, with only a constant increase in message size. We leverage a small Trusted Execution Environment (TEE) that provides a unique sequential identifier generator (USIG) to implement Reliable Broadcast with n > f processes and show that the quorum-critical proofs still hold when adapting the quorum size to ⌊ n/2 ⌋ + 1. This first USIG-based ABAB preserves the simplicity of DAG-Rider and serves as starting point for further research on TEE-based ABAB
Algorithm Diversity for Resilient Systems
Diversity can significantly increase the resilience of systems, by reducing
the prevalence of shared vulnerabilities and making vulnerabilities harder to
exploit. Work on software diversity for security typically creates variants of
a program using low-level code transformations. This paper is the first to
study algorithm diversity for resilience. We first describe how a method based
on high-level invariants and systematic incrementalization can be used to
create algorithm variants. Executing multiple variants in parallel and
comparing their outputs provides greater resilience than executing one variant.
To prevent different parallel schedules from causing variants' behaviors to
diverge, we present a synchronized execution algorithm for DistAlgo, an
extension of Python for high-level, precise, executable specifications of
distributed algorithms. We propose static and dynamic metrics for measuring
diversity. An experimental evaluation of algorithm diversity combined with
implementation-level diversity for several sequential algorithms and
distributed algorithms shows the benefits of algorithm diversity
- …