/*
  Time-stamp: <Wed Mar 21 2001 16:42:40 Stardate: [-30]6363.48 hwloidl>

  Basic functions for use in either GranSim or GUM.
*/

#if defined(GRAN) || defined(PAR)                              /* whole file */

//@menu
//* Includes::			
//* Variables and constants::	
//* Writing to the log-file::	
//* Global statistics::		
//* Dumping routines::		
//@end menu
//*/ fool highlight

//@node Includes, Variables and constants
//@subsection Includes

#include "Rts.h"
#include "RtsFlags.h"
#include "RtsUtils.h"
#include "Storage.h"
#include "GranSimRts.h"
#include "ParallelRts.h"

//@node Variables and constants, Writing to the log-file, Includes
//@subsection Variables and constants

/* Where to write the log file */
FILE *gr_file = NULL;
char gr_filename[STATS_FILENAME_MAXLEN];

#if defined(PAR)
/* Global statistics */
GlobalParStats globalParStats;
#endif

#if defined(PAR)
StgWord64 startTime = 0;
#endif

#if defined(PAR) && !defined(DEBUG)
// HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCCCCCCCCKKKKKKKKKKKK
// Definitely the wrong place for info_type in !DEBUG (see Printer.c) -- HWL

static char *closure_type_names[] = {
  "INVALID_OBJECT",          	/* 0  */
  "CONSTR",                  	/* 1  */
  "CONSTR_1_0",			/* 2  */
  "CONSTR_0_1",			/* 3  */
  "CONSTR_2_0",			/* 4  */
  "CONSTR_1_1",			/* 5  */
  "CONSTR_0_2",			/* 6  */
  "CONSTR_INTLIKE",	        /* 7  */
  "CONSTR_CHARLIKE",	        /* 8  */
  "CONSTR_STATIC",	        /* 9  */
  "CONSTR_NOCAF_STATIC",     	/* 10 */
  "FUN",		        /* 11 */
  "FUN_1_0",		  	/* 12 */
  "FUN_0_1",		  	/* 13 */
  "FUN_2_0",		  	/* 14 */
  "FUN_1_1",		  	/* 15 */
  "FUN_0_2",			/* 16 */
  "FUN_STATIC",	        	/* 17 */
  "THUNK",		        /* 18 */
  "THUNK_1_0",	  		/* 19 */
  "THUNK_0_1",	  		/* 20 */
  "THUNK_2_0",	  		/* 21 */
  "THUNK_1_1",	  		/* 22 */
  "THUNK_0_2",			/* 23 */
  "THUNK_STATIC",	        /* 24 */
  "THUNK_SELECTOR",	        /* 25 */
  "BCO",		        /* 26 */
  "AP_UPD",		        /* 27 */
  "PAP",			/* 28 */
  "IND",		        /* 29 */
  "IND_OLDGEN",	        	/* 30 */
  "IND_PERM",	        	/* 31 */
  "IND_OLDGEN_PERM",	        /* 32 */
  "IND_STATIC",	        	/* 33 */
  "CAF_UNENTERED",           	/* 34 */
  "CAF_ENTERED",		/* 35 */
  "CAF_BLACKHOLE",		/* 36 */
  "RET_BCO",                 	/* 37 */
  "RET_SMALL",	        	/* 38 */
  "RET_VEC_SMALL",	        /* 39 */
  "RET_BIG",		        /* 40 */
  "RET_VEC_BIG",	        /* 41 */
  "RET_DYN",		        /* 42 */
  "UPDATE_FRAME",	        /* 43 */
  "CATCH_FRAME",	        /* 44 */
  "STOP_FRAME",	        	/* 45 */
  "SEQ_FRAME",	        	/* 46 */
  "BLACKHOLE",	        	/* 47 */
  "BLACKHOLE_BQ",	        /* 48 */
  "SE_BLACKHOLE",		/* 49 */
  "SE_CAF_BLACKHOLE",		/* 50 */
  "MVAR",		        /* 51 */
  "ARR_WORDS",	        	/* 52 */
  "MUT_ARR_PTRS",	        /* 53 */
  "MUT_ARR_PTRS_FROZEN",     	/* 54 */
  "MUT_VAR",		        /* 55 */
  "WEAK",		        /* 56 */
  "FOREIGN",		        /* 57 */
  "STABLE_NAME",	        /* 58 */
  "TSO",		        /* 59 */
  "BLOCKED_FETCH",	        /* 60 */
  "FETCH_ME",                   /* 61 */
  "FETCH_ME_BQ",                /* 62 */
  "RBH",                        /* 63 */
  "EVACUATED",                  /* 64 */
  "REMOTE_REF",                 /* 65 */
  "N_CLOSURE_TYPES"         	/* 66 */
};

char *
info_type(StgClosure *closure){ 
  return closure_type_names[get_itbl(closure)->type];
}

char *
info_type_by_ip(StgInfoTable *ip){ 
  return closure_type_names[ip->type];
}

void
info_hdr_type(StgClosure *closure, char *res){ 
  strcpy(res,closure_type_names[get_itbl(closure)->type]);
}
#endif

//@node Writing to the log-file, Global statistics, Variables and constants
//@subsection Writing to the log-file
/*
  Writing to the log-file

  These routines dump event-based info to the main log-file.
  The code for writing log files is shared between GranSim and GUM.
*/

/* 
 * If you're not using GNUC and you're on a 32-bit machine, you're 
 * probably out of luck here.  However, since CONCURRENT currently
 * requires GNUC, I'm not too worried about it.  --JSM
 */

