Examples and clean-ups (#1)
- Attempt at implementing an example for DRS - Complete reactions set - New automaton - Formula - Fixed automaton scaling - Proc index in the formula - Benchmark generators - Scripts to reproduce experiments for reaction mining
This commit was merged in pull request #1.
This commit is contained in:
Artur Meski
290
examples/bdd/generators/gen_drs.py
Executable file
290
examples/bdd/generators/gen_drs.py
Executable file
@@ -0,0 +1,290 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
import sys
|
||||
import itertools
|
||||
|
||||
|
||||
class SingleReaction:
|
||||
def __init__(self, reactants=None, inhibitors=None, products=None):
|
||||
self.reactants = set(reactants) if reactants is not None else set()
|
||||
self.inhibitors = set(inhibitors) if inhibitors is not None else set()
|
||||
self.products = set(products) if products is not None else set()
|
||||
|
||||
def get_reactants(self):
|
||||
return "{" + ", ".join(self.reactants) + "}"
|
||||
|
||||
def get_inhibitors(self):
|
||||
return "{" + ", ".join(self.inhibitors) + "}"
|
||||
|
||||
def get_products(self):
|
||||
return "{" + ", ".join(self.products) + "}"
|
||||
|
||||
def __str__(self):
|
||||
return (
|
||||
"{"
|
||||
+ f"{self.get_reactants()}, {self.get_inhibitors()} -> {self.get_products()}"
|
||||
+ "};"
|
||||
)
|
||||
|
||||
|
||||
class Reactions:
|
||||
def __init__(self):
|
||||
self.reactions = []
|
||||
|
||||
def add(self, reaction):
|
||||
self.reactions.append(reaction)
|
||||
|
||||
def __str__(self):
|
||||
ret = ""
|
||||
for r in self.reactions:
|
||||
ret += f"{r}\n"
|
||||
return ret
|
||||
|
||||
|
||||
class Transition:
|
||||
def __init__(self, src, dst, guard, context):
|
||||
self.src = src
|
||||
self.dst = dst
|
||||
self.guard = guard
|
||||
self.context = context
|
||||
|
||||
def get_context_str(self):
|
||||
r = []
|
||||
for proc, entities in self.context:
|
||||
ent_str = ",".join(entities)
|
||||
r.append(f"{proc}={{{ent_str}}}")
|
||||
|
||||
r = " ".join(r)
|
||||
return "{ " + r + " }"
|
||||
|
||||
def __str__(self):
|
||||
if self.guard:
|
||||
return f"{self.get_context_str()}: {self.src} -> {self.dst} : {self.guard};"
|
||||
else:
|
||||
return f"{self.get_context_str()}: {self.src} -> {self.dst};"
|
||||
|
||||
|
||||
class Automaton:
|
||||
def __init__(self):
|
||||
self.transitions = []
|
||||
self.states = []
|
||||
self.init_state = None
|
||||
|
||||
def add_transition(self, transition):
|
||||
self.transitions.append(transition)
|
||||
|
||||
def add_state(self, state):
|
||||
if state not in self.states:
|
||||
self.states.append(state)
|
||||
|
||||
def set_init_state(self, state):
|
||||
assert state in self.states, f"{state} not in states"
|
||||
self.init_state = state
|
||||
|
||||
def __str__(self):
|
||||
r = "context-automaton {\n"
|
||||
r += "\tstates { " + ", ".join(self.states) + " };\n"
|
||||
r += f"\tinit-state {{ {self.init_state} }};\n"
|
||||
r += "\ttransitions {\n"
|
||||
for tr in self.transitions:
|
||||
r += "\t\t" + str(tr) + "\n"
|
||||
r += "\t};\n"
|
||||
r += "};\n"
|
||||
return r
|
||||
|
||||
|
||||
class DRSGenerator:
|
||||
def __init__(self, x, y, z, aut):
|
||||
assert y >= z
|
||||
assert x >= 2 and y >= 2 and z >= 2
|
||||
self.x = x
|
||||
self.y = y
|
||||
self.z = z
|
||||
self.aut_id = aut
|
||||
self.n = self.y
|
||||
self.reactions = {}
|
||||
|
||||
self.automaton = Automaton()
|
||||
|
||||
self.generate()
|
||||
|
||||
def generate_agent_zero(self):
|
||||
rcts = Reactions()
|
||||
for i in range(1, self.y + 1):
|
||||
rcts.add(SingleReaction(["RTK"], ["h"], [f"RTK{i}"]))
|
||||
for j in range(1, self.x + 1):
|
||||
rcts.add(SingleReaction([f"EN:{j}_{i}"], ["h"], [f"ENi:{self.x}_{i}"]))
|
||||
return rcts
|
||||
|
||||
def generate_reactions_for_component(self, i):
|
||||
self.reactions.setdefault(i, Reactions())
|
||||
rcts = self.reactions[i]
|
||||
rcts.add(SingleReaction(["GF"], ["h"], ["GF"]))
|
||||
rcts.add(SingleReaction(["GF"], ["h", f"RTK{i}"], ["RTK"]))
|
||||
rcts.add(SingleReaction(["RTK"], [f"ENi:1_{i}"], [f"EN:1_{i}"]))
|
||||
for j in range(1, self.x):
|
||||
rcts.add(
|
||||
SingleReaction([f"EN:{j}_{i}"], [f"ENi:{j+1}_{i}"], [f"EN:{j+1}_{i}"])
|
||||
)
|
||||
|
||||
indices = list(range(1, self.y + 1))
|
||||
for comb in itertools.combinations(indices, self.z):
|
||||
reactants = []
|
||||
for i in comb:
|
||||
reactants.append(f"EN:{self.x}_{i}")
|
||||
rcts.add(SingleReaction(reactants, ["h"], ["TF"]))
|
||||
|
||||
def generate(self):
|
||||
|
||||
print(f"# Generated for: x = {self.x}, y = {self.y}, z = {self.z}")
|
||||
|
||||
print("options { use-context-automaton; make-progressive; };")
|
||||
print("reactions {")
|
||||
|
||||
for i in range(1, self.y + 1):
|
||||
self.generate_reactions_for_component(i)
|
||||
|
||||
rcts_0 = self.generate_agent_zero()
|
||||
|
||||
print("proc0 {")
|
||||
print(rcts_0)
|
||||
print("};")
|
||||
|
||||
for proc, reactions in self.reactions.items():
|
||||
print(f"proc{proc} {{")
|
||||
print(reactions)
|
||||
print("};")
|
||||
|
||||
print("};")
|
||||
|
||||
if self.aut_id == "a":
|
||||
self.generate_automaton_4(self.n)
|
||||
elif self.aut_id == "b":
|
||||
self.generate_automaton_5(self.n)
|
||||
else:
|
||||
raise RuntimeError(f"Unknown automaton identifier: {self.aut_id}")
|
||||
|
||||
self.generate_formula()
|
||||
|
||||
def generate_automaton_4(self, n):
|
||||
aut = self.automaton
|
||||
|
||||
aut.add_state("qI")
|
||||
aut.add_state("qS")
|
||||
for i in range(1, n + 1):
|
||||
aut.add_state(f"q{i}A")
|
||||
aut.add_state(f"q{i}B")
|
||||
aut.add_state(f"q{i}C")
|
||||
aut.add_state(f"q{i}D")
|
||||
|
||||
aut.set_init_state("qI")
|
||||
|
||||
aut.add_transition(
|
||||
Transition("qI", "qS", "", [(f"proc{i}", ["GF"]) for i in range(0, n + 1)])
|
||||
)
|
||||
|
||||
for i in range(1, n + 1):
|
||||
aut.add_transition(Transition("qS", f"q{i}A", "", [(f"proc{i}", [])]))
|
||||
aut.add_transition(
|
||||
Transition(
|
||||
f"q{i}A", f"q{i}B", "", [(f"proc{v}", []) for v in range(0, n + 1)]
|
||||
)
|
||||
)
|
||||
aut.add_transition(Transition(f"q{i}B", f"q{i}C", "", [(f"proc{i}", [])]))
|
||||
aut.add_transition(
|
||||
Transition(
|
||||
f"q{i}C", f"q{i}D", "", [(f"proc{v}", []) for v in range(0, n + 1)]
|
||||
)
|
||||
)
|
||||
|
||||
for i in range(1, n + 1):
|
||||
for j in range(1, n + 1):
|
||||
if i == j:
|
||||
continue
|
||||
aut.add_transition(
|
||||
Transition(f"q{i}B", f"q{j}A", "", [(f"proc{j}", [])])
|
||||
)
|
||||
aut.add_transition(
|
||||
Transition(f"q{i}D", f"q{j}A", "", [(f"proc{j}", [])])
|
||||
)
|
||||
|
||||
print(aut)
|
||||
|
||||
def generate_automaton_5(self, n):
|
||||
|
||||
aut = self.automaton
|
||||
|
||||
for i in range(0, (4 * n + 1)):
|
||||
aut.add_state(f"q{i}")
|
||||
|
||||
aut.set_init_state("q0")
|
||||
|
||||
aut.add_transition(
|
||||
Transition("q0", "q1", "", [(f"proc{i}", ["GF"]) for i in range(0, n + 1)])
|
||||
)
|
||||
|
||||
for i in range(0, n): # 0, ..., n-1
|
||||
aut.add_transition(
|
||||
Transition(f"q{4*i+1}", f"q{4*i+2}", "", [(f"proc{i+1}", [])])
|
||||
)
|
||||
aut.add_transition(
|
||||
Transition(
|
||||
f"q{4*i+2}",
|
||||
f"q{4*i+3}",
|
||||
"",
|
||||
[(f"proc{v}", []) for v in range(0, n + 1)],
|
||||
)
|
||||
)
|
||||
aut.add_transition(
|
||||
Transition(f"q{4*i+3}", f"q{4*i+4}", "", [(f"proc{i+1}", [])])
|
||||
)
|
||||
|
||||
for i in range(0, n - 1): # 0, ..., n-2
|
||||
aut.add_transition(
|
||||
Transition(
|
||||
f"q{4*i+4}",
|
||||
f"q{4*i+5}",
|
||||
"",
|
||||
[(f"proc{v}", []) for v in range(0, n + 1)],
|
||||
)
|
||||
)
|
||||
|
||||
aut.add_transition(
|
||||
Transition(f"q{4*n}", "q1", "", [(f"proc{i}", []) for i in range(0, n + 1)])
|
||||
)
|
||||
|
||||
print(aut)
|
||||
|
||||
def generate_formula(self):
|
||||
|
||||
disjunction = " OR ".join([f"proc{i}.TF" for i in range(1, self.y + 1)])
|
||||
conjunction = " AND ".join([f"~proc{i}.TF" for i in range(1, self.y + 1)])
|
||||
|
||||
r = (
|
||||
"rsctlk-property { f0 : AG( K[proc0]( "
|
||||
+ disjunction
|
||||
+ " ) OR K[proc0]( "
|
||||
+ conjunction
|
||||
+ " ) ) };"
|
||||
)
|
||||
|
||||
print(r)
|
||||
|
||||
|
||||
def main():
|
||||
if len(sys.argv) < 1 + 4:
|
||||
print(f"Usage: {sys.argv[0]} <x> <y> <z> <Aut>")
|
||||
print("\twhere x,y,z >= 2 and y >= z")
|
||||
print("\tAut: a, b")
|
||||
sys.exit(1)
|
||||
|
||||
g = DRSGenerator(
|
||||
x=int(sys.argv[1]),
|
||||
y=int(sys.argv[2]),
|
||||
z=int(sys.argv[3]),
|
||||
aut=sys.argv[4],
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
2
examples/smt/chain_reaction.py
Normal file → Executable file
2
examples/smt/chain_reaction.py
Normal file → Executable file
@@ -28,7 +28,6 @@ import resource
|
||||
|
||||
|
||||
def chain_reaction(print_system=False):
|
||||
|
||||
if len(sys.argv) < 1 + 3:
|
||||
print("{source} <N> <M> <type>".format(source=sys.argv[0]))
|
||||
print()
|
||||
@@ -115,7 +114,6 @@ def chain_reaction(print_system=False):
|
||||
|
||||
|
||||
def main():
|
||||
|
||||
chain_reaction()
|
||||
|
||||
|
||||
|
||||
19
examples/smt/heat_shock_response.py
Normal file → Executable file
19
examples/smt/heat_shock_response.py
Normal file → Executable file
@@ -28,7 +28,6 @@ import resource
|
||||
|
||||
|
||||
def heat_shock_response(print_system=True, verify_rsc=True):
|
||||
|
||||
if len(sys.argv) < 1 + 1:
|
||||
print("{source} <type>".format(source=sys.argv[0]))
|
||||
print("type:")
|
||||
@@ -62,15 +61,23 @@ def heat_shock_response(print_system=True, verify_rsc=True):
|
||||
r.add_reaction([("hsf3", 1)], [("hse", 1), ("hsp", 1)], [("hsf", 1)])
|
||||
r.add_reaction([("hsf3", 1), ("hsp", 1), ("mfp", 1)], [("hse", 1)], [("hsf", 1)])
|
||||
r.add_reaction([("hsf3", 1), ("hse", 1)], [("hsp", 1)], [("hsf3:hse", 1)])
|
||||
r.add_reaction([("hsp",1),("hsf3",1),("mfp",1),("hse",1)],[], [("hsf3:hse",1)])
|
||||
r.add_reaction(
|
||||
[("hsp", 1), ("hsf3", 1), ("mfp", 1), ("hse", 1)], [], [("hsf3:hse", 1)]
|
||||
)
|
||||
r.add_reaction([("hse", 1)], [("hsf3", 1)], [("hse", 1)])
|
||||
r.add_reaction([("hsp", 1), ("hsf3", 1), ("hse", 1)], [("mfp", 1)], [("hse", 1)])
|
||||
r.add_reaction([("hsf3:hse", 1)], [("hsp", 1)], [("hsp", 1), ("hsf3:hse", 1)])
|
||||
r.add_reaction([("hsp",1),("mfp",1),("hsf3:hse",1)],[], [("hsp",1),("hsf3:hse",1)])
|
||||
r.add_reaction(
|
||||
[("hsp", 1), ("mfp", 1), ("hsf3:hse", 1)], [], [("hsp", 1), ("hsf3:hse", 1)]
|
||||
)
|
||||
r.add_reaction([("hsf", 1), ("hsp", 1)], [("mfp", 1)], [("hsp:hsf", 1)])
|
||||
r.add_reaction([("hsp:hsf",1),("temp",stress_temp)],[], [("hsf",1),("hsp",1)])
|
||||
r.add_reaction(
|
||||
[("hsp:hsf", 1), ("temp", stress_temp)], [], [("hsf", 1), ("hsp", 1)]
|
||||
)
|
||||
r.add_reaction([("hsp:hsf", 1)], [("temp", stress_temp)], [("hsp:hsf", 1)])
|
||||
r.add_reaction([("hsp",1),("hsf3:hse",1)], [("mfp",1)], [("hse",1),("hsp:hsf",1)])
|
||||
r.add_reaction(
|
||||
[("hsp", 1), ("hsf3:hse", 1)], [("mfp", 1)], [("hse", 1), ("hsp:hsf", 1)]
|
||||
)
|
||||
r.add_reaction([("temp", stress_temp), ("prot", 1)], [], [("mfp", 1), ("prot", 1)])
|
||||
r.add_reaction([("prot", 1)], [("temp", stress_temp)], [("prot", 1)])
|
||||
r.add_reaction([("hsp", 1), ("mfp", 1)], [], [("hsp:mfp", 1)])
|
||||
@@ -117,9 +124,9 @@ def state_translate_rsc2rs(p):
|
||||
|
||||
|
||||
def main():
|
||||
|
||||
heat_shock_response()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
|
||||
7
examples/smt/mutex_param.py
Normal file → Executable file
7
examples/smt/mutex_param.py
Normal file → Executable file
@@ -77,7 +77,6 @@ def mutex_param_bench(cmd_args):
|
||||
Inhib = [("s", 1)]
|
||||
|
||||
for i in range(n_proc):
|
||||
|
||||
r.add_reaction([E("out", i), E("act", i)], Inhib, [E("req", i)])
|
||||
r.add_reaction([E("out", i)], [E("act", i)], [E("out", i)])
|
||||
|
||||
@@ -217,7 +216,6 @@ def mutex_nonparam_bench(cmd_args):
|
||||
Inhib = [("s", 1)]
|
||||
|
||||
for i in range(n_proc):
|
||||
|
||||
r.add_reaction([E("out", i), E("act", i)], Inhib, [E("req", i)])
|
||||
r.add_reaction([E("out", i)], [E("act", i)], [E("out", i)])
|
||||
|
||||
@@ -325,7 +323,6 @@ def mutex_nonparam_bench_oldimpl(cmd_args):
|
||||
Inhib = [("s", 1)]
|
||||
|
||||
for i in range(n_proc):
|
||||
|
||||
r.add_reaction([E("out", i), E("act", i)], Inhib, [E("req", i)])
|
||||
r.add_reaction([E("out", i)], [E("act", i)], [E("out", i)])
|
||||
|
||||
@@ -407,7 +404,6 @@ def state_translate_rsc2rs(p):
|
||||
|
||||
|
||||
def mutex_bench_main(cmd_args):
|
||||
|
||||
mode = cmd_args.mode
|
||||
|
||||
if mode == "p":
|
||||
@@ -422,7 +418,6 @@ def mutex_bench_main(cmd_args):
|
||||
|
||||
|
||||
def main():
|
||||
|
||||
parser = argparse.ArgumentParser()
|
||||
|
||||
parser.add_argument(
|
||||
@@ -432,7 +427,7 @@ def main():
|
||||
|
||||
parser.add_argument(
|
||||
"mode",
|
||||
choices=['p', 'np-p', 'np-np'],
|
||||
choices=["p", "np-p", "np-np"],
|
||||
help="Selects the mode: p - parameter synthesis (parametric implementation), np-p - non-parametric with parametric implementation (with the parameters substituted), np-np - non-parametric with non-parametric implementation (parameters substituted)",
|
||||
)
|
||||
|
||||
|
||||
54
examples/smt/scalable_chain.py
Normal file → Executable file
54
examples/smt/scalable_chain.py
Normal file → Executable file
@@ -31,6 +31,7 @@ from itertools import chain, combinations
|
||||
import sys
|
||||
import resource
|
||||
|
||||
|
||||
def generate_system(chainLen, maxConc):
|
||||
"""
|
||||
This function generates the reaction system with concentrations
|
||||
@@ -54,7 +55,11 @@ def generate_system(chainLen, maxConc):
|
||||
if i < chainLen:
|
||||
r.add_reaction([(ent, maxConc)], [], [("e_" + str(i + 1), 1)])
|
||||
|
||||
r.add_reaction([("e_" + str(chainLen),maxConc)],[("dec",1)],[("e_" + str(chainLen),maxConc)])
|
||||
r.add_reaction(
|
||||
[("e_" + str(chainLen), maxConc)],
|
||||
[("dec", 1)],
|
||||
[("e_" + str(chainLen), maxConc)],
|
||||
)
|
||||
|
||||
c = ContextAutomatonWithConcentrations(r)
|
||||
c.add_init_state("init")
|
||||
@@ -66,6 +71,7 @@ def generate_system(chainLen, maxConc):
|
||||
|
||||
return rc
|
||||
|
||||
|
||||
def generate_formula(formula_number, chainLen, maxConc):
|
||||
"""
|
||||
This function generates the rsLTL formula
|
||||
@@ -73,30 +79,50 @@ def generate_formula(formula_number, chainLen, maxConc):
|
||||
"""
|
||||
|
||||
if formula_number == 1:
|
||||
ret = Formula_rsLTL.f_F( BagDescription.f_entity("inc") > 0, (BagDescription.f_entity('e_'+str(chainLen)) >= maxConc) )
|
||||
ret = Formula_rsLTL.f_F(
|
||||
BagDescription.f_entity("inc") > 0,
|
||||
(BagDescription.f_entity("e_" + str(chainLen)) >= maxConc),
|
||||
)
|
||||
|
||||
elif formula_number == 2:
|
||||
f_tmp = Formula_rsLTL.f_F( BagDescription.f_entity("inc") > 0, (BagDescription.f_entity('e_'+str(chainLen)) == maxConc) )
|
||||
f_tmp = Formula_rsLTL.f_F(
|
||||
BagDescription.f_entity("inc") > 0,
|
||||
(BagDescription.f_entity("e_" + str(chainLen)) == maxConc),
|
||||
)
|
||||
for i in range(chainLen - 1, 0, -1):
|
||||
f_tmp = Formula_rsLTL.f_F( BagDescription.f_entity("inc") > 0, f_tmp & (BagDescription.f_entity('e_'+str(i)) == maxConc) )
|
||||
f_tmp = Formula_rsLTL.f_F(
|
||||
BagDescription.f_entity("inc") > 0,
|
||||
f_tmp & (BagDescription.f_entity("e_" + str(i)) == maxConc),
|
||||
)
|
||||
ret = f_tmp
|
||||
|
||||
elif formula_number == 3:
|
||||
ret = Formula_rsLTL.f_G( BagDescription.f_TRUE(),
|
||||
ret = Formula_rsLTL.f_G(
|
||||
BagDescription.f_TRUE(),
|
||||
Formula_rsLTL.f_Implies(
|
||||
(BagDescription.f_entity('e_1') == 1),
|
||||
(BagDescription.f_entity("e_1") == 1),
|
||||
Formula_rsLTL.f_F(
|
||||
BagDescription.f_entity("inc") > 0,
|
||||
(BagDescription.f_entity('e_'+str(chainLen)) == maxConc)
|
||||
)
|
||||
)
|
||||
(BagDescription.f_entity("e_" + str(chainLen)) == maxConc),
|
||||
),
|
||||
),
|
||||
)
|
||||
|
||||
elif formula_number == 4:
|
||||
ret = Formula_rsLTL.f_F( BagDescription.f_entity("inc") > 0 , BagDescription.f_entity('e_1') == maxConc )
|
||||
ret = Formula_rsLTL.f_F(
|
||||
BagDescription.f_entity("inc") > 0,
|
||||
BagDescription.f_entity("e_1") == maxConc,
|
||||
)
|
||||
|
||||
elif formula_number == 5:
|
||||
ret = Formula_rsLTL.f_X(BagDescription.f_TRUE(), Formula_rsLTL.f_U( BagDescription.f_entity("inc") > 0 , BagDescription.f_entity('e_1') > 0, BagDescription.f_entity('e_2') > 0 ) )
|
||||
ret = Formula_rsLTL.f_X(
|
||||
BagDescription.f_TRUE(),
|
||||
Formula_rsLTL.f_U(
|
||||
BagDescription.f_entity("inc") > 0,
|
||||
BagDescription.f_entity("e_1") > 0,
|
||||
BagDescription.f_entity("e_2") > 0,
|
||||
),
|
||||
)
|
||||
|
||||
else:
|
||||
ret = None
|
||||
@@ -116,12 +142,12 @@ def save_statistics(smt_rsc, formula_number, chainLen, maxConc):
|
||||
filename_m = "bench_rsc_F" + str(formula_number) + "_mem.log"
|
||||
time = smt_rsc.get_verification_time()
|
||||
|
||||
f=open(filename_t, 'a')
|
||||
f = open(filename_t, "a")
|
||||
log_str = "(" + str(chainLen) + "," + str(maxConc) + "," + str(time) + ")\n"
|
||||
f.write(log_str)
|
||||
f.close()
|
||||
|
||||
f=open(filename_m, 'a')
|
||||
f = open(filename_m, "a")
|
||||
log_str = "(" + str(chainLen) + "," + str(maxConc) + "," + str(mem_usage) + ")\n"
|
||||
f.write(log_str)
|
||||
f.close()
|
||||
@@ -168,6 +194,6 @@ def scalable_chain(print_system=False):
|
||||
def main():
|
||||
scalable_chain(print_system=True)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
|
||||
97
experiments/drs_cell_signal/run.sh
Executable file
97
experiments/drs_cell_signal/run.sh
Executable file
@@ -0,0 +1,97 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
x_values="2 3 4"
|
||||
y_values="`seq 2 20`"
|
||||
z_values="`seq 2 20`"
|
||||
aut_values="a b"
|
||||
|
||||
reactics="$1"
|
||||
reactics_opts="-z -x -vv -B -c"
|
||||
|
||||
input_generator="../../examples/bdd/generators/gen_drs.py"
|
||||
|
||||
benchname="sig"
|
||||
formname="f0"
|
||||
|
||||
outdir="results_${benchname}"
|
||||
|
||||
if [[ -z "$1" ]]
|
||||
then
|
||||
echo "Usage: $0 <path to reactics>"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [[ ! -x "$reactics" ]]
|
||||
then
|
||||
echo "Provided path to ReactICS not executable"
|
||||
fi
|
||||
|
||||
if [[ ! -d "$outdir" ]]
|
||||
then
|
||||
echo "Creating output directory: $outdir"
|
||||
mkdir -p $outdir
|
||||
fi
|
||||
|
||||
#ulimit -t 3600
|
||||
#ulimit -v 2097152
|
||||
ulimit -t 3600
|
||||
#ulimit -v 1000000
|
||||
|
||||
for a in $aut_values
|
||||
do
|
||||
for z in $z_values
|
||||
do
|
||||
for y in $y_values
|
||||
do
|
||||
for x in $x_values
|
||||
do
|
||||
|
||||
if [[ $y -lt $z ]]
|
||||
then
|
||||
# Skip undesired values
|
||||
continue
|
||||
fi
|
||||
|
||||
if [[ $y -ne $z ]]
|
||||
then
|
||||
# More aggressive skipping
|
||||
continue
|
||||
fi
|
||||
|
||||
bench_identifier="${benchname}_F${formname}_A${a}"
|
||||
|
||||
filename_base="${outdir}/${benchname}_F${formname}__x${x}_y${y}_z${z}_A${a}"
|
||||
outfile="${filename_base}.out"
|
||||
infile="${filename_base}.drs"
|
||||
|
||||
stopfile="DONE_${bench_identifier}"
|
||||
|
||||
if [[ -e "$stopfile" ]]
|
||||
then
|
||||
echo "Time limit -- SKIPPING"
|
||||
continue
|
||||
fi
|
||||
|
||||
$input_generator $x $y $z $a > ${infile}
|
||||
|
||||
$reactics $reactics_opts $formname $infile |& tee ${outfile}
|
||||
exitcode=$?
|
||||
echo "ReactICS exit code: $exitcode"
|
||||
|
||||
result="$(tail -1 $outfile | grep -E '.*;.*;.*;.*'| sed "s/STAT/$n /")"
|
||||
if [ "$result" = "" ]
|
||||
then
|
||||
echo "TIME LIMIT; marking as finished"
|
||||
#touch $stopfile
|
||||
else
|
||||
echo "$x ; $y ; $z ; $a ; $exitcode $result" >> $outdir/summary_${bench_identifier}.txt
|
||||
echo "$x $y $z $a $(echo $result | sed 's/;/ /g')" >> $outdir/${bench_identifier}.dat
|
||||
echo $result
|
||||
fi
|
||||
|
||||
done
|
||||
done
|
||||
done
|
||||
done
|
||||
|
||||
# EOF
|
||||
@@ -0,0 +1,20 @@
|
||||
2 69.171875
|
||||
3 69.937500
|
||||
4 86.109375
|
||||
5 76.093750
|
||||
6 81.812500
|
||||
7 97.078125
|
||||
8 88.562500
|
||||
9 102.968750
|
||||
10 93.546875
|
||||
11 98.515625
|
||||
12 113.671875
|
||||
13 115.656250
|
||||
14 132.140625
|
||||
15 141.546875
|
||||
16 149.890625
|
||||
17 155.125000
|
||||
18 153.500000
|
||||
19 166.953125
|
||||
20 169.750000
|
||||
21 212.468750
|
||||
@@ -0,0 +1,20 @@
|
||||
2 68.765625
|
||||
3 73.140625
|
||||
4 71.625000
|
||||
5 73.359375
|
||||
6 79.234375
|
||||
7 75.578125
|
||||
8 79.812500
|
||||
9 85.828125
|
||||
10 81.718750
|
||||
11 79.828125
|
||||
12 83.984375
|
||||
13 80.406250
|
||||
14 75.859375
|
||||
15 85.812500
|
||||
16 89.093750
|
||||
17 84.296875
|
||||
18 89.078125
|
||||
19 87.609375
|
||||
20 88.281250
|
||||
21 85.406250
|
||||
@@ -0,0 +1,20 @@
|
||||
2 0.068995
|
||||
3 0.110615
|
||||
4 0.164639
|
||||
5 0.234950
|
||||
6 0.322793
|
||||
7 0.438878
|
||||
8 0.578109
|
||||
9 0.752163
|
||||
10 0.955217
|
||||
11 1.190432
|
||||
12 1.519409
|
||||
13 1.808177
|
||||
14 2.200211
|
||||
15 2.654874
|
||||
16 3.265984
|
||||
17 3.824895
|
||||
18 4.413004
|
||||
19 5.303216
|
||||
20 6.310782
|
||||
21 7.038971
|
||||
@@ -0,0 +1,20 @@
|
||||
2 0.095321
|
||||
3 0.171177
|
||||
4 0.272130
|
||||
5 0.417800
|
||||
6 0.584877
|
||||
7 0.766862
|
||||
8 1.009195
|
||||
9 1.295766
|
||||
10 1.741482
|
||||
11 2.354580
|
||||
12 2.949242
|
||||
13 3.127326
|
||||
14 4.074318
|
||||
15 4.978959
|
||||
16 6.690042
|
||||
17 8.114637
|
||||
18 12.006410
|
||||
19 11.929118
|
||||
20 14.044730
|
||||
21 15.673520
|
||||
20
experiments/reaction_mining_mutex/bench_mutex_param_mem.dat
Normal file
20
experiments/reaction_mining_mutex/bench_mutex_param_mem.dat
Normal file
@@ -0,0 +1,20 @@
|
||||
2 80.093750
|
||||
3 76.062500
|
||||
4 88.312500
|
||||
5 97.140625
|
||||
6 95.234375
|
||||
7 109.843750
|
||||
8 111.218750
|
||||
9 132.921875
|
||||
10 142.546875
|
||||
11 151.546875
|
||||
12 175.546875
|
||||
13 186.109375
|
||||
14 206.546875
|
||||
15 235.281250
|
||||
16 245.515625
|
||||
17 249.562500
|
||||
18 260.203125
|
||||
19 278.796875
|
||||
20 292.781250
|
||||
21 300.562500
|
||||
20
experiments/reaction_mining_mutex/bench_mutex_param_time.dat
Normal file
20
experiments/reaction_mining_mutex/bench_mutex_param_time.dat
Normal file
@@ -0,0 +1,20 @@
|
||||
2 0.487115
|
||||
3 0.880007
|
||||
4 1.301547
|
||||
5 2.172839
|
||||
6 2.662308
|
||||
7 3.880329
|
||||
8 4.491871
|
||||
9 6.922392
|
||||
10 8.729740
|
||||
11 10.901971
|
||||
12 13.885037
|
||||
13 18.246820
|
||||
14 21.987255
|
||||
15 28.236579
|
||||
16 41.065607
|
||||
17 44.456013
|
||||
18 50.782835
|
||||
19 59.535617
|
||||
20 83.400427
|
||||
21 96.250559
|
||||
454
experiments/reaction_mining_mutex/pmutex.py
Executable file
454
experiments/reaction_mining_mutex/pmutex.py
Executable file
@@ -0,0 +1,454 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
#
|
||||
# Copyright (c) 2015-2019 Artur Meski
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in all
|
||||
# copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
#
|
||||
|
||||
from rs import *
|
||||
from smt import *
|
||||
from logics import *
|
||||
from rsltl_shortcuts import *
|
||||
|
||||
from itertools import chain, combinations
|
||||
|
||||
import sys
|
||||
import resource
|
||||
import argparse
|
||||
|
||||
|
||||
def powerset(iterable, N=None):
|
||||
if N is None:
|
||||
N = len(s)
|
||||
s = list(iterable)
|
||||
return chain.from_iterable(combinations(s, r) for r in range(N + 1))
|
||||
|
||||
|
||||
def mutex_param_bench(cmd_args):
|
||||
"""
|
||||
Mutex Benchmark
|
||||
|
||||
Parametric
|
||||
"""
|
||||
|
||||
base_entities = ["out", "req", "in", "act"]
|
||||
shared_entities = ["lock", "done", "s"]
|
||||
|
||||
if not cmd_args.scaling:
|
||||
print("Missing scaling parameter")
|
||||
return
|
||||
n_proc = int(cmd_args.scaling)
|
||||
|
||||
r = ReactionSystemWithConcentrationsParam()
|
||||
|
||||
def E(a, b, c=1):
|
||||
return (a + "_" + str(b), c)
|
||||
|
||||
for i in range(n_proc):
|
||||
for ent in base_entities:
|
||||
max_conc = 1
|
||||
if ent == "in":
|
||||
max_conc = 3
|
||||
elif ent == "req":
|
||||
max_conc = 2
|
||||
r.add_bg_set_entity(E(ent, i, max_conc))
|
||||
|
||||
for ent in shared_entities:
|
||||
max_conc = 1
|
||||
r.add_bg_set_entity((ent, max_conc))
|
||||
|
||||
###################################################
|
||||
|
||||
Inhib = [("s", 1)]
|
||||
|
||||
for i in range(n_proc):
|
||||
r.add_reaction([E("out", i), E("act", i)], Inhib, [E("req", i)])
|
||||
r.add_reaction([E("out", i)], [E("act", i)], [E("out", i)])
|
||||
|
||||
for j in range(n_proc):
|
||||
if i != j:
|
||||
r.add_reaction(
|
||||
[E("req", i), E("act", i), E("act", j)], Inhib, [E("req", i)]
|
||||
)
|
||||
|
||||
r.add_reaction([E("req", i)], [E("act", i)], [E("req", i, 2)])
|
||||
|
||||
enter_inhib = [E("act", j) for j in range(n_proc) if i != j] + [("lock", 1)]
|
||||
r.add_reaction(
|
||||
[E("req", i, 2), E("act", i)], enter_inhib, [E("in", i, 3), ("lock", 1)]
|
||||
)
|
||||
|
||||
r.add_reaction([E("in", i, 3), E("act", i)], Inhib, [E("in", i, 2)])
|
||||
r.add_reaction([E("in", i, 2), E("act", i)], Inhib, [E("in", i, 1)])
|
||||
|
||||
r.add_reaction([E("in", i), E("act", i)], Inhib, [E("out", i), ("done", 1)])
|
||||
r.add_reaction([E("in", i)], [E("act", i)], [E("in", i)])
|
||||
|
||||
r.add_reaction([("lock", 1)], [("done", 1)], [("lock", 1)])
|
||||
|
||||
lda1 = r.get_param("lda1")
|
||||
lda2 = r.get_param("lda2")
|
||||
lda3 = r.get_param("lda3")
|
||||
|
||||
r.add_reaction(lda1, lda2, lda3)
|
||||
|
||||
###################################################
|
||||
|
||||
c = ContextAutomatonWithConcentrations(r)
|
||||
c.add_init_state("0")
|
||||
c.add_state("1")
|
||||
|
||||
init_ctx = []
|
||||
for i in range(n_proc):
|
||||
init_ctx.append(E("out", i))
|
||||
|
||||
# the experiments starts with adding x and y:
|
||||
c.add_transition("0", init_ctx, "1")
|
||||
|
||||
all_act = powerset([E("act", i) for i in range(n_proc)], 2)
|
||||
|
||||
for actions in all_act:
|
||||
actions = list(actions)
|
||||
|
||||
c.add_transition("1", actions, "1")
|
||||
|
||||
# for all the remaining steps we have empty context sequences
|
||||
# c.add_transition("1", [], "1")
|
||||
# c.add_transition("1", [("h", 1)], "1")
|
||||
|
||||
###################################################
|
||||
|
||||
rc = ReactionSystemWithAutomaton(r, c)
|
||||
rc.show()
|
||||
|
||||
f_attack = ltl_F(
|
||||
True, bag_And(bag_entity("in_0") == 1, bag_entity("in_" + str(n_proc - 1)) == 1)
|
||||
)
|
||||
|
||||
ent_of_Nth_proc = [
|
||||
ent + "_" + str(n_proc - 1) for ent in base_entities
|
||||
] + shared_entities
|
||||
disallow = ["in_" + str(n_proc - 1)]
|
||||
for ent in r.background_set:
|
||||
if ent not in ent_of_Nth_proc:
|
||||
disallow.append(ent)
|
||||
|
||||
# disallow.append("act_" + str(n_proc-1))
|
||||
|
||||
# disallow = ["in_0", "in_" + str(n_proc)] #, "req_0", "req_1"]
|
||||
lda1_disallow = [param_entity(lda1, ent) == 0 for ent in disallow]
|
||||
lda2_disallow = [param_entity(lda2, ent) == 0 for ent in disallow]
|
||||
lda3_disallow = [param_entity(lda3, ent) == 0 for ent in disallow]
|
||||
lda_disallow = lda1_disallow + lda2_disallow + lda3_disallow
|
||||
|
||||
# for bent in base_entities:
|
||||
# print(param_entity(lda3, bent + "_0"))
|
||||
|
||||
param_constr = param_And(*lda_disallow)
|
||||
|
||||
smt_rsc = SmtCheckerRSCParam(rc, optimise=cmd_args.optimise)
|
||||
smt_rsc.check_rsltl(
|
||||
formulae_list=[f_attack], param_constr=param_constr
|
||||
) # , max_level=4, cont_if_sat=True)
|
||||
|
||||
log_suffix = ""
|
||||
if cmd_args.optimise:
|
||||
log_suffix = "_OPT"
|
||||
|
||||
time = 0
|
||||
mem_usage = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / (1024 * 1024)
|
||||
filename_t = "bench_mutex_param" + log_suffix + "_time.dat"
|
||||
filename_m = "bench_mutex_param" + log_suffix + "_mem.dat"
|
||||
time = smt_rsc.get_verification_time()
|
||||
|
||||
with open(filename_t, "a") as f:
|
||||
log_str = "{:d} {:f}\n".format(n_proc, time)
|
||||
f.write(log_str)
|
||||
|
||||
with open(filename_m, "a") as f:
|
||||
log_str = "{:d} {:f}\n".format(n_proc, mem_usage)
|
||||
f.write(log_str)
|
||||
|
||||
|
||||
def mutex_nonparam_bench(cmd_args):
|
||||
"""
|
||||
Mutex Benchmark
|
||||
|
||||
Parametric
|
||||
"""
|
||||
|
||||
base_entities = ["out", "req", "in", "act"]
|
||||
shared_entities = ["lock", "done", "s"]
|
||||
|
||||
if not cmd_args.scaling:
|
||||
raise RuntimeError("Missing scaling parameter")
|
||||
n_proc = int(cmd_args.scaling)
|
||||
|
||||
r = ReactionSystemWithConcentrationsParam()
|
||||
|
||||
def E(a, b):
|
||||
return (a + "_" + str(b), 1)
|
||||
|
||||
for i in range(n_proc):
|
||||
for ent in base_entities:
|
||||
r.add_bg_set_entity(E(ent, i))
|
||||
|
||||
for ent in shared_entities:
|
||||
r.add_bg_set_entity((ent, 1))
|
||||
|
||||
###################################################
|
||||
|
||||
Inhib = [("s", 1)]
|
||||
|
||||
for i in range(n_proc):
|
||||
r.add_reaction([E("out", i), E("act", i)], Inhib, [E("req", i)])
|
||||
r.add_reaction([E("out", i)], [E("act", i)], [E("out", i)])
|
||||
|
||||
for j in range(n_proc):
|
||||
if i != j:
|
||||
r.add_reaction(
|
||||
[E("req", i), E("act", i), E("act", j)], Inhib, [E("req", i)]
|
||||
)
|
||||
|
||||
r.add_reaction([E("req", i)], [E("act", i)], [E("req", i)])
|
||||
|
||||
enter_inhib = [E("act", j) for j in range(n_proc) if i != j] + [("lock", 1)]
|
||||
r.add_reaction(
|
||||
[E("req", i), E("act", i)], enter_inhib, [E("in", i), ("lock", 1)]
|
||||
)
|
||||
|
||||
r.add_reaction([E("in", i), E("act", i)], Inhib, [E("out", i), ("done", 1)])
|
||||
r.add_reaction([E("in", i)], [E("act", i)], [E("in", i)])
|
||||
|
||||
r.add_reaction([("lock", 1)], [("done", 1)], [("lock", 1)])
|
||||
|
||||
r.add_reaction(
|
||||
[E("out", n_proc - 1)], [("s", 1)], [("done", 1), E("req", n_proc - 1)]
|
||||
)
|
||||
|
||||
###################################################
|
||||
|
||||
c = ContextAutomatonWithConcentrations(r)
|
||||
c.add_init_state("0")
|
||||
c.add_state("1")
|
||||
|
||||
init_ctx = []
|
||||
for i in range(n_proc):
|
||||
init_ctx.append(E("out", i))
|
||||
|
||||
# the experiments starts with adding x and y:
|
||||
c.add_transition("0", init_ctx, "1")
|
||||
|
||||
all_act = powerset([E("act", i) for i in range(n_proc)], 2)
|
||||
|
||||
for actions in all_act:
|
||||
actions = list(actions)
|
||||
|
||||
c.add_transition("1", actions, "1")
|
||||
|
||||
# for all the remaining steps we have empty context sequences
|
||||
# c.add_transition("1", [], "1")
|
||||
# c.add_transition("1", [("h", 1)], "1")
|
||||
|
||||
###################################################
|
||||
|
||||
rc = ReactionSystemWithAutomaton(r, c)
|
||||
rc.show()
|
||||
|
||||
f_attack = ltl_F(
|
||||
True, bag_And(bag_entity("in_0") == 1, bag_entity("in_" + str(n_proc - 1)) == 1)
|
||||
)
|
||||
|
||||
smt_rsc = SmtCheckerRSCParam(rc, optimise=cmd_args.optimise)
|
||||
smt_rsc.check_rsltl(formulae_list=[f_attack])
|
||||
|
||||
time = 0
|
||||
mem_usage = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / (1024 * 1024)
|
||||
filename_t = "bench_mutex_nonparam_time.dat"
|
||||
filename_m = "bench_mutex_nonparam_mem.dat"
|
||||
time = smt_rsc.get_verification_time()
|
||||
|
||||
with open(filename_t, "a") as f:
|
||||
log_str = "{:d} {:f}\n".format(n_proc, time)
|
||||
f.write(log_str)
|
||||
|
||||
with open(filename_m, "a") as f:
|
||||
log_str = "{:d} {:f}\n".format(n_proc, mem_usage)
|
||||
f.write(log_str)
|
||||
|
||||
|
||||
def mutex_nonparam_bench_oldimpl(cmd_args):
|
||||
"""
|
||||
Mutex Benchmark
|
||||
|
||||
Parametric
|
||||
"""
|
||||
|
||||
base_entities = ["out", "req", "in", "act"]
|
||||
shared_entities = ["lock", "done", "s"]
|
||||
|
||||
if not cmd_args.scaling:
|
||||
raise RuntimeError("Missing scaling parameter")
|
||||
n_proc = int(cmd_args.scaling)
|
||||
|
||||
r = ReactionSystemWithConcentrations()
|
||||
|
||||
def E(a, b):
|
||||
return (a + "_" + str(b), 1)
|
||||
|
||||
for i in range(n_proc):
|
||||
for ent in base_entities:
|
||||
r.add_bg_set_entity(E(ent, i))
|
||||
|
||||
for ent in shared_entities:
|
||||
r.add_bg_set_entity((ent, 1))
|
||||
|
||||
###################################################
|
||||
|
||||
Inhib = [("s", 1)]
|
||||
|
||||
for i in range(n_proc):
|
||||
r.add_reaction([E("out", i), E("act", i)], Inhib, [E("req", i)])
|
||||
r.add_reaction([E("out", i)], [E("act", i)], [E("out", i)])
|
||||
|
||||
for j in range(n_proc):
|
||||
if i != j:
|
||||
r.add_reaction(
|
||||
[E("req", i), E("act", i), E("act", j)], Inhib, [E("req", i)]
|
||||
)
|
||||
|
||||
r.add_reaction([E("req", i)], [E("act", i)], [E("req", i)])
|
||||
|
||||
enter_inhib = [E("act", j) for j in range(n_proc) if i != j] + [("lock", 1)]
|
||||
r.add_reaction(
|
||||
[E("req", i), E("act", i)], enter_inhib, [E("in", i), ("lock", 1)]
|
||||
)
|
||||
|
||||
r.add_reaction([E("in", i), E("act", i)], Inhib, [E("out", i), ("done", 1)])
|
||||
r.add_reaction([E("in", i)], [E("act", i)], [E("in", i)])
|
||||
|
||||
r.add_reaction([("lock", 1)], [("done", 1)], [("lock", 1)])
|
||||
|
||||
r.add_reaction(
|
||||
[E("out", n_proc - 1)], [("s", 1)], [("done", 1), E("req", n_proc - 1)]
|
||||
)
|
||||
|
||||
###################################################
|
||||
|
||||
c = ContextAutomatonWithConcentrations(r)
|
||||
c.add_init_state("0")
|
||||
c.add_state("1")
|
||||
|
||||
init_ctx = []
|
||||
for i in range(n_proc):
|
||||
init_ctx.append(E("out", i))
|
||||
|
||||
# the experiments starts with adding x and y:
|
||||
c.add_transition("0", init_ctx, "1")
|
||||
|
||||
all_act = powerset([E("act", i) for i in range(n_proc)], 2)
|
||||
|
||||
for actions in all_act:
|
||||
actions = list(actions)
|
||||
|
||||
c.add_transition("1", actions, "1")
|
||||
|
||||
# for all the remaining steps we have empty context sequences
|
||||
# c.add_transition("1", [], "1")
|
||||
# c.add_transition("1", [("h", 1)], "1")
|
||||
|
||||
###################################################
|
||||
|
||||
rc = ReactionSystemWithAutomaton(r, c)
|
||||
rc.show()
|
||||
|
||||
f_attack = ltl_F(
|
||||
True, bag_And(bag_entity("in_0") == 1, bag_entity("in_" + str(n_proc - 1)) == 1)
|
||||
)
|
||||
|
||||
smt_rsc = SmtCheckerRSC(rc)
|
||||
smt_rsc.check_rsltl(formula=f_attack)
|
||||
|
||||
time = 0
|
||||
mem_usage = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / (1024 * 1024)
|
||||
filename_t = "bench_mutex_nonparam_oldimpl_time.dat"
|
||||
filename_m = "bench_mutex_nonparam_oldimpl_mem.dat"
|
||||
time = smt_rsc.get_verification_time()
|
||||
|
||||
with open(filename_t, "a") as f:
|
||||
log_str = "{:d} {:f}\n".format(n_proc, time)
|
||||
f.write(log_str)
|
||||
|
||||
with open(filename_m, "a") as f:
|
||||
log_str = "{:d} {:f}\n".format(n_proc, mem_usage)
|
||||
f.write(log_str)
|
||||
|
||||
|
||||
def state_translate_rsc2rs(p):
|
||||
return [e[0] + "#" + str(e[1]) for e in p]
|
||||
|
||||
|
||||
def mutex_bench_main(cmd_args):
|
||||
mode = cmd_args.mode
|
||||
|
||||
if mode == "p":
|
||||
mutex_param_bench(cmd_args)
|
||||
elif mode == "np-p":
|
||||
mutex_nonparam_bench(cmd_args)
|
||||
elif mode == "np-np":
|
||||
mutex_nonparam_bench_oldimpl(cmd_args)
|
||||
else:
|
||||
print("Unrecognised mode")
|
||||
return
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
|
||||
parser.add_argument(
|
||||
"scaling",
|
||||
help="scaling parameter value",
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
"mode",
|
||||
choices=["p", "np-p", "np-np"],
|
||||
help="Selects the mode: p - parameter synthesis (parametric implementation), np-p - non-parametric with parametric implementation (with the parameters substituted), np-np - non-parametric with non-parametric implementation (parameters substituted)",
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
"-v", "--verbose", help="turn verbosity on", action="store_true"
|
||||
)
|
||||
parser.add_argument(
|
||||
"-o",
|
||||
"--optimise",
|
||||
help="minimise the parametric computation result",
|
||||
action="store_true",
|
||||
)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
mutex_bench_main(args)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
# EOF
|
||||
26
experiments/reaction_mining_mutex/run_mutex_param.sh
Executable file
26
experiments/reaction_mining_mutex/run_mutex_param.sh
Executable file
@@ -0,0 +1,26 @@
|
||||
#!/bin/sh
|
||||
|
||||
# sudo systemsetup -getcomputersleep
|
||||
#sudo systemsetup -setcomputersleep Never
|
||||
# sudo systemsetup -setcomputersleep 1
|
||||
|
||||
REACTICS_SMT="../../reactics-smt"
|
||||
export PYTHONPATH="$PYTHONPATH:$REACTICS_SMT"
|
||||
|
||||
REACTICS_SCRIPT="./pmutex.py"
|
||||
|
||||
for i in `seq 2 50`
|
||||
do
|
||||
for special_mode in "p" "np-p" "np-np"
|
||||
do
|
||||
echo "$i (sm=${special_mode})"
|
||||
if [[ $special_mode -eq 1 ]]
|
||||
then
|
||||
$REACTICS_SCRIPT $i $special_mode
|
||||
$REACTICS_SCRIPT -o $i $special_mode
|
||||
else
|
||||
$REACTICS_SCRIPT $i $special_mode
|
||||
fi
|
||||
done
|
||||
done
|
||||
|
||||
2
reactics
2
reactics
@@ -52,7 +52,7 @@ then
|
||||
then
|
||||
python3 $*
|
||||
else
|
||||
echo "Nothing to do"
|
||||
echo "Provide path to an example script (typically from ./examples/smt)"
|
||||
fi
|
||||
|
||||
elif [[ "$mode" == "setup" ]]
|
||||
|
||||
Reference in New Issue
Block a user