redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

radix-tree: make radix_tree_descend() more useful 

Now that the shift amount is stored in the node, radix_tree_descend()
can calculate offset itself from index, which removes several lines of
code from each of the tree walkers.

Signed-off-by: Matthew Wilcox <willy@linux.intel.com>
Cc: Konstantin Khlebnikov <koct9i@gmail.com>
Cc: Kirill Shutemov <kirill.shutemov@linux.intel.com>
Cc: Jan Kara <jack@suse.com>
Cc: Neil Brown <neilb@suse.de>
Cc: Ross Zwisler <ross.zwisler@linux.intel.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
hifive-unleashed-5.1
Matthew Wilcox 2016-05-20 17:03:48 -07:00 committed by Linus Torvalds
parent d604c32452
commit 9e85d81119
1 changed files with 26 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
lib/radix-tree.c
View File

@ -94,9 +94,10 @@ static inline unsigned long get_slot_offset(struct radix_tree_node *parent,
return slot - parent->slots; return slot - parent->slots;
} }
static unsigned radix_tree_descend(struct radix_tree_node *parent, static unsigned int radix_tree_descend(struct radix_tree_node *parent,
struct radix_tree_node **nodep, unsigned offset) struct radix_tree_node **nodep, unsigned long index)
{ {
unsigned int offset = (index >> parent->shift) & RADIX_TREE_MAP_MASK;
void **entry = rcu_dereference_raw(parent->slots[offset]); void **entry = rcu_dereference_raw(parent->slots[offset]);
#ifdef CONFIG_RADIX_TREE_MULTIORDER #ifdef CONFIG_RADIX_TREE_MULTIORDER
@ -536,8 +537,7 @@ int __radix_tree_create(struct radix_tree_root *root, unsigned long index,
/* Go a level down */ /* Go a level down */
node = entry_to_node(child); node = entry_to_node(child);
offset = (index >> shift) & RADIX_TREE_MAP_MASK; offset = radix_tree_descend(node, &child, index);
offset = radix_tree_descend(node, &child, offset);
slot = &node->slots[offset]; slot = &node->slots[offset];
} }
@ -625,13 +625,12 @@ void *__radix_tree_lookup(struct radix_tree_root *root, unsigned long index,
{ {
struct radix_tree_node *node, *parent; struct radix_tree_node *node, *parent;
unsigned long maxindex; unsigned long maxindex;
unsigned int shift;
void **slot; void **slot;
restart: restart:
parent = NULL; parent = NULL;
slot = (void **)&root->rnode; slot = (void **)&root->rnode;
shift = radix_tree_load_root(root, &node, &maxindex); radix_tree_load_root(root, &node, &maxindex);
if (index > maxindex) if (index > maxindex)
return NULL; return NULL;
@ -641,9 +640,7 @@ void *__radix_tree_lookup(struct radix_tree_root *root, unsigned long index,
if (node == RADIX_TREE_RETRY) if (node == RADIX_TREE_RETRY)
goto restart; goto restart;
parent = entry_to_node(node); parent = entry_to_node(node);
shift -= RADIX_TREE_MAP_SHIFT; offset = radix_tree_descend(parent, &node, index);
offset = (index >> shift) & RADIX_TREE_MAP_MASK;
offset = radix_tree_descend(parent, &node, offset);
slot = parent->slots + offset; slot = parent->slots + offset;
} }
@ -713,19 +710,15 @@ void *radix_tree_tag_set(struct radix_tree_root *root,
{ {
struct radix_tree_node *node, *parent; struct radix_tree_node *node, *parent;
unsigned long maxindex; unsigned long maxindex;
unsigned int shift;
shift = radix_tree_load_root(root, &node, &maxindex); radix_tree_load_root(root, &node, &maxindex);
BUG_ON(index > maxindex); BUG_ON(index > maxindex);
while (radix_tree_is_internal_node(node)) { while (radix_tree_is_internal_node(node)) {
unsigned offset; unsigned offset;
shift -= RADIX_TREE_MAP_SHIFT;
offset = (index >> shift) & RADIX_TREE_MAP_MASK;
parent = entry_to_node(node); parent = entry_to_node(node);
offset = radix_tree_descend(parent, &node, offset); offset = radix_tree_descend(parent, &node, index);
BUG_ON(!node); BUG_ON(!node);
if (!tag_get(parent, tag, offset)) if (!tag_get(parent, tag, offset))
@ -779,21 +772,17 @@ void *radix_tree_tag_clear(struct radix_tree_root *root,
{ {
struct radix_tree_node *node, *parent; struct radix_tree_node *node, *parent;
unsigned long maxindex; unsigned long maxindex;
unsigned int shift;
int uninitialized_var(offset); int uninitialized_var(offset);
shift = radix_tree_load_root(root, &node, &maxindex); radix_tree_load_root(root, &node, &maxindex);
if (index > maxindex) if (index > maxindex)
return NULL; return NULL;
parent = NULL; parent = NULL;
while (radix_tree_is_internal_node(node)) { while (radix_tree_is_internal_node(node)) {
shift -= RADIX_TREE_MAP_SHIFT;
offset = (index >> shift) & RADIX_TREE_MAP_MASK;
parent = entry_to_node(node); parent = entry_to_node(node);
offset = radix_tree_descend(parent, &node, offset); offset = radix_tree_descend(parent, &node, index);
} }
if (node) if (node)
@ -823,25 +812,21 @@ int radix_tree_tag_get(struct radix_tree_root *root,
{ {
struct radix_tree_node *node, *parent; struct radix_tree_node *node, *parent;
unsigned long maxindex; unsigned long maxindex;
unsigned int shift;
if (!root_tag_get(root, tag)) if (!root_tag_get(root, tag))
return 0; return 0;
shift = radix_tree_load_root(root, &node, &maxindex); radix_tree_load_root(root, &node, &maxindex);
if (index > maxindex) if (index > maxindex)
return 0; return 0;
if (node == NULL) if (node == NULL)
return 0; return 0;
while (radix_tree_is_internal_node(node)) { while (radix_tree_is_internal_node(node)) {
int offset; unsigned offset;
shift -= RADIX_TREE_MAP_SHIFT;
offset = (index >> shift) & RADIX_TREE_MAP_MASK;
parent = entry_to_node(node); parent = entry_to_node(node);
offset = radix_tree_descend(parent, &node, offset); offset = radix_tree_descend(parent, &node, index);
if (!node) if (!node)
return 0; return 0;
@ -874,7 +859,7 @@ static inline void __set_iter_shift(struct radix_tree_iter *iter,
void **radix_tree_next_chunk(struct radix_tree_root *root, void **radix_tree_next_chunk(struct radix_tree_root *root,
struct radix_tree_iter *iter, unsigned flags) struct radix_tree_iter *iter, unsigned flags)
{ {
unsigned shift, tag = flags & RADIX_TREE_ITER_TAG_MASK; unsigned tag = flags & RADIX_TREE_ITER_TAG_MASK;
struct radix_tree_node *node, *child; struct radix_tree_node *node, *child;
unsigned long index, offset, maxindex; unsigned long index, offset, maxindex;
@ -895,7 +880,7 @@ void **radix_tree_next_chunk(struct radix_tree_root *root,
return NULL; return NULL;
restart: restart:
shift = radix_tree_load_root(root, &child, &maxindex); radix_tree_load_root(root, &child, &maxindex);
if (index > maxindex) if (index > maxindex)
return NULL; return NULL;
if (!child) if (!child)
@ -912,9 +897,7 @@ void **radix_tree_next_chunk(struct radix_tree_root *root,
do { do {
node = entry_to_node(child); node = entry_to_node(child);
shift -= RADIX_TREE_MAP_SHIFT; offset = radix_tree_descend(node, &child, index);
offset = (index >> shift) & RADIX_TREE_MAP_MASK;
offset = radix_tree_descend(node, &child, offset);
if ((flags & RADIX_TREE_ITER_TAGGED) ? if ((flags & RADIX_TREE_ITER_TAGGED) ?
!tag_get(node, tag, offset) : !child) { !tag_get(node, tag, offset) : !child) {
@ -936,7 +919,7 @@ void **radix_tree_next_chunk(struct radix_tree_root *root,
break; break;
} }
index &= ~node_maxindex(node); index &= ~node_maxindex(node);
index += offset << shift; index += offset << node->shift;
/* Overflow after ~0UL */ /* Overflow after ~0UL */
if (!index) if (!index)
return NULL; return NULL;
@ -952,7 +935,7 @@ void **radix_tree_next_chunk(struct radix_tree_root *root,
/* Update the iterator state */ /* Update the iterator state */
iter->index = (index &~ node_maxindex(node)) | (offset << node->shift); iter->index = (index &~ node_maxindex(node)) | (offset << node->shift);
iter->next_index = (index | node_maxindex(node)) + 1; iter->next_index = (index | node_maxindex(node)) + 1;
__set_iter_shift(iter, shift); __set_iter_shift(iter, node->shift);
/* Construct iter->tags bit-mask from node->tags[tag] array */ /* Construct iter->tags bit-mask from node->tags[tag] array */
if (flags & RADIX_TREE_ITER_TAGGED) { if (flags & RADIX_TREE_ITER_TAGGED) {
@ -1010,10 +993,10 @@ unsigned long radix_tree_range_tag_if_tagged(struct radix_tree_root *root,
{ {
struct radix_tree_node *parent, *node, *child; struct radix_tree_node *parent, *node, *child;
unsigned long maxindex; unsigned long maxindex;
unsigned int shift = radix_tree_load_root(root, &child, &maxindex);
unsigned long tagged = 0; unsigned long tagged = 0;
unsigned long index = *first_indexp; unsigned long index = *first_indexp;
radix_tree_load_root(root, &child, &maxindex);
last_index = min(last_index, maxindex); last_index = min(last_index, maxindex);
if (index > last_index) if (index > last_index)
return 0; return 0;
@ -1030,11 +1013,9 @@ unsigned long radix_tree_range_tag_if_tagged(struct radix_tree_root *root,
} }
node = entry_to_node(child); node = entry_to_node(child);
shift -= RADIX_TREE_MAP_SHIFT;
for (;;) { for (;;) {
unsigned offset = (index >> shift) & RADIX_TREE_MAP_MASK; unsigned offset = radix_tree_descend(node, &child, index);
offset = radix_tree_descend(node, &child, offset);
if (!child) if (!child)
goto next; goto next;
if (!tag_get(node, iftag, offset)) if (!tag_get(node, iftag, offset))
@ -1042,7 +1023,6 @@ unsigned long radix_tree_range_tag_if_tagged(struct radix_tree_root *root,
/* Sibling slots never have tags set on them */ /* Sibling slots never have tags set on them */
if (radix_tree_is_internal_node(child)) { if (radix_tree_is_internal_node(child)) {
node = entry_to_node(child); node = entry_to_node(child);
shift -= RADIX_TREE_MAP_SHIFT;
continue; continue;
} }
@ -1063,12 +1043,12 @@ unsigned long radix_tree_range_tag_if_tagged(struct radix_tree_root *root,
tag_set(parent, settag, offset); tag_set(parent, settag, offset);
} }
next: next:
/* Go to next item at level determined by 'shift' */ /* Go to next entry in node */
index = ((index >> shift) + 1) << shift; index = ((index >> node->shift) + 1) << node->shift;
/* Overflow can happen when last_index is ~0UL... */ /* Overflow can happen when last_index is ~0UL... */
if (index > last_index || !index) if (index > last_index || !index)
break; break;
offset = (index >> shift) & RADIX_TREE_MAP_MASK; offset = (index >> node->shift) & RADIX_TREE_MAP_MASK;
while (offset == 0) { while (offset == 0) {
/* /*
* We've fully scanned this node. Go up. Because * We've fully scanned this node. Go up. Because
@ -1076,8 +1056,7 @@ unsigned long radix_tree_range_tag_if_tagged(struct radix_tree_root *root,
* we do below cannot wander astray. * we do below cannot wander astray.
*/ */
node = node->parent; node = node->parent;
shift += RADIX_TREE_MAP_SHIFT; offset = (index >> node->shift) & RADIX_TREE_MAP_MASK;
offset = (index >> shift) & RADIX_TREE_MAP_MASK;
} }
if (is_sibling_entry(node, node->slots[offset])) if (is_sibling_entry(node, node->slots[offset]))
goto next; goto next;
@ -1275,13 +1254,10 @@ struct locate_info {
static unsigned long __locate(struct radix_tree_node *slot, void *item, static unsigned long __locate(struct radix_tree_node *slot, void *item,
unsigned long index, struct locate_info *info) unsigned long index, struct locate_info *info)
{ {
unsigned int shift;
unsigned long i; unsigned long i;
shift = slot->shift + RADIX_TREE_MAP_SHIFT;
do { do {
shift -= RADIX_TREE_MAP_SHIFT; unsigned int shift = slot->shift;
for (i = (index >> shift) & RADIX_TREE_MAP_MASK; for (i = (index >> shift) & RADIX_TREE_MAP_MASK;
i < RADIX_TREE_MAP_SIZE; i < RADIX_TREE_MAP_SIZE;
@ -1304,9 +1280,7 @@ static unsigned long __locate(struct radix_tree_node *slot, void *item,
slot = node; slot = node;
break; break;
} }
if (i == RADIX_TREE_MAP_SIZE) } while (i < RADIX_TREE_MAP_SIZE);
break;
} while (shift);
out: out:
if ((index == 0) && (i == RADIX_TREE_MAP_SIZE)) if ((index == 0) && (i == RADIX_TREE_MAP_SIZE))