Added start of the DEVS performance model

model/model.py

@@ -0,0 +1,123 @@
+import sys
+sys.path.append(../kernel/)
+sys.path.append(../state/)
+from state.main import ModelverseState as MvS
+from kernel.main import ModelverseKernel as MvK
+
+from pypdevs.DEVS import AtomicDEVS, CoupledDEVS
+from pypdevs.simulator import Simulator
+
+def translate(operation):
+    return {
+            "CN": "create_node",
+            "CE": "create_edge",
+            "CNV": "create_nodevalue",
+            "CD": "create_dict",
+            "RV": "read_value",
+            "RO": "read_outgoing",
+            "RI": "read_incoming",
+            "RE": "read_edge",
+            "RD": "read_dict",
+            "RDN": "read_dict_node",
+            "RDNE": "read_dict_node_edge",
+            "RDE": "read_dict_edge",
+            "RRD": "read_reverse_dict",
+            "RR": "read_root",
+            "RDK": "read_dict_keys",
+            "DE": "delete_edge",
+            "DN": "delete_node",
+        }[operation]
+
+class MvSState(object):
+    def __init__(self):
+        self.queue = []
+        self.output = None
+        self.mvs = MvS()
+        self.timer = float("inf")
+
+class ModelverseState(AtomicDEVS):
+    def __init__(self, 
+                read_root,
+                create_node,
+                create_edge,
+                create_nodevalue,
+                create_dict,
+                read_value,
+                read_outgoing,
+                read_incoming,
+                read_edge,
+                read_dict,
+                read_dict_keys,
+                read_dict_edge,
+                read_dict_node,
+                read_dict_node_edge,
+                read_reverse_dict,
+                delete_node,
+                delete_edge):
+        AtomicDEVS.__init__(self, "MvS")
+        self.timings = {
+                "read_root": read_root,
+                "create_node": create_node,
+                "create_edge": create_edge,
+                "create_nodevalue": create_nodevalue,
+                "create_dict": create_dict,
+                "read_value": read_value,
+                "read_outgoing": read_outgoing,
+                "read_incoming": read_incoming,
+                "read_edge": read_edge,
+                "read_dict": read_dict,
+                "read_dict_keys": read_dict_keys,
+                "read_dict_edge": read_dict_edge,
+                "read_dict_node": read_dict_node,
+                "read_dict_node_edge": read_dict_node_edge,
+                "read_reverse_dict": read_reverse_dict,
+                "delete_node": delete_node,
+                "delete_edge": delete_edge,
+            }
+
+        self.from_mvk = self.addInPort("from_MvK")
+        self.to_mvk = self.addOutPort("to_MvK")
+
+    def extTransition(self, inputs):
+        self.state.timer -= self.elapsed
+        self.state.queue.extend(inputs[self.from_mvk])
+        return self.state
+
+    def outputFnc(self):
+        if self.state.output is not None:
+            return {self.to_mvk: [self.state.output]}
+        else:
+            return {}
+
+    def intTransition(self):
+        self.state.output = None
+        if self.state.queue:
+            self.state.output = []
+            value = self.state.queue.pop(0)
+            # Value contains a list of operations to do
+            # So do them and calculate how long it took!
+            for v in value:
+                self.state.output.append(getattr(self.state.mvs, translate(v[0]))(*v[1])[0])
+                self.state.timer += self.timings[translate(v[0])]
+
+        return self.state
+
+    def timeAdvance(self):
+        return self.state.timer
+
+class ModelverseKernel(AtomicDEVS):
+    def __init__(self):
+        AtomicDEVS.__init__(self, "MvK")
+        self.mvk = MvK()
+
+class ModelverseInterface(AtomicDEVS):
+    def __init__(self):
+        AtomicDEVS.__init__(self, "MvI")
+
+class Network(AtomicDEVS):  
+    def __init__(self):
+        AtomicDEVS.__init__(self, "Network")
+
+class System(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "System")