Update model to use external calibration results

calibration/averages

@@ -0,0 +1,17 @@
+           read_root: 0.00001406669616699
+           read_dict: 0.00000502352771425
+      read_dict_keys: 0.00001240247356490
+          read_value: 0.00000413408296372
+      read_dict_node: 0.00001154646457214
+     rule_generation: 0.00001681335830906
+      read_dict_edge: 0.00000712745246632
+         create_node: 0.00000410104562863
+    create_nodevalue: 0.00000520616297385
+         create_dict: 0.00001288164211797
+         delete_edge: 0.00000661631899889
+         delete_node: 0.00004409997758739
+   read_reverse_dict: 0.00002403594468997
+         create_edge: 0.00000684445992237
+       read_outgoing: 0.00000520984656801
+       read_incoming: 0.00000729428724981
+           read_edge: 0.00000465274053185

model/model.py

@@ -8,10 +8,10 @@ from modelverse_kernel.main import ModelverseKernel as MvK
 from modelverse_kernel.primitives import SleepKernel
 from hutn_compiler.compiler import main as do_compile
 
-#from pypdevs.DEVS import AtomicDEVS, CoupledDEVS
-#from pypdevs.simulator import Simulator
 from pypdevs.minimal import AtomicDEVS, CoupledDEVS, Simulator
 
+PROFILE = False
+
 import json
 import random
 
@@ -102,7 +102,8 @@ class ModelverseState(AtomicDEVS):
             for v in self.state.queue[0]:
                 start = time.time()
                 self.state.output.append(getattr(self.state.mvs, translate(v[0]))(*v[1]))
-                #print("%s: %s" % (translate(v[0]), time.time() - start))
+                if PROFILE:
+                    print("%s: %.17f" % (translate(v[0]), time.time() - start))
                 self.state.timer += self.timings[translate(v[0])]()
         else:
             # Just append the message to process
@@ -131,7 +132,7 @@ class ModelverseState(AtomicDEVS):
         return self.state.timer
 
 class MvKState(object):
-    def __init__(self):
+    def __init__(self, rule_generation):
         self.mvk = None
         self.waiting = False
         self.inputs = {}
@@ -144,7 +145,7 @@ class MvKState(object):
         self.current_task = None
         self.loaded_primitives = False
         self.execution_counter = 0
-        self.rule_generation_time = 0
+        self.rule_generation = rule_generation
 
     def __str__(self):
         return "\nMvK: %s\n" % self.mvk + \
@@ -160,9 +161,9 @@ class MvKState(object):
                 "execution counter: %s\n"
 
 class ModelverseKernel(AtomicDEVS):
-    def __init__(self, rules_per_phase):
+    def __init__(self, rules_per_phase, rule_generation):
         AtomicDEVS.__init__(self, "MvK")
-        self.state = MvKState()
+        self.state = MvKState(rule_generation)
 
         self.from_mvi = self.addInPort("from_MvI")
         self.from_mvs = self.addInPort("from_MvS")
@@ -239,7 +240,10 @@ class ModelverseKernel(AtomicDEVS):
                 # Process inputs
                 if self.state.inputs.get(self.state.current_task, None):
                     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)
+                    if PROFILE:
+                        print("rule_generation: %.17f" % ((time.time() - start)))
                     self.state.mvk.returnvalue = None
                     if commands is None:
                         self.state.inputs[self.state.current_task].pop(0)
@@ -247,19 +251,19 @@ class ModelverseKernel(AtomicDEVS):
                     commands = None
 
             elif self.state.phase == "computation":
-                start = time.time()
                 try:
+                    start = time.time()
                     commands = self.state.mvk.execute_yields(self.state.current_task, "execute_rule", [], self.state.reply)
+                    if PROFILE:
+                        print("rule_generation: %.17f" % ((time.time() - start)))
                 except SleepKernel:
                     commands = None
                     self.state.mvk.success = False