//@cindex init_gr_simulation
#if defined(GRAN)
void
init_gr_simulation(rts_argc, rts_argv, prog_argc, prog_argv)
char *prog_argv[], *rts_argv[];
int prog_argc, rts_argc;
{
  nat i;
  char *extension = RtsFlags.GranFlags.GranSimStats.Binary ? "gb" : "gr";

  if (RtsFlags.GranFlags.GranSimStats.Global)
    init_gr_stats();

  /* init global constants for costs of basic operations */
  gran_arith_cost = RtsFlags.GranFlags.Costs.arith_cost;
  gran_branch_cost = RtsFlags.GranFlags.Costs.branch_cost;
  gran_load_cost = RtsFlags.GranFlags.Costs.load_cost;
  gran_store_cost = RtsFlags.GranFlags.Costs.store_cost;
  gran_float_cost = RtsFlags.GranFlags.Costs.float_cost;

  if (RtsFlags.GranFlags.GranSimStats.Suppressed)
    return;

  if (!RtsFlags.GranFlags.GranSimStats.Full) 
    return;

  sprintf(gr_filename, GR_FILENAME_FMT, prog_argv[0], extension);

  if ((gr_file = fopen(gr_filename, "w")) == NULL) {
    barf("Can't open granularity simulation report file %s\n", 
	 gr_filename);
  }

  setbuf(gr_file, NULL);                   /* turn  buffering off */

  /* write header with program name, options and setup to gr_file */
  fputs("Granularity Simulation for ", gr_file);
  for (i = 0; i < prog_argc; ++i) {
    fputs(prog_argv[i], gr_file);
    fputc(' ', gr_file);
  }

  if (rts_argc > 0) {
    fputs("+RTS ", gr_file);
    
    for (i = 0; i < rts_argc; ++i) {
      fputs(rts_argv[i], gr_file);
      fputc(' ', gr_file);
    }
  }

  fputs("\nStart time: ", gr_file);
  fputs(time_str(), gr_file);               /* defined in RtsUtils.c */
  fputc('\n', gr_file);
    
  fputs("\n\n--------------------\n\n", gr_file);

  fputs("General Parameters:\n\n", gr_file);

  if (RtsFlags.GranFlags.Light) 
    fprintf(gr_file, "GrAnSim-Light\nPEs infinite, %s Scheduler, %sMigrate Threads %s, %s\n",
	    RtsFlags.GranFlags.DoFairSchedule?"Fair":"Unfair",
	    RtsFlags.GranFlags.DoThreadMigration?"":"Don't ",
	    RtsFlags.GranFlags.DoThreadMigration && RtsFlags.GranFlags.DoStealThreadsFirst?" Before Sparks":"",
	    RtsFlags.GranFlags.DoAsyncFetch ? "Asynchronous Fetch" :
	    "Block on Fetch");
  else 
    fprintf(gr_file, "PEs %u, %s Scheduler, %sMigrate Threads %s, %s\n",
	    RtsFlags.GranFlags.proc,RtsFlags.GranFlags.DoFairSchedule?"Fair":"Unfair",
	    RtsFlags.GranFlags.DoThreadMigration?"":"Don't ",
	    RtsFlags.GranFlags.DoThreadMigration && RtsFlags.GranFlags.DoStealThreadsFirst?" Before Sparks":"",
	    RtsFlags.GranFlags.DoAsyncFetch ? "Asynchronous Fetch" :
	    "Block on Fetch");
  
  if (RtsFlags.GranFlags.DoBulkFetching) 
    if (RtsFlags.GranFlags.ThunksToPack)
      fprintf(gr_file, "Bulk Fetching: Fetch %d Thunks in Each Packet (Packet Size = %d closures)\n",
	      RtsFlags.GranFlags.ThunksToPack, 
	      RtsFlags.GranFlags.packBufferSize);
    else
      fprintf(gr_file, "Bulk Fetching: Fetch as many closures as possible (Packet Size = %d closures)\n",
	      RtsFlags.GranFlags.packBufferSize);
  else
    fprintf(gr_file, "Incremental Fetching: Fetch Exactly One Closure in Each Packet\n");
  
  fprintf(gr_file, "Fetch Strategy(%u):If outstanding fetches %s\n",
	  RtsFlags.GranFlags.FetchStrategy,
	  RtsFlags.GranFlags.FetchStrategy==0 ?
	    " block (block-on-fetch)":
	  RtsFlags.GranFlags.FetchStrategy==1 ?
	    "only run runnable threads":
	  RtsFlags.GranFlags.FetchStrategy==2 ? 
	    "create threads only from local sparks":
	  RtsFlags.GranFlags.FetchStrategy==3 ? 
	    "create threads from local or global sparks":
	  RtsFlags.GranFlags.FetchStrategy==4 ?
	    "create sparks and steal threads if necessary":
	  "unknown");

  if (RtsFlags.GranFlags.DoPrioritySparking)
    fprintf(gr_file, "Priority Sparking (i.e. keep sparks ordered by priority)\n");

  if (RtsFlags.GranFlags.DoPriorityScheduling)
    fprintf(gr_file, "Priority Scheduling (i.e. keep threads ordered by priority)\n");

  fprintf(gr_file, "Thread Creation Time %u, Thread Queue Time %u\n",
	  RtsFlags.GranFlags.Costs.threadcreatetime, 
	  RtsFlags.GranFlags.Costs.threadqueuetime);
  fprintf(gr_file, "Thread DeSchedule Time %u, Thread Schedule Time %u\n",
	  RtsFlags.GranFlags.Costs.threaddescheduletime, 
	  RtsFlags.GranFlags.Costs.threadscheduletime);
  fprintf(gr_file, "Thread Context-Switch Time %u\n",
	  RtsFlags.GranFlags.Costs.threadcontextswitchtime);
  fputs("\n\n--------------------\n\n", gr_file);

  fputs("Communication Metrics:\n\n", gr_file);
  fprintf(gr_file,
	  "Latency %u (1st) %u (rest), Fetch %u, Notify %u (Global) %u (Local)\n",
	  RtsFlags.GranFlags.Costs.latency, 
	  RtsFlags.GranFlags.Costs.additional_latency, 
	  RtsFlags.GranFlags.Costs.fetchtime,
	  RtsFlags.GranFlags.Costs.gunblocktime, 
	  RtsFlags.GranFlags.Costs.lunblocktime);
  fprintf(gr_file,
	  "Message Creation %u (+ %u after send), Message Read %u\n",
	  RtsFlags.GranFlags.Costs.mpacktime, 
	  RtsFlags.GranFlags.Costs.mtidytime, 
	  RtsFlags.GranFlags.Costs.munpacktime);
  fputs("\n\n--------------------\n\n", gr_file);

  fputs("Instruction Metrics:\n\n", gr_file);
  fprintf(gr_file, "Arith %u, Branch %u, Load %u, Store %u, Float %u, Alloc %u\n",
	  RtsFlags.GranFlags.Costs.arith_cost, 
	  RtsFlags.GranFlags.Costs.branch_cost,
	  RtsFlags.GranFlags.Costs.load_cost, 
	  RtsFlags.GranFlags.Costs.store_cost, 
	  RtsFlags.GranFlags.Costs.float_cost, 
	  RtsFlags.GranFlags.Costs.heapalloc_cost);
  fputs("\n\n++++++++++++++++++++\n\n", gr_file);

# if 0
  /* binary log files are currently not supported */
  if (RtsFlags.GranFlags.GranSimStats.Binary)
    grputw(sizeof(rtsTime));
# endif

  return (0);
}

