#endif
static
-void cds_lfht_resize_lazy(struct cds_lfht *ht, unsigned long size, int growth);
+void cds_lfht_resize_lazy_grow(struct cds_lfht *ht, unsigned long size, int growth);
static
void cds_lfht_resize_lazy_count(struct cds_lfht *ht, unsigned long size,
assert(split_count_mask >= 0);
cpu = sched_getcpu();
- if (unlikely(cpu < 0))
+ if (caa_unlikely(cpu < 0))
return hash & split_count_mask;
else
return cpu & split_count_mask;
unsigned long split_count;
int index;
- if (unlikely(!ht->split_count))
+ if (caa_unlikely(!ht->split_count))
return;
index = ht_get_split_count_index(hash);
split_count = uatomic_add_return(&ht->split_count[index].add, 1);
- if (unlikely(!(split_count & ((1UL << COUNT_COMMIT_ORDER) - 1)))) {
+ if (caa_unlikely(!(split_count & ((1UL << COUNT_COMMIT_ORDER) - 1)))) {
long count;
dbg_printf("add split count %lu\n", split_count);
unsigned long split_count;
int index;
- if (unlikely(!ht->split_count))
+ if (caa_unlikely(!ht->split_count))
return;
index = ht_get_split_count_index(hash);
split_count = uatomic_add_return(&ht->split_count[index].del, 1);
- if (unlikely(!(split_count & ((1UL << COUNT_COMMIT_ORDER) - 1)))) {
+ if (caa_unlikely(!(split_count & ((1UL << COUNT_COMMIT_ORDER) - 1)))) {
long count;
dbg_printf("del split count %lu\n", split_count);
dbg_printf("WARNING: large chain length: %u.\n",
chain_len);
if (chain_len >= CHAIN_LEN_RESIZE_THRESHOLD)
- cds_lfht_resize_lazy(ht, size,
+ cds_lfht_resize_lazy_grow(ht, size,
get_count_order_u32(chain_len - (CHAIN_LEN_TARGET - 1)));
}
}
static
-unsigned long _uatomic_max(unsigned long *ptr, unsigned long v)
+unsigned long _uatomic_xchg_monotonic_increase(unsigned long *ptr,
+ unsigned long v)
{
unsigned long old1, old2;
if (old2 >= v)
return old2;
} while ((old1 = uatomic_cmpxchg(ptr, old2, v)) != old2);
- return v;
+ return old2;
}
static
*/
assert(dummy != node);
for (;;) {
- if (unlikely(is_end(iter)))
+ if (caa_unlikely(is_end(iter)))
return;
- if (likely(clear_flag(iter)->p.reverse_hash > node->p.reverse_hash))
+ if (caa_likely(clear_flag(iter)->p.reverse_hash > node->p.reverse_hash))
return;
next = rcu_dereference(clear_flag(iter)->p.next);
- if (likely(is_removed(next)))
+ if (caa_likely(is_removed(next)))
break;
iter_prev = clear_flag(iter);
iter = next;
iter = rcu_dereference(iter_prev->p.next);
assert(iter_prev->p.reverse_hash <= node->p.reverse_hash);
for (;;) {
- if (unlikely(is_end(iter)))
+ if (caa_unlikely(is_end(iter)))
goto insert;
- if (likely(clear_flag(iter)->p.reverse_hash > node->p.reverse_hash))
+ if (caa_likely(clear_flag(iter)->p.reverse_hash > node->p.reverse_hash))
goto insert;
/* dummy node is the first node of the identical-hash-value chain */
goto insert;
next = rcu_dereference(clear_flag(iter)->p.next);
- if (unlikely(is_removed(next)))
+ if (caa_unlikely(is_removed(next)))
goto gc_node;
/* uniquely add */
struct cds_lfht_node *new_next;
next = old;
- if (unlikely(is_removed(next)))
+ if (caa_unlikely(is_removed(next)))
return -ENOENT;
if (dummy_removal)
assert(is_dummy(next));
node = rcu_dereference(dummy_node->p.next);
node = clear_flag(node);
for (;;) {
- if (unlikely(is_end(node))) {
+ if (caa_unlikely(is_end(node))) {
node = next = NULL;
break;
}
- if (unlikely(node->p.reverse_hash > reverse_hash)) {
+ if (caa_unlikely(node->p.reverse_hash > reverse_hash)) {
node = next = NULL;
break;
}
next = rcu_dereference(node->p.next);
assert(node == clear_flag(node));
- if (likely(!is_removed(next))
+ if (caa_likely(!is_removed(next))
&& !is_dummy(next)
&& node->p.reverse_hash == reverse_hash
- && likely(!ht->compare_fct(node->key, node->key_len, key, key_len))) {
+ && caa_likely(!ht->compare_fct(node->key, node->key_len, key, key_len))) {
break;
}
node = clear_flag(next);
node = clear_flag(next);
for (;;) {
- if (unlikely(is_end(node))) {
+ if (caa_unlikely(is_end(node))) {
node = next = NULL;
break;
}
- if (unlikely(node->p.reverse_hash > reverse_hash)) {
+ if (caa_unlikely(node->p.reverse_hash > reverse_hash)) {
node = next = NULL;
break;
}
next = rcu_dereference(node->p.next);
- if (likely(!is_removed(next))
+ if (caa_likely(!is_removed(next))
&& !is_dummy(next)
- && likely(!ht->compare_fct(node->key, node->key_len, key, key_len))) {
+ && caa_likely(!ht->compare_fct(node->key, node->key_len, key, key_len))) {
break;
}
node = clear_flag(next);
node = clear_flag(iter->next);
for (;;) {
- if (unlikely(is_end(node))) {
+ if (caa_unlikely(is_end(node))) {
node = next = NULL;
break;
}
next = rcu_dereference(node->p.next);
- if (likely(!is_removed(next))
+ if (caa_likely(!is_removed(next))
&& !is_dummy(next)) {
break;
}
}
static
-unsigned long resize_target_update(struct cds_lfht *ht, unsigned long size,
- int growth_order)
+unsigned long resize_target_grow(struct cds_lfht *ht, unsigned long new_size)
{
- return _uatomic_max(&ht->t.resize_target,
- size << growth_order);
+ return _uatomic_xchg_monotonic_increase(&ht->t.resize_target, new_size);
}
static
}
static
-void cds_lfht_resize_lazy(struct cds_lfht *ht, unsigned long size, int growth)
+void __cds_lfht_resize_lazy_launch(struct cds_lfht *ht)
{
struct rcu_resize_work *work;
- unsigned long target_size;
- target_size = resize_target_update(ht, size, growth);
/* Store resize_target before read resize_initiated */
cmm_smp_mb();
- if (!CMM_LOAD_SHARED(ht->t.resize_initiated) && size < target_size) {
+ if (!CMM_LOAD_SHARED(ht->t.resize_initiated)) {
uatomic_inc(&ht->in_progress_resize);
cmm_smp_mb(); /* increment resize count before load destroy */
if (CMM_LOAD_SHARED(ht->in_progress_destroy)) {
}
}
+static
+void cds_lfht_resize_lazy_grow(struct cds_lfht *ht, unsigned long size, int growth)
+{
+ unsigned long target_size = size << growth;
+
+ if (resize_target_grow(ht, target_size) >= target_size)
+ return;
+
+ __cds_lfht_resize_lazy_launch(ht);
+}
+
static
void cds_lfht_resize_lazy_count(struct cds_lfht *ht, unsigned long size,
unsigned long count)
{
- struct rcu_resize_work *work;
-
if (!(ht->flags & CDS_LFHT_AUTO_RESIZE))
return;
+
resize_target_update_count(ht, count);
- /* Store resize_target before read resize_initiated */
- cmm_smp_mb();
- if (!CMM_LOAD_SHARED(ht->t.resize_initiated)) {
- uatomic_inc(&ht->in_progress_resize);
- cmm_smp_mb(); /* increment resize count before load destroy */
- if (CMM_LOAD_SHARED(ht->in_progress_destroy)) {
- uatomic_dec(&ht->in_progress_resize);
- return;
- }
- work = malloc(sizeof(*work));
- work->ht = ht;
- ht->cds_lfht_call_rcu(&work->head, do_resize_cb);
- CMM_STORE_SHARED(ht->t.resize_initiated, 1);
- }
+ __cds_lfht_resize_lazy_launch(ht);
}