1 /* -----------------------------------------------------------------------------
3 * (c) The GHC Team, 1998-2000
5 * Support for profiling
7 * ---------------------------------------------------------------------------*/
11 #include "PosixSource.h"
15 #include "Profiling.h"
16 #include "Proftimer.h"
20 #include "RetainerProfile.h"
21 #include "LdvProfile.h"
30 * Profiling allocation arena.
35 * Global variables used to assign unique IDs to cc's, ccs's, and
43 /* figures for the profiling report.
45 static ullong total_alloc;
46 static lnat total_prof_ticks;
48 /* Globals for opening the profiling log file(s)
50 static char *prof_filename; /* prof report file name = <program>.prof */
53 static char *hp_filename; /* heap profile (hp2ps style) log file */
56 /* The Current Cost Centre Stack (for attributing costs)
58 CostCentreStack *CCCS;
60 /* Linked lists to keep track of cc's and ccs's that haven't
61 * been declared in the log file yet
64 CostCentreStack *CCS_LIST;
67 * Built-in cost centres and cost-centre stacks:
69 * MAIN is the root of the cost-centre stack tree. If there are
70 * no _scc_s in the program, all costs will be attributed
73 * SYSTEM is the RTS in general (scheduler, etc.). All costs for
74 * RTS operations apart from garbage collection are attributed
77 * GC is the storage manager / garbage collector.
79 * OVERHEAD gets all costs generated by the profiling system
80 * itself. These are costs that would not be incurred
81 * during non-profiled execution of the program.
83 * SUBSUMED is the one-and-only CCS placed on top-level functions.
84 * It indicates that all costs are to be attributed to the
85 * enclosing cost centre stack. SUBSUMED never accumulates
86 * any costs. The is_caf flag is set on the subsumed cost
89 * DONT_CARE is a placeholder cost-centre we assign to static
90 * constructors. It should *never* accumulate any costs.
93 CC_DECLARE(CC_MAIN, "MAIN", "MAIN", CC_IS_BORING, );
94 CC_DECLARE(CC_SYSTEM, "SYSTEM", "MAIN", CC_IS_BORING, );
95 CC_DECLARE(CC_GC, "GC", "GC", CC_IS_BORING, );
96 CC_DECLARE(CC_OVERHEAD, "OVERHEAD_of", "PROFILING", CC_IS_CAF, );
97 CC_DECLARE(CC_SUBSUMED, "SUBSUMED", "MAIN", CC_IS_CAF, );
98 CC_DECLARE(CC_DONT_CARE, "DONT_CARE", "MAIN", CC_IS_BORING, );
100 CCS_DECLARE(CCS_MAIN, CC_MAIN, );
101 CCS_DECLARE(CCS_SYSTEM, CC_SYSTEM, );
102 CCS_DECLARE(CCS_GC, CC_GC, );
103 CCS_DECLARE(CCS_OVERHEAD, CC_OVERHEAD, );
104 CCS_DECLARE(CCS_SUBSUMED, CC_SUBSUMED, );
105 CCS_DECLARE(CCS_DONT_CARE, CC_DONT_CARE, );
108 * Uniques for the XML log-file format
113 #define HEAP_OBJ_UQ 4
114 #define TIME_UPD_UQ 5
115 #define HEAP_UPD_UQ 6
121 static CostCentreStack * ActualPush_ ( CostCentreStack *ccs, CostCentre *cc,
122 CostCentreStack *new_ccs );
123 static rtsBool ccs_to_ignore ( CostCentreStack *ccs );
124 static void count_ticks ( CostCentreStack *ccs );
125 static void inherit_costs ( CostCentreStack *ccs );
126 static void reportCCS ( CostCentreStack *ccs, nat indent );
127 static void DecCCS ( CostCentreStack *ccs );
128 static void DecBackEdge ( CostCentreStack *ccs,
129 CostCentreStack *oldccs );
130 static CostCentreStack * CheckLoop ( CostCentreStack *ccs, CostCentre *cc );
131 static CostCentreStack * pruneCCSTree ( CostCentreStack *ccs );
132 static CostCentreStack * ActualPush ( CostCentreStack *, CostCentre * );
133 static CostCentreStack * IsInIndexTable ( IndexTable *, CostCentre * );
134 static IndexTable * AddToIndexTable ( IndexTable *, CostCentreStack *,
135 CostCentre *, unsigned int );
136 static void ccsSetSelected ( CostCentreStack *ccs );
138 static void initTimeProfiling ( void );
139 static void initProfilingLogFile( void );
141 static void reportCCS_XML ( CostCentreStack *ccs );
143 /* -----------------------------------------------------------------------------
144 Initialise the profiling environment
145 -------------------------------------------------------------------------- */
148 initProfiling1 (void)
150 // initialise our arena
151 prof_arena = newArena();
153 /* for the benefit of allocate()... */
156 /* Initialize counters for IDs */
161 /* Initialize Declaration lists to NULL */
165 /* Register all the cost centres / stacks in the program
166 * CC_MAIN gets link = 0, all others have non-zero link.
168 REGISTER_CC(CC_MAIN);
169 REGISTER_CC(CC_SYSTEM);
171 REGISTER_CC(CC_OVERHEAD);
172 REGISTER_CC(CC_SUBSUMED);
173 REGISTER_CC(CC_DONT_CARE);
174 REGISTER_CCS(CCS_MAIN);
175 REGISTER_CCS(CCS_SYSTEM);
176 REGISTER_CCS(CCS_GC);
177 REGISTER_CCS(CCS_OVERHEAD);
178 REGISTER_CCS(CCS_SUBSUMED);
179 REGISTER_CCS(CCS_DONT_CARE);
183 /* cost centres are registered by the per-module
184 * initialisation code now...
189 freeProfiling1 (void)
191 arenaFree(prof_arena);
195 initProfiling2 (void)
197 CostCentreStack *ccs, *next;
201 /* Set up the log file, and dump the header and cost centre
202 * information into it. */
203 initProfilingLogFile();
205 /* find all the "special" cost centre stacks, and make them children
208 ASSERT(CCS_MAIN->prevStack == 0);
209 CCS_MAIN->root = CC_MAIN;
210 ccsSetSelected(CCS_MAIN);
213 for (ccs = CCS_LIST; ccs != CCS_MAIN; ) {
214 next = ccs->prevStack;
216 ActualPush_(CCS_MAIN,ccs->cc,ccs);
221 if (RtsFlags.CcFlags.doCostCentres) {
225 if (RtsFlags.ProfFlags.doHeapProfile) {
230 // Decide whether closures with this CCS should contribute to the heap
233 ccsSetSelected( CostCentreStack *ccs )
235 if (RtsFlags.ProfFlags.modSelector) {
236 if (! strMatchesSelector( ccs->cc->module,
237 RtsFlags.ProfFlags.modSelector ) ) {
242 if (RtsFlags.ProfFlags.ccSelector) {
243 if (! strMatchesSelector( ccs->cc->label,
244 RtsFlags.ProfFlags.ccSelector ) ) {
249 if (RtsFlags.ProfFlags.ccsSelector) {
251 for (c = ccs; c != NULL; c = c->prevStack) {
252 if ( strMatchesSelector( c->cc->label,
253 RtsFlags.ProfFlags.ccsSelector )) {
269 initProfilingLogFile(void)
271 if (RtsFlags.CcFlags.doCostCentres == 0 &&
272 RtsFlags.ProfFlags.doHeapProfile != HEAP_BY_RETAINER)
274 /* No need for the <prog>.prof file */
275 prof_filename = NULL;
280 /* Initialise the log file name */
281 prof_filename = arenaAlloc(prof_arena, strlen(prog_name) + 6);
282 sprintf(prof_filename, "%s.prof", prog_name);
284 /* open the log file */
285 if ((prof_file = fopen(prof_filename, "w")) == NULL) {
286 debugBelch("Can't open profiling report file %s\n", prof_filename);
287 RtsFlags.CcFlags.doCostCentres = 0;
288 // The following line was added by Sung; retainer/LDV profiling may need
289 // two output files, i.e., <program>.prof/hp.
290 if (RtsFlags.ProfFlags.doHeapProfile == HEAP_BY_RETAINER)
291 RtsFlags.ProfFlags.doHeapProfile = 0;
295 if (RtsFlags.CcFlags.doCostCentres == COST_CENTRES_XML) {
296 /* dump the time, and the profiling interval */
297 fprintf(prof_file, "\"%s\"\n", time_str());
298 fprintf(prof_file, "\"%d ms\"\n", RtsFlags.MiscFlags.tickInterval);
300 /* declare all the cost centres */
303 for (cc = CC_LIST; cc != NULL; cc = cc->link) {
304 fprintf(prof_file, "%d %ld \"%s\" \"%s\"\n",
305 CC_UQ, cc->ccID, cc->label, cc->module);
311 if (RtsFlags.ProfFlags.doHeapProfile) {
312 /* Initialise the log file name */
313 hp_filename = arenaAlloc(prof_arena, strlen(prog_name) + 6);
314 sprintf(hp_filename, "%s.hp", prog_name);
316 /* open the log file */
317 if ((hp_file = fopen(hp_filename, "w")) == NULL) {
318 debugBelch("Can't open profiling report file %s\n",
320 RtsFlags.ProfFlags.doHeapProfile = 0;
327 initTimeProfiling(void)
334 endProfiling ( void )
336 if (RtsFlags.CcFlags.doCostCentres) {
339 if (RtsFlags.ProfFlags.doHeapProfile) {
344 /* -----------------------------------------------------------------------------
345 Set cost centre stack when entering a function.
346 -------------------------------------------------------------------------- */
347 rtsBool entering_PAP;
350 EnterFunCCS ( CostCentreStack *ccsfn )
352 /* PAP_entry has already set CCCS for us */
354 entering_PAP = rtsFalse;
358 if (ccsfn->root->is_caf == CC_IS_CAF) {
359 CCCS = AppendCCS(CCCS,ccsfn);
365 /* -----------------------------------------------------------------------------
366 Cost-centre stack manipulation
367 -------------------------------------------------------------------------- */
370 CostCentreStack * _PushCostCentre ( CostCentreStack *ccs, CostCentre *cc );
372 PushCostCentre ( CostCentreStack *ccs, CostCentre *cc )
373 #define PushCostCentre _PushCostCentre
376 traceBegin("pushing %s on ", cc->label);
380 return PushCostCentre(ccs,cc);
385 PushCostCentre ( CostCentreStack *ccs, CostCentre *cc )
387 CostCentreStack *temp_ccs;
389 if (ccs == EMPTY_STACK)
390 return ActualPush(ccs,cc);
395 /* check if we've already memoized this stack */
396 temp_ccs = IsInIndexTable(ccs->indexTable,cc);
398 if (temp_ccs != EMPTY_STACK)
401 temp_ccs = CheckLoop(ccs,cc);
402 if (temp_ccs != NULL) {
403 /* we have recursed to an older CCS. Mark this in
404 * the index table, and emit a "back edge" into the
407 ccs->indexTable = AddToIndexTable(ccs->indexTable,temp_ccs,cc,1);
408 DecBackEdge(temp_ccs,ccs);
411 return ActualPush(ccs,cc);
418 static CostCentreStack *
419 CheckLoop ( CostCentreStack *ccs, CostCentre *cc )
421 while (ccs != EMPTY_STACK) {
424 ccs = ccs->prevStack;
429 /* Append ccs1 to ccs2 (ignoring any CAF cost centre at the root of ccs1 */
432 CostCentreStack *_AppendCCS ( CostCentreStack *ccs1, CostCentreStack *ccs2 );
434 AppendCCS ( CostCentreStack *ccs1, CostCentreStack *ccs2 )
435 #define AppendCCS _AppendCCS
439 debugBelch("Appending ");
444 return AppendCCS(ccs1,ccs2);
449 AppendCCS ( CostCentreStack *ccs1, CostCentreStack *ccs2 )
451 CostCentreStack *ccs = NULL;
457 if (ccs2->cc->is_caf == CC_IS_CAF) {
461 if (ccs2->prevStack != NULL) {
462 ccs = AppendCCS(ccs1, ccs2->prevStack);
465 return PushCostCentre(ccs,ccs2->cc);
468 static CostCentreStack *
469 ActualPush ( CostCentreStack *ccs, CostCentre *cc )
471 CostCentreStack *new_ccs;
473 /* allocate space for a new CostCentreStack */
474 new_ccs = (CostCentreStack *) arenaAlloc(prof_arena, sizeof(CostCentreStack));
476 return ActualPush_(ccs, cc, new_ccs);
479 static CostCentreStack *
480 ActualPush_ ( CostCentreStack *ccs, CostCentre *cc, CostCentreStack *new_ccs )
482 /* assign values to each member of the structure */
483 new_ccs->ccsID = CCS_ID++;
485 new_ccs->prevStack = ccs;
487 new_ccs->indexTable = EMPTY_TABLE;
489 /* Initialise the various _scc_ counters to zero
491 new_ccs->scc_count = 0;
493 /* Initialize all other stats here. There should be a quick way
494 * that's easily used elsewhere too
496 new_ccs->time_ticks = 0;
497 new_ccs->mem_alloc = 0;
498 new_ccs->inherited_ticks = 0;
499 new_ccs->inherited_alloc = 0;
501 new_ccs->root = ccs->root;
503 // Set the selected field.
504 ccsSetSelected(new_ccs);
506 /* update the memoization table for the parent stack */
507 if (ccs != EMPTY_STACK)
508 ccs->indexTable = AddToIndexTable(ccs->indexTable, new_ccs, cc,
509 0/*not a back edge*/);
511 /* make sure this CC is declared at the next heap/time sample */
514 /* return a pointer to the new stack */
519 static CostCentreStack *
520 IsInIndexTable(IndexTable *it, CostCentre *cc)
522 while (it!=EMPTY_TABLE)
530 /* otherwise we never found it so return EMPTY_TABLE */
536 AddToIndexTable(IndexTable *it, CostCentreStack *new_ccs,
537 CostCentre *cc, unsigned int back_edge)
541 new_it = arenaAlloc(prof_arena, sizeof(IndexTable));
544 new_it->ccs = new_ccs;
546 new_it->back_edge = back_edge;
552 DecCCS(CostCentreStack *ccs)
554 if (prof_file && RtsFlags.CcFlags.doCostCentres == COST_CENTRES_XML) {
555 if (ccs->prevStack == EMPTY_STACK)
556 fprintf(prof_file, "%d %ld 1 %ld\n", CCS_UQ,
557 ccs->ccsID, ccs->cc->ccID);
559 fprintf(prof_file, "%d %ld 2 %ld %ld\n", CCS_UQ,
560 ccs->ccsID, ccs->cc->ccID, ccs->prevStack->ccsID);
565 DecBackEdge( CostCentreStack *ccs, CostCentreStack *oldccs )
567 if (prof_file && RtsFlags.CcFlags.doCostCentres == COST_CENTRES_XML) {
568 if (ccs->prevStack == EMPTY_STACK)
569 fprintf(prof_file, "%d %ld 1 %ld\n", CCS_UQ,
570 ccs->ccsID, ccs->cc->ccID);
572 fprintf(prof_file, "%d %ld 2 %ld %ld\n", CCS_UQ,
573 ccs->ccsID, ccs->cc->ccID, oldccs->ccsID);
577 /* -----------------------------------------------------------------------------
578 Generating a time & allocation profiling report.
579 -------------------------------------------------------------------------- */
581 /* We omit certain system-related CCs and CCSs from the default
582 * reports, so as not to cause confusion.
585 cc_to_ignore (CostCentre *cc)
587 if ( cc == CC_OVERHEAD
588 || cc == CC_DONT_CARE
590 || cc == CC_SYSTEM) {
598 ccs_to_ignore (CostCentreStack *ccs)
600 if ( ccs == CCS_OVERHEAD
601 || ccs == CCS_DONT_CARE
603 || ccs == CCS_SYSTEM) {
610 /* -----------------------------------------------------------------------------
611 Generating the aggregated per-cost-centre time/alloc report.
612 -------------------------------------------------------------------------- */
614 static CostCentre *sorted_cc_list;
617 aggregate_cc_costs( CostCentreStack *ccs )
621 ccs->cc->mem_alloc += ccs->mem_alloc;
622 ccs->cc->time_ticks += ccs->time_ticks;
624 for (i = ccs->indexTable; i != 0; i = i->next) {
626 aggregate_cc_costs(i->ccs);
632 insert_cc_in_sorted_list( CostCentre *new_cc )
634 CostCentre **prev, *cc;
636 prev = &sorted_cc_list;
637 for (cc = sorted_cc_list; cc != NULL; cc = cc->link) {
638 if (new_cc->time_ticks > cc->time_ticks) {
651 report_per_cc_costs( void )
653 CostCentre *cc, *next;
655 aggregate_cc_costs(CCS_MAIN);
656 sorted_cc_list = NULL;
658 for (cc = CC_LIST; cc != NULL; cc = next) {
660 if (cc->time_ticks > total_prof_ticks/100
661 || cc->mem_alloc > total_alloc/100
662 || RtsFlags.CcFlags.doCostCentres >= COST_CENTRES_ALL) {
663 insert_cc_in_sorted_list(cc);
667 fprintf(prof_file, "%-30s %-20s", "COST CENTRE", "MODULE");
668 fprintf(prof_file, "%6s %6s", "%time", "%alloc");
669 if (RtsFlags.CcFlags.doCostCentres >= COST_CENTRES_VERBOSE) {
670 fprintf(prof_file, " %5s %9s", "ticks", "bytes");
672 fprintf(prof_file, "\n\n");
674 for (cc = sorted_cc_list; cc != NULL; cc = cc->link) {
675 if (cc_to_ignore(cc)) {
678 fprintf(prof_file, "%-30s %-20s", cc->label, cc->module);
679 fprintf(prof_file, "%6.1f %6.1f",
680 total_prof_ticks == 0 ? 0.0 : (cc->time_ticks / (StgFloat) total_prof_ticks * 100),
681 total_alloc == 0 ? 0.0 : (cc->mem_alloc / (StgFloat)
685 if (RtsFlags.CcFlags.doCostCentres >= COST_CENTRES_VERBOSE) {
686 fprintf(prof_file, " %5" FMT_Word64 " %9" FMT_Word64,
687 (StgWord64)(cc->time_ticks), cc->mem_alloc);
689 fprintf(prof_file, "\n");
692 fprintf(prof_file,"\n\n");
695 /* -----------------------------------------------------------------------------
696 Generate the cost-centre-stack time/alloc report
697 -------------------------------------------------------------------------- */
700 fprint_header( void )
702 fprintf(prof_file, "%-24s %-10s individual inherited\n", "", "");
704 fprintf(prof_file, "%-24s %-50s", "COST CENTRE", "MODULE");
705 fprintf(prof_file, "%6s %10s %5s %5s %5s %5s", "no.", "entries", "%time", "%alloc", "%time", "%alloc");
707 if (RtsFlags.CcFlags.doCostCentres >= COST_CENTRES_VERBOSE) {
708 fprintf(prof_file, " %5s %9s", "ticks", "bytes");
709 #if defined(PROFILING_DETAIL_COUNTS)
710 fprintf(prof_file, " %8s %8s %8s %8s %8s %8s %8s",
711 "closures", "thunks", "funcs", "PAPs", "subfuns", "subcafs", "cafssub");
715 fprintf(prof_file, "\n\n");
719 reportCCSProfiling( void )
722 char temp[128]; /* sigh: magic constant */
726 total_prof_ticks = 0;
728 count_ticks(CCS_MAIN);
730 switch (RtsFlags.CcFlags.doCostCentres) {
733 case COST_CENTRES_XML:
740 fprintf(prof_file, "\t%s Time and Allocation Profiling Report (%s)\n",
741 time_str(), "Final");
743 fprintf(prof_file, "\n\t ");
744 fprintf(prof_file, " %s", prog_name);
745 fprintf(prof_file, " +RTS");
746 for (count = 0; rts_argv[count]; count++)
747 fprintf(prof_file, " %s", rts_argv[count]);
748 fprintf(prof_file, " -RTS");
749 for (count = 1; prog_argv[count]; count++)
750 fprintf(prof_file, " %s", prog_argv[count]);
751 fprintf(prof_file, "\n\n");
753 fprintf(prof_file, "\ttotal time = %11.2f secs (%lu ticks @ %d ms)\n",
754 (double) total_prof_ticks *
755 (double) RtsFlags.MiscFlags.tickInterval / 1000,
756 (unsigned long) total_prof_ticks,
757 (int) RtsFlags.MiscFlags.tickInterval);
759 fprintf(prof_file, "\ttotal alloc = %11s bytes",
760 ullong_format_string(total_alloc * sizeof(W_),
761 temp, rtsTrue/*commas*/));
763 #if defined(PROFILING_DETAIL_COUNTS)
764 fprintf(prof_file, " (%lu closures)", total_allocs);
766 fprintf(prof_file, " (excludes profiling overheads)\n\n");
768 report_per_cc_costs();
770 inherit_costs(CCS_MAIN);
773 reportCCS(pruneCCSTree(CCS_MAIN), 0);
777 reportCCS(CostCentreStack *ccs, nat indent)
784 /* Only print cost centres with non 0 data ! */
786 if ( RtsFlags.CcFlags.doCostCentres >= COST_CENTRES_ALL ||
787 ! ccs_to_ignore(ccs))
788 /* force printing of *all* cost centres if -P -P */
791 fprintf(prof_file, "%-*s%-*s %-50s",
792 indent, "", 24-indent, cc->label, cc->module);
794 fprintf(prof_file, "%6ld %11.0f %5.1f %5.1f %5.1f %5.1f",
795 ccs->ccsID, (double) ccs->scc_count,
796 total_prof_ticks == 0 ? 0.0 : ((double)ccs->time_ticks / (double)total_prof_ticks * 100.0),
797 total_alloc == 0 ? 0.0 : ((double)ccs->mem_alloc / (double)total_alloc * 100.0),
798 total_prof_ticks == 0 ? 0.0 : ((double)ccs->inherited_ticks / (double)total_prof_ticks * 100.0),
799 total_alloc == 0 ? 0.0 : ((double)ccs->inherited_alloc / (double)total_alloc * 100.0)
802 if (RtsFlags.CcFlags.doCostCentres >= COST_CENTRES_VERBOSE) {
803 fprintf(prof_file, " %5" FMT_Word64 " %9" FMT_Word64,
804 (StgWord64)(ccs->time_ticks), ccs->mem_alloc*sizeof(W_));
805 #if defined(PROFILING_DETAIL_COUNTS)
806 fprintf(prof_file, " %8ld %8ld %8ld %8ld %8ld %8ld %8ld",
807 ccs->mem_allocs, ccs->thunk_count,
808 ccs->function_count, ccs->pap_count,
809 ccs->subsumed_fun_count, ccs->subsumed_caf_count,
810 ccs->caffun_subsumed);
813 fprintf(prof_file, "\n");
816 for (i = ccs->indexTable; i != 0; i = i->next) {
818 reportCCS(i->ccs, indent+1);
824 /* Traverse the cost centre stack tree and accumulate
828 count_ticks(CostCentreStack *ccs)
832 if (!ccs_to_ignore(ccs)) {
833 total_alloc += ccs->mem_alloc;
834 total_prof_ticks += ccs->time_ticks;
836 for (i = ccs->indexTable; i != NULL; i = i->next)
842 /* Traverse the cost centre stack tree and inherit ticks & allocs.
845 inherit_costs(CostCentreStack *ccs)
849 if (ccs_to_ignore(ccs)) { return; }
851 ccs->inherited_ticks += ccs->time_ticks;
852 ccs->inherited_alloc += ccs->mem_alloc;
854 for (i = ccs->indexTable; i != NULL; i = i->next)
856 inherit_costs(i->ccs);
857 ccs->inherited_ticks += i->ccs->inherited_ticks;
858 ccs->inherited_alloc += i->ccs->inherited_alloc;
864 static CostCentreStack *
865 pruneCCSTree( CostCentreStack *ccs )
867 CostCentreStack *ccs1;
868 IndexTable *i, **prev;
870 prev = &ccs->indexTable;
871 for (i = ccs->indexTable; i != 0; i = i->next) {
872 if (i->back_edge) { continue; }
874 ccs1 = pruneCCSTree(i->ccs);
882 if ( (RtsFlags.CcFlags.doCostCentres >= COST_CENTRES_ALL
883 /* force printing of *all* cost centres if -P -P */ )
885 || ( ccs->indexTable != 0 )
886 || ( ccs->scc_count || ccs->time_ticks || ccs->mem_alloc )
894 /* -----------------------------------------------------------------------------
895 Generate the XML time/allocation profile
896 -------------------------------------------------------------------------- */
899 gen_XML_logfile( void )
901 fprintf(prof_file, "%d %lu", TIME_UPD_UQ, total_prof_ticks);
903 reportCCS_XML(pruneCCSTree(CCS_MAIN));
905 fprintf(prof_file, " 0\n");
909 reportCCS_XML(CostCentreStack *ccs)
914 if (ccs_to_ignore(ccs)) { return; }
918 fprintf(prof_file, " 1 %ld %" FMT_Word64 " %" FMT_Word64 " %" FMT_Word64,
919 ccs->ccsID, ccs->scc_count, (StgWord64)(ccs->time_ticks), ccs->mem_alloc);
921 for (i = ccs->indexTable; i != 0; i = i->next) {
923 reportCCS_XML(i->ccs);
929 fprintCCS( FILE *f, CostCentreStack *ccs )
932 for (; ccs && ccs != CCS_MAIN; ccs = ccs->prevStack ) {
933 fprintf(f,"%s.%s", ccs->cc->module, ccs->cc->label);
934 if (ccs->prevStack && ccs->prevStack != CCS_MAIN) {
941 /* For calling from .cmm code, where we can't reliably refer to stderr */
943 fprintCCS_stderr( CostCentreStack *ccs )
945 fprintCCS(stderr, ccs);
950 debugCCS( CostCentreStack *ccs )
953 for (; ccs && ccs != CCS_MAIN; ccs = ccs->prevStack ) {
954 debugBelch("%s.%s", ccs->cc->module, ccs->cc->label);
955 if (ccs->prevStack && ccs->prevStack != CCS_MAIN) {
963 #endif /* PROFILING */