CMSIS/DSP/Testing/extractDb.py

import argparse
import sqlite3
import re
import pandas as pd
import numpy as np
from TestScripts.doc.Structure import *
from TestScripts.doc.Format import *
import os.path

runidCMD = "runid = ?"

# Command to get last runid 
lastID="""SELECT runid FROM RUN ORDER BY runid DESC LIMIT 1
"""

# Command to get last runid and date
lastIDAndDate="""SELECT date FROM RUN WHERE runid=?
"""

# Command to get last runid 
runIDDetails="""SELECT distinct core FROM %s 
INNER JOIN CORE USING(coreid)
WHERE %s
"""

def joinit(iterable, delimiter):
    # Intersperse a delimiter between element of a list
    it = iter(iterable)
    yield next(it)
    for x in it:
        yield delimiter
        yield x


def getLastRunID():
  r=c.execute(lastID)
  return(int(r.fetchone()[0]))

def getrunIDDate(forID):
  r=c.execute(lastIDAndDate,(forID,))
  return(r.fetchone()[0])




parser = argparse.ArgumentParser(description='Generate summary benchmarks')

parser.add_argument('-b', nargs='?',type = str, default="bench.db", help="Database")
parser.add_argument('-o', nargs='?',type = str, default="full.md", help="Full summary")
parser.add_argument('-r', action='store_true', help="Regression database")
parser.add_argument('-t', nargs='?',type = str, default="md", help="type md or html")
parser.add_argument('-byc', action='store_true', help="Result oganized by Compiler")
parser.add_argument('-g', action='store_true', help="Include graphs in regression report")

parser.add_argument('-details', action='store_true', help="Details about runids")
parser.add_argument('-lastid', action='store_true', help="Get last ID")
parser.add_argument('-comments', nargs='?',type = str, default="comments.txt", help="Comment section")
parser.add_argument('-byd', action='store_true', help="Result oganized by datatype")

# For runid or runid range
parser.add_argument('others', nargs=argparse.REMAINDER,help="Run ID")

args = parser.parse_args()

c = sqlite3.connect(args.b)

if args.others:
   vals=[]
   runidCMD=[]
   runidHeader=[]
   for t in args.others:
     if re.search(r'-',t):
       bounds=[int(x) for x in t.split("-")]
       vals += bounds
       runidHeader += ["%d <= runid <= %d" % tuple(bounds)]
       runidCMD += ["(runid >= ? AND runid <= ?)"]
     else:
      theid=int(t)
      runidHeader += ["runid == %d" % theid]
      runidCMD += ["runid == ?"]
      vals.append(theid)

   runidval = tuple(vals)
   runidHeader = "".join(joinit(runidHeader," OR "))
   runidCMD = "".join(joinit(runidCMD," OR "))
else:
   theid=getLastRunID()
   print("Last run ID = %d\n" % theid)
   runidval=(theid,)
   runidHeader="%d" % theid


# We extract data only from data tables
# Those tables below are used for descriptions
REMOVETABLES=['TESTNAME','TESTDATE','RUN','CORE', 'PLATFORM', 'COMPILERKIND', 'COMPILER', 'TYPE', 'CATEGORY', 'CONFIG']

# This is assuming the database is generated by the regression script
# So platform is the same for all benchmarks.
# Category and type is coming from the test name in the yaml
# So no need to add this information here
# Name is removed here because it is added at the beginning
REMOVECOLUMNS=['runid','name','type','platform','category','coredef','OPTIMIZED','HARDFP','FASTMATH','NEON','HELIUM','UNROLL','ROUNDING','DATE','compilerkindid','date','categoryid', 'ID', 'platformid', 'coreid', 'compilerid', 'typeid']

REMOVECOLUMNSFORHISTORY=['Regression','MAXREGCOEF','name','type','platform','category','coredef','OPTIMIZED','HARDFP','FASTMATH','NEON','HELIUM','UNROLL','ROUNDING','DATE','compilerkindid','date','categoryid', 'ID', 'platformid', 'coreid', 'compilerid', 'typeid']