-                # TODO this should be sampled from a distribution!
-                self.state.rule_generation_time = time.time() - start
             elif self.state.phase == "output":
                 start = time.time()
                 commands = self.state.mvk.execute_yields(self.state.current_task, "get_output", [], self.state.reply)
-                # TODO this should be sampled from a distribution!
-                self.state.rule_generation_time = time.time() - start
+                if PROFILE:
+                    print("rule_generation: %.17f" % ((time.time() - start)))
             else:
                 raise Exception("Phase: " + str(self.state.phase))
 
@@ -305,7 +309,7 @@ class ModelverseKernel(AtomicDEVS):
 
     def timeAdvance(self):
         if self.state.commands is not None:
-            return self.state.rule_generation_time
+            return self.state.rule_generation()
         elif self.state.waiting:
             return float("inf")
         elif self.state.mvk is None:  
@@ -404,6 +408,7 @@ class System(CoupledDEVS):
                 taskname,
                 operations,
                 finish_on,
+                rule_generation,
                 rules_per_phase,
                 mvi2mvk_latency,
                 mvi2mvk_bandwidth,
@@ -444,6 +449,7 @@ class System(CoupledDEVS):
                         ))
         self.mvk = self.addSubModel(ModelverseKernel(\
                             rules_per_phase     = rules_per_phase,
+                            rule_generation     = rule_generation,
                         ))
         self.mvs = self.addSubModel(ModelverseState(\
                             read_root           = read_root,
@@ -512,26 +518,34 @@ args = {
         "mvs2mvk_bandwidth":    50000000000,
         "mvk2mvi_latency":      0.000001,
         "mvk2mvi_bandwidth":    50000000000,
-        "read_root":            lambda: 0.000014,
-        "create_node":          lambda: 0.000003,
-        "create_edge":          lambda: 0.000005,
-        "create_nodevalue":     lambda: 0.000004,
-        "create_dict":          lambda: 0.000008,
-        "read_value":           lambda: 0.000003,
-        "read_outgoing":        lambda: 0.000004,
-        "read_incoming":        lambda: 0.000004,
-        "read_edge":            lambda: 0.000004,
-        "read_dict":            lambda: 0.000004,
-        "read_dict_keys":       lambda: 0.000010,
-        "read_dict_node":       lambda: 0.000010,
-        "read_dict_edge":       lambda: 0.000004,
-        "read_dict_node_edge":  lambda: 0.000010,
-        "read_reverse_dict":    lambda: 0.000026,
-        "delete_node":          lambda: 0.000037,
-        "delete_edge":          lambda: 0.000005,
+        "read_root":            lambda: 0.0000,
+        "create_node":          lambda: 0.0000,
+        "create_edge":          lambda: 0.0000,
+        "create_nodevalue":     lambda: 0.0000,
+        "create_dict":          lambda: 0.0000,
+        "read_value":           lambda: 0.0000,
+        "read_outgoing":        lambda: 0.0000,
+        "read_incoming":        lambda: 0.0000,
+        "read_edge":            lambda: 0.0000,
+        "read_dict":            lambda: 0.0000,
+        "read_dict_keys":       lambda: 0.0000,
+        "read_dict_node":       lambda: 0.0000,
+        "read_dict_edge":       lambda: 0.0000,
+        "read_dict_node_edge":  lambda: 0.0000,
+        "read_reverse_dict":    lambda: 0.0000,
+        "delete_node":          lambda: 0.0000,
+        "delete_edge":          lambda: 0.0000,
+        "rule_generation":      lambda: 0.0000,
         "rules_per_phase":      2000,
     }
 
+with open("calibration/averages", 'r') as param_file:
+    for l in param_file:
+        op, t = l.split(": ")
+        op = op.strip()
+        t = float(t)
+        args[op] = lambda: t
+
 model = System(**args)
 sim = Simulator(model)
 sim.setTerminationCondition(lambda t, m: m.mvi.state.finished)