#include "ProfHeap.h"
#include "Stats.h"
#include "Hash.h"
-#include "StrHash.h"
#include "RetainerProfile.h"
#include "LdvProfile.h"
#include "Arena.h"
, "ARR_WORDS"
- , "MUT_ARR_PTRS"
+ , "MUT_ARR_PTRS_CLEAN"
+ , "MUT_ARR_PTRS_DIRTY"
, "MUT_ARR_PTRS_FROZEN"
- , "MUT_VAR"
+ , "MUT_VAR_CLEAN"
+ , "MUT_VAR_DIRTY"
, "WEAK"
if (RtsFlags.ProfFlags.bioSelector == NULL) {
censuses[t].void_total += (int)size;
censuses[era].void_total -= (int)size;
+ ASSERT(censuses[t].void_total < censuses[t].not_used);
} else {
id = closureIdentity(c);
ctr = lookupHashTable(censuses[t].hash, (StgWord)id);
fractionalPart = modf(sampleValue, &integralPart);
fprintf(hp_file, "%s %d.%02d\n",
(beginSample ? "BEGIN_SAMPLE" : "END_SAMPLE"),
- (int)integralPart, (int)(fractionalPart * 100 + 0.5));
+ (int)integralPart, (int)(fractionalPart * 100));
}
/* --------------------------------------------------------------------------
#ifdef PROFILING
if (doingLDVProfiling() && doingRetainerProfiling()) {
errorBelch("cannot mix -hb and -hr");
- stg_exit(1);
+ stg_exit(EXIT_FAILURE);
}
#endif
fprint_ccs(FILE *fp, CostCentreStack *ccs, nat max_length)
{
char buf[max_length+1], *p, *buf_end;
- nat next_offset = 0;
- nat written;
// MAIN on its own gets printed as "MAIN", otherwise we ignore MAIN.
if (ccs == CCS_MAIN) {
if (p >= buf_end) {
sprintf(buf+max_length-4, "...");
break;
- } else {
- next_offset += written;
}
}
fprintf(fp, "%s", buf);
int void_total, drag_total;
// Now we compute void_total and drag_total for each census
+ // After the program has finished, the void_total field of
+ // each census contains the count of words that were *created*
+ // in this era and were eventually void. Conversely, if a
+ // void closure was destroyed in this era, it will be
+ // represented by a negative count of words in void_total.
+ //
+ // To get the count of live words that are void at each
+ // census, just propagate the void_total count forwards:
+
void_total = 0;
drag_total = 0;
for (t = 1; t < era; t++) { // note: start at 1, not 0
drag_total += censuses[t].drag_total;
censuses[t].void_total = void_total;
censuses[t].drag_total = drag_total;
+
ASSERT( censuses[t].void_total <= censuses[t].not_used );
+ // should be true because: void_total is the count of
+ // live words that are void at this census, which *must*
+ // be less than the number of live words that have not
+ // been used yet.
+
ASSERT( censuses[t].drag_total <= censuses[t].used );
+ // similar reasoning as above.
}
return;
case THUNK_1_1:
case THUNK_0_2:
case THUNK_2_0:
- size = sizeofW(StgHeader) + stg_max(MIN_UPD_SIZE,2);
+ size = sizeofW(StgThunkHeader) + 2;
break;
case THUNK_1_0:
case THUNK_0_1:
case THUNK_SELECTOR:
- size = sizeofW(StgHeader) + stg_max(MIN_UPD_SIZE,1);
+ size = sizeofW(StgThunkHeader) + 1;
break;
case CONSTR:
case CONSTR_2_0:
size = sizeW_fromITBL(info);
break;
-
+
+ case IND:
+ // Special case/Delicate Hack: INDs don't normally
+ // appear, since we're doing this heap census right
+ // after GC. However, GarbageCollect() also does
+ // resurrectThreads(), which can update some
+ // blackholes when it calls raiseAsync() on the
+ // resurrected threads. So we know that any IND will
+ // be the size of a BLACKHOLE.
+ size = BLACKHOLE_sizeW();
+ break;
+
case BCO:
prim = rtsTrue;
size = bco_sizeW((StgBCO *)p);
case MVAR:
case WEAK:
case STABLE_NAME:
- case MUT_VAR:
+ case MUT_VAR_CLEAN:
+ case MUT_VAR_DIRTY:
prim = rtsTrue;
size = sizeW_fromITBL(info);
break;
size = arr_words_sizeW(stgCast(StgArrWords*,p));
break;
- case MUT_ARR_PTRS:
+ case MUT_ARR_PTRS_CLEAN:
+ case MUT_ARR_PTRS_DIRTY:
case MUT_ARR_PTRS_FROZEN:
case MUT_ARR_PTRS_FROZEN0:
prim = rtsTrue;
}
#endif
+ case TREC_HEADER:
+ prim = rtsTrue;
+ size = sizeofW(StgTRecHeader);
+ break;
+
+ case TVAR_WAIT_QUEUE:
+ prim = rtsTrue;
+ size = sizeofW(StgTVarWaitQueue);
+ break;
+
+ case TVAR:
+ prim = rtsTrue;
+ size = sizeofW(StgTVar);
+ break;
+
+ case TREC_CHUNK:
+ prim = rtsTrue;
+ size = sizeofW(StgTRecChunk);
+ break;
+
default:
- barf("heapCensus");
+ barf("heapCensus, unknown object: %d", info->type);
}
identity = NULL;