# Get existing benchmark tables
def getBenchTables():
    r=c.execute("SELECT name FROM sqlite_master WHERE type='table'")
    benchtables=[]
    for table in r:
        if not table[0] in REMOVETABLES:
          benchtables.append(table[0])
    return(benchtables)

# get existing types in a table
def getExistingTypes(benchTable):
    r=c.execute("select distinct typeid from %s WHERE %s order by typeid desc " % (benchTable,runidCMD),runidval).fetchall()
    result=[x[0] for x in r]
    return(result)

# Get existing cores in a table
def getAllExistingCores(benchTable):
    r=c.execute("select distinct coreid from %s WHERE %s order by coreid desc " % (benchTable,runidCMD),runidval).fetchall()
    result=[x[0] for x in r]
    return(result)

def getrunIDDetails():
  tables=getBenchTables()
  r=[]
  for table in tables:
      r += [x[0] for x in c.execute(runIDDetails % (table,runidCMD),runidval).fetchall()]
  r=list(set(r)) 
  print(r)

if args.lastid:
   quit()
   
if args.details:
   getrunIDDetails()
   quit()


# Get compilers from specific type and table
allCompilers="""select distinct compilerid from %s WHERE typeid=?"""

# Get compilers from specific type and table
allCompilerForCore="""select distinct compilerid from %s WHERE coreid=?"""

# Get compilers from specific type and table
allCores="""select distinct coreid from %s WHERE typeid=? AND (%s)"""


compilerDesc="""select compiler,version from COMPILER 
  INNER JOIN COMPILERKIND USING(compilerkindid) WHERE compilerid=?"""

coreDesc="""select core from CORE WHERE coreid=?"""

# Get existing compiler in a table for a specific type
# (In case report is structured by types)
def getExistingCompiler(benchTable,typeid):
    r=c.execute(allCompilers % benchTable,(typeid,)).fetchall()
    return([x[0] for x in r])


# Get existing compiler in a table for a specific core
# (In case report is structured by core)
def getExistingCompilerForCore(benchTable,coreid):
    r=c.execute(allCompilerForCore % benchTable,(coreid,)).fetchall()
    return([x[0] for x in r])

def getExistingCores(benchTable,typeid):
    vals = (typeid,) + runidval
    r=c.execute(allCores % (benchTable,runidCMD),vals).fetchall()
    return([x[0] for x in r])



def getCoreDesc(compilerid):
    r=c.execute(coreDesc,(compilerid,)).fetchone()
    return(r)

def getCompilerDesc(compilerid):
    r=c.execute(compilerDesc,(compilerid,)).fetchone()
    return(r)

# Get type name from type id
def getTypeName(typeid):
    r=c.execute("select type from TYPE where typeid=?",(typeid,)).fetchone()
    return(r[0])
 
# Diff of 2 lists 
def diff(first, second):
        second = set(second)
        return [item for item in first if item not in second]


# Command to get data for specific compiler 
# and type
benchCmdForCoreCompiler="""select %s from %s
  INNER JOIN CATEGORY USING(categoryid)
  INNER JOIN PLATFORM USING(platformid)
  INNER JOIN CORE USING(coreid)
  INNER JOIN COMPILER USING(compilerid)
  INNER JOIN COMPILERKIND USING(compilerkindid)
  INNER JOIN TYPE USING(typeid)
  INNER JOIN TESTNAME USING(testnameid)
  WHERE coreid=? AND compilerid = ? AND (%s)
  """

