root/branches/atorf/personal playground/NXCProfiler/Analyzer/AnalyzeNXCProfile.py @ 857

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""

    Author:  Linus Atorf
    Date:    2009-12-08
    License: GPLv3

"""

from __future__ import division

from optparse import OptionParser

import os
import sys
#import math
#import platform
#import time
#import copy

import HTMLSnippets


__author__           = "Linus Atorf"
__version__          = "0.1"
__date__             = "2009-12-08"
__copyright__        = "Copyright © 2009 Linus Atorf"
__organizationName__ = "LA"
__applicationName__  = "NXC Profile Analyzer"


class StuffHolder(object):
    pass


Consts = StuffHolder()
Vars   = StuffHolder()

Vars.verbose = False


Consts.CODENOTPROFILED = 0
Consts.CODEDIDNTRUN    = 1
Consts.CODEPROFILED    = 2

verbosePrint = None  # this is gonne be a method!

#Consts.



def unflatten4(input):
    out = ord(input[0]);
    out = out + ord(input[1]) * 256
    out = out + ord(input[2]) * 65536
    out = out + ord(input[3]) * 16777216
    return out
#end def



def printMethod(str):
    print str
    
def emptyMethod(str):
    pass



def parseProfileFile(filename):
    try:
        f = file(filename, "rb")
    except (IOError, OSError):
        print "Could not find or open input file"
        sys.exit(1)
    #end try

    out = StuffHolder()
    try:
        verbosePrint(" - Parsing firmware string")
        out.FirmwareString = f.read(3)
        verbosePrint(" - Parsing enhanced FW flag")
        if f.read(1) == "1":
            out.EnhancedFW = True
        else:
            out.EnhancedFW = False
        #end if
        verbosePrint(" - Parsing global stats")
        out.TotalRunTime     = unflatten4(f.read(4))
        out.ProfiledRunTime  = unflatten4(f.read(4))
        out.MaxSections      = unflatten4(f.read(4))
    except:
        f.close()
        print("Something went wrong parsing the first part of the input file")
        sys.exit(1)
    #end try

    out.ExecutionCount   = []
    out.ExecutionsSameMs = []
    out.ElapsedTicks     = []

    verbosePrint(" - Parsing section data")
    try:
        for i in range(1, out.MaxSections+1):
            verbosePrint("   . Parsing %d of %d" % (i, out.MaxSections))
            out.ExecutionCount.append(unflatten4(f.read(4)))
            out.ExecutionsSameMs.append(unflatten4(f.read(4)))
            out.ElapsedTicks.append(unflatten4(f.read(4)))
        #end for
    except:
        f.close()
        print("Something went wrong parsing the second part of the input file")
        sys.exit(1)
    #end try

    f.close()
    
    return out

#end def


def readSourceFile(filename):
    try:
        f = file(filename, "r")
        lines = f.readlines()
    except (IOError, OSError):
        print "Could not find, open or read input file"
        f.close()
        sys.exit(1)
    #end try

    f.close()
    return lines
#end def


#def 

def writeStringToFile(filename, str):
    try:
        f = file(filename, "w")
        f.write(str)
    except (IOError, OSError):
        print "Could not open output file for writing or write to it"
        f.close()
        sys.exit(1)
    #end try

    f.close()
#end def



def findProfilerCommands(lines):
    out = [];
    
    verbosePrint(" - Looking for profiler commands")
    
    for i, l in enumerate(lines):
        tmp = l.strip()
        if len(tmp) > 0:
            if tmp.startswith("PROFILER_START"):
                out.append((i, "start"))
                verbosePrint('   . found "start" in line %d' % i) 
            elif tmp.startswith("PROFILER_STOP"):
                out.append((i, "stop"))
                verbosePrint('   . found "stop" in line %d' % i)
            elif tmp.startswith("PROFILER_BEGINSECTION"):
                val = int(tmp.partition("(")[2].partition(")")[0])
                out.append((i, "beginsection", val))
                verbosePrint('   . found "beginsection(%d)" in line %d' % (val, i))
            elif tmp.startswith("PROFILER_ENDSECTION"):
                val = int(tmp.partition("(")[2].partition(")")[0])
                out.append((i, "endsection", val))
                verbosePrint('   . found "endsection(%d)" in line %d' % (val, i))
            #end if
        #end if
    #end for
    
    return out
    
#end def

def findProfilerCommandLine(lines, cmd):
    lineno = -1
    for p in lines:
        if p[1] == cmd:
            lineno = p[0]
            break
        #end if
    #end if
    if lineno == -1:
        print "Profiler command %s not found in source file." % cmd
        sys.exit(1)
    #end if
    
    return lineno
#end def

def generateCoverageLines(sourcelines, proflines, stats):
    coverage = [Consts.CODENOTPROFILED for tmp in sourcelines];
    # for all profiler commands
    for (i, p) in enumerate(proflines):
        # look for profiled sections
        if p[1] == 'beginsection':
            # find out if code was executed
            verbosePrint('   . checking section %s, ExecutionCount = %d' % (p[2], stats.ExecutionCount[p[2]]))
            if stats.ExecutionCount[p[2]] > 0:
                val = Consts.CODEPROFILED
            else:
                val = Consts.CODEDIDNTRUN
            #end if
            
            #NOTE BAD
            endline = -1
            for nextp in proflines:
                if nextp[1] == 'endsection':
                    if nextp[2] == p[2]:
                        endline = nextp[0]
                        break
            if endline == -1:
                print "Warning: Didn't find matching profiler command endsection for a certain startsection!"
                        
            #end if
            # set all lines to the end...
            for j in range(p[0], endline+1):
                coverage[j] = val
            #end for
        #end if
    return coverage

def generateHTMLHeader(sourcefile):
    # get everything until <body> (including), fill in title as
    str = HTMLSnippets.getHTMLHead() % ("Profile results of " + sourcefile);
    return str
#end if

def generateHTMLFileSummary(sourcefile, statsfile, stats):
    isEnhanced = "yes" if stats.EnhancedFW else "no"
    str = HTMLSnippets.getHTMLFileInfo() % (sourcefile, statsfile, stats.FirmwareString, isEnhanced)    
    return str
#end if

def generateHTMLRuntimeSummary(stats):
    str = HTMLSnippets.getHTMLRuntimeStats() % (stats.TotalRunTime/1000.0, stats.ProfiledRunTime/1000.0)    
    return str





def generateHTMLCodeTable(sourcelines, proflines, stats, coverage):
    parts = [];
    
    startline = findProfilerCommandLine(proflines, "start")
    stopline = findProfilerCommandLine(proflines, "stop")
    
    
    parts.append(HTMLSnippets.getHTMLCodeStart())
    
    for (i, line) in enumerate(sourcelines):
        escapedCode = line.rstrip().replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;').replace('"', '&quot;');
        escapedCode = escapedCode.replace('\t', '    ')
        escapedCode = escapedCode.replace(' ', '&nbsp;')
        if i == startline or i == stopline:
            tmp = '<span class="profilercmd">' +  escapedCode + "</span><br>\n"
        else:
            if coverage[i] == Consts.CODENOTPROFILED:
                tmp = '<span class="codenotprofiled">' +  escapedCode + "</span><br>\n"
            elif coverage[i] == Consts.CODEDIDNTRUN:
                tmp = '<span class="codedidntrun">' +  escapedCode + "</span><br>\n"
            else:
                tmp = '<span class="codeprofiled">' +  escapedCode + "</span><br>\n"
            #end if
        #end if
        parts.append(tmp)
    #end for

    parts.append("</td></tr>")
    
    return ''.join(parts)




def doTheAnalysis(statsfile, sourcefile, outfile):
    stats       = parseProfileFile(statsfile)
    sourcelines = readSourceFile(sourcefile)
    proflines   = findProfilerCommands(sourcelines)
    coverage    = generateCoverageLines(sourcelines, proflines, stats)
    
    verbosePrint(" - Generating HTML output file")
    HTMLparts = []; # build list of strings, join later...
    HTMLparts.append(generateHTMLHeader(sourcefile))
    HTMLparts.append(generateHTMLFileSummary(sourcefile, statsfile, stats))
    HTMLparts.append(generateHTMLRuntimeSummary(stats))
    HTMLparts.append(generateHTMLCodeTable(sourcelines, proflines, stats, coverage))
    HTMLparts.append(HTMLSnippets.getHTMLFooter())
    
    
    writeStringToFile(outfile, ''.join(HTMLparts))
    verbosePrint(" - %s written." % outfile)
    
    
#end def



if __name__=='__main__':

    # parse cmd line arguments...
    parser = OptionParser()

    parser.add_option("-p", "--profileinput",  dest="statsfile",  metavar="<FILE>",            help="Set <FILE> to binary .prf results file from NXT")
    parser.add_option("-s", "--sourceinput",   dest="sourcefile", metavar="<FILE>",            help="Set <FILE> to NXC sourcecode file which was profiled")
    parser.add_option("-o", "--output",        dest="outfile",    metavar="<FILE>",            help="Set <FILE> to HTML output file")
    parser.add_option("-v", "--verbose", dest="verbose", default=False, action="store_true", help="Enable verbose output")

    (options, args) = parser.parse_args()

    Vars.verbose = options.verbose
    if Vars.verbose:
        verbosePrint = printMethod
    else:
        verbosePrint = emptyMethod
    #end if


    if options.statsfile is None:
        print("No profiler input file specified")
        print("Use --help, -? or /? too see available options")
        sys.exit(1)
    elif options.sourcefile is None:
        print("No NXC sourcecode input file specified")
        print("Use --help, -? or /? too see available options")
        sys.exit(1)
    elif options.outfile is None:
        print("No HTML output file specified")
        print("Use --help, -? or /? too see available options")
        sys.exit(1)
    else:
        doTheAnalysis(options.statsfile, options.sourcefile, options.outfile)

#end main