Kite: Efficient and Available Release Consistency for the Datacenter KeyValue Stores (KVSs) came into prominence as highlyavailable, eventually consistent (EC), NoSQLu0027u0027 Databases, but have quickly transformed into generalpurpose, programmable storage systems. Thus, EC, while relevant, is no longer sufficient. Complying with the emerging requirements for stronger consistency, researchers have proposed KVSs with multiple consistency levels (MCL) that expose the consistencyperformance tradeoff to the programmer. We argue that this approach falls short in both programmability and performance. For instance, the MCL APIs proposed thus far, fail to capture the ordering relationship between strongly and weaklyconsistent accesses that naturally occur in programs.NTaking inspiration from shared memory, we advocate Release Consistency (RC) for KVSs.  We argue that RCxe2x80x99s onesided barriers are ideal for capturing the ordering relationship between synchronization and nonsynchronization accesses while enabling highperformance.NWe present Kite, the first highlyavailable, replicated KVS that offers a linearizable variant of RC for the asynchronous setting with individual process and network failures. Kite enforces RC barriers through a novel fastslow path mechanism that leverages the absence of failures in the typical case to maximize performance while relying on the slow path for progress. Our evaluation shows that the RDMAenabled and heavilymultithreaded Kite achieves orders of magnitude better performance than Derecho (a stateoftheart RMDAenabled state machine replication system) and significantly outperforms ZAB (the protocol at the heart of Zookeeper). We demonstrate the efficacy of Kite by porting three lockfree shared memory data structures, and showing that Kite outperforms the competition.NVasilis GavrielatosThe University of EdinburghAntonios KatsarakisUniversity of Edinburgh, UKUni

Using Weaker Consistency Models with Monitoring and Recovery for Improving Performance of KeyValue Stores Limitations of the CAP theorem imply that if availability is desired in the presence of faults xe2x80x93 especially that create network partitions (or substantial delays), one must sacrifice sequential consistency, a consistency model that is more natural for system design. We focus on the problem of what a designer should do if heshe has an algorithm that works correctly with sequential consistency but is faced with an underlying keyvalue store that provides a weaker (e.g., eventual or causal) consistency. We propose a detectrollback based approach: The designer identifies a correctness predicate, say P, and continues to run the protocol, as our system monitors P. If P is violated (because the underlying keyvalue store provides a weaker consistency), the system rolls back and resumes the computation at a state where P holds. We evaluate this approach with practical graph applications running on the Voldemort keyvalue store. Our experiments, deployed on Amazon AWS EC2 instances, show that using eventual consistency with monitoring can provide a 50 xe2x80x93 80% increase in throughput when compared with sequential consistency. We also show that the overhead of the monitoring itself is low (typically less than 4%) and the latency of detecting violations is small. In particular, more than 99.9% of violations are detected in less than 50 milliseconds in regional AWS networks, and in less than 5 seconds in global AWS networks. In turn, this makes it possible to provide efficient recovery from such faults with a minimal amount of work wasted due to rollbacks.