-/*
- * sgen-nursery-allocator.c: Nursery allocation code.
+/**
+ * \file
+ * Nursery allocation code.
*
* Copyright 2009-2010 Novell, Inc.
* 2011 Rodrigo Kumpera
* Copyright 2011 Xamarin Inc (http://www.xamarin.com)
* Copyright (C) 2012 Xamarin Inc
*
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License 2.0 as published by the Free Software Foundation;
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License 2.0 along with this library; if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
/*
char *sgen_nursery_start;
char *sgen_nursery_end;
-#ifdef USER_CONFIG
+/* good sizes are 512KB-1MB: larger ones increase a lot memzeroing time */
size_t sgen_nursery_size = (1 << 22);
+/* The number of trailing 0 bits in sgen_nursery_size */
int sgen_nursery_bits = 22;
-#endif
char *sgen_space_bitmap;
size_t sgen_space_bitmap_size;
frag->next = frag->next_in_order = NULL;
return frag;
}
- frag = sgen_alloc_internal (INTERNAL_MEM_FRAGMENT);
+ frag = (SgenFragment *)sgen_alloc_internal (INTERNAL_MEM_FRAGMENT);
frag->next = frag->next_in_order = NULL;
return frag;
}
fragment->fragment_start = start;
fragment->fragment_next = start;
fragment->fragment_end = end;
- fragment->next_in_order = fragment->next = unmask (allocator->region_head);
+ fragment->next_in_order = fragment->next = (SgenFragment *)unmask (allocator->region_head);
allocator->region_head = allocator->alloc_head = fragment;
g_assert (fragment->fragment_end > fragment->fragment_start);
printf ("retry count for fppf is %d\n", count);
#endif
- cur = unmask (*prev);
+ cur = (SgenFragment *)unmask (*prev);
while (1) {
if (cur == NULL)
return prev;
prev = &cur->next;
} else {
- next = unmask (next);
+ next = (SgenFragment *)unmask (next);
if (InterlockedCompareExchangePointer ((volatile gpointer*)prev, next, cur) != cur)
goto try_again;
/*we must make sure that the next from cur->next happens after*/
mono_memory_write_barrier ();
}
- cur = unmask (next);
+ cur = (SgenFragment *)unmask (next);
}
return NULL;
}
*/
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));
+ HEAVY_STAT (stat_wasted_bytes_trailer += frag->fragment_end - end);
#ifdef NALLOC_DEBUG
add_alloc_record (end, frag->fragment_end - end, BLOCK_ZEROING);
#endif
#endif
restart:
- for (frag = unmask (allocator->alloc_head); unmask (frag); frag = unmask (frag->next)) {
- HEAVY_STAT (InterlockedIncrement (&stat_alloc_iterations));
+ for (frag = (SgenFragment *)unmask (allocator->alloc_head); unmask (frag); frag = (SgenFragment *)unmask (frag->next)) {
+ HEAVY_STAT (++stat_alloc_iterations);
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));
+ HEAVY_STAT (++stat_alloc_retries);
goto restart;
}
#ifdef NALLOC_DEBUG
previous = &allocator->alloc_head;
for (frag = *previous; frag; frag = *previous) {
- char *p = serial_alloc_from_fragment (previous, frag, size);
+ char *p = (char *)serial_alloc_from_fragment (previous, frag, size);
- HEAVY_STAT (InterlockedIncrement (&stat_alloc_iterations));
+ HEAVY_STAT (++stat_alloc_iterations);
if (p) {
#ifdef NALLOC_DEBUG
for (frag = *previous; frag; frag = *previous) {
size_t frag_size = frag->fragment_end - frag->fragment_next;
- HEAVY_STAT (InterlockedIncrement (&stat_alloc_range_iterations));
+ HEAVY_STAT (++stat_alloc_range_iterations);
if (desired_size <= frag_size) {
void *p;
InterlockedIncrement (&alloc_count);
#endif
- for (frag = unmask (allocator->alloc_head); frag; frag = unmask (frag->next)) {
+ for (frag = (SgenFragment *)unmask (allocator->alloc_head); frag; frag = (SgenFragment *)unmask (frag->next)) {
size_t frag_size = frag->fragment_end - frag->fragment_next;
- HEAVY_STAT (InterlockedIncrement (&stat_alloc_range_iterations));
+ HEAVY_STAT (++stat_alloc_range_iterations);
if (desired_size <= frag_size) {
void *p;
p = par_alloc_from_fragment (allocator, frag, desired_size);
if (!p) {
- HEAVY_STAT (InterlockedIncrement (&stat_alloc_range_retries));
+ HEAVY_STAT (++stat_alloc_range_retries);
goto restart;
}
#ifdef NALLOC_DEBUG
/*XXX restarting here is quite dubious given this is already second chance allocation. */
if (!p) {
- HEAVY_STAT (InterlockedIncrement (&stat_alloc_retries));
+ HEAVY_STAT (++stat_alloc_retries);
goto restart;
}
#ifdef NALLOC_DEBUG
{
SgenFragment *frag;
- for (frag = unmask (allocator->alloc_head); frag; frag = unmask (frag->next)) {
+ for (frag = (SgenFragment *)unmask (allocator->alloc_head); frag; frag = (SgenFragment *)unmask (frag->next)) {
SGEN_LOG (4, "Clear nursery frag %p-%p", frag->fragment_next, frag->fragment_end);
sgen_clear_range (frag->fragment_next, frag->fragment_end);
#ifdef NALLOC_DEBUG
} else {
/* Clear unused fragments, pinning depends on this */
sgen_clear_range (frag_start, frag_end);
- HEAVY_STAT (InterlockedExchangeAdd (&stat_wasted_bytes_small_areas, frag_size));
+ HEAVY_STAT (stat_wasted_bytes_small_areas += frag_size);
}
}
addr0 = addr1 = sgen_nursery_end;
if (pin_entry < pin_end)
- addr0 = *pin_entry;
+ addr0 = (char *)*pin_entry;
if (frags_ranges)
addr1 = frags_ranges->fragment_start;
if (addr0 < addr1) {
if (unpin_queue)
- GRAY_OBJECT_ENQUEUE (unpin_queue, addr0, sgen_obj_get_descriptor_safe (addr0));
+ GRAY_OBJECT_ENQUEUE_SERIAL (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));
if (!unmask (mutator_allocator.alloc_head)) {
SGEN_LOG (1, "Nursery fully pinned");
for (pin_entry = pin_start; pin_entry < pin_end; ++pin_entry) {
- void *p = *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;
}
-char *
-sgen_nursery_alloc_get_upper_alloc_bound (void)
-{
- /*FIXME we need to calculate the collector upper bound as well, but this must be done in the previous GC. */
- return sgen_nursery_end;
-}
-
/*** Nursery memory allocation ***/
void
sgen_nursery_retire_region (void *address, ptrdiff_t size)
{
- HEAVY_STAT (InterlockedExchangeAdd (&stat_wasted_bytes_discarded_fragments, size));
+ HEAVY_STAT (stat_wasted_bytes_discarded_fragments += size);
}
gboolean
size = SGEN_ALIGN_UP (size);
- for (frag = unmask (mutator_allocator.alloc_head); frag; frag = unmask (frag->next)) {
+ for (frag = (SgenFragment *)unmask (mutator_allocator.alloc_head); frag; frag = (SgenFragment *)unmask (frag->next)) {
if ((size_t)(frag->fragment_end - frag->fragment_next) >= size)
return TRUE;
}
SGEN_LOG (4, "Searching nursery for size: %zd", size);
size = SGEN_ALIGN_UP (size);
- HEAVY_STAT (InterlockedIncrement (&stat_nursery_alloc_requests));
+ HEAVY_STAT (++stat_nursery_alloc_requests);
return sgen_fragment_allocator_par_alloc (&mutator_allocator, size);
}
{
SGEN_LOG (4, "Searching for byte range desired size: %zd minimum size %zd", desired_size, minimum_size);
- HEAVY_STAT (InterlockedIncrement (&stat_nursery_alloc_range_requests));
+ HEAVY_STAT (++stat_nursery_alloc_range_requests);
return sgen_fragment_allocator_par_range_alloc (&mutator_allocator, desired_size, minimum_size, out_alloc_size);
}
* 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);
+ sgen_space_bitmap = (char *)g_malloc0 (sgen_space_bitmap_size);
/* Setup the single first large fragment */
sgen_minor_collector.init_nursery (&mutator_allocator, start, end);
projects / mono.git / blobdiff