  This paper considers the modeling and the analysis of the performance of
lock-free concurrent data structures. Lock-free designs employ an optimistic
conflict control mechanism, allowing several processes to access the shared
data object at the same time. They guarantee that at least one concurrent
operation finishes in a finite number of its own steps regardless of the state
of the operations. Our analysis considers such lock-free data structures that
can be represented as linear combinations of fixed size retry loops. Our main
contribution is a new way of modeling and analyzing a general class of
lock-free algorithms, achieving predictions of throughput that are close to
what we observe in practice. We emphasize two kinds of conflicts that shape the
performance: (i) hardware conflicts, due to concurrent calls to atomic
primitives; (ii) logical conflicts, caused by simultaneous operations on the
shared data structure. We show how to deal with these hardware and logical
conflicts separately, and how to combine them, so as to calculate the
throughput of lock-free algorithms. We propose also a common framework that
enables a fair comparison between lock-free implementations by covering the
whole contention domain, together with a better understanding of the
performance impacting factors. This part of our analysis comes with a method
for calculating a good back-off strategy to finely tune the performance of a
lock-free algorithm. Our experimental results, based on a set of widely used
concurrent data structures and on abstract lock-free designs, show that our
analysis follows closely the actual code behavior.
