def genParseEventStructures(allEvents, classId):
parseMacro = "TRACE_" + string.upper(classId) + "_PARSE_DEFINE_IN_C"
print '#ifdef', parseMacro
print "TraceEventParse trace" + classId + "EventParse[] = {"
# define a function to replace the positional arguments with %pos[%fmt]
pFmt = '%(?P<argNo>\d+)' # identify a field argument
def pFmt2k42(matchObject):
fieldNo = int(matchObject.group('argNo'))
fieldName = anEvent.getFieldNameByPos(fieldNo)
fieldFormat = anEvent.getFieldFormat(fieldName)
traceFieldNo = anEvent.getTraceFields().index(fieldName)
return '%' + str(traceFieldNo) + '[' + fieldFormat + ']'
# generate the parse structure for each event
for anEvent in allEvents:
print "\t{ __TR(" + pemEvent.getEventSpecifierMacro(anEvent) + "),"
parseString = "\""
for field in anEvent.getTraceFields(): # anEvent._fieldSeq:
parseString = parseString + \
pemTypes.getTypeBitSize(anEvent.getFieldType(field)) + " "
parseString = parseString + "\""
print "\t" + parseString + ","
if anEvent._printFormat != None:
print "\t \"" + re.sub(pFmt, pFmt2k42,
anEvent._printFormat) + "\"},"
else:
print "\t \"\" },"
print "};"
print '#else /* #ifdef', parseMacro, '*/'
print "extern TraceEventParse trace" + classId + "EventParse[];"
print '#endif /* #ifdef', parseMacro, '*/'
print '\n'
def genParseEventStructures(allEvents, classId):
parseMacro = "TRACE_" + string.upper(classId) + "_PARSE_DEFINE_IN_C"
print '#ifdef', parseMacro
print "TraceEventParse trace" + classId + "EventParse[] = {"
# define a function to replace the positional arguments with %pos[%fmt]
pFmt = '%(?P<argNo>\d+)' # identify a field argument
def pFmt2k42(matchObject):
fieldNo = int(matchObject.group('argNo'))
fieldName = anEvent.getFieldNameByPos(fieldNo)
fieldFormat = anEvent.getFieldFormat(fieldName)
traceFieldNo = anEvent.getTraceFields().index(fieldName)
return '%' + str(traceFieldNo) + '[' + fieldFormat + ']'
# generate the parse structure for each event
for anEvent in allEvents:
print "\t{ __TR(" + pemEvent.getEventSpecifierMacro(anEvent) + "),"
parseString = "\""
for field in anEvent.getTraceFields(): # anEvent._fieldSeq:
parseString = parseString + \
pemTypes.getTypeBitSize(anEvent.getFieldType(field)) + " "
parseString = parseString + "\""
print "\t" + parseString + ","
if anEvent._printFormat != None:
print "\t \""+re.sub(pFmt, pFmt2k42, anEvent._printFormat)+"\"},"
else:
print "\t \"\" },"
print "};"
print '#else /* #ifdef', parseMacro, '*/'
print "extern TraceEventParse trace" + classId + "EventParse[];"
print '#endif /* #ifdef', parseMacro, '*/'
print '\n'
def genNotifyEventId(anEvent):
if pemGlobals.dialect == 'K42':
print pemEvent.getEventMajorIdMacro(anEvent.getClassId()),
print ",\n\t\t\t" + pemEvent.getEventSpecifierMacro(anEvent),
print ", \n\t\t\t" + pemEvent.getLayerIdMacro(anEvent.getLayerId()),
elif pemGlobals.dialect == 'AIX':
print "TRACE_" + anEvent.getQualifiedSpecifier(),
else:
print "TRACE_" + anEvent.getQualifiedSpecifier(),
def genNotifyEventId(anEvent):
if pemGlobals.dialect == 'K42':
print pemEvent.getEventMajorIdMacro(anEvent.getClassId()),
print ",\n\t\t\t"+pemEvent.getEventSpecifierMacro(anEvent),
print ", \n\t\t\t" + pemEvent.getLayerIdMacro(anEvent.getLayerId()),
elif pemGlobals.dialect == 'AIX':
print "TRACE_" + anEvent.getQualifiedSpecifier(),
else:
print "TRACE_" + anEvent.getQualifiedSpecifier(),
def genFortranHeader(layerId, classId, layerEvents, wrappers):
genFtnPreamble()
# generate the specifiers enum
specCnt = 0
for anEvent in layerEvents[classId]:
print '\tinteger*2', pemEvent.getEventSpecifierMacro(anEvent)
print '\tparameter (', pemEvent.getEventSpecifierMacro(anEvent), '=', str(specCnt),')'
specCnt = specCnt + 1
#for anEvent in layerEvents[classId]:
# # generate the specifier for the interval event
# if anEvent.isIntervalEvent() and anEvent.getIntervalType()=='END':
# intervalEvent = anEvent.transferClassName()
# print '\tinteger*2', intervalEvent.getSpecifier()
# print '\tparameter (', intervalEvent.getSpecifier(), '=', str(specCnt),')'
# specCnt = specCnt + 1
print '\n'
for aWrapper in wrappers:
print '\texternal', aWrapper
def genStreamConstructor(anEvent):
print '\n'
print '\t/** stream constructor for class readers */'
print '\t', anEvent.getClassName(), '(TraceInputStream istr)', \
'throws TraceException, IOException {'
print '\t\tsuper(istr);'
# check that the record is of this class
print '\t\tif(getLayerId() !=', anEvent.getLayerId(), \
'|| getClassId() !=', pemEvent.getEventMajorIdMacro(anEvent.getClassId()), \
'|| getSpecifier() !=', pemEvent.getEventSpecifierMacro(anEvent),\
')'
print '\t\t\tthrow new TraceException("event " + getLayerId() + ":" +',\
'getClassId() + ":" + getSpecifier() + " is not of type', anEvent._name,'");'
if len(anEvent._fieldSeq) > 0:
print '\t\tfinal TraceInputStream recordStr =', \
'new TraceInputStream(getPayloadAsStream());'
# read the fields off the payload
for field in anEvent.getTraceFields(): # anEvent._fieldSeq:
if anEvent.isListField(field):
listLength = getListLength(anEvent, field)
print '\t\t', anEvent.getFieldName(field), '= new', \
getListEltType(anEvent, field), \
'[', listLength, '];'
print '\t\tfor(unsigned int i = 0; i <', listLength, '; i++)'
print '\t\t\t', anEvent.getFieldName(field), '[i] =', \
string.join(('recordStr.read', \
getJavaReaderType(anEvent, field), \
'()'), ''), \
';'
else:
print '\t\t', anEvent.getFieldName(field), '=', \
string.join(('recordStr.read', \
getJavaReaderType(anEvent, field),'()'),''), \
';'
print '\t}'
def genFiles(layer, layerEvents, outputDir):
fd = None
for classId in layerEvents.keys():
if pemGlobals.dummyOutput == 0:
fd = open(os.path.join(outputDir, "trace" + classId + ".h"), 'w')
sys.stdout = fd
classIdUpper = string.upper(classId)
print "#ifndef __TRACE_" + classIdUpper + "_H_"
print "#define __TRACE_" + classIdUpper + "_H_"
genPreamble()
if pemGlobals.genTraceStubs > 0:
print "#ifdef TRACE_STUBS"
print "#include <stdio.h>"
print "#endif"
print "\n"
if pemGlobals.dialect == 'AIX':
print "/* following for AIX trace hooks */"
# print "#include <sys/trcctl.h>" ...not sure this is necessary
print "#include <sys/trcmacros.h>"
print "#include <sys/trchkid.h>"
print "\n"
if pemGlobals.dialect != 'K42':
print "#include <traceHeader.h>"
print "#include <traceRecord.h>"
print "#include <notify.h>"
print "#include \"trace" + layer + "Classes.h\"\n"
print "/* the XLC compiler does not accept inline and long long at the same time."
print " * Using the _XLC_INLINE macro we can force the inline. */"
print "#ifdef __GNUC__"
print "#define _XLC_INLINE static inline"
print "#else"
print "#define _XLC_INLINE"
print "#endif"
print "\n"
# generate the specifiers enum
print 'enum {',
for anEvent in layerEvents[classId]:
print '\t', pemEvent.getEventSpecifierMacro(anEvent), ','
# generate the specifier for the interval events
#for anEvent in layerEvents[classId]:
# if anEvent.isIntervalEvent() and anEvent.getIntervalType()=='END':
# print '\t', pemEvent.getEventSpecifierMacro(anEvent.transferClassName()), ','
print '\t', "TRACE_" + string.upper(
layer) + "_" + classIdUpper + "_MAX"
print '};\n'
# generate global eventId macros
if pemGlobals.dialect != 'K42':
for anEvent in layerEvents[classId]:
print "#define TRACE_"+anEvent.getQualifiedSpecifier()+ \
" \\\n"+ " (" +\
"(" + pemEvent.getLayerIdMacro(layer) + "<<20)|(" + \
pemEvent.getEventMajorIdMacro(classId) + "<<14)|(" + \
pemEvent.getEventSpecifierMacro(anEvent) + "))"
print '\n'
if pemGlobals.dialect == 'K42':
genParseEventStructures(layerEvents[classId], classId)
# generate the function calls
if classId != 'Default':
genInlineMethods(layerEvents[classId], classId)
print "#endif /* #ifndef __TRACE_" + classIdUpper + "_H_ */"
if pemGlobals.dummyOutput == 0:
sys.stdout = sys.__stdout__
fd.close()
def genAllClasses(allEvents, allClassIds, outputDir):
fd = None
for layer in allEvents.keys():
fileName = ""
if pemGlobals.dummyOutput == 0:
fileName = layer + ".H"
fd = open(os.path.join(outputDir, fileName), 'w')
sys.stdout = fd
genPreamble(fileName)
print 'namespace PEM {\n'
print 'namespace', layer + "Layer", '{'
print ''
if allClassIds.has_key(layer):
print '\t/* enum for event classIds in layer', layer, '*/'
print '\tenum {'
for classId, classVal in allClassIds[layer]:
print '\t\t', pemEvent.getEventMajorIdMacro(classId), \
'=', classVal, ','
print '};'
print '\n'
# generate the specifiers enum
for classId in allEvents[layer].keys():
if pemGlobals.strictXMLChecking == 1:
if not allClassIds.has_key(layer) or \
allClassIds[layer].count(classId) == 0:
raise "Event class " + str(classId) + \
" has not been defined for layer " + str(layer)
print '\t/* enum for the event specifiers in class', classId, '*/'
print '\tenum {'
for anEvent in allEvents[layer][classId]:
# print anEvent.getSpecifier(), ',',
print '\t\t', pemEvent.getEventSpecifierMacro(anEvent), ','
for anEvent in allEvents[layer][classId]:
# generate the specifier for the interval event
if anEvent.isIntervalEvent() and anEvent.getIntervalType()=='END':
print '\t\t', pemEvent.getEventSpecifierMacro(anEvent.transferClassName()), ','
print '};'
print '} // end namespace', layer + "Layer"
# generate the event classes
for classId in allEvents[layer].keys():
for anEvent in allEvents[layer][classId]:
print '\n'
genCPPClass(anEvent)
print '} // end namespace PEM'
print '\n#endif /*', getHeaderDefine(fileName), '*/'
if pemGlobals.dummyOutput == 0:
sys.stdout = sys.__stdout__
fd.close()
genEventSwitch(allEvents, allClassIds, outputDir)
if pemGlobals.dialect == 'AIX':
genAIXTraceReader(allEvents, allClassIds, outputDir)
if pemGlobals.dialect == 'MPI':
genGetRank(allEvents, allClassIds, outputDir)
def genGeneratorConstructor(anEvent):
print '\n'
print '\t/** constructor for trace record generators */'
print '\t', anEvent.getClassName(), '(int timestamp__',
# generate the prototype
# used to compute the record size
recLen = '8'
# get the trace layout of the arguments
packedArgs = anEvent.packFields();
# generate all filed arguments
listFieldOrd = 0
for field in anEvent._fieldSeq:
if anEvent.isListField(field) and anEvent.getListCount(field) == None:
print ',\n\t\tuint32', "listLengthInBytes" + str(listFieldOrd),
listFieldOrd = listFieldOrd + 1
print ',\n\t\t', getFieldType(anEvent, field), \
anEvent.getFieldNameStripped(field),
print ')',
# compute the actual record length
listFieldOrd = 0
for field in packedArgs:
fn = packedArgs[field]
if anEvent.hasField(fn) and anEvent.isListField(fn):
if anEvent.getFieldType(fn) == 'string':
recLen = recLen + "+0"
continue
if anEvent.getListCount(fn) != None:
recLen = recLen + "+(" +\
string.replace(anEvent.getListCount(fn),'_','',1)+\
"*" + \
pemTypes.getTypeRawSize(anEvent.getFieldType(fn),
fn) + ")"
else:
recLen = recLen + "+listLengthInBytes" + str(listFieldOrd)
listFieldOrd = listFieldOrd + 1
elif anEvent.hasField(fn):
recLen = recLen + "+" + \
pemTypes.getTypeRawSize(anEvent.getFieldType(fn),fn)
else:
recLen = recLen + "+8"
# call parent constructor
print ' :\n\t TraceRecord(',
print 'timestamp__,', anEvent.getLayerId(), ',', \
pemEvent.getEventMajorIdMacro(anEvent.getClassId()), ',' , \
pemEvent.getEventSpecifierMacro(anEvent),', (',recLen,')) {'
# if the event has no fields, just return
if len(anEvent._fieldSeq) == 0:
print '\t}'
return
# write all the records
print '\t\t/* copy the arguments into the fields of the record, in case\n',
print '\t\t * the event gets used for anything else than dumping */'
for field in anEvent._fieldSeq:
argField = string.replace(anEvent.getFieldName(field), '_', '', 1)
if anEvent.isListField(field):
lenVar = "__" + anEvent.getFieldName(field) + "Len"
print '\t\t', anEvent.getFieldName(field), '= new ',\
getListEltType(anEvent, field), \
'[', getListLength(anEvent, field), '];'
if anEvent.getFieldType(field) == 'string':
print "\t\tunsigned int " + lenVar + " = 0;"
print '\t\tfor(unsigned int i = 0; i <', \
getListLength(anEvent, field), '; i++) {'
if anEvent.getFieldType(field) == 'string':
print '\t\t\t', anEvent.getFieldName(field), \
'[i] = strdup(', argField, '[i]);'
print '\t\t\t', lenVar, '+=', \
pemTypes.getTypeRawSize(anEvent.getFieldType(field),
anEvent.getFieldName(field)+'[i]'), \
';'
else:
print '\t\t\t', anEvent.getFieldName(field), \
'[i] =', argField, '[i];'
print '\t\t}'
if anEvent.getFieldType(field) == 'string':
print '\t\tsetRecordLength(getRecordLength() +', lenVar, '/8);'
else:
if anEvent.getFieldType(field) == 'string':
lenVar = "__" + anEvent.getFieldName(field) + "Len"
print '\t\tint', lenVar, '=', \
pemTypes.getTypeRawSize(anEvent.getFieldType(field),
argField), ';'
print '\t\t', anEvent.getFieldName(field),'= new char[', \
lenVar ,'];'
print '\t\tmemcpy(', anEvent.getFieldName(field), ',', \
argField, ', strlen(', argField, ')+1);'
else:
print '\t\t', anEvent.getFieldName(field), '=', \
argField, ';'
print '\n\t\t/* write the fields into the payload */'
sortedKeys = packedArgs.keys()
sortedKeys.sort()
declareTmp = 1
for pArg in sortedKeys:
field = packedArgs[pArg]
if anEvent.hasField(field):
if anEvent.isListField(field):
# write a list of strings
if anEvent.getFieldType(field) == 'string':
print '\t\tfor(unsigned i = 0; i <', \
getListLength(anEvent, field), '; i++) {'
lenVar = "__" + anEvent.getFieldName(field) + "Len"
print '\t\t\t', lenVar, '=', \
pemTypes.getTypeRawSize(anEvent.getFieldType(field),
anEvent.getFieldName(field)+'[i]'), ';'
print '\t\t\twritePayload((char *)', \
anEvent.getFieldName(field), '[i],', lenVar, ');'
print '\t\t}'
else: # write a list that's not of strings
lenVar = getTypeSize(anEvent, field)
print '\t\twritePayload((char *)', \
anEvent.getFieldName(field), ',', lenVar, ');'
else:
if anEvent.getFieldType(field) == 'string':
lenVar = "__" + anEvent.getFieldName(field) + "Len"
print '\t\twritePayload((char *)', \
anEvent.getFieldName(field), ',', lenVar, ');'
else:
lenVar = getTypeSize(anEvent, field)
print '\t\twritePayload((char *)&', \
anEvent.getFieldName(field), ',', lenVar, ');'
else:
if declareTmp == 1:
print '\t\tuint64 __tmp;'
declareTmp = 0
print '\t\t__tmp =', packedArgs[pArg], ';',
print 'writePayload((char *)&__tmp, 8);'
print '\t}'
def genRecordConstructor(anEvent):
print '\npublic:'
print '\t/** copy constructor for class readers */'
print '\t', anEvent.getClassName(), \
'(const TraceRecord &r, const char endianEnc)', \
': TraceRecord(r) {'
# check that the record is of this class
print '\t\tassert(r.getLayerId() ==', anEvent.getLayerId(), \
'&& r.getClassId() ==', pemEvent.getEventMajorIdMacro(anEvent.getClassId()), \
'&& r.getSpecifier() ==', pemEvent.getEventSpecifierMacro(anEvent),\
');'
if len(anEvent._fieldSeq) > 0:
print '\t\tuint32 __pos = 0;'
# read the fields off the payload in chunks of 64 bytes.
declareTmp = 1
byteOffset = 0
packedFields = anEvent.packFields()
currentField = 0
for field in anEvent.getTraceFields(): # anEvent._fieldSeq:
if anEvent.isListField(field):
listLength = getListLength(anEvent, field)
# print '\t\tassert(', listLength, '< r.getPayloadLength());'
print '\t\t', anEvent.getFieldName(field), '= new', \
getListEltType(anEvent, field), \
'[', listLength, '];'
print '\t\tfor(unsigned int i = 0; i <', listLength, '; i++) {'
_fieldName = anEvent.getFieldName(field) + "[i]"
_fieldType = getListEltType(anEvent, field)
_fieldTypeSize = pemTypes.getTypeRawSize(anEvent.getFieldType(field),
_fieldName)
byteOffset = 0 # force reloading next field
# retrieve the field
if anEvent.getFieldType(field) == 'string':
print '\t\t', _fieldName, '=', \
'strdup(r.getPayloadString(__pos));'
print '\t\t__pos +=', _fieldTypeSize, ';'
else:
print '\t\tif( ((i*', _fieldTypeSize, ')& 0x7)==0) {'
print '\t\t\tif((__pos >> 3) < r.getPayloadLength()) {'
print '\t\t\t__tmp8bytes =',\
'*(uint64 *)r.getPayloadString(__pos, 8);'
print '\t\t\t__tmp8bytes =TR2HO_8(__tmp8bytes, endianEnc);'
print '\t\t\t__pos += 8;'
print '\t\t} else { __tmp8bytes = 0; } // added fields '
print '\t\t}'
if _fieldTypeSize != '8':
print '\t\t', _fieldName, '= (', _fieldType, ')', \
'((__tmp8bytes >>', \
'((8-((i*',_fieldTypeSize,')&0x7)-',_fieldTypeSize, \
')*8)) &', (str((1<<int(_fieldTypeSize)*8)-1)+'UL'),\
');'
else:
print '\t\t', _fieldName, '= __tmp8bytes;'
print '\t\t}'
else:
_fieldName = anEvent.getFieldName(field)
_fieldType = getFieldType(anEvent, field)
_fieldTypeSize = pemTypes.getTypeRawSize(anEvent.getFieldType(field),
_fieldName)
# retrieve the field
if anEvent.getFieldType(field) == 'string':
print '\t\t', _fieldName, '=', \
'strdup(r.getPayloadString(__pos));'
print '\t\t__pos +=', _fieldTypeSize, ';'
byteOffset = 0
else:
if declareTmp == 1:
print '\t\tuint64 __tmp8bytes;'
declareTmp = 0
# if I cant find the current argument in the packed expr
# it means that I need to move to the next 8 bytes
if string.find(packedFields[currentField], field) == -1:
byteOffset = 0
currentField = currentField + 1
if byteOffset == 0:
print '\t\tif((__pos >> 3) < r.getPayloadLength()) {'
print '\t\t\t__tmp8bytes =',\
'*(uint64 *)r.getPayloadString(__pos, 8);'
print '\t\t\t__tmp8bytes =TR2HO_8(__tmp8bytes, endianEnc);'
print '\t\t} else { __tmp8bytes = 0; } // added fields '
print '\t\t\t__pos += 8;'
if _fieldTypeSize != '8':
print '\t\t', _fieldName, '= (', _fieldType, ')', \
'((__tmp8bytes >>', \
((8-byteOffset-int(_fieldTypeSize))*8),\
') &', (str((1<<int(_fieldTypeSize)*8)-1)+'UL') ,');'
else:
print '\t\t', _fieldName, '= __tmp8bytes;'
byteOffset = (byteOffset + int(_fieldTypeSize)) % 8
print '\t}'
def genFiles(layer, layerEvents, outputDir):
fd = None
for classId in layerEvents.keys():
if pemGlobals.dummyOutput == 0:
fd = open(os.path.join(outputDir, "trace" + classId + ".h"), 'w')
sys.stdout = fd
classIdUpper = string.upper(classId)
print "#ifndef __TRACE_" + classIdUpper + "_H_"
print "#define __TRACE_" + classIdUpper + "_H_"
genPreamble()
if pemGlobals.genTraceStubs > 0:
print "#ifdef TRACE_STUBS"
print "#include <stdio.h>"
print "#endif"
print "\n"
if pemGlobals.dialect == 'AIX':
print "/* following for AIX trace hooks */"
# print "#include <sys/trcctl.h>" ...not sure this is necessary
print "#include <sys/trcmacros.h>"
print "#include <sys/trchkid.h>"
print "\n"
if pemGlobals.dialect != 'K42':
print "#include <traceHeader.h>"
print "#include <traceRecord.h>"
print "#include <notify.h>"
print "#include \"trace" + layer + "Classes.h\"\n"
print "/* the XLC compiler does not accept inline and long long at the same time."
print " * Using the _XLC_INLINE macro we can force the inline. */"
print "#ifdef __GNUC__"
print "#define _XLC_INLINE static inline"
print "#else"
print "#define _XLC_INLINE"
print "#endif"
print "\n"
# generate the specifiers enum
print 'enum {',
for anEvent in layerEvents[classId]:
print '\t', pemEvent.getEventSpecifierMacro(anEvent), ','
# generate the specifier for the interval events
#for anEvent in layerEvents[classId]:
# if anEvent.isIntervalEvent() and anEvent.getIntervalType()=='END':
# print '\t', pemEvent.getEventSpecifierMacro(anEvent.transferClassName()), ','
print '\t',"TRACE_" + string.upper(layer) + "_" + classIdUpper + "_MAX"
print '};\n'
# generate global eventId macros
if pemGlobals.dialect != 'K42':
for anEvent in layerEvents[classId]:
print "#define TRACE_"+anEvent.getQualifiedSpecifier()+ \
" \\\n"+ " (" +\
"(" + pemEvent.getLayerIdMacro(layer) + "<<20)|(" + \
pemEvent.getEventMajorIdMacro(classId) + "<<14)|(" + \
pemEvent.getEventSpecifierMacro(anEvent) + "))"
print '\n'
if pemGlobals.dialect == 'K42':
genParseEventStructures(layerEvents[classId], classId)
# generate the function calls
if classId != 'Default':
genInlineMethods(layerEvents[classId], classId)
print "#endif /* #ifndef __TRACE_" + classIdUpper + "_H_ */"
if pemGlobals.dummyOutput == 0:
sys.stdout = sys.__stdout__
fd.close()
