#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;
}
#endif /* HAVE_MMAP_FILE */
-/* Modify the bound based on rlimits. Keep the smallest number found. */
+/* Modify the bound based on rlimits. */
static double
ggc_rlimit_bound (double limit)
{
#if defined(HAVE_GETRLIMIT)
struct rlimit rlim;
-# ifdef RLIMIT_RSS
- if (getrlimit (RLIMIT_RSS, &rlim) == 0
+# if defined (RLIMIT_AS)
+ /* RLIMIT_AS is what POSIX says is the limit on mmap. Presumably
+ any OS which has RLIMIT_AS also has a working mmap that GCC will use. */
+ if (getrlimit (RLIMIT_AS, &rlim) == 0
&& rlim.rlim_cur != (rlim_t) RLIM_INFINITY
&& rlim.rlim_cur < limit)
limit = rlim.rlim_cur;
-# endif
-# ifdef RLIMIT_DATA
+# elif defined (RLIMIT_DATA)
+ /* ... but some older OSs bound mmap based on RLIMIT_DATA, or we
+ might be on an OS that has a broken mmap. (Others don't bound
+ mmap at all, apparently.) */
if (getrlimit (RLIMIT_DATA, &rlim) == 0
&& rlim.rlim_cur != (rlim_t) RLIM_INFINITY
- && rlim.rlim_cur < limit)
- limit = rlim.rlim_cur;
-# endif
-# ifdef RLIMIT_AS
- if (getrlimit (RLIMIT_AS, &rlim) == 0
- && rlim.rlim_cur != (rlim_t) RLIM_INFINITY
- && rlim.rlim_cur < limit)
+ && rlim.rlim_cur < limit
+ /* Darwin has this horribly bogus default setting of
+ RLIMIT_DATA, to 6144Kb. No-one notices because RLIMIT_DATA
+ appears to be ignored. Ignore such silliness. If a limit
+ this small was actually effective for mmap, GCC wouldn't even
+ start up. */
+ && rlim.rlim_cur >= 8 * 1024 * 1024)
limit = rlim.rlim_cur;
-# endif
+# endif /* RLIMIT_AS or RLIMIT_DATA */
#endif /* HAVE_GETRLIMIT */
return limit;
int
ggc_min_heapsize_heuristic (void)
{
- double min_heap_kbytes = physmem_total();
-
- /* Adjust for rlimits. */
- min_heap_kbytes = ggc_rlimit_bound (min_heap_kbytes);
+ double phys_kbytes = physmem_total();
+ double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2);
- min_heap_kbytes /= 1024; /* Convert to Kbytes. */
+ phys_kbytes /= 1024; /* Convert to Kbytes. */
+ limit_kbytes /= 1024;
/* The heuristic is RAM/8, with a lower bound of 4M and an upper
bound of 128M (when RAM >= 1GB). */
- min_heap_kbytes /= 8;
- min_heap_kbytes = MAX (min_heap_kbytes, 4 * 1024);
- min_heap_kbytes = MIN (min_heap_kbytes, 128 * 1024);
+ phys_kbytes /= 8;
+
+#if defined(HAVE_GETRLIMIT) && defined (RLIMIT_RSS)
+ /* Try not to overrun the RSS limit while doing garbage collection.
+ The RSS limit is only advisory, so no margin is subtracted. */
+ {
+ struct rlimit rlim;
+ if (getrlimit (RLIMIT_RSS, &rlim) == 0
+ && rlim.rlim_cur != (rlim_t) RLIM_INFINITY)
+ phys_kbytes = MIN (phys_kbytes, rlim.rlim_cur / 1024);
+ }
+# endif
+
+ /* Don't blindly run over our data limit; do GC at least when the
+ *next* GC would be within 16Mb of the limit. If GCC does hit the
+ data limit, compilation will fail, so this tries to be
+ conservative. */
+ limit_kbytes = MAX (0, limit_kbytes - 16 * 1024);
+ limit_kbytes = (limit_kbytes * 100) / (110 + ggc_min_expand_heuristic());
+ phys_kbytes = MIN (phys_kbytes, limit_kbytes);
+
+ phys_kbytes = MAX (phys_kbytes, 4 * 1024);
+ phys_kbytes = MIN (phys_kbytes, 128 * 1024);
- return min_heap_kbytes;
+ return phys_kbytes;
}
void
int times;
size_t allocated;
size_t overhead;
+ size_t freed;
+ size_t collected;
};
/* Hashtable used for statistics. */
&& 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)
/* 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. */
#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++)
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
}