int main (int argc, char **argv) {
#ifdef HAVE_VTF3
fcbT fha;
int i;
int numcpus;
char* inputFile = NULL;
char* outputFile = NULL;
int buffersize= 1024;
OTF_FileManager* manager;
OTF_Reader* reader;
OTF_HandlerArray* handlers;
nodeT* p_root;
int format= VTF3_FILEFORMAT_STD_ASCII;
handlers = OTF_HandlerArray_open();
/* argument handling */
if ( 1 >= argc ) {
SHOW_HELPTEXT;
exit(0);
}
for ( i = 1; i < argc; i++ ) {
if( 0 == strcmp( "-i", argv[i] ) ) {
if( i+1 < argc ) {
inputFile= strdup( argv[i+1] );
++i;
}
} else if ( 0 == strcmp( "-o", argv[i] ) ) {
if( i+1 < argc ) {
outputFile = argv[i+1];
++i;
}
} else if( ( 0 == strcmp( "-b", argv[i] ) ) && ( i+1 < argc ) ) {
buffersize = atoi( argv[i+1] );
++i;
} else if ( 0 == strcmp( "--help", argv[i] ) ||
0 == strcmp( "-h", argv[i] ) ) {
SHOW_HELPTEXT;
exit(0);
} else if ( 0 == strcmp( "-A", argv[i] ) ) {
format= VTF3_FILEFORMAT_STD_ASCII;
} else if ( 0 == strcmp( "-B", argv[i] ) ) {
format= VTF3_FILEFORMAT_STD_BINARY;
} else if ( 0 == strcmp( "-V", argv[i] ) ) {
printf( "%u.%u.%u \"%s\"\n", OTF_VERSION_MAYOR, OTF_VERSION_MINOR,
OTF_VERSION_SUB, OTF_VERSION_STRING);
exit( 0 );
} else {
if ( '-' != argv[i][0] ) {
inputFile= strdup( argv[i] );
} else {
fprintf( stderr, "ERROR: Unknown argument.\n" );
exit(1);
}
}
}
if ( NULL == inputFile ) {
printf( " no input file specified\n" );
exit(1);
}
if ( NULL == outputFile ) {
printf( " no output file specified\n" );
exit(1);
}
/* open filemanager */
manager= OTF_FileManager_open( 100 );
assert( NULL != manager );
/* Open OTF Reader */
reader = OTF_Reader_open( inputFile, manager );
if( NULL == reader ) {
fprintf( stderr, "cannot open input trace '%s'\n", inputFile );
exit( 1 );
}
OTF_Reader_setBufferSizes( reader, buffersize );
free( inputFile );
/* Initialize VTF3. */
(void) VTF3_InitTables ();
fha.fcb = VTF3_OpenFileOutput ( outputFile, format, 0);
assert( 0 != fha.fcb );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleDefinitionComment,
OTF_DEFINITIONCOMMENT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_DEFINITIONCOMMENT_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleDeftimerresolution,
OTF_DEFTIMERRESOLUTION_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_DEFTIMERRESOLUTION_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleDefprocess,
OTF_DEFPROCESS_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_DEFPROCESS_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleDefprocessgroup,
OTF_DEFPROCESSGROUP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_DEFPROCESSGROUP_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleDeffunction,
OTF_DEFFUNCTION_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_DEFFUNCTION_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleDeffunctiongroup,
OTF_DEFFUNCTIONGROUP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_DEFFUNCTIONGROUP_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleDefcounter,
OTF_DEFCOUNTER_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_DEFCOUNTER_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleDefcountergroup,
OTF_DEFCOUNTERGROUP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_DEFCOUNTERGROUP_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleDefCollectiveOperation,
OTF_DEFCOLLOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_DEFCOLLOP_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleDefscl,
OTF_DEFSCL_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_DEFSCL_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleDefsclfile,
OTF_DEFSCLFILE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_DEFSCLFILE_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleDefFile,
OTF_DEFFILE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_DEFFILE_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleEventComment,
OTF_EVENTCOMMENT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_EVENTCOMMENT_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleCounter,
OTF_COUNTER_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_COUNTER_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleEnter,
OTF_ENTER_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_ENTER_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*)
handleCollectiveOperation, OTF_COLLOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha,
OTF_COLLOP_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleRecvmsg,
OTF_RECEIVE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_RECEIVE_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleSendmsg,
OTF_SEND_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_SEND_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleLeave,
OTF_LEAVE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha, OTF_LEAVE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleBeginProcess,
OTF_BEGINPROCESS_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha,
OTF_BEGINPROCESS_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleEndProcess,
OTF_ENDPROCESS_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha,
OTF_ENDPROCESS_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleFileOperation,
OTF_FILEOPERATION_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fha,
OTF_FILEOPERATION_RECORD );
/***************/
treehash_init( &p_root, &fha.p_hashtab);
fha.FileIOQueue= FileIOEndQueue_init();
/***************/
VTF3_WriteDefversion( fha.fcb, OTF2VTF3VERSION);
VTF3_WriteDefcreator( fha.fcb, OTF2VTF3CREATOR );
OTF_Reader_readDefinitions( reader, handlers );
/***************/
numcpus = 0;
/* indicate the processes */
for( i = 0; i < p_root->childrensize; i++ ) {
numcpus = treehash_createindices( numcpus, p_root->p_children[i] );
}
if ( numcpus == 0)
{
fprintf( stderr, "There are no cpus.\n" );
exit(1);
}
/* write VTF3_syscpunum-record */
VTF3_WriteDefsyscpunums( fha.fcb, 1, &numcpus );
/* write VFT3_cpuname-records */
for( i = 0; i < p_root->childrensize; i++ ) {
writenames_recursive( fha.fcb, p_root->p_children[i] );
}
/***************/
OTF_Reader_readEvents( reader, handlers );
/***************/
FileIOEndQueue_finish( &fha.FileIOQueue );
treehash_deleteall( fha.p_hashtab );
/***************/
/* Close all devices. */
(void) VTF3_Close ( fha.fcb );
OTF_Reader_close( reader );
OTF_HandlerArray_close( handlers );
OTF_FileManager_close( manager );
#else /* HAVE_VTF3 */
fprintf( stderr, "VTF3 not available, otf2vtf deactivated\n" );
#endif /* HAVE_VTF3 */
return (0);
}
int main(int argc, char **argv) {
char* infile;
char* outfile;
char* dot;
int ch;
int fmt = VTF3_FILEFORMAT_STD_ASCII;
int eflag = 0;
struct stat statbuf;
elg_ui4 numrec = 0;
elg_ui4 limrec = 0xFFFFFFFF;
elg_ui4 limsiz = 0xFFFFFFFF;
ElgRCB* handle = NULL;
MYDATA md = { 0, 0, 0, 0 };
while ((ch = getopt(argc, argv, "abfghin:r:s:GO")) != EOF) {
switch (ch) {
case 'a': fmt = VTF3_FILEFORMAT_STD_ASCII;
break;
case 'b': fmt = VTF3_FILEFORMAT_STD_BINARY;
break;
case 'f': fmt = VTF3_FILEFORMAT_FST_ASCII;
break;
case 'g': genompglop = 0;
break;
case 'G': genmpiglop = 0;
genompglop = 0;
break;
case 'i': addidle = 0;
break;
case 'n': limrec = atol(optarg);
break;
case 'O':
#ifdef VTF3_HAS_OPENMP
writeOMP = 1;
genompglop = 0;
#endif
break;
case 's': limsiz = atol(optarg);
break;
case 'r': rmatag = atol(optarg);
break;
case 'h':
case '?': eflag = 1;
break;
}
}
if ((argc-optind) == 2) {
infile = epk_get_elgfilename(argv[optind]);
outfile = argv[optind+1];
} else if ((argc-optind) == 1) {
infile = epk_get_elgfilename(argv[optind]);
outfile = strdup(infile);
dot = strrchr(outfile, '.');
*(dot + 1) = 'v';
*(dot + 2) = 'p';
*(dot + 3) = 't';
} else {
eflag = 1;
}
if ( eflag ) {
fprintf(stderr, "Usage: %s [-a|-b|-f] [-i] [-g|-G] [-O] [-n #] [-s #]"
" [-r #]"
" (<infile>.elg | <experiment_archive>) [<outfile>]\n",
argv[0]);
fprintf(stderr, "Options: -a force standard ascii output\n");
fprintf(stderr, " -b force binary output\n");
fprintf(stderr, " -f force fast ascii output\n");
fprintf(stderr, " -g do not generate globalops for OMP barriers\n");
fprintf(stderr, " -G do not generate globalops (for MPI + OMP)\n");
fprintf(stderr, " -i do not add idle state\n");
fprintf(stderr, " -O generate VTF3 OpenMP events\n");
fprintf(stderr, " -n stop converting after # records\n");
fprintf(stderr, " -s stop converting after # bytes written\n");
fprintf(stderr, " -r use # as tag for RMA operations\n");
fprintf(stderr, "If <outfile> is omitted, <infile>.vpt is used for output\n");
fflush(stderr);
exit(EXIT_FAILURE);
}
handle = elg_read_open(infile);
if ( ! handle ) exit(EXIT_FAILURE);
stat(infile, &statbuf);
conv_init();
VTF3_InitTables();
if ( (fcb = VTF3_OpenFileOutput(outfile, fmt, genmpiglop)) == 0 ) {
fprintf(stderr, "Can't open output file %s\n", outfile);
fflush(stderr);
exit(EXIT_FAILURE);
}
wbytes += VTF3_WriteDefversion(fcb, VTF3_GetVersionNumber());
wbytes += VTF3_WriteDefcreator(fcb, "epilog -> vtf3 converter 1.3");
while ( elg_read_next(handle, (void*) &md) ) {
numrec++;
if ( numrec % 1000 == 0 ) {
printf("done: %3.0f%%\r", ((double) md.done / statbuf.st_size) * 100.0);
fflush(stdout);
}
if ( numrec > limrec ) {
printf("Limit of %u records reached.\n", limrec);
break;
}
if ( wbytes > limsiz ) {
printf("Limit of %ld bytes reached.\n", (long)wbytes);
break;
}
}
{
int lid;
if ( state_idle != -1 && addidle ) {
for(lid=0; lid<totallocs; lid++) {
if ( loctab[lid].proc->member[0].id != lid ) {
wbytes += VTF3_WriteUpfrom(fcb, lasttime*1.0e+10, (int) state_idle,
locmap[lid], VTF3_SCLNONE);
}
}
}
}
elg_read_close(handle);
VTF3_Close(fcb);
return 0;
}
