  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.
