Browse Source
* Makefile.in (SFILES): Add bcache.c.
(symtab_h): Add bcache.h.
(HFILES_NO_SRCDIR): add bcache.h
(COMMON_OBJS): Add bcache.o
(bcache.o): New target.
* dbxread.c (start_psymtab): Make global_syms & static_syms
type "partial_symbol **".
* hpread.c (hpread_start_symtab): Ditto.
* os9kread.c (os9k_start_psymtab): Ditto.
* stabsread.h (start_psymtab): Ditto.
* {symfile.c, symfile.h} (start_psymtab_common): Ditto.
* maint.c (maintenance_print_statistics): Call
print_symbol_bcache_statistics.
* objfiles.c (allocate_objfile): Initialize psymbol bcache malloc
and free pointers.
* solib.c (allocate_rt_common_objfile): Ditto.
* symfile.c (reread_symbols): Ditto.
(free_objfile): Free psymbol bcache when objfile is freed.
(objfile_relocate): Use new indirect psymbol pointers.
* objfiles.h (struct objfile): Add psymbol cache.
* symfile.c (compare_psymbols): Now passed pointers to pointers to
psymbols.
(reread_symbols): Free psymbol bcache when freeing other objfile
resources.
(add_psymbol_to_list, add_psymbol_addr_to_list): Initialize new
psymbol using the psymbol bcache.
(init_psymbol_list): Psymbol lists now contain pointers rather than
the actual psymbols.
* symfile.h (psymbol_allocation_list): Psymbol lists now dynamically
grown arrays of pointers.
(ADD_PSYMBOL_VT_TO_LIST): Initialize new symbol using the psymbol
bcache.
* symmisc.c (print_partial_symbols): Now takes pointer to pointer
to partial symbol.
(print_symbol_bcache_statistics): New function to print per objfile
bcache statistics.
(print_partial_symbol, print_partial_symbols,
maintenance_check_symtabs, extend_psymbol_list):
Account for change to pointer to pointer to partial symbol.
* symtab.c (find_pc_psymbol, lookup_partial_symbol, decode_line_2,
make_symbol_completion_list):
Account for change to pointer to pointer to partial symbol.
* symtab.h (bcache.h): Include.
* xcoffread.c (xcoff_start_psymtab): Make global_syms & static_syms
type "partial_symbol **".
gdb-4_18-branch
Fred Fish
31 years ago
16 changed files with 458 additions and 115 deletions
@ -0,0 +1,188 @@ |
|||
/* Implement a cached obstack.
|
|||
Written by Fred Fish (fnf@cygnus.com) |
|||
Copyright 1995 Free Software Foundation, Inc. |
|||
|
|||
This file is part of GDB. |
|||
|
|||
This program is free software; you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation; either version 2 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
This program is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with this program; if not, write to the Free Software |
|||
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
|||
|
|||
#include "defs.h" |
|||
#include "obstack.h" |
|||
#include "bcache.h" |
|||
|
|||
/* FIXME: Incredibly simplistic hash generator. Probably way too expensive
|
|||
(consider long strings) and unlikely to have good distribution across hash |
|||
values for typical input. */ |
|||
|
|||
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) |
|||
{ |
|||
c = *data++; |
|||
hashval += c + (c << 17); |
|||
hashval ^= hashval >> 2; |
|||
++len; |
|||
} |
|||
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; |
|||
{ |
|||
void *location = NULL; |
|||
struct hashlink **hashtablep; |
|||
struct hashlink *linkp; |
|||
|
|||
hashtablep = bcachep -> indextable[count]; |
|||
if (hashtablep != NULL) |
|||
{ |
|||
linkp = hashtablep[hashval]; |
|||
while (linkp != NULL) |
|||
{ |
|||
if (memcmp (linkp -> data, bytes, count) == 0) |
|||
{ |
|||
location = linkp -> data; |
|||
break; |
|||
} |
|||
linkp = linkp -> next; |
|||
} |
|||
} |
|||
return (location); |
|||
} |
|||
|
|||
void * |
|||
bcache (bytes, count, bcachep) |
|||
void *bytes; |
|||
int count; |
|||
struct bcache *bcachep; |
|||
{ |
|||
int hashval; |
|||
void *location; |
|||
struct hashlink *newlink; |
|||
struct hashlink **linkpp; |
|||
struct hashlink ***hashtablepp; |
|||
|
|||
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 += 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); |
|||
newlink -> next = *linkpp; |
|||
*linkpp = newlink; |
|||
location = newlink -> data; |
|||
} |
|||
} |
|||
return (location); |
|||
} |
|||
|
|||
#if MAINTENANCE_CMDS |
|||
|
|||
void |
|||
print_bcache_statistics (bcachep, id) |
|||
struct bcache *bcachep; |
|||
char *id; |
|||
{ |
|||
struct hashlink **hashtablep; |
|||
struct hashlink *linkp; |
|||
int tidx, tcount, hidx, hcount, lcount, lmax, temp, lmaxt, lmaxh; |
|||
|
|||
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: %d%%\n", ((bcachep -> cache_hits) * 100) / (bcachep -> cache_hits + bcachep -> cache_misses)); |
|||
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 (" Maximum chain length %d at %d:%d\n", lmax, lmaxt, lmaxh); |
|||
} |
|||
|
|||
#endif /* MAINTENANCE_CMDS */ |
|||
@ -0,0 +1,46 @@ |
|||
/* Include file cached obstack implementation.
|
|||
Written by Fred Fish (fnf@cygnus.com) |
|||
Copyright 1995 Free Software Foundation, Inc. |
|||
|
|||
This file is part of GDB. |
|||
|
|||
This program is free software; you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation; either version 2 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
This program is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with this program; if not, write to the Free Software |
|||
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
|||
|
|||
#ifndef BCACHE_H |
|||
#define BCACHE_H 1 |
|||
|
|||
#define BCACHE_HASHLENGTH 12 /* Number of bits in hash value */ |
|||
#define BCACHE_HASHSIZE (1 << BCACHE_HASHLENGTH) |
|||
#define BCACHE_MAXLENGTH 128 |
|||
|
|||
struct hashlink { |
|||
struct hashlink *next; |
|||
char data[1]; |
|||
}; |
|||
|
|||
struct bcache { |
|||
struct obstack cache; |
|||
struct hashlink **indextable[BCACHE_MAXLENGTH]; |
|||
int cache_hits; |
|||
int cache_misses; |
|||
int cache_bytes; |
|||
int cache_savings; |
|||
int bcache_overflows; |
|||
}; |
|||
|
|||
extern void * |
|||
bcache PARAMS ((void *bytes, int count, struct bcache *bcachep)); |
|||
|
|||
#endif /* BCACHE_H */ |
|||
Loading…
Reference in new issue