void hash_test()
{
stu_t stu[3] = {
{"aaa","12345"},
{"bbb","dadad"},
{"ccc","xxxxx"},
};
hashtable_t* hash = hashtable_init(5,hash_fun);
int i = 0;
for ( i = 0 ; i < 3 ; ++i)
{
hashtable_add(hash,stu[i].name,strlen(stu[i].name),stu[i].school,strlen(stu[i].name));
}
hashtable_del(hash,"aaa",strlen("aaa"));
hashtable_add(hash,stu[0].name,strlen(stu[0].name),stu[0].school,strlen(stu[0].name));
char *str = hashtable_search(hash,"aaa",3);
if ( NULL == str )
printf("not fount\n");
else
printf("name:\"aaa\",school:%s\n",str);
hashtable_destroy(&hash);
}
int main (int argc, char **argv) {
int srv_fd, cfd;
hashtable_init(&db, 16);
log_fd = log_init("CaStore.log");
log_replay(log_fd, &db);
struct sockaddr_in servaddr;
srv_fd = socket(AF_INET, SOCK_STREAM, 0);
int yep = 1;
setsockopt(srv_fd, SOL_SOCKET, SO_REUSEADDR, &yep, sizeof(int));
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htons(INADDR_ANY);
servaddr.sin_port = htons(11124);
bind(srv_fd, (struct sockaddr *) &servaddr, sizeof(servaddr));
listen(srv_fd, 10);
while (1) {
cfd = accept(srv_fd, (struct sockaddr*) NULL, NULL);
setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY, &yep, sizeof(int));
printf("Accettato il client %d\n", cfd);
struct client *cl =(struct client *)malloc(sizeof(struct client));
pthread_t tred_id;
cl->fd = cfd;
pthread_create(&tred_id, NULL, client_thread, cl);
}
close(srv_fd);
return(0);
}
drmf_status_t
drsyscall_os_init(void *drcontext)
{
uint i;
hashtable_init_ex(&systable, SYSTABLE_HASH_BITS, HASH_INTPTR, false/*!strdup*/,
false/*!synch*/, NULL, sysnum_hash, sysnum_cmp);
/* We initialize & leave secondary_systable empty to be in sync with our
* Windows & Linux solutions. Xref i#1438 i#1549.
*/
hashtable_init_ex(&secondary_systable, SECONDARY_SYSTABLE_HASH_BITS,
HASH_INTPTR, false/*!strdup*/, false/*!synch*/, NULL,
sysnum_hash, sysnum_cmp);
hashtable_init(&name2num_table, NAME2NUM_TABLE_HASH_BITS, HASH_STRING,
false/*!strdup*/);
dr_recurlock_lock(systable_lock);
for (i = 0; i < count_syscall_info_bsd; i++) {
IF_DEBUG(bool ok =)
hashtable_add(&systable, (void *) &syscall_info_bsd[i].num,
(void *) &syscall_info_bsd[i]);
ASSERT(ok, "no dups");
IF_DEBUG(ok =)
hashtable_add(&name2num_table, (void *) syscall_info_bsd[i].name,
(void *) &syscall_info_bsd[i].num);
ASSERT(ok || strcmp(syscall_info_bsd[i].name, "ni_syscall") == 0, "no dups");
}
dr_recurlock_unlock(systable_lock);
return DRMF_SUCCESS;
}
void hash() {
printf(">> HASH\n");
hashtable_t hash;
test_hash_t a = { "Hello" };
test_hash_t b = { "Intrusive" };
test_hash_t c = { "World" };
hashtable_init(&hash, 10, &hash_func);
hashtable_insert(&hash, &a.node, "a", 2);
hashtable_insert(&hash, &b.node, "b", 2);
hashtable_insert(&hash, &c.node, "c", 2);
hashnode_t *ga = hashtable_search(&hash, "a", 2);
hashnode_t *gb = hashtable_search(&hash, "b", 2);
hashnode_t *gc = hashtable_search(&hash, "c", 2);
test_hash_t *aa = hashtable_ref(ga, test_hash_t, node);
test_hash_t *bb = hashtable_ref(gb, test_hash_t, node);
test_hash_t *cc = hashtable_ref(gc, test_hash_t, node);
printf("%s\n", aa->message);
printf("%s\n", bb->message);
printf("%s\n", cc->message);
}
int mysql_pool_init() {
if (0 > hashtable_init(&ht_idle_connections, 128))
return -1;
if (0 > vmbuf_init(&misc, 4096))
return -1;
return 0;
}
symtable_t *create_symbol_table(const char* name)
{
symtable_t *t = (symtable_t*)calloc(1, sizeof(symtable_t));
strncpy(t->name, name, 32 -1 );
t->curid = 1;
hashtable_init(&t->ht, HASH_INIT_SIZE, NULL);
return t;
}
void initialize_AST () {
program_start = malloc (sizeof (program_state_t));
program_start->st_list = NULL;
env_t *e = malloc (sizeof (env_t));
e->parent = NULL;
e->bindings = hashtable_init (10);
program_start->env = e;
}
void deps_init(struct deps *deps, struct strings *strings) {
array_init(&deps->names, 0);
array_init(&deps->epochs, 0);
array_init(&deps->vers, 0);
array_init(&deps->rels, 0);
array_init(&deps->flags, 0);
hashtable_init(&deps->hashtable);
deps->strings = strings;
}
t_tcp_conn_map* tcp_conn_map_init()
{
t_tcp_conn_map* tcp_conn_map;
tcp_conn_map = kmalloc(sizeof(t_tcp_conn_map));
tcp_conn_map->conn_map = hashtable_init(TCP_CONN_MAP_SIZE);
tcp_conn_map->duplicate_conn_list = new_dllist();
tcp_conn_map->is_key_unique = 0;
}
void verr_init() {
if (initialized) return;
initialized = true;
hashtable_init(providers, hasher_fnv64, memcmp, sizeof(int), sizeof(ErrorProvider*));
verr_register(VERR_PGENERAL, &general_provider);
verr_register(VERR_PIO, &io_provider);
verr_thread_init();
}
/*!
*****************************************************************************
*
****************************************************************************/
void dircache_init()
{
struct hash_table_ops ops = {
.alloc = __alloc,
.free = __free,
};
ht = hashtable_init(DIRCACHE_SZ, &ops);
pthread_mutex_init(&dir_access_mutex, NULL);
}
/**
* @brief Init the hashtable for NFSv4 owner cache
*
* @retval 0 if successful.
* @retval -1 if we failed.
*/
int Init_nfs4_owner(void)
{
ht_nfs4_owner = hashtable_init(&nfs4_owner_param);
if (ht_nfs4_owner == NULL) {
LogCrit(COMPONENT_STATE, "Cannot init NFS Open Owner cache");
return -1;
}
return 0;
} /* nfs4_Init_nfs4_owner */
int Init_9p_hash(void)
{
ht_9p_owner = hashtable_init(&_9p_owner_hash_param);
if (ht_9p_owner == NULL) {
LogCrit(COMPONENT_STATE, "Cannot init 9P Owner cache");
return -1;
}
return 0;
}
int nfs41_Init_session_id(void)
{
ht_session_id = hashtable_init(&session_id_param);
if (ht_session_id == NULL) {
LogCrit(COMPONENT_SESSIONS,
"NFS SESSION_ID: Cannot init Session Id cache");
return -1;
}
return 0;
}
} END_TEST
START_TEST(wraparoundHashTest) {
unsigned numEntries = NUM_OPS/ NUM_THREADS * 4 + 3;
unsigned power = 1;
while ( (1ull << power ) < numEntries ) {
++power;
}
#ifdef DBUG_TEST
ht = hashtable_init(HT_ENTRIES);
#else
ht = hashtable_init(numEntries);
#endif
pageid_t *data = malloc(sizeof(pageid_t) * THREAD_ENTRIES);
for(int i = 1; i <= THREAD_ENTRIES; i++) {
data[i-1] = -1 * (((i << power) - 6 + stasis_util_random64(13)) / 13);
}
worker(data);
hashtable_deinit(ht);
} END_TEST
vchan_t* vchans_get(int id)
{
vchan_t *ret;
blob_t id_blob = {&id, sizeof(int)};
hashtable_init(&vchans, sizeof(vchan_t));
ret = hashtable_get(&vchans, &id_blob, HT_CREATE);
if(ret->id == 0) {
memset(ret->cur_ctl_vals, 0xFF, sizeof(ret->cur_ctl_vals));
ret->id = id;
}
return (vchan_t*)ret;
}
} END_TEST
START_TEST(concurrentHashTest) {
#ifdef DBUG_TEST
ht = hashtable_init(HT_ENTRIES);
#else
ht = hashtable_init((pageid_t)((double)NUM_ENTRIES * 1.1));
#endif
pthread_t workers[NUM_THREADS];
for(int i = 0 ; i < NUM_THREADS; i++) {
pageid_t *data = malloc(sizeof(pageid_t) * THREAD_ENTRIES);
for(int j = 1; j <= THREAD_ENTRIES; j++) {
data[j-1] = -1 * (i + (j * NUM_THREADS));
}
pthread_create(&workers[i], 0, worker, data);
}
for(int i = 0 ; i < NUM_THREADS; i++) {
pthread_join(workers[i],0);
}
hashtable_deinit(ht);
} END_TEST
int main(void)
{
item i1;
i1.key = "key";
i1.nkey = strlen(i1.key)+1;
i1.value = "value";
i1.nvalue = strlen(i1.value)+1;
i1.h_next = 0;
hashtable_init();
hashtable_insert(i1,0);
return 0;
}
int main(int argc, char** argv) {
char* key = "key 2";
HASHTABLE* hashtable = hashtable_init();
hashtable->put(hashtable, "key 0", "value 0", hashtable->string_create, hashtable->string_destroy);
hashtable->put(hashtable, "key 1", "value 1", hashtable->string_create, hashtable->string_destroy);
hashtable->put(hashtable, "key 2", "value 2", hashtable->string_create, hashtable->string_destroy);
fprintf(stdout, "\nThe value with key %s is: %s", key, (char*)hashtable->get(hashtable, key));
fprintf(stdout, "\nDoes the hashtable contain the key: %s?: %d", key, hashtable->contains(hashtable, key));
fprintf(stdout, "\nRemoving %s...", key);
hashtable->remove(hashtable, key);
fprintf(stdout, "\nDoes the hashtable contain the key: %s?: %d", key, hashtable->contains(hashtable, key));
hashtable_quit(hashtable);
return 0;
}
hashtable_t *hashtable_create(key_hash_fn hash_key, key_cmp_fn cmp_keys,
free_fn free_key, free_fn free_value)
{
hashtable_t *hashtable = malloc(sizeof(hashtable_t));
if(!hashtable)
return NULL;
if(hashtable_init(hashtable, hash_key, cmp_keys, free_key, free_value))
{
free(hashtable);
return NULL;
}
return hashtable;
}
/**
* @brief Init the hashtable for stateids
*
* @retval 0 if successful.
* @retval -1 on failure.
*/
int nfs4_Init_state_id(void)
{
/* Init all_one */
memset(all_zero, 0, OTHERSIZE);
memset(all_ones, 0xFF, OTHERSIZE);
ht_state_id = hashtable_init(&state_id_param);
if (ht_state_id == NULL) {
LogCrit(COMPONENT_STATE, "Cannot init State Id cache");
return -1;
}
return 0;
}
HashTable *
hashtable_new(size_t size, HashFunc hash_func, EqualFunc compare_keys, FreeFunc free_key, FreeFunc free_value)
{
HashTable *table;
if(!(table = (HashTable *)malloc(sizeof(HashTable))))
{
fprintf(stderr, "Couldn't allocate memory.\n");
abort();
}
hashtable_init(table, size, hash_func, compare_keys, free_key, free_value);
return table;
}
void
replace_init(void)
{
if (options.replace_libc) {
app_pc addr;
int i;
char *s;
/* replace_module_load will be called for each module to populate the hashtable */
ASSERT(PAGE_START(get_function_entry((app_pc)replace_memset)) ==
PAGE_START(get_function_entry((app_pc)replace_memmove)),
"replace_ routines taking up more than one page");
ASSERT(sizeof(int) >= sizeof(wchar_t),
"wchar_t replacement functions assume wchar_t is not larger than int");
replace_routine_start = (app_pc)
PAGE_START(get_function_entry((app_pc)replace_memset));
/* PR 485412: we support passing in addresses of libc routines to
* be replaced if statically included in the executable and if
* we have no symbols available
*/
s = options.libc_addrs;
i = 0;
while (s != NULL) {
if (sscanf(s, PIFX, (ptr_uint_t *)&addr) == 1 ||
/* we save option space by having no 0x prefix but assuming hex */
sscanf(s, PIFMT, (ptr_uint_t *)&addr) == 1) {
LOG(2, "replacing %s @"PFX" in executable from options\n",
replace_routine_name[i], addr);
if (!drwrap_replace((app_pc)addr, (app_pc)replace_routine_addr[i], false))
ASSERT(false, "failed to replace");
}
s = strchr(s, ',');
if (s != NULL)
s++;
i++;
}
#ifdef USE_DRSYMS
hashtable_init(&replace_name_table, REPLACE_NAME_TABLE_HASH_BITS, HASH_STRING,
false/*!strdup*/);
for (i=0; i<REPLACE_NUM; i++) {
hashtable_add(&replace_name_table, (void *) replace_routine_name[i],
(void *)(ptr_int_t)(i+1)/*since 0 is "not found"*/);
}
#endif
}
}
int main(int argc, char** argv) {
hashtable_init(argc, argv);
unsigned i;
if (grt_id == 0) {
printf("TABLE_SIZE=%u\n", TABLE_SIZE);
printf("NUM_WRITES=%u\n", NUM_WRITES);
printf("grt_num_procs=%u\n", grt_num_procs);
printf("WRITES_PER_PROC=%u\n", WRITES_PER_PROC);
}
double sum = 0;
double min_time_per_op = -1;
double min_of_max = -1;
times =
(grt_word_t*) grt_all_alloc(0, grt_num_procs * sizeof(grt_word_t));
for (i = 0; i < NUM_RUNS; ++i) {
if (grt_id == 0) {
printf("\nRUN NUMBER %u\n\n", i);
fflush(stdout);
}
BARRIER();
run();
if (grt_id == 0) {
sum += time_per_op;
if (min_time_per_op == -1 ||
time_per_op < min_time_per_op)
min_time_per_op = time_per_op;
if (min_of_max == -1 ||
max_time < min_of_max)
min_of_max = max_time;
}
}
BARRIER();
if (grt_id == 0) {
printf("\nSUMMARY RESULTS\n\n");
printf("average time per operation=%f us\n", sum / NUM_RUNS);
printf("min time per op=%f us\n", min_time_per_op);
printf("min of max=%f us\n", min_of_max);
}
hashtable_exit(0);
}
int main(void)
{
char line[MAXLINE];
node *hashtable;
hashtable = (node*)malloc(HASHSIZE*sizeof(node));
hashtable_init(hashtable);
while (fgets(line, MAXLINE, stdin)!=NULL)
{
htable_insert(hashtable, line);
}
htable_display(hashtable);
return 0;
}
json_t *json_object(void)
{
json_object_t *object = malloc(sizeof(json_object_t));
if(!object)
return NULL;
json_init(&object->json, JSON_OBJECT);
if(hashtable_init(&object->hashtable, hash_string, string_equal,
free, value_decref))
{
free(object);
return NULL;
}
object->visited = 0;
return &object->json;
}
json_t *json_object(void)
{
json_object_t *object = jsonp_malloc(sizeof(json_object_t));
if(!object)
return NULL;
json_init(&object->json, JSON_OBJECT);
if(hashtable_init(&object->hashtable))
{
jsonp_free(object);
return NULL;
}
object->serial = 0;
object->visited = 0;
return &object->json;
}
static int
add_algorithm(state *s,
hashname_t pos,
char *name,
uint16_t len,
int ( *func_init)(void *),
int ( *func_update)(void *, unsigned char *, uint64_t ),
int ( *func_finalize)(void *, unsigned char *),
int inuse)
{
if (NULL == s)
return TRUE;
s->hashes[pos] = (algorithm_t *)malloc(sizeof(algorithm_t));
if (NULL == s->hashes[pos])
return TRUE;
s->hashes[pos]->name = strdup(name);
if (NULL == s->hashes[pos]->name)
return TRUE;
s->hashes[pos]->known = (hashtable_t *)malloc(sizeof(hashtable_t));
if (NULL == s->hashes[pos]->known)
return TRUE;
hashtable_init(s->hashes[pos]->known);
s->hashes[pos]->hash_sum = (unsigned char *)malloc(len * 2);
if (NULL == s->hashes[pos]->hash_sum)
return TRUE;
s->hashes[pos]->hash_context = malloc(ALGORITHM_CONTEXT_SIZE);
if (NULL == s->hashes[pos]->hash_context)
return TRUE;
s->hashes[pos]->f_init = func_init;
s->hashes[pos]->f_update = func_update;
s->hashes[pos]->f_finalize = func_finalize;
s->hashes[pos]->byte_length = len;
s->hashes[pos]->inuse = inuse;
return FALSE;
}
DR_EXPORT
void dr_init(client_id_t id)
{
uint i = 0;
uint const_arrays_num;
drsys_options_t ops = { sizeof(ops), 0, };
dr_set_client_name("Dr. STrace", "http://drmemory.org/issues");
#ifdef WINDOWS
dr_enable_console_printing();
#endif
options_init(id);
drsym_init(0);
drmgr_init();
drx_init();
if (drsys_init(id, &ops) != DRMF_SUCCESS)
ASSERT(false, "drsys failed to init");
dr_register_exit_event(exit_event);
dr_register_filter_syscall_event(event_filter_syscall);
drmgr_register_pre_syscall_event(event_pre_syscall);
drmgr_register_post_syscall_event(event_post_syscall);
if (drsys_filter_all_syscalls() != DRMF_SUCCESS)
ASSERT(false, "drsys_filter_all_syscalls should never fail");
open_log_file();
const_arrays_num = get_const_arrays_num();
hashtable_init(&nconsts_table, HASHTABLE_BITSIZE, HASH_STRING, false);
while (i < const_arrays_num) {
const_values_t *named_consts = const_struct_array[i];
bool res = hashtable_add(&nconsts_table,
(void *) named_consts[0].const_name,
(void *) named_consts);
if (!res)
ASSERT(false, "drstrace failed to add to hashtable");
i++;
}
}
int mime_types_init(void) {
if (hashtable_is_initialized(&ht_mime_types))
return 1;
LOGGER_INFO("initializing mime types");
int fd = open(MIME_TYPES, O_RDONLY);
struct stat st;
if (0 > fstat(fd, &st))
return LOGGER_PERROR("mime_types fstat"), close(fd), -1;
void *mem = mmap(NULL, st.st_size + 1, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
if (MAP_FAILED == mem)
return LOGGER_PERROR("mime_types mmap"), close(fd), -1;
hashtable_init(&ht_mime_types, 4096);
char *content = (char *)mem;
char *content_end = content + st.st_size;
while (content < content_end)
{
// find end of line
char *line = content, *p = line;
for (; p < content_end && *p != '\n'; ++p);
*p = 0; // mmap'd one extra byte to avoid checks
content = p + 1;
p = strchrnul(line, '#');
*p = 0; // truncate line after comment
p = line;
char *saveptr;
char *mime = strtok_r(p, MIME_DELIMS, &saveptr);
if (!mime)
continue;
char *ext;
while (NULL != (ext = strtok_r(NULL, MIME_DELIMS, &saveptr))) {
for (p = ext; *p; *p = tolower(*p), ++p);
hashtable_insert(&ht_mime_types, ext, strlen(ext), mime, strlen(mime) + 1);
}
}
munmap(mem, st.st_size + 1);
close(fd);
return 0;
}
