/*
* This is called when we've run out of memory during a major collection.
*
* After collecting potential pin entries and sorting the array, this is what it looks like:
*
* +--------------------+---------------------------------------------+--------------------+
* | major heap entries | nursery entries | major heap entries |
* +--------------------+---------------------------------------------+--------------------+
*
* Of course there might not be major heap entries before and/or after the nursery entries,
* depending on where the major heap sections are in the address space, and whether there
* were any potential pointers there.
*
* When we pin nursery objects, we compact the nursery part of the pin array, which leaves
* discarded entries after the ones that actually pointed to nursery objects:
*
* +--------------------+-----------------+---------------------------+--------------------+
* | major heap entries | nursery entries | discarded nursery entries | major heap entries |
* +--------------------+-----------------+---------------------------+--------------------+
*
* When, due to being out of memory, we late pin more objects, the pin array looks like
* this:
*
* +--------------------+-----------------+---------------------------+--------------------+--------------+
* | major heap entries | nursery entries | discarded nursery entries | major heap entries | late entries |
* +--------------------+-----------------+---------------------------+--------------------+--------------+
*
* This function gets rid of the discarded nursery entries by nulling them out. Note that
* we can late pin objects not only in the nursery but also in the major heap, which happens
* when evacuation fails.
*/
void
sgen_pin_queue_clear_discarded_entries (GCMemSection *section, size_t max_pin_slot)
{
void **start = sgen_pinning_get_entry (section->pin_queue_last_entry);
void **end = sgen_pinning_get_entry (max_pin_slot);
void *addr;
for (; start < end; ++start) {
addr = *start;
if ((char*)addr < section->data || (char*)addr > section->end_data)
break;
*start = NULL;
}
}
mword
sgen_build_nursery_fragments (GCMemSection *nursery_section, SgenGrayQueue *unpin_queue)
{
char *frag_start, *frag_end;
size_t frag_size;
SgenFragment *frags_ranges;
void **pin_start, **pin_entry, **pin_end;
#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));
pin_start = pin_entry = sgen_pinning_get_entry (nursery_section->pin_queue_first_entry);
pin_end = sgen_pinning_get_entry (nursery_section->pin_queue_last_entry);
while (pin_entry < pin_end || frags_ranges) {
char *addr0, *addr1;
size_t size;
addr0 = addr1 = sgen_nursery_end;
if (pin_entry < pin_end)
addr0 = (char *)*pin_entry;
if (frags_ranges)
addr1 = frags_ranges->fragment_start;
if (addr0 < addr1) {
if (unpin_queue)
GRAY_OBJECT_ENQUEUE (unpin_queue, (GCObject*)addr0, sgen_obj_get_descriptor_safe ((GCObject*)addr0));
else
SGEN_UNPIN_OBJECT (addr0);
size = SGEN_ALIGN_UP (sgen_safe_object_get_size ((GCObject*)addr0));
CANARIFY_SIZE (size);
sgen_set_nursery_scan_start (addr0);
frag_end = addr0;
++pin_entry;
} else {
frag_end = addr1;
size = frags_ranges->fragment_next - addr1;
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 (*pin_entry, 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");
for (pin_entry = pin_start; pin_entry < pin_end; ++pin_entry) {
GCObject *p = (GCObject *)*pin_entry;
SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", p, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (p)), sgen_safe_object_get_size (p));
}
}
return fragment_total;
}
