1 /* Simple garbage collection for the GNU compiler.
2 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
22 /* Generic garbage collection (GC) functions and data, not specific to
23 any particular GC implementation. */
27 #include "coretypes.h"
32 #include "hosthooks.h"
33 #include "hosthooks-def.h"
35 #ifdef HAVE_SYS_RESOURCE_H
36 # include <sys/resource.h>
40 # include <sys/mman.h>
42 /* This is on Solaris. */
43 # include <sys/types.h>
48 # define MAP_FAILED ((void *)-1)
51 #ifdef ENABLE_VALGRIND_CHECKING
52 # ifdef HAVE_VALGRIND_MEMCHECK_H
53 # include <valgrind/memcheck.h>
54 # elif defined HAVE_MEMCHECK_H
55 # include <memcheck.h>
57 # include <valgrind.h>
60 /* Avoid #ifdef:s when we can help it. */
61 #define VALGRIND_DISCARD(x)
64 /* When set, ggc_collect will do collection. */
65 bool ggc_force_collect;
67 /* Statistics about the allocation. */
68 static ggc_statistics *ggc_stats;
70 struct traversal_state;
72 static int ggc_htab_delete (void **, void *);
73 static hashval_t saving_htab_hash (const void *);
74 static int saving_htab_eq (const void *, const void *);
75 static int call_count (void **, void *);
76 static int call_alloc (void **, void *);
77 static int compare_ptr_data (const void *, const void *);
78 static void relocate_ptrs (void *, void *);
79 static void write_pch_globals (const struct ggc_root_tab * const *tab,
80 struct traversal_state *state);
81 static double ggc_rlimit_bound (double);
83 /* Maintain global roots that are preserved during GC. */
85 /* Process a slot of an htab by deleting it if it has not been marked. */
88 ggc_htab_delete (void **slot, void *info)
90 const struct ggc_cache_tab *r = (const struct ggc_cache_tab *) info;
92 if (! (*r->marked_p) (*slot))
93 htab_clear_slot (*r->base, slot);
100 /* Iterate through all registered roots and mark each element. */
103 ggc_mark_roots (void)
105 const struct ggc_root_tab *const *rt;
106 const struct ggc_root_tab *rti;
107 const struct ggc_cache_tab *const *ct;
108 const struct ggc_cache_tab *cti;
111 for (rt = gt_ggc_deletable_rtab; *rt; rt++)
112 for (rti = *rt; rti->base != NULL; rti++)
113 memset (rti->base, 0, rti->stride);
115 for (rt = gt_ggc_rtab; *rt; rt++)
116 for (rti = *rt; rti->base != NULL; rti++)
117 for (i = 0; i < rti->nelt; i++)
118 (*rti->cb)(*(void **)((char *)rti->base + rti->stride * i));
120 ggc_mark_stringpool ();
122 /* Now scan all hash tables that have objects which are to be deleted if
123 they are not already marked. */
124 for (ct = gt_ggc_cache_rtab; *ct; ct++)
125 for (cti = *ct; cti->base != NULL; cti++)
128 ggc_set_mark (*cti->base);
129 htab_traverse_noresize (*cti->base, ggc_htab_delete, (void *) cti);
130 ggc_set_mark ((*cti->base)->entries);
134 /* Allocate a block of memory, then clear it. */
136 ggc_alloc_cleared_stat (size_t size MEM_STAT_DECL)
138 void *buf = ggc_alloc_stat (size PASS_MEM_STAT);
139 memset (buf, 0, size);
143 /* Resize a block of memory, possibly re-allocating it. */
145 ggc_realloc_stat (void *x, size_t size MEM_STAT_DECL)
151 return ggc_alloc_stat (size PASS_MEM_STAT);
153 old_size = ggc_get_size (x);
155 if (size <= old_size)
157 /* Mark the unwanted memory as unaccessible. We also need to make
158 the "new" size accessible, since ggc_get_size returns the size of
159 the pool, not the size of the individually allocated object, the
160 size which was previously made accessible. Unfortunately, we
161 don't know that previously allocated size. Without that
162 knowledge we have to lose some initialization-tracking for the
163 old parts of the object. An alternative is to mark the whole
164 old_size as reachable, but that would lose tracking of writes
165 after the end of the object (by small offsets). Discard the
166 handle to avoid handle leak. */
167 VALGRIND_DISCARD (VALGRIND_MAKE_NOACCESS ((char *) x + size,
169 VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (x, size));
173 r = ggc_alloc_stat (size PASS_MEM_STAT);
175 /* Since ggc_get_size returns the size of the pool, not the size of the
176 individually allocated object, we'd access parts of the old object
177 that were marked invalid with the memcpy below. We lose a bit of the
178 initialization-tracking since some of it may be uninitialized. */
179 VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (x, old_size));
181 memcpy (r, x, old_size);
183 /* The old object is not supposed to be used anymore. */
189 /* Like ggc_alloc_cleared, but performs a multiplication. */
191 ggc_calloc (size_t s1, size_t s2)
193 return ggc_alloc_cleared (s1 * s2);
196 /* These are for splay_tree_new_ggc. */
198 ggc_splay_alloc (int sz, void *nl)
201 return ggc_alloc (sz);
205 ggc_splay_dont_free (void * x ATTRIBUTE_UNUSED, void *nl)
210 /* Print statistics that are independent of the collector in use. */
211 #define SCALE(x) ((unsigned long) ((x) < 1024*10 \
213 : ((x) < 1024*1024*10 \
215 : (x) / (1024*1024))))
216 #define LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M'))
219 ggc_print_common_statistics (FILE *stream ATTRIBUTE_UNUSED,
220 ggc_statistics *stats)
222 /* Set the pointer so that during collection we will actually gather
226 /* Then do one collection to fill in the statistics. */
229 /* At present, we don't really gather any interesting statistics. */
231 /* Don't gather statistics any more. */
235 /* Functions for saving and restoring GCable memory to disk. */
237 static htab_t saving_htab;
242 void *note_ptr_cookie;
243 gt_note_pointers note_ptr_fn;
244 gt_handle_reorder reorder_fn;
247 enum gt_types_enum type;
250 #define POINTER_HASH(x) (hashval_t)((long)x >> 3)
252 /* Register an object in the hash table. */
255 gt_pch_note_object (void *obj, void *note_ptr_cookie,
256 gt_note_pointers note_ptr_fn,
257 enum gt_types_enum type)
259 struct ptr_data **slot;
261 if (obj == NULL || obj == (void *) 1)
264 slot = (struct ptr_data **)
265 htab_find_slot_with_hash (saving_htab, obj, POINTER_HASH (obj),
269 gcc_assert ((*slot)->note_ptr_fn == note_ptr_fn
270 && (*slot)->note_ptr_cookie == note_ptr_cookie);
274 *slot = xcalloc (sizeof (struct ptr_data), 1);
276 (*slot)->note_ptr_fn = note_ptr_fn;
277 (*slot)->note_ptr_cookie = note_ptr_cookie;
278 if (note_ptr_fn == gt_pch_p_S)
279 (*slot)->size = strlen (obj) + 1;
281 (*slot)->size = ggc_get_size (obj);
282 (*slot)->type = type;
286 /* Register an object in the hash table. */
289 gt_pch_note_reorder (void *obj, void *note_ptr_cookie,
290 gt_handle_reorder reorder_fn)
292 struct ptr_data *data;
294 if (obj == NULL || obj == (void *) 1)
297 data = htab_find_with_hash (saving_htab, obj, POINTER_HASH (obj));
298 gcc_assert (data && data->note_ptr_cookie == note_ptr_cookie);
300 data->reorder_fn = reorder_fn;
303 /* Hash and equality functions for saving_htab, callbacks for htab_create. */
306 saving_htab_hash (const void *p)
308 return POINTER_HASH (((struct ptr_data *)p)->obj);
312 saving_htab_eq (const void *p1, const void *p2)
314 return ((struct ptr_data *)p1)->obj == p2;
317 /* Handy state for the traversal functions. */
319 struct traversal_state
322 struct ggc_pch_data *d;
324 struct ptr_data **ptrs;
328 /* Callbacks for htab_traverse. */
331 call_count (void **slot, void *state_p)
333 struct ptr_data *d = (struct ptr_data *)*slot;
334 struct traversal_state *state = (struct traversal_state *)state_p;
336 ggc_pch_count_object (state->d, d->obj, d->size,
337 d->note_ptr_fn == gt_pch_p_S,
344 call_alloc (void **slot, void *state_p)
346 struct ptr_data *d = (struct ptr_data *)*slot;
347 struct traversal_state *state = (struct traversal_state *)state_p;
349 d->new_addr = ggc_pch_alloc_object (state->d, d->obj, d->size,
350 d->note_ptr_fn == gt_pch_p_S,
352 state->ptrs[state->ptrs_i++] = d;
356 /* Callback for qsort. */
359 compare_ptr_data (const void *p1_p, const void *p2_p)
361 struct ptr_data *p1 = *(struct ptr_data *const *)p1_p;
362 struct ptr_data *p2 = *(struct ptr_data *const *)p2_p;
363 return (((size_t)p1->new_addr > (size_t)p2->new_addr)
364 - ((size_t)p1->new_addr < (size_t)p2->new_addr));
367 /* Callbacks for note_ptr_fn. */
370 relocate_ptrs (void *ptr_p, void *state_p)
372 void **ptr = (void **)ptr_p;
373 struct traversal_state *state ATTRIBUTE_UNUSED
374 = (struct traversal_state *)state_p;
375 struct ptr_data *result;
377 if (*ptr == NULL || *ptr == (void *)1)
380 result = htab_find_with_hash (saving_htab, *ptr, POINTER_HASH (*ptr));
382 *ptr = result->new_addr;
385 /* Write out, after relocation, the pointers in TAB. */
387 write_pch_globals (const struct ggc_root_tab * const *tab,
388 struct traversal_state *state)
390 const struct ggc_root_tab *const *rt;
391 const struct ggc_root_tab *rti;
394 for (rt = tab; *rt; rt++)
395 for (rti = *rt; rti->base != NULL; rti++)
396 for (i = 0; i < rti->nelt; i++)
398 void *ptr = *(void **)((char *)rti->base + rti->stride * i);
399 struct ptr_data *new_ptr;
400 if (ptr == NULL || ptr == (void *)1)
402 if (fwrite (&ptr, sizeof (void *), 1, state->f)
404 fatal_error ("can't write PCH file: %m");
408 new_ptr = htab_find_with_hash (saving_htab, ptr,
410 if (fwrite (&new_ptr->new_addr, sizeof (void *), 1, state->f)
412 fatal_error ("can't write PCH file: %m");
417 /* Hold the information we need to mmap the file back in. */
423 void *preferred_base;
426 /* Write out the state of the compiler to F. */
429 gt_pch_save (FILE *f)
431 const struct ggc_root_tab *const *rt;
432 const struct ggc_root_tab *rti;
434 struct traversal_state state;
435 char *this_object = NULL;
436 size_t this_object_size = 0;
437 struct mmap_info mmi;
438 const size_t mmap_offset_alignment = host_hooks.gt_pch_alloc_granularity();
440 gt_pch_save_stringpool ();
442 saving_htab = htab_create (50000, saving_htab_hash, saving_htab_eq, free);
444 for (rt = gt_ggc_rtab; *rt; rt++)
445 for (rti = *rt; rti->base != NULL; rti++)
446 for (i = 0; i < rti->nelt; i++)
447 (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
449 for (rt = gt_pch_cache_rtab; *rt; rt++)
450 for (rti = *rt; rti->base != NULL; rti++)
451 for (i = 0; i < rti->nelt; i++)
452 (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
454 /* Prepare the objects for writing, determine addresses and such. */
456 state.d = init_ggc_pch();
458 htab_traverse (saving_htab, call_count, &state);
460 mmi.size = ggc_pch_total_size (state.d);
462 /* Try to arrange things so that no relocation is necessary, but
463 don't try very hard. On most platforms, this will always work,
464 and on the rest it's a lot of work to do better.
465 (The extra work goes in HOST_HOOKS_GT_PCH_GET_ADDRESS and
466 HOST_HOOKS_GT_PCH_USE_ADDRESS.) */
467 mmi.preferred_base = host_hooks.gt_pch_get_address (mmi.size, fileno (f));
469 ggc_pch_this_base (state.d, mmi.preferred_base);
471 state.ptrs = XNEWVEC (struct ptr_data *, state.count);
473 htab_traverse (saving_htab, call_alloc, &state);
474 qsort (state.ptrs, state.count, sizeof (*state.ptrs), compare_ptr_data);
476 /* Write out all the scalar variables. */
477 for (rt = gt_pch_scalar_rtab; *rt; rt++)
478 for (rti = *rt; rti->base != NULL; rti++)
479 if (fwrite (rti->base, rti->stride, 1, f) != 1)
480 fatal_error ("can't write PCH file: %m");
482 /* Write out all the global pointers, after translation. */
483 write_pch_globals (gt_ggc_rtab, &state);
484 write_pch_globals (gt_pch_cache_rtab, &state);
486 /* Pad the PCH file so that the mmapped area starts on an allocation
487 granularity (usually page) boundary. */
490 o = ftell (state.f) + sizeof (mmi);
492 fatal_error ("can't get position in PCH file: %m");
493 mmi.offset = mmap_offset_alignment - o % mmap_offset_alignment;
494 if (mmi.offset == mmap_offset_alignment)
498 if (fwrite (&mmi, sizeof (mmi), 1, state.f) != 1)
499 fatal_error ("can't write PCH file: %m");
501 && fseek (state.f, mmi.offset, SEEK_SET) != 0)
502 fatal_error ("can't write padding to PCH file: %m");
504 ggc_pch_prepare_write (state.d, state.f);
506 /* Actually write out the objects. */
507 for (i = 0; i < state.count; i++)
509 if (this_object_size < state.ptrs[i]->size)
511 this_object_size = state.ptrs[i]->size;
512 this_object = xrealloc (this_object, this_object_size);
514 memcpy (this_object, state.ptrs[i]->obj, state.ptrs[i]->size);
515 if (state.ptrs[i]->reorder_fn != NULL)
516 state.ptrs[i]->reorder_fn (state.ptrs[i]->obj,
517 state.ptrs[i]->note_ptr_cookie,
518 relocate_ptrs, &state);
519 state.ptrs[i]->note_ptr_fn (state.ptrs[i]->obj,
520 state.ptrs[i]->note_ptr_cookie,
521 relocate_ptrs, &state);
522 ggc_pch_write_object (state.d, state.f, state.ptrs[i]->obj,
523 state.ptrs[i]->new_addr, state.ptrs[i]->size,
524 state.ptrs[i]->note_ptr_fn == gt_pch_p_S);
525 if (state.ptrs[i]->note_ptr_fn != gt_pch_p_S)
526 memcpy (state.ptrs[i]->obj, this_object, state.ptrs[i]->size);
528 ggc_pch_finish (state.d, state.f);
529 gt_pch_fixup_stringpool ();
532 htab_delete (saving_htab);
535 /* Read the state of the compiler back in from F. */
538 gt_pch_restore (FILE *f)
540 const struct ggc_root_tab *const *rt;
541 const struct ggc_root_tab *rti;
543 struct mmap_info mmi;
546 /* Delete any deletable objects. This makes ggc_pch_read much
547 faster, as it can be sure that no GCable objects remain other
548 than the ones just read in. */
549 for (rt = gt_ggc_deletable_rtab; *rt; rt++)
550 for (rti = *rt; rti->base != NULL; rti++)
551 memset (rti->base, 0, rti->stride);
553 /* Read in all the scalar variables. */
554 for (rt = gt_pch_scalar_rtab; *rt; rt++)
555 for (rti = *rt; rti->base != NULL; rti++)
556 if (fread (rti->base, rti->stride, 1, f) != 1)
557 fatal_error ("can't read PCH file: %m");
559 /* Read in all the global pointers, in 6 easy loops. */
560 for (rt = gt_ggc_rtab; *rt; rt++)
561 for (rti = *rt; rti->base != NULL; rti++)
562 for (i = 0; i < rti->nelt; i++)
563 if (fread ((char *)rti->base + rti->stride * i,
564 sizeof (void *), 1, f) != 1)
565 fatal_error ("can't read PCH file: %m");
567 for (rt = gt_pch_cache_rtab; *rt; rt++)
568 for (rti = *rt; rti->base != NULL; rti++)
569 for (i = 0; i < rti->nelt; i++)
570 if (fread ((char *)rti->base + rti->stride * i,
571 sizeof (void *), 1, f) != 1)
572 fatal_error ("can't read PCH file: %m");
574 if (fread (&mmi, sizeof (mmi), 1, f) != 1)
575 fatal_error ("can't read PCH file: %m");
577 result = host_hooks.gt_pch_use_address (mmi.preferred_base, mmi.size,
578 fileno (f), mmi.offset);
580 fatal_error ("had to relocate PCH");
583 if (fseek (f, mmi.offset, SEEK_SET) != 0
584 || fread (mmi.preferred_base, mmi.size, 1, f) != 1)
585 fatal_error ("can't read PCH file: %m");
587 else if (fseek (f, mmi.offset + mmi.size, SEEK_SET) != 0)
588 fatal_error ("can't read PCH file: %m");
590 ggc_pch_read (f, mmi.preferred_base);
592 gt_pch_restore_stringpool ();
595 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is not present.
596 Select no address whatsoever, and let gt_pch_save choose what it will with
597 malloc, presumably. */
600 default_gt_pch_get_address (size_t size ATTRIBUTE_UNUSED,
601 int fd ATTRIBUTE_UNUSED)
606 /* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is not present.
607 Allocate SIZE bytes with malloc. Return 0 if the address we got is the
608 same as base, indicating that the memory has been allocated but needs to
609 be read in from the file. Return -1 if the address differs, to relocation
610 of the PCH file would be required. */
613 default_gt_pch_use_address (void *base, size_t size, int fd ATTRIBUTE_UNUSED,
614 size_t offset ATTRIBUTE_UNUSED)
616 void *addr = xmalloc (size);
617 return (addr == base) - 1;
620 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS. Return the
621 alignment required for allocating virtual memory. Usually this is the
625 default_gt_pch_alloc_granularity (void)
627 return getpagesize();
631 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is present.
632 We temporarily allocate SIZE bytes, and let the kernel place the data
633 wherever it will. If it worked, that's our spot, if not we're likely
637 mmap_gt_pch_get_address (size_t size, int fd)
641 ret = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
642 if (ret == (void *) MAP_FAILED)
650 /* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is present.
651 Map SIZE bytes of FD+OFFSET at BASE. Return 1 if we succeeded at
652 mapping the data at BASE, -1 if we couldn't.
654 This version assumes that the kernel honors the START operand of mmap
655 even without MAP_FIXED if START through START+SIZE are not currently
656 mapped with something. */
659 mmap_gt_pch_use_address (void *base, size_t size, int fd, size_t offset)
663 /* We're called with size == 0 if we're not planning to load a PCH
664 file at all. This allows the hook to free any static space that
665 we might have allocated at link time. */
669 addr = mmap (base, size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
672 return addr == base ? 1 : -1;
674 #endif /* HAVE_MMAP_FILE */
676 /* Modify the bound based on rlimits. */
678 ggc_rlimit_bound (double limit)
680 #if defined(HAVE_GETRLIMIT)
682 # if defined (RLIMIT_AS)
683 /* RLIMIT_AS is what POSIX says is the limit on mmap. Presumably
684 any OS which has RLIMIT_AS also has a working mmap that GCC will use. */
685 if (getrlimit (RLIMIT_AS, &rlim) == 0
686 && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
687 && rlim.rlim_cur < limit)
688 limit = rlim.rlim_cur;
689 # elif defined (RLIMIT_DATA)
690 /* ... but some older OSs bound mmap based on RLIMIT_DATA, or we
691 might be on an OS that has a broken mmap. (Others don't bound
692 mmap at all, apparently.) */
693 if (getrlimit (RLIMIT_DATA, &rlim) == 0
694 && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
695 && rlim.rlim_cur < limit
696 /* Darwin has this horribly bogus default setting of
697 RLIMIT_DATA, to 6144Kb. No-one notices because RLIMIT_DATA
698 appears to be ignored. Ignore such silliness. If a limit
699 this small was actually effective for mmap, GCC wouldn't even
701 && rlim.rlim_cur >= 8 * 1024 * 1024)
702 limit = rlim.rlim_cur;
703 # endif /* RLIMIT_AS or RLIMIT_DATA */
704 #endif /* HAVE_GETRLIMIT */
709 /* Heuristic to set a default for GGC_MIN_EXPAND. */
711 ggc_min_expand_heuristic (void)
713 double min_expand = physmem_total();
715 /* Adjust for rlimits. */
716 min_expand = ggc_rlimit_bound (min_expand);
718 /* The heuristic is a percentage equal to 30% + 70%*(RAM/1GB), yielding
719 APPLE LOCAL retune gc params 6124839
720 a lower bound of 30% and an upper bound of 150% (when RAM >= 1.7GB). */
721 min_expand /= 1024*1024*1024;
723 /* APPLE LOCAL retune gc params 6124839 */
724 min_expand = MIN (min_expand, 120);
730 /* Heuristic to set a default for GGC_MIN_HEAPSIZE. */
732 /* APPLE LOCAL retune gc params 6124839 */
733 ggc_min_heapsize_heuristic (bool optimize)
735 double phys_kbytes = physmem_total();
736 double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2);
738 phys_kbytes /= 1024; /* Convert to Kbytes. */
739 limit_kbytes /= 1024;
741 /* The heuristic is RAM/8, with a lower bound of 4M and an upper
742 bound of 128M (when RAM >= 1GB). */
745 /* APPLE LOCAL begin retune gc params 6124839 */
747 /* Additionally, on a multicore machine, we assume that we share the
748 memory with others reasonably equally. */
749 phys_kbytes /= (double)ncpu_available() / (2 - optimize);
750 /* APPLE LOCAL end retune gc params 6124839 */
752 #if defined(HAVE_GETRLIMIT) && defined (RLIMIT_RSS)
753 /* Try not to overrun the RSS limit while doing garbage collection.
754 The RSS limit is only advisory, so no margin is subtracted. */
757 if (getrlimit (RLIMIT_RSS, &rlim) == 0
758 && rlim.rlim_cur != (rlim_t) RLIM_INFINITY)
759 phys_kbytes = MIN (phys_kbytes, rlim.rlim_cur / 1024);
763 /* Don't blindly run over our data limit; do GC at least when the
764 *next* GC would be within 16Mb of the limit. If GCC does hit the
765 data limit, compilation will fail, so this tries to be
767 limit_kbytes = MAX (0, limit_kbytes - 16 * 1024);
768 limit_kbytes = (limit_kbytes * 100) / (110 + ggc_min_expand_heuristic());
769 phys_kbytes = MIN (phys_kbytes, limit_kbytes);
771 phys_kbytes = MAX (phys_kbytes, 4 * 1024);
772 phys_kbytes = MIN (phys_kbytes, 128 * 1024);
778 /* APPLE LOCAL retune gc params 6124839 */
779 init_ggc_heuristics (bool optimize ATTRIBUTE_UNUSED)
781 #if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT
782 set_param_value ("ggc-min-expand", ggc_min_expand_heuristic());
783 /* APPLE LOCAL retune gc params 6124839 */
784 set_param_value ("ggc-min-heapsize", ggc_min_heapsize_heuristic(optimize));
788 #ifdef GATHER_STATISTICS
790 /* Datastructure used to store per-call-site statistics. */
791 struct loc_descriptor
795 const char *function;
803 /* Hashtable used for statistics. */
804 static htab_t loc_hash;
806 /* Hash table helpers functions. */
808 hash_descriptor (const void *p)
810 const struct loc_descriptor *d = p;
812 return htab_hash_pointer (d->function) | d->line;
816 eq_descriptor (const void *p1, const void *p2)
818 const struct loc_descriptor *d = p1;
819 const struct loc_descriptor *d2 = p2;
821 return (d->file == d2->file && d->line == d2->line
822 && d->function == d2->function);
825 /* Hashtable converting address of allocated field to loc descriptor. */
826 static htab_t ptr_hash;
827 struct ptr_hash_entry
830 struct loc_descriptor *loc;
834 /* Hash table helpers functions. */
836 hash_ptr (const void *p)
838 const struct ptr_hash_entry *d = p;
840 return htab_hash_pointer (d->ptr);
844 eq_ptr (const void *p1, const void *p2)
846 const struct ptr_hash_entry *p = p1;
848 return (p->ptr == p2);
851 /* Return descriptor for given call site, create new one if needed. */
852 static struct loc_descriptor *
853 loc_descriptor (const char *name, int line, const char *function)
855 struct loc_descriptor loc;
856 struct loc_descriptor **slot;
860 loc.function = function;
862 loc_hash = htab_create (10, hash_descriptor, eq_descriptor, NULL);
864 slot = (struct loc_descriptor **) htab_find_slot (loc_hash, &loc, 1);
867 *slot = xcalloc (sizeof (**slot), 1);
868 (*slot)->file = name;
869 (*slot)->line = line;
870 (*slot)->function = function;
874 /* Record ALLOCATED and OVERHEAD bytes to descriptor NAME:LINE (FUNCTION). */
876 ggc_record_overhead (size_t allocated, size_t overhead, void *ptr,
877 const char *name, int line, const char *function)
879 struct loc_descriptor *loc = loc_descriptor (name, line, function);
880 struct ptr_hash_entry *p = XNEW (struct ptr_hash_entry);
885 p->size = allocated + overhead;
887 ptr_hash = htab_create (10, hash_ptr, eq_ptr, NULL);
888 slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr), INSERT);
893 loc->allocated+=allocated;
894 loc->overhead+=overhead;
897 /* Helper function for prune_overhead_list. See if SLOT is still marked and
898 remove it from hashtable if it is not. */
900 ggc_prune_ptr (void **slot, void *b ATTRIBUTE_UNUSED)
902 struct ptr_hash_entry *p = *slot;
903 if (!ggc_marked_p (p->ptr))
905 p->loc->collected += p->size;
906 htab_clear_slot (ptr_hash, slot);
912 /* After live values has been marked, walk all recorded pointers and see if
913 they are still live. */
915 ggc_prune_overhead_list (void)
917 htab_traverse (ptr_hash, ggc_prune_ptr, NULL);
920 /* Notice that the pointer has been freed. */
922 ggc_free_overhead (void *ptr)
924 PTR *slot = htab_find_slot_with_hash (ptr_hash, ptr, htab_hash_pointer (ptr),
926 struct ptr_hash_entry *p = *slot;
927 p->loc->freed += p->size;
928 htab_clear_slot (ptr_hash, slot);
932 /* Helper for qsort; sort descriptors by amount of memory consumed. */
934 cmp_statistic (const void *loc1, const void *loc2)
936 struct loc_descriptor *l1 = *(struct loc_descriptor **) loc1;
937 struct loc_descriptor *l2 = *(struct loc_descriptor **) loc2;
938 return ((l1->allocated + l1->overhead - l1->freed) -
939 (l2->allocated + l2->overhead - l2->freed));
942 /* Collect array of the descriptors from hashtable. */
943 struct loc_descriptor **loc_array;
945 add_statistics (void **slot, void *b)
948 loc_array[*n] = (struct loc_descriptor *) *slot;
953 /* Dump per-site memory statistics. */
956 dump_ggc_loc_statistics (void)
958 #ifdef GATHER_STATISTICS
961 size_t collected = 0, freed = 0, allocated = 0, overhead = 0, times = 0;
964 ggc_force_collect = true;
967 loc_array = xcalloc (sizeof (*loc_array), loc_hash->n_elements);
968 fprintf (stderr, "-------------------------------------------------------\n");
969 fprintf (stderr, "\n%-48s %10s %10s %10s %10s %10s\n",
970 "source location", "Garbage", "Freed", "Leak", "Overhead", "Times");
971 fprintf (stderr, "-------------------------------------------------------\n");
972 htab_traverse (loc_hash, add_statistics, &nentries);
973 qsort (loc_array, nentries, sizeof (*loc_array), cmp_statistic);
974 for (i = 0; i < nentries; i++)
976 struct loc_descriptor *d = loc_array[i];
977 allocated += d->allocated;
980 collected += d->collected;
981 overhead += d->overhead;
983 for (i = 0; i < nentries; i++)
985 struct loc_descriptor *d = loc_array[i];
988 const char *s1 = d->file;
990 while ((s2 = strstr (s1, "gcc/")))
992 sprintf (s, "%s:%i (%s)", s1, d->line, d->function);
994 fprintf (stderr, "%-48s %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li:%4.1f%% %10li\n", s,
996 (d->collected) * 100.0 / collected,
998 (d->freed) * 100.0 / freed,
999 (long)(d->allocated + d->overhead - d->freed - d->collected),
1000 (d->allocated + d->overhead - d->freed - d->collected) * 100.0
1001 / (allocated + overhead - freed - collected),
1003 d->overhead * 100.0 / overhead,
1007 fprintf (stderr, "%-48s %10ld %10ld %10ld %10ld %10ld\n",
1008 "Total", (long)collected, (long)freed,
1009 (long)(allocated + overhead - freed - collected), (long)overhead,
1011 fprintf (stderr, "%-48s %10s %10s %10s %10s %10s\n",
1012 "source location", "Garbage", "Freed", "Leak", "Overhead", "Times");
1013 fprintf (stderr, "-------------------------------------------------------\n");