log.c

MPICH是MPI的重要研究,提供了一系列的接口函数,为并行计算的实现提供了编程环境.

/*
   Format-unspecific logfile stuff for Upshot.
*/

#include <stdio.h>
#include "log.h"
#include "alog.h"
#include "picl.h"
#include "str_dup.h"
#include "cvt_args.h"

#ifdef NEEDS_STDLIB_PROTOTYPES
#include "protofix.h"
#endif



static int Load ANSI_ARGS(( Tcl_Interp*, logFile* ));
static int CreateCmd ANSI_ARGS(( ClientData, Tcl_Interp*, int, char** ));
static int Cmd ANSI_ARGS(( ClientData, Tcl_Interp*, int, char** ));
static logFormat FormatStr2Enum ANSI_ARGS(( char *str ));
static int ReturnDouble ANSI_ARGS(( Tcl_Interp*, double ));
static int ReturnInt ANSI_ARGS(( Tcl_Interp*, int ));



#define DEBUG 0

logFile *Log_Open( interp, cmdname, filename, format, pct_done )
Tcl_Interp *interp;
char *cmdname;
char *filename;
logFormat format;
char *pct_done;
{
  logFile *log;
  int load_status;

  log = (logFile*)malloc( sizeof( logFile ) );
  if (!log) {
    Tcl_AppendResult( interp, "out of memory opening logfile", (char*)0 );
    return 0;
  }

  log->interp = interp;
  log->format = format;
  log->filename = STRDUP( filename );
  log->cmdname = STRDUP( cmdname );
  log->creator = 0;

  Tcl_CreateCommand( interp, log->cmdname, Cmd, (ClientData)log,
		     (Tcl_CmdDeleteProc*)0 );

  log->states = State_Create();
  log->events = Event_Create();
  log->msgs   = Msg_Create();
  log->processes = Process_Create();  
  log->pct_done = pct_done;

  if (!log->filename || !log->cmdname || !log->states || !log->events ||
      !log->msgs || !log->processes) {
    Tcl_AppendResult( interp, "out of memory opening logfile", (char*)0 );
    return 0;
  }

  log->loaded = 0;
  log->halt = 0;

    /* load the logfile */
  log->is_reading = 1;
    /* Load(), or whomever it calls, should take care of opening
       and closing the FILE* */
  load_status = Load( interp, log );
  log->is_reading = 0;
  log->loaded = 1;

/* For this to be effective, the window title must NOT be set in mainwin.tcl 
  if( log->creator ) {
      int code;
      code = Tcl_VarEval(interp, "wm title . ", log->creator, (char *) NULL);
  }
  */
  if (load_status != TCL_OK) {
    Log_Close( log );
    return 0;
  }

  return log;
}



/*
   Close the logfile.  If the logfile is currently being read, just mark
   it for closing.
*/
int Log_Close( log )
logFile *log;
{

  /* if the logfile is in use being read, mark it for deletion. */
  /* the reading thread should close it when it notices */
  if (log->is_reading) {
    log->halt = 1;
    return 0;
  }

  Tcl_DeleteCommand( log->interp, log->cmdname );
  free( log->filename );
  free( log->cmdname );
  if (log->creator) free( log->creator );
  Event_Close( log->events );
  State_Close( log->states );
  Msg_Close( log->msgs );
  Process_Close( log->processes );
  free( (char*)log );

  return TCL_OK;
}


static int Load( interp, log )
Tcl_Interp *interp;
logFile *log;
{
  switch (log->format) {

  case alog_format:
  case blog_format:

    return Alog_Open( log );

  case old_picl_format:

    return Picl_Open( log );

  case new_picl_format:
  case sddf_format:
  case vt_format:
  case unknown_format:
  default:
    Tcl_AppendResult( interp, "unknown logfile format", (char*)0 );
    return TCL_ERROR;
  }
}


static logFormat FormatStr2Enum( str )
char *str;
{
  if (!strcmp( str, "alog" )) return alog_format;
  if (!strcmp( str, "picl_1" )) return old_picl_format;
  else return unknown_format;
}



static int ReturnDouble( interp, num )
Tcl_Interp *interp;
double num;
{
  Tcl_PrintDouble( interp, num, interp->result );
  return TCL_OK;
}



