static void
sweep_pinned_objects_callback (char *ptr, size_t size, void *data)
{
if (SGEN_OBJECT_IS_PINNED (ptr)) {
SGEN_UNPIN_OBJECT (ptr);
DEBUG (6, fprintf (gc_debug_file, "Unmarked pinned object %p (%s)\n", ptr, sgen_safe_name (ptr)));
} else {
DEBUG (6, fprintf (gc_debug_file, "Freeing unmarked pinned object %p (%s)\n", ptr, sgen_safe_name (ptr)));
free_pinned_object (ptr, size);
}
}
void
sgen_dump_pin_queue (void)
{
int i;
for (i = 0; i < last_num_pinned; ++i) {
SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %d", pin_queue [i], sgen_safe_name (pin_queue [i]), sgen_safe_object_get_size (pin_queue [i]));
}
}
void
sgen_dump_pin_queue (void)
{
int i;
for (i = 0; i < last_num_pinned; ++i) {
void *ptr = pin_queue.data [i];
SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", ptr, sgen_safe_name (ptr), sgen_safe_object_get_size (ptr));
}
}
/* LOCKING: requires that the GC lock is held */
void
sgen_collect_bridge_objects (int generation, ScanCopyContext ctx)
{
CopyOrMarkObjectFunc copy_func = ctx.copy_func;
GrayQueue *queue = ctx.queue;
SgenHashTable *hash_table = get_finalize_entry_hash_table (generation);
MonoObject *object;
gpointer dummy;
char *copy;
if (no_finalize)
return;
SGEN_HASH_TABLE_FOREACH (hash_table, object, dummy) {
int tag = tagged_object_get_tag (object);
object = tagged_object_get_object (object);
/* Bridge code told us to ignore this one */
if (tag == BRIDGE_OBJECT_MARKED)
continue;
/* Object is a bridge object and major heap says it's dead */
if (major_collector.is_object_live ((char*)object))
continue;
/* Nursery says the object is dead. */
if (!sgen_gc_is_object_ready_for_finalization (object))
continue;
if (!sgen_is_bridge_object (object))
continue;
copy = (char*)object;
copy_func ((void**)©, queue);
sgen_bridge_register_finalized_object ((MonoObject*)copy);
if (hash_table == &minor_finalizable_hash && !ptr_in_nursery (copy)) {
/* remove from the list */
SGEN_HASH_TABLE_FOREACH_REMOVE (TRUE);
/* insert it into the major hash */
sgen_hash_table_replace (&major_finalizable_hash, tagged_object_apply (copy, tag), NULL, NULL);
SGEN_LOG (5, "Promoting finalization of object %p (%s) (was at %p) to major table", copy, sgen_safe_name (copy), object);
continue;
} else {
/* update pointer */
SGEN_LOG (5, "Updating object for finalization: %p (%s) (was at %p)", copy, sgen_safe_name (copy), object);
SGEN_HASH_TABLE_FOREACH_SET_KEY (tagged_object_apply (copy, tag));
}
} SGEN_HASH_TABLE_FOREACH_END;
mword
sgen_build_nursery_fragments (GCMemSection *nursery_section, void **start, size_t num_entries, SgenGrayQueue *unpin_queue)
{
char *frag_start, *frag_end;
size_t frag_size;
size_t i = 0;
SgenFragment *frags_ranges;
#ifdef NALLOC_DEBUG
reset_alloc_records ();
#endif
/*The mutator fragments are done. We no longer need them. */
sgen_fragment_allocator_release (&mutator_allocator);
frag_start = sgen_nursery_start;
fragment_total = 0;
/* The current nursery might give us a fragment list to exclude [start, next[*/
frags_ranges = sgen_minor_collector.build_fragments_get_exclude_head ();
/* clear scan starts */
memset (nursery_section->scan_starts, 0, nursery_section->num_scan_start * sizeof (gpointer));
while (i < num_entries || frags_ranges) {
char *addr0, *addr1;
size_t size;
SgenFragment *last_frag = NULL;
addr0 = addr1 = sgen_nursery_end;
if (i < num_entries)
addr0 = start [i];
if (frags_ranges)
addr1 = frags_ranges->fragment_start;
if (addr0 < addr1) {
if (unpin_queue)
GRAY_OBJECT_ENQUEUE (unpin_queue, addr0);
else
SGEN_UNPIN_OBJECT (addr0);
sgen_set_nursery_scan_start (addr0);
frag_end = addr0;
size = SGEN_ALIGN_UP (sgen_safe_object_get_size ((MonoObject*)addr0));
++i;
} else {
frag_end = addr1;
size = frags_ranges->fragment_next - addr1;
last_frag = frags_ranges;
frags_ranges = frags_ranges->next_in_order;
}
frag_size = frag_end - frag_start;
if (size == 0)
continue;
g_assert (frag_size >= 0);
g_assert (size > 0);
if (frag_size && size)
add_nursery_frag (&mutator_allocator, frag_size, frag_start, frag_end);
frag_size = size;
#ifdef NALLOC_DEBUG
add_alloc_record (start [i], frag_size, PINNING);
#endif
frag_start = frag_end + frag_size;
}
nursery_last_pinned_end = frag_start;
frag_end = sgen_nursery_end;
frag_size = frag_end - frag_start;
if (frag_size)
add_nursery_frag (&mutator_allocator, frag_size, frag_start, frag_end);
/* Now it's safe to release the fragments exclude list. */
sgen_minor_collector.build_fragments_release_exclude_head ();
/* First we reorder the fragment list to be in ascending address order. This makes H/W prefetchers happier. */
fragment_list_reverse (&mutator_allocator);
/*The collector might want to do something with the final nursery fragment list.*/
sgen_minor_collector.build_fragments_finish (&mutator_allocator);
if (!unmask (mutator_allocator.alloc_head)) {
SGEN_LOG (1, "Nursery fully pinned (%zd)", num_entries);
for (i = 0; i < num_entries; ++i) {
SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", start [i], sgen_safe_name (start [i]), sgen_safe_object_get_size (start [i]));
}
}
return fragment_total;
}
static void
pin_pinned_object_callback (void *addr, size_t slot_size, SgenGrayQueue *queue)
{
binary_protocol_pin (addr, (gpointer)SGEN_LOAD_VTABLE (addr), sgen_safe_object_get_size ((MonoObject*)addr));
if (!SGEN_OBJECT_IS_PINNED (addr))
sgen_pin_stats_register_object ((char*) addr, sgen_safe_object_get_size ((MonoObject*) addr));
SGEN_PIN_OBJECT (addr);
GRAY_OBJECT_ENQUEUE (queue, addr);
DEBUG (6, fprintf (gc_debug_file, "Marked pinned object %p (%s) from roots\n", addr, sgen_safe_name (addr)));
}
static void
major_copy_or_mark_object (void **obj_slot, SgenGrayQueue *queue)
{
char *forwarded;
char *obj = *obj_slot;
mword objsize;
DEBUG (9, g_assert (current_collection_generation == GENERATION_OLD));
HEAVY_STAT (++stat_copy_object_called_major);
DEBUG (9, fprintf (gc_debug_file, "Precise copy of %p from %p", obj, obj_slot));
/*
* obj must belong to one of:
*
* 1. the nursery
* 2. the LOS
* 3. a pinned chunk
* 4. a non-to-space section of the major heap
* 5. a to-space section of the major heap
*
* In addition, objects in 1, 2 and 4 might also be pinned.
* Objects in 1 and 4 might be forwarded.
*
* Before we can copy the object we must make sure that we are
* allowed to, i.e. that the object not pinned, not already
* forwarded, not in the nursery To Space and doesn't belong
* to the LOS, a pinned chunk, or a to-space section.
*
* We are usually called for to-space objects (5) when we have
* two remset entries for the same reference. The first entry
* copies the object and updates the reference and the second
* calls us with the updated reference that points into
* to-space. There might also be other circumstances where we
* get to-space objects.
*/
if ((forwarded = SGEN_OBJECT_IS_FORWARDED (obj))) {
DEBUG (9, g_assert (((MonoVTable*)SGEN_LOAD_VTABLE(obj))->gc_descr));
DEBUG (9, fprintf (gc_debug_file, " (already forwarded to %p)\n", forwarded));
HEAVY_STAT (++stat_major_copy_object_failed_forwarded);
*obj_slot = forwarded;
return;
}
if (SGEN_OBJECT_IS_PINNED (obj)) {
DEBUG (9, g_assert (((MonoVTable*)SGEN_LOAD_VTABLE(obj))->gc_descr));
DEBUG (9, fprintf (gc_debug_file, " (pinned, no change)\n"));
HEAVY_STAT (++stat_major_copy_object_failed_pinned);
return;
}
if (ptr_in_nursery (obj)) {
/* A To Space object is already on its final destination for the current collection. */
if (sgen_nursery_is_to_space (obj))
return;
goto copy;
}
/*
* At this point we know obj is not pinned, not forwarded and
* belongs to 2, 3, 4, or 5.
*
* LOS object (2) are simple, at least until we always follow
* the rule: if objsize > SGEN_MAX_SMALL_OBJ_SIZE, pin the
* object and return it. At the end of major collections, we
* walk the los list and if the object is pinned, it is
* marked, otherwise it can be freed.
*
* Pinned chunks (3) and major heap sections (4, 5) both
* reside in blocks, which are always aligned, so once we've
* eliminated LOS objects, we can just access the block and
* see whether it's a pinned chunk or a major heap section.
*/
objsize = SGEN_ALIGN_UP (sgen_safe_object_get_size ((MonoObject*)obj));
if (G_UNLIKELY (objsize > SGEN_MAX_SMALL_OBJ_SIZE || obj_is_from_pinned_alloc (obj))) {
if (SGEN_OBJECT_IS_PINNED (obj))
return;
DEBUG (9, fprintf (gc_debug_file, " (marked LOS/Pinned %p (%s), size: %td)\n", obj, sgen_safe_name (obj), objsize));
binary_protocol_pin (obj, (gpointer)SGEN_LOAD_VTABLE (obj), sgen_safe_object_get_size ((MonoObject*)obj));
SGEN_PIN_OBJECT (obj);
GRAY_OBJECT_ENQUEUE (queue, obj);
HEAVY_STAT (++stat_major_copy_object_failed_large_pinned);
return;
}
/*
* Now we know the object is in a major heap section. All we
* need to do is check whether it's already in to-space (5) or
* not (4).
*/
if (MAJOR_OBJ_IS_IN_TO_SPACE (obj)) {
DEBUG (9, g_assert (objsize <= SGEN_MAX_SMALL_OBJ_SIZE));
DEBUG (9, fprintf (gc_debug_file, " (already copied)\n"));
HEAVY_STAT (++stat_major_copy_object_failed_to_space);
return;
}
copy:
HEAVY_STAT (++stat_objects_copied_major);
*obj_slot = copy_object_no_checks (obj, queue);
}
static mword*
handle_remset (mword *p, void *start_nursery, void *end_nursery, gboolean global, SgenGrayQueue *queue)
{
void **ptr;
mword count;
mword desc;
if (global)
HEAVY_STAT (++stat_global_remsets_processed);
else
HEAVY_STAT (++stat_local_remsets_processed);
/* FIXME: exclude stack locations */
switch ((*p) & REMSET_TYPE_MASK) {
case REMSET_LOCATION:
ptr = (void**)(*p);
//__builtin_prefetch (ptr);
if (((void*)ptr < start_nursery || (void*)ptr >= end_nursery)) {
gpointer old = *ptr;
sgen_get_current_object_ops ()->copy_or_mark_object (ptr, queue);
SGEN_LOG (9, "Overwrote remset at %p with %p", ptr, *ptr);
if (old)
binary_protocol_ptr_update (ptr, old, *ptr, (gpointer)SGEN_LOAD_VTABLE (*ptr), sgen_safe_object_get_size (*ptr));
if (!global && *ptr >= start_nursery && *ptr < end_nursery) {
/*
* If the object is pinned, each reference to it from nonpinned objects
* becomes part of the global remset, which can grow very large.
*/
SGEN_LOG (9, "Add to global remset because of pinning %p (%p %s)", ptr, *ptr, sgen_safe_name (*ptr));
sgen_add_to_global_remset (ptr);
}
} else {
SGEN_LOG (9, "Skipping remset at %p holding %p", ptr, *ptr);
}
return p + 1;
case REMSET_RANGE: {
CopyOrMarkObjectFunc copy_func = sgen_get_current_object_ops ()->copy_or_mark_object;
ptr = (void**)(*p & ~REMSET_TYPE_MASK);
if (((void*)ptr >= start_nursery && (void*)ptr < end_nursery))
return p + 2;
count = p [1];
while (count-- > 0) {
copy_func (ptr, queue);
SGEN_LOG (9, "Overwrote remset at %p with %p (count: %d)", ptr, *ptr, (int)count);
if (!global && *ptr >= start_nursery && *ptr < end_nursery)
sgen_add_to_global_remset (ptr);
++ptr;
}
return p + 2;
}
case REMSET_OBJECT:
ptr = (void**)(*p & ~REMSET_TYPE_MASK);
if (((void*)ptr >= start_nursery && (void*)ptr < end_nursery))
return p + 1;
sgen_get_current_object_ops ()->scan_object ((char*)ptr, queue);
return p + 1;
case REMSET_VTYPE: {
size_t skip_size;
ptr = (void**)(*p & ~REMSET_TYPE_MASK);
if (((void*)ptr >= start_nursery && (void*)ptr < end_nursery))
return p + 4;
desc = p [1];
count = p [2];
skip_size = p [3];
while (count-- > 0) {
sgen_get_current_object_ops ()->scan_vtype ((char*)ptr, desc, queue);
ptr = (void**)((char*)ptr + skip_size);
}
return p + 4;
}
default:
g_assert_not_reached ();
}
return NULL;
}
