(and error-prone!) description. Moreover, the ro ot of the tree is a dramatic b ottleneck in this
approach, which can be qualied as \coarse-grained".
Later attempts have thus explored higher-level approaches. Kessels [Kes83] proposes to see the
reorganization of the data structure as a side eect of the access. The reorganization is split into
atomic steps involving a small number of nodes, so as to allow concurrency. Additional registers,
local on each node, are used to store the necessary information on intermediate states. At each
update, a reorganizing process is launched, which pro ceeds asynchronously. This approach is ex-
tended by Nurmi, Soisalon-Soininen and Woo d [NSS96, NSSW87, NSSW92]. Finally Larsen [Lar94]
shows that the reorganization process converges in
O
(
k:
log(
n
+ 2
:k
)) steps in a tree with
n
nodes
updated with
k
insertions. Each step consists in propagating a piece of information from a son
to its father, and applying the appropriate sequence of rotations to the father so as to restore its
balance. These transformations are described by 9 dierent rules, depending on the values of the
local registers. As an atomic step may include complex operation, this approach can b e qualied
as \medium-grained".
The contribution of this paper is to go one step further towards a \ne-grained" solution to
concurrent up dates of AVL search trees. As for Kessels, our source of inspiration is the seminal work
by Dijkstra, Lamport at al. [DLM
+
78] on concurrent \on the y" garbage-collection. Their key idea
is to completely uncouple the reorganization of the data structure (collecting the garbage cells and
linking them into the free list) from its up dates (creating garbage cells by p ointer manipulations).
Taking this viewp oint in our problem lets us consider the insertions or deletions of keys in the
data structure as external
perturbations
done by mutator pro cesses on which we have no control.
Reorganizing the data structure is the job of asynchronous daemons which have no knowledge
about the ongoing mutations. They just compete with the mutator pro cesses to access the data
structure. The only consistency restriction on their b ehavior is that it should resp ect the invariant
on which the insertion and deletion protocols are based: the keys appear in sorted order.
We even go one step further by splitting the macro-steps of Larsen into ner atomic steps, and
we dene two kinds of daemon actions:
Propagation:
Flowing the information about current up dates upwards in the tree, from the leaves
to the ro ot.
Rotation:
Rebalancing the no des according to their best knowledge ab out the shape of the tree.
It turns out that only one rule suces to sp ecify propagations, and three for the rotations, which
makes our approach signicantly simpler than the previous ones. Moreover, as the daemons have
no knowledge of the keys, the rules apply to any binary tree, without regards to the way it has b een
obtained by successive insertions and deletions. This is the reason why we have coined the term
AVL rebalancing
. As a byproduct, it answers in a very general setting an old question raised by
H.T. Kung and P.L. Lehman [KL80]: where should rotations take place for to rebalance arbitrary
trees? The answer is: anywhere.
The price to pay for this \ne-grained approach" is that (
n
2
) steps are needed to rebalance
an arbitrary binary tree in the worst case, instead of Larsen's
O
(
n:
log(
n
)) for an empty tree lled
by
n
successive insertions. Note however that a single atomic step of Larsen corresponds to several
steps here which makes the comparison slightly more balanced. Also, we provide the user with a
better degree of concurrency. Finally, there is go od experimental evidence that the convergence is
obtained in
O
(
n
) steps in the average.
The rest of the paper is organized as follows. Section 2.4 describes the mo del and the two
daemons. Correctness is easy: once no daemon can work any more, the tree is an balanced. On
2