#include "metadata/sgen-protocol.h"
#include "metadata/sgen-archdep.h"
#include "metadata/sgen-bridge.h"
+#include "metadata/sgen-memory-governor.h"
#include "metadata/mono-gc.h"
#include "metadata/method-builder.h"
#include "metadata/profiler-private.h"
char *sgen_nursery_end;
#ifdef USER_CONFIG
-int sgen_nursery_size = (1 << 22);
+size_t sgen_nursery_size = (1 << 22);
#ifdef SGEN_ALIGN_NURSERY
int sgen_nursery_bits = 22;
#endif
#endif
char *sgen_space_bitmap MONO_INTERNAL;
-int sgen_space_bitmap_size MONO_INTERNAL;
+size_t sgen_space_bitmap_size MONO_INTERNAL;
#ifdef HEAVY_STATISTICS
static volatile int next_record;
static volatile int alloc_count;
+void dump_alloc_records (void);
+void verify_alloc_records (void);
static const char*
get_reason_name (AllocRecord *rec)
dump_alloc_records (void)
{
int i;
- qsort (alloc_records, next_record, sizeof (AllocRecord), comp_alloc_record);
+ sgen_qsort (alloc_records, next_record, sizeof (AllocRecord), comp_alloc_record);
printf ("------------------------------------DUMP RECORDS----------------------------\n");
for (i = 0; i < next_record; ++i) {
int max_hole = 0;
AllocRecord *prev = NULL;
- qsort (alloc_records, next_record, sizeof (AllocRecord), comp_alloc_record);
+ sgen_qsort (alloc_records, next_record, sizeof (AllocRecord), comp_alloc_record);
printf ("------------------------------------DUMP RECORDS- %d %d---------------------------\n", next_record, alloc_count);
for (i = 0; i < next_record; ++i) {
AllocRecord *rec = alloc_records + i;
* allocating from this dying fragment as it doesn't respect SGEN_MAX_NURSERY_WASTE
* when doing second chance allocation.
*/
- if (sgen_get_nursery_clear_policy () == CLEAR_AT_TLAB_CREATION && claim_remaining_size (frag, end)) {
+ if ((sgen_get_nursery_clear_policy () == CLEAR_AT_TLAB_CREATION || sgen_get_nursery_clear_policy () == CLEAR_AT_TLAB_CREATION_DEBUG) && claim_remaining_size (frag, end)) {
sgen_clear_range (end, frag->fragment_end);
HEAVY_STAT (InterlockedExchangeAdd (&stat_wasted_bytes_trailer, frag->fragment_end - end));
#ifdef NALLOC_DEBUG
/*frag->next read must happen before the first CAS*/
mono_memory_write_barrier ();
- /*Fail if the next done is removed concurrently and its CAS wins */
+ /*Fail if the next node is removed concurrently and its CAS wins */
if (InterlockedCompareExchangePointer ((volatile gpointer*)&frag->next, mask (next, 1), next) != next) {
continue;
}
mono_memory_write_barrier ();
/* Fail if the previous node was deleted and its CAS wins */
- if (InterlockedCompareExchangePointer ((volatile gpointer*)prev_ptr, next, frag) != frag) {
+ if (InterlockedCompareExchangePointer ((volatile gpointer*)prev_ptr, unmask (next), frag) != frag) {
prev_ptr = find_previous_pointer_fragment (allocator, frag);
continue;
}
for (frag = unmask (allocator->alloc_head); unmask (frag); frag = unmask (frag->next)) {
HEAVY_STAT (InterlockedIncrement (&stat_alloc_iterations));
- if (size <= (frag->fragment_end - frag->fragment_next)) {
+ if (size <= (size_t)(frag->fragment_end - frag->fragment_next)) {
void *p = par_alloc_from_fragment (allocator, frag, size);
if (!p) {
HEAVY_STAT (InterlockedIncrement (&stat_alloc_retries));
#endif
for (frag = unmask (allocator->alloc_head); frag; frag = unmask (frag->next)) {
- int frag_size = frag->fragment_end - frag->fragment_next;
+ size_t frag_size = frag->fragment_end - frag->fragment_next;
HEAVY_STAT (InterlockedIncrement (&stat_alloc_range_iterations));
if (min_frag) {
void *p;
- int frag_size;
+ size_t frag_size;
frag_size = min_frag->fragment_end - min_frag->fragment_next;
if (frag_size < minimum_size)
void
sgen_clear_nursery_fragments (void)
{
- if (sgen_get_nursery_clear_policy () == CLEAR_AT_TLAB_CREATION) {
+ if (sgen_get_nursery_clear_policy () == CLEAR_AT_TLAB_CREATION || sgen_get_nursery_clear_policy () == CLEAR_AT_TLAB_CREATION_DEBUG) {
sgen_clear_allocator_fragments (&mutator_allocator);
sgen_minor_collector.clear_fragments ();
}
/* Mark this as not a real object */
o->obj.synchronisation = GINT_TO_POINTER (-1);
o->bounds = NULL;
- o->max_length = size - sizeof (MonoArray);
+ o->max_length = (mono_array_size_t)(size - sizeof (MonoArray));
sgen_set_nursery_scan_start (start);
g_assert (start + sgen_safe_object_get_size ((MonoObject*)o) == end);
}
/* memsetting just the first chunk start is bound to provide better cache locality */
if (sgen_get_nursery_clear_policy () == CLEAR_AT_GC)
memset (frag_start, 0, frag_size);
+ else if (sgen_get_nursery_clear_policy () == CLEAR_AT_TLAB_CREATION_DEBUG)
+ memset (frag_start, 0xff, frag_size);
#ifdef NALLOC_DEBUG
/* XXX convert this into a flight record entry
}
mword
-sgen_build_nursery_fragments (GCMemSection *nursery_section, void **start, int num_entries)
+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;
- int i = 0;
+ size_t i = 0;
SgenFragment *frags_ranges;
#ifdef NALLOC_DEBUG
addr1 = frags_ranges->fragment_start;
if (addr0 < addr1) {
- SGEN_UNPIN_OBJECT (addr0);
+ 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));
sgen_minor_collector.build_fragments_finish (&mutator_allocator);
if (!unmask (mutator_allocator.alloc_head)) {
- SGEN_LOG (1, "Nursery fully pinned (%d)", num_entries);
+ 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: %d", start [i], sgen_safe_name (start [i]), sgen_safe_object_get_size (start [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;
sgen_can_alloc_size (size_t size)
{
SgenFragment *frag;
+
+ if (!SGEN_CAN_ALIGN_UP (size))
+ return FALSE;
+
size = SGEN_ALIGN_UP (size);
for (frag = unmask (mutator_allocator.alloc_head); frag; frag = unmask (frag->next)) {
- if ((frag->fragment_end - frag->fragment_next) >= size)
+ if ((size_t)(frag->fragment_end - frag->fragment_next) >= size)
return TRUE;
}
return FALSE;
void*
sgen_nursery_alloc (size_t size)
{
+ SGEN_ASSERT (1, size >= sizeof (MonoObject) && size <= SGEN_MAX_SMALL_OBJ_SIZE, "Invalid nursery object size");
+
SGEN_LOG (4, "Searching nursery for size: %zd", size);
size = SGEN_ALIGN_UP (size);
sgen_nursery_start = start;
sgen_nursery_end = end;
- sgen_space_bitmap_size = (end - start) / (SGEN_TO_SPACE_GRANULE_IN_BYTES * 8);
+ /*
+ * This will not divide evenly for tiny nurseries (<4kb), so we make sure to be on
+ * the right side of things and round up. We could just do a MIN(1,x) instead,
+ * since the nursery size must be a power of 2.
+ */
+ sgen_space_bitmap_size = (end - start + SGEN_TO_SPACE_GRANULE_IN_BYTES * 8 - 1) / (SGEN_TO_SPACE_GRANULE_IN_BYTES * 8);
sgen_space_bitmap = g_malloc0 (sgen_space_bitmap_size);
/* Setup the single first large fragment */