From 4f670845ff9ab6c48bcb5f7bf4d4ef6dc3c3064b Mon Sep 17 00:00:00 2001 From: manuel Date: Tue, 27 Mar 2012 11:51:08 +0200 Subject: reorganize file structure to match the upstream requirements --- pintos-progos/lib/kernel/hash.c | 430 ---------------------------------------- 1 file changed, 430 deletions(-) delete mode 100644 pintos-progos/lib/kernel/hash.c (limited to 'pintos-progos/lib/kernel/hash.c') diff --git a/pintos-progos/lib/kernel/hash.c b/pintos-progos/lib/kernel/hash.c deleted file mode 100644 index 57eed45..0000000 --- a/pintos-progos/lib/kernel/hash.c +++ /dev/null @@ -1,430 +0,0 @@ -/* Hash table. - - This data structure is thoroughly documented in the Tour of - Pintos for Project 3. - - See hash.h for basic information. */ - -#include "hash.h" -#include "../debug.h" -#include "threads/malloc.h" - -#define list_elem_to_hash_elem(LIST_ELEM) \ - list_entry(LIST_ELEM, struct hash_elem, list_elem) - -static struct list *find_bucket (struct hash *, struct hash_elem *); -static struct hash_elem *find_elem (struct hash *, struct list *, - struct hash_elem *); -static void insert_elem (struct hash *, struct list *, struct hash_elem *); -static void remove_elem (struct hash *, struct hash_elem *); -static void rehash (struct hash *); - -/* Initializes hash table H to compute hash values using HASH and - compare hash elements using LESS, given auxiliary data AUX. */ -bool -hash_init (struct hash *h, - hash_hash_func *hash, hash_less_func *less, void *aux) -{ - h->elem_cnt = 0; - h->bucket_cnt = 4; - h->buckets = malloc (sizeof *h->buckets * h->bucket_cnt); - h->hash = hash; - h->less = less; - h->aux = aux; - - if (h->buckets != NULL) - { - hash_clear (h, NULL); - return true; - } - else - return false; -} - -/* Removes all the elements from H. - - If DESTRUCTOR is non-null, then it is called for each element - in the hash. DESTRUCTOR may, if appropriate, deallocate the - memory used by the hash element. However, modifying hash - table H while hash_clear() is running, using any of the - functions hash_clear(), hash_destroy(), hash_insert(), - hash_replace(), or hash_delete(), yields undefined behavior, - whether done in DESTRUCTOR or elsewhere. */ -void -hash_clear (struct hash *h, hash_action_func *destructor) -{ - size_t i; - - for (i = 0; i < h->bucket_cnt; i++) - { - struct list *bucket = &h->buckets[i]; - - if (destructor != NULL) - while (!list_empty (bucket)) - { - struct list_elem *list_elem = list_pop_front (bucket); - struct hash_elem *hash_elem = list_elem_to_hash_elem (list_elem); - destructor (hash_elem, h->aux); - } - - list_init (bucket); - } - - h->elem_cnt = 0; -} - -/* Destroys hash table H. - - If DESTRUCTOR is non-null, then it is first called for each - element in the hash. DESTRUCTOR may, if appropriate, - deallocate the memory used by the hash element. However, - modifying hash table H while hash_clear() is running, using - any of the functions hash_clear(), hash_destroy(), - hash_insert(), hash_replace(), or hash_delete(), yields - undefined behavior, whether done in DESTRUCTOR or - elsewhere. */ -void -hash_destroy (struct hash *h, hash_action_func *destructor) -{ - if (destructor != NULL) - hash_clear (h, destructor); - free (h->buckets); -} - -/* Inserts NEW into hash table H and returns a null pointer, if - no equal element is already in the table. - If an equal element is already in the table, returns it - without inserting NEW. */ -struct hash_elem * -hash_insert (struct hash *h, struct hash_elem *new) -{ - struct list *bucket = find_bucket (h, new); - struct hash_elem *old = find_elem (h, bucket, new); - - if (old == NULL) - insert_elem (h, bucket, new); - - rehash (h); - - return old; -} - -/* Inserts NEW into hash table H, replacing any equal element - already in the table, which is returned. */ -struct hash_elem * -hash_replace (struct hash *h, struct hash_elem *new) -{ - struct list *bucket = find_bucket (h, new); - struct hash_elem *old = find_elem (h, bucket, new); - - if (old != NULL) - remove_elem (h, old); - insert_elem (h, bucket, new); - - rehash (h); - - return old; -} - -/* Finds and returns an element equal to E in hash table H, or a - null pointer if no equal element exists in the table. */ -struct hash_elem * -hash_find (struct hash *h, struct hash_elem *e) -{ - return find_elem (h, find_bucket (h, e), e); -} - -/* Finds, removes, and returns an element equal to E in hash - table H. Returns a null pointer if no equal element existed - in the table. - - If the elements of the hash table are dynamically allocated, - or own resources that are, then it is the caller's - responsibility to deallocate them. */ -struct hash_elem * -hash_delete (struct hash *h, struct hash_elem *e) -{ - struct hash_elem *found = find_elem (h, find_bucket (h, e), e); - if (found != NULL) - { - remove_elem (h, found); - rehash (h); - } - return found; -} - -/* Calls ACTION for each element in hash table H in arbitrary - order. - Modifying hash table H while hash_apply() is running, using - any of the functions hash_clear(), hash_destroy(), - hash_insert(), hash_replace(), or hash_delete(), yields - undefined behavior, whether done from ACTION or elsewhere. */ -void -hash_apply (struct hash *h, hash_action_func *action) -{ - size_t i; - - ASSERT (action != NULL); - - for (i = 0; i < h->bucket_cnt; i++) - { - struct list *bucket = &h->buckets[i]; - struct list_elem *elem, *next; - - for (elem = list_begin (bucket); elem != list_end (bucket); elem = next) - { - next = list_next (elem); - action (list_elem_to_hash_elem (elem), h->aux); - } - } -} - -/* Initializes I for iterating hash table H. - - Iteration idiom: - - struct hash_iterator i; - - hash_first (&i, h); - while (hash_next (&i)) - { - struct foo *f = hash_entry (hash_cur (&i), struct foo, elem); - ...do something with f... - } - - Modifying hash table H during iteration, using any of the - functions hash_clear(), hash_destroy(), hash_insert(), - hash_replace(), or hash_delete(), invalidates all - iterators. */ -void -hash_first (struct hash_iterator *i, struct hash *h) -{ - ASSERT (i != NULL); - ASSERT (h != NULL); - - i->hash = h; - i->bucket = i->hash->buckets; - i->elem = list_elem_to_hash_elem (list_head (i->bucket)); -} - -/* Advances I to the next element in the hash table and returns - it. Returns a null pointer if no elements are left. Elements - are returned in arbitrary order. - - Modifying a hash table H during iteration, using any of the - functions hash_clear(), hash_destroy(), hash_insert(), - hash_replace(), or hash_delete(), invalidates all - iterators. */ -struct hash_elem * -hash_next (struct hash_iterator *i) -{ - ASSERT (i != NULL); - - i->elem = list_elem_to_hash_elem (list_next (&i->elem->list_elem)); - while (i->elem == list_elem_to_hash_elem (list_end (i->bucket))) - { - if (++i->bucket >= i->hash->buckets + i->hash->bucket_cnt) - { - i->elem = NULL; - break; - } - i->elem = list_elem_to_hash_elem (list_begin (i->bucket)); - } - - return i->elem; -} - -/* Returns the current element in the hash table iteration, or a - null pointer at the end of the table. Undefined behavior - after calling hash_first() but before hash_next(). */ -struct hash_elem * -hash_cur (struct hash_iterator *i) -{ - return i->elem; -} - -/* Returns the number of elements in H. */ -size_t -hash_size (struct hash *h) -{ - return h->elem_cnt; -} - -/* Returns true if H contains no elements, false otherwise. */ -bool -hash_empty (struct hash *h) -{ - return h->elem_cnt == 0; -} - -/* Fowler-Noll-Vo hash constants, for 32-bit word sizes. */ -#define FNV_32_PRIME 16777619u -#define FNV_32_BASIS 2166136261u - -/* Returns a hash of the SIZE bytes in BUF. */ -unsigned -hash_bytes (const void *buf_, size_t size) -{ - /* Fowler-Noll-Vo 32-bit hash, for bytes. */ - const unsigned char *buf = buf_; - unsigned hash; - - ASSERT (buf != NULL); - - hash = FNV_32_BASIS; - while (size-- > 0) - hash = (hash * FNV_32_PRIME) ^ *buf++; - - return hash; -} - -/* Returns a hash of string S. */ -unsigned -hash_string (const char *s_) -{ - const unsigned char *s = (const unsigned char *) s_; - unsigned hash; - - ASSERT (s != NULL); - - hash = FNV_32_BASIS; - while (*s != '\0') - hash = (hash * FNV_32_PRIME) ^ *s++; - - return hash; -} - -/* Returns a hash of integer I. */ -unsigned -hash_int (int i) -{ - return hash_bytes (&i, sizeof i); -} - -/* Returns the bucket in H that E belongs in. */ -static struct list * -find_bucket (struct hash *h, struct hash_elem *e) -{ - size_t bucket_idx = h->hash (e, h->aux) & (h->bucket_cnt - 1); - return &h->buckets[bucket_idx]; -} - -/* Searches BUCKET in H for a hash element equal to E. Returns - it if found or a null pointer otherwise. */ -static struct hash_elem * -find_elem (struct hash *h, struct list *bucket, struct hash_elem *e) -{ - struct list_elem *i; - - for (i = list_begin (bucket); i != list_end (bucket); i = list_next (i)) - { - struct hash_elem *hi = list_elem_to_hash_elem (i); - if (!h->less (hi, e, h->aux) && !h->less (e, hi, h->aux)) - return hi; - } - return NULL; -} - -/* Returns X with its lowest-order bit set to 1 turned off. */ -static inline size_t -turn_off_least_1bit (size_t x) -{ - return x & (x - 1); -} - -/* Returns true if X is a power of 2, otherwise false. */ -static inline size_t -is_power_of_2 (size_t x) -{ - return x != 0 && turn_off_least_1bit (x) == 0; -} - -/* Element per bucket ratios. */ -#define MIN_ELEMS_PER_BUCKET 1 /* Elems/bucket < 1: reduce # of buckets. */ -#define BEST_ELEMS_PER_BUCKET 2 /* Ideal elems/bucket. */ -#define MAX_ELEMS_PER_BUCKET 4 /* Elems/bucket > 4: increase # of buckets. */ - -/* Changes the number of buckets in hash table H to match the - ideal. This function can fail because of an out-of-memory - condition, but that'll just make hash accesses less efficient; - we can still continue. */ -static void -rehash (struct hash *h) -{ - size_t old_bucket_cnt, new_bucket_cnt; - struct list *new_buckets, *old_buckets; - size_t i; - - ASSERT (h != NULL); - - /* Save old bucket info for later use. */ - old_buckets = h->buckets; - old_bucket_cnt = h->bucket_cnt; - - /* Calculate the number of buckets to use now. - We want one bucket for about every BEST_ELEMS_PER_BUCKET. - We must have at least four buckets, and the number of - buckets must be a power of 2. */ - new_bucket_cnt = h->elem_cnt / BEST_ELEMS_PER_BUCKET; - if (new_bucket_cnt < 4) - new_bucket_cnt = 4; - while (!is_power_of_2 (new_bucket_cnt)) - new_bucket_cnt = turn_off_least_1bit (new_bucket_cnt); - - /* Don't do anything if the bucket count wouldn't change. */ - if (new_bucket_cnt == old_bucket_cnt) - return; - - /* Allocate new buckets and initialize them as empty. */ - new_buckets = malloc (sizeof *new_buckets * new_bucket_cnt); - if (new_buckets == NULL) - { - /* Allocation failed. This means that use of the hash table will - be less efficient. However, it is still usable, so - there's no reason for it to be an error. */ - return; - } - for (i = 0; i < new_bucket_cnt; i++) - list_init (&new_buckets[i]); - - /* Install new bucket info. */ - h->buckets = new_buckets; - h->bucket_cnt = new_bucket_cnt; - - /* Move each old element into the appropriate new bucket. */ - for (i = 0; i < old_bucket_cnt; i++) - { - struct list *old_bucket; - struct list_elem *elem, *next; - - old_bucket = &old_buckets[i]; - for (elem = list_begin (old_bucket); - elem != list_end (old_bucket); elem = next) - { - struct list *new_bucket - = find_bucket (h, list_elem_to_hash_elem (elem)); - next = list_next (elem); - list_remove (elem); - list_push_front (new_bucket, elem); - } - } - - free (old_buckets); -} - -/* Inserts E into BUCKET (in hash table H). */ -static void -insert_elem (struct hash *h, struct list *bucket, struct hash_elem *e) -{ - h->elem_cnt++; - list_push_front (bucket, &e->list_elem); -} - -/* Removes E from hash table H. */ -static void -remove_elem (struct hash *h, struct hash_elem *e) -{ - h->elem_cnt--; - list_remove (&e->list_elem); -} - -- cgit v1.2.3