sourcebuild.texi: Add libcpp, now that CPP has its own directory.
[official-gcc.git] / gcc / ggc-common.c
blobcc0dc93be84177b531ffa64699980d571f83a927
1 /* Simple garbage collection for the GNU compiler.
2 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004
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
10 version.
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
15 for more details.
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, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
22 /* Generic garbage collection (GC) functions and data, not specific to
23 any particular GC implementation. */
25 #include "config.h"
26 #include "system.h"
27 #include "coretypes.h"
28 #include "hashtab.h"
29 #include "ggc.h"
30 #include "toplev.h"
31 #include "params.h"
32 #include "hosthooks.h"
33 #include "hosthooks-def.h"
35 #ifdef HAVE_SYS_RESOURCE_H
36 # include <sys/resource.h>
37 #endif
39 #ifdef HAVE_MMAP_FILE
40 # include <sys/mman.h>
41 # ifdef HAVE_MINCORE
42 /* This is on Solaris. */
43 # include <sys/types.h>
44 # endif
45 #endif
47 #ifndef MAP_FAILED
48 # define MAP_FAILED ((void *)-1)
49 #endif
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>
56 # else
57 # include <valgrind.h>
58 # endif
59 #else
60 /* Avoid #ifdef:s when we can help it. */
61 #define VALGRIND_DISCARD(x)
62 #endif
64 /* Statistics about the allocation. */
65 static ggc_statistics *ggc_stats;
67 struct traversal_state;
69 static int ggc_htab_delete (void **, void *);
70 static hashval_t saving_htab_hash (const void *);
71 static int saving_htab_eq (const void *, const void *);
72 static int call_count (void **, void *);
73 static int call_alloc (void **, void *);
74 static int compare_ptr_data (const void *, const void *);
75 static void relocate_ptrs (void *, void *);
76 static void write_pch_globals (const struct ggc_root_tab * const *tab,
77 struct traversal_state *state);
78 static double ggc_rlimit_bound (double);
80 /* Maintain global roots that are preserved during GC. */
82 /* Process a slot of an htab by deleting it if it has not been marked. */
84 static int
85 ggc_htab_delete (void **slot, void *info)
87 const struct ggc_cache_tab *r = (const struct ggc_cache_tab *) info;
89 if (! (*r->marked_p) (*slot))
90 htab_clear_slot (*r->base, slot);
91 else
92 (*r->cb) (*slot);
94 return 1;
97 /* Iterate through all registered roots and mark each element. */
99 void
100 ggc_mark_roots (void)
102 const struct ggc_root_tab *const *rt;
103 const struct ggc_root_tab *rti;
104 const struct ggc_cache_tab *const *ct;
105 const struct ggc_cache_tab *cti;
106 size_t i;
108 for (rt = gt_ggc_deletable_rtab; *rt; rt++)
109 for (rti = *rt; rti->base != NULL; rti++)
110 memset (rti->base, 0, rti->stride);
112 for (rt = gt_ggc_rtab; *rt; rt++)
113 for (rti = *rt; rti->base != NULL; rti++)
114 for (i = 0; i < rti->nelt; i++)
115 (*rti->cb)(*(void **)((char *)rti->base + rti->stride * i));
117 ggc_mark_stringpool ();
119 /* Now scan all hash tables that have objects which are to be deleted if
120 they are not already marked. */
121 for (ct = gt_ggc_cache_rtab; *ct; ct++)
122 for (cti = *ct; cti->base != NULL; cti++)
123 if (*cti->base)
125 ggc_set_mark (*cti->base);
126 htab_traverse_noresize (*cti->base, ggc_htab_delete, (void *) cti);
127 ggc_set_mark ((*cti->base)->entries);
131 /* Allocate a block of memory, then clear it. */
132 void *
133 ggc_alloc_cleared_stat (size_t size MEM_STAT_DECL)
135 void *buf = ggc_alloc_stat (size PASS_MEM_STAT);
136 memset (buf, 0, size);
137 return buf;
140 /* Resize a block of memory, possibly re-allocating it. */
141 void *
142 ggc_realloc_stat (void *x, size_t size MEM_STAT_DECL)
144 void *r;
145 size_t old_size;
147 if (x == NULL)
148 return ggc_alloc_stat (size PASS_MEM_STAT);
150 old_size = ggc_get_size (x);
152 if (size <= old_size)
154 /* Mark the unwanted memory as unaccessible. We also need to make
155 the "new" size accessible, since ggc_get_size returns the size of
156 the pool, not the size of the individually allocated object, the
157 size which was previously made accessible. Unfortunately, we
158 don't know that previously allocated size. Without that
159 knowledge we have to lose some initialization-tracking for the
160 old parts of the object. An alternative is to mark the whole
161 old_size as reachable, but that would lose tracking of writes
162 after the end of the object (by small offsets). Discard the
163 handle to avoid handle leak. */
164 VALGRIND_DISCARD (VALGRIND_MAKE_NOACCESS ((char *) x + size,
165 old_size - size));
166 VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (x, size));
167 return x;
170 r = ggc_alloc_stat (size PASS_MEM_STAT);
172 /* Since ggc_get_size returns the size of the pool, not the size of the
173 individually allocated object, we'd access parts of the old object
174 that were marked invalid with the memcpy below. We lose a bit of the
175 initialization-tracking since some of it may be uninitialized. */
176 VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (x, old_size));
178 memcpy (r, x, old_size);
180 /* The old object is not supposed to be used anymore. */
181 ggc_free (x);
183 return r;
186 /* Like ggc_alloc_cleared, but performs a multiplication. */
187 void *
188 ggc_calloc (size_t s1, size_t s2)
190 return ggc_alloc_cleared (s1 * s2);
193 /* These are for splay_tree_new_ggc. */
194 void *
195 ggc_splay_alloc (int sz, void *nl)
197 if (nl != NULL)
198 abort ();
199 return ggc_alloc (sz);
202 void
203 ggc_splay_dont_free (void * x ATTRIBUTE_UNUSED, void *nl)
205 if (nl != NULL)
206 abort ();
209 /* Print statistics that are independent of the collector in use. */
210 #define SCALE(x) ((unsigned long) ((x) < 1024*10 \
211 ? (x) \
212 : ((x) < 1024*1024*10 \
213 ? (x) / 1024 \
214 : (x) / (1024*1024))))
215 #define LABEL(x) ((x) < 1024*10 ? ' ' : ((x) < 1024*1024*10 ? 'k' : 'M'))
217 void
218 ggc_print_common_statistics (FILE *stream ATTRIBUTE_UNUSED,
219 ggc_statistics *stats)
221 /* Set the pointer so that during collection we will actually gather
222 the statistics. */
223 ggc_stats = stats;
225 /* Then do one collection to fill in the statistics. */
226 ggc_collect ();
228 /* At present, we don't really gather any interesting statistics. */
230 /* Don't gather statistics any more. */
231 ggc_stats = NULL;
234 /* Functions for saving and restoring GCable memory to disk. */
236 static htab_t saving_htab;
238 struct ptr_data
240 void *obj;
241 void *note_ptr_cookie;
242 gt_note_pointers note_ptr_fn;
243 gt_handle_reorder reorder_fn;
244 size_t size;
245 void *new_addr;
248 #define POINTER_HASH(x) (hashval_t)((long)x >> 3)
250 /* Register an object in the hash table. */
253 gt_pch_note_object (void *obj, void *note_ptr_cookie,
254 gt_note_pointers note_ptr_fn)
256 struct ptr_data **slot;
258 if (obj == NULL || obj == (void *) 1)
259 return 0;
261 slot = (struct ptr_data **)
262 htab_find_slot_with_hash (saving_htab, obj, POINTER_HASH (obj),
263 INSERT);
264 if (*slot != NULL)
266 if ((*slot)->note_ptr_fn != note_ptr_fn
267 || (*slot)->note_ptr_cookie != note_ptr_cookie)
268 abort ();
269 return 0;
272 *slot = xcalloc (sizeof (struct ptr_data), 1);
273 (*slot)->obj = obj;
274 (*slot)->note_ptr_fn = note_ptr_fn;
275 (*slot)->note_ptr_cookie = note_ptr_cookie;
276 if (note_ptr_fn == gt_pch_p_S)
277 (*slot)->size = strlen (obj) + 1;
278 else
279 (*slot)->size = ggc_get_size (obj);
280 return 1;
283 /* Register an object in the hash table. */
285 void
286 gt_pch_note_reorder (void *obj, void *note_ptr_cookie,
287 gt_handle_reorder reorder_fn)
289 struct ptr_data *data;
291 if (obj == NULL || obj == (void *) 1)
292 return;
294 data = htab_find_with_hash (saving_htab, obj, POINTER_HASH (obj));
295 if (data == NULL
296 || data->note_ptr_cookie != note_ptr_cookie)
297 abort ();
299 data->reorder_fn = reorder_fn;
302 /* Hash and equality functions for saving_htab, callbacks for htab_create. */
304 static hashval_t
305 saving_htab_hash (const void *p)
307 return POINTER_HASH (((struct ptr_data *)p)->obj);
310 static int
311 saving_htab_eq (const void *p1, const void *p2)
313 return ((struct ptr_data *)p1)->obj == p2;
316 /* Handy state for the traversal functions. */
318 struct traversal_state
320 FILE *f;
321 struct ggc_pch_data *d;
322 size_t count;
323 struct ptr_data **ptrs;
324 size_t ptrs_i;
327 /* Callbacks for htab_traverse. */
329 static int
330 call_count (void **slot, void *state_p)
332 struct ptr_data *d = (struct ptr_data *)*slot;
333 struct traversal_state *state = (struct traversal_state *)state_p;
335 ggc_pch_count_object (state->d, d->obj, d->size, d->note_ptr_fn == gt_pch_p_S);
336 state->count++;
337 return 1;
340 static int
341 call_alloc (void **slot, void *state_p)
343 struct ptr_data *d = (struct ptr_data *)*slot;
344 struct traversal_state *state = (struct traversal_state *)state_p;
346 d->new_addr = ggc_pch_alloc_object (state->d, d->obj, d->size, d->note_ptr_fn == gt_pch_p_S);
347 state->ptrs[state->ptrs_i++] = d;
348 return 1;
351 /* Callback for qsort. */
353 static int
354 compare_ptr_data (const void *p1_p, const void *p2_p)
356 struct ptr_data *p1 = *(struct ptr_data *const *)p1_p;
357 struct ptr_data *p2 = *(struct ptr_data *const *)p2_p;
358 return (((size_t)p1->new_addr > (size_t)p2->new_addr)
359 - ((size_t)p1->new_addr < (size_t)p2->new_addr));
362 /* Callbacks for note_ptr_fn. */
364 static void
365 relocate_ptrs (void *ptr_p, void *state_p)
367 void **ptr = (void **)ptr_p;
368 struct traversal_state *state ATTRIBUTE_UNUSED
369 = (struct traversal_state *)state_p;
370 struct ptr_data *result;
372 if (*ptr == NULL || *ptr == (void *)1)
373 return;
375 result = htab_find_with_hash (saving_htab, *ptr, POINTER_HASH (*ptr));
376 if (result == NULL)
377 abort ();
378 *ptr = result->new_addr;
381 /* Write out, after relocation, the pointers in TAB. */
382 static void
383 write_pch_globals (const struct ggc_root_tab * const *tab,
384 struct traversal_state *state)
386 const struct ggc_root_tab *const *rt;
387 const struct ggc_root_tab *rti;
388 size_t i;
390 for (rt = tab; *rt; rt++)
391 for (rti = *rt; rti->base != NULL; rti++)
392 for (i = 0; i < rti->nelt; i++)
394 void *ptr = *(void **)((char *)rti->base + rti->stride * i);
395 struct ptr_data *new_ptr;
396 if (ptr == NULL || ptr == (void *)1)
398 if (fwrite (&ptr, sizeof (void *), 1, state->f)
399 != 1)
400 fatal_error ("can't write PCH file: %m");
402 else
404 new_ptr = htab_find_with_hash (saving_htab, ptr,
405 POINTER_HASH (ptr));
406 if (fwrite (&new_ptr->new_addr, sizeof (void *), 1, state->f)
407 != 1)
408 fatal_error ("can't write PCH file: %m");
413 /* Hold the information we need to mmap the file back in. */
415 struct mmap_info
417 size_t offset;
418 size_t size;
419 void *preferred_base;
422 /* Write out the state of the compiler to F. */
424 void
425 gt_pch_save (FILE *f)
427 const struct ggc_root_tab *const *rt;
428 const struct ggc_root_tab *rti;
429 size_t i;
430 struct traversal_state state;
431 char *this_object = NULL;
432 size_t this_object_size = 0;
433 struct mmap_info mmi;
434 const size_t mmap_offset_alignment = host_hooks.gt_pch_alloc_granularity();
436 gt_pch_save_stringpool ();
438 saving_htab = htab_create (50000, saving_htab_hash, saving_htab_eq, free);
440 for (rt = gt_ggc_rtab; *rt; rt++)
441 for (rti = *rt; rti->base != NULL; rti++)
442 for (i = 0; i < rti->nelt; i++)
443 (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
445 for (rt = gt_pch_cache_rtab; *rt; rt++)
446 for (rti = *rt; rti->base != NULL; rti++)
447 for (i = 0; i < rti->nelt; i++)
448 (*rti->pchw)(*(void **)((char *)rti->base + rti->stride * i));
450 /* Prepare the objects for writing, determine addresses and such. */
451 state.f = f;
452 state.d = init_ggc_pch();
453 state.count = 0;
454 htab_traverse (saving_htab, call_count, &state);
456 mmi.size = ggc_pch_total_size (state.d);
458 /* Try to arrange things so that no relocation is necessary, but
459 don't try very hard. On most platforms, this will always work,
460 and on the rest it's a lot of work to do better.
461 (The extra work goes in HOST_HOOKS_GT_PCH_GET_ADDRESS and
462 HOST_HOOKS_GT_PCH_USE_ADDRESS.) */
463 mmi.preferred_base = host_hooks.gt_pch_get_address (mmi.size, fileno (f));
465 ggc_pch_this_base (state.d, mmi.preferred_base);
467 state.ptrs = xmalloc (state.count * sizeof (*state.ptrs));
468 state.ptrs_i = 0;
469 htab_traverse (saving_htab, call_alloc, &state);
470 qsort (state.ptrs, state.count, sizeof (*state.ptrs), compare_ptr_data);
472 /* Write out all the scalar variables. */
473 for (rt = gt_pch_scalar_rtab; *rt; rt++)
474 for (rti = *rt; rti->base != NULL; rti++)
475 if (fwrite (rti->base, rti->stride, 1, f) != 1)
476 fatal_error ("can't write PCH file: %m");
478 /* Write out all the global pointers, after translation. */
479 write_pch_globals (gt_ggc_rtab, &state);
480 write_pch_globals (gt_pch_cache_rtab, &state);
482 ggc_pch_prepare_write (state.d, state.f);
484 /* Pad the PCH file so that the mmapped area starts on an allocation
485 granularity (usually page) boundary. */
487 long o;
488 o = ftell (state.f) + sizeof (mmi);
489 if (o == -1)
490 fatal_error ("can't get position in PCH file: %m");
491 mmi.offset = mmap_offset_alignment - o % mmap_offset_alignment;
492 if (mmi.offset == mmap_offset_alignment)
493 mmi.offset = 0;
494 mmi.offset += o;
496 if (fwrite (&mmi, sizeof (mmi), 1, state.f) != 1)
497 fatal_error ("can't write PCH file: %m");
498 if (mmi.offset != 0
499 && fseek (state.f, mmi.offset, SEEK_SET) != 0)
500 fatal_error ("can't write padding to PCH file: %m");
502 /* Actually write out the objects. */
503 for (i = 0; i < state.count; i++)
505 if (this_object_size < state.ptrs[i]->size)
507 this_object_size = state.ptrs[i]->size;
508 this_object = xrealloc (this_object, this_object_size);
510 memcpy (this_object, state.ptrs[i]->obj, state.ptrs[i]->size);
511 if (state.ptrs[i]->reorder_fn != NULL)
512 state.ptrs[i]->reorder_fn (state.ptrs[i]->obj,
513 state.ptrs[i]->note_ptr_cookie,
514 relocate_ptrs, &state);
515 state.ptrs[i]->note_ptr_fn (state.ptrs[i]->obj,
516 state.ptrs[i]->note_ptr_cookie,
517 relocate_ptrs, &state);
518 ggc_pch_write_object (state.d, state.f, state.ptrs[i]->obj,
519 state.ptrs[i]->new_addr, state.ptrs[i]->size,
520 state.ptrs[i]->note_ptr_fn == gt_pch_p_S);
521 if (state.ptrs[i]->note_ptr_fn != gt_pch_p_S)
522 memcpy (state.ptrs[i]->obj, this_object, state.ptrs[i]->size);
524 ggc_pch_finish (state.d, state.f);
525 gt_pch_fixup_stringpool ();
527 free (state.ptrs);
528 htab_delete (saving_htab);
531 /* Read the state of the compiler back in from F. */
533 void
534 gt_pch_restore (FILE *f)
536 const struct ggc_root_tab *const *rt;
537 const struct ggc_root_tab *rti;
538 size_t i;
539 struct mmap_info mmi;
540 int result;
542 /* Delete any deletable objects. This makes ggc_pch_read much
543 faster, as it can be sure that no GCable objects remain other
544 than the ones just read in. */
545 for (rt = gt_ggc_deletable_rtab; *rt; rt++)
546 for (rti = *rt; rti->base != NULL; rti++)
547 memset (rti->base, 0, rti->stride);
549 /* Read in all the scalar variables. */
550 for (rt = gt_pch_scalar_rtab; *rt; rt++)
551 for (rti = *rt; rti->base != NULL; rti++)
552 if (fread (rti->base, rti->stride, 1, f) != 1)
553 fatal_error ("can't read PCH file: %m");
555 /* Read in all the global pointers, in 6 easy loops. */
556 for (rt = gt_ggc_rtab; *rt; rt++)
557 for (rti = *rt; rti->base != NULL; rti++)
558 for (i = 0; i < rti->nelt; i++)
559 if (fread ((char *)rti->base + rti->stride * i,
560 sizeof (void *), 1, f) != 1)
561 fatal_error ("can't read PCH file: %m");
563 for (rt = gt_pch_cache_rtab; *rt; rt++)
564 for (rti = *rt; rti->base != NULL; rti++)
565 for (i = 0; i < rti->nelt; i++)
566 if (fread ((char *)rti->base + rti->stride * i,
567 sizeof (void *), 1, f) != 1)
568 fatal_error ("can't read PCH file: %m");
570 if (fread (&mmi, sizeof (mmi), 1, f) != 1)
571 fatal_error ("can't read PCH file: %m");
573 result = host_hooks.gt_pch_use_address (mmi.preferred_base, mmi.size,
574 fileno (f), mmi.offset);
575 if (result < 0)
576 fatal_error ("had to relocate PCH");
577 if (result == 0)
579 if (fseek (f, mmi.offset, SEEK_SET) != 0
580 || fread (mmi.preferred_base, mmi.size, 1, f) != 1)
581 fatal_error ("can't read PCH file: %m");
583 else if (fseek (f, mmi.offset + mmi.size, SEEK_SET) != 0)
584 fatal_error ("can't read PCH file: %m");
586 ggc_pch_read (f, mmi.preferred_base);
588 gt_pch_restore_stringpool ();
591 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is not present.
592 Select no address whatsoever, and let gt_pch_save choose what it will with
593 malloc, presumably. */
595 void *
596 default_gt_pch_get_address (size_t size ATTRIBUTE_UNUSED,
597 int fd ATTRIBUTE_UNUSED)
599 return NULL;
602 /* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is not present.
603 Allocate SIZE bytes with malloc. Return 0 if the address we got is the
604 same as base, indicating that the memory has been allocated but needs to
605 be read in from the file. Return -1 if the address differs, to relocation
606 of the PCH file would be required. */
609 default_gt_pch_use_address (void *base, size_t size, int fd ATTRIBUTE_UNUSED,
610 size_t offset ATTRIBUTE_UNUSED)
612 void *addr = xmalloc (size);
613 return (addr == base) - 1;
616 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS. Return the
617 alignment required for allocating virtual memory. Usually this is the
618 same as pagesize. */
620 size_t
621 default_gt_pch_alloc_granularity (void)
623 return getpagesize();
626 #if HAVE_MMAP_FILE
627 /* Default version of HOST_HOOKS_GT_PCH_GET_ADDRESS when mmap is present.
628 We temporarily allocate SIZE bytes, and let the kernel place the data
629 wherever it will. If it worked, that's our spot, if not we're likely
630 to be in trouble. */
632 void *
633 mmap_gt_pch_get_address (size_t size, int fd)
635 void *ret;
637 ret = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
638 if (ret == (void *) MAP_FAILED)
639 ret = NULL;
640 else
641 munmap (ret, size);
643 return ret;
646 /* Default version of HOST_HOOKS_GT_PCH_USE_ADDRESS when mmap is present.
647 Map SIZE bytes of FD+OFFSET at BASE. Return 1 if we succeeded at
648 mapping the data at BASE, -1 if we couldn't.
650 This version assumes that the kernel honors the START operand of mmap
651 even without MAP_FIXED if START through START+SIZE are not currently
652 mapped with something. */
655 mmap_gt_pch_use_address (void *base, size_t size, int fd, size_t offset)
657 void *addr;
659 /* We're called with size == 0 if we're not planning to load a PCH
660 file at all. This allows the hook to free any static space that
661 we might have allocated at link time. */
662 if (size == 0)
663 return -1;
665 addr = mmap (base, size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
666 fd, offset);
668 return addr == base ? 1 : -1;
670 #endif /* HAVE_MMAP_FILE */
672 /* Modify the bound based on rlimits. Keep the smallest number found. */
673 static double
674 ggc_rlimit_bound (double limit)
676 #if defined(HAVE_GETRLIMIT)
677 struct rlimit rlim;
678 # ifdef RLIMIT_RSS
679 if (getrlimit (RLIMIT_RSS, &rlim) == 0
680 && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
681 && rlim.rlim_cur < limit)
682 limit = rlim.rlim_cur;
683 # endif
684 # ifdef RLIMIT_DATA
685 if (getrlimit (RLIMIT_DATA, &rlim) == 0
686 && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
687 && rlim.rlim_cur < limit)
688 limit = rlim.rlim_cur;
689 # endif
690 # ifdef RLIMIT_AS
691 if (getrlimit (RLIMIT_AS, &rlim) == 0
692 && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
693 && rlim.rlim_cur < limit)
694 limit = rlim.rlim_cur;
695 # endif
696 #endif /* HAVE_GETRLIMIT */
698 return limit;
701 /* Heuristic to set a default for GGC_MIN_EXPAND. */
703 ggc_min_expand_heuristic (void)
705 double min_expand = physmem_total();
707 /* Adjust for rlimits. */
708 min_expand = ggc_rlimit_bound (min_expand);
710 /* The heuristic is a percentage equal to 30% + 70%*(RAM/1GB), yielding
711 a lower bound of 30% and an upper bound of 100% (when RAM >= 1GB). */
712 min_expand /= 1024*1024*1024;
713 min_expand *= 70;
714 min_expand = MIN (min_expand, 70);
715 min_expand += 30;
717 return min_expand;
720 /* Heuristic to set a default for GGC_MIN_HEAPSIZE. */
722 ggc_min_heapsize_heuristic (void)
724 double min_heap_kbytes = physmem_total();
726 /* Adjust for rlimits. */
727 min_heap_kbytes = ggc_rlimit_bound (min_heap_kbytes);
729 min_heap_kbytes /= 1024; /* Convert to Kbytes. */
731 /* The heuristic is RAM/8, with a lower bound of 4M and an upper
732 bound of 128M (when RAM >= 1GB). */
733 min_heap_kbytes /= 8;
734 min_heap_kbytes = MAX (min_heap_kbytes, 4 * 1024);
735 min_heap_kbytes = MIN (min_heap_kbytes, 128 * 1024);
737 return min_heap_kbytes;
740 void
741 init_ggc_heuristics (void)
743 #if !defined ENABLE_GC_CHECKING && !defined ENABLE_GC_ALWAYS_COLLECT
744 set_param_value ("ggc-min-expand", ggc_min_expand_heuristic());
745 set_param_value ("ggc-min-heapsize", ggc_min_heapsize_heuristic());
746 #endif
749 #ifdef GATHER_STATISTICS
751 /* Datastructure used to store per-call-site statistics. */
752 struct loc_descriptor
754 const char *file;
755 int line;
756 const char *function;
757 int times;
758 size_t allocated;
759 size_t overhead;
762 /* Hashtable used for statistics. */
763 static htab_t loc_hash;
765 /* Hash table helpers functions. */
766 static hashval_t
767 hash_descriptor (const void *p)
769 const struct loc_descriptor *d = p;
771 return htab_hash_pointer (d->function) | d->line;
774 static int
775 eq_descriptor (const void *p1, const void *p2)
777 const struct loc_descriptor *d = p1;
778 const struct loc_descriptor *d2 = p2;
780 return (d->file == d2->file && d->line == d2->line
781 && d->function == d2->function);
784 /* Return descriptor for given call site, create new one if needed. */
785 static struct loc_descriptor *
786 loc_descriptor (const char *name, int line, const char *function)
788 struct loc_descriptor loc;
789 struct loc_descriptor **slot;
791 loc.file = name;
792 loc.line = line;
793 loc.function = function;
794 if (!loc_hash)
795 loc_hash = htab_create (10, hash_descriptor, eq_descriptor, NULL);
797 slot = (struct loc_descriptor **) htab_find_slot (loc_hash, &loc, 1);
798 if (*slot)
799 return *slot;
800 *slot = xcalloc (sizeof (**slot), 1);
801 (*slot)->file = name;
802 (*slot)->line = line;
803 (*slot)->function = function;
804 return *slot;
807 /* Record ALLOCATED and OVERHEAD bytes to descriptor NAME:LINE (FUNCTION). */
808 void
809 ggc_record_overhead (size_t allocated, size_t overhead,
810 const char *name, int line, const char *function)
812 struct loc_descriptor *loc = loc_descriptor (name, line, function);
814 loc->times++;
815 loc->allocated+=allocated;
816 loc->overhead+=overhead;
819 /* Helper for qsort; sort descriptors by amount of memory consumed. */
820 static int
821 cmp_statistic (const void *loc1, const void *loc2)
823 struct loc_descriptor *l1 = *(struct loc_descriptor **) loc1;
824 struct loc_descriptor *l2 = *(struct loc_descriptor **) loc2;
825 return (l1->allocated + l1->overhead) - (l2->allocated + l2->overhead);
828 /* Collect array of the descriptors from hashtable. */
829 struct loc_descriptor **loc_array;
830 static int
831 add_statistics (void **slot, void *b)
833 int *n = (int *)b;
834 loc_array[*n] = (struct loc_descriptor *) *slot;
835 (*n)++;
836 return 1;
839 /* Dump per-site memory statistics. */
840 #endif
841 void dump_ggc_loc_statistics (void)
843 #ifdef GATHER_STATISTICS
844 int nentries = 0;
845 char s[4096];
846 size_t count, size, overhead;
847 int i;
849 loc_array = xcalloc (sizeof (*loc_array), loc_hash->n_elements);
850 fprintf (stderr, "-------------------------------------------------------\n");
851 fprintf (stderr, "\n%-60s %10s %10s %10s\n",
852 "source location", "Times", "Allocated", "Overhead");
853 fprintf (stderr, "-------------------------------------------------------\n");
854 count = 0;
855 size = 0;
856 overhead = 0;
857 htab_traverse (loc_hash, add_statistics, &nentries);
858 qsort (loc_array, nentries, sizeof (*loc_array), cmp_statistic);
859 for (i = 0; i < nentries; i++)
861 struct loc_descriptor *d = loc_array[i];
862 size += d->allocated;
863 count += d->times;
864 overhead += d->overhead;
866 for (i = 0; i < nentries; i++)
868 struct loc_descriptor *d = loc_array[i];
869 if (d->allocated)
871 const char *s1 = d->file;
872 const char *s2;
873 while ((s2 = strstr (s1, "gcc/")))
874 s1 = s2 + 4;
875 sprintf (s, "%s:%i (%s)", s1, d->line, d->function);
876 fprintf (stderr, "%-60s %10i %10li %10li:%.3f%%\n", s,
877 d->times, (long)d->allocated, (long)d->overhead,
878 (d->allocated + d->overhead) *100.0 / (size + overhead));
881 fprintf (stderr, "%-60s %10ld %10ld %10ld\n",
882 "Total", (long)count, (long)size, (long)overhead);
883 fprintf (stderr, "-------------------------------------------------------\n");
884 #endif