#elif defined(PAR)

void init_gr_stats (void);

void
init_gr_simulation(rts_argc, rts_argv, prog_argc, prog_argv)
char *prog_argv[], *rts_argv[];
int prog_argc, rts_argc;
{
  nat i;
  char time_string[TIME_STR_LEN], node_str[NODE_STR_LEN];
  char *extension = RtsFlags.ParFlags.ParStats.Binary ? "gb" : "gr";

  sprintf(gr_filename, GR_FILENAME_FMT_GUM, prog_argv[0], thisPE, extension);

  if (!RtsFlags.ParFlags.ParStats.Full) 
    return;

  if (RtsFlags.ParFlags.ParStats.Global)
    init_gr_stats();

  if ((gr_file = fopen(gr_filename, "w")) == NULL)
    barf("Can't open activity report file %s\n", gr_filename);

  setbuf(gr_file, NULL);                   /* turn  buffering off */

  /* write header with program name, options and setup to gr_file */
  for (i = 0; i < prog_argc; ++i) {
    fputs(prog_argv[i], gr_file);
    fputc(' ', gr_file);
  }

  if (rts_argc > 0) {
    fputs("+RTS ", gr_file);
    
    for (i = 0; i < rts_argc; ++i) {
      fputs(rts_argv[i], gr_file);
      fputc(' ', gr_file);
    }
  }
  fputc('\n', gr_file);

  /* record the absolute start time to allow synchronisation of log-files */
  fputs("Start-Time: ", gr_file);
  fputs(time_str(), gr_file);
  fputc('\n', gr_file);

  ASSERT(startTime==0);
  // startTime = msTime();
  startTime = CURRENT_TIME;
  showStgWord64(CURRENT_TIME, time_string, rtsFalse/*no commas!*/);
  fprintf(gr_file, "PE %2u [%s]: TIME\n", thisPE, time_string);

# if 0
    ngoq Dogh'q' vImuS
  IF_PAR_DEBUG(verbose,
	       belch("== Start-time: %ld (%s)",
		     startTime, time_string));

    if (startTime > LL(1000000000)) {
      fprintf(gr_file, "PE %2u [%lu%lu]: TIME\n", thisPE, 
	    (rtsTime) (startTime / LL(1000000000)),
	    (rtsTime) (startTime % LL(1000000000)));
    } else {
      fprintf(gr_file, "PE %2u [%lu]: TIME\n", thisPE, (TIME) startTime);
    } 
    /* binary log files are currently not supported */
    if (RtsFlags.GranFlags.GranSimStats.Binary)
	grputw(sizeof(rtsTime));
# endif

    return;
}

void 
init_gr_stats (void) {
  // memset(&globalParStats, '\0', sizeof(GlobalParStats));

  globalParStats.tot_mark_GA = globalParStats.tot_rebuild_GA = globalParStats.tot_free_GA = globalParStats.res_mark_GA = globalParStats.res_rebuild_GA = globalParStats.res_free_GA = globalParStats.tot_size_GA = globalParStats.res_size_GA = globalParStats.tot_global = globalParStats.tot_local = 0;
  globalParStats.cnt_mark_GA = globalParStats.cnt_rebuild_GA = globalParStats.cnt_free_GA = globalParStats.res_free_GA = globalParStats.local_alloc_GA = 0;

  globalParStats.time_mark_GA = 0.0;
  globalParStats.time_rebuild_GA = 0.0;
  globalParStats.time_sparks = 0.0;
  globalParStats.time_pack = 0.0;

  globalParStats.res_sp = globalParStats.res_tp = globalParStats.tot_sp = globalParStats.tot_tp = globalParStats.cnt_sp = globalParStats.cnt_tp = globalParStats.emp_sp = globalParStats.emp_tp = 0;
  globalParStats.tot_packets = globalParStats.tot_packet_size = globalParStats.tot_thunks = globalParStats.res_packet_size = globalParStats.res_thunks = globalParStats.rec_res_packet_size = globalParStats.rec_res_thunks = 0;

  globalParStats.tot_fish_mess = globalParStats.tot_fetch_mess = globalParStats.tot_resume_mess = globalParStats.tot_schedule_mess = 0;
  globalParStats.rec_fish_mess = globalParStats.rec_resume_mess = globalParStats.rec_schedule_mess = 0;
  globalParStats.rec_fetch_mess = 0;
#if defined(DIST)
  globalParStats.tot_reval_mess = 0;
  globalParStats.rec_reval_mess = 0;
#endif

  globalParStats.tot_threads_created = globalParStats.tot_sparks_created = globalParStats.tot_sparks_ignored = globalParStats.tot_sparks_marked = globalParStats.res_sparks_created = globalParStats.res_sparks_ignored = globalParStats.res_sparks_marked = 0;
   globalParStats.tot_yields = globalParStats.tot_stackover = globalParStats.tot_heapover = 0;

   globalParStats.tot_arrs = globalParStats.tot_arr_size = 0; 
}

