static void
initGeneration (generation *gen, int g)
{
gen->no = g;
gen->collections = 0;
gen->par_collections = 0;
gen->failed_promotions = 0;
gen->max_blocks = 0;
gen->blocks = NULL;
gen->n_blocks = 0;
gen->n_words = 0;
gen->live_estimate = 0;
gen->old_blocks = NULL;
gen->n_old_blocks = 0;
gen->large_objects = NULL;
gen->n_large_blocks = 0;
gen->n_large_words = 0;
gen->n_new_large_words = 0;
gen->scavenged_large_objects = NULL;
gen->n_scavenged_large_blocks = 0;
gen->mark = 0;
gen->compact = 0;
gen->bitmap = NULL;
#ifdef THREADED_RTS
initSpinLock(&gen->sync);
#endif
gen->threads = END_TSO_QUEUE;
gen->old_threads = END_TSO_QUEUE;
gen->weak_ptr_list = NULL;
gen->old_weak_ptr_list = NULL;
}
int initTime(void)
{
if(initHpet(timeInterrupt,TIMER_HZ))
if(initPit(timeInterrupt,TIMER_HZ))
return -ENODEV;
initList(&timers);
initSpinLock(&timerLock);
printkInColor(0x00,0xff,0x00,"Initialize time successfully!\n\n");
return 0;
}
void
initStorage (void)
{
nat g;
if (generations != NULL) {
// multi-init protection
return;
}
initMBlocks();
/* Sanity check to make sure the LOOKS_LIKE_ macros appear to be
* doing something reasonable.
*/
/* We use the NOT_NULL variant or gcc warns that the test is always true */
ASSERT(LOOKS_LIKE_INFO_PTR_NOT_NULL((StgWord)&stg_BLOCKING_QUEUE_CLEAN_info));
ASSERT(LOOKS_LIKE_CLOSURE_PTR(&stg_dummy_ret_closure));
ASSERT(!HEAP_ALLOCED(&stg_dummy_ret_closure));
if (RtsFlags.GcFlags.maxHeapSize != 0 &&
RtsFlags.GcFlags.heapSizeSuggestion >
RtsFlags.GcFlags.maxHeapSize) {
RtsFlags.GcFlags.maxHeapSize = RtsFlags.GcFlags.heapSizeSuggestion;
}
if (RtsFlags.GcFlags.maxHeapSize != 0 &&
RtsFlags.GcFlags.minAllocAreaSize >
RtsFlags.GcFlags.maxHeapSize) {
errorBelch("maximum heap size (-M) is smaller than minimum alloc area size (-A)");
RtsFlags.GcFlags.minAllocAreaSize = RtsFlags.GcFlags.maxHeapSize;
}
initBlockAllocator();
#if defined(THREADED_RTS)
initMutex(&sm_mutex);
#endif
ACQUIRE_SM_LOCK;
/* allocate generation info array */
generations = (generation *)stgMallocBytes(RtsFlags.GcFlags.generations
* sizeof(struct generation_),
"initStorage: gens");
/* Initialise all generations */
for(g = 0; g < RtsFlags.GcFlags.generations; g++) {
initGeneration(&generations[g], g);
}
/* A couple of convenience pointers */
g0 = &generations[0];
oldest_gen = &generations[RtsFlags.GcFlags.generations-1];
/* Set up the destination pointers in each younger gen. step */
for (g = 0; g < RtsFlags.GcFlags.generations-1; g++) {
generations[g].to = &generations[g+1];
}
oldest_gen->to = oldest_gen;
/* The oldest generation has one step. */
if (RtsFlags.GcFlags.compact || RtsFlags.GcFlags.sweep) {
if (RtsFlags.GcFlags.generations == 1) {
errorBelch("WARNING: compact/sweep is incompatible with -G1; disabled");
} else {
oldest_gen->mark = 1;
if (RtsFlags.GcFlags.compact)
oldest_gen->compact = 1;
}
}
generations[0].max_blocks = 0;
dyn_caf_list = (StgIndStatic*)END_OF_CAF_LIST;
debug_caf_list = (StgIndStatic*)END_OF_CAF_LIST;
revertible_caf_list = (StgIndStatic*)END_OF_CAF_LIST;
/* initialise the allocate() interface */
large_alloc_lim = RtsFlags.GcFlags.minAllocAreaSize * BLOCK_SIZE_W;
exec_block = NULL;
#ifdef THREADED_RTS
initSpinLock(&gc_alloc_block_sync);
#ifdef PROF_SPIN
whitehole_spin = 0;
#endif
#endif
N = 0;
next_nursery = 0;
storageAddCapabilities(0, n_capabilities);
IF_DEBUG(gc, statDescribeGens());
RELEASE_SM_LOCK;
traceEventHeapInfo(CAPSET_HEAP_DEFAULT,
RtsFlags.GcFlags.generations,
RtsFlags.GcFlags.maxHeapSize * BLOCK_SIZE_W * sizeof(W_),
RtsFlags.GcFlags.minAllocAreaSize * BLOCK_SIZE_W * sizeof(W_),
MBLOCK_SIZE_W * sizeof(W_),
BLOCK_SIZE_W * sizeof(W_));
}
void
initStorage( void )
{
nat g, n;
if (generations != NULL) {
// multi-init protection
return;
}
initMBlocks();
/* Sanity check to make sure the LOOKS_LIKE_ macros appear to be
* doing something reasonable.
*/
/* We use the NOT_NULL variant or gcc warns that the test is always true */
ASSERT(LOOKS_LIKE_INFO_PTR_NOT_NULL((StgWord)&stg_BLOCKING_QUEUE_CLEAN_info));
ASSERT(LOOKS_LIKE_CLOSURE_PTR(&stg_dummy_ret_closure));
ASSERT(!HEAP_ALLOCED(&stg_dummy_ret_closure));
if (RtsFlags.GcFlags.maxHeapSize != 0 &&
RtsFlags.GcFlags.heapSizeSuggestion >
RtsFlags.GcFlags.maxHeapSize) {
RtsFlags.GcFlags.maxHeapSize = RtsFlags.GcFlags.heapSizeSuggestion;
}
if (RtsFlags.GcFlags.maxHeapSize != 0 &&
RtsFlags.GcFlags.minAllocAreaSize >
RtsFlags.GcFlags.maxHeapSize) {
errorBelch("maximum heap size (-M) is smaller than minimum alloc area size (-A)");
RtsFlags.GcFlags.minAllocAreaSize = RtsFlags.GcFlags.maxHeapSize;
}
initBlockAllocator();
#if defined(THREADED_RTS)
initMutex(&sm_mutex);
#endif
ACQUIRE_SM_LOCK;
/* allocate generation info array */
generations = (generation *)stgMallocBytes(RtsFlags.GcFlags.generations
* sizeof(struct generation_),
"initStorage: gens");
/* Initialise all generations */
for(g = 0; g < RtsFlags.GcFlags.generations; g++) {
initGeneration(&generations[g], g);
}
/* A couple of convenience pointers */
g0 = &generations[0];
oldest_gen = &generations[RtsFlags.GcFlags.generations-1];
nurseries = stgMallocBytes(n_capabilities * sizeof(struct nursery_),
"initStorage: nurseries");
/* Set up the destination pointers in each younger gen. step */
for (g = 0; g < RtsFlags.GcFlags.generations-1; g++) {
generations[g].to = &generations[g+1];
}
oldest_gen->to = oldest_gen;
/* The oldest generation has one step. */
if (RtsFlags.GcFlags.compact || RtsFlags.GcFlags.sweep) {
if (RtsFlags.GcFlags.generations == 1) {
errorBelch("WARNING: compact/sweep is incompatible with -G1; disabled");
} else {
oldest_gen->mark = 1;
if (RtsFlags.GcFlags.compact)
oldest_gen->compact = 1;
}
}
generations[0].max_blocks = 0;
/* The allocation area. Policy: keep the allocation area
* small to begin with, even if we have a large suggested heap
* size. Reason: we're going to do a major collection first, and we
* don't want it to be a big one. This vague idea is borne out by
* rigorous experimental evidence.
*/
allocNurseries();
weak_ptr_list = NULL;
caf_list = END_OF_STATIC_LIST;
revertible_caf_list = END_OF_STATIC_LIST;
/* initialise the allocate() interface */
large_alloc_lim = RtsFlags.GcFlags.minAllocAreaSize * BLOCK_SIZE_W;
exec_block = NULL;
#ifdef THREADED_RTS
initSpinLock(&gc_alloc_block_sync);
whitehole_spin = 0;
#endif
N = 0;
// allocate a block for each mut list
for (n = 0; n < n_capabilities; n++) {
for (g = 1; g < RtsFlags.GcFlags.generations; g++) {
capabilities[n].mut_lists[g] = allocBlock();
}
}
initGcThreads();
IF_DEBUG(gc, statDescribeGens());
RELEASE_SM_LOCK;
}
