|
@@ -1,34 +1,46 @@
|
|
import sys
|
|
import sys
|
|
|
|
+import time
|
|
|
|
+import uuid
|
|
sys.path.append("kernel/")
|
|
sys.path.append("kernel/")
|
|
sys.path.append("state/")
|
|
sys.path.append("state/")
|
|
sys.path.append("interface/HUTN")
|
|
sys.path.append("interface/HUTN")
|
|
from modelverse_state.main import ModelverseState as MvS
|
|
from modelverse_state.main import ModelverseState as MvS
|
|
from modelverse_kernel.main import ModelverseKernel as MvK
|
|
from modelverse_kernel.main import ModelverseKernel as MvK
|
|
|
|
+from modelverse_kernel.primitives import SleepKernel
|
|
|
|
+import modelverse_jit.jit as jit
|
|
from hutn_compiler.compiler import main as do_compile
|
|
from hutn_compiler.compiler import main as do_compile
|
|
-from hutn_compiler.linker import link
|
|
|
|
|
|
|
|
-from pypdevs.DEVS import AtomicDEVS, CoupledDEVS
|
|
|
|
-from pypdevs.simulator import Simulator
|
|
|
|
|
|
+from pypdevs.minimal import AtomicDEVS, CoupledDEVS, Simulator
|
|
|
|
+
|
|
|
|
+PROFILE = False
|
|
|
|
|
|
import json
|
|
import json
|
|
import random
|
|
import random
|
|
|
|
|
|
-random.seed(1)
|
|
|
|
-max_used_id = 0
|
|
|
|
-
|
|
|
|
-def get_object_constructor(code, filename):
|
|
|
|
- with open(".code.alc", "w") as f:
|
|
|
|
- f.write(code)
|
|
|
|
- f.flush()
|
|
|
|
- constructors = do_compile(".code.alc", "interface/HUTN/grammars/actionlanguage.g", "CS")
|
|
|
|
- constructors = [3, "upload", filename, str(random.random()), True] + constructors + [False]
|
|
|
|
- return constructors
|
|
|
|
-
|
|
|
|
-def link_code(main_function, taskname, objects):
|
|
|
|
- return [3, "link_and_load"] + objects + ["", main_function]
|
|
|
|
|
|
+COMPILER_PATH = "interface/HUTN"
|
|
|
|
|
|
-def translate(operation):
|
|
|
|
- return {
|
|
|
|
|
|
+sys.path.append(COMPILER_PATH)
|
|
|
|
+from hutn_compiler.compiler import main as do_compile
|
|
|
|
+import os
|
|
|
|
+
|
|
|
|
+def clean_code(code):
|
|
|
|
+ if code == "":
|
|
|
|
+ return code
|
|
|
|
+
|
|
|
|
+ code_fragments = code.split("\n")
|
|
|
|
+ code_fragments = [i.rstrip() for i in code_fragments if i.strip() != ""]
|
|
|
|
+ code_fragments = [i.replace(" ", "\t") for i in code_fragments]
|
|
|
|
+ initial_tabs = min([len(i) - len(i.lstrip("\t")) for i in code_fragments])
|
|
|
|
+ code_fragments = [i[initial_tabs:] for i in code_fragments]
|
|
|
|
+ code_fragments.append("")
|
|
|
|
+ code = "\n".join(code_fragments)
|
|
|
|
+ return code.encode('ascii', 'replace')
|
|
|
|
+
|
|
|
|
+def compile_model(temp_file):
|
|
|
|
+ compiled = do_compile(temp_file, COMPILER_PATH + "/grammars/modelling.g", "M")
|
|
|
|
+ return ["__LOCAL__"] + compiled
|
|
|
|
+
|
|
|
|
+trans_map = {
|
|
"CN": "create_node",
|
|
"CN": "create_node",
|
|
"CE": "create_edge",
|
|
"CE": "create_edge",
|
|
"CNV": "create_nodevalue",
|
|
"CNV": "create_nodevalue",
|
|
@@ -46,7 +58,11 @@ def translate(operation):
|
|
"RDK": "read_dict_keys",
|
|
"RDK": "read_dict_keys",
|
|
"DE": "delete_edge",
|
|
"DE": "delete_edge",
|
|
"DN": "delete_node",
|
|
"DN": "delete_node",
|
|
- }[operation]
|
|
|
|
|
|
+ "GC": "purge",
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+def translate(operation):
|
|
|
|
+ return trans_map[operation]
|
|
|
|
|
|
class MvSState(object):
|
|
class MvSState(object):
|
|
def __init__(self):
|
|
def __init__(self):
|
|
@@ -73,7 +89,8 @@ class ModelverseState(AtomicDEVS):
|
|
read_dict_node_edge,
|
|
read_dict_node_edge,
|
|
read_reverse_dict,
|
|
read_reverse_dict,
|
|
delete_node,
|
|
delete_node,
|
|
- delete_edge):
|
|
|
|
|
|
+ delete_edge,
|
|
|
|
+ purge):
|
|
AtomicDEVS.__init__(self, "MvS")
|
|
AtomicDEVS.__init__(self, "MvS")
|
|
self.timings = {
|
|
self.timings = {
|
|
"read_root": read_root,
|
|
"read_root": read_root,
|
|
@@ -93,6 +110,7 @@ class ModelverseState(AtomicDEVS):
|
|
"read_reverse_dict": read_reverse_dict,
|
|
"read_reverse_dict": read_reverse_dict,
|
|
"delete_node": delete_node,
|
|
"delete_node": delete_node,
|
|
"delete_edge": delete_edge,
|
|
"delete_edge": delete_edge,
|
|
|
|
+ "purge": purge,
|
|
}
|
|
}
|
|
|
|
|
|
self.state = MvSState()
|
|
self.state = MvSState()
|
|
@@ -110,8 +128,12 @@ class ModelverseState(AtomicDEVS):
|
|
self.state.output = []
|
|
self.state.output = []
|
|
self.state.timer = 0.0
|
|
self.state.timer = 0.0
|
|
for v in self.state.queue[0]:
|
|
for v in self.state.queue[0]:
|
|
- self.state.output.append(getattr(self.state.mvs, translate(v[0]))(*v[1]))
|
|
|
|
- self.state.timer += self.timings[translate(v[0])]()
|
|
|
|
|
|
+ f = getattr(self.state.mvs, translate(v[0]))
|
|
|
|
+ start = time.time()
|
|
|
|
+ self.state.output.append(f(*v[1]))
|
|
|
|
+ if PROFILE:
|
|
|
|
+ print("%s: %.17f" % (translate(v[0]), time.time() - start))
|
|
|
|
+ self.state.timer += self.timings[translate(v[0])]
|
|
else:
|
|
else:
|
|
# Just append the message to process
|
|
# Just append the message to process
|
|
pass
|
|
pass
|
|
@@ -128,8 +150,12 @@ class ModelverseState(AtomicDEVS):
|
|
# Value contains a list of operations to do
|
|
# Value contains a list of operations to do
|
|
# So do them and calculate how long it takes
|
|
# So do them and calculate how long it takes
|
|
for v in self.state.queue[0]:
|
|
for v in self.state.queue[0]:
|
|
- self.state.output.append(getattr(self.state.mvs, translate(v[0]))(*v[1])[0])
|
|
|
|
- self.state.timer += self.timings[translate(v[0])]()
|
|
|
|
|
|
+ f = getattr(self.state.mvs, translate(v[0]))
|
|
|
|
+ start = time.time()
|
|
|
|
+ self.state.output.append(f(*v[1]))
|
|
|
|
+ if PROFILE:
|
|
|
|
+ print("%s: %.17f" % (translate(v[0]), time.time() - start))
|
|
|
|
+ self.state.timer += self.timings[translate(v[0])]
|
|
else:
|
|
else:
|
|
self.state.timer = float("inf")
|
|
self.state.timer = float("inf")
|
|
|
|
|
|
@@ -139,7 +165,7 @@ class ModelverseState(AtomicDEVS):
|
|
return self.state.timer
|
|
return self.state.timer
|
|
|
|
|
|
class MvKState(object):
|
|
class MvKState(object):
|
|
- def __init__(self):
|
|
|
|
|
|
+ def __init__(self, rule_generation):
|
|
self.mvk = None
|
|
self.mvk = None
|
|
self.waiting = False
|
|
self.waiting = False
|
|
self.inputs = {}
|
|
self.inputs = {}
|
|
@@ -152,7 +178,10 @@ class MvKState(object):
|
|
self.current_task = None
|
|
self.current_task = None
|
|
self.loaded_primitives = False
|
|
self.loaded_primitives = False
|
|
self.execution_counter = 0
|
|
self.execution_counter = 0
|
|
- self.all_failed = True
|
|
|
|
|
|
+ self.rule_generation = rule_generation
|
|
|
|
+ self.current_time = 0.0
|
|
|
|
+ self.start_task_time = 0.0
|
|
|
|
+ self.execution_rounds = 0
|
|
|
|
|
|
def __str__(self):
|
|
def __str__(self):
|
|
return "\nMvK: %s\n" % self.mvk + \
|
|
return "\nMvK: %s\n" % self.mvk + \
|
|
@@ -168,18 +197,19 @@ class MvKState(object):
|
|
"execution counter: %s\n"
|
|
"execution counter: %s\n"
|
|
|
|
|
|
class ModelverseKernel(AtomicDEVS):
|
|
class ModelverseKernel(AtomicDEVS):
|
|
- def __init__(self, rules_per_phase):
|
|
|
|
|
|
+ def __init__(self, time_per_phase, rule_generation):
|
|
AtomicDEVS.__init__(self, "MvK")
|
|
AtomicDEVS.__init__(self, "MvK")
|
|
- self.state = MvKState()
|
|
|
|
|
|
+ self.state = MvKState(rule_generation)
|
|
|
|
|
|
self.from_mvi = self.addInPort("from_MvI")
|
|
self.from_mvi = self.addInPort("from_MvI")
|
|
self.from_mvs = self.addInPort("from_MvS")
|
|
self.from_mvs = self.addInPort("from_MvS")
|
|
self.to_mvi = self.addOutPort("to_MvI")
|
|
self.to_mvi = self.addOutPort("to_MvI")
|
|
self.to_mvs = self.addOutPort("to_MvS")
|
|
self.to_mvs = self.addOutPort("to_MvS")
|
|
|
|
|
|
- self.rules_per_phase = rules_per_phase
|
|
|
|
|
|
+ self.time_per_phase = time_per_phase
|
|
|
|
|
|
def extTransition(self, inputs):
|
|
def extTransition(self, inputs):
|
|
|
|
+ self.state.current_time += self.elapsed
|
|
if self.from_mvi in inputs:
|
|
if self.from_mvi in inputs:
|
|
# Got input from MvI, so we queue it
|
|
# Got input from MvI, so we queue it
|
|
for inp in inputs[self.from_mvi]:
|
|
for inp in inputs[self.from_mvi]:
|
|
@@ -193,23 +223,27 @@ class ModelverseKernel(AtomicDEVS):
|
|
if self.from_mvs in inputs:
|
|
if self.from_mvs in inputs:
|
|
# Got input from MvS, so we can continue processing
|
|
# Got input from MvS, so we can continue processing
|
|
for mvs_input in inputs[self.from_mvs]:
|
|
for mvs_input in inputs[self.from_mvs]:
|
|
- mvs_stripped = [i[0] for i in mvs_input]
|
|
|
|
if self.state.mvk is None:
|
|
if self.state.mvk is None:
|
|
# No MvK, so set it with the root we have just received (or should have received)
|
|
# No MvK, so set it with the root we have just received (or should have received)
|
|
- self.state.root = mvs_stripped[0]
|
|
|
|
|
|
+ self.state.root = mvs_input[0]
|
|
self.state.mvk = MvK(self.state.root)
|
|
self.state.mvk = MvK(self.state.root)
|
|
|
|
+ self.state.mvk.jit.set_function_body_compiler(jit.compile_function_body_fast)
|
|
else:
|
|
else:
|
|
- self.state.reply = mvs_stripped
|
|
|
|
|
|
+ self.state.reply = mvs_input
|
|
self.state.waiting = False
|
|
self.state.waiting = False
|
|
|
|
|
|
return self.state
|
|
return self.state
|
|
|
|
|
|
def intTransition(self):
|
|
def intTransition(self):
|
|
|
|
+ self.state.current_time += self.timeAdvance()
|
|
was_empty = len(self.state.tasks) == 0
|
|
was_empty = len(self.state.tasks) == 0
|
|
if self.state.commands is not None:
|
|
if self.state.commands is not None:
|
|
self.state.commands = None
|
|
self.state.commands = None
|
|
return self.state
|
|
return self.state
|
|
|
|
|
|
|
|
+ if self.state.mvk is not None:
|
|
|
|
+ self.state.mvk.returnvalue = None
|
|
|
|
+
|
|
if self.state.mvk is None:
|
|
if self.state.mvk is None:
|
|
# Initializing
|
|
# Initializing
|
|
self.state.waiting = True
|
|
self.state.waiting = True
|
|
@@ -226,7 +260,11 @@ class ModelverseKernel(AtomicDEVS):
|
|
if len(self.state.tasks) == 0:
|
|
if len(self.state.tasks) == 0:
|
|
# Read out new set of tasks first
|
|
# Read out new set of tasks first
|
|
if self.state.reply is None:
|
|
if self.state.reply is None:
|
|
|
|
+ self.state.execution_rounds += 1
|
|
commands = [("RDK", [self.state.root])]
|
|
commands = [("RDK", [self.state.root])]
|
|
|
|
+ if self.state.execution_rounds > 1000:
|
|
|
|
+ commands.append(("GC", []))
|
|
|
|
+ self.state.execution_rounds = 0
|
|
else:
|
|
else:
|
|
self.state.tasks = self.state.reply[0]
|
|
self.state.tasks = self.state.reply[0]
|
|
commands = None
|
|
commands = None
|
|
@@ -235,6 +273,7 @@ class ModelverseKernel(AtomicDEVS):
|
|
commands = [("RV", [self.state.tasks[0]])]
|
|
commands = [("RV", [self.state.tasks[0]])]
|
|
else:
|
|
else:
|
|
self.state.current_task = self.state.reply[0]
|
|
self.state.current_task = self.state.reply[0]
|
|
|
|
+ self.state.start_task_time = self.state.current_time
|
|
if self.state.current_task.startswith("__"):
|
|
if self.state.current_task.startswith("__"):
|
|
# Don't process this task and force termination of task
|
|
# Don't process this task and force termination of task
|
|
self.state.phase = "output"
|
|
self.state.phase = "output"
|
|
@@ -242,17 +281,41 @@ class ModelverseKernel(AtomicDEVS):
|
|
elif self.state.phase == "input":
|
|
elif self.state.phase == "input":
|
|
# Process inputs
|
|
# Process inputs
|
|
if self.state.inputs.get(self.state.current_task, None):
|
|
if self.state.inputs.get(self.state.current_task, None):
|
|
- element_type, value = self.state.inputs[self.state.current_task][0]
|
|
|
|
- commands = self.state.mvk.execute_yields(self.state.current_task, "set_input", [element_type, value], self.state.reply)
|
|
|
|
|
|
+ value = self.state.inputs[self.state.current_task][0]
|
|
|
|
+ start = time.time()
|
|
|
|
+ commands = self.state.mvk.execute_yields(self.state.current_task, "set_input", [value], self.state.reply)
|
|
|
|
+ #print("EXECUTEYIELDSI %s %.17f" % (self.state.current_task, time.time() - start))
|
|
|
|
+ #print(commands)
|
|
|
|
+ if PROFILE:
|
|
|
|
+ print("rule_generation: %.17f" % ((time.time() - start)))
|
|
|
|
+ #self.state.rule_generation = time.time() - start
|
|
|
|
+ self.state.mvk.returnvalue = None
|
|
if commands is None:
|
|
if commands is None:
|
|
self.state.inputs[self.state.current_task].pop(0)
|
|
self.state.inputs[self.state.current_task].pop(0)
|
|
else:
|
|
else:
|
|
commands = None
|
|
commands = None
|
|
|
|
|
|
elif self.state.phase == "computation":
|
|
elif self.state.phase == "computation":
|
|
- commands = self.state.mvk.execute_yields(self.state.current_task, "execute_rule", [], self.state.reply)
|
|
|
|
|
|
+ try:
|
|
|
|
+ start = time.time()
|
|
|
|
+ commands = self.state.mvk.execute_yields(self.state.current_task, "execute_rule", [], self.state.reply)
|
|
|
|
+ #print("EXECUTEYIELDS %s %.17f" % (self.state.current_task, time.time() - start))
|
|
|
|
+ #print(commands)
|
|
|
|
+ if PROFILE:
|
|
|
|
+ print("rule_generation: %.17f" % ((time.time() - start)))
|
|
|
|
+ except SleepKernel:
|
|
|
|
+ commands = None
|
|
|
|
+ self.state.mvk.success = False
|
|
|
|
+ else:
|
|
|
|
+ self.state.mvk.success = True
|
|
elif self.state.phase == "output":
|
|
elif self.state.phase == "output":
|
|
|
|
+ start = time.time()
|
|
commands = self.state.mvk.execute_yields(self.state.current_task, "get_output", [], self.state.reply)
|
|
commands = self.state.mvk.execute_yields(self.state.current_task, "get_output", [], self.state.reply)
|
|
|
|
+ #print("EXECUTEYIELDSO %s %.17f" % (self.state.current_task, time.time() - start))
|
|
|
|
+ #print(commands)
|
|
|
|
+ if PROFILE:
|
|
|
|
+ print("rule_generation: %.17f" % ((time.time() - start)))
|
|
|
|
+ #self.state.rule_generation = time.time() - start
|
|
else:
|
|
else:
|
|
raise Exception("Phase: " + str(self.state.phase))
|
|
raise Exception("Phase: " + str(self.state.phase))
|
|
|
|
|
|
@@ -265,11 +328,8 @@ class ModelverseKernel(AtomicDEVS):
|
|
elif self.state.phase == "input":
|
|
elif self.state.phase == "input":
|
|
self.state.phase = "computation"
|
|
self.state.phase = "computation"
|
|
elif self.state.phase == "computation":
|
|
elif self.state.phase == "computation":
|
|
- if not self.state.mvk.success or (self.state.execution_counter > self.rules_per_phase):
|
|
|
|
|
|
+ if (not self.state.mvk.success) or (self.state.current_time - self.state.start_task_time > self.time_per_phase):
|
|
self.state.phase = "output"
|
|
self.state.phase = "output"
|
|
- self.state.execution_counter = 0
|
|
|
|
- else:
|
|
|
|
- self.state.execution_counter += 1
|
|
|
|
elif self.state.phase == "output":
|
|
elif self.state.phase == "output":
|
|
self.state.tasks.pop(0)
|
|
self.state.tasks.pop(0)
|
|
self.state.phase = "init_task"
|
|
self.state.phase = "init_task"
|
|
@@ -283,20 +343,21 @@ class ModelverseKernel(AtomicDEVS):
|
|
return self.state
|
|
return self.state
|
|
|
|
|
|
def outputFnc(self):
|
|
def outputFnc(self):
|
|
|
|
+ outputs = {}
|
|
if self.state.mvk is None:
|
|
if self.state.mvk is None:
|
|
# Ask the root first
|
|
# Ask the root first
|
|
- return {self.to_mvs: [[("RR", [])]]}
|
|
|
|
|
|
+ outputs[self.to_mvs] = [[("RR", [])]]
|
|
elif self.state.waiting:
|
|
elif self.state.waiting:
|
|
- return {self.to_mvs: [self.state.commands]}
|
|
|
|
|
|
+ outputs[self.to_mvs] = [self.state.commands]
|
|
|
|
+
|
|
|
|
+ if self.state.mvk and self.state.mvk.returnvalue is not None:
|
|
|
|
+ outputs[self.to_mvi] = [(self.state.current_task, self.state.mvk.returnvalue)]
|
|
|
|
|
|
- return {}
|
|
|
|
|
|
+ return outputs
|
|
|
|
|
|
def timeAdvance(self):
|
|
def timeAdvance(self):
|
|
- if self.state.phase == "init_task" and self.state.all_failed:
|
|
|
|
- # Make this a parameter
|
|
|
|
- return 200
|
|
|
|
if self.state.commands is not None:
|
|
if self.state.commands is not None:
|
|
- return 0
|
|
|
|
|
|
+ return self.state.rule_generation
|
|
elif self.state.waiting:
|
|
elif self.state.waiting:
|
|
return float("inf")
|
|
return float("inf")
|
|
elif self.state.mvk is None:
|
|
elif self.state.mvk is None:
|
|
@@ -307,48 +368,134 @@ class ModelverseKernel(AtomicDEVS):
|
|
class MvIState():
|
|
class MvIState():
|
|
def __init__(self):
|
|
def __init__(self):
|
|
self.operations = []
|
|
self.operations = []
|
|
- self.output = []
|
|
|
|
- self.processing = []
|
|
|
|
- self.memory = {}
|
|
|
|
- self.init = True
|
|
|
|
|
|
+ self.additional_operations = []
|
|
|
|
+ self.keyed_operations = {}
|
|
|
|
+ self.task_to_spawner = {}
|
|
|
|
+ self.task_to_operation = {}
|
|
|
|
+ self.output = {}
|
|
|
|
+ self.blocked = True
|
|
|
|
+ self.finished = False
|
|
|
|
+ self.send_operations = {}
|
|
|
|
|
|
class ModelverseInterface(AtomicDEVS):
|
|
class ModelverseInterface(AtomicDEVS):
|
|
- def __init__(self, taskname, operations):
|
|
|
|
|
|
+ def __init__(self, taskname, operations, finish_on, additional_operations=[], keyed_operations={}):
|
|
AtomicDEVS.__init__(self, "MvI_%s" % taskname)
|
|
AtomicDEVS.__init__(self, "MvI_%s" % taskname)
|
|
self.state = MvIState()
|
|
self.state = MvIState()
|
|
|
|
+ if taskname == "task_manager":
|
|
|
|
+ self.state.blocked = False
|
|
self.state.operations = operations
|
|
self.state.operations = operations
|
|
|
|
+ self.state.additional_operations = additional_operations
|
|
|
|
+ self.state.keyed_operations = keyed_operations
|
|
|
|
+ self.state.create_additional_task = []
|
|
self.taskname = taskname
|
|
self.taskname = taskname
|
|
|
|
+ self.finish_on = finish_on
|
|
|
|
|
|
self.to_mvk = self.addOutPort("to_MvK")
|
|
self.to_mvk = self.addOutPort("to_MvK")
|
|
self.from_mvk = self.addInPort("from_MvK")
|
|
self.from_mvk = self.addInPort("from_MvK")
|
|
|
|
|
|
def intTransition(self):
|
|
def intTransition(self):
|
|
- self.state.init = False
|
|
|
|
- while self.state.operations:
|
|
|
|
- i = self.state.operations[0]
|
|
|
|
- if isinstance(i, int) and i not in self.state.memory:
|
|
|
|
- break
|
|
|
|
- self.state.operations.pop(0)
|
|
|
|
|
|
+ self.state.create_additional_task = []
|
|
|
|
+ if not self.state.send_operations:
|
|
|
|
+ if self.state.operations[0] is not None:
|
|
|
|
+ self.state.operations.pop(0)
|
|
|
|
+ else:
|
|
|
|
+ for k in self.state.send_operations.keys():
|
|
|
|
+ if self.state.send_operations[k]:
|
|
|
|
+ self.state.send_operations[k][0] = None
|
|
|
|
+
|
|
|
|
+ self.state.blocked = True
|
|
return self.state
|
|
return self.state
|
|
|
|
|
|
def extTransition(self, inputs):
|
|
def extTransition(self, inputs):
|
|
for inp in inputs[self.from_mvk]:
|
|
for inp in inputs[self.from_mvk]:
|
|
- if inp["value"] == "None" and isinstance(self.state.processing[0], int) and self.state.processing[0] not in self.state.memory:
|
|
|
|
- self.state.memory[self.state.processing.pop(0)] = int(inp["id"])
|
|
|
|
- else:
|
|
|
|
- self.state.output.append(inp)
|
|
|
|
|
|
+ print(inp)
|
|
|
|
+ self.state.blocked = False
|
|
|
|
+
|
|
|
|
+ self.state.output.setdefault(inp[0], []).append(inp[1])
|
|
|
|
+ if inp[0] == self.taskname and inp[1] == self.finish_on:
|
|
|
|
+ self.state.finished = True
|
|
|
|
+ elif inp[0] == self.taskname and self.state.operations[0] is None:
|
|
|
|
+ # We have to block for now, and modify a model first...
|
|
|
|
+ prev_output = self.state.output[inp[0]][-1]
|
|
|
|
+ if prev_output.startswith("Please edit this model before sending next input: "):
|
|
|
|
+ _, model_name = prev_output.split("Please edit this model before sending next input: ", 1)
|
|
|
|
+ new_taskname = str(uuid.uuid4())
|
|
|
|
+ self.state.send_operations[new_taskname] = [[], ["admin"], ["admin"], ["quiet"], ["model_modify", model_name, ""]] + self.state.additional_operations[0] + [["exit"], ["exit"]]
|
|
|
|
+ self.state.create_additional_task.append(new_taskname)
|
|
|
|
+ self.state.task_to_operation[new_taskname] = None
|
|
|
|
+ self.state.task_to_spawner[new_taskname] = None
|
|
|
|
+ elif prev_output.startswith("Spawned activity on task: "):
|
|
|
|
+ _, task_name = prev_output.split("Spawned activity on task: ", 1)
|
|
|
|
+ self.state.blocked = True
|
|
|
|
+ self.state.task_to_spawner[task_name] = None
|
|
|
|
+ elif prev_output.startswith("Finished task: "):
|
|
|
|
+ self.state.blocked = True
|
|
|
|
+ elif " : " in prev_output:
|
|
|
|
+ task_name, _ = prev_output.split(" : ", 1)
|
|
|
|
+ self.state.blocked = True
|
|
|
|
+ self.state.task_to_spawner[task_name] = None
|
|
|
|
+ self.state.operations.insert(0, None)
|
|
|
|
+ elif prev_output == "Success":
|
|
|
|
+ self.state.operations = [["echo", "FINISHED"]]
|
|
|
|
+ self.state.blocked = False
|
|
|
|
+
|
|
|
|
+ elif inp[0] != self.taskname:
|
|
|
|
+ # Got some output on another task
|
|
|
|
+ # If the task is not registered yet, it is likely not important to communicate with it, so ignore it
|
|
|
|
+ #print("Send operations: " + str(self.state.send_operations))
|
|
|
|
+ if inp[0] in self.state.send_operations:
|
|
|
|
+ self.state.send_operations[inp[0]].pop(0)
|
|
|
|
+
|
|
|
|
+ if inp[1].startswith("Please edit this model before sending next input: "):
|
|
|
|
+ _, model_name = inp[1].split("Please edit this model before sending next input: ", 1)
|
|
|
|
+ new_taskname = str(uuid.uuid4())
|
|
|
|
+ self.state.send_operations[new_taskname] = [[], ["admin"], ["admin"], ["quiet"], ["model_modify", model_name, ""]] + self.state.keyed_operations.get(self.state.task_to_operation[inp[0]], []) + [["exit"], ["exit"]]
|
|
|
|
+ #print("DO EXIT2")
|
|
|
|
+ self.state.create_additional_task.append(new_taskname)
|
|
|
|
+ self.state.task_to_spawner[new_taskname] = inp[0]
|
|
|
|
+ elif inp[1].startswith("Please perform manual operation "):
|
|
|
|
+ _, op_name = inp[1].split("Please perform manual operation ", 1)
|
|
|
|
+ self.state.task_to_operation[inp[0]] = op_name[1:-1]
|
|
|
|
+
|
|
|
|
+ if inp[0] in self.state.send_operations and len(self.state.send_operations[inp[0]]) == 0:
|
|
|
|
+ del self.state.send_operations[inp[0]]
|
|
|
|
+
|
|
|
|
+ # At the end of these operations, so finish up!
|
|
|
|
+ if inp[0] in self.state.task_to_spawner:
|
|
|
|
+ if self.state.task_to_spawner[inp[0]] is not None:
|
|
|
|
+ self.state.keyed_operations.pop(self.state.task_to_operation[self.state.task_to_spawner[inp[0]]], None)
|
|
|
|
+ self.state.additional_operations.insert(0, [])
|
|
|
|
+ self.state.send_operations[self.state.task_to_spawner[inp[0]]] = ["__continue__"]
|
|
|
|
+ else:
|
|
|
|
+ self.state.additional_operations.pop(0)
|
|
|
|
+ self.state.operations.pop(0)
|
|
|
|
+
|
|
return self.state
|
|
return self.state
|
|
|
|
|
|
def outputFnc(self):
|
|
def outputFnc(self):
|
|
- return {self.to_mvk: [(self.taskname, self.state.operations)]}
|
|
|
|
|
|
+ if self.state.send_operations:
|
|
|
|
+ outp = []
|
|
|
|
+ if self.state.create_additional_task:
|
|
|
|
+ outp.append(('task_manager', self.state.create_additional_task))
|
|
|
|
+ for k, v in self.state.send_operations.items():
|
|
|
|
+ if v and v[0] is not None:
|
|
|
|
+ outp.append((k, v[0]))
|
|
|
|
+ if outp:
|
|
|
|
+ print("SEND " + str(outp))
|
|
|
|
+ return {self.to_mvk: outp}
|
|
|
|
+ else:
|
|
|
|
+ return {}
|
|
|
|
+ elif self.state.operations and self.state.operations[0] is not None:
|
|
|
|
+ print("SEND " + str([(self.taskname, self.state.operations[0])]))
|
|
|
|
+ return {self.to_mvk: [(self.taskname, self.state.operations[0])]}
|
|
|
|
+ else:
|
|
|
|
+ return {}
|
|
|
|
|
|
def timeAdvance(self):
|
|
def timeAdvance(self):
|
|
- if self.state.init:
|
|
|
|
- return 0
|
|
|
|
- elif self.state.processing and (not isinstance(self.state.processing[0], int) or self.state.processing[0] in self.state.memory):
|
|
|
|
- return 0
|
|
|
|
- else:
|
|
|
|
|
|
+ if self.state.blocked:
|
|
return float("inf")
|
|
return float("inf")
|
|
|
|
+ else:
|
|
|
|
+ return 0.0
|
|
|
|
|
|
class NetworkState(object):
|
|
class NetworkState(object):
|
|
def __init__(self):
|
|
def __init__(self):
|
|
@@ -369,7 +516,7 @@ class Network(AtomicDEVS):
|
|
def intTransition(self):
|
|
def intTransition(self):
|
|
self.state.processing.pop(0)
|
|
self.state.processing.pop(0)
|
|
if self.state.processing:
|
|
if self.state.processing:
|
|
- self.state.timer = int(len(self.state.processing[0]) / float(self.bandwidth) + self.latency)
|
|
|
|
|
|
+ self.state.timer = (len(json.dumps(self.state.processing[0])) * 8 / float(self.bandwidth) + self.latency)
|
|
else:
|
|
else:
|
|
self.state.timer = float("inf")
|
|
self.state.timer = float("inf")
|
|
return self.state
|
|
return self.state
|
|
@@ -379,13 +526,14 @@ class Network(AtomicDEVS):
|
|
if self.state.timer == float("inf"):
|
|
if self.state.timer == float("inf"):
|
|
self.state.timer = 0
|
|
self.state.timer = 0
|
|
for v in inputs[self.input_port]:
|
|
for v in inputs[self.input_port]:
|
|
- self.state.processing.append(json.dumps(v))
|
|
|
|
|
|
+ self.state.processing.append(v)
|
|
|
|
+ # NOTE data is in bytes, while bandwidth is in bits, so multiply by 8
|
|
if len(self.state.processing) > 0:
|
|
if len(self.state.processing) > 0:
|
|
- self.state.timer = int(len(self.state.processing[0]) / float(self.bandwidth) + self.latency)
|
|
|
|
|
|
+ self.state.timer = (len(json.dumps(self.state.processing[0])) * 8 / float(self.bandwidth) + self.latency)
|
|
return self.state
|
|
return self.state
|
|
|
|
|
|
def outputFnc(self):
|
|
def outputFnc(self):
|
|
- return {self.output_port: [json.loads(self.state.processing[0])]}
|
|
|
|
|
|
+ return {self.output_port: [self.state.processing[0]]}
|
|
|
|
|
|
def timeAdvance(self):
|
|
def timeAdvance(self):
|
|
return self.state.timer
|
|
return self.state.timer
|
|
@@ -394,7 +542,11 @@ class System(CoupledDEVS):
|
|
def __init__(self,
|
|
def __init__(self,
|
|
taskname,
|
|
taskname,
|
|
operations,
|
|
operations,
|
|
- rules_per_phase,
|
|
|
|
|
|
+ mvi_additional,
|
|
|
|
+ mvi_keyed,
|
|
|
|
+ finish_on,
|
|
|
|
+ rule_generation,
|
|
|
|
+ time_per_phase,
|
|
mvi2mvk_latency,
|
|
mvi2mvk_latency,
|
|
mvi2mvk_bandwidth,
|
|
mvi2mvk_bandwidth,
|
|
mvk2mvs_latency,
|
|
mvk2mvs_latency,
|
|
@@ -419,19 +571,25 @@ class System(CoupledDEVS):
|
|
read_dict_node_edge,
|
|
read_dict_node_edge,
|
|
read_reverse_dict,
|
|
read_reverse_dict,
|
|
delete_node,
|
|
delete_node,
|
|
- delete_edge):
|
|
|
|
|
|
+ delete_edge,
|
|
|
|
+ purge):
|
|
CoupledDEVS.__init__(self, "System")
|
|
CoupledDEVS.__init__(self, "System")
|
|
|
|
|
|
self.mvi_manager = self.addSubModel(ModelverseInterface(\
|
|
self.mvi_manager = self.addSubModel(ModelverseInterface(\
|
|
taskname = "task_manager",
|
|
taskname = "task_manager",
|
|
- operations = [taskname],
|
|
|
|
|
|
+ operations = [[taskname]],
|
|
|
|
+ finish_on = None,
|
|
))
|
|
))
|
|
self.mvi = self.addSubModel(ModelverseInterface(\
|
|
self.mvi = self.addSubModel(ModelverseInterface(\
|
|
taskname = taskname,
|
|
taskname = taskname,
|
|
- operations = operations
|
|
|
|
|
|
+ operations = operations,
|
|
|
|
+ finish_on = finish_on,
|
|
|
|
+ additional_operations = mvi_additional,
|
|
|
|
+ keyed_operations = mvi_keyed,
|
|
))
|
|
))
|
|
self.mvk = self.addSubModel(ModelverseKernel(\
|
|
self.mvk = self.addSubModel(ModelverseKernel(\
|
|
- rules_per_phase = rules_per_phase
|
|
|
|
|
|
+ time_per_phase = time_per_phase,
|
|
|
|
+ rule_generation = rule_generation,
|
|
))
|
|
))
|
|
self.mvs = self.addSubModel(ModelverseState(\
|
|
self.mvs = self.addSubModel(ModelverseState(\
|
|
read_root = read_root,
|
|
read_root = read_root,
|
|
@@ -450,27 +608,28 @@ class System(CoupledDEVS):
|
|
read_dict_node_edge = read_dict_node_edge,
|
|
read_dict_node_edge = read_dict_node_edge,
|
|
read_reverse_dict = read_reverse_dict,
|
|
read_reverse_dict = read_reverse_dict,
|
|
delete_node = delete_node,
|
|
delete_node = delete_node,
|
|
- delete_edge = delete_edge
|
|
|
|
|
|
+ delete_edge = delete_edge,
|
|
|
|
+ purge = purge,
|
|
))
|
|
))
|
|
self.mvi2mvk = self.addSubModel(Network(\
|
|
self.mvi2mvk = self.addSubModel(Network(\
|
|
name = "mvi2mvk",
|
|
name = "mvi2mvk",
|
|
latency = mvi2mvk_latency,
|
|
latency = mvi2mvk_latency,
|
|
- bandwidth = mvi2mvk_bandwidth
|
|
|
|
|
|
+ bandwidth = mvi2mvk_bandwidth,
|
|
))
|
|
))
|
|
self.mvk2mvs = self.addSubModel(Network(\
|
|
self.mvk2mvs = self.addSubModel(Network(\
|
|
name = "mvk2mvs",
|
|
name = "mvk2mvs",
|
|
latency = mvk2mvs_latency,
|
|
latency = mvk2mvs_latency,
|
|
- bandwidth = mvk2mvs_bandwidth
|
|
|
|
|
|
+ bandwidth = mvk2mvs_bandwidth,
|
|
))
|
|
))
|
|
self.mvs2mvk = self.addSubModel(Network(\
|
|
self.mvs2mvk = self.addSubModel(Network(\
|
|
name = "mvs2mvk",
|
|
name = "mvs2mvk",
|
|
latency = mvs2mvk_latency,
|
|
latency = mvs2mvk_latency,
|
|
- bandwidth = mvs2mvk_bandwidth
|
|
|
|
|
|
+ bandwidth = mvs2mvk_bandwidth,
|
|
))
|
|
))
|
|
self.mvk2mvi = self.addSubModel(Network(\
|
|
self.mvk2mvi = self.addSubModel(Network(\
|
|
name = "mvk2mvi",
|
|
name = "mvk2mvi",
|
|
latency = mvk2mvi_latency,
|
|
latency = mvk2mvi_latency,
|
|
- bandwidth = mvk2mvi_bandwidth
|
|
|
|
|
|
+ bandwidth = mvk2mvi_bandwidth,
|
|
))
|
|
))
|
|
|
|
|
|
self.connectPorts(self.mvi_manager.to_mvk, self.mvk.from_mvi)
|
|
self.connectPorts(self.mvi_manager.to_mvk, self.mvk.from_mvi)
|
|
@@ -483,57 +642,101 @@ class System(CoupledDEVS):
|
|
self.connectPorts(self.mvk.to_mvi, self.mvk2mvi.input_port)
|
|
self.connectPorts(self.mvk.to_mvi, self.mvk2mvi.input_port)
|
|
self.connectPorts(self.mvk2mvi.output_port, self.mvi.from_mvk)
|
|
self.connectPorts(self.mvk2mvi.output_port, self.mvi.from_mvk)
|
|
|
|
|
|
-files = ["bootstrap/primitives.alc"]
|
|
|
|
-code = \
|
|
|
|
- """
|
|
|
|
-include "primitives.alh"
|
|
|
|
-
|
|
|
|
-Void function main():
|
|
|
|
-\tlog("Executed the code!")
|
|
|
|
-\treturn !
|
|
|
|
- """
|
|
|
|
-taskname = "test_task"
|
|
|
|
-
|
|
|
|
-operations = [get_object_constructor(open(f, 'r').read(), str(f)) for f in files] + \
|
|
|
|
- get_object_constructor(code, "main") + \
|
|
|
|
- link_code("main", taskname, files + ["code.alc"])
|
|
|
|
-
|
|
|
|
-print("Generated operations:")
|
|
|
|
-print(operations)
|
|
|
|
-
|
|
|
|
-args = {
|
|
|
|
- "taskname": taskname,
|
|
|
|
- "operations": operations,
|
|
|
|
- "mvi2mvk_latency": 1,
|
|
|
|
- "mvi2mvk_bandwidth": 2000,
|
|
|
|
- "mvk2mvs_latency": 1,
|
|
|
|
- "mvk2mvs_bandwidth": 2000,
|
|
|
|
- "mvs2mvk_latency": 1,
|
|
|
|
- "mvs2mvk_bandwidth": 2000,
|
|
|
|
- "mvk2mvi_latency": 1,
|
|
|
|
- "mvk2mvi_bandwidth": 2000,
|
|
|
|
- "read_root": lambda: 1,
|
|
|
|
- "create_node": lambda: 1,
|
|
|
|
- "create_edge": lambda: 1,
|
|
|
|
- "create_nodevalue": lambda: 1,
|
|
|
|
- "create_dict": lambda: 1,
|
|
|
|
- "read_value": lambda: 1,
|
|
|
|
- "read_outgoing": lambda: 1,
|
|
|
|
- "read_incoming": lambda: 1,
|
|
|
|
- "read_edge": lambda: 1,
|
|
|
|
- "read_dict": lambda: 1,
|
|
|
|
- "read_dict_keys": lambda: 1,
|
|
|
|
- "read_dict_node": lambda: 1,
|
|
|
|
- "read_dict_edge": lambda: 1,
|
|
|
|
- "read_dict_node_edge": lambda: 1,
|
|
|
|
- "read_reverse_dict": lambda: 1,
|
|
|
|
- "delete_node": lambda: 1,
|
|
|
|
- "delete_edge": lambda: 1,
|
|
|
|
- "rules_per_phase": 200,
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
-model = System(**args)
|
|
|
|
-sim = Simulator(model)
|
|
|
|
-sim.setTerminationTime(900000)
|
|
|
|
-#sim.setVerbose()
|
|
|
|
-sim.simulate()
|
|
|
|
|
|
+def simulate(supplied_args):
|
|
|
|
+ random.seed(1)
|
|
|
|
+ taskname = "test_task"
|
|
|
|
+
|
|
|
|
+ operations = json.loads(open("model/operations", 'r').read())
|
|
|
|
+ #operations = json.loads(open("model/operations_simple", 'r').read())
|
|
|
|
+ additional_operations = [[], # revise_req
|
|
|
|
+ [], # revise_environment
|
|
|
|
+ [], # revise_plant
|
|
|
|
+ [], # revise_control
|
|
|
|
+ [], # revise_query
|
|
|
|
+ [], # revise_architecture
|
|
|
|
+ [], # make_initial_models
|
|
|
|
+ [["instantiate_edge", "Association", "PLANT2EPN_link", "PW_Plant/State", "Encapsulated_PetriNet/Place"], ["instantiate_edge", "Association", "PLANT2EPN_tlink", "PW_Plant/Transition", "Encapsulated_PetriNet/Transition"]], # plant_to_EPN
|
|
|
|
+ [["instantiate_edge", "Association", "CTRL2EPN_link", "PW_Control/State", "Encapsulated_PetriNet/Place"], ["instantiate_edge", "Association", "CTRL2EPN_tlink", "PW_Control/Transition", "Encapsulated_PetriNet/Transition"]], # control_to_EPN
|
|
|
|
+ [["instantiate_edge", "Association", "ENV2EPN_link", "PW_Environment/Event", "Encapsulated_PetriNet/Place"]], # environment_to_EPN
|
|
|
|
+ [["instantiate_edge", "Association", "EPN2PN_place_link", "Encapsulated_PetriNet/Place", "PetriNet/Place"], ["instantiate_edge", "Association", "EPN2PN_transition_link", "Encapsulated_PetriNet/Transition", "PetriNet/Transition"]], # EPN_to_PN
|
|
|
|
+ [], # match
|
|
|
|
+ [], # reachability
|
|
|
|
+ [], # bfs
|
|
|
|
+ [], # merge
|
|
|
|
+ ]
|
|
|
|
+
|
|
|
|
+ #additional_operations = [[]]
|
|
|
|
+ keyed_operations = {"models/revise_req": [["upload"], compile_model("models/requirements_model.mvc")],
|
|
|
|
+ "models/revise_plant": [["upload"], compile_model("models/plant_model.mvc")],
|
|
|
|
+ "models/revise_environment": [["upload"], compile_model("models/environment_model.mvc")],
|
|
|
|
+ "models/revise_control": [["upload"], compile_model("models/control_model.mvc")],
|
|
|
|
+ "models/revise_query": [["upload"], compile_model("models/query_model.mvc")],
|
|
|
|
+ "models/revise_architecture": [["upload"], compile_model("models/architecture_model.mvc")],
|
|
|
|
+ }
|
|
|
|
+ #keyed_operations = {"models/modify_lang": [["instantiate_node", "PN/Class", ""]]}
|
|
|
|
+ finish_on = "FINISHED"
|
|
|
|
+
|
|
|
|
+ args = {
|
|
|
|
+ "taskname": taskname,
|
|
|
|
+ "operations": operations,
|
|
|
|
+ "finish_on": finish_on,
|
|
|
|
+ "mvi_additional": additional_operations,
|
|
|
|
+ "mvi_keyed": keyed_operations,
|
|
|
|
+ "mvi2mvk_latency": 0.0000001,
|
|
|
|
+ "mvi2mvk_bandwidth": 50000000000,
|
|
|
|
+ "mvk2mvs_latency": 0.0000001,
|
|
|
|
+ "mvk2mvs_bandwidth": 50000000000,
|
|
|
|
+ "mvs2mvk_latency": 0.0000001,
|
|
|
|
+ "mvs2mvk_bandwidth": 50000000000,
|
|
|
|
+ "mvk2mvi_latency": 0.0000001,
|
|
|
|
+ "mvk2mvi_bandwidth": 50000000000,
|
|
|
|
+ "time_per_phase": 0.05,
|
|
|
|
+ # Automatically filled in from calibration results, just here to prevent crashes (results for my UA desktop)
|
|
|
|
+ "read_root": 0.00001406669616699,
|
|
|
|
+ "create_node": 0.00000379181167487,
|
|
|
|
+ "create_edge": 0.00000601282282066,
|
|
|
|
+ "create_nodevalue": 0.00000501364247391,
|
|
|
|
+ "create_dict": 0.00001028065706205,
|
|
|
|
+ "read_value": 0.00000388661630500,
|
|
|
|
+ "read_outgoing": 0.00000520600098073,
|
|
|
|
+ "read_incoming": 0.00000645903181994,
|
|
|
|
+ "read_edge": 0.00000449162172644,
|
|
|
|
+ "read_dict": 0.00000460127038355,
|
|
|
|
+ "read_dict_keys": 0.00001678063432883,
|
|
|
|
+ "read_dict_node": 0.00001020808859528,
|
|
|
|
+ "read_dict_edge": 0.00000642558526942,
|
|
|
|
+ "read_dict_node_edge": 0.0,
|
|
|
|
+ "read_reverse_dict": 0.00002557890755790,
|
|
|
|
+ "delete_node": 0.00004755891187096,
|
|
|
|
+ "delete_edge": 0.00000683382081240,
|
|
|
|
+ "rule_generation": 0.00001543215873893,
|
|
|
|
+ "purge": 7.0,
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ with open("calibration/averages", 'r') as param_file:
|
|
|
|
+ for l in param_file:
|
|
|
|
+ op, t = l.split(": ")
|
|
|
|
+ op = op.strip()
|
|
|
|
+ args[op] = float(t)
|
|
|
|
+
|
|
|
|
+ local_args = dict(args)
|
|
|
|
+ local_args.update(supplied_args)
|
|
|
|
+ model = System(**local_args)
|
|
|
|
+ sim = Simulator(model)
|
|
|
|
+ sim.setTerminationCondition(lambda t, m: m.mvi.state.finished)
|
|
|
|
+ #sim.setVerbose()
|
|
|
|
+ start = time.time()
|
|
|
|
+ tn = sim.simulate()
|
|
|
|
+ return (tn, time.time() - start)
|
|
|
|
+
|
|
|
|
+if __name__ == "__main__":
|
|
|
|
+ import sys
|
|
|
|
+ args = {}
|
|
|
|
+ i = 1
|
|
|
|
+ while i < len(sys.argv):
|
|
|
|
+ args[sys.argv[i]] = float(sys.argv[i+1])
|
|
|
|
+ i += 2
|
|
|
|
+ ts, te = simulate(args)
|
|
|
|
+
|
|
|
|
+ print("Execution time %s" % ts)
|
|
|
|
+ print("Simulation time %s" % te)
|