#endif /* PAR */

//@cindex end_gr_simulation
#if defined(GRAN)
void
end_gr_simulation(void)
{
   char time_string[TIME_STR_LEN];

   showStgWord64(CURRENT_TIME, time_string, rtsFalse/*no commas!*/);

   if (RtsFlags.GranFlags.GranSimStats.Suppressed)
     return;

   /* Print event stats */
   if (RtsFlags.GranFlags.GranSimStats.Global) {
     nat i;
   
     fprintf(stderr,"Total yields: %d\n",
             globalGranStats.tot_yields);

     fprintf(stderr,"Total number of threads created: %d ; per PE:\n",
             globalGranStats.tot_threads_created);
     for (i=0; i<RtsFlags.GranFlags.proc; i++) {
       fprintf(stderr,"  PE %d: %d\t", 
	       i, globalGranStats.threads_created_on_PE[i]);
       if (i+1 % 4 == 0) fprintf(stderr,"\n");
     }
     if (RtsFlags.GranFlags.proc+1 % 4 != 0) fprintf(stderr,"\n");
     fprintf(stderr,"Total number of threads migrated: %d\n",
             globalGranStats.tot_TSOs_migrated);

     fprintf(stderr,"Total number of sparks created: %d ; per PE:\n",
             globalGranStats.tot_sparks_created);
     for (i=0; i<RtsFlags.GranFlags.proc; i++) {
       fprintf(stderr,"  PE %d: %d\t", 
	       i, globalGranStats.sparks_created_on_PE[i]);
       if (i+1 % 4 == 0) fprintf(stderr,"\n");
     }
     if (RtsFlags.GranFlags.proc+1 % 4 != 0) fprintf(stderr,"\n");

     fprintf(stderr,"Event statistics (number of events: %d):\n",
             globalGranStats.noOfEvents);
     for (i=0; i<=MAX_EVENT; i++) {
       fprintf(stderr,"  %s (%d): \t%d \t%f%%\t%f%%\n",
               event_names[i],i,globalGranStats.event_counts[i],
               (float)(100*globalGranStats.event_counts[i])/(float)(globalGranStats.noOfEvents),
               (i==ContinueThread ? 0.0 :
   		   (float)(100*(globalGranStats.event_counts[i])/(float)(globalGranStats.noOfEvents-globalGranStats.event_counts[ContinueThread])) ));
     }
     fprintf(stderr,"Randomized steals: %ld sparks, %ld threads \n \t(Sparks: #%u (avg ntimes=%f; avg fl=%f)\n\t(Threads: %ld)", 
   	             globalGranStats.rs_sp_count, 
	             globalGranStats.rs_t_count, 
	             globalGranStats.no_of_steals, 
   	             (float)globalGranStats.ntimes_total/(float)stg_max(globalGranStats.no_of_steals,1),
   	             (float)globalGranStats.fl_total/(float)stg_max(globalGranStats.no_of_steals,1),
	             globalGranStats.no_of_migrates);
     fprintf(stderr,"Moved sparks: %d  Withered sparks: %d (%.2f %%)\n",
   	      globalGranStats.tot_sparks, globalGranStats.withered_sparks,
             ( globalGranStats.tot_sparks == 0 ? 0 :
                  (float)(100*globalGranStats.withered_sparks)/(float)(globalGranStats.tot_sparks)) );
     /* Print statistics about priority sparking */
     if (RtsFlags.GranFlags.DoPrioritySparking) {
   	fprintf(stderr,"About Priority Sparking:\n");
   	fprintf(stderr,"  Total no. NewThreads: %d   Avg. spark queue len: %.2f \n", globalGranStats.tot_sq_probes, (float)globalGranStats.tot_sq_len/(float)globalGranStats.tot_sq_probes);
     }
     /* Print statistics about priority sparking */
     if (RtsFlags.GranFlags.DoPriorityScheduling) {
   	fprintf(stderr,"About Priority Scheduling:\n");
   	fprintf(stderr,"  Total no. of StartThreads: %d (non-end: %d) Avg. thread queue len: %.2f\n", 
   		globalGranStats.tot_add_threads, globalGranStats.non_end_add_threads, 
   		(float)globalGranStats.tot_tq_len/(float)globalGranStats.tot_add_threads);
     }
     /* Blocking queue statistics */
     if (1) {
   	fprintf(stderr,"Blocking queue statistcs:\n");
   	fprintf(stderr,"  Total no. of FMBQs generated: %d\n",
		globalGranStats.tot_FMBQs);
   	fprintf(stderr,"  Total no. of bqs awakened: %d\n",
		globalGranStats.tot_awbq);
   	fprintf(stderr,"  Total length of all bqs: %d\tAvg length of bqs: %.2f\n",
		globalGranStats.tot_bq_len, (float)globalGranStats.tot_bq_len/(float)globalGranStats.tot_awbq);
   	fprintf(stderr,"  Percentage of local TSOs in BQs: %.2f\n",
		(float)globalGranStats.tot_bq_len*100.0/(float)globalGranStats.tot_bq_len);
   	fprintf(stderr,"  Total time spent processing BQs: %lx\n",
		globalGranStats.tot_bq_processing_time);
     }

     /* Fetch misses and thunk stealing */
     fprintf(stderr,"Number of fetch misses: %d\n", 
	     globalGranStats.fetch_misses);

     /* Print packet statistics if GUMM fetching is turned on */
     if (RtsFlags.GranFlags.DoBulkFetching) {
   	fprintf(stderr,"Packet statistcs:\n");
   	fprintf(stderr,"  Total no. of packets: %d   Avg. packet size: %.2f \n", globalGranStats.tot_packets, (float)globalGranStats.tot_packet_size/(float)globalGranStats.tot_packets);
   	fprintf(stderr,"  Total no. of thunks: %d   Avg. thunks/packet: %.2f \n", globalGranStats.tot_thunks, (float)globalGranStats.tot_thunks/(float)globalGranStats.tot_packets);
   	fprintf(stderr,"  Total no. of cuts: %d   Avg. cuts/packet: %.2f\n", globalGranStats.tot_cuts, (float)globalGranStats.tot_cuts/(float)globalGranStats.tot_packets);
        /* 
   	if (closure_queue_overflows>0) 
   	  fprintf(stderr,"  Number of closure queue overflows: %u\n",
   		  closure_queue_overflows);
	*/
     }
   } /* RtsFlags.GranFlags.GranSimStats.Global */

#  if defined(GRAN_COUNT)
#  error "GRAN_COUNT not supported; should be parallel ticky profiling, really"
    fprintf(stderr,"Update count statistics:\n");
    fprintf(stderr,"  Total number of updates: %u\n",nUPDs);
    fprintf(stderr,"  Needed to awaken BQ: %u with avg BQ len of: %f\n",
	    nUPDs_BQ,(float)BQ_lens/(float)nUPDs_BQ);
    fprintf(stderr,"  Number of PAPs: %u\n",nPAPs);
#  endif

    fprintf(stderr, "Simulation finished after @ %s @ cycles. %d sparks created, %d sparks ignored. Check %s for details.\n",
	    time_string, sparksCreated, sparksIgnored, gr_filename);

    if (RtsFlags.GranFlags.GranSimStats.Full) 
      fclose(gr_file);
}

