int test_hash_rw_populate_hash(void)
{
struct lfht_test_node *node;
if (!init_populate)
return 0;
printf("Starting rw test\n");
URCU_TLS(rand_lookup) = urcu_get_thread_id() ^ time(NULL);
if ((add_unique || add_replace) && init_populate * 10 > init_pool_size) {
printf("WARNING: required to populate %lu nodes (-k), but random "
"pool is quite small (%lu values) and we are in add_unique (-u) or add_replace (-s) mode. Try with a "
"larger random pool (-p option). This may take a while...\n", init_populate, init_pool_size);
}
while (URCU_TLS(nr_add) < init_populate) {
struct cds_lfht_node *ret_node = NULL;
node = malloc(sizeof(struct lfht_test_node));
lfht_test_node_init(node,
(void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % init_pool_size) + init_pool_offset),
sizeof(void *));
rcu_read_lock();
if (add_unique) {
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,
test_hash(node->key, node->key_len, TEST_HASH_SEED),
test_match, node->key, &node->node);
else
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->node) {
free(node);
URCU_TLS(nr_addexist)++;
} else {
if (add_replace && ret_node) {
call_rcu(&to_test_node(ret_node)->head, free_node_cb);
URCU_TLS(nr_addexist)++;
} else {
URCU_TLS(nr_add)++;
}
}
URCU_TLS(nr_writes)++;
}
return 0;
}
/*
* Add unique string node to hashtable.
*/
void lttng_ht_add_unique_str(struct lttng_ht *ht,
struct lttng_ht_node_str *node)
{
struct cds_lfht_node *node_ptr;
assert(ht);
assert(ht->ht);
assert(node);
/* RCU read lock protects from ABA. */
rcu_read_lock();
node_ptr = cds_lfht_add_unique(ht->ht, ht->hash_fct(node->key, lttng_ht_seed),
ht->match_fct, node->key, &node->node);
rcu_read_unlock();
assert(node_ptr == &node->node);
}
/*
* Create a ust_registry_event from the given parameters and add it to the
* registry hash table. If event_id is valid, it is set with the newly created
* event id.
*
* On success, return 0 else a negative value. The created event MUST be unique
* so on duplicate entry -EINVAL is returned. On error, event_id is untouched.
*
* Should be called with session registry mutex held.
*/
int ust_registry_create_event(struct ust_registry_session *session,
uint64_t chan_key, int session_objd, int channel_objd, char *name,
char *sig, size_t nr_fields, struct ustctl_field *fields,
int loglevel_value, char *model_emf_uri, int buffer_type,
uint32_t *event_id_p, struct ust_app *app)
{
int ret;
uint32_t event_id;
struct cds_lfht_node *nptr;
struct ust_registry_event *event = NULL;
struct ust_registry_channel *chan;
assert(session);
assert(name);
assert(sig);
assert(event_id_p);
rcu_read_lock();
/*
* This should not happen but since it comes from the UST tracer, an
* external party, don't assert and simply validate values.
*/
if (session_objd < 0 || channel_objd < 0) {
ret = -EINVAL;
goto error_free;
}
chan = ust_registry_channel_find(session, chan_key);
if (!chan) {
ret = -EINVAL;
goto error_free;
}
/* Check if we've reached the maximum possible id. */
if (ust_registry_is_max_id(chan->used_event_id)) {
ret = -ENOENT;
goto error_free;
}
event = alloc_event(session_objd, channel_objd, name, sig, nr_fields,
fields, loglevel_value, model_emf_uri, app);
if (!event) {
ret = -ENOMEM;
goto error_free;
}
DBG3("UST registry creating event with event: %s, sig: %s, id: %u, "
"chan_objd: %u, sess_objd: %u, chan_id: %u", event->name,
event->signature, event->id, event->channel_objd,
event->session_objd, chan->chan_id);
/*
* This is an add unique with a custom match function for event. The node
* are matched using the event name and signature.
*/
nptr = cds_lfht_add_unique(chan->ht->ht, chan->ht->hash_fct(event,
lttng_ht_seed), chan->ht->match_fct, event, &event->node.node);
if (nptr != &event->node.node) {
if (buffer_type == LTTNG_BUFFER_PER_UID) {
/*
* This is normal, we just have to send the event id of the
* returned node and make sure we destroy the previously allocated
* event object.
*/
destroy_event(event);
event = caa_container_of(nptr, struct ust_registry_event,
node.node);
assert(event);
event_id = event->id;
} else {
void *test_hash_rw_thr_writer(void *_count)
{
struct lfht_test_node *node;
struct cds_lfht_node *ret_node;
struct cds_lfht_iter iter;
struct wr_count *count = _count;
int ret;
printf_verbose("thread_begin %s, tid %lu\n",
"writer", urcu_get_thread_id());
URCU_TLS(rand_lookup) = urcu_get_thread_id() ^ time(NULL);
set_affinity();
rcu_register_thread();
while (!test_go)
{
}
cmm_smp_mb();
for (;;) {
if ((addremove == AR_ADD || add_only)
|| (addremove == AR_RANDOM && rand_r(&URCU_TLS(rand_lookup)) & 1)) {
node = malloc(sizeof(struct lfht_test_node));
lfht_test_node_init(node,
(void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % write_pool_size) + write_pool_offset),
sizeof(void *));
rcu_read_lock();
if (add_unique) {
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,
test_hash(node->key, node->key_len, TEST_HASH_SEED),
test_match, node->key, &node->node);
else
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->node) {
free(node);
URCU_TLS(nr_addexist)++;
} else {
if (add_replace && ret_node) {
call_rcu(&to_test_node(ret_node)->head,
free_node_cb);
URCU_TLS(nr_addexist)++;
} else {
URCU_TLS(nr_add)++;
}
}
} else {
/* May delete */
rcu_read_lock();
cds_lfht_test_lookup(test_ht,
(void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % write_pool_size) + write_pool_offset),
sizeof(void *), &iter);
ret = cds_lfht_del(test_ht, cds_lfht_iter_get_node(&iter));
rcu_read_unlock();
if (ret == 0) {
node = cds_lfht_iter_get_test_node(&iter);
call_rcu(&node->head, free_node_cb);
URCU_TLS(nr_del)++;
} else
URCU_TLS(nr_delnoent)++;
}
#if 0
//if (URCU_TLS(nr_writes) % 100000 == 0) {
if (URCU_TLS(nr_writes) % 1000 == 0) {
rcu_read_lock();
if (rand_r(&URCU_TLS(rand_lookup)) & 1) {
ht_resize(test_ht, 1);
} else {
ht_resize(test_ht, -1);
}
rcu_read_unlock();
}
#endif //0
URCU_TLS(nr_writes)++;
if (caa_unlikely(!test_duration_write()))
break;
if (caa_unlikely(wdelay))
loop_sleep(wdelay);
if (caa_unlikely((URCU_TLS(nr_writes) & ((1 << 10) - 1)) == 0))
rcu_quiescent_state();
}
rcu_unregister_thread();
printf_verbose("thread_end %s, tid %lu\n",
"writer", urcu_get_thread_id());
printf_verbose("info tid %lu: nr_add %lu, nr_addexist %lu, nr_del %lu, "
"nr_delnoent %lu\n", urcu_get_thread_id(),
URCU_TLS(nr_add),
URCU_TLS(nr_addexist),
URCU_TLS(nr_del),
URCU_TLS(nr_delnoent));
count->update_ops = URCU_TLS(nr_writes);
count->add = URCU_TLS(nr_add);
count->add_exist = URCU_TLS(nr_addexist);
count->remove = URCU_TLS(nr_del);
return ((void*)2);
}
UA_StatusCode UA_NodeStore_insert(UA_NodeStore *ns, UA_Node *node, const UA_Node **inserted) {
size_t nodesize;
/* Copy the node into the entry. Then reset the original node. It shall no longer be used. */
switch(node->nodeClass) {
case UA_NODECLASS_OBJECT:
nodesize = sizeof(UA_ObjectNode);
break;
case UA_NODECLASS_VARIABLE:
nodesize = sizeof(UA_VariableNode);
break;
case UA_NODECLASS_METHOD:
nodesize = sizeof(UA_MethodNode);
break;
case UA_NODECLASS_OBJECTTYPE:
nodesize = sizeof(UA_ObjectTypeNode);
break;
case UA_NODECLASS_VARIABLETYPE:
nodesize = sizeof(UA_VariableTypeNode);
break;
case UA_NODECLASS_REFERENCETYPE:
nodesize = sizeof(UA_ReferenceTypeNode);
break;
case UA_NODECLASS_DATATYPE:
nodesize = sizeof(UA_DataTypeNode);
break;
case UA_NODECLASS_VIEW:
nodesize = sizeof(UA_ViewNode);
break;
default:
return UA_STATUSCODE_BADINTERNALERROR;
}
struct nodeEntry *entry;
if(!(entry = UA_malloc(sizeof(struct nodeEntry) - sizeof(UA_Node) + nodesize)))
return UA_STATUSCODE_BADOUTOFMEMORY;
memcpy((void*)&entry->node, node, nodesize);
cds_lfht_node_init(&entry->htn);
entry->refcount = ALIVE_BIT;
if(inserted) // increase the counter before adding the node
entry->refcount++;
struct cds_lfht_node *result;
//FIXME: a bit dirty workaround of preserving namespace
//namespace index is assumed to be valid
UA_NodeId tempNodeid;
UA_NodeId_copy(&node->nodeId, &tempNodeid);
tempNodeid.namespaceIndex = 0;
if(!UA_NodeId_isNull(&tempNodeid)) {
hash_t h = hash(&node->nodeId);
rcu_read_lock();
result = cds_lfht_add_unique(ns->ht, h, compare, &entry->node.nodeId, &entry->htn);
rcu_read_unlock();
/* If the nodeid exists already */
if(result != &entry->htn) {
UA_free(entry);
return UA_STATUSCODE_BADNODEIDEXISTS;
}
} else {
/* create a unique nodeid */
((UA_Node *)&entry->node)->nodeId.identifierType = UA_NODEIDTYPE_NUMERIC;
if(((UA_Node *)&entry->node)->nodeId.namespaceIndex == 0) //original request for ns=0 should yield ns=1
((UA_Node *)&entry->node)->nodeId.namespaceIndex = 1;
if(((UA_Node *)&entry->node)->nodeClass==UA_NODECLASS_VARIABLE){ //set namespaceIndex in browseName in case id is generated
((UA_VariableNode*)&entry->node)->browseName.namespaceIndex=((UA_Node *)&entry->node)->nodeId.namespaceIndex;
}
unsigned long identifier;
long before, after;
rcu_read_lock();
cds_lfht_count_nodes(ns->ht, &before, &identifier, &after); // current amount of nodes stored
identifier++;
((UA_Node *)&entry->node)->nodeId.identifier.numeric = identifier;
while(UA_TRUE) {
hash_t nhash = hash(&entry->node.nodeId);
result = cds_lfht_add_unique(ns->ht, nhash, compare, &entry->node.nodeId, &entry->htn);
if(result == &entry->htn)
break;
((UA_Node *)&entry->node)->nodeId.identifier.numeric += (identifier * 2654435761);
}
rcu_read_unlock();
}
UA_NodeId_deleteMembers(&tempNodeid);
UA_free(node);
if(inserted)
*inserted = &entry->node;
return UA_STATUSCODE_GOOD;
}
