  Concurrent linearizable access to shared objects can be prohibitively
expensive in a high contention workload. Many applications apply ad-hoc
techniques to eliminate the need of synchronous atomic updates, which may
result in non-linearizable implementations. We propose a new programming model
which leverages such patterns for concurrent access to objects in a shared
memory system. In this model, each thread maintains different views on the
shared object - a thread-local view and a global view. As the thread-local view
is not shared, it can be updated without incurring synchronization costs. These
local updates become visible to other threads only after the thread-local view
is merged with the global view. This enables better performance at the expense
of linearizability. We show that it is possible to maintain thread-local views
and to perform merge efficiently for several data types and evaluate their
performance and scalability compared to linearizable implementations. Further,
we discuss the consistency semantics of the data types and the associated
programming model.
