model.py 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381
  1. import sys
  2. sys.path.append("../kernel/")
  3. sys.path.append("../state/")
  4. from modelverse_state.main import ModelverseState as MvS
  5. from modelverse_kernel.main import ModelverseKernel as MvK
  6. from pypdevs.DEVS import AtomicDEVS, CoupledDEVS
  7. from pypdevs.simulator import Simulator
  8. import json
  9. def translate(operation):
  10. return {
  11. "CN": "create_node",
  12. "CE": "create_edge",
  13. "CNV": "create_nodevalue",
  14. "CD": "create_dict",
  15. "RV": "read_value",
  16. "RO": "read_outgoing",
  17. "RI": "read_incoming",
  18. "RE": "read_edge",
  19. "RD": "read_dict",
  20. "RDN": "read_dict_node",
  21. "RDNE": "read_dict_node_edge",
  22. "RDE": "read_dict_edge",
  23. "RRD": "read_reverse_dict",
  24. "RR": "read_root",
  25. "RDK": "read_dict_keys",
  26. "DE": "delete_edge",
  27. "DN": "delete_node",
  28. }[operation]
  29. class MvSState(object):
  30. def __init__(self):
  31. self.queue = []
  32. self.output = None
  33. self.mvs = MvS()
  34. self.timer = float("inf")
  35. class ModelverseState(AtomicDEVS):
  36. def __init__(self,
  37. read_root,
  38. create_node,
  39. create_edge,
  40. create_nodevalue,
  41. create_dict,
  42. read_value,
  43. read_outgoing,
  44. read_incoming,
  45. read_edge,
  46. read_dict,
  47. read_dict_keys,
  48. read_dict_edge,
  49. read_dict_node,
  50. read_dict_node_edge,
  51. read_reverse_dict,
  52. delete_node,
  53. delete_edge):
  54. AtomicDEVS.__init__(self, "MvS")
  55. self.timings = {
  56. "read_root": read_root,
  57. "create_node": create_node,
  58. "create_edge": create_edge,
  59. "create_nodevalue": create_nodevalue,
  60. "create_dict": create_dict,
  61. "read_value": read_value,
  62. "read_outgoing": read_outgoing,
  63. "read_incoming": read_incoming,
  64. "read_edge": read_edge,
  65. "read_dict": read_dict,
  66. "read_dict_keys": read_dict_keys,
  67. "read_dict_edge": read_dict_edge,
  68. "read_dict_node": read_dict_node,
  69. "read_dict_node_edge": read_dict_node_edge,
  70. "read_reverse_dict": read_reverse_dict,
  71. "delete_node": delete_node,
  72. "delete_edge": delete_edge,
  73. }
  74. self.state = MvSState()
  75. self.from_mvk = self.addInPort("from_MvK")
  76. self.to_mvk = self.addOutPort("to_MvK")
  77. def extTransition(self, inputs):
  78. self.state.timer -= self.elapsed
  79. empty = len(self.state.queue) == 0
  80. self.state.queue.extend(inputs[self.from_mvk])
  81. if empty:
  82. # First message, so set the timer
  83. # And already compute the result so it is ready to output
  84. self.state.output = []
  85. self.state.timer = 0.0
  86. print("Got input: " + str(inputs[self.from_mvk]))
  87. for v in self.state.queue[0]:
  88. self.state.output.append(getattr(self.state.mvs, translate(v[0]))(*v[1])[0])
  89. self.state.timer += self.timings[translate(v[0])]()
  90. else:
  91. # Just append the message to process
  92. pass
  93. return self.state
  94. def outputFnc(self):
  95. return {self.to_mvk: [self.state.output]}
  96. def intTransition(self):
  97. self.state.queue.pop(0)
  98. self.state.output = []
  99. if len(self.state.queue) > 0:
  100. self.state.timer = 0.0
  101. # Value contains a list of operations to do
  102. # So do them and calculate how long it takes
  103. for v in self.state.queue[0]:
  104. self.state.output.append(getattr(self.state.mvs, translate(v[0]))(*v[1])[0])
  105. self.state.timer += self.timings[translate(v[0])]()
  106. else:
  107. self.state.timer = float("inf")
  108. return self.state
  109. def timeAdvance(self):
  110. return self.state.timer
  111. class MvKState(object):
  112. def __init__(self):
  113. self.mvk = None
  114. self.waiting = False
  115. class ModelverseKernel(AtomicDEVS):
  116. def __init__(self):
  117. AtomicDEVS.__init__(self, "MvK")
  118. self.state = MvKState()
  119. self.from_mvi = self.addInPort("from_MvI")
  120. self.from_mvs = self.addInPort("from_MvS")
  121. self.to_mvi = self.addOutPort("to_MvI")
  122. self.to_mvs = self.addOutPort("to_MvS")
  123. def extTransition(self, inputs):
  124. if self.from_mvi in inputs:
  125. # Got input from MvI, so we queue it
  126. pass
  127. elif self.from_mvs in inputs:
  128. # Got input from MvS, so we can continue processing
  129. if self.state.mvk is None:
  130. # No MvK, so set it with the root we have just received (or should have received)
  131. self.state.mvk = MvK(inputs[self.from_mvs][0])
  132. return self.state
  133. def intTransition(self):
  134. if self.state.mvk is None:
  135. self.state.waiting = True
  136. return self.state
  137. def outputFnc(self):
  138. if self.state.mvk is None:
  139. # Ask the root first
  140. return {self.to_mvs: [[("RR", [])]]}
  141. def timeAdvance(self):
  142. if self.state.waiting:
  143. return float("inf")
  144. elif self.state.mvk is None:
  145. return 0
  146. else:
  147. return float("inf")
  148. class MvIState():
  149. def __init__(self):
  150. self.operations = []
  151. self.output = []
  152. self.processing = []
  153. self.memory = {}
  154. class ModelverseInterface(AtomicDEVS):
  155. def __init__(self, operations):
  156. AtomicDEVS.__init__(self, "MvI")
  157. self.state = MvIState()
  158. self.state.operations = operations
  159. self.to_mvk = self.addOutPort("to_MvK")
  160. self.from_mvk = self.addInPort("from_MvK")
  161. def intTransition(self):
  162. while self.state.operations:
  163. i = self.state.operations[0]
  164. if isinstance(i, int) and i not in self.memory:
  165. break
  166. self.state.operations.pop(0)
  167. return self.state
  168. def extTransition(self, inputs):
  169. for inp in inputs[self.from_mvk]:
  170. if inp["value"] == "None" and isinstance(self.state.processing[0], int) and self.state.processing[0] not in self.memory:
  171. self.state.memory[self.state.processing.pop(0)] = int(inp["id"])
  172. else:
  173. self.state.output.append(inp)
  174. return self.state
  175. def outputFnc(self):
  176. send = []
  177. for i in self.state.operations:
  178. if isinstance(i, int) and i not in self.memory:
  179. break
  180. elif isinstance(i, int) and i in self.memory:
  181. # Pass a reference!
  182. send.append(("R", self.memory[i]))
  183. elif not isinstance(i, int):
  184. send.append(("V", i))
  185. return {self.to_mvk: [send]}
  186. def timeAdvance(self):
  187. if self.state.processing and (not isinstance(self.state.processing[0], int) or self.state.processing[0] in self.memory):
  188. return 0
  189. else:
  190. return float("inf")
  191. class NetworkState(object):
  192. def __init__(self):
  193. self.processing = []
  194. self.timer = float("inf")
  195. class Network(AtomicDEVS):
  196. def __init__(self, name, latency, bandwidth):
  197. AtomicDEVS.__init__(self, name)
  198. self.state = NetworkState()
  199. self.input_port = self.addInPort("input_port")
  200. self.output_port = self.addOutPort("output_port")
  201. self.latency = latency
  202. self.bandwidth = bandwidth
  203. def intTransition(self):
  204. self.state.processing.pop(0)
  205. if self.state.processing:
  206. self.state.timer = int(len(self.state.processing[0]) / float(self.bandwidth) + self.latency)
  207. else:
  208. self.state.timer = float("inf")
  209. return self.state
  210. def extTransition(self, inputs):
  211. self.state.timer -= self.elapsed
  212. if self.state.timer == float("inf"):
  213. self.state.timer = 0
  214. for v in inputs[self.input_port]:
  215. self.state.processing.append(json.dumps(v))
  216. if len(self.state.processing) > 0:
  217. self.state.timer = int(len(self.state.processing[0]) / float(self.bandwidth) + self.latency)
  218. return self.state
  219. def outputFnc(self):
  220. return {self.output_port: [json.loads(self.state.processing[0])]}
  221. def timeAdvance(self):
  222. return self.state.timer
  223. class System(CoupledDEVS):
  224. def __init__(self,
  225. operations,
  226. mvi2mvk_latency,
  227. mvi2mvk_bandwidth,
  228. mvk2mvs_latency,
  229. mvk2mvs_bandwidth,
  230. mvs2mvk_latency,
  231. mvs2mvk_bandwidth,
  232. mvk2mvi_latency,
  233. mvk2mvi_bandwidth,
  234. read_root,
  235. create_node,
  236. create_edge,
  237. create_nodevalue,
  238. create_dict,
  239. read_value,
  240. read_outgoing,
  241. read_incoming,
  242. read_edge,
  243. read_dict,
  244. read_dict_keys,
  245. read_dict_edge,
  246. read_dict_node,
  247. read_dict_node_edge,
  248. read_reverse_dict,
  249. delete_node,
  250. delete_edge):
  251. CoupledDEVS.__init__(self, "System")
  252. self.mvi = self.addSubModel(ModelverseInterface(\
  253. operations = operations
  254. ))
  255. self.mvk = self.addSubModel(ModelverseKernel())
  256. self.mvs = self.addSubModel(ModelverseState(\
  257. read_root = read_root,
  258. create_node = create_node,
  259. create_edge = create_edge,
  260. create_nodevalue = create_nodevalue,
  261. create_dict = create_dict,
  262. read_value = read_value,
  263. read_outgoing = read_outgoing,
  264. read_incoming = read_incoming,
  265. read_edge = read_edge,
  266. read_dict = read_dict,
  267. read_dict_keys = read_dict_keys,
  268. read_dict_edge = read_dict_edge,
  269. read_dict_node = read_dict_node,
  270. read_dict_node_edge = read_dict_node_edge,
  271. read_reverse_dict = read_reverse_dict,
  272. delete_node = delete_node,
  273. delete_edge = delete_edge
  274. ))
  275. self.mvi2mvk = self.addSubModel(Network(\
  276. name = "mvi2mvk",
  277. latency = mvi2mvk_latency,
  278. bandwidth = mvi2mvk_bandwidth
  279. ))
  280. self.mvk2mvs = self.addSubModel(Network(\
  281. name = "mvk2mvs",
  282. latency = mvk2mvs_latency,
  283. bandwidth = mvk2mvs_bandwidth
  284. ))
  285. self.mvs2mvk = self.addSubModel(Network(\
  286. name = "mvs2mvk",
  287. latency = mvs2mvk_latency,
  288. bandwidth = mvs2mvk_bandwidth
  289. ))
  290. self.mvk2mvi = self.addSubModel(Network(\
  291. name = "mvk2mvi",
  292. latency = mvk2mvi_latency,
  293. bandwidth = mvk2mvi_bandwidth
  294. ))
  295. self.connectPorts(self.mvi.to_mvk, self.mvi2mvk.input_port)
  296. self.connectPorts(self.mvi2mvk.output_port, self.mvk.from_mvi)
  297. self.connectPorts(self.mvk.to_mvs, self.mvk2mvs.input_port)
  298. self.connectPorts(self.mvk2mvs.output_port, self.mvs.from_mvk)
  299. self.connectPorts(self.mvs.to_mvk, self.mvs2mvk.input_port)
  300. self.connectPorts(self.mvs2mvk.output_port, self.mvk.from_mvs)
  301. self.connectPorts(self.mvk.to_mvi, self.mvk2mvi.input_port)
  302. self.connectPorts(self.mvk2mvi.output_port, self.mvi.from_mvk)
  303. operations = [
  304. "test",
  305. ]
  306. args = {
  307. "operations": operations,
  308. "mvi2mvk_latency": 1,
  309. "mvi2mvk_bandwidth": 2000,
  310. "mvk2mvs_latency": 1,
  311. "mvk2mvs_bandwidth": 2000,
  312. "mvs2mvk_latency": 1,
  313. "mvs2mvk_bandwidth": 2000,
  314. "mvk2mvi_latency": 1,
  315. "mvk2mvi_bandwidth": 2000,
  316. "read_root": lambda: 1,
  317. "create_node": lambda: 1,
  318. "create_edge": lambda: 1,
  319. "create_nodevalue": lambda: 1,
  320. "create_dict": lambda: 1,
  321. "read_value": lambda: 1,
  322. "read_outgoing": lambda: 1,
  323. "read_incoming": lambda: 1,
  324. "read_edge": lambda: 1,
  325. "read_dict": lambda: 1,
  326. "read_dict_keys": lambda: 1,
  327. "read_dict_node": lambda: 1,
  328. "read_dict_edge": lambda: 1,
  329. "read_dict_node_edge": lambda: 1,
  330. "read_reverse_dict": lambda: 1,
  331. "delete_node": lambda: 1,
  332. "delete_edge": lambda: 1,
  333. }
  334. model = System(**args)
  335. sim = Simulator(model)
  336. sim.setTerminationTime(10)
  337. sim.setVerbose()
  338. sim.simulate()