Merge pull request #9 from rkkautsar/refactor

Clean-up project and import/export feature

Author: rkkautsar

.gitignore

@@ -87,3 +87,9 @@ ENV/
 
 # Rope project settings
 .ropeproject
+
+# Emacs backup files
+*~
+
+# Benchmark-tool output
+output

Pipfile

@@ -0,0 +1,13 @@
+[[source]]
+name = "pypi"
+url = "https://pypi.org/simple"
+verify_ssl = true
+
+[dev-packages]
+
+[packages]
+lxml = "*"
+jinja2 = "*"
+
+[requires]
+python_version = "3"

Pipfile.lock

@@ -0,0 +1,6 @@
+*
+
+!*/
+!examples/*
+!.gitignore
+

benchmarks/.gitignore

@@ -0,0 +1,2 @@
+from .clasp import clasp
+from .claspar import claspar

benchmarks/asp

@@ -0,0 +1,90 @@
+'''
+Created on Jan 17, 2010
+
+@author: Roland Kaminski
+'''
+
+import os
+import re
+import sys
+import codecs
+
+clasp_re = {
+    "models"      : ("float", re.compile(r"^(c )?Models[ ]*:[ ]*(?P<val>[0-9]+)\+?[ ]*$")),
+    "choices"     : ("float", re.compile(r"^(c )?Choices[ ]*:[ ]*(?P<val>[0-9]+)\+?[ ]*$")),
+    "time"        : ("float", re.compile(r"^Real time \(s\): (?P<val>[0-9]+(\.[0-9]+)?)$")),
+    "conflicts"   : ("float", re.compile(r"^(c )?Conflicts[ ]*:[ ]*(?P<val>[0-9]+)\+?[ ]*\(Analyzed:[ ]*(\d+(\.\d+)?)\)")),
+    "conflicts_analyzed"   : ("float", re.compile(r"^(c )?Conflicts[ ]*:[ ]*([0-9]+)\+?[ ]*\(Analyzed:[ ]*(?P<val>\d+(\.\d+)?)\)")),
+    "conflict":  ("float", re.compile(r"^(c[ ]*)?Conflict[ ]*:[ ]*(?P<val>[0-9]+)\+?[ ]*\(Average[ ]Length:[ ]*(\d+(\.\d+)?)[ ]*Ratio:[ ]*(\d+(\.\d+)?)%[ ]*\)")),
+    "conflict_avg_length":  ("float", re.compile(r"^(c[ ]*)?Conflict[ ]*:[ ]*([0-9]+)\+?[ ]*\(Average[ ]Length:[ ]*(?P<val>\d+(\.\d+)?)[ ]*Ratio:[ ]*(\d+(\.\d+)?)%[ ]*\)")),
+    "conflict_ratio":  ("float", re.compile(r"^(c[ ]*)?Conflict[ ]*:[ ]*([0-9]+)\+?[ ]*\(Average[ ]Length:[ ]*(\d+(\.\d+)?)[ ]*Ratio:[ ]*(?P<val>\d+(\.\d+)?)%[ ]*\)")),
+    "restarts"    : ("float", re.compile(r"^(c )?Restarts[ ]*:[ ]*(?P<val>[0-9]+)\+?[ ]*")),
+    "restarts_avg"    : ("float", re.compile(r"^(c )?Restarts[ ]*:[ ]*([0-9]+)\+?[ ]*\(Average:[ ]*(?P<val>\d+(\.\d+)?)[ ]*Last:[ ]*\d+(\.\d+)?[ ]*\)")),
+    "restarts_last"    : ("float", re.compile(r"^(c )?Restarts[ ]*:[ ]*([0-9]+)\+?[ ]*\(Average:[ ]*(\d+(\.\d+)?)[ ]*Last:[ ]*(?P<val>\d+(\.\d+))?[ ]*\)")),
+    "optimum"     : ("string", re.compile(r"^(c )?Optimization[ ]*:[ ]*(?P<val>(-?[0-9]+)( -?[0-9]+)*)[ ]*$")),
+    "status"      : ("string", re.compile(r"^(s )?(?P<val>SATISFIABLE|UNSATISFIABLE|UNKNOWN|OPTIMUM FOUND)[ ]*$")),
+    "interrupted" : ("string", re.compile(r"(c )?(?P<val>INTERRUPTED!)")),
+    "error"       : ("string", re.compile(r"^\*\*\* clasp ERROR: (?P<val>.*)$")),
+    "memerror"    : ("string", re.compile(r"^Maximum VSize (?P<val>exceeded): sending SIGTERM then SIGKILL")),
+    "lemmas_del"    : ("float", re.compile(r"^(c )?Lemmas[ ]*:[ ]*([0-9]+)\+?[ ]*\(Deleted:[ ]*(?P<val>\d+(\.\d+)?)\)")),
+    "lemmas"    : ("float", re.compile(r"^(c )?Lemmas[ ]*:[ ]*(?P<val>[0-9]+)\+?[ ]*\(Deleted:[ ]*(\d+(\.\d+)?)\)")),
+    "lemmas_binary" : ("float", re.compile(r"^(c[ ]*)?Binary[ ]*:[ ]*(?P<val>[0-9]+)\+?[ ]*\(Ratio:[ ]*(\d+(\.\d+)?)%\)")),
+    "lemmas_binary_ratio" : ("float", re.compile(r"^(c[ ]*)?Binary[ ]*:[ ]*([0-9]+)\+?[ ]*\(Ratio:[ ]*(?P<val>\d+(\.\d+)?)%\)")),
+    "lemmas_ternary" : ("float", re.compile(r"^(c[ ]*)?Ternary[ ]*:[ ]*(?P<val>[0-9]+)\+?[ ]*\(Ratio:[ ]*(\d+(\.\d+)?)%\)")),
+    "lemmas_ternary_ratio" : ("float", re.compile(r"^(c[ ]*)?Ternary[ ]*:[ ]*([0-9]+)\+?[ ]*\(Ratio:[ ]*(?P<val>\d+(\.\d+)?)%\)")),
+    "backjumps": ("float", re.compile(r"^(c[ ]*)?Backjumps[ ]*:[ ]*(?P<val>[0-9]+)\+?[ ]*\(Average:[ ]*(\d+(\.\d+)?)[ ]*Max:[ ]*(\d+(\.\d+)?)[ ]*Sum:[ ]*(\d+(\.\d+)?)\)")),
+    "backjumps_avg": ("float", re.compile(r"^(c[ ]*)?Backjumps[ ]*:[ ]*([0-9]+)\+?[ ]*\(Average:[ ]*(?P<val>\d+(\.\d+)?)[ ]*Max:[ ]*(\d+(\.\d+)?)[ ]*Sum:[ ]*(\d+(\.\d+)?)\)")),
+    "backjumps_max": ("float", re.compile(r"^(c[ ]*)?Backjumps[ ]*:[ ]*([0-9]+)\+?[ ]*\(Average:[ ]*(\d+(\.\d+)?)[ ]*Max:[ ]*(?P<val>\d+(\.\d+)?)[ ]*Sum:[ ]*(\d+(\.\d+)?)\)")),
+    "backjumps_sum": ("float", re.compile(r"^(c[ ]*)?Backjumps[ ]*:[ ]*([0-9]+)\+?[ ]*\(Average:[ ]*(\d+(\.\d+)?)[ ]*Max:[ ]*(\d+(\.\d+)?)[ ]*Sum:[ ]*(?P<val>\d+(\.\d+)?)\)")),
+    "variables": ("float", re.compile(r"^(c[ ]*)?Variables[ ]*:[ ]*(?P<val>[0-9]+)\+?[ ]*\(Eliminated:[ ]*(\d+(\.\d+)?)[ ]*Frozen:[ ]*(\d+(\.\d+)?)[ ]*\)")),
+    "variables_eliminated": ("float", re.compile(r"^(c[ ]*)?Variables[ ]*:[ ]*([0-9]+)\+?[ ]*\(Eliminated:[ ]*(?P<val>\d+(\.\d+)?)[ ]*Frozen:[ ]*(\d+(\.\d+)?)[ ]*\)")),
+    "variables_frozen": ("float", re.compile(r"^(c[ ]*)?Variables[ ]*:[ ]*([0-9]+)\+?[ ]*\(Eliminated:[ ]*(\d+(\.\d+)?)[ ]*Frozen:[ ]*(?P<val>\d+(\.\d+)?)[ ]*\)")),
+    "constraints": ("float", re.compile(r"^(c[ ]*)?Constraints[ ]*:[ ]*(?P<val>[0-9]+)\+?[ ]*\(Binary:[ ]*(\d+(\.\d+)?)%[ ]*Ternary:[ ]*(\d+(\.\d+)?)%[ ]*Other:[ ]*(\d+(\.\d+)?)%[ ]*\)")),
+    "constraints_binary": ("float", re.compile(r"^(c[ ]*)?Constraints[ ]*:[ ]*([0-9]+)\+?[ ]*\(Binary:[ ]*(?P<val>\d+(\.\d+)?)%[ ]*Ternary:[ ]*(\d+(\.\d+)?)%[ ]*Other:[ ]*(\d+(\.\d+)?)%[ ]*\)")),
+    "constraints_ternary": ("float", re.compile(r"^(c[ ]*)?Constraints[ ]*:[ ]*([0-9]+)\+?[ ]*\(Binary:[ ]*(\d+(\.\d+)?)%[ ]*Ternary:[ ]*(?P<val>\d+(\.\d+)?)%[ ]*Other:[ ]*(\d+(\.\d+)?)%[ ]*\)")),
+    "constraints_other": ("float", re.compile(r"^(c[ ]*)?Constraints[ ]*:[ ]*([0-9]+)\+?[ ]*\(Binary:[ ]*(\d+(\.\d+)?)%[ ]*Ternary:[ ]*(\d+(\.\d+)?)%[ ]*Other:[ ]*(?P<val>\d+(\.\d+)?)%[ ]*\)"))
+}
+
+def clasp(root, runspec, instance):
+    """
+    Extracts some clasp statistics.
+    """
+
+    timeout = runspec.project.job.timeout
+    res     = { "time": ("float", timeout) }
+    for f in [instance.instance + ".txt", instance.instance + ".watcher"]:
+    #for f in [instance.instance"runsolver.solver", "runsolver.watcher"]:
+        for line in codecs.open(os.path.join(root, f), errors='ignore', encoding='utf-8'):
+            for val, reg in clasp_re.items():
+                m = reg[1].match(line)
+                if m: res[val] = (reg[0], float(m.group("val")) if reg[0] == "float" else m.group("val"))
+        break
+
+    #print res["time"][1]
+    if "memerror" in res:
+        res["error"]  = ("string", "std::bad_alloc")
+        res["status"] = ("string", "UNKNOWN")
+        del res["memerror"]
+    if res["time"][1] >= timeout and not "status" in res:
+        #res["error"] = ("string", "timeout")
+        res["status"] = ("string", "UNKNOWN")
+    result   = []
+    error    = not "status" in res or ("error" in res and res["error"][1] != "std::bad_alloc")
+    memout   = "error" in res and res["error"][1] == "std::bad_alloc"
+    status   = res["status"][1] if "status" in res else None
+    timedout = memout or error or status == "UNKNOWN" or (status == "SATISFIABLE" and "optimum" in res) or res["time"][1] >= timeout or "interrupted" in res;
+    if timedout: res["time"] = ("float", timeout)
+    if error: 
+        sys.stderr.write("*** ERROR: Run {0} failed with unrecognized status or error!\n".format(root))
+        exit(1)
+    result.append(("error", "float", int(error)))
+    result.append(("timeout", "float", int(timedout)))
+    result.append(("memout", "float", int(memout)))
+
+    if "optimum" in res and not " " in res["optimum"][1]:
+        result.append(("optimum", "float", float(res["optimum"][1])))
+        del res["optimum"]
+    if "interrupted" in res: del res["interrupted"]
+    if "error" in res: del res["error"]
+    for key, val in res.items(): result.append((key, val[0], val[1]))
+    return result

benchmarks/dynasp

@@ -1,10 +1,10 @@
-<runscript output="output">
+<runscript output="benchmark/examples/clasp/output">
 
 	<machine name="houat" cpu="[email protected]" memory="24GB"/>
 	<machine name="zuse" cpu="[email protected]" memory="24GB"/>
 
-	<config name="seq-generic" template="templates/seq-generic.sh"/>
-	<system name="clasp" version="1.3.2" measures="clasp" config="seq-generic">
+	<config name="seq-generic" template="benchmarks/examples/clasp/templates/seq-generic.sh"/>
+	<system name="clasp" version="1.3.2" measures="benchmarks.examples.clasp.resultparsers.clasp" config="seq-generic">
 		<!-- optionally allows for tagging settings -->
 		<setting name="default"  tag="seq" cmdline="--stats 1"/>
 		<setting name="vsids"    tag="seq" cmdline="--stats --heu=vsids 1"/>
@@ -15,26 +15,26 @@
 		<setting name="norest"   tag="seq" cmdline="--stats --restarts=no 1"/>
 	</system>
 
-	<config name="pbs-generic" template="templates/pbs-generic.sh"/>
-	<system name="claspar" version="2.1.0" measures="claspar" config="pbs-generic">
-		<setting name="one-as" tag="par one-as" cmdline="--stats 1" ppn="2" procs="1 2 4 8" pbstemplate="templates/impi.pbs"/>
-		<setting name="all-as" tag="par all-as" cmdline="--stats -q 0" ppn="2" procs="1 2 4 8" pbstemplate="templates/impi.pbs"/>
+	<config name="pbs-generic" template="benchmarks/examples/clasp/templates/pbs-generic.sh"/>
+	<system name="claspar" version="2.1.0" measures="benchmarks.examples.clasp.resultparsers.claspar" config="pbs-generic">
+		<setting name="one-as" tag="par one-as" cmdline="--stats 1" ppn="2" procs="1 2 4 8" pbstemplate="benchmarks/examples/clasp/templates/impi.pbs"/>
+		<setting name="all-as" tag="par all-as" cmdline="--stats -q 0" ppn="2" procs="1 2 4 8" pbstemplate="benchmarks/examples/clasp/templates/impi.pbs"/>
 	</system>
 
 	<seqjob name="seq-generic" timeout="120" runs="1" parallel="8"/>
 	<pbsjob name="pbs-generic" timeout="120" runs="1" script_mode="timeout" walltime="23:59:59"/>
 
 	<benchmark name="seq-suite">
-		<folder path="benchmarks/clasp">
+		<folder path="benchmarks/examples/clasp/instances">
 			<ignore prefix="pigeons"/>
 		</folder>
-		<files path="benchmarks/clasp">
+		<files path="benchmarks/examples/clasp/instances">
 			<add file="pigeons/pigeonhole10-unsat.lp"/>
 			<add file="pigeons/pigeonhole11-unsat.lp"/>
 		</files>
 	</benchmark>
 	<benchmark name="pbs-suite">
-		<folder path="benchmarks/clasp"/>
+		<folder path="benchmarks/examples/clasp/instances"/>
 	</benchmark>
 
 	<project name="clasp-big" job="seq-generic">

benchmarks/clasp/blocked-queens/blocked-n-queens_decision-156.48.1960.36.1721259656.lp renamed to benchmarks/examples/clasp/instances/blocked-queens/blocked-n-queens_decision-156.48.1960.36.1721259656.lp

@@ -0,0 +1 @@
+sudoku_team1/sudokusolver.sh

benchmarks/clasp/blocked-queens/blocked-n-queens_decision-156.48.1960.36.1721330060.lp renamed to benchmarks/examples/clasp/instances/blocked-queens/blocked-n-queens_decision-156.48.1960.36.1721330060.lp

@@ -0,0 +1,50 @@
+import sys
+import numpy as np
+
+def convert_nativ_to_dense(N, i, j, n):
+    n = N**2*(i-1) + N*(j-1) + (n-1) + 1
+    return str(n) + " "
+
+def read_inital_values(file_name, N):
+    file_ptr = open(file_name)
+    out_file = open("sudoku.cnf", "w+")
+    i = 1
+    for line in file_ptr.readlines():
+        if line.startswith("|"):
+            line = line.replace("| ", "")
+            line = line.replace(" |" , "")
+            line = line.replace("\n", "")
+            numbers = line.split()
+            for j, nn in enumerate(numbers):
+                if nn != "_" and nn != "__" and nn != "___":
+                    nn = int(nn)
+                    out_file.write(str(convert_nativ_to_dense(N, i, j+1, nn)) + "0\n")
+            i += 1
+    file_ptr.close()
+    out_file.close()
+
+def get_model_information(file_name):
+    file_ptr = open(file_name)
+    for line in file_ptr.readlines():
+        if "puzzle size:" in line:
+            N_sqrt = int(line.split(" ")[-1].split("x")[-1])
+            N = N_sqrt * N_sqrt
+            break
+
+    file_ptr.close()
+    return N, N_sqrt
+
+def main():
+    file_name = sys.argv[1]
+    N, N_sqrt = get_model_information(file_name)
+    read_inital_values(file_name, N)
+    print(N_sqrt)
+
+
+
+
+if __name__ == "__main__":
+    main()
+
+
+

benchmarks/clasp/blocked-queens/blocked-n-queens_decision-156.48.1960.36.1721351180.lp renamed to benchmarks/examples/clasp/instances/blocked-queens/blocked-n-queens_decision-156.48.1960.36.1721351180.lp

@@ -0,0 +1,61 @@
+import numpy as np
+import sys
+#import birkhoff as bi
+
+f = open("out.txt")
+nn = int(sys.argv[1])
+N = nn**2
+
+def convert_dense_to_native(clause, N=4):
+    clause -= 1
+    first = clause % N**2
+    i = (clause - (first))/N**2 + 1
+    second = first % N
+    j = (first - second)/N + 1
+    n = second + 1
+    return i, j, n
+
+sodoku = np.zeros( (N, N) )
+for line in f.readlines():
+    if line[0] == "v":
+        clauses = line[2:].split(" ")
+        for n in clauses:
+            n = int(n)
+            if n>0:
+                i, j, n = convert_dense_to_native(n, N=N)
+                sodoku[i-1][j-1] = n
+
+#result = bi.birkhoff_von_neumann_decomposition(2*sodoku/(N*(N+1)))
+#for c, p in result:
+#    print("coeff ", (N+1)*N*c/2)
+#    print("m: ", p)
+
+
+
+
+f_out = open("result.txt", "w+")
+f_out.writelines("experiment: generator (Time: 0.1 s)\n")
+f_out.writelines("number of tasks: 1\n")
+f_out.writelines("task: 1\n")
+f_out.writelines("puzzle size: " + str(nn)+"x"+str(nn)+"\n")
+
+def make_numb_str(n, N):
+    numb_str = str(int(n))
+    while len(numb_str) < N:
+        numb_str = " " + numb_str
+    return numb_str
+
+a = len(str(int(np.max(sodoku))))
+
+sep_line = nn*("+" + nn*a*"-" + (nn+1)*"-") + "+"
+for i in range(N):
+    if (i % nn) == 0:
+        f_out.writelines(sep_line+"\n")
+    line = "|"
+    for j in range(N):
+        line += " " + make_numb_str(sodoku[i][j], a)
+        if (j + 1 ) % nn == 0:
+            line += " |"
+    f_out.writelines(line+"\n")
+f_out.writelines(sep_line+"\n")
+f_out.close()