/* Implement a cached obstack.
Written by Fred Fish (fnf@cygnus.com)
- Copyright 1995 Free Software Foundation, Inc.
+ Copyright 1995, 1998 Free Software Foundation, Inc.
This file is part of GDB.
#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));
+
+static void *lookup_cache PARAMS ((void *, int, int, struct bcache *));
/* FIXME: Incredibly simplistic hash generator. Probably way too expensive
(consider long strings) and unlikely to have good distribution across hash
linkp = hashtablep[hashval];
while (linkp != NULL)
{
- if (memcmp (linkp -> data, bytes, count) == 0)
+ if (memcmp (BCACHE_DATA (linkp), bytes, count) == 0)
{
- location = linkp -> data;
+ location = BCACHE_DATA (linkp);
break;
}
linkp = linkp -> next;
struct hashlink **linkpp;
struct hashlink ***hashtablepp;
- if (count > BCACHE_MAXLENGTH)
+ if (count >= BCACHE_MAXLENGTH)
{
/* Rare enough to just stash unique copies */
location = (void *) obstack_alloc (&bcachep->cache, count);
{
*hashtablepp = (struct hashlink **)
obstack_alloc (&bcachep->cache, BCACHE_HASHSIZE * sizeof (struct hashlink *));
- bcachep -> cache_bytes += 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, sizeof (struct hashlink *) + count);
- bcachep -> cache_bytes += sizeof (struct hashlink *) + count;
- memcpy (newlink -> data, bytes, count);
+ 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 = newlink -> data;
+ location = BCACHE_DATA (newlink);
}
}
return (location);
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: %d%%\n", ((bcachep -> cache_hits) * 100) / (bcachep -> cache_hits + 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: %d%%\n",
- (hcount * 100) / (tcount * BCACHE_HASHSIZE));
- printf_filtered (" Average chain length %d\n", lcount / hcount);
+ printf_filtered (" Average hash table population: ");
+ if (tcount > 0)
+ {
+ printf_filtered ("%d%%\n", (hcount * 100) / (tcount * BCACHE_HASHSIZE));
+ }
+ else
+ {
+ printf_filtered ("(not applicable)\n");
+ }
+ printf_filtered (" Average chain length ");
+ if (hcount > 0)
+ {
+ printf_filtered ("%d\n", lcount / hcount);
+ }
+ else
+ {
+ printf_filtered ("(not applicable)\n");
+ }
printf_filtered (" Maximum chain length %d at %d:%d\n", lmax, lmaxt, lmaxh);
}