model.py 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437
  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. self.inputs = []
  116. self.outputs = []
  117. self.users = []
  118. class ModelverseKernel(AtomicDEVS):
  119. def __init__(self):
  120. AtomicDEVS.__init__(self, "MvK")
  121. self.state = MvKState()
  122. self.from_mvi = self.addInPort("from_MvI")
  123. self.from_mvs = self.addInPort("from_MvS")
  124. self.to_mvi = self.addOutPort("to_MvI")
  125. self.to_mvs = self.addOutPort("to_MvS")
  126. def extTransition(self, inputs):
  127. if self.from_mvi in inputs:
  128. # Got input from MvI, so we queue it
  129. for inp in inputs[self.from_mvi]:
  130. if inp is not None:
  131. self.state.inputs.append(inp)
  132. else:
  133. self.state.outputs.append(None)
  134. if self.from_mvs in inputs:
  135. # Got input from MvS, so we can continue processing
  136. if self.state.mvk is None:
  137. # No MvK, so set it with the root we have just received (or should have received)
  138. self.state.mvk = MvK(inputs[self.from_mvs][0])
  139. else:
  140. self.state.reply = inputs[self.from_mvs][0]
  141. self.state.waiting = False
  142. return self.state
  143. def intTransition(self):
  144. if self.state.mvk is None:
  145. # Initializing
  146. self.state.waiting = True
  147. else:
  148. # Are initialized and have work to do
  149. if len(self.state.users) == 0:
  150. # Read out new set of users first
  151. if self.state.reply is None:
  152. commands = [("RDK", [])]
  153. else:
  154. self.users = self.state.reply
  155. print("Got users: " + str(self.users))
  156. commands = None
  157. elif self.state.phase == "input":
  158. # Process inputs
  159. commands = self.state.mvk.execute_yields(self.state.users[0], "set_input", [self.state.inputs[0]], self.state.reply)
  160. elif self.state.phase == "computation":
  161. commands = self.state.mvk.execute_yields(self.state.users[0], "execute_rule", [], self.state.reply)
  162. elif self.state.phase == "output":
  163. commands = self.state.mvk.execute_yields(self.state.users[0], "get_output", [], self.state.reply)
  164. # Advance phase
  165. if commands is None:
  166. if len(self.state.users) == 0:
  167. self.state.phase = "input"
  168. elif self.state.phase == "input":
  169. self.state.inputs.pop(0)
  170. self.state.phase = "computation"
  171. elif self.state.phase == "computation":
  172. self.state.phase = "output"
  173. elif self.state.phase == "output":
  174. self.state.users.pop(0)
  175. self.state.phase = "input"
  176. self.state.waiting = False
  177. self.state.reply = None
  178. else:
  179. self.state.waiting = True
  180. # Send the commands to the MvS
  181. self.state.commands = commands
  182. return self.state
  183. def outputFnc(self):
  184. if self.state.mvk is None:
  185. # Ask the root first
  186. return {self.to_mvs: [[("RR", [])]]}
  187. elif self.state.waiting:
  188. return {self.to_mvs: [self.state.commands]}
  189. return {}
  190. def timeAdvance(self):
  191. if self.state.waiting:
  192. return float("inf")
  193. elif self.state.mvk is None:
  194. return 0
  195. else:
  196. return float("inf")
  197. class MvIState():
  198. def __init__(self):
  199. self.operations = []
  200. self.output = []
  201. self.processing = []
  202. self.memory = {}
  203. self.init = True
  204. class ModelverseInterface(AtomicDEVS):
  205. def __init__(self, operations):
  206. AtomicDEVS.__init__(self, "MvI")
  207. self.state = MvIState()
  208. self.state.operations = operations
  209. self.to_mvk = self.addOutPort("to_MvK")
  210. self.from_mvk = self.addInPort("from_MvK")
  211. def intTransition(self):
  212. self.state.init = False
  213. while self.state.operations:
  214. i = self.state.operations[0]
  215. if isinstance(i, int) and i not in self.memory:
  216. break
  217. self.state.operations.pop(0)
  218. return self.state
  219. def extTransition(self, inputs):
  220. for inp in inputs[self.from_mvk]:
  221. if inp["value"] == "None" and isinstance(self.state.processing[0], int) and self.state.processing[0] not in self.memory:
  222. self.state.memory[self.state.processing.pop(0)] = int(inp["id"])
  223. else:
  224. self.state.output.append(inp)
  225. return self.state
  226. def outputFnc(self):
  227. send = []
  228. for i in self.state.operations:
  229. if isinstance(i, int) and i not in self.memory:
  230. break
  231. elif isinstance(i, int) and i in self.memory:
  232. # Pass a reference!
  233. send.append(("R", self.memory[i]))
  234. elif not isinstance(i, int):
  235. send.append(("V", i))
  236. return {self.to_mvk: [send]}
  237. def timeAdvance(self):
  238. if self.state.init:
  239. return 0
  240. elif self.state.processing and (not isinstance(self.state.processing[0], int) or self.state.processing[0] in self.memory):
  241. return 0
  242. else:
  243. return float("inf")
  244. class NetworkState(object):
  245. def __init__(self):
  246. self.processing = []
  247. self.timer = float("inf")
  248. class Network(AtomicDEVS):
  249. def __init__(self, name, latency, bandwidth):
  250. AtomicDEVS.__init__(self, name)
  251. self.state = NetworkState()
  252. self.input_port = self.addInPort("input_port")
  253. self.output_port = self.addOutPort("output_port")
  254. self.latency = latency
  255. self.bandwidth = bandwidth
  256. def intTransition(self):
  257. self.state.processing.pop(0)
  258. if self.state.processing:
  259. self.state.timer = int(len(self.state.processing[0]) / float(self.bandwidth) + self.latency)
  260. else:
  261. self.state.timer = float("inf")
  262. return self.state
  263. def extTransition(self, inputs):
  264. self.state.timer -= self.elapsed
  265. if self.state.timer == float("inf"):
  266. self.state.timer = 0
  267. for v in inputs[self.input_port]:
  268. self.state.processing.append(json.dumps(v))
  269. if len(self.state.processing) > 0:
  270. self.state.timer = int(len(self.state.processing[0]) / float(self.bandwidth) + self.latency)
  271. return self.state
  272. def outputFnc(self):
  273. return {self.output_port: [json.loads(self.state.processing[0])]}
  274. def timeAdvance(self):
  275. return self.state.timer
  276. class System(CoupledDEVS):
  277. def __init__(self,
  278. operations,
  279. mvi2mvk_latency,
  280. mvi2mvk_bandwidth,
  281. mvk2mvs_latency,
  282. mvk2mvs_bandwidth,
  283. mvs2mvk_latency,
  284. mvs2mvk_bandwidth,
  285. mvk2mvi_latency,
  286. mvk2mvi_bandwidth,
  287. read_root,
  288. create_node,
  289. create_edge,
  290. create_nodevalue,
  291. create_dict,
  292. read_value,
  293. read_outgoing,
  294. read_incoming,
  295. read_edge,
  296. read_dict,
  297. read_dict_keys,
  298. read_dict_edge,
  299. read_dict_node,
  300. read_dict_node_edge,
  301. read_reverse_dict,
  302. delete_node,
  303. delete_edge):
  304. CoupledDEVS.__init__(self, "System")
  305. self.mvi = self.addSubModel(ModelverseInterface(\
  306. operations = operations
  307. ))
  308. self.mvk = self.addSubModel(ModelverseKernel())
  309. self.mvs = self.addSubModel(ModelverseState(\
  310. read_root = read_root,
  311. create_node = create_node,
  312. create_edge = create_edge,
  313. create_nodevalue = create_nodevalue,
  314. create_dict = create_dict,
  315. read_value = read_value,
  316. read_outgoing = read_outgoing,
  317. read_incoming = read_incoming,
  318. read_edge = read_edge,
  319. read_dict = read_dict,
  320. read_dict_keys = read_dict_keys,
  321. read_dict_edge = read_dict_edge,
  322. read_dict_node = read_dict_node,
  323. read_dict_node_edge = read_dict_node_edge,
  324. read_reverse_dict = read_reverse_dict,
  325. delete_node = delete_node,
  326. delete_edge = delete_edge
  327. ))
  328. self.mvi2mvk = self.addSubModel(Network(\
  329. name = "mvi2mvk",
  330. latency = mvi2mvk_latency,
  331. bandwidth = mvi2mvk_bandwidth
  332. ))
  333. self.mvk2mvs = self.addSubModel(Network(\
  334. name = "mvk2mvs",
  335. latency = mvk2mvs_latency,
  336. bandwidth = mvk2mvs_bandwidth
  337. ))
  338. self.mvs2mvk = self.addSubModel(Network(\
  339. name = "mvs2mvk",
  340. latency = mvs2mvk_latency,
  341. bandwidth = mvs2mvk_bandwidth
  342. ))
  343. self.mvk2mvi = self.addSubModel(Network(\
  344. name = "mvk2mvi",
  345. latency = mvk2mvi_latency,
  346. bandwidth = mvk2mvi_bandwidth
  347. ))
  348. self.connectPorts(self.mvi.to_mvk, self.mvi2mvk.input_port)
  349. self.connectPorts(self.mvi2mvk.output_port, self.mvk.from_mvi)
  350. self.connectPorts(self.mvk.to_mvs, self.mvk2mvs.input_port)
  351. self.connectPorts(self.mvk2mvs.output_port, self.mvs.from_mvk)
  352. self.connectPorts(self.mvs.to_mvk, self.mvs2mvk.input_port)
  353. self.connectPorts(self.mvs2mvk.output_port, self.mvk.from_mvs)
  354. self.connectPorts(self.mvk.to_mvi, self.mvk2mvi.input_port)
  355. self.connectPorts(self.mvk2mvi.output_port, self.mvi.from_mvk)
  356. operations = [
  357. "test",
  358. ]
  359. args = {
  360. "operations": operations,
  361. "mvi2mvk_latency": 1,
  362. "mvi2mvk_bandwidth": 2000,
  363. "mvk2mvs_latency": 1,
  364. "mvk2mvs_bandwidth": 2000,
  365. "mvs2mvk_latency": 1,
  366. "mvs2mvk_bandwidth": 2000,
  367. "mvk2mvi_latency": 1,
  368. "mvk2mvi_bandwidth": 2000,
  369. "read_root": lambda: 1,
  370. "create_node": lambda: 1,
  371. "create_edge": lambda: 1,
  372. "create_nodevalue": lambda: 1,
  373. "create_dict": lambda: 1,
  374. "read_value": lambda: 1,
  375. "read_outgoing": lambda: 1,
  376. "read_incoming": lambda: 1,
  377. "read_edge": lambda: 1,
  378. "read_dict": lambda: 1,
  379. "read_dict_keys": lambda: 1,
  380. "read_dict_node": lambda: 1,
  381. "read_dict_edge": lambda: 1,
  382. "read_dict_node_edge": lambda: 1,
  383. "read_reverse_dict": lambda: 1,
  384. "delete_node": lambda: 1,
  385. "delete_edge": lambda: 1,
  386. }
  387. model = System(**args)
  388. sim = Simulator(model)
  389. sim.setTerminationTime(10)
  390. sim.setVerbose()
  391. sim.simulate()