Xiaozhou Li

Analyzing consistency properties for fun and profit

Motivated by the increasing popularity of eventually consistent key-value stores as a commercial service, we address two important problems related to the consistency properties in a history of operations on a read/write register (i.e., the start time, finish time, argument, and response of every operation). First, we consider how to detect a consistency violation as soon as one happens. To this end, we formulate a specification for online verification algorithms, and we present such algorithms for several well-known consistency properties. Second, we consider how to quantify the severity of the violations, if a history is found to contain consistency violations. We investigate two quantities: one is the staleness of the reads, and the other is the commonality of violations. For staleness, we further consider time-based staleness and operation-count-based staleness. We present efficient algorithms that compute these quantities. We believe that addressing these problems helps both key-value store providers and users adopt data consistency as an important aspect of key-value store offerings.

Active and Concurrent Topology Maintenance

A central problem for structured peer-to-peer networks is topology maintenance, that is, how to properly update neighbor variables when nodes join and leave the network, possibly concurrently. In this paper, we first present a protocol that maintains a ring, the basis of several structured peer-to-peer networks. We then present a protocol that maintains Ranch, a topology consisting of multiple rings. The protocols handle both joins and leaves concurrently and actively (i.e., neighbor variables are updated once a join or a leave occurs). We use an assertional method to prove the correctness of the protocols, that is, we first identify a global invariant for a protocol and then show that every action of the protocol preserves the invariant. The protocols are simple and the proofs are rigorous and explicit.

On name resolution in peer-to-peer networks

An efficient name resolution scheme is the cornerstone of any peer-to-peer network. The name resolution scheme proposed by Plaxton, Rajaraman, and Richa, which we hereafter refer to as the PRR scheme, is a scalable name resolution scheme that also provides provable locality properties. However, since PRR goes to extra lengths to provide these locality properties, it is somewhat complicated. In this paper, we propose a scalable, locality-aware, and fault-tolerant name resolution scheme which can be considered a simplified version of PRR. Although this new scheme does not provide as strong locality guarantees as PRR, it exploits locality heuristically yet effectively.

Concurrent maintenance of rings

A central problem for structured peer-to-peer networks is topology maintenance, that is, how to properly update neighbor variables when nodes join or leave the network, possibly concurrently. In this paper, we consider the maintenance of the ring topology, the basisof several peer-to-peer networks, in the fault-free environment. We design, and prove the correctness of, protocols that maintain a bidirectional ring under both joins and leaves. Our protocols update neighbor variables once a membership change occurs. We prove the correctness of our protocols using an assertional proof method, that is, we first identify a global invariant for a protocol and then show that every action of the protocol preserves the invariant. Our protocols are simple and our proofs are rigorous and explicit.

Brief announcement: concurrent maintenance of rings

A central problem for structured peer-to-peer networks is topology maintenance, that is, how to properly update neighbor variables when membership changes (i.e., nodes join or leave the network, possibly concurrently). Depending on whether neighbor variables are immediately updated once membership changes occur, there are two general approaches to topology maintenance: the passive approach and the active approach. Existing work on the active approach has several shortcomings: the protocols cannot handle both joins and leaves actively; the protocols are complicated; the correctness proofs are operational and sketched at a high level. It is well known, however, that concurrent programs often contain subtle errors and operational reasoning is unreliable for proving their correctness. In this work, we address the maintenance of the ring topology, the basis of several peer-to-peer networks, in the fault-free environment. We design, and prove the correctness of, protocols that actively maintain a bidirectional ring under both joins and leaves. Using an assertional proof method, we prove the correctness of a protocol by developing a global invariant and showing that every action of the protocol preserves the invariant. We show that, although the ring topology may be tentatively disrupted during membership changes, the protocols restore the ring topology once membership changes subside or all the messages associated with membership changes are delivered. The protocols are based on an asynchronous communication model where only reliable delivery is assumed. To illustrate our approach, we show in Figure 1 a join protocol for a unidirectional ring. The protocol is written as a collection of actions. We assume without loss of generality that the actions are atomic, and we reason about the system state between actions. In the protocol, the contact () function returns an arbitrary non-out process if there is one, and returns the calling process otherwise. Our global invariant identifies a secondary ring structure that is preserved by every action. We then design a protocol that maintains a bidirectional ring under both joins and leaves. Our approach is to first design a join

On the k-Atomicity-Verification Problem

Modern Internet-scale storage systems often provide weak consistency in exchange for better performance and resilience. An important weak consistency property is k-atomicity, which bounds the staleness of values returned by read operations. The k-atomicity-verification problem (or k-AV for short) is the problem of deciding whether a given history of operations is k-atomic. The 1-AV problem is equivalent to verifying atomicity/linearizability, a well-known and solved problem. However, for k ≥ 2, no polynomial-time k-AV algorithm is known. This paper makes the following contributions towards solving the k-AV problem. First, we present a simple 2-AV algorithm called LBT, which is likely to be efficient (quasilinear) for histories that arise in practice, although it is less efficient (quadratic) in the worst case. Second, we present a more involved 2-AV algorithm called FZF, which runs efficiently (quasilinear) even in the worst case. To our knowledge, these are the first algorithms that solve the 2-AV problem fully. Third, we show that the weighted k-AV problem, a natural extension of the k-AV problem, is NP-complete.

Maintaining the Ranch topology

Topology maintenance, or how to handle the possibly concurrent joining and leaving of nodes, is a central problem for structured peer-to-peer networks. A good topology maintenance protocol should run efficiently, fully maintain the topology, and should not unduly restrict concurrency. In this paper, we present such a protocol for a multi-ring topology called Ranch. The protocol is efficient: for each join or leave, it uses a logarithmic number of messages with high probability. The protocol fully maintains Ranch after joins and leaves, and allows for a high degree of concurrency. To our knowledge, this is the first maintenance protocol that enjoys all of these properties for a structured peer-to-peer network topology.

Online hierarchical cooperative caching

We address a hierarchical generalization of the well-known disk paging problem. In the hierarchical cooperative caching problem, a set of n machines residing in an ultrametric space cooperate with one another to satisfy a sequence of read requests to a collection of (read-only) files. A seminal result in the area of competitive analysis states that LRU (the widely-used deterministic online paging algorithm based on the least recently used eviction policy) is constant-competitive if it is given a constant-factor blowup in capacity over the offline algorithm. Does such a constant-competitive deterministic algorithm (with a constant-factor blowup in the machine capacities) exist for the hierarchical cooperative caching problem? The main contribution of the present paper is to answer this question in the negative. More specifically, we establish an Ω(log log n) lower bound on the competitive ratio of any online hierarchical cooperative caching algorithm with capacity blowup O((log n)1-e), where e denotes an arbitrarily small positive constant.