src/analyzer/tunerloganalyzer.py

   1 import re
   2 import argparse
   3 import sys
   4 import os
   5
   6
   7 class AutoTunerArgParser:
   8         def __init__(self):
   9                 self.parser = argparse.ArgumentParser(description='Parsing the output log of the CSolver auto tuner ...')
  10                 self.parser.add_argument('--folder', '-f', metavar='bin', type=str, nargs=1,help='output log of running the autotuner ...')
  11                 self.parser.add_argument('--number', '-n', metavar='122', type=int, nargs=1,help='Number of runs ...')
  12                 self.args = self.parser.parse_args()
  13
  14         def getFolder(self):
  15                 return self.args.folder[0]
  16
  17         def getRunNumber(self):
  18                 return self.args.number[0]
  19
  20 TUNABLEHEADER = ["DECOMPOSEORDER", "MUSTREACHGLOBAL", "MUSTREACHLOCAL", "MUSTREACHPRUNE", "OPTIMIZEORDERSTRUCTURE",
  21                 "ORDERINTEGERENCODING", "PREPROCESS", "NODEENCODING", "EDGEENCODING", "MUSTEDGEPRUNE", "ELEMENTOPT",
  22                 "ENCODINGGRAPHOPT", "ELEMENTOPTSETS", "PROXYVARIABLE", "MUSTVALUE", "NAIVEENCODER", "VARIABLEORDER",
  23                 "PROBLEM","SATTIME", "EXECTIME"]
  24
  25 configs = {"EXECTIME": "-",
  26                 "SATTIME":"-",
  27                 "TESTCASE":"-",
  28                 "PREPROCESS" : "-",
  29                 "ELEMENTOPT" : "-",
  30                 "ELEMENTOPTSETS" : "-",
  31                 "PROXYVARIABLE" : "-",
  32                 "#SubGraph" : "-",
  33                 "NODEENCODING" : "-",
  34                 "EDGEENCODING" : "-",
  35                 "NAIVEENCODER" :"-",
  36                 "ENCODINGGRAPHOPT" : "-"
  37                 }
  38
  39 REGEXES = {"EXECTIME": "CSOLVER solve time: (.*)",
  40                 "SATTIME":"SAT Solving time: (.*)",
  41                 "TESTCASE": "deserializing (.+) ...",
  42                 "PREPROCESS" : "Param PREPROCESS = (.*)range=\[0,1\]",
  43                 "ELEMENTOPT" : "Param ELEMENTOPT = (.*)range=\[0,1\]",
  44                 "ELEMENTOPTSETS" : "Param ELEMENTOPTSETS = (.*)range=\[0,1\]",
  45                 "PROXYVARIABLE" : "Param PROXYVARIABLE = (.*)range=\[1,5\]",
  46                 "#SubGraph" : "#SubGraph = (.*)",
  47                 "NODEENCODING" : "Param NODEENCODING = (.*)range=\[0,3\](.*)",
  48                 "EDGEENCODING" : "Param EDGEENCODING = (.*)range=\[0,2\](.*)",
  49                 "NAIVEENCODER" : "Param NAIVEENCODER = (.*)range=\[1,3\](.*)",
  50                 "ENCODINGGRAPHOPT" : "Param ENCODINGGRAPHOPT = (.*)range=\[0,1\]"
  51                 }
  52
  53 def printHeader(file):
  54         global TUNABLEHEADER
  55         mystr=""
  56         for header in TUNABLEHEADER:
  57                  mystr+=str(header)+","
  58         print >>file, mystr
  59
  60 def dump(file, row):
  61         global TUNABLEHEADER
  62         mystr=""
  63         for i in range(len(TUNABLEHEADER)):
  64                 mystr += row[TUNABLEHEADER[i]]+ ","
  65         print "mystr is:"+ mystr
  66         print >>file, mystr
  67
  68 def loadTunerInfo(row, filename):
  69         with open(filename) as f:
  70                 for line in f:
  71                         numbers = re.findall('\d+',line)
  72                         numbers = map(int,numbers)
  73                         row[TUNABLEHEADER[numbers[3]]] = row[TUNABLEHEADER[numbers[3]]] + str(numbers[7])
  74
  75 def loadSolverTime(row, filename):
  76         global REGEXES
  77         global configs
  78         with open(filename) as f:
  79                 for line in f:
  80                         for regex in REGEXES:
  81                                 p = re.compile(REGEXES[regex])
  82                                 token = p.search(line)
  83                                 if token is not None:
  84                                         if regex == "TESTCASE":
  85                                                 configs[regex] = re.search(REGEXES[regex], line).group(1)
  86                                         else:
  87                                                 configs[regex] = re.findall("\d+\.?\d*", line)[0]
  88         row["SATTIME"] = configs["SATTIME"]
  89         row["EXECTIME"] = configs["EXECTIME"]
  90
  91 def loadProblemName(row,filename):
  92         with open(filename) as f:
  93                 row["PROBLEM"] = f.readline().replace("\n","")
  94
  95 def main():
  96         global configs
  97         argprocess = AutoTunerArgParser()
  98         file = open("tuner.csv", "w")
  99         printHeader(file)
 100         for i in range(argprocess.getRunNumber()):
 101                 row = {"DECOMPOSEORDER" : "",
 102                         "MUSTREACHGLOBAL" : "",
 103                         "MUSTREACHLOCAL" : "",
 104                         "MUSTREACHPRUNE" : "",
 105                         "OPTIMIZEORDERSTRUCTURE" : "",
 106                         "ORDERINTEGERENCODING" : "",
 107                         "PREPROCESS" : "",
 108                         "NODEENCODING" : "",
 109                         "EDGEENCODING" : "",
 110                         "MUSTEDGEPRUNE" : "",
 111                         "ELEMENTOPT" : "",
 112                         "ENCODINGGRAPHOPT" : "",
 113                         "ELEMENTOPTSETS" : "",
 114                         "PROXYVARIABLE" : "",
 115                         "MUSTVALUE" : "",
 116                         "NAIVEENCODER" : "",
 117                         "VARIABLEORDER" : "",
 118                         "PROBLEM":"",
 119                         "SATTIME":"",
 120                         "EXECTIME": ""
 121                 }
 122                 loadTunerInfo(row, argprocess.getFolder()+"/tuner"+str(i)+"used")
 123                 loadSolverTime(row, argprocess.getFolder()+"/log"+str(i))
 124                 loadProblemName(row, argprocess.getFolder()+"/problem"+str(i))
 125                 dump(file, row)
 126         file.close()
 127         return
 128
 129 if __name__ == "__main__":
 130         main()