#elif defined(PAR)

/*
  Under GUM we print only one line. 
*/
void
end_gr_simulation(void)
{
  char time_string[TIME_STR_LEN];

  showStgWord64(CURRENT_TIME-startTime, time_string, rtsFalse/*no commas!*/);

  fprintf(stderr, "Computation finished after @ %s @ ms. %d sparks created, %d sparks ignored. Check %s for details.\n",
	    time_string, sparksCreated, sparksIgnored, gr_filename);

  if (RtsFlags.ParFlags.ParStats.Full) 
    fclose(gr_file);
}
#endif /* PAR */

//@node Global statistics, Dumping routines, Writing to the log-file
//@subsection Global statistics
/* 
   Called at the end of execution
*/

//@node Dumping routines,  , Global statistics
//@subsection Dumping routines

//@cindex DumpGranEvent
void
DumpGranEvent(name, tso)
GranEventType name;
StgTSO *tso;
{
    DumpRawGranEvent(CURRENT_PROC, (PEs)0, name, tso, &stg_END_TSO_QUEUE_closure, (StgInt)0, (StgInt)0);
}

//@cindex DumpRawGranEvent
void
DumpRawGranEvent(proc, p, name, tso, node, sparkname, len)
PEs proc, p;         /* proc ... where it happens; p ... where node lives */
GranEventType name;
StgTSO *tso;
StgClosure *node;
StgInt sparkname, len;
{
# if defined(GRAN)
  DumpVeryRawGranEvent(TIME_ON_PROC(proc), 
		       proc, p, name, tso, node, sparkname, len);
# elif defined(PAR)
  DumpVeryRawGranEvent(CURRENT_TIME,
		       proc, p, name, tso, node, sparkname, len);
# endif
}

//@cindex DumpVeryRawGranEvent
void
DumpVeryRawGranEvent(time, proc, p, name, tso, node, sparkname, len)
rtsTime time;
PEs proc, p;         /* proc ... where it happens; p ... where node lives */
GranEventType name;
StgTSO *tso;
StgClosure *node;
StgInt sparkname, len;
{
  FILE *output_file; // DEBUGGING ONLY !!!!!!!!!!!!!!!!!!!!!!!!!1
  StgWord id;
  char time_string[TIME_STR_LEN], node_str[NODE_STR_LEN];
# if defined(GRAN)
  showStgWord64(time,
		       time_string, rtsFalse/*no commas!*/);
# elif defined(PAR)
  showStgWord64(time,
		       time_string, rtsFalse/*no commas!*/);
# endif
  output_file = gr_file;

# if defined(GRAN)

  if (RtsFlags.GranFlags.GranSimStats.Full) 
    ASSERT(output_file!=NULL);

  if (RtsFlags.GranFlags.GranSimStats.Suppressed)
    return;
# elif defined(PAR)

  if (RtsFlags.ParFlags.ParStats.Full) 
    ASSERT(output_file!=NULL);

  if (RtsFlags.ParFlags.ParStats.Suppressed)
    return;

# endif

  id = tso == NULL ? -1 : tso->id;
  if (node==stgCast(StgClosure*,&stg_END_TSO_QUEUE_closure))
      strcpy(node_str,"________");  /* "END_TSO_QUEUE"); */
  else
      sprintf(node_str,"0x%-6lx",node);

  if (name > GR_EVENT_MAX)
	name = GR_EVENT_MAX;

  if (BINARY_STATS)
    barf("binary log files not yet supported");
#if 0
    /* ToDo: fix code for writing binary GrAnSim statistics */
    switch (name) { 
      case GR_START:
      case GR_STARTQ:
                      grputw(name);
		      grputw(proc);
		      abort();        /* die please: a single word */
				      /* doesn't represent long long times */
		      grputw(TIME_ON_PROC(proc));
		      grputw((StgWord)node);
		      break;
      case GR_FETCH:
      case GR_REPLY:
      case GR_BLOCK:
		      grputw(name);
		      grputw(proc);
		      abort();        /* die please: a single word */
				      /* doesn't represent long long times */
		      grputw(TIME_ON_PROC(proc));  /* this line is bound to */
		      grputw(id);                  /*   do the wrong thing */
		      break;
      default: 
                      grputw(name);
		      grputw(proc);
		      abort();        /* die please: a single word */
				      /* doesn't represent long long times */
		      grputw(TIME_ON_PROC(proc));
		      grputw((StgWord)node);
    }
#endif
  else /* !BINARY_STATS */
    switch (name) { 
     case GR_START:
     case GR_STARTQ:
        fprintf(output_file,"PE %2u [%s]: %-9s\t%lx\t%s\t[SN %u]\t[sparks %u]\n", 
	        proc,time_string,gran_event_names[name],
	        id,node_str,sparkname,len);
        break;
     case GR_FETCH:
     case GR_REPLY:
     case GR_BLOCK:
     case GR_STOLEN:
     case GR_STOLENQ:
     case GR_STEALING:
	fprintf(output_file, "PE %2u [%s]: %-9s\t%lx \t%s\t(from %2u)\n",
	        proc, time_string, gran_event_names[name], 
		id,node_str,p);
	break;
     case GR_RESUME:
     case GR_RESUMEQ:
     case GR_SCHEDULE:
     case GR_DESCHEDULE:
        fprintf(output_file,"PE %2u [%s]: %-9s\t%lx \n",
	        proc,time_string,gran_event_names[name],id);
        break;
     case GR_ALLOC:
        fprintf(output_file,"PE %2u [%s]: %-9s\t%lx\t        \tallocating %u words\n",
	        proc,time_string,gran_event_names[name],id,len);
        break;
     default:
        fprintf(output_file,"PE %2u [%s]: %-9s\t%lx\t%s\t[sparks %u]\n",
	        proc,time_string,gran_event_names[name],id,node_str,len);
    }
}

