X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=rts%2FProfHeap.c;h=7d2a4501292177ba663db3c6d25ffdad10c2bdfb;hb=7d9eb2e45b4a9ff4cb053b1ec37602be88528b62;hp=f1a3b05ce49bc27be37b0565148bda562c67a5b2;hpb=61af839f961ea85dc80bed03313ee318fc02fa00;p=ghc-hetmet.git diff --git a/rts/ProfHeap.c b/rts/ProfHeap.c index f1a3b05..7d2a450 100644 --- a/rts/ProfHeap.c +++ b/rts/ProfHeap.c @@ -8,8 +8,8 @@ #include "PosixSource.h" #include "Rts.h" + #include "RtsUtils.h" -#include "RtsFlags.h" #include "Profiling.h" #include "ProfHeap.h" #include "Stats.h" @@ -18,10 +18,9 @@ #include "LdvProfile.h" #include "Arena.h" #include "Printer.h" +#include "sm/GCThread.h" #include -#include -#include /* ----------------------------------------------------------------------------- * era stores the current time period. It is the same as the @@ -95,93 +94,14 @@ static void aggregateCensusInfo( void ); static void dumpCensus( Census *census ); -/* ---------------------------------------------------------------------------- - Closure Type Profiling; - ------------------------------------------------------------------------- */ - -#ifndef PROFILING -static char *type_names[] = { - "INVALID_OBJECT", - "CONSTR", - "CONSTR_1_0", - "CONSTR_0_1", - "CONSTR_2_0", - "CONSTR_1_1", - "CONSTR_0_2", - "CONSTR_STATIC", - "CONSTR_NOCAF_STATIC", - "FUN", - "FUN_1_0", - "FUN_0_1", - "FUN_2_0", - "FUN_1_1", - "FUN_0_2", - "FUN_STATIC", - "THUNK", - "THUNK_1_0", - "THUNK_0_1", - "THUNK_2_0", - "THUNK_1_1", - "THUNK_0_2", - "THUNK_STATIC", - "THUNK_SELECTOR", - "BCO", - "AP", - "PAP", - "AP_STACK", - "IND", - "IND_OLDGEN", - "IND_PERM", - "IND_OLDGEN_PERM", - "IND_STATIC", - "RET_BCO", - "RET_SMALL", - "RET_BIG", - "RET_DYN", - "RET_FUN", - "UPDATE_FRAME", - "CATCH_FRAME", - "STOP_FRAME", - "CAF_BLACKHOLE", - "BLACKHOLE", - "SE_BLACKHOLE", - "SE_CAF_BLACKHOLE", - "MVAR", - "ARR_WORDS", - "MUT_ARR_PTRS_CLEAN", - "MUT_ARR_PTRS_DIRTY", - "MUT_ARR_PTRS_FROZEN0", - "MUT_ARR_PTRS_FROZEN", - "MUT_VAR_CLEAN", - "MUT_VAR_DIRTY", - "WEAK", - "STABLE_NAME", - "TSO", - "BLOCKED_FETCH", - "FETCH_ME", - "FETCH_ME_BQ", - "RBH", - "EVACUATED", - "REMOTE_REF", - "TVAR_WATCH_QUEUE", - "INVARIANT_CHECK_QUEUE", - "ATOMIC_INVARIANT", - "TVAR", - "TREC_CHUNK", - "TREC_HEADER", - "ATOMICALLY_FRAME", - "CATCH_RETRY_FRAME", - "CATCH_STM_FRAME", - "N_CLOSURE_TYPES" - }; -#endif +static rtsBool closureSatisfiesConstraints( StgClosure* p ); /* ---------------------------------------------------------------------------- * Find the "closure identity", which is a unique pointer reresenting * the band to which this closure's heap space is attributed in the * heap profile. * ------------------------------------------------------------------------- */ -STATIC_INLINE void * +static void * closureIdentity( StgClosure *p ) { switch (RtsFlags.ProfFlags.doHeapProfile) { @@ -217,10 +137,9 @@ closureIdentity( StgClosure *p ) case CONSTR_0_2: case CONSTR_STATIC: case CONSTR_NOCAF_STATIC: - printf("",strlen(GET_CON_DESC(itbl_to_con_itbl(info)))); return GET_CON_DESC(itbl_to_con_itbl(info)); default: - return type_names[info->type]; + return closure_type_names[info->type]; } } @@ -391,16 +310,31 @@ void initProfiling1 (void) { } -void freeProfiling1 (void) +void freeProfiling (void) { } void initProfiling2 (void) { + char *prog; + + prog = stgMallocBytes(strlen(prog_name) + 1, "initProfiling2"); + strcpy(prog, prog_name); +#ifdef mingw32_HOST_OS + // on Windows, drop the .exe suffix if there is one + { + char *suff; + suff = strrchr(prog,'.'); + if (suff != NULL && !strcmp(suff,".exe")) { + *suff = '\0'; + } + } +#endif + if (RtsFlags.ProfFlags.doHeapProfile) { /* Initialise the log file name */ - hp_filename = stgMallocBytes(strlen(prog_name) + 6, "hpFileName"); - sprintf(hp_filename, "%s.hp", prog_name); + hp_filename = stgMallocBytes(strlen(prog) + 6, "hpFileName"); + sprintf(hp_filename, "%s.hp", prog); /* open the log file */ if ((hp_file = fopen(hp_filename, "w")) == NULL) { @@ -411,6 +345,8 @@ void initProfiling2 (void) } } + stgFree(prog); + initHeapProfiling(); } @@ -458,12 +394,8 @@ initHeapProfiling(void) era = 0; } - { // max_era = 2^LDV_SHIFT - nat p; - max_era = 1; - for (p = 0; p < LDV_SHIFT; p++) - max_era *= 2; - } + // max_era = 2^LDV_SHIFT + max_era = 1 << LDV_SHIFT; n_censuses = 32; censuses = stgMallocBytes(sizeof(Census) * n_censuses, "initHeapProfiling"); @@ -604,7 +536,6 @@ fprint_ccs(FILE *fp, CostCentreStack *ccs, nat max_length) } fprintf(fp, "%s", buf); } -#endif /* PROFILING */ rtsBool strMatchesSelector( char* str, char* sel ) @@ -630,11 +561,13 @@ strMatchesSelector( char* str, char* sel ) } } +#endif /* PROFILING */ + /* ----------------------------------------------------------------------------- * Figure out whether a closure should be counted in this census, by * testing against all the specified constraints. * -------------------------------------------------------------------------- */ -rtsBool +static rtsBool closureSatisfiesConstraints( StgClosure* p ) { #if !defined(PROFILING) @@ -880,7 +813,7 @@ dumpCensus( Census *census ) rs->id = -(rs->id); // report in the unit of bytes: * sizeof(StgWord) - printRetainerSetShort(hp_file, rs); + printRetainerSetShort(hp_file, rs, RtsFlags.ProfFlags.ccsLength); break; } default: @@ -944,12 +877,8 @@ heapCensusChain( Census *census, bdescr *bd ) case CONSTR: case FUN: case IND_PERM: - case IND_OLDGEN: - case IND_OLDGEN_PERM: - case CAF_BLACKHOLE: - case SE_CAF_BLACKHOLE: - case SE_BLACKHOLE: case BLACKHOLE: + case BLOCKING_QUEUE: case FUN_1_0: case FUN_0_1: case FUN_1_1: @@ -979,9 +908,11 @@ heapCensusChain( Census *census, bdescr *bd ) size = bco_sizeW((StgBCO *)p); break; - case MVAR: + case MVAR_CLEAN: + case MVAR_DIRTY: case WEAK: - case STABLE_NAME: + case PRIM: + case MUT_PRIM: case MUT_VAR_CLEAN: case MUT_VAR_DIRTY: prim = rtsTrue; @@ -1002,7 +933,7 @@ heapCensusChain( Census *census, bdescr *bd ) case ARR_WORDS: prim = rtsTrue; - size = arr_words_sizeW(stgCast(StgArrWords*,p)); + size = arr_words_sizeW((StgArrWords*)p); break; case MUT_ARR_PTRS_CLEAN: @@ -1017,44 +948,35 @@ heapCensusChain( Census *census, bdescr *bd ) prim = rtsTrue; #ifdef PROFILING if (RtsFlags.ProfFlags.includeTSOs) { - size = tso_sizeW((StgTSO *)p); + size = sizeofW(StgTSO); break; } else { // Skip this TSO and move on to the next object - p += tso_sizeW((StgTSO *)p); + p += sizeofW(StgTSO); continue; } #else - size = tso_sizeW((StgTSO *)p); + size = sizeofW(StgTSO); break; #endif - case TREC_HEADER: + case STACK: prim = rtsTrue; - size = sizeofW(StgTRecHeader); +#ifdef PROFILING + if (RtsFlags.ProfFlags.includeTSOs) { + size = stack_sizeW((StgStack*)p); + break; + } else { + // Skip this TSO and move on to the next object + p += stack_sizeW((StgStack*)p); + continue; + } +#else + size = stack_sizeW((StgStack*)p); break; +#endif - case TVAR_WATCH_QUEUE: - prim = rtsTrue; - size = sizeofW(StgTVarWatchQueue); - break; - - case INVARIANT_CHECK_QUEUE: - prim = rtsTrue; - size = sizeofW(StgInvariantCheckQueue); - break; - - case ATOMIC_INVARIANT: - prim = rtsTrue; - size = sizeofW(StgAtomicInvariant); - break; - - case TVAR: - prim = rtsTrue; - size = sizeofW(StgTVar); - break; - - case TREC_CHUNK: + case TREC_CHUNK: prim = rtsTrue; size = sizeofW(StgTRecChunk); break; @@ -1136,8 +1058,9 @@ heapCensusChain( Census *census, bdescr *bd ) void heapCensus( void ) { - nat g, s; + nat g, n; Census *census; + gen_workspace *ws; census = &censuses[era]; census->time = mut_user_time(); @@ -1154,23 +1077,17 @@ heapCensus( void ) #endif // Traverse the heap, collecting the census info - - // First the small_alloc_list: we have to fix the free pointer at - // the end by calling tidyAllocatedLists() first. - tidyAllocateLists(); - heapCensusChain( census, small_alloc_list ); - - // Now traverse the heap in each generation/step. - if (RtsFlags.GcFlags.generations == 1) { - heapCensusChain( census, g0s0->blocks ); - } else { - for (g = 0; g < RtsFlags.GcFlags.generations; g++) { - for (s = 0; s < generations[g].n_steps; s++) { - heapCensusChain( census, generations[g].steps[s].blocks ); - // Are we interested in large objects? might be - // confusing to include the stack in a heap profile. - heapCensusChain( census, generations[g].steps[s].large_objects ); - } + for (g = 0; g < RtsFlags.GcFlags.generations; g++) { + heapCensusChain( census, generations[g].blocks ); + // Are we interested in large objects? might be + // confusing to include the stack in a heap profile. + heapCensusChain( census, generations[g].large_objects ); + + for (n = 0; n < n_capabilities; n++) { + ws = &gc_threads[n]->gens[g]; + heapCensusChain(census, ws->todo_bd); + heapCensusChain(census, ws->part_list); + heapCensusChain(census, ws->scavd_list); } }