main()
{
struct hashtable *ht;
ht = hashtable_new(0);
hashtable_print(stdout, ht);
hashtable_put(ht, "one", (void *)0x1);
hashtable_print(stdout, ht);
hashtable_put(ht, "two", (void *)0x2);
hashtable_print(stdout, ht);
hashtable_put(ht, "three", (void *)0x3);
hashtable_print(stdout, ht);
hashtable_put(ht, "four", (void *)0x4);
hashtable_print(stdout, ht);
hashtable_put(ht, "five", (void *)0x5);
hashtable_print(stdout, ht);
hashtable_put(ht, "six", (void *)0x6);
hashtable_print(stdout, ht);
hashtable_put(ht, "seven", (void *)0x7);
hashtable_print(stdout, ht);
hashtable_put(ht, "eight", (void *)0x8);
hashtable_print(stdout, ht);
hashtable_put(ht, "nine", (void *)0x9);
hashtable_print(stdout, ht);
}
int main(){
hashtable_t * table = hashtable_new(5);
int i = 0;
for(;i<5;i++){
hashtable_add(table,"one");
hashtable_add(table,"two");
hashtable_add(table,"three");
hashtable_add(table,"four");
hashtable_add(table,"five");
}
i=0;/*
for(;i<5;i++){
hashtable_remove(table,"one");
hashtable_remove(table,"two");
hashtable_remove(table,"three");
hashtable_remove(table,"four");
hashtable_remove(table,"five");
}
*/
hashtable_print(table);
hashtable_free(table);
return 1;
}
int main(int argc, char **argv)
{
hashtable ht = hashtable_new(8);
int i = 1;
while (i < argc) {
char *str = argv[i++];
if (i < argc && strcmp(str, "-") == 0) {
str = argv[i++];
hashtable_remove(ht, str);
}
else if (i < argc && strcmp(str, "+") == 0) {
str = argv[i++];
hashtable_insert(ht, str);
}
else {
hashtable_insert(ht, str);
}
}
hashtable_print(ht);
hashtable_free(ht);
}
int main(int argc, char **argv) {
int num_threads = 1;
int max_values_to_add = 10;
int num_hash_buckets = 13;
int c;
while ((c = getopt(argc, argv, "t:m:s:h")) != -1) {
switch(c) {
case 't':
num_threads = atoi(optarg);
if (num_threads < 1 || num_threads > 100) {
usage(argv[0]);
}
break;
case 'm':
max_values_to_add = atoi(optarg);
if (max_values_to_add < 1) {
usage(argv[0]);
}
break;
case 's':
num_hash_buckets = atoi(optarg);
if (num_hash_buckets < 1) {
usage(argv[0]);
}
break;
case 'h':
default:
usage(argv[0]);
break;
}
}
// see the RNG
srandom(time(NULL));
// set up thread arguments
struct args thread_args;
thread_args.hash = hashtable_new(num_hash_buckets);
thread_args.max_values = max_values_to_add;
thread_args.num_words = 0;
thread_args.words = NULL;
thread_args.done_adding = 0;
pthread_mutex_init(&thread_args.done_adding_mutex, NULL);
pthread_cond_init(&thread_args.done_adding_condv, NULL);
// load up words from text file
load_words("words.txt", &thread_args);
// here are our threads...
pthread_t threads[num_threads];
int i = 0;
// start up the threads; they'll start adding to the hashtable
// immediately.
for (i = 0; i < num_threads; i++) {
if (0 > pthread_create(&threads[i], NULL, hasher_thread, (void*)&thread_args)) {
fprintf(stderr, "Error creating thread: %s\n", strerror(errno));
}
}
// do nothing in the main thread while worker
// threads are adding to hashtable.
while (thread_args.done_adding < num_threads) {
// sleep for half a second
usleep(500000);
}
// threads are done adding - dump the hashtable
printf("Dump of the hash table (which should be as full as it's gonna get).\n");
hashtable_print(thread_args.hash);
// signal worker threads to start removing from hashtable
pthread_mutex_lock(&thread_args.done_adding_mutex);
thread_args.done_adding = -1;
pthread_mutex_unlock(&thread_args.done_adding_mutex);
pthread_cond_broadcast(&thread_args.done_adding_condv);
// wait for workers to complete
for (i = 0; i < num_threads; i++) {
pthread_join(threads[i], NULL);
}
printf("Dump of the hash table (which should be empty!)\n");
hashtable_print(thread_args.hash);
for (i = 0; i < thread_args.num_words; i++) {
free(thread_args.words[i]);
}
free(thread_args.words);
hashtable_free(thread_args.hash);
exit(0);
}