//@cindex DumpGranInfo
void
DumpEndEvent(proc, tso, mandatory_thread)
PEs proc;
StgTSO *tso;
rtsBool mandatory_thread;
{
  FILE *output_file; // DEBUGGING ONLY !!!!!!!!!!!!!!!!!!!!!!!!!1
  char time_string[TIME_STR_LEN];
# if defined(GRAN)
  showStgWord64(TIME_ON_PROC(proc), 
		       time_string, rtsFalse/*no commas!*/);
# elif defined(PAR)
  showStgWord64(CURRENT_TIME,
		       time_string, rtsFalse/*no commas!*/);
# endif

  output_file = gr_file;
  ASSERT(output_file!=NULL);
#if defined(GRAN)
    if (RtsFlags.GranFlags.GranSimStats.Suppressed)
      return;
#endif

    if (BINARY_STATS) {
    barf("binary log files not yet supported");
#if 0
	grputw(GR_END);
	grputw(proc);
	abort(); /* die please: a single word doesn't represent long long times */
	grputw(CURRENT_TIME); /* this line is bound to fail */
	grputw(tso->id);
#ifdef PAR
	grputw(0);
	grputw(0);
	grputw(0);
	grputw(0);
	grputw(0);
	grputw(0);
	grputw(0);
	grputw(0);
	grputw(0);
	grputw(0);
	grputw(0);
	grputw(0);
#else
	grputw(tso->gran.sparkname);
	grputw(tso->gran.startedat);
	grputw(tso->gran.exported);
	grputw(tso->gran.basicblocks);
	grputw(tso->gran.allocs);
	grputw(tso->gran.exectime);
	grputw(tso->gran.blocktime);
	grputw(tso->gran.blockcount);
	grputw(tso->gran.fetchtime);
	grputw(tso->gran.fetchcount);
	grputw(tso->gran.localsparks);
	grputw(tso->gran.globalsparks);
#endif
	grputw(mandatory_thread);
#endif /* 0 */
    } else {

	/*
	 * NB: DumpGranEvent cannot be used because PE may be wrong 
	 * (as well as the extra info)
	 */
	fprintf(output_file, "PE %2u [%s]: END %lx, SN %u, ST %lu, EXP %s, BB %u, HA %u, RT %u, BT %u (%u), FT %u (%u), LS %u, GS %u, MY %s\n"
	  ,proc
	  ,time_string
	  ,tso->id
#if defined(GRAN)		
	  ,tso->gran.sparkname
	  ,tso->gran.startedat
	  ,((tso->gran.exported) ? 'T' : 'F')
	  ,tso->gran.basicblocks
	  ,tso->gran.allocs
	  ,tso->gran.exectime
	  ,tso->gran.blocktime
	  ,tso->gran.blockcount
	  ,tso->gran.fetchtime
	  ,tso->gran.fetchcount
	  ,tso->gran.localsparks
	  ,tso->gran.globalsparks
#elif defined(PAR)
	  ,tso->par.sparkname
	  ,tso->par.startedat
	  ,(tso->par.exported) ? "T" : "F"
	  ,tso->par.basicblocks
	  ,tso->par.allocs
	  ,tso->par.exectime
	  ,tso->par.blocktime
	  ,tso->par.blockcount
	  ,tso->par.fetchtime
	  ,tso->par.fetchcount
	  ,tso->par.localsparks
	  ,tso->par.globalsparks
#endif
	  ,(mandatory_thread ? "T" : "F")
	  );
    }
}

