element* table_remove(BlockInfo* pRoot, BlockInfo* pBlock) { MY_PRINTF(" table remove\n"); element* pCur = pRoot; MY_ASSERT(table_search(pRoot, element_size(pBlock)) != NULL); if (pCur == pBlock) { //pCur->child //pSib if (element_child(pCur)) { element* pSib = element_sibling(pCur); pCur = element_child(pCur); element_sibling(pCur) = pSib; } else { pCur = element_sibling(pCur); } } else if (element_size(pCur) == element_size(pBlock)) { MY_ASSERT(pCur != pBlock); MY_ASSERT(element_child(pCur) != NULL); element_child(pCur) = child_remove(element_child(pCur), pBlock); } else if (element_size(pCur) < element_size(pBlock)) { MY_ASSERT(element_sibling(pCur) != NULL); element_sibling(pCur) = table_remove(element_sibling(pCur), pBlock); } else { MY_ASSERT(element_size(pCur) > element_size(pBlock)); MY_ASSERT(0); } return pCur; };
void table_main(int ac, char **av) { if (!strncmp(*av, "append", strlen(*av))) { table_append(ac, av); } else if (!strncmp(*av, "remove", strlen(*av))) { table_remove(ac, av); } else if (!strncmp(*av, "flush", strlen(*av))) { table_flush(ac, av); } else if (!strncmp(*av, "list", strlen(*av))) { table_list(ac, av); } else if (!strncmp(*av, "show", strlen(*av))) { table_show(ac, av); } else if (!strncmp(*av, "type", strlen(*av))) { table_create(ac, av); } else if (!strncmp(*av, "delete", strlen(*av))) { table_delete(ac, av); } else if (!strncmp(*av, "test", strlen(*av))) { table_test(ac,av); } else if (!strncmp(*av, "name", strlen(*av))) { table_rename(ac, av); } else { errx(EX_USAGE, "bad ipfw table command `%s'", *av); } }
DIRECT_FN STATIC int gnix_av_remove(struct fid_av *av, fi_addr_t *fi_addr, size_t count, uint64_t flags) { struct gnix_fid_av *int_av = NULL; int ret = FI_SUCCESS; GNIX_TRACE(FI_LOG_AV, "\n"); if (!av) { ret = -FI_EINVAL; goto err; } int_av = container_of(av, struct gnix_fid_av, av_fid); if (!int_av) { ret = -FI_EINVAL; goto err; } switch (int_av->type) { case FI_AV_TABLE: ret = table_remove(int_av, fi_addr, count, flags); break; case FI_AV_MAP: ret = map_remove(int_av, fi_addr, count, flags); break; default: ret = -FI_EINVAL; break; } err: return ret; }
int test_remove( void ) { ASSERT_TRUE(table_put(&test_table, L"test2", value, NULL)); ASSERT_TRUE(table_has(&test_table, L"test2")); table_remove(&test_table, L"test2", NULL); ASSERT_FALSE(table_has(&test_table, L"test2")); return 0; }
void test_hash(int prime, int table_size, int elems_count) { struct HashTableParams params = GET_HASH_PARAMS(&prime, hash_func, 0, int); struct HashTable *table = allocate_table(table_size, params); for (int i = 0; i != elems_count; ++i) { for (int j = 0; j != i; ++j) { int value = j * j; assert(table_has(table, &value)); assert(table_insert(table, &value) == 1); } for (int j = i; j != elems_count; ++j) { int value = j * j; assert(!table_has(table, &value)); assert(!table_remove(table, &value)); } int value = i * i; assert(!table_insert(table, &value)); } for (int i = 0; i != elems_count; ++i) { for (int j = i; j != elems_count; ++j) { int value = j * j; assert(table_has(table, &value)); } int value = i * i; assert(table_remove(table, &value)); assert(!table_remove(table, &value)); for (int j = 0; j != i; ++j) { int value = j * j; assert(!table_has(table, &value)); } } deallocate_table(table); }
void intt_test (void) { int_table it; unsigned i, j; TABLE_INIT (it); for (j = 0; j < 10; j++) { i = table_add (&it); assert (i != 0); TABLE_ITEM (it, i) = j + 5; printf ("Add: it[%u]=%d\r\n", i, TABLE_ITEM (it, i)); } int_table_dump (&it); table_remove (&it, 2); printf ("Remove: it[%u]\r\n", 2); table_remove (&it, 4); printf ("Remove: it[%u]\r\n", 4); int_table_dump (&it); for (j = 2; j < 12; j++) { i = table_add (&it); assert (i != 0); TABLE_ITEM (it, i) = j; printf ("Add: it[%u]=%d\r\n", i, TABLE_ITEM (it, i)); } int_table_dump (&it); TABLE_REQUIRE (it, 2, ~0); table_reset (&it); int_table_dump (&it); for (j = 0; j < 5; j++) { i = table_add (&it); assert (i != 0); TABLE_ITEM (it, i) = j + 5; printf ("Add: it[%u]=%d\r\n", i, TABLE_ITEM (it, i)); } int_table_dump (&it); }
/* FIXME */ void u_command(client c) { dstr pkey, skey; dlist_t dlist; if (dstr_length(c->argv[0]) == 1) { add_reply_error(c, "index can't be empty\r\n"); return; } pkey = dstr_new(c->argv[0] + 1); skey = dstr_new(pkey); if (c->argc > 1) { int i; for (i = 1; i < c->argc; ++i) { skey = dstr_cat(skey, ","); skey = dstr_cat(skey, c->argv[i]); } } table_rwlock_wrlock(subscribers); if ((dlist = table_get_value(subscribers, pkey))) { struct kvd *kvd; if (NEW(kvd)) { dlist_node_t node, node2; kvd->key = skey; if ((node = dlist_find(dlist, kvd))) { FREE(kvd); kvd = (struct kvd *)dlist_node_value(node); if ((node2 = dlist_find(kvd->u.dlist, c))) dlist_remove(kvd->u.dlist, node2); if (dlist_length(kvd->u.dlist) == 0) { dlist_remove(dlist, node); kdfree(kvd); } if (dlist_length(dlist) == 0) { table_remove(subscribers, pkey); dlist_free(&dlist); } } else FREE(kvd); } else add_reply_error(c, "error allocating memory for kvd"); } table_rwlock_unlock(subscribers); dstr_free(skey); dstr_free(pkey); add_reply_string(c, "\r\n", 2); }
/* FIXME */ void uall_command(client c) { dstr res = get_indices(); dstr *fields = NULL; int nfield = 0, i; RTRIM(res); fields = dstr_split_len(res, dstr_length(res), ",", 1, &nfield); for (i = 1; i < nfield; ++i) { dstr pkey = dstr_new(fields[i]); dstr skey = dstr_new(pkey); dlist_t dlist; table_rwlock_wrlock(subscribers); if ((dlist = table_get_value(subscribers, pkey))) { struct kvd *kvd; if (NEW(kvd)) { dlist_node_t node, node2; kvd->key = skey; if ((node = dlist_find(dlist, kvd))) { FREE(kvd); kvd = (struct kvd *)dlist_node_value(node); if ((node2 = dlist_find(kvd->u.dlist, c))) dlist_remove(kvd->u.dlist, node2); if (dlist_length(kvd->u.dlist) == 0) { dlist_remove(dlist, node); kdfree(kvd); } if (dlist_length(dlist) == 0) { table_remove(subscribers, pkey); dlist_free(&dlist); } } else FREE(kvd); } else add_reply_error(c, "error allocating memory for kvd"); } table_rwlock_unlock(subscribers); dstr_free(skey); dstr_free(pkey); } add_reply_string(c, "\r\n", 2); dstr_free(res); }
void test_2() { //generate_keys(30, 2); int i; enum { nNode = 50 }; int keys[nNode] = { 0x38, 0x85, 0x37, 0x55, 0x43, 0x86, 0x78, 0x23, 0x62, 0x57, 0x24, 0x02, 0x17, 0x34, 0x96, 0x22, 0x07, 0x89, 0x91, 0x12, 0x61, 0x05, 0x36, 0x09, 0x41, 0x00, 0x31, 0x88, 0x94, 0x04, 0x18, 0x97, 0x68, 0x35, 0x83, 0x53, 0x93, 0x64, 0x65, 0x03, 0x58, 0x60, 0x52, 0x15, 0x30, 0x06, 0x25, 0x32, 0x39, 0x63 }; queue q(nNode); element* pNode = NULL; element* pRoot = NULL; //init pRoot = element_crt(keys[0]); q.push(pRoot); //generate data for (i = 1; i < nNode;) { //add node pNode = element_crt(keys[i]); q.push(pNode); pRoot = table_insert(pRoot, pNode); i++; } //print int count = table_printf(pRoot); printf(" count %d\n", count); //clean for (pNode = (element*)q.pop(); pNode != NULL; pNode = (element*)q.pop()) { pRoot = table_remove(pRoot, pNode); count = table_printf(pRoot); printf(" count %d\n", count); element_del(pNode); } }
// Syfte: Funktionen tar bort tabellen och frigor minne. // Inparametrar: Pekare till en tabell. // Returnerar: Ingenting. void table_free(Table *table) { ArrayTable *t = (ArrayTable*)table; TableElement *i = calloc(1,sizeof(TableElement)); int position; // Loopar genom hela arrayen for att ta bort minne. // Avslutas nar vi natt slutet, dvs NULL. // Tar bort minnesallokering for nycklar, keys, och // minnesallokering for varden, value. for (position=0;array_hasValue(t->values,position);position++) { i=array_inspectValue(t->values,position); if(t->keyFree!=NULL) t->keyFree(i->key); if(t->valueFree!=NULL) t->valueFree(i->value); table_remove(t,i->key); } array_free(t->values); // Frigor slutligen allokerat minne for tabellen. free(t); }
//----------------------------- void test_1() { element arr[] = { { 0x100 }, { 0x200 }, { 0x300 }, { 0x300 }, { 0x400 }, }; element* pRoot = &arr[0]; for (int i = 1; i < (sizeof(arr) / sizeof(arr[0])); i++) { pRoot = table_insert(pRoot, &arr[i]); printf("insert %d\n", i); table_printf(pRoot); } for (int i = 0; i < (sizeof(arr) / sizeof(arr[0])); i++) { pRoot = table_remove(pRoot, &arr[i]); printf("remove %d\n", i); table_printf(pRoot); } }
int main () { table_t* tablePtr; long hash[] = {3, 1, 4, 1, 5, 9, 2, 6, 8, 7, -1}; long i; bool_t status = memory_init(1, 4, 2); assert(status); puts("Starting..."); tablePtr = table_alloc(8, NULL); for (i = 0; hash[i] >= 0; i++ ) { bool_t status = table_insert(tablePtr, (ulong_t)hash[i], (void*)&hash[i]) assert(status); printTable(tablePtr); puts(""); } for (i = 0; hash[i] >= 0; i++ ) { bool_t status = table_remove(tablePtr, (ulong_t)hash[i], (void*)&hash[i]) assert(status); printTable(tablePtr); puts(""); } table_free(tablePtr); puts("Done."); return 0; }
int main(int argc, char *argv[]) { FILE *fp; char buffer[512]; size_t i, j, r; unsigned int d = 0; uint64_t s, e, a, ri, si, ai, sr, rg, sg, ag, sd, ng; char **t; struct ck_ht_stat st; r = 20; s = 8; srand(time(NULL)); if (argc < 2) { ck_error("Usage: ck_ht <dictionary> [<repetitions> <initial size>]\n"); } if (argc >= 3) r = atoi(argv[2]); if (argc >= 4) s = (uint64_t)atoi(argv[3]); keys = malloc(sizeof(char *) * keys_capacity); assert(keys != NULL); fp = fopen(argv[1], "r"); assert(fp != NULL); while (fgets(buffer, sizeof(buffer), fp) != NULL) { buffer[strlen(buffer) - 1] = '\0'; keys[keys_length++] = strdup(buffer); assert(keys[keys_length - 1] != NULL); if (keys_length == keys_capacity) { t = realloc(keys, sizeof(char *) * (keys_capacity *= 2)); assert(t != NULL); keys = t; } } t = realloc(keys, sizeof(char *) * keys_length); assert(t != NULL); keys = t; table_init(); for (i = 0; i < keys_length; i++) d += table_insert(keys[i]) == false; ck_ht_stat(&ht, &st); fprintf(stderr, "# %zu entries stored, %u duplicates, %" PRIu64 " probe.\n", table_count(), d, st.probe_maximum); fprintf(stderr, "# reverse_insertion serial_insertion random_insertion serial_replace reverse_get serial_get random_get serial_remove negative_get\n\n"); a = 0; for (j = 0; j < r; j++) { if (table_reset() == false) { ck_error("ERROR: Failed to reset hash table.\n"); } s = rdtsc(); for (i = keys_length; i > 0; i--) d += table_insert(keys[i - 1]) == false; e = rdtsc(); a += e - s; } ri = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { if (table_reset() == false) { ck_error("ERROR: Failed to reset hash table.\n"); } s = rdtsc(); for (i = 0; i < keys_length; i++) d += table_insert(keys[i]) == false; e = rdtsc(); a += e - s; } si = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { keys_shuffle(keys); if (table_reset() == false) { ck_error("ERROR: Failed to reset hash table.\n"); } s = rdtsc(); for (i = 0; i < keys_length; i++) d += table_insert(keys[i]) == false; e = rdtsc(); a += e - s; } ai = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) table_replace(keys[i]); e = rdtsc(); a += e - s; } sr = a / (r * keys_length); table_reset(); for (i = 0; i < keys_length; i++) table_insert(keys[i]); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = keys_length; i > 0; i--) { if (table_get(keys[i - 1]) == NULL) { ck_error("ERROR: Unexpected NULL value.\n"); } } e = rdtsc(); a += e - s; } rg = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) { if (table_get(keys[i]) == NULL) { ck_error("ERROR: Unexpected NULL value.\n"); } } e = rdtsc(); a += e - s; } sg = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { keys_shuffle(keys); s = rdtsc(); for (i = 0; i < keys_length; i++) { if (table_get(keys[i]) == NULL) { ck_error("ERROR: Unexpected NULL value.\n"); } } e = rdtsc(); a += e - s; } ag = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) table_remove(keys[i]); e = rdtsc(); a += e - s; for (i = 0; i < keys_length; i++) table_insert(keys[i]); } sd = a / (r * keys_length); a = 0; for (j = 0; j < r; j++) { s = rdtsc(); for (i = 0; i < keys_length; i++) { table_get("\x50\x03\x04\x05\x06\x10"); } e = rdtsc(); a += e - s; } ng = a / (r * keys_length); printf("%zu " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 " " "%" PRIu64 "\n", keys_length, ri, si, ai, sr, rg, sg, ag, sd, ng); return 0; }
int main() { table_t tab = table_new(1024, cmp, dictGenHashFunction); table_put(tab, "append", "cmd_append"); table_put(tab, "bitcount", "cmd_bitcount"); table_put(tab, "brpop", "cmd_brpop"); table_put(tab, "brpoplpush", "cmd_brpoplpush"); table_put(tab, "decr", "cmd_decr"); table_put(tab, "decrby", "cmd_decrby"); table_put(tab, "del", "cmd_del"); table_put(tab, "exists", "cmd_exists"); table_put(tab, "get", "cmd_get"); table_put(tab, "getbit", "cmd_getbit"); table_put(tab, "getrange", "cmd_getrange"); table_put(tab, "incr", "cmd_incr"); table_put(tab, "incrby", "cmd_incrby"); table_put(tab, "keys", "cmd_keys"); table_put(tab, "lindex", "cmd_lindex"); table_put(tab, "linsert", "cmd_linsert"); table_put(tab, "llen", "cmd_llen"); table_put(tab, "lpop", "cmd_lpop"); table_put(tab, "lpush", "cmd_lpush"); table_put(tab, "lpushx", "cmd_lpushx"); table_put(tab, "lrange", "cmd_lrange"); table_put(tab, "lrem", "cmd_lrem"); table_put(tab, "lset", "cmd_lset"); table_put(tab, "ltrim", "cmd_ltrim"); table_put(tab, "mget", "cmd_mget"); table_put(tab, "msetnx", "cmd_msetnx"); table_put(tab, "randomkey", "cmd_randomkey"); table_put(tab, "rename", "cmd_rename"); table_put(tab, "rpop", "cmd_rpop"); table_put(tab, "rpoplpush", "cmd_rpoplpush"); table_put(tab, "rpush", "cmd_rpush"); table_put(tab, "rpushx", "cmd_rpushx"); table_put(tab, "set", "cmd_set"); table_put(tab, "setbit", "cmd_setbit"); table_put(tab, "setrange", "cmd_setrange"); table_put(tab, "strlen", "cmd_strlen"); table_put(tab, "type", "cmd_type"); table_map(tab, apply); printf("len = %d\n", table_length(tab)); char key[32]; scanf("%s", key); printf("%s\n", (char *)table_get(tab, key)); printf("remove set\n"); table_remove(tab, "set"); table_map(tab, apply); printf("len = %d\n", table_length(tab)); scanf("%s", key); printf("%s\n", (char *)table_get(tab, key)); table_free(&tab); return 0; }
void test_table(void) { int i; void* T = table_create(100, NULL, NULL); fprintf(stdout, "call function : %s\n", __func__); table_object(T); fprintf(stdout, "\ntest function - table_insert ===>\n"); { srand((unsigned int)time(0)); for (i = 0; i < 5; ++i) { double* d = (double*)malloc(sizeof(double)); *d = (i + 1) * rand() % 5000 * 0.123; fprintf(stdout, "\tinsert {key=>%d,value=>{object=>0x%p,value=>%.3f}}\n", i, d, *d); table_insert(T, (const void*)i, d); } table_for_each(T, table_key_value_show, NULL); table_for_each(T, table_key_value_destroy, NULL); table_object(T); table_clear(T); } table_object(T); fprintf(stdout, "\ntest function - table_remove ===>\n"); { srand((unsigned int)time(0)); for (i = 0; i < 5; ++i) { double* d = (double*)malloc(sizeof(double)); *d = (i + 1) * rand() % 5000 * 0.123; fprintf(stdout, "\tinsert {key=>%d,value=>{object=>0x%p,value=>%.3f}}\n", i, d, *d); table_insert(T, (const void*)i, d); } table_for_each(T, table_key_value_show, NULL); table_for_each(T, table_key_value_destroy, NULL); table_object(T); for (i = 0; i < 5; ++i) table_remove(T, (const void*)i); table_object(T); table_clear(T); } table_object(T); fprintf(stdout, "\ntest function - table_get ===>\n"); { double* d; srand((unsigned int)time(0)); for (i = 0; i < 5; ++i) { d = (double*)malloc(sizeof(double)); *d = (i + 1) * rand() % 5000 * 0.123; fprintf(stdout, "\tinsert {key=>%d,value=>{object=>0x%p,value=>%.3f}}\n", i, d, *d); table_insert(T, (const void*)i, d); } table_object(T); d = table_get(T, (const void*)3); if (NULL != d) fprintf(stdout, "\t{key=>3, value=>0x%p} => %.3f\n", d, *d); table_for_each(T, table_key_value_show, NULL); table_for_each(T, table_key_value_destroy, NULL); table_clear(T); } table_object(T); fprintf(stdout, "\ntest function - table_release ===>\n"); table_release(&T); table_object(T); }
/* FIXME */ static void *q_thread(void *data) { struct crss *crss = (struct crss *)data; char buf[64]; dstr rid, res = NULL; db_iterator_t *it; const char *key, *value; size_t klen, vlen; snprintf(buf, sizeof buf, "%p,", crss->c); rid = dstr_new(buf); rid = dstr_cat(rid, crss->rid); it = db_iterator_create(db, db_ro); db_iterator_seek(it, crss->start, dstr_length(crss->start)); /* seek failed */ if (!db_iterator_valid(it)) { res = dstr_new(crss->rid); res = dstr_cat(res, ",1\r\n\r\n"); pthread_spin_lock(&crss->c->lock); if (net_try_write(crss->c->fd, res, dstr_length(res), 10, NET_NONBLOCK) == -1) xcb_log(XCB_LOG_WARNING, "Writing to client '%p': %s", crss->c, strerror(errno)); pthread_spin_unlock(&crss->c->lock); goto end; } key = db_iterator_key(it, &klen); while (memcmp(key, crss->stop, dstr_length(crss->stop)) <= 0) { if (crss->cancel) break; if (!strcmp(crss->match, "") || strstr(key, crss->match)) { value = db_iterator_value(it, &vlen); res = dstr_new(crss->rid); res = dstr_cat(res, ",0,"); res = dstr_cat_len(res, key, klen); res = dstr_cat(res, ","); res = dstr_cat_len(res, value, vlen); res = dstr_cat(res, "\r\n"); pthread_spin_lock(&crss->c->lock); if (net_try_write(crss->c->fd, res, dstr_length(res), 10, NET_NONBLOCK) == -1) { xcb_log(XCB_LOG_WARNING, "Writing to client '%p': %s", crss->c, strerror(errno)); pthread_spin_unlock(&crss->c->lock); goto end; } pthread_spin_unlock(&crss->c->lock); dstr_free(res); } db_iterator_next(it); if (!db_iterator_valid(it) || crss->cancel) break; key = db_iterator_key(it, &klen); } res = dstr_new(crss->rid); res = dstr_cat(res, ",1\r\n\r\n"); pthread_spin_lock(&crss->c->lock); if (net_try_write(crss->c->fd, res, dstr_length(res), 10, NET_NONBLOCK) == -1) xcb_log(XCB_LOG_WARNING, "Writing to client '%p': %s", crss->c, strerror(errno)); pthread_spin_unlock(&crss->c->lock); end: db_iterator_destroy(&it); dstr_free(res); table_lock(rids); table_remove(rids, rid); table_unlock(rids); dstr_free(rid); client_decr(crss->c); dstr_free(crss->rid); dstr_free(crss->match); dstr_free(crss->start); dstr_free(crss->stop); FREE(crss); return NULL; }