#endif
#define DEFAULT_HASH_SIZE 32
+#define DEFAULT_MIN_ALLOC_SIZE 1
#define DEFAULT_RAND_POOL 1000000
+#define TEST_HASH_SEED 0x42UL
+
/* Make this big enough to include the POWER5+ L3 cacheline size of 256B */
#define CACHE_LINE_SIZE 4096
int b;
};
+struct lfht_test_node {
+ struct cds_lfht_node node;
+ void *key;
+ unsigned int key_len;
+ /* cache-cold for iteration */
+ struct rcu_head head;
+};
+
+static inline struct lfht_test_node *
+to_test_node(struct cds_lfht_node *node)
+{
+ return caa_container_of(node, struct lfht_test_node, node);
+}
+
+static inline
+void lfht_test_node_init(struct lfht_test_node *node, void *key,
+ size_t key_len)
+{
+ cds_lfht_node_init(&node->node);
+ node->key = key;
+ node->key_len = key_len;
+}
+
+static inline struct lfht_test_node *
+cds_lfht_iter_get_test_node(struct cds_lfht_iter *iter)
+{
+ return to_test_node(cds_lfht_iter_get_node(iter));
+}
+
static volatile int test_go, test_stop;
static unsigned long wdelay;
static unsigned long rduration;
static unsigned long init_hash_size = DEFAULT_HASH_SIZE;
+static unsigned long min_hash_alloc_size = DEFAULT_MIN_ALLOC_SIZE;
static unsigned long init_populate;
static int opt_auto_resize;
static int add_only, add_unique, add_replace;
void sigusr2_handler(int signo)
{
char msg[1] = { 0x42 };
- write(count_pipe[1], msg, 1); /* wakeup thread */
+ ssize_t ret;
+
+ do {
+ ret = write(count_pipe[1], msg, 1); /* wakeup thread */
+ } while (ret == -1L && errno == EINTR);
}
/*
#if (CAA_BITS_PER_LONG == 32)
static
-unsigned long test_hash(void *_key, size_t length, unsigned long seed)
+unsigned long test_hash(const void *_key, size_t length, unsigned long seed)
{
- unsigned long key = (unsigned long) _key;
+ unsigned int key = (unsigned int) _key;
- assert(length == sizeof(unsigned long));
+ assert(length == sizeof(unsigned int));
return hash_u32(&key, 1, seed);
}
#else
static
-unsigned long test_hash(void *_key, size_t length, unsigned long seed)
+unsigned long test_hash(const void *_key, size_t length, unsigned long seed)
{
union {
uint64_t v64;
#endif
static
-unsigned long test_compare(void *key1, size_t key1_len,
- void *key2, size_t key2_len)
+unsigned long test_compare(const void *key1, size_t key1_len,
+ const void *key2, size_t key2_len)
{
- if (unlikely(key1_len != key2_len))
+ if (caa_unlikely(key1_len != key2_len))
return -1;
assert(key1_len == sizeof(unsigned long));
if (key1 == key2)
return 1;
}
+static
+int test_match(struct cds_lfht_node *node, const void *key)
+{
+ struct lfht_test_node *test_node = to_test_node(node);
+
+ return !test_compare(test_node->key, test_node->key_len,
+ key, sizeof(unsigned long));
+}
+
+static
+void cds_lfht_test_lookup(struct cds_lfht *ht, void *key, size_t key_len,
+ struct cds_lfht_iter *iter)
+{
+ assert(key_len == sizeof(unsigned long));
+
+ cds_lfht_lookup(ht, test_hash(key, key_len, TEST_HASH_SEED),
+ test_match, key, iter);
+}
+
void *thr_count(void *arg)
{
printf_verbose("thread_begin %s, thread id : %lx, tid %lu\n",
rcu_thread_offline();
len = read(count_pipe[0], buf, 1);
rcu_thread_online();
- if (unlikely(!test_duration_read()))
+ if (caa_unlikely(!test_duration_read()))
break;
if (len != 1)
continue;
void *thr_reader(void *_count)
{
unsigned long long *count = _count;
- struct cds_lfht_node *node;
+ struct lfht_test_node *node;
struct cds_lfht_iter iter;
printf_verbose("thread_begin %s, thread id : %lx, tid %lu\n",
for (;;) {
rcu_read_lock();
- cds_lfht_lookup(test_ht,
+ cds_lfht_test_lookup(test_ht,
(void *)(((unsigned long) rand_r(&rand_lookup) % lookup_pool_size) + lookup_pool_offset),
sizeof(void *), &iter);
- node = cds_lfht_iter_get_node(&iter);
+ node = cds_lfht_iter_get_test_node(&iter);
if (node == NULL) {
if (validate_lookup) {
printf("[ERROR] Lookup cannot find initial node.\n");
lookup_ok++;
}
debug_yield_read();
- if (unlikely(rduration))
+ if (caa_unlikely(rduration))
loop_sleep(rduration);
rcu_read_unlock();
nr_reads++;
- if (unlikely(!test_duration_read()))
+ if (caa_unlikely(!test_duration_read()))
break;
- if (unlikely((nr_reads & ((1 << 10) - 1)) == 0))
+ if (caa_unlikely((nr_reads & ((1 << 10) - 1)) == 0))
rcu_quiescent_state();
}
static
void free_node_cb(struct rcu_head *head)
{
- struct cds_lfht_node *node =
- caa_container_of(head, struct cds_lfht_node, head);
+ struct lfht_test_node *node =
+ caa_container_of(head, struct lfht_test_node, head);
free(node);
}
void *thr_writer(void *_count)
{
- struct cds_lfht_node *node, *ret_node;
+ struct lfht_test_node *node;
+ struct cds_lfht_node *ret_node;
struct cds_lfht_iter iter;
struct wr_count *count = _count;
int ret;
for (;;) {
if ((addremove == AR_ADD || add_only)
|| (addremove == AR_RANDOM && rand_r(&rand_lookup) & 1)) {
- node = malloc(sizeof(struct cds_lfht_node));
- cds_lfht_node_init(node,
+ node = malloc(sizeof(struct lfht_test_node));
+ lfht_test_node_init(node,
(void *)(((unsigned long) rand_r(&rand_lookup) % write_pool_size) + write_pool_offset),
sizeof(void *));
rcu_read_lock();
if (add_unique) {
- ret_node = cds_lfht_add_unique(test_ht, node);
+ ret_node = cds_lfht_add_unique(test_ht,
+ test_hash(node->key, node->key_len, TEST_HASH_SEED),
+ test_match, node->key, &node->node);
} else {
if (add_replace)
- ret_node = cds_lfht_add_replace(test_ht, node);
+ ret_node = cds_lfht_add_replace(test_ht,
+ test_hash(node->key, node->key_len, TEST_HASH_SEED),
+ test_match, node->key, &node->node);
else
- cds_lfht_add(test_ht, node);
+ cds_lfht_add(test_ht,
+ test_hash(node->key, node->key_len, TEST_HASH_SEED),
+ &node->node);
}
rcu_read_unlock();
- if (add_unique && ret_node != node) {
+ if (add_unique && ret_node != &node->node) {
free(node);
nr_addexist++;
} else {
if (add_replace && ret_node) {
- call_rcu(&ret_node->head, free_node_cb);
+ call_rcu(&to_test_node(ret_node)->head,
+ free_node_cb);
nr_addexist++;
} else {
nr_add++;
} else {
/* May delete */
rcu_read_lock();
- cds_lfht_lookup(test_ht,
+ cds_lfht_test_lookup(test_ht,
(void *)(((unsigned long) rand_r(&rand_lookup) % write_pool_size) + write_pool_offset),
sizeof(void *), &iter);
ret = cds_lfht_del(test_ht, &iter);
rcu_read_unlock();
if (ret == 0) {
- node = cds_lfht_iter_get_node(&iter);
+ node = cds_lfht_iter_get_test_node(&iter);
call_rcu(&node->head, free_node_cb);
nr_del++;
} else
}
#endif //0
nr_writes++;
- if (unlikely(!test_duration_write()))
+ if (caa_unlikely(!test_duration_write()))
break;
- if (unlikely(wdelay))
+ if (caa_unlikely(wdelay))
loop_sleep(wdelay);
- if (unlikely((nr_writes & ((1 << 10) - 1)) == 0))
+ if (caa_unlikely((nr_writes & ((1 << 10) - 1)) == 0))
rcu_quiescent_state();
}
static int populate_hash(void)
{
- struct cds_lfht_node *node, *ret_node;
+ struct lfht_test_node *node;
+ struct cds_lfht_node *ret_node;
if (!init_populate)
return 0;
}
while (nr_add < init_populate) {
- node = malloc(sizeof(struct cds_lfht_node));
- cds_lfht_node_init(node,
+ node = malloc(sizeof(struct lfht_test_node));
+ lfht_test_node_init(node,
(void *)(((unsigned long) rand_r(&rand_lookup) % init_pool_size) + init_pool_offset),
sizeof(void *));
rcu_read_lock();
if (add_unique) {
- ret_node = cds_lfht_add_unique(test_ht, node);
+ ret_node = cds_lfht_add_unique(test_ht,
+ test_hash(node->key, node->key_len, TEST_HASH_SEED),
+ test_match, node->key, &node->node);
} else {
if (add_replace)
- ret_node = cds_lfht_add_replace(test_ht, node);
+ ret_node = cds_lfht_add_replace(test_ht,
+ test_hash(node->key, node->key_len, TEST_HASH_SEED),
+ test_match, node->key, &node->node);
else
- cds_lfht_add(test_ht, node);
+ cds_lfht_add(test_ht,
+ test_hash(node->key, node->key_len, TEST_HASH_SEED),
+ &node->node);
}
rcu_read_unlock();
- if (add_unique && ret_node != node) {
+ if (add_unique && ret_node != &node->node) {
free(node);
nr_addexist++;
} else {
if (add_replace && ret_node) {
- call_rcu(&ret_node->head, free_node_cb);
+ call_rcu(&to_test_node(ret_node)->head, free_node_cb);
nr_addexist++;
} else {
nr_add++;
void test_delete_all_nodes(struct cds_lfht *ht)
{
struct cds_lfht_iter iter;
- struct cds_lfht_node *node;
+ struct lfht_test_node *node;
unsigned long count = 0;
- cds_lfht_first(ht, &iter);
- while ((node = cds_lfht_iter_get_node(&iter)) != NULL) {
+ cds_lfht_for_each_entry(ht, &iter, node, node) {
int ret;
ret = cds_lfht_del(test_ht, &iter);
assert(!ret);
call_rcu(&node->head, free_node_cb);
- cds_lfht_next(ht, &iter);
count++;
}
printf("deleted %lu nodes.\n", count);
printf(" [-v] (verbose output)\n");
printf(" [-a cpu#] [-a cpu#]... (affinity)\n");
printf(" [-h size] (initial hash table size)\n");
+ printf(" [-m size] (minimum hash alloc size)\n");
printf(" [not -u nor -s] Add entries (supports redundant keys).\n");
printf(" [-u] Uniquify add (no redundant keys).\n");
printf(" [-s] Replace (swap) entries.\n");
}
init_hash_size = atol(argv[++i]);
break;
+ case 'm':
+ if (argc < i + 2) {
+ show_usage(argc, argv);
+ return -1;
+ }
+ min_hash_alloc_size = atol(argv[++i]);
+ break;
case 'u':
if (add_replace) {
printf("Please specify at most one of -s or -u.\n");
return -1;
}
+ if (min_hash_alloc_size && min_hash_alloc_size & (min_hash_alloc_size - 1)) {
+ printf("Error: Min hash alloc size %lu is not a power of 2.\n",
+ min_hash_alloc_size);
+ return -1;
+ }
+
memset(&act, 0, sizeof(act));
ret = sigemptyset(&act.sa_mask);
if (ret == -1) {
add_only ? " add only" : " add/remove",
add_unique ? " uniquify" : ( add_replace ? " replace" : " insert"));
printf_verbose("Initial hash table size: %lu buckets.\n", init_hash_size);
+ printf_verbose("Minimum hash alloc size: %lu buckets.\n", min_hash_alloc_size);
printf_verbose("Init pool size offset %lu size %lu.\n",
init_pool_offset, init_pool_size);
printf_verbose("Lookup pool size offset %lu size %lu.\n",
* thread from the point of view of resize.
*/
rcu_register_thread();
- test_ht = cds_lfht_new(test_hash, test_compare, 0x42UL,
- init_hash_size,
- opt_auto_resize ? CDS_LFHT_AUTO_RESIZE : 0, NULL);
+ test_ht = cds_lfht_new(init_hash_size, min_hash_alloc_size, (1UL << 18),
+ (opt_auto_resize ? CDS_LFHT_AUTO_RESIZE : 0) |
+ CDS_LFHT_ACCOUNTING, NULL);
ret = populate_hash();
assert(!ret);
}
{
char msg[1] = { 0x42 };
- write(count_pipe[1], msg, 1); /* wakeup thread */
+ ssize_t ret;
+
+ do {
+ ret = write(count_pipe[1], msg, 1); /* wakeup thread */
+ } while (ret == -1L && errno == EINTR);
}
err = pthread_join(tid_count, &tret);
if (err != 0)
projects / urcu.git / blobdiff