/* hash_map_t */ void _type_init_hash_map(const void* cpv_input, void* pv_output) { bool_t b_result = false; assert(cpv_input != NULL && pv_output != NULL); b_result = _create_hash_map_auxiliary((hash_map_t*)cpv_input, (char*)pv_output); assert(b_result); hash_map_init((hash_map_t*)cpv_input); }
static inline int __container_hash_map_init(container_t *ct,uint32_t data_size) { hash_map_t *hmap = ct->priv.hmap; dbg_str(DBG_CONTAINER_DETAIL,"__container_hash_map_init"); return hash_map_init(hmap,//hash_map_t *hmap, hmap->key_size,//uint32_t key_size, data_size,//uint32_t data_size, hmap->bucket_size,//uint32_t bucket_size, hmap->hash_func,//hash_func_fpt hash_func, hmap->key_cmp_func);//key_cmp_fpt key_cmp_func); }
int test_add_get_remove(struct harness_t *harness) { struct hash_map_t map; struct hash_map_bucket_t buckets[8]; struct hash_map_entry_t entries[4]; hash_map_init(&map, buckets, membersof(buckets), entries, membersof(entries), hash); /* Add three entries. */ BTASSERT(hash_map_add(&map, 37, (void *)34) == 0); BTASSERT(hash_map_add(&map, 38, (void *)35) == 0); BTASSERT(hash_map_add(&map, 39, (void *)36) == 0); BTASSERT(hash_map_add(&map, 39, (void *)36) == 0); /* Get them. */ BTASSERT(hash_map_get(&map, 38) == (void *)35); BTASSERT(hash_map_get(&map, 39) == (void *)36); BTASSERT(hash_map_get(&map, 37) == (void *)34); /* Remove first two. */ BTASSERT(hash_map_remove(&map, 37) == 0); BTASSERT(hash_map_remove(&map, 38) == 0); BTASSERT(hash_map_remove(&map, 38) == -1); /* Get removed entries. */ BTASSERT(hash_map_get(&map, 37) == NULL); BTASSERT(hash_map_get(&map, 38) == NULL); /* Get, remove and get last entry. */ BTASSERT(hash_map_get(&map, 39) == (void *)36); BTASSERT(hash_map_remove(&map, 39) == 0); BTASSERT(hash_map_remove(&map, 39) == -1); BTASSERT(hash_map_get(&map, 39) == NULL); /* Add one entry over limit. */ BTASSERT(hash_map_add(&map, 37, (void *)4) == 0); BTASSERT(hash_map_add(&map, 39, (void *)5) == 0); BTASSERT(hash_map_add(&map, 41, (void *)6) == 0); BTASSERT(hash_map_add(&map, 43, (void *)7) == 0); BTASSERT(hash_map_add(&map, 45, (void *)8) == -ENOMEM); return (0); }
static void init(void) { long number; struct fat16_dir_t dir; struct fat16_dir_entry_t entry; struct song_t *song_p; uint32_t seconds; fat16_read_t read; fat16_write_t write; void * arg_p; sys_start(); uart_module_init(); uart_init(&uart, &uart_device[0], 38400, qinbuf, sizeof(qinbuf)); uart_start(&uart); sys_set_stdout(&uart.chout); std_printf(sys_get_info()); fs_command_init(&cmd_list, FSTR("/list"), cmd_list_cb, NULL); fs_command_register(&cmd_list); fs_command_init(&cmd_play, FSTR("/play"), cmd_play_cb, NULL); fs_command_register(&cmd_play); fs_command_init(&cmd_pause, FSTR("/pause"), cmd_pause_cb, NULL); fs_command_register(&cmd_pause); fs_command_init(&cmd_next, FSTR("/next"), cmd_next_cb, NULL); fs_command_register(&cmd_next); fs_command_init(&cmd_prev, FSTR("/prev"), cmd_prev_cb, NULL); fs_command_register(&cmd_prev); fs_command_init(&cmd_stop, FSTR("/stop"), cmd_stop_cb, NULL); fs_command_register(&cmd_stop); fs_command_init(&cmd_repeat, FSTR("/repeat"), cmd_repeat_cb, NULL); fs_command_register(&cmd_repeat); fs_command_init(&cmd_set_bits_per_sample, FSTR("/set_bits_per_sample"), cmd_set_bits_per_sample_cb, NULL); fs_command_register(&cmd_set_bits_per_sample); if (storage_init(&read, &write, &arg_p) != 0) { std_printf(FSTR("storage init failed\r\n")); return; } std_printf(FSTR("initializing fat16\r\n")); fat16_init(&fs, read, write, arg_p, 0); std_printf(FSTR("fat16 initialized\r\n")); if (fat16_mount(&fs) != 0) { std_printf(FSTR("failed to mount fat16\r\n")); return; } std_printf(FSTR("fat16 mounted\r\n")); event_init(&event); exti_module_init(); /* Initialize the buttons. */ exti_init(&buttons[0], &exti_d18_dev, EXTI_TRIGGER_FALLING_EDGE, on_button_play, NULL); exti_start(&buttons[0]); exti_init(&buttons[1], &exti_d19_dev, EXTI_TRIGGER_FALLING_EDGE, on_button_prev, NULL); exti_start(&buttons[1]); exti_init(&buttons[2], &exti_d20_dev, EXTI_TRIGGER_FALLING_EDGE, on_button_next, NULL); exti_start(&buttons[2]); exti_init(&buttons[3], &exti_d21_dev, EXTI_TRIGGER_FALLING_EDGE, on_button_stop, NULL); exti_start(&buttons[3]); dac_init(&dac, &dac_0_dev, &pin_dac0_dev, &pin_dac1_dev, 2 * SAMPLES_PER_SOCOND); hash_map_init(&song_map, buckets, membersof(buckets), entries, membersof(entries), hash_number); sem_init(&sem, 0, 1); music_player_init(&music_player, &fs, &dac, get_current_song_path, get_next_song_path, NULL); /* Initialize the song number. */ current_song = FIRST_SONG_NUMBER; number = FIRST_SONG_NUMBER; /* Add songs to the hash map. */ fat16_dir_open(&fs, &dir, ".", O_READ); while (fat16_dir_read(&dir, &entry) == 1) { if (number - FIRST_SONG_NUMBER == membersof(songs)) { std_printf("Maximum number of songs already added. " "Skipping the rest of the songs.\r\n"); break; } /* Skip folders. */ if (entry.is_dir == 1) { continue; } song_p = &songs[number - FIRST_SONG_NUMBER]; /* Initialize the song entry. */ song_p->number = number; strcpy(song_p->name, entry.name); seconds = (entry.size / 4 / SAMPLES_PER_SOCOND); song_p->minutes = (seconds / 60); song_p->seconds = (seconds % 60); std_printf("Adding song %s to playlist.\r\n", entry.name); hash_map_add(&song_map, number, song_p); number++; } fat16_dir_close(&dir); last_song_number = (number - 1); music_player_start(&music_player); }
int main(){ printf("ok, it is done\n"); lru_cache_t * lru; hash_map_t * hash_map; int res = hash_map_init(&hash_map, &simple_hash_function, &key_cmp_cbf, &key_free_cbf, & key_clone_cbf); printf("hash init result: %d\n", res); int rest = lru_cache_init(&lru, &simple_hash_function, &key_cmp_cbf, &key_free_cbf, &key_clone_cbf); printf("lru init result: %d\n", rest); lru_dump(lru, &value_to_string, &key_to_string); int i = 1; test_key_t key; test_value_t value; test_value_t * vp; int ret = 0; while(i){ printf("0: quit\n1: insert\n2: lookup\n3: delete\nyour choice:"); scanf("%d", &i); switch(i){ case 1: printf("key:"); scanf("%19s", key.key); printf("got key: %s\nvalue:", key.key); scanf("%19s", value.value); if(value.value[0] == '0') i=0; ret = lru_cache_insert(lru, (const void *)(&key), (const void *)(&value), &value_clone_cbf, &value_free_cbf); if(!ret){ printf("insert (%s, %s) failed", key.key, value.value); } break; case 3: ret = lru_delete_auto(lru); if(!ret){ printf("delete failed\n"); } break; case 2: printf("key:"); scanf("%19s", key.key); ret = lru_cache_get(lru, (const void *) &key, (void **)(&vp)); if(!ret || !vp){ printf("key does not exist\n"); } else{ printf("key=%s, value=%s\n", key_to_string((const void *)&key), value_to_string((const void *)vp)); } break; default: i = 0; break; } lru_dump(lru, value_to_string, key_to_string); } printf("quit cache; test hash map"); i = 1; while(i){ printf("0: quit\n1: insert\n2: lookup\n3: delete\nyour choice:"); scanf("%d", &i); switch(i){ case 1: printf("key:"); scanf("%19s", key.key); printf("got key: %s\nvalue:", key.key); scanf("%19s", value.value); if(value.value[0] == '0') i=0; ret = hash_map_insert(hash_map, (const void *)(&key), (const void *)(&value), &value_clone_cbf, &value_free_cbf); if(!ret){ printf("insert (%s, %s) failed", key.key, value.value); } break; case 3: printf("key:"); scanf("%19s", key.key); ret = hash_map_delete_entry(hash_map, (const void *) &key); if(!ret){ printf("delete failed\n"); } break; case 2: printf("key:"); scanf("%19s", key.key); ret = hash_map_lookup(hash_map, (const void *) &key, (void **)(&vp)); if(!ret || !vp){ printf("key does not exist\n"); } else{ printf("key=%s, value=%s\n", key_to_string((const void *)&key), value_to_string((const void *)vp)); } break; default: i = 0; break; } hash_map_dump(hash_map, &key_to_string, &value_to_string); } hash_map_fini(hash_map); printf("quit hash map\n"); return 0; }
int main(int argc, char** argv) { unsigned i; struct timeval tv; double sum = 0; double min_time_per_op = -1; double min_of_max = -1; grt_random_init(); int got_params = get_params(); hash_map_init(argc, argv, params[SHARE_POWER]); if (!got_params) { if (grt_id == 0) { fprintf(stderr, "*** USING DEFAULT PARAMETERS ***\n"); } grt_barrier(); } keys = malloc(MY_NUM_OPS * sizeof(grt_word_t)); values = malloc(MY_NUM_OPS * sizeof(grt_word_t)); int nth = 4*grt_distrib_start(params[NUM_OPS])+1; grt_random_nth(grt_distrib_start(nth)); for (i = 0; i < MY_NUM_OPS; ++i) { keys[i] = RAND_MAX * grt_random_next(); values[i] = RAND_MAX * grt_random_next(); } grt_barrier(); if (grt_id == 0) { printf("User-specified parameters:\n"); for (i = 0; i < NUM_PARAMS; ++i) { const char *name = param_names[i]; unsigned param = params[i]; printf(" %s=", name); if (i == ON_PTHREAD) printf((param == GRT_TRUE) ? "yes" : "no"); else printf("%u", param); printf("\n"); } printf(" grt_num_procs=%u\n", grt_num_procs); } grt_barrier(); times = (grt_word_t*) grt_all_alloc(0, grt_num_procs * sizeof(grt_word_t)); for (i = 0; i < params[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 / params[NUM_RUNS]); printf("min time per op=%f us\n", min_time_per_op); printf("min of max=%f us\n", min_of_max); } hash_map_exit(0); }
int main (int argc, char *argv[]) { hash_map_t *map = NULL; struct thread_info *tinfo = NULL; pthread_attr_t attr; pthread_barrier_t barrier = {0,}; int ret = -1; int tcount = 100, idx = 0; map = hash_map_init (); if (map == NULL) { printf ("failed to initialize hash map\n"); } hh_random_init (); ret = pthread_attr_init(&attr); if (ret != 0) printf ("ERROR: failed to initialize pthread attr\n"); pthread_barrier_init (&barrier, NULL, tcount + 1); tinfo = calloc (tcount, sizeof(struct thread_info)); if (tinfo == NULL) printf ("ERROR: calloc failed\n"); for (idx = 0; idx < tcount; idx++) { tinfo[idx].action = (hh_random() % 3) + 1; if (tinfo[idx].action == ACTION_INSERTION) tinfo[idx].size = 100 + idx; else tinfo[idx].size = 23; tinfo[idx].map = map; tinfo[idx].barrier = &barrier; } for (idx = 0; idx < tcount; idx++) pthread_create (&tinfo[idx].thread_id, &attr, &thread_start, &tinfo[idx]); /* tinfo[0].action = ACTION_INSERTION; */ /* tinfo[0].size = 100; */ /* tinfo[1].action = ACTION_REMOVAL; */ /* tinfo[1].size = 20; */ /* tinfo[2].action = ACTION_RETRIEVAL; */ /* tinfo[2].size = 20; */ /* tinfo[0].map = tinfo[1].map = tinfo[2].map = map; */ /* tinfo[0].barrier = tinfo[1].barrier = tinfo[2].barrier = &barrier; */ /* // insertions (map, 100); */ /* pthread_create (&tinfo[0].thread_id, &attr, &thread_start, &tinfo[0]); */ /* // removals (map, 20); */ /* pthread_create (&tinfo[1].thread_id, &attr, &thread_start, &tinfo[1]); */ /* // retrievals (map, 10); */ /* pthread_create (&tinfo[2].thread_id, &attr, &thread_start, &tinfo[2]); */ pthread_barrier_wait (&barrier); for (idx = 0; idx < tcount; idx++) pthread_join (tinfo[idx].thread_id, NULL); /* pthread_join (tinfo[0].thread_id, NULL); */ /* pthread_join (tinfo[1].thread_id, NULL); */ /* pthread_join (tinfo[2].thread_id, NULL); */ hash_map_dump (map); return 0; }
void setUp() { map = safe_malloc(sizeof(hash_map)); hash_map_init(map, 1000, (hash_map_comparator) strcmp, NULL); }