1========================================
2Generic Associative Array Implementation
3========================================
4
5Overview
6========
7
8This associative array implementation is an object container with the following
9properties:
10
111. Objects are opaque pointers.  The implementation does not care where they
12   point (if anywhere) or what they point to (if anything).
13
14   .. note::
15
16      Pointers to objects _must_ be zero in the least significant bit.
17
182. Objects do not need to contain linkage blocks for use by the array.  This
19   permits an object to be located in multiple arrays simultaneously.
20   Rather, the array is made up of metadata blocks that point to objects.
21
223. Objects require index keys to locate them within the array.
23
244. Index keys must be unique.  Inserting an object with the same key as one
25   already in the array will replace the old object.
26
275. Index keys can be of any length and can be of different lengths.
28
296. Index keys should encode the length early on, before any variation due to
30   length is seen.
31
327. Index keys can include a hash to scatter objects throughout the array.
33
348. The array can iterated over.  The objects will not necessarily come out in
35   key order.
36
379. The array can be iterated over whilst it is being modified, provided the
38   RCU readlock is being held by the iterator.  Note, however, under these
39   circumstances, some objects may be seen more than once.  If this is a
40   problem, the iterator should lock against modification.  Objects will not
41   be missed, however, unless deleted.
42
4310. Objects in the array can be looked up by means of their index key.
44
4511. Objects can be looked up whilst the array is being modified, provided the
46    RCU readlock is being held by the thread doing the look up.
47
48The implementation uses a tree of 16-pointer nodes internally that are indexed
49on each level by nibbles from the index key in the same manner as in a radix
50tree.  To improve memory efficiency, shortcuts can be emplaced to skip over
51what would otherwise be a series of single-occupancy nodes.  Further, nodes
52pack leaf object pointers into spare space in the node rather than making an
53extra branch until as such time an object needs to be added to a full node.
54
55
56The Public API
57==============
58
59The public API can be found in ``<linux/assoc_array.h>``.  The associative
60array is rooted on the following structure::
61
62    struct assoc_array {
63            ...
64    };
65
66The code is selected by enabling ``CONFIG_ASSOCIATIVE_ARRAY`` with::
67
68    ./script/config -e ASSOCIATIVE_ARRAY
69
70
71Edit Script
72-----------
73
74The insertion and deletion functions produce an 'edit script' that can later be
75applied to effect the changes without risking ``ENOMEM``. This retains the
76preallocated metadata blocks that will be installed in the internal tree and
77keeps track of the metadata blocks that will be removed from the tree when the
78script is applied.
79
80This is also used to keep track of dead blocks and dead objects after the
81script has been applied so that they can be freed later.  The freeing is done
82after an RCU grace period has passed - thus allowing access functions to
83proceed under the RCU read lock.
84
85The script appears as outside of the API as a pointer of the type::
86
87    struct assoc_array_edit;
88
89There are two functions for dealing with the script:
90
911. Apply an edit script::
92
93    void assoc_array_apply_edit(struct assoc_array_edit *edit);
94
95This will perform the edit functions, interpolating various write barriers
96to permit accesses under the RCU read lock to continue.  The edit script
97will then be passed to ``call_rcu()`` to free it and any dead stuff it points
98to.
99
1002. Cancel an edit script::
101
102    void assoc_array_cancel_edit(struct assoc_array_edit *edit);
103
104This frees the edit script and all preallocated memory immediately. If
105this was for insertion, the new object is _not_ released by this function,
106but must rather be released by the caller.
107
108These functions are guaranteed not to fail.
109
110
111Operations Table
112----------------
113
114Various functions take a table of operations::
115
116    struct assoc_array_ops {
117            ...
118    };
119
120This points to a number of methods, all of which need to be provided:
121
1221. Get a chunk of index key from caller data::
123
124    unsigned long (*get_key_chunk)(const void *index_key, int level);
125
126This should return a chunk of caller-supplied index key starting at the
127*bit* position given by the level argument.  The level argument will be a
128multiple of ``ASSOC_ARRAY_KEY_CHUNK_SIZE`` and the function should return
129``ASSOC_ARRAY_KEY_CHUNK_SIZE bits``.  No error is possible.
130
131
1322. Get a chunk of an object's index key::
133
134    unsigned long (*get_object_key_chunk)(const void *object, int level);
135
136As the previous function, but gets its data from an object in the array
137rather than from a caller-supplied index key.
138
139
1403. See if this is the object we're looking for::
141
142    bool (*compare_object)(const void *object, const void *index_key);
143
144Compare the object against an index key and return ``true`` if it matches and
145``false`` if it doesn't.
146
147
1484. Diff the index keys of two objects::
149
150    int (*diff_objects)(const void *object, const void *index_key);
151
152Return the bit position at which the index key of the specified object
153differs from the given index key or -1 if they are the same.
154
155
1565. Free an object::
157
158    void (*free_object)(void *object);
159
160Free the specified object.  Note that this may be called an RCU grace period
161after ``assoc_array_apply_edit()`` was called, so ``synchronize_rcu()`` may be
162necessary on module unloading.
163
164
165Manipulation Functions
166----------------------
167
168There are a number of functions for manipulating an associative array:
169
1701. Initialise an associative array::
171
172    void assoc_array_init(struct assoc_array *array);
173
174This initialises the base structure for an associative array.  It can't fail.
175
176
1772. Insert/replace an object in an associative array::
178
179    struct assoc_array_edit *
180    assoc_array_insert(struct assoc_array *array,
181                       const struct assoc_array_ops *ops,
182                       const void *index_key,
183                       void *object);
184
185This inserts the given object into the array.  Note that the least
186significant bit of the pointer must be zero as it's used to type-mark
187pointers internally.
188
189If an object already exists for that key then it will be replaced with the
190new object and the old one will be freed automatically.
191
192The ``index_key`` argument should hold index key information and is
193passed to the methods in the ops table when they are called.
194
195This function makes no alteration to the array itself, but rather returns
196an edit script that must be applied.  ``-ENOMEM`` is returned in the case of
197an out-of-memory error.
198
199The caller should lock exclusively against other modifiers of the array.
200
201
2023. Delete an object from an associative array::
203
204    struct assoc_array_edit *
205    assoc_array_delete(struct assoc_array *array,
206                       const struct assoc_array_ops *ops,
207                       const void *index_key);
208
209This deletes an object that matches the specified data from the array.
210
211The ``index_key`` argument should hold index key information and is
212passed to the methods in the ops table when they are called.
213
214This function makes no alteration to the array itself, but rather returns
215an edit script that must be applied.  ``-ENOMEM`` is returned in the case of
216an out-of-memory error.  ``NULL`` will be returned if the specified object is
217not found within the array.
218
219The caller should lock exclusively against other modifiers of the array.
220
221
2224. Delete all objects from an associative array::
223
224    struct assoc_array_edit *
225    assoc_array_clear(struct assoc_array *array,
226                      const struct assoc_array_ops *ops);
227
228This deletes all the objects from an associative array and leaves it
229completely empty.
230
231This function makes no alteration to the array itself, but rather returns
232an edit script that must be applied.  ``-ENOMEM`` is returned in the case of
233an out-of-memory error.
234
235The caller should lock exclusively against other modifiers of the array.
236
237
2385. Destroy an associative array, deleting all objects::
239
240    void assoc_array_destroy(struct assoc_array *array,
241                             const struct assoc_array_ops *ops);
242
243This destroys the contents of the associative array and leaves it
244completely empty.  It is not permitted for another thread to be traversing
245the array under the RCU read lock at the same time as this function is
246destroying it as no RCU deferral is performed on memory release -
247something that would require memory to be allocated.
248
249The caller should lock exclusively against other modifiers and accessors
250of the array.
251
252
2536. Garbage collect an associative array::
254
255    int assoc_array_gc(struct assoc_array *array,
256                       const struct assoc_array_ops *ops,
257                       bool (*iterator)(void *object, void *iterator_data),
258                       void *iterator_data);
259
260This iterates over the objects in an associative array and passes each one to
261``iterator()``.  If ``iterator()`` returns ``true``, the object is kept.  If it
262returns ``false``, the object will be freed.  If the ``iterator()`` function
263returns ``true``, it must perform any appropriate refcount incrementing on the
264object before returning.
265
266The internal tree will be packed down if possible as part of the iteration
267to reduce the number of nodes in it.
268
269The ``iterator_data`` is passed directly to ``iterator()`` and is otherwise
270ignored by the function.
271
272The function will return ``0`` if successful and ``-ENOMEM`` if there wasn't
273enough memory.
274
275It is possible for other threads to iterate over or search the array under
276the RCU read lock whilst this function is in progress.  The caller should
277lock exclusively against other modifiers of the array.
278
279
280Access Functions
281----------------
282
283There are two functions for accessing an associative array:
284
2851. Iterate over all the objects in an associative array::
286
287    int assoc_array_iterate(const struct assoc_array *array,
288                            int (*iterator)(const void *object,
289                                            void *iterator_data),
290                            void *iterator_data);
291
292This passes each object in the array to the iterator callback function.
293``iterator_data`` is private data for that function.
294
295This may be used on an array at the same time as the array is being
296modified, provided the RCU read lock is held.  Under such circumstances,
297it is possible for the iteration function to see some objects twice.  If
298this is a problem, then modification should be locked against.  The
299iteration algorithm should not, however, miss any objects.
300
301The function will return ``0`` if no objects were in the array or else it will
302return the result of the last iterator function called.  Iteration stops
303immediately if any call to the iteration function results in a non-zero
304return.
305
306
3072. Find an object in an associative array::
308
309    void *assoc_array_find(const struct assoc_array *array,
310                           const struct assoc_array_ops *ops,
311                           const void *index_key);
312
313This walks through the array's internal tree directly to the object
314specified by the index key..
315
316This may be used on an array at the same time as the array is being
317modified, provided the RCU read lock is held.
318
319The function will return the object if found (and set ``*_type`` to the object
320type) or will return ``NULL`` if the object was not found.
321
322
323Index Key Form
324--------------
325
326The index key can be of any form, but since the algorithms aren't told how long
327the key is, it is strongly recommended that the index key includes its length
328very early on before any variation due to the length would have an effect on
329comparisons.
330
331This will cause leaves with different length keys to scatter away from each
332other - and those with the same length keys to cluster together.
333
334It is also recommended that the index key begin with a hash of the rest of the
335key to maximise scattering throughout keyspace.
336
337The better the scattering, the wider and lower the internal tree will be.
338
339Poor scattering isn't too much of a problem as there are shortcuts and nodes
340can contain mixtures of leaves and metadata pointers.
341
342The index key is read in chunks of machine word.  Each chunk is subdivided into
343one nibble (4 bits) per level, so on a 32-bit CPU this is good for 8 levels and
344on a 64-bit CPU, 16 levels.  Unless the scattering is really poor, it is
345unlikely that more than one word of any particular index key will have to be
346used.
347
348
349Internal Workings
350=================
351
352The associative array data structure has an internal tree.  This tree is
353constructed of two types of metadata blocks: nodes and shortcuts.
354
355A node is an array of slots.  Each slot can contain one of four things:
356
357* A NULL pointer, indicating that the slot is empty.
358* A pointer to an object (a leaf).
359* A pointer to a node at the next level.
360* A pointer to a shortcut.
361
362
363Basic Internal Tree Layout
364--------------------------
365
366Ignoring shortcuts for the moment, the nodes form a multilevel tree.  The index
367key space is strictly subdivided by the nodes in the tree and nodes occur on
368fixed levels.  For example::
369
370 Level: 0               1               2               3
371        =============== =============== =============== ===============
372                                                        NODE D
373                        NODE B          NODE C  +------>+---+
374                +------>+---+   +------>+---+   |       | 0 |
375        NODE A  |       | 0 |   |       | 0 |   |       +---+
376        +---+   |       +---+   |       +---+   |       :   :
377        | 0 |   |       :   :   |       :   :   |       +---+
378        +---+   |       +---+   |       +---+   |       | f |
379        | 1 |---+       | 3 |---+       | 7 |---+       +---+
380        +---+           +---+           +---+
381        :   :           :   :           | 8 |---+
382        +---+           +---+           +---+   |       NODE E
383        | e |---+       | f |           :   :   +------>+---+
384        +---+   |       +---+           +---+           | 0 |
385        | f |   |                       | f |           +---+
386        +---+   |                       +---+           :   :
387                |       NODE F                          +---+
388                +------>+---+                           | f |
389                        | 0 |           NODE G          +---+
390                        +---+   +------>+---+
391                        :   :   |       | 0 |
392                        +---+   |       +---+
393                        | 6 |---+       :   :
394                        +---+           +---+
395                        :   :           | f |
396                        +---+           +---+
397                        | f |
398                        +---+
399
400In the above example, there are 7 nodes (A-G), each with 16 slots (0-f).
401Assuming no other meta data nodes in the tree, the key space is divided
402thusly::
403
404    KEY PREFIX      NODE
405    ==========      ====
406    137*            D
407    138*            E
408    13[0-69-f]*     C
409    1[0-24-f]*      B
410    e6*             G
411    e[0-57-f]*      F
412    [02-df]*        A
413
414So, for instance, keys with the following example index keys will be found in
415the appropriate nodes::
416
417    INDEX KEY       PREFIX  NODE
418    =============== ======= ====
419    13694892892489  13      C
420    13795289025897  137     D
421    13889dde88793   138     E
422    138bbb89003093  138     E
423    1394879524789   12      C
424    1458952489      1       B
425    9431809de993ba  -       A
426    b4542910809cd   -       A
427    e5284310def98   e       F
428    e68428974237    e6      G
429    e7fffcbd443     e       F
430    f3842239082     -       A
431
432To save memory, if a node can hold all the leaves in its portion of keyspace,
433then the node will have all those leaves in it and will not have any metadata
434pointers - even if some of those leaves would like to be in the same slot.
435
436A node can contain a heterogeneous mix of leaves and metadata pointers.
437Metadata pointers must be in the slots that match their subdivisions of key
438space.  The leaves can be in any slot not occupied by a metadata pointer.  It
439is guaranteed that none of the leaves in a node will match a slot occupied by a
440metadata pointer.  If the metadata pointer is there, any leaf whose key matches
441the metadata key prefix must be in the subtree that the metadata pointer points
442to.
443
444In the above example list of index keys, node A will contain::
445
446    SLOT    CONTENT         INDEX KEY (PREFIX)
447    ====    =============== ==================
448    1       PTR TO NODE B   1*
449    any     LEAF            9431809de993ba
450    any     LEAF            b4542910809cd
451    e       PTR TO NODE F   e*
452    any     LEAF            f3842239082
453
454and node B::
455
456    3	PTR TO NODE C	13*
457    any	LEAF		1458952489
458
459
460Shortcuts
461---------
462
463Shortcuts are metadata records that jump over a piece of keyspace.  A shortcut
464is a replacement for a series of single-occupancy nodes ascending through the
465levels.  Shortcuts exist to save memory and to speed up traversal.
466
467It is possible for the root of the tree to be a shortcut - say, for example,
468the tree contains at least 17 nodes all with key prefix ``1111``.  The
469insertion algorithm will insert a shortcut to skip over the ``1111`` keyspace
470in a single bound and get to the fourth level where these actually become
471different.
472
473
474Splitting And Collapsing Nodes
475------------------------------
476
477Each node has a maximum capacity of 16 leaves and metadata pointers.  If the
478insertion algorithm finds that it is trying to insert a 17th object into a
479node, that node will be split such that at least two leaves that have a common
480key segment at that level end up in a separate node rooted on that slot for
481that common key segment.
482
483If the leaves in a full node and the leaf that is being inserted are
484sufficiently similar, then a shortcut will be inserted into the tree.
485
486When the number of objects in the subtree rooted at a node falls to 16 or
487fewer, then the subtree will be collapsed down to a single node - and this will
488ripple towards the root if possible.
489
490
491Non-Recursive Iteration
492-----------------------
493
494Each node and shortcut contains a back pointer to its parent and the number of
495slot in that parent that points to it.  None-recursive iteration uses these to
496proceed rootwards through the tree, going to the parent node, slot N + 1 to
497make sure progress is made without the need for a stack.
498
499The backpointers, however, make simultaneous alteration and iteration tricky.
500
501
502Simultaneous Alteration And Iteration
503-------------------------------------
504
505There are a number of cases to consider:
506
5071. Simple insert/replace.  This involves simply replacing a NULL or old
508   matching leaf pointer with the pointer to the new leaf after a barrier.
509   The metadata blocks don't change otherwise.  An old leaf won't be freed
510   until after the RCU grace period.
511
5122. Simple delete.  This involves just clearing an old matching leaf.  The
513   metadata blocks don't change otherwise.  The old leaf won't be freed until
514   after the RCU grace period.
515
5163. Insertion replacing part of a subtree that we haven't yet entered.  This
517   may involve replacement of part of that subtree - but that won't affect
518   the iteration as we won't have reached the pointer to it yet and the
519   ancestry blocks are not replaced (the layout of those does not change).
520
5214. Insertion replacing nodes that we're actively processing.  This isn't a
522   problem as we've passed the anchoring pointer and won't switch onto the
523   new layout until we follow the back pointers - at which point we've
524   already examined the leaves in the replaced node (we iterate over all the
525   leaves in a node before following any of its metadata pointers).
526
527   We might, however, re-see some leaves that have been split out into a new
528   branch that's in a slot further along than we were at.
529
5305. Insertion replacing nodes that we're processing a dependent branch of.
531   This won't affect us until we follow the back pointers.  Similar to (4).
532
5336. Deletion collapsing a branch under us.  This doesn't affect us because the
534   back pointers will get us back to the parent of the new node before we
535   could see the new node.  The entire collapsed subtree is thrown away
536   unchanged - and will still be rooted on the same slot, so we shouldn't
537   process it a second time as we'll go back to slot + 1.
538
539.. note::
540
541   Under some circumstances, we need to simultaneously change the parent
542   pointer and the parent slot pointer on a node (say, for example, we
543   inserted another node before it and moved it up a level).  We cannot do
544   this without locking against a read - so we have to replace that node too.
545
546   However, when we're changing a shortcut into a node this isn't a problem
547   as shortcuts only have one slot and so the parent slot number isn't used
548   when traversing backwards over one.  This means that it's okay to change
549   the slot number first - provided suitable barriers are used to make sure
550   the parent slot number is read after the back pointer.
551
552Obsolete blocks and leaves are freed up after an RCU grace period has passed,
553so as long as anyone doing walking or iteration holds the RCU read lock, the
554old superstructure should not go away on them.
555