void test_htable_erase() {
htable *ht = htable_create();
htable_insert(ht, "one", "1st value");
htable_insert(ht, "two", "2nd value");
htable_erase(ht, "one");
assert(0 == htable_count(ht, "one")
&& "Bucket with key one should not exist.");
htable_destroy(ht);
}
/**
*
Creates a hashtable, and inserts words into it.
The table is then printed before we free the memory allocated to it.
Note: The tablesize of the hashtable is determined by the first command line
argument if there is one, with a default table tablesize of 113.
The number of statistical snapshots to print is determined by the second
command line argument if there is one, with a default number of 10.
tablesize = the maximum number of positions in the hash table.
word = the string to be inserted into the hash table.
ht = the hash table using eith double hashing or linear probing.
snapshots = the number of statistical snapshots to be used.
@param argc the number of command-line arguments.
@param argv an array of strings containing the command-line arguments.
@return EXIT_SUCCESS if the program is successful.
*/
int main(int argc, char **argv) {
time_t start,end;
bool_t entire_table = FALSE, double_hashing = FALSE, print_stats = FALSE,
do_spell_check = FALSE;
int tablesize = 113, snapshots = 10;
char word[256];
char *filename;
htable ht;
set_flags(argc, argv, &do_spell_check, &filename, &double_hashing, &entire_table,
&print_stats, &snapshots, &tablesize);
ht = htable_new(tablesize, (double_hashing) ? DOUBLE_H : LINEAR_P);
start = clock();
while (getword(word, sizeof word, stdin) != EOF) {
htable_insert(ht, word);
}
end = clock();
if(do_spell_check) {
spell_check(ht,filename,(end-start)/(double)CLOCKS_PER_SEC);
}
if (entire_table) {
htable_print_entire_table(ht, stderr);
}
if (print_stats) {
htable_print_stats(ht, stdout, snapshots);
} else if (!do_spell_check){ /* print words and frequencies */
htable_print(ht, stdout);
}
htable_delete(ht);
return EXIT_SUCCESS;
}
static void
search_gui_flush_queue_data(search_t *search, GtkTreeModel *model,
struct result_data *rd)
{
GtkTreeIter *parent_iter;
record_t *rc;
rc = rd->record;
record_check(rc);
if (rc->sha1) {
struct result_data *parent;
parent = find_parent(search, rd);
parent_iter = parent ? &parent->iter : NULL;
if (parent) {
record_check(parent->record);
parent->children++;
search_gui_data_changed(model, parent);
} else {
htable_insert(search->parents, rd, rd);
}
} else {
parent_iter = NULL;
}
gtk_tree_store_append(GTK_TREE_STORE(model), &rd->iter, parent_iter);
search_gui_set_data(model, rd);
}
//k and v both are in stack
//k td
//v mvalue.data
int
insert_kv_mem(struct rbtree *rbt, struct htable *ds, uchar * k, int klen,
int type, uchar * v, int vlen, int hijack, packet_type *lowerdomain)
{
uchar *val = NULL;
struct mvalue *mv = NULL, tmp = {0};
int ret = -1;
struct rbnode *pn = NULL;
struct ttlnode tn = { 0 }, *tmp_tn = NULL;
int idx;
if (vlen < 0 || vlen > MAX_RECORD_SIZE)
return -1;
hashval_t *hash = &(lowerdomain->hash[0]);
idx = get_pre_mem_hash(k, klen, hash);
val = malloc(vlen);
if (val == NULL)
return -1;
memcpy(val, v, vlen);
mv = (struct mvalue *) v;
ret = htable_insert(ds + idx, k, klen, type, val, 1, &tmp, hash); //mem, replace
if (ret >= HTABLE_INSERT_RET_NEVER_EXPIRE) {
free(val);
}
if (rbt) {
if (ret == HTABLE_INSERT_RET_REPLACE) {
pthread_spin_lock(&rbt->lock);
tn.dlen = klen;
//tmp get old data
tn.exp = tmp.ttl;
tn.type = type;
tn.lowerdomain = NULL;
tn.data = k;
pn = find_node(rbt, &tn);
//if update, we had delete tn in rbt
//else update tn in rbt
if (pn != NULL) {
tmp_tn = delete_node(rbt, pn);
if (tmp_tn) {
free(tmp_tn->lowerdomain);
free(tmp_tn);
}
}
pthread_spin_unlock(&rbt->lock);
}
}
if (mv->ttl == (MAX_TTL + 1)) { //never expired
return 0;
}
if (rbt == NULL) {
return 0;
}
//data exists in htable, delete it in ttl tree, then insert
pthread_spin_lock(&rbt->lock);
if (type != NS && ret == HTABLE_INSERT_RET_REPLACE)
ret = insert_into_ttltree(rbt, k, klen, type, mv->ttl, lowerdomain); //ttl expired tree
else
ret = insert_into_ttltree(rbt, k, klen, type, tmp.ttl, lowerdomain); //ttl expired tree
pthread_spin_unlock(&rbt->lock);
return 0;
}
/**
* Locate record for query hits for specified MUID.
*
* @returns located record, or NULL if not found.
*/
static dqhit_t *
dh_locate(const struct guid *muid)
{
bool found = FALSE;
const void *key;
void *value;
if (NULL == by_muid_old)
return NULL; /* DH layer shutdown occurred already */
/*
* Look in the old table first. If we find something there, move it
* to the new table to keep te record "alive" since we still get hits
* for this query.
*/
found = htable_lookup_extended(by_muid_old, muid, &key, &value);
if (found) {
htable_remove(by_muid_old, key);
g_assert(!htable_contains(by_muid, key));
htable_insert(by_muid, key, value);
return value;
}
return htable_lookup(by_muid, muid);
}
/**
* Record a new leak of `size' bytes allocated at `file', line `line'.
*/
void
leak_add(leak_set_t *ls, size_t size, const char *file, int line)
{
char key[1024];
struct leak_record *lr;
bool found;
void *v;
leak_set_check(ls);
g_assert(file);
g_assert(line >= 0);
concat_strings(key, sizeof key,
file, ":", uint64_to_string(line), (void *) 0);
found = htable_lookup_extended(ls->places, key, NULL, &v);
if (found) {
lr = v;
lr->size += size;
lr->count++;
} else {
XPMALLOC(lr);
lr->size = size;
lr->count = 1;
htable_insert(ls->places, xstrdup(key), lr);
}
}
/**
* Add header line to the `headers' hash for specified field name.
* A private copy of the `field' name and of the `text' data is made.
*/
static void
add_header(header_t *o, const char *field, const char *text)
{
htable_t *ht;
str_t *v;
header_check(o);
ht = header_get_table(o);
v = htable_lookup(ht, field);
if (v) {
/*
* Header already exists, according to RFC2616 we need to append
* the value, comma-separated.
*/
STR_CAT(v, ", ");
str_cat(v, text);
} else {
char *key;
/*
* Create a new header entry in the hash table.
*/
key = h_strdup(field);
v = str_new_from(text);
htable_insert(ht, key, v);
}
}
/**
* Adds the given node to the gui.
*/
void
nodes_gui_add_node(gnet_node_info_t *info)
{
static const struct node_data zero_data;
struct node_data *data;
gnet_node_flags_t flags;
g_return_if_fail(info);
g_return_if_fail(!htable_contains(nodes_handles, info->node_id));
WALLOC(data);
*data = zero_data;
data->node_id = nid_ref(info->node_id);
data->user_agent = info->vendor ? atom_str_get(info->vendor) : NULL;
data->country = info->country;
data->host_size = w_concat_strings(&data->host,
host_addr_port_to_string(info->addr, info->port),
(void *) 0);
str_bprintf(data->version, sizeof data->version, "%u.%u",
info->proto_major, info->proto_minor);
guc_node_fill_flags(data->node_id, &flags);
nodes_gui_update_node_flags(data, &flags);
htable_insert(nodes_handles, data->node_id, data);
gtk_list_store_append(nodes_model, &data->iter);
gtk_list_store_set(nodes_model, &data->iter, 0, data, (-1));
}
static void
run_test(HTable* htable)
{
int i, j;
/* fill table */
for(i = 1; i <= N; i++)
{
for(j = 1; j <= N; j++)
{
bool isNewNode;
ExpressionTableNodeData new_node_data;
sprintf(new_node_data.expression, "%d + %d", i, j);
new_node_data.value = (i + j);
htable_insert(htable, (HTableNode*)&new_node_data, &isNewNode);
assert(isNewNode);
}
}
assert(htable_nitems(htable) == (N*N));
/* check hash table is filled right */
for(i = 1; i <= N; i++)
{
for(j = 1; j <= N; j++)
{
ExpressionTableNode found_node;
ExpressionTableNodeData query;
sprintf(query.expression, "%d + %d", i, j);
found_node = (ExpressionTableNode)htable_find(htable, (HTableNode*)&query);
assert(found_node != NULL);
assert(found_node->value == (i + j));
}
}
/* try to delete a non-existing node */
{
bool result;
ExpressionTableNodeData query;
sprintf(query.expression, "ololo trololo");
result = htable_delete(htable, (HTableNode*)&query);
assert(result == false);
}
/* clean table */
for(i = 1; i <= N; i++)
{
for(j = 1; j <= N; j++)
{
bool result;
ExpressionTableNodeData query;
sprintf(query.expression, "%d + %d", i, j);
result = htable_delete(htable, (HTableNode*)&query);
assert(result == true);
}
}
assert(htable_nitems(htable) == 0);
}
void test_htable_probing() {
htable *ht = htable_create();
size_t capacity = htable_capacity(ht);
assert(_hash_func("one", capacity) == _hash_func("seven", capacity)
&& "Make sure that the keys gives the same key");
htable_insert(ht, "one", "1st value");
htable_insert(ht, "seven", "7th value");
assert(0 == strcmp("1st value", htable_get(ht, "one"))
&& "First value should be equal to 1st value");
assert(0 == strcmp("7th value", htable_get(ht, "seven"))
&& "Seventh value should be equal to 7th value");
htable_destroy(ht);
}
void
main_phrases (void)
{
phrase_t *p1 = phrase_create ("ala");
phrase_t *p2 = phrase_create ("ela");
entry_t *entry;
htable_t *table = htable_create_p (4);
htable_insert (table, p1, p1);
htable_insert (table, p2, p2);
entry = htable_lookup (table, p2);
phrase_print ((phrase_t *) entry->value);
printf ("\n");
htable_destroy (table, destroy_entry);
}
int main(void) {
htable h = htable_new(18143);
char word[256];
while (getword(word, sizeof word, stdin) != EOF) {
htable_insert(h, word);
}
htable_print(h, stdout);
htable_free(h);
return EXIT_SUCCESS;
}
void test_htable_size() {
htable *ht = htable_create();
assert(0 == htable_size(ht)
&& "Count should be 0 upon creation.");
htable_insert(ht, "one", "1st value");
htable_insert(ht, "two", "2nd value");
htable_insert(ht, "three", "3rd value");
assert(3 == htable_size(ht)
&& "Count should be 3 after three insertions.");
htable_clear(ht);
assert(0 == htable_size(ht)
&& "Count should be 0 after clear.");
htable_destroy(ht);
}
int test_add_element_and_find_it(){
hashtable* myhtable;
hsize size=101;
myhtable=htable_create(size,NULL);
htable_insert(myhtable,"Hugo","Yvaon");
assert(!strcmp("Yvaon",htable_get(myhtable,"Hugo")));
htable_destroy(myhtable);
myhtable=NULL;
return 1;
}
void
fi_gui_source_show(struct download *d)
{
GtkTreeIter *iter;
g_return_if_fail(store_sources);
g_return_if_fail(!htable_contains(fi_sources, d));
WALLOC(iter);
htable_insert(fi_sources, d, iter);
list_store_append_pointer(store_sources, iter, 0, d);
}
/**
* Create new record for query hits for specified MUID.
* New record is registered in the current table.
*/
static dqhit_t *
dh_create(const struct guid *muid)
{
dqhit_t *dh;
const struct guid *key;
WALLOC0(dh);
key = atom_guid_get(muid);
htable_insert(by_muid, key, dh);
return dh;
}
/**
* Hash table iterator to invert the "uri -> node" mapping to "node -> uri".
*
* Since there are many URIs that can be associated to a given node, the
* values are actually lists of URIs.
*/
static void
xfmt_invert_uri_kv(const void *key, void *value, void *data)
{
struct xfmt_invert_ctx *ictx = data;
const char *uri = key;
const xnode_t *xn = value;
GSList *sl;
g_assert(xn != NULL);
sl = htable_lookup(ictx->node2uri, xn);
sl = gm_slist_prepend_const(sl, uri);
htable_insert(ictx->node2uri, xn, sl);
}
int main(void) {
char line[MAXLINE];
node *hashtable;
hashtable = (node *)malloc(HASHSIZE * sizeof(node));
htable_init(hashtable);
while((fgets(line, MAXLINE, stdin)) != NULL)
htable_insert(hashtable, line);
htable_display(hashtable);
return 0;
}
/**
* Record a waiting event.
*
* @param key waiting key
* @param cb callback to invoke on wakeup
* @param arg additional callback argument
*
* @return the registered event, whose reference must be kept if it is meant
* to be cancelled.
*/
wq_event_t *
wq_sleep(const void *key, wq_callback_t cb, void *arg)
{
wq_event_t *we;
hash_list_t *hl;
we = wq_event_alloc(key, cb, arg);
hl = htable_lookup(waitqueue, key);
if (NULL == hl) {
hl = hash_list_new(pointer_hash, NULL);
htable_insert(waitqueue, key, hl);
}
hash_list_append(hl, we); /* FIFO layout */
return we;
}
void test_htable_get() {
htable *ht = htable_create();
htable_insert(ht, "two", "2nd value");
assert(NULL == htable_get(ht, "one")
&& "First value should be NULL");
assert(NULL != htable_get(ht, "two")
&& "Second value should not equal NULL");
assert(0 == strcmp("2nd value", htable_get(ht, "two"))
&& "Second value should be equal to 2nd value");
htable_destroy(ht);
}
int main(int argc, char **argv) {
int size;
htable h;
char word[256];
if (argc <=1 ){
size = 25013;
fprintf(stderr, "No arguments given, set htable size to %d\n", size);
} else {
size = atoi(argv[1]);
}
h = htable_new(size);
while (getword(word, sizeof word, stdin) != EOF) {
htable_insert(h, word);
}
htable_print(h, stdout);
htable_free(h);
return EXIT_SUCCESS;
}
static void
add_word (htable_t *words, word_t *word, phrase_t *phrase, int project_id,
int location_id, int destroy_phrase)
{
entry_t *entry;
list_t *node = xmalloc (sizeof (list_t));
node->next = NULL;
node->phrase = phrase;
node->project_id = project_id;
node->location_id = location_id;
node->destroy_phrase = destroy_phrase;
entry = htable_insert (words, word, node);
if (entry->value != node){
node->next = entry->value;
entry->value = node;
}
}
void *
st_th(void *arg)
{
int i, idx;
uchar key[50] = { 0 };
int klen;
uchar *val = NULL;
int pre = 0;
// struct hentry *he = NULL;
uchar *oval;
struct htable *ht;
struct st_hlp *sh = (struct st_hlp *) arg;
hashval_t hash;
idx = sh->idx;
ht = sh->ht;
for (i = idx * NUMX; i < (idx + 1) * NUMX; i++) {
hash = 0;
sprintf((char *)key, "%dkey", i);
val = malloc(50);
sprintf((char *)val, "%dval", i);
//printf("%d,%s,%s\n",idx,key,val);
klen = strlen((const char *)key) + 1;
pre = get_pre_mem_hash(key, klen, &hash);
htable_insert(ht + pre, key, klen, A, val, 0, NULL, &hash);
}
if (idx == (THREADX - 1))
idx = -1;
sleep(2);
for (i = (idx + 1) * NUMX; i < (idx + 2) * NUMX; i++) {
hash = 0;
sprintf((char *)key, "%dkey", i);
klen = strlen((const char *)key) + 1;
pre = get_pre_mem_hash(key, klen, &hash);
oval = htable_delete(ht + pre, key, klen, A, hash);
if (oval == NULL) {
printf("error in test %s,%d,%d\n", key, idx, i);
}
else
free(oval);
}
sleep(5);
return NULL;
}
static void
hit_word (htable_t *words, htable_t *hits, word_t *word)
{
entry_t *entry = htable_lookup (words, word);
list_t *node = (entry) ? (list_t *) entry->value : NULL;
while (node){
entry_t *entry;
hit_t *hit = xmalloc (sizeof (hit_t));
hit->query_hits = word->occurences;
hit->storage_hits = word_occurences (word, node->phrase);
entry = htable_insert (hits, node, hit);
if (entry->value != hit)
merge_and_destroy_hit ((hit_t *)entry->value, hit);
node = node->next;
}
}
void
sip_calls_clear_soft()
{
// Create again the callid hash table
htable_destroy(calls.callids);
calls.callids = htable_create(calls.limit);
// Repopulate list applying current filter
calls.list = vector_copy_if(sip_calls_vector(), filter_check_call);
calls.active = vector_copy_if(sip_active_calls_vector(), filter_check_call);
// Repopulate callids based on filtered list
sip_call_t *call;
vector_iter_t it = vector_iterator(calls.list);
while ((call = vector_iterator_next(&it)))
{
htable_insert(calls.callids, call->callid, call);
}
}
//k and v both are in stack
//k td
//v mvalue.data
int insert_kv_mem(struct rbtree *rbt,struct htable *ds,uchar *k,uchar *v,int vlen)
{
uchar *val = NULL;
struct mvalue *mv = NULL,tmp;
int ret = -1;
struct rbnode *pn = NULL;
struct ttlnode tn = {0};
if(vlen < 0 || vlen > MAX_RECORD_SIZE)
return -1;
hashval_t hash = nocase_char_hash_function(k);
hash = get_pre_mem_hash(k);
val = malloc(vlen);
if(val == NULL)
return -1;
memcpy(val,v,vlen);
mv = (struct mvalue*)v;
ret = htable_insert(ds + hash,k,val,1,&tmp); //mem, replace
if(ret == 2)
free(val);
if(mv->ttl == (MAX_TTL + 1))//never expired
return 0;
if(rbt == NULL)
return 0;
//data exists in htable, delete it in ttl tree, then insert
pthread_mutex_lock(&rbt->lock);
if(ret != 0)
{
tn.dlen = strlen(k) + 1;
//tmp get old data
tn.exp = tmp.ttl;
tn.data = k;
pn = find_node(rbt,&tn);
//if update, we had delete tn in rbt
//else update tn in rbt
if(pn != NULL)
delete_node(rbt,pn);
}
ret = insert_into_ttltree(rbt,k,mv->ttl);//ttl expired tree
pthread_mutex_unlock(&rbt->lock);
return 0;
}
/**
* Count a word that has been seen.
*/
static void
search_stats_tally(const word_vec_t *vec)
{
struct term_counts *val;
if (vec->word[1] == '\0' || vec->word[2] == '\0')
return;
val = htable_lookup(stat_hash, vec->word);
if (val) {
val->period_cnt++;
} else {
const char *key;
WALLOC0(val);
val->period_cnt = vec->amount;
key = wcopy(vec->word, 1 + strlen(vec->word));
htable_insert(stat_hash, key, val);
}
}
/**
* Record a new leak of `size' bytes allocated from stack trace.
*/
void
leak_stack_add(leak_set_t *ls, size_t size, const struct stackatom *sa)
{
struct leak_record *lr;
bool found;
void *v;
leak_set_check(ls);
found = htable_lookup_extended(ls->stacks, sa, NULL, &v);
if (found) {
lr = v;
lr->size += size;
lr->count++;
} else {
XPMALLOC(lr);
lr->size = size;
lr->count = 1;
htable_insert(ls->stacks, sa, lr);
}
}
/**
* Add a new upload stats row to the model.
*
* Add the information within the ul_stats structure
* to the GtkTreeModel and another row the the
* upload statistics pane.
*
* @param us A ul_stats structure with new upload stats to add.
*
*/
void
upload_stats_gui_add(struct ul_stats *us)
{
struct upload_data *data;
GtkListStore *store;
g_assert(us != NULL);
upload_stats_gui_init_intern(TRUE);
store = GTK_LIST_STORE(gtk_tree_view_get_model(upload_stats_treeview));
g_return_if_fail(store);
g_return_if_fail(!htable_contains(ht_uploads, us));
WALLOC(data);
data->us = us;
data->filename = atom_str_get(us->filename);
htable_insert(ht_uploads, data->us, data);
gtk_list_store_append(store, &data->iter);
gtk_list_store_set(store, &data->iter, 0, data, (-1));
}
int htable_rehash( struct hash_table* table, int new_size )
{
// Allocate the new table..
void **newTable = (void**)malloc(sizeof(void**) * new_size);
if ( newTable == NULL ) return -1; // Out of memory.
void **oldTable = table->table;
int oldSize = table->size;
int i;
for ( i = 0; i < new_size; i++) newTable[i] = NULL;
table->size = new_size;
table->total = 0;
table->table = newTable;
for ( i = 0; i < oldSize; i++ )
if ( oldTable[i] != NULL ) htable_insert( table, oldTable[i] );
free( oldTable );
return 0;
}
