zero otherwise. We allocate them all together, to enable a
better runtime data access pattern. */
unsigned long **save_in_use;
-
-#ifdef ENABLE_GC_ALWAYS_COLLECT
- /* List of free objects to be verified as actually free on the
- next collection. */
- struct free_object
- {
- void *object;
- struct free_object *next;
- } *free_object_list;
-#endif
-
#ifdef GATHER_STATISTICS
struct
{
/* For a page that is no longer needed, put it on the free page list. */
-static void
+static inline void
free_page (page_entry *entry)
{
if (GGC_DEBUG_LEVEL >= 2)
void *
ggc_alloc (size_t size)
{
- size_t order, word, bit, object_offset, object_size;
+ unsigned order, word, bit, object_offset;
struct page_entry *entry;
void *result;
if (size <= 256)
- {
- order = size_lookup[size];
- object_size = OBJECT_SIZE (order);
- }
+ order = size_lookup[size];
else
{
order = 9;
- while (size > (object_size = OBJECT_SIZE (order)))
+ while (size > OBJECT_SIZE (order))
order++;
}
/* Next time, try the next bit. */
entry->next_bit_hint = hint + 1;
- object_offset = hint * object_size;
+ object_offset = hint * OBJECT_SIZE (order);
}
/* Set the in-use bit. */
exact same semantics in presence of memory bugs, regardless of
ENABLE_VALGRIND_CHECKING. We override this request below. Drop the
handle to avoid handle leak. */
- VALGRIND_DISCARD (VALGRIND_MAKE_WRITABLE (result, object_size));
+ VALGRIND_DISCARD (VALGRIND_MAKE_WRITABLE (result, OBJECT_SIZE (order)));
/* `Poison' the entire allocated object, including any padding at
the end. */
- memset (result, 0xaf, object_size);
+ memset (result, 0xaf, OBJECT_SIZE (order));
/* Make the bytes after the end of the object unaccessible. Discard the
handle to avoid handle leak. */
VALGRIND_DISCARD (VALGRIND_MAKE_NOACCESS ((char *) result + size,
- object_size - size));
+ OBJECT_SIZE (order) - size));
#endif
/* Tell Valgrind that the memory is there, but its content isn't
/* Keep track of how many bytes are being allocated. This
information is used in deciding when to collect. */
- G.allocated += object_size;
+ G.allocated += OBJECT_SIZE (order);
#ifdef GATHER_STATISTICS
{
- size_t overhead = object_size - size;
+ G.stats.total_overhead += OBJECT_SIZE (order) - size;
+ G.stats.total_allocated += OBJECT_SIZE(order);
+ G.stats.total_overhead_per_order[order] += OBJECT_SIZE (order) - size;
+ G.stats.total_allocated_per_order[order] += OBJECT_SIZE (order);
+
+ if (size <= 32){
+ G.stats.total_overhead_under32 += OBJECT_SIZE (order) - size;
+ G.stats.total_allocated_under32 += OBJECT_SIZE(order);
+ }
- G.stats.total_overhead += overhead;
- G.stats.total_allocated += object_size;
- G.stats.total_overhead_per_order[order] += overhead;
- G.stats.total_allocated_per_order[order] += object_size;
+ if (size <= 64){
+ G.stats.total_overhead_under64 += OBJECT_SIZE (order) - size;
+ G.stats.total_allocated_under64 += OBJECT_SIZE(order);
+ }
+
+ if (size <= 128){
+ G.stats.total_overhead_under128 += OBJECT_SIZE (order) - size;
+ G.stats.total_allocated_under128 += OBJECT_SIZE(order);
+ }
- if (size <= 32)
- {
- G.stats.total_overhead_under32 += overhead;
- G.stats.total_allocated_under32 += object_size;
- }
- if (size <= 64)
- {
- G.stats.total_overhead_under64 += overhead;
- G.stats.total_allocated_under64 += object_size;
- }
- if (size <= 128)
- {
- G.stats.total_overhead_under128 += overhead;
- G.stats.total_allocated_under128 += object_size;
- }
}
#endif
-
+
if (GGC_DEBUG_LEVEL >= 3)
fprintf (G.debug_file,
"Allocating object, requested size=%lu, actual=%lu at %p on %p\n",
- (unsigned long) size, (unsigned long) object_size, result,
+ (unsigned long) size, (unsigned long) OBJECT_SIZE (order), result,
(void *) entry);
return result;
page_entry *pe = lookup_page_table_entry (p);
return OBJECT_SIZE (pe->order);
}
-
-/* Release the memory for object P. */
-
-void
-ggc_free (void *p)
-{
- page_entry *pe = lookup_page_table_entry (p);
- size_t order = pe->order;
- size_t size = OBJECT_SIZE (order);
-
- if (GGC_DEBUG_LEVEL >= 3)
- fprintf (G.debug_file,
- "Freeing object, actual size=%lu, at %p on %p\n",
- (unsigned long) size, p, (void *) pe);
-
-#ifdef ENABLE_GC_CHECKING
- /* Poison the data, to indicate the data is garbage. */
- VALGRIND_DISCARD (VALGRIND_MAKE_WRITABLE (p, size));
- memset (p, 0xa5, size);
-#endif
- /* Let valgrind know the object is free. */
- VALGRIND_DISCARD (VALGRIND_MAKE_NOACCESS (p, size));
-
-#ifdef ENABLE_GC_ALWAYS_COLLECT
- /* In the completely-anal-checking mode, we do *not* immediately free
- the data, but instead verify that the data is *actually* not
- reachable the next time we collect. */
- {
- struct free_object *fo = xmalloc (sizeof (struct free_object));
- fo->object = p;
- fo->next = G.free_object_list;
- G.free_object_list = fo;
- }
-#else
- {
- unsigned int bit_offset, word, bit;
-
- G.allocated -= size;
-
- /* Mark the object not-in-use. */
- bit_offset = OFFSET_TO_BIT (((const char *) p) - pe->page, order);
- word = bit_offset / HOST_BITS_PER_LONG;
- bit = bit_offset % HOST_BITS_PER_LONG;
- pe->in_use_p[word] &= ~(1UL << bit);
-
- if (pe->num_free_objects++ == 0)
- {
- /* If the page is completely full, then it's supposed to
- be after all pages that aren't. Since we've freed one
- object from a page that was full, we need to move the
- page to the head of the list. */
-
- page_entry *p, *q;
- for (q = NULL, p = G.pages[order]; ; q = p, p = p->next)
- if (p == pe)
- break;
- if (q && q->num_free_objects == 0)
- {
- p = pe->next;
- q->next = p;
- if (!p)
- G.page_tails[order] = q;
- pe->next = G.pages[order];
- G.pages[order] = pe;
- }
-
- /* Reset the hint bit to point to the only free object. */
- pe->next_bit_hint = bit_offset;
- }
- }
-#endif
-}
\f
/* Subroutine of init_ggc which computes the pair of numbers used to
perform division by OBJECT_SIZE (order) and fills in inverse_table[].
timevar_push (TV_GC);
if (!quiet_flag)
fprintf (stderr, " {GC %luk -> ", (unsigned long) G.allocated / 1024);
- if (GGC_DEBUG_LEVEL >= 2)
- fprintf (G.debug_file, "BEGIN COLLECTING\n");
/* Zero the total allocated bytes. This will be recalculated in the
sweep phase. */
sweep_pages ();
-#ifdef ENABLE_GC_ALWAYS_COLLECT
- /* Validate that the reportedly free objects actually are. */
- {
- struct free_object *f, *n;
- for (f = G.free_object_list; f ; f = n)
- {
- page_entry *pe = lookup_page_table_entry (f->object);
-
- /* If the page entry is null, that means the entire page is free.
- Otherwise, we have to examine the in-use bit for the object. */
- if (pe != NULL)
- {
- size_t bit, word;
- bit = OFFSET_TO_BIT ((char *)f->object - pe->page, pe->order);
- word = bit / HOST_BITS_PER_LONG;
- bit = bit % HOST_BITS_PER_LONG;
-
- if (pe->in_use_p[word] & (1UL << bit))
- abort ();
- }
-
- n = f->next;
- free (f);
- }
- G.free_object_list = NULL;
- }
-#endif
-
G.allocated_last_gc = G.allocated;
timevar_pop (TV_GC);
if (!quiet_flag)
fprintf (stderr, "%luk}", (unsigned long) G.allocated / 1024);
- if (GGC_DEBUG_LEVEL >= 2)
- fprintf (G.debug_file, "END COLLECTING\n");
}
/* Print allocation statistics. */
projects / gcc.git / commitdiff