# Command to get data for specific core 
# and type
historyCmd="""select %s from %s
  INNER JOIN CATEGORY USING(categoryid)
  INNER JOIN PLATFORM USING(platformid)
  INNER JOIN CORE USING(coreid)
  INNER JOIN COMPILER USING(compilerid)
  INNER JOIN COMPILERKIND USING(compilerkindid)
  INNER JOIN TYPE USING(typeid)
  INNER JOIN TESTNAME USING(testnameid)
  WHERE compilerid=? AND coreid=? AND typeid = ? AND ID = ? AND runid > (? - 10)
  """

compilersForHistory="""select distinct compilerid,compiler,version  from %s
  INNER JOIN COMPILER USING(compilerid)
  INNER JOIN COMPILERKIND USING(compilerkindid)
  WHERE coreid=? AND typeid = ? AND ID = ? AND runid > (? - 10)
  """

# Command to get data for specific core 
# and type
benchCmdForCore="""select %s from %s
  INNER JOIN CATEGORY USING(categoryid)
  INNER JOIN PLATFORM USING(platformid)
  INNER JOIN CORE USING(coreid)
  INNER JOIN COMPILER USING(compilerid)
  INNER JOIN COMPILERKIND USING(compilerkindid)
  INNER JOIN TYPE USING(typeid)
  INNER JOIN TESTNAME USING(testnameid)
  WHERE coreid=? AND typeid = ? AND (%s)
  """

coresForHistory="""select distinct coreid,core from %s
  INNER JOIN CORE USING(coreid)
  WHERE compilerid=? AND typeid = ? AND ID = ? AND runid > (? - 10)
  """

# Command to get data for specific compiler 
# and type
benchCmdForCompiler="""select %s from %s
  INNER JOIN CATEGORY USING(categoryid)
  INNER JOIN PLATFORM USING(platformid)
  INNER JOIN CORE USING(coreid)
  INNER JOIN COMPILER USING(compilerid)
  INNER JOIN COMPILERKIND USING(compilerkindid)
  INNER JOIN TYPE USING(typeid)
  INNER JOIN TESTNAME USING(testnameid)
  WHERE compilerid=? AND typeid = ? AND (%s)
  """

# Command to get test names for specific compiler 
# and type
benchNamesForCore="""select distinct name from %s
  INNER JOIN COMPILER USING(compilerid)
  INNER JOIN COMPILERKIND USING(compilerkindid)
  INNER JOIN TYPE USING(typeid)
  INNER JOIN TESTNAME USING(testnameid)
  WHERE coreid=? AND typeid = ? AND (%s)
  """

# Command to get test names for specific core 
# and compiler
benchNamesForCoreCompiler="""select distinct name from %s
  INNER JOIN COMPILER USING(compilerid)
  INNER JOIN COMPILERKIND USING(compilerkindid)
  INNER JOIN TYPE USING(typeid)
  INNER JOIN TESTNAME USING(testnameid)
  WHERE coreid=? AND compilerid = ? AND (%s)
  """

# Command to get test names for specific compiler 
# and type
benchNamesForCompiler="""select distinct name from %s
  INNER JOIN COMPILER USING(compilerid)
  INNER JOIN COMPILERKIND USING(compilerkindid)
  INNER JOIN TYPE USING(typeid)
  INNER JOIN TESTNAME USING(testnameid)
  WHERE compilerid=? AND typeid = ? AND (%s)
  """

# Command to get columns for specific table
benchCmdColumns="""select * from %s
  INNER JOIN CATEGORY USING(categoryid)
  INNER JOIN PLATFORM USING(platformid)
  INNER JOIN CORE USING(coreid)
  INNER JOIN COMPILER USING(compilerid)
  INNER JOIN COMPILERKIND USING(compilerkindid)
  INNER JOIN TESTNAME USING(testnameid)
  INNER JOIN TYPE USING(typeid)
  """

def joinit(iterable, delimiter):
    it = iter(iterable)
    yield next(it)
    for x in it:
        yield delimiter
        yield x

# Is not a column name finishing by id 
# (often primary key for thetable)
def isNotIDColumn(col):
    if re.match(r'^.*id$',col):
        return(False)
    else:
        return(True)

