int main ( int argc, char** argv ) {
OTF_Reader* reader = NULL;
OTF_HandlerArray* handlers;
OTF_FileManager* manager;
OTF_MasterControl* mc;
OTF_MapEntry* mapentry;
int read_stats= 0;
int read_snaps= 0;
int nstreams = 1;
int nfiles = 200;
int longformat = 0;
int showprogress= 0;
int i;
int readerbuffersize = 1024 * 1024;
int writerbuffersize = 1024 * 1024;
OTF_FileCompression compression= 0;
fcbT fcb;
char* infile= NULL;
char* outfile= NULL;
uint64_t minbytes;
uint64_t maxbytes;
uint64_t curbytes;
uint64_t minbytestmp;
uint64_t maxbytestmp;
uint64_t curbytestmp;
uint64_t recordsperupdate;
uint64_t totalbytes;
uint32_t progress_counter= 0;
uint64_t retde;
uint64_t retma;
uint64_t retev;
uint64_t retst;
uint64_t retsn;
fcb.error= 0;
if ( 1 >= argc ) {
SHOW_HELPTEXT;
return 0;
}
for ( i = 1; i < argc; i++ ) {
if ( ( 0 == strcmp( "-i", argv[i] ) ) && ( i+1 < argc ) ) {
infile= argv[i+1];
++i;
} else if ( ( 0 == strcmp( "-n", argv[i] ) ) && ( i+1 < argc ) ) {
nstreams = atoi( argv[i+1] );
++i;
} else if ( ( 0 == strcmp( "-rb", argv[i] ) ) && ( i+1 < argc ) ) {
readerbuffersize = atoi( argv[i+1] );
++i;
} else if ( ( 0 == strcmp( "-wb", argv[i] ) ) && ( i+1 < argc ) ) {
writerbuffersize = atoi( argv[i+1] );
++i;
} else if ( ( 0 == strcmp( "-f", argv[i] ) ) && ( i+1 < argc ) ) {
nfiles = atoi( argv[i+1] );
++i;
} else if ( ( 0 == strcmp( "-o", argv[i] ) ) && ( i+1 < argc ) ) {
outfile= argv[i+1];
++i;
} else if ( 0 == strcmp( "-stats", argv[i] ) ) {
read_stats= 1;
} else if ( 0 == strcmp( "-snaps", argv[i] ) ) {
read_snaps= 1;
} else if ( ( 0 == strcmp( "-z", argv[i] ) ) && ( i+1 < argc ) ) {
compression= atoi( argv[i+1] );
++i;
} else if ( 0 == strcmp( "-l", argv[i] ) ) {
longformat = 1;
} else if ( 0 == strcmp( "-p", argv[i] ) ) {
showprogress= 1;
} else if ( 0 == strcmp( "--help", argv[i] ) ||
0 == strcmp( "-h", argv[i] ) ) {
SHOW_HELPTEXT;
return 0;
} else if ( 0 == strcmp( "-V", argv[i] ) ) {
printf( "%u.%u.%u \"%s\"\n", OTF_VERSION_MAJOR, OTF_VERSION_MINOR,
OTF_VERSION_SUB, OTF_VERSION_STRING);
exit( 0 );
} else {
if ( '-' != argv[i][0] ) {
infile= argv[i];
} else {
fprintf( stderr, "ERROR: Unknown option: '%s'\n", argv[i] );
exit(1);
}
}
}
if ( nfiles < 1 ) {
fprintf( stderr, "ERROR: less than 1 filehandle is not permitted\n" );
exit(1);
}
if ( nstreams < 0 ) {
fprintf( stderr, "ERROR: less than 0 stream is not permitted\n" );
exit(1);
}
if ( NULL == infile ) {
fprintf( stderr, "ERROR: no input file specified\n" );
exit(1);
}
if ( NULL == outfile ) {
/*
fprintf( stderr, "ERROR: no output file has been specified\n" );
exit(1);
*/
outfile= "out.otf";
}
handlers = OTF_HandlerArray_open();
manager= OTF_FileManager_open( nfiles );
if( NULL == manager) {
fprintf( stderr, "Error: Unable to initialize File Manager. aborting\n" );
exit(1);
}
reader = OTF_Reader_open( infile, manager );
if ( NULL == reader ) {
fprintf( stderr, "Error: Unable to open '%s'. aborting\n", infile );
OTF_FileManager_close( manager );
OTF_HandlerArray_close( handlers );
exit(1);
}
OTF_Reader_setBufferSizes( reader, readerbuffersize );
fcb.writer = OTF_Writer_open( outfile, nstreams, manager );
OTF_Writer_setBufferSizes( fcb.writer, writerbuffersize );
OTF_Writer_setCompression( fcb.writer, compression );
if( longformat )
OTF_Writer_setFormat( fcb.writer, OTF_WSTREAM_FORMAT_LONG );
else
OTF_Writer_setFormat( fcb.writer, OTF_WSTREAM_FORMAT_SHORT );
mc = OTF_Reader_getMasterControl( reader );
/* set your own handler functions */
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefinitionComment,
OTF_DEFINITIONCOMMENT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFINITIONCOMMENT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefTimerResolution,
OTF_DEFTIMERRESOLUTION_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFTIMERRESOLUTION_RECORD);
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefProcess,
OTF_DEFPROCESS_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFPROCESS_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefProcessGroup,
OTF_DEFPROCESSGROUP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFPROCESSGROUP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefAttributeList,
OTF_DEFATTRLIST_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFATTRLIST_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefProcessOrGroupAttributes,
OTF_DEFPROCESSORGROUPATTR_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFPROCESSORGROUPATTR_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefFunction,
OTF_DEFFUNCTION_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFFUNCTION_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefFunctionGroup,
OTF_DEFFUNCTIONGROUP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFFUNCTIONGROUP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefCollectiveOperation,
OTF_DEFCOLLOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFCOLLOP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefCounter,
OTF_DEFCOUNTER_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFCOUNTER_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefCounterGroup,
OTF_DEFCOUNTERGROUP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFCOUNTERGROUP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefScl,
OTF_DEFSCL_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFSCL_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefSclFile,
OTF_DEFSCLFILE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFSCLFILE_RECORD );
/* OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefversion,
OTF_DEFVERSION_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFVERSION_RECORD );
*/
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefCreator,
OTF_DEFCREATOR_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFCREATOR_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefFile,
OTF_DEFFILE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFFILE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefFileGroup,
OTF_DEFFILEGROUP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFFILEGROUP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefKeyValue,
OTF_DEFKEYVALUE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_DEFKEYVALUE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefTimeRange,
OTF_DEFTIMERANGE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb,
OTF_DEFTIMERANGE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleDefCounterAssignments,
OTF_DEFCOUNTERASSIGNMENTS_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb,
OTF_DEFCOUNTERASSIGNMENTS_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleNoOp,
OTF_NOOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_NOOP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleEventComment,
OTF_EVENTCOMMENT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_EVENTCOMMENT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleCounter,
OTF_COUNTER_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_COUNTER_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleEnter,
OTF_ENTER_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_ENTER_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleCollectiveOperation,
OTF_COLLOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_COLLOP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleBeginCollectiveOperation,
OTF_BEGINCOLLOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_BEGINCOLLOP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleEndCollectiveOperation,
OTF_ENDCOLLOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_ENDCOLLOP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleRecvMsg,
OTF_RECEIVE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_RECEIVE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleSendMsg,
OTF_SEND_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_SEND_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleLeave,
OTF_LEAVE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_LEAVE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleBeginProcess,
OTF_BEGINPROCESS_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb,
OTF_BEGINPROCESS_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleEndProcess,
OTF_ENDPROCESS_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb,
OTF_ENDPROCESS_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleFileOperation,
OTF_FILEOPERATION_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb,
OTF_FILEOPERATION_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleBeginFileOperation,
OTF_BEGINFILEOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb,
OTF_BEGINFILEOP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleEndFileOperation,
OTF_ENDFILEOP_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb,
OTF_ENDFILEOP_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleRMAPut,
OTF_RMAPUT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb,
OTF_RMAPUT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleRMAPutRemoteEnd,
OTF_RMAPUTRE_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb,
OTF_RMAPUTRE_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleRMAGet,
OTF_RMAGET_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb,
OTF_RMAGET_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleRMAEnd,
OTF_RMAEND_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb,
OTF_RMAEND_RECORD );
/* snapshot records */
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleSnapshotComment,
OTF_SNAPSHOTCOMMENT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb,
OTF_SNAPSHOTCOMMENT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleEnterSnapshot,
OTF_ENTERSNAPSHOT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb,
OTF_ENTERSNAPSHOT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleSendSnapshot,
OTF_SENDSNAPSHOT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb,
OTF_SENDSNAPSHOT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleOpenFileSnapshot,
OTF_OPENFILESNAPSHOT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb,
OTF_OPENFILESNAPSHOT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleBeginCollopSnapshot,
OTF_BEGINCOLLOPSNAPSHOT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb,
OTF_BEGINCOLLOPSNAPSHOT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleBeginFileOpSnapshot,
OTF_BEGINFILEOPSNAPSHOT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb,
OTF_BEGINFILEOPSNAPSHOT_RECORD );
/* summary records */
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleSummaryComment,
OTF_SUMMARYCOMMENT_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_SUMMARYCOMMENT_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleFunctionSummary,
OTF_FUNCTIONSUMMARY_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_FUNCTIONSUMMARY_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleFunctionGroupSummary,
OTF_FUNCTIONGROUPSUMMARY_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_FUNCTIONGROUPSUMMARY_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleMessageSummary,
OTF_MESSAGESUMMARY_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_MESSAGESUMMARY_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleCollopSummary,
OTF_COLLOPSUMMARY_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_COLLOPSUMMARY_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleFileOperationSummary,
OTF_FILEOPERATIONSUMMARY_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_FILEOPERATIONSUMMARY_RECORD );
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleFileGroupOperationSummary,
OTF_FILEGROUPOPERATIONSUMMARY_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_FILEGROUPOPERATIONSUMMARY_RECORD );
/* marker record types */
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleDefMarker, OTF_DEFMARKER_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb, OTF_DEFMARKER_RECORD );
OTF_HandlerArray_setHandler( handlers, (OTF_FunctionPointer*) handleMarker, OTF_MARKER_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers, &fcb, OTF_MARKER_RECORD );
/* misc records */
OTF_HandlerArray_setHandler( handlers,
(OTF_FunctionPointer*) handleUnknown,
OTF_UNKNOWN_RECORD );
OTF_HandlerArray_setFirstHandlerArg( handlers,
&fcb, OTF_UNKNOWN_RECORD );
/* ask the mastercontrol for the number of streams and create the
* streaminfos array
*/
fcb.nstreaminfos = 0;
while ( 0 != OTF_MasterControl_getEntryByIndex( mc, fcb.nstreaminfos )) {
fcb.nstreaminfos++;
}
fcb.hash = hash_new ();
/* global stream yourself, because he isnt in the mapping */
hash_add( fcb.hash, 0 );
/* add all streams to the hash */
for( i = 0; i < fcb.nstreaminfos; i++ ) {
mapentry = OTF_MasterControl_getEntryByIndex( mc, i );
hash_add( fcb.hash, mapentry->argument );
}
/* read definitions */
retde= OTF_Reader_readDefinitions( reader, handlers );
if( OTF_READ_ERROR == retde || 1 == fcb.error ) {
fprintf( stderr, "Error while reading definitions. aborting\n" );
FINISH_EVERYTHING;
exit(1);
}
/* read markers */
retma= OTF_Reader_readMarkers( reader, handlers );
if( OTF_READ_ERROR == retma || 1 == fcb.error ) {
fprintf( stderr, "Error while reading marker records. aborting\n" );
FINISH_EVERYTHING;
exit(1);
}
if ( 0 == showprogress ) {
/* do not show the progress */
/* read events */
retev= OTF_Reader_readEvents( reader, handlers );
if( OTF_READ_ERROR == retev ) {
fprintf( stderr, "Error while reading events. aborting\n" );
FINISH_EVERYTHING;
exit(1);
}
/* read stats */
if ( 1 == read_stats ) {
retst= OTF_Reader_readStatistics( reader, handlers );
if( OTF_READ_ERROR == retst ) {
fprintf( stderr, "Error while reading statistics. aborting\n" );
FINISH_EVERYTHING;
exit(1);
}
}
/* read snaps */
if ( 1 == read_snaps ) {
retsn= OTF_Reader_readSnapshots( reader, handlers );
if( OTF_READ_ERROR == retsn ) {
fprintf( stderr, "Error while reading snapshots. aborting\n" );
FINISH_EVERYTHING;
exit(1);
}
}
} else {
/* show progress */
initProgressDisplay();
/* calculate how many records will be read */
minbytes= 0;
curbytes= 0;
maxbytes= 0;
OTF_Reader_setRecordLimit( reader, 0 );
retev= OTF_Reader_readEvents( reader, handlers );
if( OTF_READ_ERROR == retev ) {
fprintf( stderr, "Error while reading events. aborting\n" );
FINISH_EVERYTHING;
exit(1);
}
if ( 1 == read_stats ) {
retst= OTF_Reader_readStatistics( reader, handlers );
if( OTF_READ_ERROR == retst ) {
fprintf( stderr, "Error while reading statistics. aborting\n" );
FINISH_EVERYTHING;
exit(1);
}
}
if ( 1 == read_snaps ) {
retsn= OTF_Reader_readSnapshots( reader, handlers );
if( OTF_READ_ERROR == retsn ) {
fprintf( stderr, "Error while reading snapshots. aborting\n" );
FINISH_EVERYTHING;
exit(1);
}
}
OTF_Reader_eventBytesProgress( reader, &minbytestmp, &curbytestmp, &maxbytestmp );
minbytes+= minbytestmp;
maxbytes+= maxbytestmp;
if ( 1 == read_stats ) {
OTF_Reader_statisticBytesProgress( reader, &minbytestmp, &curbytestmp, &maxbytestmp );
minbytes+= minbytestmp;
maxbytes+= maxbytestmp;
}
/* read snaps */
if ( 1 == read_snaps ) {
OTF_Reader_snapshotBytesProgress( reader, &minbytestmp, &curbytestmp, &maxbytestmp );
minbytes+= minbytestmp;
maxbytes+= maxbytestmp;
}
curbytes= 0;
totalbytes= maxbytes - minbytes;
/* fixed number of records per update in order to provide
frequent update */
recordsperupdate= 100000;
OTF_Reader_setRecordLimit( reader, recordsperupdate );
while ( 0 != ( retev= OTF_Reader_readEvents( reader, handlers ) ) ) {
if( OTF_READ_ERROR == retev ) {
fprintf( stderr, "Error while reading events. aborting\n" );
FINISH_EVERYTHING;
exit(1);
}
OTF_Reader_eventBytesProgress( reader,
&minbytestmp, &curbytestmp, &maxbytestmp );
curbytes += curbytestmp - minbytestmp - curbytes;
updateProgressDisplay( progress_counter++, totalbytes, curbytes );
}
/* read stats */
while ( ( 1 == read_stats ) &&
( 0 != ( retst= OTF_Reader_readStatistics( reader, handlers ) ) ) ) {
if( OTF_READ_ERROR == retst ) {
fprintf( stderr, "Error while reading statistics. aborting\n" );
FINISH_EVERYTHING;
exit(1);
}
OTF_Reader_statisticBytesProgress( reader,
&minbytestmp, &curbytestmp, &maxbytestmp );
curbytes += curbytestmp - minbytestmp - curbytes;
updateProgressDisplay( progress_counter++, totalbytes, curbytes );
}
/* read snaps */
while ( ( 1 == read_snaps ) &&
( 0 != ( retsn= OTF_Reader_readSnapshots( reader, handlers ) ) ) ) {
if( OTF_READ_ERROR == retsn ) {
fprintf( stderr, "Error while reading snapshots. aborting\n" );
FINISH_EVERYTHING;
exit(1);
}
OTF_Reader_snapshotBytesProgress( reader,
&minbytestmp, &curbytestmp, &maxbytestmp );
curbytes += curbytestmp - minbytestmp - curbytes;
updateProgressDisplay( progress_counter++, totalbytes, curbytes );
}
finishProgressDisplay();
}
FINISH_EVERYTHING;
return 0;
}
int main( int argc, char** argv ) {
google::ParseCommandLineFlags( &argc, &argv, true);
google::InitGoogleLogging( argv[0] );
FLAGS_logtostderr = 1;
FLAGS_v = 1;
LOG(INFO) << "Starting!";
OTF_FileManager * manager = OTF_FileManager_open( 100 ); // limit to 100 filehandles
CHECK_NOTNULL( manager );
CHECK_NE( FLAGS_otf, "" ) << "Please specify input OTF file";
reader = OTF_Reader_open( FLAGS_otf.c_str(), manager );
CHECK_NOTNULL( reader );
OTF_Reader_setBufferSizes( reader, FLAGS_buffer_size );
if( FLAGS_db != "" ) {
auto retval = sqlite3_open( FLAGS_db.c_str(), &db );
if( retval ) {
LOG(FATAL) << "Can't open db " << FLAGS_db << ": " << sqlite3_errmsg(db);
}
std::stringstream ss;
ss << "CREATE TABLE IF NOT EXISTS " << FLAGS_table << "("
<< " TIME INT8 PRIMARY KEY NOT NULL,"
<< " COUNTER_NAME TEXT,"
<< " PROCESS INT,"
<< " INT_VALUE INT8,"
<< " DOUBLE_VALUE REAL);";
sqlite_exec( db, ss.str().c_str(), NULL, NULL );
sqlite_exec(db, "BEGIN TRANSACTION", NULL, NULL);
std::stringstream ss2;
ss2 << "INSERT OR IGNORE INTO " << FLAGS_table
<< " VALUES (?, ?, ?, ?, ?);";
sqlite_prepare( db, ss2.str().c_str(), -1, &stmt );
}
if( -1 != FLAGS_max_time ) {
OTF_Reader_setTimeInterval( reader, FLAGS_min_time, FLAGS_max_time );
}
OTF_HandlerArray * handlers = OTF_HandlerArray_open();
CHECK_NOTNULL( handlers );
// register handlers to do whatever you want.
// many handlers can be registered; full list here:
// http://wwwpub.zih.tu-dresden.de/~jurenz/otf/api/current/OTF__Definitions_8h.html
register_otf_handler( handlers, OTF_DEFCOUNTER_RECORD, defcounter_handler );
register_otf_handler( handlers, OTF_COUNTER_RECORD, counter_handler );
register_otf_handler( handlers, OTF_DEFTIMERRESOLUTION_RECORD, handle_time_resolution );
uint64_t read;
read = OTF_Reader_readDefinitions( reader, handlers );
LOG(INFO) << "Read " << read << " definitions";
read = OTF_Reader_readEvents( reader, handlers );
LOG(INFO) << "Read " << read << " events";
read = OTF_Reader_readStatistics( reader, handlers );
LOG(INFO) << "Read " << read << " statistics";
read = OTF_Reader_readSnapshots( reader, handlers );
LOG(INFO) << "Read " << read << " snapshots";
read = OTF_Reader_readMarkers( reader, handlers );
LOG(INFO) << "Read " << read << " markers";
sqlite_exec(db, "COMMIT TRANSACTION", NULL, NULL);
LOG(INFO) << "Done.";
if( stmt ) sqlite3_finalize( stmt );
if( db ) sqlite3_close( db );
OTF_Reader_close( reader );
OTF_HandlerArray_close( handlers );
OTF_FileManager_close( manager );
return 0;
}