//@cindex DumpTSO
void
DumpTSO(tso)
StgTSO *tso;
{
  FILE *output_file; // DEBUGGING ONLY !!!!!!!!!!!!!!!!!!!!!!!!!1

  output_file = gr_file;
  ASSERT(output_file!=NULL);
  fprintf(stderr,"TSO 0x%lx, NAME 0x%lx, ID %u, LINK 0x%lx, TYPE %s\n"
          ,tso
#if defined(GRAN)
          ,tso->gran.sparkname
#elif defined(PAR)
          ,tso->par.sparkname
#endif
          ,tso->id
          ,tso->link
          ,/*tso->state==T_MAIN?"MAIN":
           TSO_TYPE(tso)==T_FAIL?"FAIL":
           TSO_TYPE(tso)==T_REQUIRED?"REQUIRED":
           TSO_TYPE(tso)==T_ADVISORY?"ADVISORY":
	   */
           "???"
          );
          
  fprintf(output_file,"TSO %lx: SN %u, ST %u, GBL %c, BB %u, HA %u, RT %u, BT %u (%u), FT %u (%u) LS %u, GS %u\n"
	  ,tso->id
#if defined(GRAN)
          ,tso->gran.sparkname
          ,tso->gran.startedat
          ,tso->gran.exported?'T':'F'
          ,tso->gran.basicblocks
          ,tso->gran.allocs
          ,tso->gran.exectime
          ,tso->gran.blocktime
          ,tso->gran.blockcount
          ,tso->gran.fetchtime
          ,tso->gran.fetchcount
          ,tso->gran.localsparks
          ,tso->gran.globalsparks
#elif defined(PAR)
          ,tso->par.sparkname
          ,tso->par.startedat
          ,tso->par.exported?'T':'F'
          ,tso->par.basicblocks
          ,tso->par.allocs
          ,tso->par.exectime
          ,tso->par.blocktime
          ,tso->par.blockcount
          ,tso->par.fetchtime
          ,tso->par.fetchcount
          ,tso->par.localsparks
          ,tso->par.globalsparks
#endif
          );
}

#if 0
/*
  ToDo: fix binary output of log files, and support new log file format.
*/
/*
   Output a terminate event and an 8-byte time.
*/

//@cindex grterminate
void
grterminate(v)
rtsTime v;
{
  if (!BINARY_STATS) 
    barf("grterminate: binary statistics not enabled\n");

# if defined(GRAN)
    if (RtsFlags.GranFlags.GranSimStats.Suppressed)
      return;
# endif

    DumpGranEvent(GR_TERMINATE, stgCast(StgTSO*,&stg_END_TSO_QUEUE_closure));

    if (sizeof(rtsTime) == 4) {
      putc('\0', gr_file);
      putc('\0', gr_file);
      putc('\0', gr_file);
      putc('\0', gr_file);
    } else {
      putc(v >> 56l, gr_file);
      putc((v >> 48l) & 0xffl, gr_file);
      putc((v >> 40l) & 0xffl, gr_file);
      putc((v >> 32l) & 0xffl, gr_file);
    }
    putc((v >> 24l) & 0xffl, gr_file);
    putc((v >> 16l) & 0xffl, gr_file);
    putc((v >> 8l) & 0xffl, gr_file);
    putc(v & 0xffl, gr_file);
}

/*
   Length-coded output: first 3 bits contain length coding

     00x        1 byte
     01x        2 bytes
     10x        4 bytes
     110        8 bytes
     111        5 or 9 bytes
*/

//@cindex grputw
void
grputw(v)
rtsTime v;
{
  if (!BINARY_STATS) 
    barf("grputw: binary statistics not enabled\n");

# if defined(GRAN)
    if (RtsFlags.GranFlags.GranSimStats.Suppressed)
      return;
# endif

    if (v <= 0x3fl) {                           /* length v = 1 byte */ 
	fputc(v & 0x3f, gr_file);
    } else if (v <= 0x3fffl) {                  /* length v = 2 byte */ 
	fputc((v >> 8l) | 0x40l, gr_file);
	fputc(v & 0xffl, gr_file);
    } else if (v <= 0x3fffffffl) {              /* length v = 4 byte */ 
	fputc((v >> 24l) | 0x80l, gr_file);
	fputc((v >> 16l) & 0xffl, gr_file);
	fputc((v >> 8l) & 0xffl, gr_file);
	fputc(v & 0xffl, gr_file);
    } else if (sizeof(TIME) == 4) {
	fputc(0x70, gr_file);
	fputc((v >> 24l) & 0xffl, gr_file);
	fputc((v >> 16l) & 0xffl, gr_file);
	fputc((v >> 8l) & 0xffl, gr_file);
	fputc(v & 0xffl, gr_file);
    } else {
	if (v <= 0x3fffffffffffffl)
	    putc((v >> 56l) | 0x60l, gr_file);
	else {
	    putc(0x70, gr_file);
	    putc((v >> 56l) & 0xffl, gr_file);
	}

	putc((v >> 48l) & 0xffl, gr_file);
	putc((v >> 40l) & 0xffl, gr_file);
	putc((v >> 32l) & 0xffl, gr_file);
	putc((v >> 24l) & 0xffl, gr_file);
	putc((v >> 16l) & 0xffl, gr_file);
	putc((v >> 8l) & 0xffl, gr_file);
	putc(v & 0xffl, gr_file);
    }
}
#endif /* 0 */