# Get test names
# for specific core and compiler (for the data)
def getTestNamesForCoreCompiler(benchTable,compilerid,core):
    vals=(core,compilerid) + runidval
    result=c.execute(benchNamesForCoreCompiler % (benchTable,runidCMD),vals).fetchall()
    names=[x[0] for x in list(result)]
    return(names)

# Get test names
# for specific typeid and core (for the data)
def getTestNamesForCore(benchTable,core,typeid):
    vals=(core,typeid) + runidval
    result=c.execute(benchNamesForCore % (benchTable,runidCMD),vals).fetchall()
    names=[x[0] for x in list(result)]
    return(names)

# Get test names
# for specific typeid and compiler (for the data)
def getTestNamesForCompiler(benchTable,comp,typeid):
    vals=(comp,typeid) + runidval
    result=c.execute(benchNamesForCompiler % (benchTable,runidCMD),vals).fetchall()
    names=[x[0] for x in list(result)]
    return(names)

# Command to get data for specific core 
# and type
nbElemsInBenchAndTypeAndCoreCmd="""select count(*) from %s
  WHERE coreid=? AND typeid = ? AND (%s)
  """

# Command to get data for specific compiler 
# and type
nbElemsInBenchAndTypeAndCompilerCmd="""select count(*) from %s
  WHERE compilerid=? AND typeid = ? AND (%s)
  """

# Command to get data for specific compiler 
# and type
nbElemsInBenchAndCoreAndCompilerCmd="""select count(*) from %s
  WHERE compilerid=? AND coreid = ? AND (%s)
  """

nbElemsInBenchAndTypeCmd="""select count(*) from %s
  WHERE typeid = ? AND (%s)
  """
nbElemsInBenchAndCoreCmd="""select count(*) from %s
  WHERE coreid = ? AND (%s)
  """

nbElemsInBenchCmd="""select count(*) from %s
  WHERE %s
  """

categoryName="""select distinct category from %s
  INNER JOIN CATEGORY USING(categoryid)
  WHERE %s
  """

def getCategoryName(benchTable):
  result=c.execute(categoryName % (benchTable,runidCMD),runidval).fetchone()
  return(result[0])

# Get nb elems in a table
def getNbElemsInBenchAndTypeAndCoreCmd(benchTable,coreid,typeid):
    vals=(coreid,typeid) + runidval
    result=c.execute(nbElemsInBenchAndTypeAndCoreCmd % (benchTable,runidCMD),vals).fetchone()
    return(result[0])

# Get nb elems in a table
def getNbElemsInBenchAndTypeAndCompilerCmd(benchTable,comp,typeid):
    vals=(comp,typeid) + runidval
    result=c.execute(nbElemsInBenchAndTypeAndCompilerCmd % (benchTable,runidCMD),vals).fetchone()
    return(result[0])

# Get nb elems in a table
def getNbElemsInBenchAndCoreAndCompilerCmd(benchTable,comp,coreid):
    vals=(comp,coreid) + runidval
    result=c.execute(nbElemsInBenchAndCoreAndCompilerCmd % (benchTable,runidCMD),vals).fetchone()
    return(result[0])

def getNbElemsInBenchAndTypeCmd(benchTable,typeid):
    vals=(typeid,) + runidval
    result=c.execute(nbElemsInBenchAndTypeCmd % (benchTable,runidCMD),vals).fetchone()
    return(result[0])

def getNbElemsInBenchAndCoreCmd(benchTable,coreid):
    vals=(coreid,) + runidval
    result=c.execute(nbElemsInBenchAndCoreCmd % (benchTable,runidCMD),vals).fetchone()
    return(result[0])

def getNbElemsInBenchCmd(benchTable):
    result=c.execute(nbElemsInBenchCmd % (benchTable,runidCMD),runidval).fetchone()
    return(result[0])

