*
* Userspace RCU library - RCU Judy Array
*
- * Copyright 2012 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ * Copyright (C) 2000 - 2002 Hewlett-Packard Company
+ * Copyright 2012-2013 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
#include <errno.h>
#include <limits.h>
#include <string.h>
+#include <assert.h>
#include <urcu/rcuja.h>
#include <urcu/compiler.h>
#include <urcu/arch.h>
-#include <assert.h>
#include <urcu-pointer.h>
#include <urcu/uatomic.h>
-#include <stdint.h>
#include "rcuja-internal.h"
uint8_t nr_child;
uint8_t *values;
struct cds_ja_inode_flag **pointers;
- struct cds_ja_inode_flag *ptr;
+ struct cds_ja_inode_flag *ptr = NULL;
unsigned int i;
int match_idx = -1, match_v;
assert(type->type_class != RCU_JA_LINEAR || nr_child >= type->min_child);
values = &node->u.data[1];
+ pointers = (struct cds_ja_inode_flag **) align_ptr_size(&values[type->max_linear_child]);
for (i = 0; i < nr_child; i++) {
unsigned int v;
v = CMM_LOAD_SHARED(values[i]);
+ ptr = CMM_LOAD_SHARED(pointers[i]);
+ if (!ptr)
+ continue;
if (dir == JA_LEFT) {
if ((int) v < n && (int) v > match_v) {
match_v = v;
assert(match_v >= 0 && match_v < JA_ENTRY_PER_NODE);
*result_key = (uint8_t) match_v;
- pointers = (struct cds_ja_inode_flag **) align_ptr_size(&values[type->max_linear_child]);
ptr = rcu_dereference(pointers[match_idx]);
return ptr;
}
iter_key = (uint8_t) (key >> (JA_BITS_PER_BYTE * (tree_depth - level - 1)));
node_flag = ja_node_get_leftright(cur_node_depth[level - 1],
iter_key, &cur_key[level - 1], dir);
+ dbg_printf("cds_ja_lookup_inequality find sibling from %u at %u finds node_flag %p\n",
+ (unsigned int) iter_key, (unsigned int) cur_key[level - 1],
+ node_flag);
/* If found left/right sibling, find rightmost/leftmost child. */
if (ja_node_ptr(node_flag))
break;
}
for (; level < tree_depth; level++) {
node_flag = ja_node_get_minmax(node_flag, &cur_key[level - 1], dir);
+ dbg_printf("cds_ja_lookup_inequality find minmax at %u finds node_flag %p\n",
+ (unsigned int) cur_key[level - 1],
+ node_flag);
if (!ja_node_ptr(node_flag))
break;
}
struct cds_ja_node *cds_ja_lookup_below_equal(struct cds_ja *ja,
uint64_t key, uint64_t *result_key)
{
+ dbg_printf("cds_ja_lookup_below_equal key %" PRIu64 "\n", key);
return cds_ja_lookup_inequality(ja, key, result_key, JA_LOOKUP_BE);
}
struct cds_ja_node *cds_ja_lookup_above_equal(struct cds_ja *ja,
uint64_t key, uint64_t *result_key)
{
+ dbg_printf("cds_ja_lookup_above_equal key %" PRIu64 "\n", key);
return cds_ja_lookup_inequality(ja, key, result_key, JA_LOOKUP_AE);
}
struct cds_ja_inode_flag *parent_node_flag,
struct cds_ja_inode_flag **node_flag_ptr,
struct cds_ja_inode_flag *node_flag,
+ struct cds_ja_node *last_node,
struct cds_ja_node *node)
{
struct cds_ja_shadow_node *shadow_node;
- int ret = 0;
+ struct cds_ja_node *iter_node;
+ int ret = 0, found = 0;
shadow_node = rcuja_shadow_lookup_lock(ja->ht, parent_node_flag);
if (!shadow_node) {
return -EAGAIN;
}
- if (ja_node_ptr(*node_flag_ptr) != ja_node_ptr(node_flag)) {
+ /*
+ * Ensure that previous node is still there at end of list.
+ */
+ iter_node = (struct cds_ja_node *) ja_node_ptr(node_flag);
+ if ((struct cds_ja_node *) ja_node_ptr(*node_flag_ptr) != iter_node) {
+ ret = -EAGAIN;
+ goto end;
+ }
+ cds_ja_for_each_duplicate(iter_node) {
+ if (iter_node == last_node)
+ found = 1;
+ }
+ if (!found) {
ret = -EAGAIN;
goto end;
}
/*
- * Add node to head of list. Safe against concurrent RCU read
- * traversals.
+ * Add node to tail of list to ensure that RCU traversals will
+ * always see either the prior node or the newly added if
+ * executed concurrently with a sequence of add followed by del
+ * on the same key. Safe against concurrent RCU read traversals.
*/
- node->next = (struct cds_ja_node *) node_flag;
- rcu_assign_pointer(*node_flag_ptr, (struct cds_ja_inode_flag *) node);
+ node->next = NULL;
+ rcu_assign_pointer(last_node->next, node);
end:
rcuja_shadow_unlock(shadow_node);
return ret;
node_flag,
key, i, node);
} else {
+ struct cds_ja_node *iter_node, *last_node = NULL;
+
if (unique_node_ret) {
*unique_node_ret = (struct cds_ja_node *) ja_node_ptr(node_flag);
return -EEXIST;
}
+ /* Find last duplicate */
+ iter_node = (struct cds_ja_node *) ja_node_ptr(node_flag);
+ cds_ja_for_each_duplicate_rcu(iter_node)
+ last_node = iter_node;
+
dbg_printf("cds_ja_add duplicate parent2_node_flag %p parent_node_flag %p node_flag_ptr %p node_flag %p\n",
parent2_node_flag, parent_node_flag, node_flag_ptr, node_flag);
parent_attach_node_flag,
attach_node_flag_ptr,
attach_node_flag,
+ last_node,
node);
}
if (ret == -EAGAIN || ret == -EEXIST)
projects / userspace-rcu.git / blobdiff