Parameterized algorithm for replicated objects with local reads

We consider the problem of implementing linearizable objects that support both read and read-modify-write (RMW) operations in message-passing systems with process crashes. Since in many systems read operations vastly outnumber RMW operations, we are interested in implementations that emphasize the efficiency of read operations. We present a parametrized algorithm for partially synchronous systems where processes have access to external clocks that are synchronized within $\epsilon$. With this algorithm, every read operation is local (intuitively, it does not trigger messages). If a read is not concurrent with a conflicting RMW, it is performed immediately with no waiting; furthermore, even with a concurrent conflicting RMW, a read experiences very little delay in the worst-case. For example, the algorithm's parameters can be set to ensure that every read takes $\epsilon$ time in the worst-case. To the best of our knowledge this is the first algorithm to achieve this bound in the partially synchronous systems that we assume here. Our parametrized algorithm generalizes the (non-parameterized) lease-based algorithm of Chandra et al. [6] where the worst-case time for reads is $3\delta$, where $\delta$ is the maximum message delay. The algorithm's parameters can be used to trade-off the worst-case times for read and RMW operations. They can also be used to take advantage of the fact that in many message-passing systems the delay of most messages is order of magnitudes smaller than the maximum message delay~$\delta$: for example, the parameters can be set so that, in "nice" periods where message delays are $\delta^* \ll \delta$, reads take at most $\epsilon$ time while RMWs take at most $3 \delta^*$ time.