# Get names of columns and data for a table
# for specific typeid and coreid (for the data)
def getColNamesAndHistory(benchTable,compiler,core,typeid,testid):
    cursor=c.cursor()
    result=cursor.execute(benchCmdColumns % (benchTable))
    cols= [member[0] for member in cursor.description]
    keepCols = ['name'] + [c for c in diff(cols , REMOVECOLUMNSFORHISTORY) if isNotIDColumn(c)]
    keepColsStr = "".join(joinit(keepCols,","))
    vals=(compiler,core,typeid,testid,runid)
    result=cursor.execute(historyCmd % (keepColsStr,benchTable),vals)
    vals =np.array([list(x) for x in list(result)])
    return(keepCols,vals)

# Get names of columns and data for a table
# for specific typeid and coreid (for the data)
def getColNamesAndDataForCore(benchTable,core,typeid):
    cursor=c.cursor()
    result=cursor.execute(benchCmdColumns % (benchTable))
    cols= [member[0] for member in cursor.description]
    keepCols = ['name'] + [c for c in diff(cols , REMOVECOLUMNS) if isNotIDColumn(c)]
    keepColsStr = "".join(joinit(keepCols,","))
    vals=(core,typeid) + runidval
    result=cursor.execute(benchCmdForCore % (keepColsStr,benchTable,runidCMD),vals)
    vals =np.array([list(x) for x in list(result)])
    return(keepCols,vals)

# Get names of columns and data for a table
# for specific coreid and compilerid (for the data)
def getColNamesAndDataForCoreCompiler(benchTable,compilerid,core):
    cursor=c.cursor()
    result=cursor.execute(benchCmdColumns % (benchTable))
    cols= [member[0] for member in cursor.description]
    keepCols = ['name','type'] + [c for c in diff(cols , REMOVECOLUMNS) if isNotIDColumn(c)]
    keepColsStr = "".join(joinit(keepCols,","))
    vals=(core,compilerid) + runidval
    result=cursor.execute(benchCmdForCoreCompiler % (keepColsStr,benchTable,runidCMD),vals)
    vals =np.array([list(x) for x in list(result)])
    return(keepCols,vals)

# Get names of columns and data for a table
# for specific typeid and compiler (for the data)
def getColNamesAndDataForCompiler(benchTable,comp,typeid):
    cursor=c.cursor()
    result=cursor.execute(benchCmdColumns % (benchTable))
    cols= [member[0] for member in cursor.description]
    keepCols = ['name'] + [c for c in diff(cols , REMOVECOLUMNS) if isNotIDColumn(c)]
    keepColsStr = "".join(joinit(keepCols,","))
    vals=(comp,typeid) + runidval
    result=cursor.execute(benchCmdForCompiler % (keepColsStr,benchTable,runidCMD),vals)
    vals =np.array([list(x) for x in list(result)])
    return(keepCols,vals)



PARAMS=["NB","NumTaps", "NBA", "NBB", "Factor", "NumStages","VECDIM","NBR","NBC","NBI","IFFT", "BITREV"]

def regressionTableFor(byname,name,section,ref,toSort,indexCols,field):
    data=ref.pivot_table(index=indexCols, columns=byname, 
    values=[field], aggfunc='first')
       
    data=data.sort_values(toSort)
       
    cores = [c[1] for c in list(data.columns)]
    columns = diff(indexCols,['name'])

    dataTable=Table(columns,cores)
    section.addContent(dataTable)

    dataForFunc=data.loc[name]
    if type(dataForFunc) is pd.DataFrame:
       bars={'cols':columns,'cores':cores,'data':[]}
       for row in dataForFunc.itertuples():
           row=list(row)
           if type(row[0]) is int:
              row=[row[0]] + row[1:]
           else: 
              row=list(row[0]) + row[1:]
           if field=="MAXREGCOEF":
              newrow = row
              newrow[len(columns):] = [("%.3f" % x) for x in row[len(columns):]]
              row=newrow
           dataTable.addRow(row)
           bars['data'].append(row)
       return(bars)
    else:
       if field=="MAXREGCOEF":
              dataForFunc=[("%.3f" % x) for x in dataForFunc]
       dataTable.addRow(dataForFunc)
       return(list(zip(cores,dataForFunc)))