static int ReturnInt( interp, num )
Tcl_Interp *interp;
int num;
{
  sprintf( interp->result, "%d", num );
  return TCL_OK;
}



double Log_StartTime( log )
logFile *log;
{
  return log->starttime;
}


double Log_EndTime( log )
logFile *log;
{
  return log->endtime;
}


int Log_Np( log )
logFile *log;
{
  return log->np;
}


  /* Event-handling stuff */

int Log_NeventDefs( log )
logFile *log;
{
  return Event_Ndefs( log->events );
}

int Log_GetEventDef( log, def_num, name )
logFile *log;
int def_num;
char **name;
{
  return Event_GetDef( log->events, def_num, name );
}

int Log_SetEventDef( log, def_num, name )
logFile *log;
int def_num;
char *name;
{
  return Event_SetDef( log->events, def_num, name );
}

int Log_Nevents( log )
logFile *log;
{
  return Event_N( log->events );
}

int Log_GetEvent( log, event_num, type, proc, time )
logFile *log;
int event_num, *type, *proc;
double *time;
{
  return Event_Get( log->events, event_num, type, proc, time );
}


  /* State-handling stuff */

int Log_NstateDefs( log )
logFile *log;
{
  return State_Ndefs( log->states );
}

int Log_GetStateDef( log, def_num, name, color, bitmap )
logFile *log;
int def_num;
char **name, **color, **bitmap;
{
  return State_GetDef( log->states, def_num, name, color, bitmap );
}

int Log_SetStateDef( log, def_num, name, color, bitmap )
logFile *log;
int def_num;
char *name, *color, *bitmap;
{
  return State_SetDef( log->states, def_num, name, color, bitmap );
}

int Log_Nstates( log )
logFile *log;
{
  return State_N( log->states );
}

/*
   Return the # of instances of the given state type.
*/
int Log_NstateTypeInst( log, idx )
logFile *log;
int idx;
{
  return State_TypeNinst( log->states, idx );
}


int Log_GetState( log, state_num, type, proc, startTime, endTime,
		  parent, firstChild, overlapLevel )
logFile *log;
int state_num, *type, *proc, *parent, *firstChild, *overlapLevel;
double *startTime, *endTime;
{
  return State_Get( log->states, state_num, type, proc, startTime, endTime,
		    parent, firstChild, overlapLevel );
}


   /* Message-handling stuff */

int Log_NmsgDefs( log )
logFile *log;
{
  return Msg_Ndefs( log->msgs );
}

int Log_GetMsgDef( log, def_num, name, tag, color )
logFile *log;
int def_num, *tag;
char **name, **color;
{
  return Msg_GetDef( log->msgs, def_num, name, tag, color );
}

int Log_SetMsgDef( log, def_num, name, tag, color )
logFile *log;
int def_num, tag;
char *name, *color;
{
  return Msg_SetDef( log->msgs, def_num, name, tag, color );
}

int Log_Nmsgs( log )
logFile *log;
{
  return Msg_N( log->msgs );
}

int Log_GetMsg( log, msg_num, type, sender, recver,
		     sendTime, recvTime, size )
logFile *log;
int msg_num;
int *type, *sender, *recver, *size;
double *sendTime, *recvTime;
{
  return Msg_Get( log->msgs, msg_num, type, sender, recver,
		  sendTime, recvTime, size );
}


  /* Process-handling stuff */

int Log_GetProcessDef( log, def_num, name )
logFile *log;
int def_num;
char **name;
{
  return Process_GetDef( log->processes, def_num, name );
}


int Log_SetProcessDef( log, def_num, name )
logFile *log;
int def_num;
char *name;
{
  return Process_SetDef( log->processes, def_num, name );
}


/* Tcl hooks */


/*
   Register the 'logfile' command with the Tcl interpreter.
*/
int Log_Init( interp )
Tcl_Interp *interp;
{
  Tcl_CreateCommand( interp, "logfile", CreateCmd, (ClientData)0,
		     (Tcl_CmdDeleteProc*)0 );
  return TCL_OK;
}



/*
   This impements the Tcl 'logfile' command.  When called,
   it creates a command for using this logfile instance and loads