diff options
| -rw-r--r-- | gcc/ChangeLog | 28 | ||||
| -rw-r--r-- | gcc/Makefile.in | 2 | ||||
| -rw-r--r-- | gcc/ggc-common.c | 123 | ||||
| -rw-r--r-- | gcc/ggc-page.c | 32 | ||||
| -rw-r--r-- | gcc/ggc.h | 6 | ||||
| -rw-r--r-- | gcc/gimplify.c | 13 |
6 files changed, 172 insertions, 32 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 7101910..80d593f 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,31 @@ +2004-09-02 Jan Hubicka <jh@suse.cz> + + * gimplify.c (gimplify_compound_lval): Move "stack" varray out of + GGC. + + * ggc-page.c: include tree-flow.h. + (extra_order_size_table): Add stmt_ann_d. + (STAT_LABEL): Rename from .... + (LABEL): ... this one. + * Makefile.in (ggc-page.o): Add dependency. + + * ggc-common.c (ggc_force_collect): New global variable. + (loc_description): Add fields "freed", "collected" + (ptr_hash): New static hash + (ptr_hash_entry): New structure. + (hash_ptr,eq_ptr,ggc_prune_ptr): New static functions. + (ggc_record_overhead): Take ptr argument, record it + (ggc_prune_overhead_list, ggc_free_overhead): New functions. + (cmp_statistics): Imrove sorting. + (dump_ggc_loc_statistics): Output newly collected statistics + * ggc-page.c (ggc_alloc): Update call of ggc_record_overhead + (ggc_free): Call ggc_free_overhead. + (ggc_collect): Force collection when asked to be forced. + (ggc_collect): Call ggc_prune_overhead_list. + * ggc.h (ggc_force_collect): Declare + (ggc_record_overhead): Update prototype. + (ggc_free_overhead, ggc_prune_overhead_list): Declare. + 2004-09-02 James E Wilson <wilson@specifixinc.com> * common.opt (ftrapping-math): Default to on. diff --git a/gcc/Makefile.in b/gcc/Makefile.in index dd2333c..80af8c5 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1548,7 +1548,7 @@ ggc-common.o: ggc-common.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(GGC_H) \ $(HASHTAB_H) toplev.h $(PARAMS_H) hosthooks.h ggc-page.o: ggc-page.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) $(TREE_H) \ - flags.h toplev.h $(GGC_H) $(TIMEVAR_H) $(TM_P_H) $(PARAMS_H) + flags.h toplev.h $(GGC_H) $(TIMEVAR_H) $(TM_P_H) $(PARAMS_H) $(TREE_FLOW_H) ggc-zone.o: ggc-zone.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) $(TREE_H) \ flags.h toplev.h $(GGC_H) $(TIMEVAR_H) $(TM_P_H) $(PARAMS_H) diff --git a/gcc/ggc-common.c b/gcc/ggc-common.c index 5c99175..d2528c0 100644 --- a/gcc/ggc-common.c +++ b/gcc/ggc-common.c @@ -61,6 +61,9 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #define VALGRIND_DISCARD(x) #endif +/* When set, ggc_collect will do collection. */ +bool ggc_force_collect; + /* Statistics about the allocation. */ static ggc_statistics *ggc_stats; @@ -780,6 +783,8 @@ struct loc_descriptor int times; size_t allocated; size_t overhead; + size_t freed; + size_t collected; }; /* Hashtable used for statistics. */ @@ -804,6 +809,32 @@ eq_descriptor (const void *p1, const void *p2) && d->function == d2->function); } +/* Hashtable converting address of allocated field to loc descriptor. */ +static htab_t ptr_hash; +struct ptr_hash_entry +{ + void *ptr; + struct loc_descriptor *loc; + size_t size; +}; + +/* Hash table helpers functions. */ +static hashval_t +hash_ptr (const void *p) +{ + const struct ptr_hash_entry *d = p; + + return htab_hash_pointer (d->ptr); +} + +static int +eq_ptr (const void *p1, const void *p2) +{ + const struct ptr_hash_entry *p = p1; + + return (p->ptr == p2); +} + /* Return descriptor for given call site, create new one if needed. */ static struct loc_descriptor * loc_descriptor (const char *name, int line, const char *function) @@ -829,23 +860,70 @@ loc_descriptor (const char *name, int line, const char *function) /* Record ALLOCATED and OVERHEAD bytes to descriptor NAME:LINE (FUNCTION). */ void -ggc_record_overhead (size_t allocated, size_t overhead, +ggc_record_overhead (size_t allocated, size_t overhead, void *ptr, const char *name, int line, const char *function) { struct loc_descriptor *loc = loc_descriptor (name, line, function); + struct ptr_hash_entry *p = xmalloc (sizeof (struct ptr_hash_entry)); + PTR *slot; + + p->ptr = ptr; + p->loc = loc; + p->size = allocated + overhead; + if (!ptr_hash) + ptr_hash = htab_create (10, hash_ptr, eq_ptr, NULL); + slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr), INSERT); + if (*slot) + abort (); + *slot = p; loc->times++; loc->allocated+=allocated; loc->overhead+=overhead; } +/* Helper function for prune_overhead_list. See if SLOT is still marked and + remove it from hashtable if it is not. */ +static int +ggc_prune_ptr (void **slot, void *b ATTRIBUTE_UNUSED) +{ + struct ptr_hash_entry *p = *slot; + if (!ggc_marked_p (p->ptr)) + { + p->loc->collected += p->size; + htab_clear_slot (ptr_hash, slot); + free (p); + } + return 1; +} + +/* After live values has been marked, walk all recorded pointers and see if + they are still live. */ +void +ggc_prune_overhead_list (void) +{ + htab_traverse (ptr_hash, ggc_prune_ptr, NULL); +} + +/* Notice that the pointer has been freed. */ +void ggc_free_overhead (void *ptr) +{ + PTR *slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr), + NO_INSERT); + struct ptr_hash_entry *p = *slot; + p->loc->freed += p->size; + htab_clear_slot (ptr_hash, slot); + free (p); +} + /* Helper for qsort; sort descriptors by amount of memory consumed. */ static int cmp_statistic (const void *loc1, const void *loc2) { struct loc_descriptor *l1 = *(struct loc_descriptor **) loc1; struct loc_descriptor *l2 = *(struct loc_descriptor **) loc2; - return (l1->allocated + l1->overhead) - (l2->allocated + l2->overhead); + return ((l1->allocated + l1->overhead - l1->freed) - + (l2->allocated + l2->overhead - l1->freed)); } /* Collect array of the descriptors from hashtable. */ @@ -866,24 +944,26 @@ void dump_ggc_loc_statistics (void) #ifdef GATHER_STATISTICS int nentries = 0; char s[4096]; - size_t count, size, overhead; + size_t collected = 0, freed = 0, allocated = 0, overhead = 0, times = 0; int i; + ggc_force_collect = true; + ggc_collect (); + loc_array = xcalloc (sizeof (*loc_array), loc_hash->n_elements); fprintf (stderr, "-------------------------------------------------------\n"); - fprintf (stderr, "\n%-60s %10s %10s %10s\n", - "source location", "Times", "Allocated", "Overhead"); + fprintf (stderr, "\n%-48s %10s %10s %10s %10s %10s\n", + "source location", "Garbage", "Freed", "Leak", "Overhead", "Times"); fprintf (stderr, "-------------------------------------------------------\n"); - count = 0; - size = 0; - overhead = 0; htab_traverse (loc_hash, add_statistics, &nentries); qsort (loc_array, nentries, sizeof (*loc_array), cmp_statistic); for (i = 0; i < nentries; i++) { struct loc_descriptor *d = loc_array[i]; - size += d->allocated; - count += d->times; + allocated += d->allocated; + times += d->times; + freed += d->freed; + collected += d->collected; overhead += d->overhead; } for (i = 0; i < nentries; i++) @@ -896,13 +976,26 @@ void dump_ggc_loc_statistics (void) while ((s2 = strstr (s1, "gcc/"))) s1 = s2 + 4; sprintf (s, "%s:%i (%s)", s1, d->line, d->function); - fprintf (stderr, "%-60s %10i %10li %10li:%.3f%%\n", s, - d->times, (long)d->allocated, (long)d->overhead, - (d->allocated + d->overhead) *100.0 / (size + overhead)); + s[48] = 0; + fprintf (stderr, "%-48s %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li\n", s, + (long)d->collected, + (d->collected) * 100.0 / collected, + (long)d->freed, + (d->freed) * 100.0 / freed, + (long)(d->allocated + d->overhead - d->freed - d->collected), + (d->allocated + d->overhead - d->freed - d->collected) * 100.0 + / (allocated + overhead - freed - collected), + (long)d->overhead, + d->overhead * 100.0 / overhead, + (long)d->times); } } - fprintf (stderr, "%-60s %10ld %10ld %10ld\n", - "Total", (long)count, (long)size, (long)overhead); + fprintf (stderr, "%-48s %10ld %10ld %10ld %10ld %10ld\n", + "Total", (long)collected, (long)freed, + (long)(allocated + overhead - freed - collected), (long)overhead, + (long)times); + fprintf (stderr, "%-48s %10s %10s %10s %10s %10s\n", + "source location", "Garbage", "Freed", "Leak", "Overhead", "Times"); fprintf (stderr, "-------------------------------------------------------\n"); #endif } diff --git a/gcc/ggc-page.c b/gcc/ggc-page.c index 4fc6887..578faf6 100644 --- a/gcc/ggc-page.c +++ b/gcc/ggc-page.c @@ -31,6 +31,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "ggc.h" #include "timevar.h" #include "params.h" +#include "tree-flow.h" #ifdef ENABLE_VALGRIND_CHECKING # ifdef HAVE_VALGRIND_MEMCHECK_H # include <valgrind/memcheck.h> @@ -184,6 +185,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA thing you need to do to add a new special allocation size. */ static const size_t extra_order_size_table[] = { + sizeof (struct stmt_ann_d), sizeof (struct tree_decl), sizeof (struct tree_list), TREE_EXP_SIZE (2), @@ -1173,12 +1175,13 @@ ggc_alloc_stat (size_t size MEM_STAT_DECL) G.page_tails[order]->next = entry; G.page_tails[order] = entry; } -#ifdef GATHER_STATISTICS - ggc_record_overhead (OBJECT_SIZE (order), OBJECT_SIZE (order) - size PASS_MEM_STAT); -#endif /* Calculate the object's address. */ result = entry->page + object_offset; +#ifdef GATHER_STATISTICS + ggc_record_overhead (OBJECT_SIZE (order), OBJECT_SIZE (order) - size, + result PASS_MEM_STAT); +#endif #ifdef ENABLE_GC_CHECKING /* Keep poisoning-by-writing-0xaf the object, in an attempt to keep the @@ -1327,6 +1330,10 @@ ggc_free (void *p) size_t order = pe->order; size_t size = OBJECT_SIZE (order); +#ifdef GATHER_STATISTICS + ggc_free_overhead (p); +#endif + if (GGC_DEBUG_LEVEL >= 3) fprintf (G.debug_file, "Freeing object, actual size=%lu, at %p on %p\n", @@ -1971,7 +1978,7 @@ ggc_collect (void) float min_expand = allocated_last_gc * PARAM_VALUE (GGC_MIN_EXPAND) / 100; - if (G.allocated < allocated_last_gc + min_expand) + if (G.allocated < allocated_last_gc + min_expand && !ggc_force_collect) return; timevar_push (TV_GC); @@ -1993,6 +2000,9 @@ ggc_collect (void) clear_marks (); ggc_mark_roots (); +#ifdef GATHER_STATISTICS + ggc_prune_overhead_list (); +#endif poison_pages (); validate_free_objects (); sweep_pages (); @@ -2013,7 +2023,7 @@ ggc_collect (void) : ((x) < 1024*1024*10 \ ? (x) / 1024 \ : (x) / (1024*1024)))) -#define LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M')) +#define STAT_LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M')) void ggc_print_statistics (void) @@ -2068,15 +2078,15 @@ ggc_print_statistics (void) } fprintf (stderr, "%-5lu %10lu%c %10lu%c %10lu%c\n", (unsigned long) OBJECT_SIZE (i), - SCALE (allocated), LABEL (allocated), - SCALE (in_use), LABEL (in_use), - SCALE (overhead), LABEL (overhead)); + SCALE (allocated), STAT_LABEL (allocated), + SCALE (in_use), STAT_LABEL (in_use), + SCALE (overhead), STAT_LABEL (overhead)); total_overhead += overhead; } fprintf (stderr, "%-5s %10lu%c %10lu%c %10lu%c\n", "Total", - SCALE (G.bytes_mapped), LABEL (G.bytes_mapped), - SCALE (G.allocated), LABEL(G.allocated), - SCALE (total_overhead), LABEL (total_overhead)); + SCALE (G.bytes_mapped), STAT_LABEL (G.bytes_mapped), + SCALE (G.allocated), STAT_LABEL(G.allocated), + SCALE (total_overhead), STAT_LABEL (total_overhead)); #ifdef GATHER_STATISTICS { @@ -209,6 +209,8 @@ extern struct alloc_zone *garbage_zone; extern struct alloc_zone *rtl_zone; /* For regular tree allocations. */ extern struct alloc_zone *tree_zone; +/* When set, ggc_collect will do collection. */ +extern bool ggc_force_collect; /* The internal primitive. */ extern void *ggc_alloc_stat (size_t MEM_STAT_DECL); @@ -233,7 +235,9 @@ extern void *ggc_calloc (size_t, size_t); /* Free a block. To be used when known for certain it's not reachable. */ extern void ggc_free (void *); -extern void ggc_record_overhead (size_t, size_t MEM_STAT_DECL); +extern void ggc_record_overhead (size_t, size_t, void * MEM_STAT_DECL); +extern void ggc_free_overhead (void *); +extern void ggc_prune_overhead_list (void); extern void dump_ggc_loc_statistics (void); diff --git a/gcc/gimplify.c b/gcc/gimplify.c index 050f97c..1ba8cad 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -1466,8 +1466,11 @@ gimplify_compound_lval (tree *expr_p, tree *pre_p, int i; /* Create a stack of the subexpressions so later we can walk them in - order from inner to outer. */ - VARRAY_TREE_INIT (stack, 10, "stack"); + order from inner to outer. + + This array is very memory consuming. Don't even think of making + it VARRAY_TREE. */ + VARRAY_GENERIC_PTR_NOGC_INIT (stack, 10, "stack"); /* We can either handle REALPART_EXPR, IMAGEPART_EXPR anything that handled_components can deal with. */ @@ -1475,7 +1478,7 @@ gimplify_compound_lval (tree *expr_p, tree *pre_p, (handled_component_p (*p) || TREE_CODE (*p) == REALPART_EXPR || TREE_CODE (*p) == IMAGPART_EXPR); p = &TREE_OPERAND (*p, 0)) - VARRAY_PUSH_TREE (stack, *p); + VARRAY_PUSH_GENERIC_PTR_NOGC (stack, *p); #if defined ENABLE_CHECKING if (VARRAY_ACTIVE_SIZE (stack) == 0) @@ -1496,7 +1499,7 @@ gimplify_compound_lval (tree *expr_p, tree *pre_p, then we gimplify any indices, from left to right. */ for (i = VARRAY_ACTIVE_SIZE (stack) - 1; i >= 0; i--) { - tree t = VARRAY_TREE (stack, i); + tree t = VARRAY_GENERIC_PTR_NOGC (stack, i); if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF) { @@ -1615,6 +1618,8 @@ gimplify_compound_lval (tree *expr_p, tree *pre_p, ret = MIN (ret, GS_OK); } + VARRAY_FREE (stack); + return ret; } |