Enriching the report description

[satune.git] / src / analyzer / tunerloganalyzer.py

diff --git a/src/analyzer/tunerloganalyzer.py b/src/analyzer/tunerloganalyzer.py
index 396e3f628556b1ba26f8f8950350000fa337eb16..d47df1f41c2e5eb88d2e09cb13c725324c4760f1 100644 (file)
--- a/src/analyzer/tunerloganalyzer.py
+++ b/src/analyzer/tunerloganalyzer.py
@@ -2,7 +2,7 @@ import re
 import argparse
 import sys
 import os
-
+import plot as pl
 
 class AutoTunerArgParser:
        def __init__(self):
@@ -17,10 +17,12 @@ class AutoTunerArgParser:
        def getRunNumber(self):
                return self.args.number[0]
 
+PROBLEMS = []
+
 TUNABLEHEADER = ["DECOMPOSEORDER", "MUSTREACHGLOBAL", "MUSTREACHLOCAL", "MUSTREACHPRUNE", "OPTIMIZEORDERSTRUCTURE",
                 "ORDERINTEGERENCODING", "PREPROCESS", "NODEENCODING", "EDGEENCODING", "MUSTEDGEPRUNE", "ELEMENTOPT",
                 "ENCODINGGRAPHOPT", "ELEMENTOPTSETS", "PROXYVARIABLE", "MUSTVALUE", "NAIVEENCODER", "VARIABLEORDER",
-                "PROBLEM","SATTIME", "EXECTIME"]
+                "PROBLEM","SATTIME", "EXECTIME","TUNERNUMBER"]
 
 configs = {"EXECTIME": "-",
                "SATTIME":"-",
@@ -60,10 +62,13 @@ def printHeader(file):
 def dump(file, row):
        global TUNABLEHEADER
        mystr=""
+       data = []
        for i in range(len(TUNABLEHEADER)):
                mystr += row[TUNABLEHEADER[i]]+ ","
-       print "mystr is:"+ mystr
+               data.append(row[TUNABLEHEADER[i]])
+       print ("mystr is:"+ mystr)
        print >>file, mystr
+       return data
 
 def loadTunerInfo(row, filename):
        with open(filename) as f:
@@ -89,14 +94,25 @@ def loadSolverTime(row, filename):
        row["EXECTIME"] = configs["EXECTIME"]
 
 def loadProblemName(row,filename):
+       global PROBLEMS
        with open(filename) as f:
-               row["PROBLEM"] = f.readline().replace("\n","")
+               problem = f.readline().replace("\n","")
+               probNumber = int(f.readline())
+               if probNumber >= len(PROBLEMS):
+                       PROBLEMS.insert(probNumber,problem)
+               elif PROBLEMS[probNumber] != problem:
+                       PROBLEMS[probNumber] = problem
+               row["PROBLEM"] = problem
 
-def main():
+def loadTunerNumber(row, filename):
+       with open(filename) as f:
+               row["TUNERNUMBER"] = f.readline().replace("\n","")
+def analyzeLogs(file):
        global configs
        argprocess = AutoTunerArgParser()
-       file = open("tuner.csv", "w") 
        printHeader(file)
+       rows = []
+       data = []
        for i in range(argprocess.getRunNumber()):
                row = {"DECOMPOSEORDER" : "",
                        "MUSTREACHGLOBAL" : "",
@@ -117,14 +133,69 @@ def main():
                        "VARIABLEORDER" : "",
                        "PROBLEM":"",
                        "SATTIME":"",
-                       "EXECTIME": ""
+                       "EXECTIME": "",
+                       "TUNERNUMBER":""
                }
+               loadTunerNumber(row, argprocess.getFolder() + "/tunernum" + str(i))
                loadTunerInfo(row, argprocess.getFolder()+"/tuner"+str(i)+"used")
                loadSolverTime(row, argprocess.getFolder()+"/log"+str(i))
                loadProblemName(row, argprocess.getFolder()+"/problem"+str(i))
-               dump(file, row)
+               data.append(dump(file, row))
+               rows.append(row)
+       return rows, data
+
+def tunerCountAnalysis(file, rows):
+       global TUNABLEHEADER
+       global PROBLEMS
+       tunercount = {}
+       tunernumber = {}
+       for row in rows:
+               mystr=""
+               for i in range(18):
+                       if not row[TUNABLEHEADER[i]]:
+                               mystr += "."
+                       else:
+                               mystr+=row[TUNABLEHEADER[i]]
+               if mystr not in tunercount:
+                       tunercount.update({mystr : 1})
+                       tunernumber.update({mystr : str(row["TUNERNUMBER"])})
+               else :
+                       tunercount[mystr] += 1
+                       tunernumber[mystr] += "-" + str(row["TUNERNUMBER"])
+
+       problems = set(map(lambda x: x["PROBLEM"], rows))
+       print ("Number of repititive tuners")
+       for key in tunercount:
+               if tunercount[key] > 1:
+                       print key + "(ids:" + tunernumber[key]  + ") = #" + str(tunercount[key])
+
+def combineRowForEachTuner(rows):
+       global PROBLEMS
+       newRows = []
+       combined = None
+       for row in rows:
+               if row["PROBLEM"] == PROBLEMS[0]:
+                       combined = row
+               for key in row:
+                       if row[key]:
+                               combined[key] = row[key]
+               if row["PROBLEM"] == PROBLEMS[len(PROBLEMS)-1]:
+                       newRows.append(combined)
+       return newRows
+
+def transformDataset(rows):
+       print(rows)
+
+
+def main():
+       global TUNABLEHEADER
+       file = open("tuner.csv", "w")
+       rows, data = analyzeLogs(file)
+       tunerCountAnalysis(file, combineRowForEachTuner(rows) )
        file.close()
-       return
+       #transformDataset(data)
+       pl.plot(data, TUNABLEHEADER)
+
 
 if __name__ == "__main__":
        main()