From c2d11a7da0372ef052af1c74d56e264d8aae4743 Mon Sep 17 00:00:00 2001 From: Jason Molenda Date: Tue, 7 Dec 1999 03:56:43 +0000 Subject: import gdb-1999-12-06 snapshot --- gdb/bcache.c | 423 ++++++++++++++++++++++++++++++++++++----------------------- 1 file changed, 258 insertions(+), 165 deletions(-) (limited to 'gdb/bcache.c') diff --git a/gdb/bcache.c b/gdb/bcache.c index 97485dd..8ac3305 100644 --- a/gdb/bcache.c +++ b/gdb/bcache.c @@ -1,6 +1,7 @@ /* Implement a cached obstack. - Written by Fred Fish (fnf@cygnus.com) - Copyright 1995, 1998 Free Software Foundation, Inc. + Written by Fred Fish + Rewritten by Jim Blandy + Copyright 1999 Free Software Foundation, Inc. This file is part of GDB. @@ -19,198 +20,290 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +#include +#include + #include "defs.h" #include "obstack.h" #include "bcache.h" #include "gdb_string.h" /* For memcpy declaration */ -/* Prototypes for local functions. */ -static unsigned int hash PARAMS ((void *, int)); + +/* The hash function. */ -static void *lookup_cache PARAMS ((void *, int, int, struct bcache *)); +unsigned long +hash (void *addr, int length) +{ + /* If it's a short string, hash on every character. Otherwise, sample + characters from throughout the string. */ + if (length <= 64) + { + char *byte = addr; + unsigned long h = 0; + int i; -/* FIXME: Incredibly simplistic hash generator. Probably way too expensive - (consider long strings) and unlikely to have good distribution across hash - values for typical input. */ + for (i = 0; i < length; i++) + h = h * 65793 ^ (h >> (sizeof (h) * 8 - 6)) ^ byte[i]; -static unsigned int -hash (bytes, count) - void *bytes; - int count; -{ - unsigned int len; - unsigned long hashval; - unsigned int c; - const unsigned char *data = bytes; - - hashval = 0; - len = 0; - while (count-- > 0) + return h; + } + else { - c = *data++; - hashval += c + (c << 17); - hashval ^= hashval >> 2; - ++len; + char *byte = addr; + int n, i; + unsigned long h = 0; + + for (n = i = 0; n < 64; n++) + { + h = h * 65793 + (h >> (sizeof (h) * 8 - 6)) + byte[i]; + i = h % length; + } + + return h; } - hashval += len + (len << 17); - hashval ^= hashval >> 2; - return (hashval % BCACHE_HASHSIZE); } -static void * -lookup_cache (bytes, count, hashval, bcachep) - void *bytes; - int count; - int hashval; - struct bcache *bcachep; + +/* Growing the bcache's hash table. */ + +/* If the average chain length grows beyond this, then we want to + resize our hash table. */ +#define CHAIN_LENGTH_THRESHOLD (5) + +static void +expand_hash_table (struct bcache *bcache) { - void *location = NULL; - struct hashlink **hashtablep; - struct hashlink *linkp; + /* A table of good hash table sizes. Whenever we grow, we pick the + next larger size from this table. sizes[i] is close to 1 << (i+10), + so we roughly double the table size each time. After we fall off + the end of this table, we just double. Don't laugh --- there have + been executables sighted with a gigabyte of debug info. */ + static unsigned long sizes[] = { + 1021, 2053, 4099, 8191, 16381, 32771, + 65537, 131071, 262144, 524287, 1048573, 2097143, + 4194301, 8388617, 16777213, 33554467, 67108859, 134217757, + 268435459, 536870923, 1073741827, 2147483659UL + }; + int new_num_buckets; + struct bstring **new_buckets; + int i; + + /* Find the next size. */ + for (i = 0; i < (sizeof (sizes) / sizeof (sizes[0])); i++) + if (sizes[i] > bcache->num_buckets) + { + new_num_buckets = sizes[i]; + break; + } + if (i >= (sizeof (sizes) / sizeof (sizes[0]))) + new_num_buckets = bcache->num_buckets * 2; + + /* Allocate the new table. */ + { + size_t new_size = new_num_buckets * sizeof (new_buckets[0]); + new_buckets = (struct bstring **) xmalloc (new_size); + memset (new_buckets, 0, new_size); + + bcache->structure_size -= (bcache->num_buckets + * sizeof (bcache->bucket[0])); + bcache->structure_size += new_size; + } - hashtablep = bcachep->indextable[count]; - if (hashtablep != NULL) + /* Rehash all existing strings. */ + for (i = 0; i < bcache->num_buckets; i++) { - linkp = hashtablep[hashval]; - while (linkp != NULL) + struct bstring *s, *next; + + for (s = bcache->bucket[i]; s; s = next) { - if (memcmp (BCACHE_DATA (linkp), bytes, count) == 0) - { - location = BCACHE_DATA (linkp); - break; - } - linkp = linkp->next; + struct bstring **new_bucket; + next = s->next; + + new_bucket = &new_buckets[(hash (&s->d.data, s->length) + % new_num_buckets)]; + s->next = *new_bucket; + *new_bucket = s; } } - return (location); + + /* Plug in the new table. */ + if (bcache->bucket) + free (bcache->bucket); + bcache->bucket = new_buckets; + bcache->num_buckets = new_num_buckets; } + +/* Looking up things in the bcache. */ + +/* The number of bytes needed to allocate a struct bstring whose data + is N bytes long. */ +#define BSTRING_SIZE(n) (offsetof (struct bstring, d.data) + (n)) + +/* Find a copy of the LENGTH bytes at ADDR in BCACHE. If BCACHE has + never seen those bytes before, add a copy of them to BCACHE. In + either case, return a pointer to BCACHE's copy of that string. */ void * -bcache (bytes, count, bcachep) - void *bytes; - int count; - struct bcache *bcachep; +bcache (void *addr, int length, struct bcache *bcache) { - int hashval; - void *location; - struct hashlink *newlink; - struct hashlink **linkpp; - struct hashlink ***hashtablepp; + int hash_index; + struct bstring *s; - if (count >= BCACHE_MAXLENGTH) - { - /* Rare enough to just stash unique copies */ - location = (void *) obstack_alloc (&bcachep->cache, count); - bcachep->cache_bytes += count; - memcpy (location, bytes, count); - bcachep->bcache_overflows++; - } - else - { - hashval = hash (bytes, count); - location = lookup_cache (bytes, count, hashval, bcachep); - if (location != NULL) - { - bcachep->cache_savings += count; - bcachep->cache_hits++; - } - else - { - bcachep->cache_misses++; - hashtablepp = &bcachep->indextable[count]; - if (*hashtablepp == NULL) - { - *hashtablepp = (struct hashlink **) - obstack_alloc (&bcachep->cache, BCACHE_HASHSIZE * sizeof (struct hashlink *)); - bcachep->cache_bytes += BCACHE_HASHSIZE * sizeof (struct hashlink *); - memset (*hashtablepp, 0, BCACHE_HASHSIZE * sizeof (struct hashlink *)); - } - linkpp = &(*hashtablepp)[hashval]; - newlink = (struct hashlink *) - obstack_alloc (&bcachep->cache, BCACHE_DATA_ALIGNMENT + count); - bcachep->cache_bytes += BCACHE_DATA_ALIGNMENT + count; - memcpy (BCACHE_DATA (newlink), bytes, count); - newlink->next = *linkpp; - *linkpp = newlink; - location = BCACHE_DATA (newlink); - } - } - return (location); + /* If our average chain length is too high, expand the hash table. */ + if (bcache->unique_count >= bcache->num_buckets * CHAIN_LENGTH_THRESHOLD) + expand_hash_table (bcache); + + bcache->total_count++; + bcache->total_size += length; + + hash_index = hash (addr, length) % bcache->num_buckets; + + /* Search the hash bucket for a string identical to the caller's. */ + for (s = bcache->bucket[hash_index]; s; s = s->next) + if (s->length == length + && ! memcmp (&s->d.data, addr, length)) + return &s->d.data; + + /* The user's string isn't in the list. Insert it after *ps. */ + { + struct bstring *new + = obstack_alloc (&bcache->cache, BSTRING_SIZE (length)); + memcpy (&new->d.data, addr, length); + new->length = length; + new->next = bcache->bucket[hash_index]; + bcache->bucket[hash_index] = new; + + bcache->unique_count++; + bcache->unique_size += length; + bcache->structure_size += BSTRING_SIZE (length); + + return &new->d.data; + } } + +/* Freeing bcaches. */ + +/* Free all the storage associated with BCACHE. */ void -print_bcache_statistics (bcachep, id) - struct bcache *bcachep; - char *id; +free_bcache (struct bcache *bcache) { - struct hashlink **hashtablep; - struct hashlink *linkp; - int tidx, tcount, hidx, hcount, lcount, lmax, temp, lmaxt, lmaxh; + obstack_free (&bcache->cache, 0); + free (bcache->bucket); - for (lmax = lcount = tcount = hcount = tidx = 0; tidx < BCACHE_MAXLENGTH; tidx++) - { - hashtablep = bcachep->indextable[tidx]; - if (hashtablep != NULL) - { - tcount++; - for (hidx = 0; hidx < BCACHE_HASHSIZE; hidx++) - { - linkp = hashtablep[hidx]; - if (linkp != NULL) - { - hcount++; - for (temp = 0; linkp != NULL; linkp = linkp->next) - { - lcount++; - temp++; - } - if (temp > lmax) - { - lmax = temp; - lmaxt = tidx; - lmaxh = hidx; - } - } - } - } - } - printf_filtered (" Cached '%s' statistics:\n", id); - printf_filtered (" Cache hits: %d\n", bcachep->cache_hits); - printf_filtered (" Cache misses: %d\n", bcachep->cache_misses); - printf_filtered (" Cache hit ratio: "); - if (bcachep->cache_hits + bcachep->cache_misses > 0) - { - printf_filtered ("%d%%\n", ((bcachep->cache_hits) * 100) / - (bcachep->cache_hits + bcachep->cache_misses)); - } - else - { - printf_filtered ("(not applicable)\n"); - } - printf_filtered (" Space used for caching: %d\n", bcachep->cache_bytes); - printf_filtered (" Space saved by cache hits: %d\n", bcachep->cache_savings); - printf_filtered (" Number of bcache overflows: %d\n", bcachep->bcache_overflows); - printf_filtered (" Number of index buckets used: %d\n", tcount); - printf_filtered (" Number of hash table buckets used: %d\n", hcount); - printf_filtered (" Number of chained items: %d\n", lcount); - printf_filtered (" Average hash table population: "); - if (tcount > 0) - { - printf_filtered ("%d%%\n", (hcount * 100) / (tcount * BCACHE_HASHSIZE)); - } + /* This isn't necessary, but at least the bcache is always in a + consistent state. */ + memset (bcache, 0, sizeof (*bcache)); +} + + + +/* Printing statistics. */ + +static int +compare_ints (const void *ap, const void *bp) +{ + /* Because we know we're comparing two ints which are positive, + there's no danger of overflow here. */ + return * (int *) ap - * (int *) bp; +} + + +static void +print_percentage (int portion, int total) +{ + if (total == 0) + printf_filtered ("(not applicable)\n"); else - { - printf_filtered ("(not applicable)\n"); - } - printf_filtered (" Average chain length "); - if (hcount > 0) - { - printf_filtered ("%d\n", lcount / hcount); - } + printf_filtered ("%3d%%\n", portion * 100 / total); +} + + +/* Print statistics on BCACHE's memory usage and efficacity at + eliminating duplication. NAME should describe the kind of data + BCACHE holds. Statistics are printed using `printf_filtered' and + its ilk. */ +void +print_bcache_statistics (struct bcache *c, char *type) +{ + int occupied_buckets; + int max_chain_length; + int median_chain_length; + + /* Count the number of occupied buckets, and measure chain lengths. */ + { + int b; + int *chain_length + = (int *) alloca (c->num_buckets * sizeof (*chain_length)); + + occupied_buckets = 0; + + for (b = 0; b < c->num_buckets; b++) + { + struct bstring *s = c->bucket[b]; + + chain_length[b] = 0; + + if (s) + { + occupied_buckets++; + + while (s) + { + chain_length[b]++; + s = s->next; + } + } + } + + /* To compute the median, we need the set of chain lengths sorted. */ + qsort (chain_length, c->num_buckets, sizeof (chain_length[0]), + compare_ints); + + if (c->num_buckets > 0) + { + max_chain_length = chain_length[c->num_buckets - 1]; + median_chain_length = chain_length[c->num_buckets / 2]; + } + else + { + max_chain_length = 0; + median_chain_length = 0; + } + } + + printf_filtered (" Cached '%s' statistics:\n", type); + printf_filtered (" Total object count: %ld\n", c->total_count); + printf_filtered (" Unique object count: %ld\n", c->unique_count); + printf_filtered (" Percentage of duplicates, by count: "); + print_percentage (c->total_count - c->unique_count, c->total_count); + printf_filtered ("\n"); + + printf_filtered (" Total object size: %ld\n", c->total_size); + printf_filtered (" Unique object size: %ld\n", c->unique_size); + printf_filtered (" Percentage of duplicates, by size: "); + print_percentage (c->total_size - c->unique_size, c->total_size); + printf_filtered ("\n"); + + printf_filtered (" Total memory used by bcache, including overhead: %ld\n", + c->structure_size); + printf_filtered (" Percentage memory overhead: "); + print_percentage (c->structure_size - c->unique_size, c->unique_size); + printf_filtered (" Net memory savings: "); + print_percentage (c->total_size - c->structure_size, c->total_size); + printf_filtered ("\n"); + + printf_filtered (" Hash table size: %3d\n", c->num_buckets); + printf_filtered (" Hash table population: "); + print_percentage (occupied_buckets, c->num_buckets); + printf_filtered (" Median hash chain length: %3d\n", + median_chain_length); + printf_filtered (" Average hash chain length: "); + if (c->num_buckets > 0) + printf_filtered ("%3ld\n", c->unique_count / c->num_buckets); else - { - printf_filtered ("(not applicable)\n"); - } - printf_filtered (" Maximum chain length %d at %d:%d\n", lmax, lmaxt, lmaxh); + printf_filtered ("(not applicable)\n"); + printf_filtered (" Maximum hash chain length: %3d\n", max_chain_length); + printf_filtered ("\n"); } -- cgit v1.1