/* 
   extracting specific info out of a closure; used in packing (GranSim, GUM)
*/
//@cindex get_closure_info
StgInfoTable*
get_closure_info(StgClosure* node, nat *size, nat *ptrs, nat *nonptrs, 
		 nat *vhs, char *info_hdr_ty)
{
  StgInfoTable *info;

  ASSERT(LOOKS_LIKE_COOL_CLOSURE(node)); 
  info = get_itbl(node);
  /* the switch shouldn't be necessary, really; just use default case */
  switch (info->type) {
  case RBH:
    {
      StgInfoTable *rip = REVERT_INFOPTR(info); // closure to revert to
      *size = sizeW_fromITBL(rip);
      *ptrs = (nat) (rip->layout.payload.ptrs);
      *nonptrs = (nat) (rip->layout.payload.nptrs);
      *vhs = *size - *ptrs - *nonptrs - sizeofW(StgHeader);
#if 0 /* DEBUG */
      info_hdr_type(node, info_hdr_ty);
#else
      strcpy(info_hdr_ty, "RBH");
#endif
      return rip;  // NB: we return the reverted info ptr for a RBH!!!!!!
    }

#if defined(PAR)
  /* Closures specific to GUM */
  case FETCH_ME:
    *size = sizeofW(StgFetchMe);
    *ptrs = (nat)0;
    *nonptrs = (nat)0;
    *vhs = *size - *ptrs - *nonptrs - sizeofW(StgHeader);
#if 0 /* DEBUG */
    info_hdr_type(node, info_hdr_ty);
#else
    strcpy(info_hdr_ty, "FETCH_ME");
#endif
    return info;

#ifdef DIST    
  case REMOTE_REF: //same as for FETCH_ME...
    *size = sizeofW(StgFetchMe);
    *ptrs = (nat)0;
    *nonptrs = (nat)0;
    *vhs = *size - *ptrs - *nonptrs - sizeofW(StgHeader);
#if 0 /* DEBUG */
    info_hdr_type(node, info_hdr_ty);
#else
    strcpy(info_hdr_ty, "REMOTE_REF");
#endif
    return info; 
#endif /* DIST */
    
  case FETCH_ME_BQ:
    *size = sizeofW(StgFetchMeBlockingQueue);
    *ptrs = (nat)0;
    *nonptrs = (nat)0;
    *vhs = *size - *ptrs - *nonptrs - sizeofW(StgHeader);
#if 0 /* DEBUG */
    info_hdr_type(node, info_hdr_ty);
#else
    strcpy(info_hdr_ty, "FETCH_ME_BQ");
#endif
    return info;

  case BLOCKED_FETCH:
    *size = sizeofW(StgBlockedFetch);
    *ptrs = (nat)0;
    *nonptrs = (nat)0;
    *vhs = *size - *ptrs - *nonptrs - sizeofW(StgHeader);
#if 0 /* DEBUG */
    info_hdr_type(node, info_hdr_ty);
#else
    strcpy(info_hdr_ty, "BLOCKED_FETCH");
#endif
    return info;
#endif /* PAR */
    
  /* these magic constants are outrageous!! why does the ITBL lie about it? */
  case THUNK_SELECTOR:
    *size = THUNK_SELECTOR_sizeW();
    *ptrs = 1;
    *nonptrs = MIN_UPD_SIZE-*ptrs;   // weird
    *vhs = *size - *ptrs - *nonptrs - sizeofW(StgHeader);
    return info;

  case ARR_WORDS:
    /* ToDo: check whether this can be merged with the default case */
    *size = arr_words_sizeW((StgArrWords *)node); 
    *ptrs = 0;
    *nonptrs = arr_words_words(((StgArrWords *)node));
    *vhs = *size - *ptrs - *nonptrs - sizeofW(StgHeader);
    return info;

  case PAP:
    /* ToDo: check whether this can be merged with the default case */
    *size = pap_sizeW((StgPAP *)node); 
    *ptrs = 0;
    *nonptrs = 0;
    *vhs = *size - *ptrs - *nonptrs - sizeofW(StgHeader);
    return info;

  case AP_UPD:
    /* ToDo: check whether this can be merged with the default case */
    *size = AP_sizeW(((StgAP_UPD *)node)->n_args); 
    *ptrs = 0;
    *nonptrs = 0;
    *vhs = *size - *ptrs - *nonptrs - sizeofW(StgHeader);
    return info;

  default:
    *size = sizeW_fromITBL(info);
    *ptrs = (nat) (info->layout.payload.ptrs);
    *nonptrs = (nat) (info->layout.payload.nptrs);
    *vhs = *size - *ptrs - *nonptrs - sizeofW(StgHeader);
#if 0 /* DEBUG */
      info_hdr_type(node, info_hdr_ty);
#else
      strcpy(info_hdr_ty, "UNKNOWN");
#endif
    return info;
  }
} 

//@cindex IS_BLACK_HOLE
rtsBool
IS_BLACK_HOLE(StgClosure* node)          
{ 
  // StgInfoTable *info;
  ASSERT(LOOKS_LIKE_COOL_CLOSURE(node));
  switch (get_itbl(node)->type) {
  case BLACKHOLE:
  case BLACKHOLE_BQ:
  case RBH:
  case FETCH_ME:
  case FETCH_ME_BQ:
    return rtsTrue;
  default:
    return rtsFalse;
  }
//return ((info->type == BLACKHOLE || info->type == RBH) ? rtsTrue : rtsFalse);
}

//@cindex IS_INDIRECTION
StgClosure *
IS_INDIRECTION(StgClosure* node)          
{ 
  StgInfoTable *info;
  ASSERT(LOOKS_LIKE_COOL_CLOSURE(node));
  info = get_itbl(node);
  switch (info->type) {
    case IND:
    case IND_OLDGEN:
    case IND_PERM:
    case IND_OLDGEN_PERM:
    case IND_STATIC:
      /* relies on indirectee being at same place for all these closure types */
      return (((StgInd*)node) -> indirectee);
#if 0
    case EVACUATED:           // counting as ind to use in GC routines, too
      // could use the same code as above (evacuee is at same pos as indirectee)
      return (((StgEvacuated *)node) -> evacuee);
#endif
    default:
      return NULL;
  }
}

//@cindex unwindInd
StgClosure *
UNWIND_IND (StgClosure *closure)
{
  StgClosure *next;

  while ((next = IS_INDIRECTION((StgClosure *)closure)) != NULL) 
    closure = next;

  ASSERT(next==(StgClosure *)NULL);
  ASSERT(LOOKS_LIKE_COOL_CLOSURE(closure)); 
  return closure;
}

#endif /* GRAN || PAR   whole file */
