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()