def formatColumnName(c):
  return("".join(joinit(c,":")))

def getCoresForHistory(benchTable,compilerid,typeid,testid,runid):
    vals=(compilerid,typeid,testid,runid)
    result=c.execute(coresForHistory % benchTable,vals).fetchall()
    ids=[(x[0],x[1]) for x in list(result)]
    return(ids)

def getCompilerForHistory(benchTable,coreid,typeid,testid,runid):
    vals=(coreid,typeid,testid,runid)
    result=c.execute(compilersForHistory % benchTable,vals).fetchall()
    ids=[(x[0],x[1],x[2]) for x in list(result)]
    return(ids)

def getHistory(desc,testid,indexCols):
    benchName,sectionID,typeid,runid = desc

    #print(benchName)
    #print(sectionID)
    #print(typeid)
    #print(testid)
    columns = diff(indexCols,['name'])
    #print(columns)
    if args.byc:
       coreid=sectionID
       compilerids=getCompilerForHistory(benchName,coreid,typeid,testid,runid)
       series={}
       for compilerid,compilername,version in compilerids:
          result=getColNamesAndHistory(benchName,compilerid,coreid,typeid,testid)
          #print("%s:%s" % (compilername,version))
          maxpos = result[0].index('MAX')
          lrunid = result[0].index('runid')
          r=[[int(x[lrunid]),int(x[maxpos])] for x in result[1:][0]]
          series[corename]=r
       hist=History(series,runid)
       return(hist)
    else:
       compilerid=sectionID
       coreids = getCoresForHistory(benchName,compilerid,typeid,testid,runid)
       series={}
       for coreid,corename in coreids:
          result=getColNamesAndHistory(benchName,compilerid,coreid,typeid,testid)
          #print(corename)
          maxpos = result[0].index('MAX')
          corepos = result[0].index('core')
          lrunid = result[0].index('runid')
          r=[[int(x[lrunid]),int(x[maxpos])] for x in result[1:][0]]
          series[corename]=r
       hist=History(series,runid)
       return(hist)

def convertRowToInt(r):
  result=[]
  for e in r:
    if type(e) is float:
      result.append(int(e))
    else:
      result.append(e)

  return(result)

