static void*
major_alloc_heap (mword nursery_size, mword nursery_align, int the_nursery_bits)
{
char *heap_start;
mword major_heap_size = ms_heap_num_blocks * MS_BLOCK_SIZE;
mword alloc_size = nursery_size + major_heap_size;
int i;
g_assert (ms_heap_num_blocks > 0);
g_assert (nursery_size % MS_BLOCK_SIZE == 0);
if (nursery_align)
g_assert (nursery_align % MS_BLOCK_SIZE == 0);
nursery_start = mono_sgen_alloc_os_memory_aligned (alloc_size, nursery_align ? nursery_align : MS_BLOCK_SIZE, TRUE);
nursery_end = heap_start = nursery_start + nursery_size;
nursery_bits = the_nursery_bits;
ms_heap_end = heap_start + major_heap_size;
block_infos = mono_sgen_alloc_internal_dynamic (sizeof (MSBlockInfo) * ms_heap_num_blocks, INTERNAL_MEM_MS_BLOCK_INFO);
for (i = 0; i < ms_heap_num_blocks; ++i) {
block_infos [i].block = heap_start + i * MS_BLOCK_SIZE;
if (i < ms_heap_num_blocks - 1)
block_infos [i].next_free = &block_infos [i + 1];
else
block_infos [i].next_free = NULL;
}
empty_blocks = &block_infos [0];
return nursery_start;
}
/*
* Allocate a new section of memory to be used as old generation.
*/
static GCMemSection*
alloc_major_section (void)
{
GCMemSection *section;
int scan_starts;
section = mono_sgen_alloc_os_memory_aligned (MAJOR_SECTION_SIZE, MAJOR_SECTION_SIZE, TRUE);
section->next_data = section->data = (char*)section + SGEN_SIZEOF_GC_MEM_SECTION;
g_assert (!((mword)section->data & 7));
section->size = MAJOR_SECTION_SIZE - SGEN_SIZEOF_GC_MEM_SECTION;
section->end_data = section->data + section->size;
mono_sgen_update_heap_boundaries ((mword)section->data, (mword)section->end_data);
DEBUG (3, fprintf (gc_debug_file, "New major heap section: (%p-%p), total: %ld\n", section->data, section->end_data, mono_gc_get_heap_size ()));
scan_starts = (section->size + SGEN_SCAN_START_SIZE - 1) / SGEN_SCAN_START_SIZE;
section->scan_starts = mono_sgen_alloc_internal_dynamic (sizeof (char*) * scan_starts, INTERNAL_MEM_SCAN_STARTS);
section->num_scan_start = scan_starts;
section->block.role = MEMORY_ROLE_GEN1;
section->is_to_space = TRUE;
/* add to the section list */
section->block.next = section_list;
section_list = section;
++num_major_sections;
return section;
}
static gpointer
alloc_sb (Descriptor *desc)
{
gpointer sb_header = mono_sgen_alloc_os_memory_aligned (SB_SIZE, SB_SIZE, TRUE);
g_assert (sb_header == SB_HEADER_FOR_ADDR (sb_header));
DESCRIPTOR_FOR_ADDR (sb_header) = desc;
//g_print ("sb %p for %p\n", sb_header, desc);
return (char*)sb_header + SB_HEADER_SIZE;
}
static void*
major_alloc_heap (mword nursery_size, mword nursery_align, int the_nursery_bits)
{
if (nursery_align)
nursery_start = mono_sgen_alloc_os_memory_aligned (nursery_size, nursery_align, TRUE);
else
nursery_start = mono_sgen_alloc_os_memory (nursery_size, TRUE);
nursery_end = nursery_start + nursery_size;
nursery_bits = the_nursery_bits;
return nursery_start;
}
static void*
ms_get_empty_block (void)
{
char *p;
int i;
void *block, *empty, *next;
retry:
if (!empty_blocks) {
p = mono_sgen_alloc_os_memory_aligned (MS_BLOCK_SIZE * MS_BLOCK_ALLOC_NUM, MS_BLOCK_SIZE, TRUE);
for (i = 0; i < MS_BLOCK_ALLOC_NUM; ++i) {
block = p;
/*
* We do the free list update one after the
* other so that other threads can use the new
* blocks as quickly as possible.
*/
do {
empty = empty_blocks;
*(void**)block = empty;
} while (SGEN_CAS_PTR (&empty_blocks, block, empty) != empty);
p += MS_BLOCK_SIZE;
}
SGEN_ATOMIC_ADD (num_empty_blocks, MS_BLOCK_ALLOC_NUM);
stat_major_blocks_alloced += MS_BLOCK_ALLOC_NUM;
}
do {
empty = empty_blocks;
if (!empty)
goto retry;
block = empty;
next = *(void**)block;
} while (SGEN_CAS_PTR (&empty_blocks, next, empty) != empty);
SGEN_ATOMIC_ADD (num_empty_blocks, -1);
*(void**)block = NULL;
g_assert (!((mword)block & (MS_BLOCK_SIZE - 1)));
mono_sgen_update_heap_boundaries ((mword)block, (mword)block + MS_BLOCK_SIZE);
return block;
}
static SgenPinnedChunk*
alloc_pinned_chunk (SgenPinnedAllocator *alc)
{
SgenPinnedChunk *chunk;
int offset;
int size = SGEN_PINNED_CHUNK_SIZE;
chunk = mono_sgen_alloc_os_memory_aligned (size, size, TRUE);
chunk->block.role = MEMORY_ROLE_PINNED;
mono_sgen_update_heap_boundaries ((mword)chunk, ((mword)chunk + size));
pinned_chunk_bytes_alloced += size;
/* setup the bookeeping fields */
chunk->num_pages = size / FREELIST_PAGESIZE;
offset = G_STRUCT_OFFSET (SgenPinnedChunk, data);
chunk->page_sizes = (void*)((char*)chunk + offset);
offset += sizeof (int) * chunk->num_pages;
offset = SGEN_ALIGN_UP (offset);
chunk->free_list = (void*)((char*)chunk + offset);
offset += sizeof (void*) * SGEN_PINNED_FREELIST_NUM_SLOTS;
offset = SGEN_ALIGN_UP (offset);
chunk->start_data = (void*)((char*)chunk + offset);
/* allocate the first page to the freelist */
chunk->page_sizes [0] = PINNED_FIRST_SLOT_SIZE;
build_freelist (alc, chunk, slot_for_size (PINNED_FIRST_SLOT_SIZE), PINNED_FIRST_SLOT_SIZE,
chunk->start_data, ((char*)chunk + FREELIST_PAGESIZE));
mono_sgen_debug_printf (4, "Allocated pinned chunk %p, size: %d\n", chunk, size);
chunk->block.next = alc->chunk_list;
alc->chunk_list = chunk;
chunk->allocator = alc;
return chunk;
}
