void cheap_tcam_insert(cheap_tcam_t *tcam,
uint8_t *mask,
uint8_t *key,
cheap_tcam_node *node,
void *data) {
tommy_list *hashmaps = &tcam->hashmaps;
tcam_hashmap_t *tcam_hashmap;
uint32_t hash = hashlittle(key, tcam->key_size, 0);
tommy_node* elem = tommy_list_head(hashmaps);
while(elem) {
tcam_hashmap = (tcam_hashmap_t *) elem->data;
if(!memcmp(mask, tcam_hashmap->mask, tcam->key_size)) {
tommy_hashlin_insert(&tcam_hashmap->hashmap, node, data, hash);
return;
}
elem = elem->next;
}
tcam_hashmap = malloc(sizeof(tcam_hashmap_t));
tommy_hashlin_init(&tcam_hashmap->hashmap);
tcam_hashmap->mask = malloc(tcam->key_size);
memcpy(tcam_hashmap->mask, mask, tcam->key_size);
tommy_list_insert_head(hashmaps, &tcam_hashmap->node, tcam_hashmap);
tommy_hashlin_insert(&tcam_hashmap->hashmap, node, data, hash);
}
int ${pd_prefix}mirroring_mapping_add(p4_pd_mirror_id_t mirror_id,
uint16_t egress_port
)
{
RMT_LOG(P4_LOG_LEVEL_VERBOSE,
"adding mirroring mapping mirror_id -> egress_port: %d -> %d\n",
mirror_id, egress_port);
mirroring_mapping_t *mapping;
mapping = tommy_hashlin_search(&mirroring_mappings,
compare_mirroring_mappings,
&mirror_id,
tommy_inthash_u32(mirror_id));
if(mapping) {
mapping->egress_port = egress_port;
}
else {
mapping = malloc(sizeof(mirroring_mapping_t));
mapping->mirror_id = mirror_id;
mapping->egress_port = egress_port;
mapping->coalescing_session = NULL;
tommy_hashlin_insert(&mirroring_mappings,
&mapping->node,
mapping,
tommy_inthash_u32(mapping->mirror_id));
}
return 0;
}
int ${pd_prefix}mirroring_mapping_add(int mirror_id, int egress_port){
RMT_LOG(P4_LOG_LEVEL_VERBOSE,
"adding mirroring mapping mirror_id -> egress_port: %d -> %d\n",
mirror_id, egress_port);
mirroring_mapping_t *mapping = malloc(sizeof(mirroring_mapping_t));
mapping->mirror_id = mirror_id;
mapping->egress_port = egress_port;
tommy_hashlin_insert(&mirroring_mappings,
&mapping->node,
mapping,
tommy_inthash_u32(mapping->mirror_id));
return 0;
}
switchlink_db_status_t switchlink_db_mac_add(switchlink_mac_addr_t mac_addr,
switchlink_handle_t bridge_h,
switchlink_handle_t intf_h) {
switchlink_db_mac_obj_t *obj =
switchlink_malloc(sizeof(switchlink_db_mac_obj_t), 1);
memcpy(obj->addr, mac_addr, sizeof(switchlink_mac_addr_t));
obj->bridge_h = bridge_h;
obj->intf_h = intf_h;
uint32_t hash;
uint8_t key[SWITCHLINK_MAC_KEY_LEN];
switchlink_db_mac_key_hash(mac_addr, bridge_h, key, &hash);
tommy_hashlin_insert(&switchlink_db_mac_obj_hash, &obj->hash_node, obj, hash);
tommy_list_insert_tail(&switchlink_db_mac_obj_list, &obj->list_node, obj);
return SWITCHLINK_DB_STATUS_SUCCESS;
}
void add_hash_table(void *ht, void *ht_node, void *ll, void *ll_node, void *obj, void *key, int key_len)
{
tommy_hashlin_insert(ht, ht_node, obj, tommy_hash_u32(0, key, key_len));
tommy_list_insert_tail(ll, ll_node, obj);
}
void test_hashlin(void)
{
tommy_list list;
tommy_hashlin hashlin;
struct object_hash* HASH;
unsigned i, n;
tommy_node* p;
unsigned limit;
unsigned count;
HASH = malloc(MAX * sizeof(struct object_hash));
for(i=0;i<MAX;++i) {
HASH[i].value = i;
}
START("hashlin stack");
limit = 10 * sqrt(MAX);
for(n=0;n<limit;++n) {
tommy_list_init(&list);
tommy_hashlin_init(&hashlin);
/* insert */
for(i=0;i<n;++i) {
tommy_list_insert_head(&list, &HASH[i].node, &HASH[i]);
tommy_hashlin_insert(&hashlin, &HASH[i].hashnode, &HASH[i], HASH[i].value);
}
count = 0;
tommy_hashlin_foreach_arg(&hashlin, count_arg, &count);
if (count != n)
abort();
/* remove */
p = tommy_list_head(&list);
while (p) {
struct object_hash* obj = p->data;
p = p->next;
tommy_hashlin_remove_existing(&hashlin, &obj->hashnode);
}
tommy_hashlin_done(&hashlin);
}
STOP();
START("hashlin queue");
limit = sqrt(MAX) / 8;
for(n=0;n<limit;++n) {
tommy_list_init(&list);
tommy_hashlin_init(&hashlin);
/* insert first run */
for(i=0;i<n;++i) {
tommy_list_insert_head(&list, &HASH[i].node, &HASH[i]);
tommy_hashlin_insert(&hashlin, &HASH[i].hashnode, &HASH[i], HASH[i].value);
}
count = 0;
tommy_hashlin_foreach_arg(&hashlin, count_arg, &count);
if (count != n)
abort();
/* insert all the others */
for(;i<MAX;++i) {
struct object_hash* obj;
/* insert one */
tommy_list_insert_head(&list, &HASH[i].node, &HASH[i]);
tommy_hashlin_insert(&hashlin, &HASH[i].hashnode, &HASH[i], HASH[i].value);
/* remove one */
p = tommy_list_head(&list);
obj = p->data;
tommy_list_remove_existing(&list, p);
tommy_hashlin_remove_existing(&hashlin, &obj->hashnode);
}
/* remove remaining */
p = tommy_list_head(&list);
while (p) {
struct object_hash* obj = p->data;
p = p->next;
tommy_hashlin_remove_existing(&hashlin, &obj->hashnode);
}
tommy_hashlin_done(&hashlin);
}
STOP();
}