def formatTableBy(desc,byname,section,typeSection,testNames,cols,vals):
    if vals.size != 0:
       ref=pd.DataFrame(vals,columns=cols)
       toSort=["name"]
       
       for param in PARAMS:
          if param in ref.columns:
             ref[param]=pd.to_numeric(ref[param])
             toSort.append(param)
       if args.r:
         #  Regression table
         ref['MAX']=pd.to_numeric(ref['MAX'])
         ref['MAXREGCOEF']=pd.to_numeric(ref['MAXREGCOEF'])
       
         indexCols=diff(cols,byname + ['Regression','MAXREGCOEF','MAX'] + section)
         valList = ['Regression']
       else:
         ref['CYCLES']=pd.to_numeric(ref['CYCLES']).round(decimals=0)

         indexCols=diff(cols,byname + ['CYCLES'] + section)
         valList = ['CYCLES']
      
       
       for name in testNames:
           if args.r:
              testSection = Section(name)
              typeSection.addSection(testSection)

              maxCyclesSection = Section("Max cycles")
              testSection.addSection(maxCyclesSection)
              theCycles=regressionTableFor(byname,name,maxCyclesSection,ref,toSort,indexCols,'MAX')
              if args.g:
                 if type(theCycles) is dict:
                   nbParams=len(theCycles['cols'])
                   for bar in theCycles['data']:
                       params=bar[0:nbParams]
                       values=bar[nbParams:]
                       title=[("%s=%s" % x) for x in list(zip(theCycles['cols'],params))]
                       title="".join(joinit(title," "))
                       sec=Section(title)
                       maxCyclesSection.addSection(sec)
                       values=list(zip(theCycles['cores'],values))
                       barChart=BarChart(values)
                       sec.addContent(barChart)
                 else:
                    #print(theCycles)
                    sec=Section("Graph")
                    maxCyclesSection.addSection(sec)
                    barChart=BarChart(theCycles)
                    sec.addContent(barChart)

                 #history=getHistory(desc,testid,indexCols)
                 #testSection.addContent(history)

              regressionSection = Section("Regression")
              testSection.addSection(regressionSection)
              regressionTableFor(byname,name,regressionSection,ref,toSort,indexCols,'Regression')
              
              
              maxRegCoefSection = Section("Max Reg Coef")
              testSection.addSection(maxRegCoefSection)
              regressionTableFor(byname,name,maxRegCoefSection,ref,toSort,indexCols,'MAXREGCOEF')

           else:
              data=ref.pivot_table(index=indexCols, columns=byname, 
              values=valList, aggfunc='first')

              data=data.sort_values(toSort)

              #print(list(data.columns))

              testSection = Section(name)
              typeSection.addSection(testSection)

              dataForFunc=data.loc[name]
              dataForFunc = dataForFunc.dropna(axis=1)

              columnsID = [formatColumnName(c[1:]) for c in list(dataForFunc.columns)]
              columns = diff(indexCols,['name'])

              dataTable=Table(columns,columnsID)
              testSection.addContent(dataTable)


              if type(dataForFunc) is pd.DataFrame:
                 for row in dataForFunc.itertuples():
                     if type(row[0]) is int:
                        row=list([row[0]] + list(row[1:]))
                     else: 
                        row=list(row[0]) + list(row[1:])
                     dataTable.addRow(convertRowToInt(row))
              else:
                 dataTable.addRow(convertRowToInt(dataForFunc))

# Add a report for each table
def addReportFor(document,benchName):
    nbElems = getNbElemsInBenchCmd(benchName)
    if nbElems > 0:
       categoryName = getCategoryName(benchName)
       benchSection = Section(categoryName)
       document.addSection(benchSection)
       print("Process %s\n" % benchName)
       if args.byd:
          allCores=getAllExistingCores(benchName)
          for aCoreID in allCores:
            nbElems = getNbElemsInBenchAndCoreCmd(benchName,aCoreID)
            if nbElems > 0:
               coreName=getCoreDesc(aCoreID)
               coreSection = Section("%s" % coreName)
               benchSection.addSection(coreSection)
               allCompilers = getExistingCompilerForCore(benchName,aCoreID)
               for compiler in allCompilers:
                 #print(compiler)
                 nbElems = getNbElemsInBenchAndCoreAndCompilerCmd(benchName,compiler,aCoreID)
                 
                 # Print test results for table, type, compiler
                 if nbElems > 0:
                    compilerName,version=getCompilerDesc(compiler)
                    compilerSection = Section("%s (%s)" % (compilerName,version))
                    coreSection.addSection(compilerSection)
                    cols,vals=getColNamesAndDataForCoreCompiler(benchName,compiler,aCoreID)
                    desc=(benchName,compiler,aCoreID)
                    names=getTestNamesForCoreCompiler(benchName,compiler,aCoreID)
                   
                    formatTableBy(desc,['type'],['core','version','compiler'],compilerSection,names,cols,vals)
                       
       else:
          allTypes = getExistingTypes(benchName)
          # Add report for each type
          for aTypeID in allTypes:
              nbElems = getNbElemsInBenchAndTypeCmd(benchName,aTypeID)
              if nbElems > 0:
                 typeName = getTypeName(aTypeID)
                 typeSection = Section(typeName)
                 benchSection.addSection(typeSection)
                 if args.byc:
                   ## Add report for each core
                   allCores = getExistingCores(benchName,aTypeID)
                   for core in allCores:
                       #print(core)
                       nbElems = getNbElemsInBenchAndTypeAndCoreCmd(benchName,core,aTypeID)
                       # Print test results for table, type, compiler
                       if nbElems > 0:
                          coreName=getCoreDesc(core)
                          coreSection = Section("%s" % coreName)
                          typeSection.addSection(coreSection)
                          cols,vals=getColNamesAndDataForCore(benchName,core,aTypeID)
                          desc=(benchName,core,aTypeID)
                          names=getTestNamesForCore(benchName,core,aTypeID)
                          formatTableBy(desc,['compiler','version'],['core'],coreSection,names,cols,vals)
                 else:
                   ## Add report for each compiler
                   allCompilers = getExistingCompiler(benchName,aTypeID)
                   for compiler in allCompilers:
                       #print(compiler)
                       nbElems = getNbElemsInBenchAndTypeAndCompilerCmd(benchName,compiler,aTypeID)
                       # Print test results for table, type, compiler
                       if nbElems > 0:
                          compilerName,version=getCompilerDesc(compiler)
                          compilerSection = Section("%s (%s)" % (compilerName,version))
                          typeSection.addSection(compilerSection)
                          cols,vals=getColNamesAndDataForCompiler(benchName,compiler,aTypeID)
                          desc=(benchName,compiler,aTypeID)
                          names=getTestNamesForCompiler(benchName,compiler,aTypeID)
                          formatTableBy(desc,['core'],['version','compiler'],compilerSection,names,cols,vals)
                       



toc=[Hierarchy("BasicMathsBenchmarks"),    
Hierarchy("ComplexMathsBenchmarks"),
Hierarchy("FastMath"),
Hierarchy("Filters",
  [Hierarchy("FIR"),
   Hierarchy("BIQUAD"),
   Hierarchy("DECIM"), 
   Hierarchy("MISC")]),

Hierarchy("Support Functions",
  [Hierarchy("Support"),
   Hierarchy("SupportBar")]),
        
Hierarchy("Matrix Operations"    ,  
  [Hierarchy("Binary"),
   Hierarchy("Unary")]),
Hierarchy("Transform"),
Hierarchy("Stats"),
Hierarchy("Classical ML",[
  Hierarchy("Bayes"),
  Hierarchy("SVM"),
  Hierarchy("Distance"),
  ]),

]

processed=[]

def addComments(document):
  if os.path.exists(args.comments):
     section=Section("Measurement Context")

     document.addSection(section)
     para=""
     with open(args.comments,"r") as r:
         for l in r:
             if l.strip():
               para += l
             else:
               section.addContent(Text(para))
               para=""
     if para:
        section.addContent(Text(para))

def createDoc(document,sections,benchtables):
    global processed
    for s in sections:
        if s.name in benchtables:
           addReportFor(document,s.name)
           processed.append(s.name)
        else:
           section=Section(s.name)
           document.addSection(section)
           createDoc(section,s.sections,benchtables)

try:
      benchtables=getBenchTables()
      document = Document(runidHeader)

      addComments(document)

      createDoc(document,toc,benchtables)
      
      misc=Section("Miscellaneous")
      document.addSection(misc)
      remaining=diff(benchtables,processed)
      for bench in remaining:
          addReportFor(misc,bench)

      #for bench in benchtables:
      #    addReportFor(document,bench)
      with open(args.o,"w") as output:
          if args.t=="md":
             document.accept(Markdown(output))
          if args.t=="html":
             reorder=NORMALFORMAT
             if args.byc:
               reorder=BYCFORMAT
             if args.byd:
               reorder=BYDFORMAT
             document.accept(HTML(output,args.r,reorder))

finally:
     c.close()