main.py 54 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080
  1. import modelverse_kernel.primitives as primitive_functions
  2. import modelverse_kernel.compiled as compiled_functions
  3. from modelverse_kernel.request_handler import RequestHandler
  4. import modelverse_jit.jit as jit
  5. import modelverse_jit.intrinsics as jit_intrinsics
  6. from collections import defaultdict
  7. import sys
  8. import time
  9. if sys.version > '3': # pragma: no cover
  10. string_types = (str,)
  11. else:
  12. string_types = (str, unicode)
  13. class ModelverseKernel(object):
  14. def __init__(self, root):
  15. self.root = root
  16. self.returnvalue = None
  17. self.success = True
  18. # request_handlers is a dictionary of usernames to dictionaries of operations
  19. # to request handlers. In generics notation:
  20. #
  21. # Dictionary<
  22. # Username,
  23. # Dictionary<
  24. # Operation,
  25. # RequestHandler>>
  26. #
  27. self.request_handlers = {}
  28. self.allow_compiled = True
  29. #self.allow_compiled = False
  30. # suggested_function_names maps body ids to suggested function names.
  31. # You tell the kernel to stop caring about getting the function names
  32. # right by setting this to `None`.
  33. self.suggested_function_names = {}
  34. # `self.jit` handles most JIT-related functionality.
  35. self.jit = jit.ModelverseJit()
  36. if self.allow_compiled:
  37. self.jit.compiled_function_lookup = lambda func_name: \
  38. getattr(compiled_functions, func_name, None)
  39. jit_intrinsics.register_intrinsics(self.jit)
  40. # To disable the JIT, uncomment the line below:
  41. # self.jit.set_jit_enabled(False)
  42. #
  43. # To disable direct calls in the JIT, uncomment the line below:
  44. # self.jit.allow_direct_calls(False)
  45. #
  46. # To enable tracing in the JIT (for debugging purposes), uncomment
  47. # the line below:
  48. #
  49. # self.jit.enable_tracing()
  50. self.debug_info = defaultdict(list)
  51. def execute_yields(self, username, operation, params, reply):
  52. self.success = True
  53. self.username = username
  54. if username not in self.request_handlers:
  55. self.request_handlers[username] = {}
  56. if operation not in self.request_handlers[username]:
  57. # Create the generator for the function to execute
  58. self.request_handlers[username][operation] = RequestHandler()
  59. handler = self.request_handlers[username][operation]
  60. if not handler.is_active():
  61. handler.push_generator(getattr(self, operation)(username, *params))
  62. return handler.handle_request(reply)
  63. def execute_rule(self, username):
  64. user_root, = yield [("RD", [self.root, username])]
  65. if user_root is None:
  66. self.success = False
  67. self.returnvalue = None
  68. yield None
  69. else:
  70. user_frame, = yield [("RD", [user_root, "frame"])]
  71. self.inst, phase = yield [("RD", [user_frame, "IP"]),
  72. ("RD", [user_frame, "phase"]),
  73. ]
  74. self.new_debug, self.phase_v, inst_v = \
  75. yield [("RD", [self.inst, "__debug"]),
  76. ("RV", [phase]),
  77. ("RV", [self.inst]),
  78. ]
  79. if self.new_debug is not None:
  80. if self.debug_info[username]:
  81. self.debug_info[username][-1], = yield [("RV", [self.new_debug])]
  82. if self.phase_v == "finish":
  83. gen = self.helper_init(user_root)
  84. elif self.inst is None:
  85. raise Exception("Instruction pointer could not be found!")
  86. elif isinstance(self.phase_v, string_types):
  87. if self.phase_v == "init" and self.jit.is_jittable_entry_point(self.inst):
  88. #print("%-30s(%s)" % ("COMPILED " + str(self.jit.jitted_entry_points[self.inst]), phase_v))
  89. gen = self.execute_jit(user_root, self.inst, username)
  90. elif inst_v is None:
  91. raise Exception("%s: error understanding command (%s, %s)" % (self.debug_info[username], inst_v, self.phase_v))
  92. else:
  93. #print("%-30s(%s) -- %s" % (inst_v["value"], self.phase_v, username))
  94. gen = self.get_inst_phase_generator(inst_v, self.phase_v, user_root)
  95. elif inst_v is None:
  96. raise Exception("%s: error understanding command (%s, %s)" % (self.debug_info[username], inst_v, self.phase_v))
  97. elif inst_v["value"] == "call":
  98. #print("%-30s(%s)" % ("call", "param"))
  99. gen = self.call_param(user_root)
  100. else:
  101. raise Exception("%s: error understanding command (%s, %s)" % (self.debug_info[username], inst_v, self.phase_v))
  102. try:
  103. inp = None
  104. while 1:
  105. inp = yield gen.send(inp)
  106. except StopIteration:
  107. pass
  108. except jit.JitCompilationFailedException as e:
  109. # Try again, but this time without the JIT.
  110. # print(e.message)
  111. gen = self.get_inst_phase_generator(inst_v, self.phase_v, user_root)
  112. yield [("RUN", [gen])]
  113. def get_inst_phase_generator(self, inst_v, phase_v, user_root):
  114. """Gets a generator for the given instruction in the given phase,
  115. for the specified user root."""
  116. #print("%-30s(%s) -- %s" % (inst_v["value"], phase_v, username))
  117. return getattr(self, "%s_%s" % (inst_v["value"], phase_v))(user_root)
  118. ##########################
  119. ### Process primitives ###
  120. ##########################
  121. def load_primitives(self, username):
  122. hierarchy, = yield [("RD", [self.root, "__hierarchy"])]
  123. primitives, = yield [("RD", [hierarchy, "primitives"])]
  124. keys, = yield [("RDK", [primitives])]
  125. function_names = yield [("RV", [f]) for f in keys]
  126. signatures = yield [("RDN", [primitives, f]) for f in keys]
  127. bodies = yield [("RD", [f, "body"]) for f in signatures]
  128. for i in range(len(keys)):
  129. self.jit.register_compiled(
  130. bodies[i],
  131. getattr(primitive_functions, function_names[i]),
  132. function_names[i])
  133. def jit_compile(self, user_root, inst):
  134. # Try to retrieve the suggested name.
  135. if self.suggested_function_names is not None and inst in self.suggested_function_names:
  136. suggested_name = self.suggested_function_names[inst]
  137. else:
  138. suggested_name = None
  139. # Have the JIT compile the function.
  140. return self.jit.jit_compile(user_root, inst, suggested_name)
  141. def execute_jit(self, user_root, inst, username):
  142. # execute_jit
  143. user_frame, = yield [("RD", [user_root, "frame"])]
  144. symbols, = yield [("RD", [user_frame, "symbols"])]
  145. all_links, = yield [("RO", [symbols])]
  146. containers = yield [("RE", [v]) for v in all_links]
  147. outgoings = yield [("RO", [v]) for v in all_links]
  148. dict_values = yield [("RD", [v[1], "value"]) for v in containers]
  149. formals_1 = yield [("RE", [v[0]]) for v in outgoings]
  150. dict_keys_ref = yield [("RD", [v[1], "name"]) for v in formals_1]
  151. dict_keys = yield [("RV", [v]) for v in dict_keys_ref]
  152. parameters = dict(zip(dict_keys, dict_values))
  153. parameters["root"] = self.root
  154. parameters["user_root"] = user_root
  155. parameters["username"] = username
  156. parameters["mvk"] = self
  157. # Have the JIT compile the function.
  158. compiled_func, = yield [("RUN", [self.jit_compile(user_root, inst)])]
  159. # Run the compiled function.
  160. results = yield [("RUN", [compiled_func, parameters])]
  161. if results is None:
  162. raise Exception(
  163. "%s: primitive finished without returning a value!" % (self.debug_info[username]))
  164. else:
  165. result, = results
  166. # Clean up the current stack, as if a return happened
  167. old_frame, exception_return = yield [
  168. ("RD", [user_frame, "prev"]),
  169. ("RD", [user_frame, primitive_functions.EXCEPTION_RETURN_KEY])]
  170. if self.debug_info[self.username]:
  171. self.debug_info[self.username].pop()
  172. if exception_return is not None:
  173. # The caller has requested that we throw an exception instead of injecting
  174. # the return value into the caller's frame. Read the comment at
  175. # primitive_functions.EXCEPTION_RETURN_KEY for the rationale behind this design.
  176. yield [("CD", [user_root, "frame", old_frame]),
  177. ("DN", [user_frame])]
  178. raise primitive_functions.InterpretedFunctionFinished(result)
  179. else:
  180. lnk, = yield [("RDE", [old_frame, "returnvalue"])]
  181. _, _, _, _ = yield [("CD", [old_frame, "returnvalue", result]),
  182. ("CD", [user_root, "frame", old_frame]),
  183. ("DE", [lnk]),
  184. ("DN", [user_frame]),
  185. ]
  186. ########################################
  187. ### Execute input and output methods ###
  188. ########################################
  189. def get_output(self, username):
  190. user_root, = yield [("RD", [self.root, username])]
  191. first_output, = yield [("RD", [user_root, "output"])]
  192. next_output, rv = yield [("RD", [first_output, "next"]),
  193. ("RD", [first_output, "value"]),
  194. ]
  195. if next_output is None:
  196. self.success = False
  197. self.returnvalue = None
  198. else:
  199. rv_value, = yield [("RV", [rv])]
  200. _, _ = yield [("CD", [user_root, "output", next_output]),
  201. ("DN", [first_output]),
  202. ]
  203. self.returnvalue = rv_value
  204. def set_input(self, username, value):
  205. user_root, = yield [("RD", [self.root, username])]
  206. old_input, link = yield [("RD", [user_root, "last_input"]),
  207. ("RDE", [user_root, "last_input"]),
  208. ]
  209. new_input, = yield [("CN", [])]
  210. _, _ = yield [("CD", [user_root, "last_input", new_input]),
  211. ("CD", [old_input, "next", new_input]),
  212. ]
  213. new_value, = yield [("CNV", [value])]
  214. _, _ = yield [("CD", [old_input, "value", new_value]),
  215. ("DE", [link])
  216. ]
  217. self.returnvalue = {"id": 100, "value": "success"}
  218. #############################################
  219. ### Transformation rules for instructions ###
  220. #############################################
  221. def break_init(self, user_root):
  222. user_frame, = yield [("RD", [user_root, "frame"])]
  223. phase_link, ip_link = \
  224. yield [("RDE", [user_frame, "phase"]),
  225. ("RDE", [user_frame, "IP"])
  226. ]
  227. inst, = yield [("RD", [user_frame, "IP"])]
  228. while_inst, new_phase = \
  229. yield [("RD", [inst, "while"]),
  230. ("CNV", ["finish"]),
  231. ]
  232. _, _, _, _ = yield [("CD", [user_frame, "phase", new_phase]),
  233. ("CD", [user_frame, "IP", while_inst]),
  234. ("DE", [phase_link]),
  235. ("DE", [ip_link]),
  236. ]
  237. def continue_init(self, user_root):
  238. user_frame, = yield [("RD", [user_root, "frame"])]
  239. ip_link, inst = yield [("RDE", [user_frame, "IP"]),
  240. ("RD", [user_frame, "IP"]),
  241. ]
  242. while_inst, = yield [("RD", [inst, "while"])]
  243. _, _ = yield [("CD", [user_frame, "IP", while_inst]),
  244. ("DE", [ip_link]),
  245. ]
  246. def if_init(self, user_root):
  247. user_frame, = yield [("RD", [user_root, "frame"])]
  248. evalstack, evalstack_link = \
  249. yield [("RD", [user_frame, "evalstack"]),
  250. ("RDE", [user_frame, "evalstack"]),
  251. ]
  252. inst, ip_link = yield [("RD", [user_frame, "IP"]),
  253. ("RDE", [user_frame, "IP"]),
  254. ]
  255. cond, = yield [("RD", [inst, "cond"])]
  256. new_evalstack, new_phase = \
  257. yield [("CN", []),
  258. ("CNV", ["cond"]),
  259. ]
  260. _, _, _, _, _, _, _ = \
  261. yield [("CD", [user_frame, "evalstack", new_evalstack]),
  262. ("CD", [new_evalstack, "prev", evalstack]),
  263. ("CD", [user_frame, "IP", cond]),
  264. ("CD", [evalstack, "inst", inst]),
  265. ("CD", [evalstack, "phase", new_phase]),
  266. ("DE", [evalstack_link]),
  267. ("DE", [ip_link]),
  268. ]
  269. def if_cond(self, user_root):
  270. user_frame, = yield [("RD", [user_root, "frame"])]
  271. returnvalue, inst = yield [("RD", [user_frame, "returnvalue"]),
  272. ("RD", [user_frame, "IP"]),
  273. ]
  274. returnvalue_v, = yield [("RV", [returnvalue])]
  275. _else, = yield [("RD", [inst, "else"])]
  276. if returnvalue_v:
  277. phase_link, evalstack, evalstack_link, ip_link, _then, new_evalstack, evalstack_phase, new_phase = \
  278. yield [("RDE", [user_frame, "phase"]),
  279. ("RD", [user_frame, "evalstack"]),
  280. ("RDE", [user_frame, "evalstack"]),
  281. ("RDE", [user_frame, "IP"]),
  282. ("RD", [inst, "then"]),
  283. ("CN", []),
  284. ("CNV", ["finish"]),
  285. ("CNV", ["init"]),
  286. ]
  287. _, _, _, _, _, _, _, _, _ = \
  288. yield [("CD", [user_frame, "evalstack", new_evalstack]),
  289. ("CD", [user_frame, "IP", _then]),
  290. ("CD", [new_evalstack, "prev", evalstack]),
  291. ("CD", [evalstack, "inst", inst]),
  292. ("CD", [evalstack, "phase", evalstack_phase]),
  293. ("CD", [user_frame, "phase", new_phase]),
  294. ("DE", [evalstack_link]),
  295. ("DE", [ip_link]),
  296. ("DE", [phase_link]),
  297. ]
  298. elif _else is None:
  299. phase_link, new_phase = \
  300. yield [("RDE", [user_frame, "phase"]),
  301. ("CNV", ["finish"]),
  302. ]
  303. _, _ = yield [("CD", [user_frame, "phase", new_phase]),
  304. ("DE", [phase_link]),
  305. ]
  306. else:
  307. phase_link, evalstack, evalstack_link, ip_link = \
  308. yield [("RDE", [user_frame, "phase"]),
  309. ("RD", [user_frame, "evalstack"]),
  310. ("RDE", [user_frame, "evalstack"]),
  311. ("RDE", [user_frame, "IP"]),
  312. ]
  313. new_evalstack, new_phase, evalstack_phase = \
  314. yield [("CN", []),
  315. ("CNV", ["init"]),
  316. ("CNV", ["finish"]),
  317. ]
  318. _, _, _, _, _, _, _, _, _ = \
  319. yield [("CD", [user_frame, "evalstack", new_evalstack]),
  320. ("CD", [user_frame, "IP", _else]),
  321. ("CD", [new_evalstack, "prev", evalstack]),
  322. ("CD", [evalstack, "inst", inst]),
  323. ("CD", [evalstack, "phase", evalstack_phase]),
  324. ("CD", [user_frame, "phase", new_phase]),
  325. ("DE", [evalstack_link]),
  326. ("DE", [ip_link]),
  327. ("DE", [phase_link]),
  328. ]
  329. def while_init(self, user_root):
  330. user_frame, = yield [("RD", [user_root, "frame"])]
  331. evalstack, evalstack_link, ip_link, inst = \
  332. yield [("RD", [user_frame, "evalstack"]),
  333. ("RDE", [user_frame, "evalstack"]),
  334. ("RDE", [user_frame, "IP"]),
  335. ("RD", [user_frame, "IP"]),
  336. ]
  337. cond, new_evalstack, new_phase = \
  338. yield [("RD", [inst, "cond"]),
  339. ("CN", []),
  340. ("CNV", ["cond"]),
  341. ]
  342. _, _, _, _, _, _, _ = \
  343. yield [("CD", [user_frame, "evalstack", new_evalstack]),
  344. ("CD", [new_evalstack, "prev", evalstack]),
  345. ("CD", [user_frame, "IP", cond]),
  346. ("CD", [evalstack, "phase", new_phase]),
  347. ("CD", [evalstack, "inst", inst]),
  348. ("DE", [evalstack_link]),
  349. ("DE", [ip_link]),
  350. ]
  351. def while_cond(self, user_root):
  352. user_frame, = yield [("RD", [user_root, "frame"])]
  353. returnvalue, = yield [("RD", [user_frame, "returnvalue"])]
  354. returnvalue_v, = yield [("RV", [returnvalue])]
  355. if returnvalue_v:
  356. phase_link, evalstack, evalstack_link, ip_link, inst = \
  357. yield [("RDE", [user_frame, "phase"]),
  358. ("RD", [user_frame, "evalstack"]),
  359. ("RDE", [user_frame, "evalstack"]),
  360. ("RDE", [user_frame, "IP"]),
  361. ("RD", [user_frame, "IP"]),
  362. ]
  363. body, = yield [("RD", [inst, "body"])]
  364. new_evalstack, new_phase, evalstack_phase = \
  365. yield [("CN", []),
  366. ("CNV", ["init"]),
  367. ("CNV", ["init"]),
  368. ]
  369. _, _, _, _, _, _, _, _, _ = \
  370. yield [("CD", [user_frame, "IP", body]),
  371. ("CD", [user_frame, "phase", new_phase]),
  372. ("CD", [user_frame, "evalstack", new_evalstack]),
  373. ("CD", [new_evalstack, "prev", evalstack]),
  374. ("CD", [evalstack, "inst", inst]),
  375. ("CD", [evalstack, "phase", evalstack_phase]),
  376. ("DE", [evalstack_link]),
  377. ("DE", [ip_link]),
  378. ("DE", [phase_link]),
  379. ]
  380. else:
  381. phase_link, new_phase = \
  382. yield [("RDE", [user_frame, "phase"]),
  383. ("CNV", ["finish"]),
  384. ]
  385. _, _ = yield [("CD", [user_frame, "phase", new_phase]),
  386. ("DE", [phase_link])
  387. ]
  388. def access_init(self, user_root):
  389. user_frame, = yield [("RD", [user_root, "frame"])]
  390. evalstack, evalstack_link, inst, ip_link = \
  391. yield [("RD", [user_frame, "evalstack"]),
  392. ("RDE", [user_frame, "evalstack"]),
  393. ("RD", [user_frame, "IP"]),
  394. ("RDE", [user_frame, "IP"]),
  395. ]
  396. var, new_evalstack, new_phase = \
  397. yield [("RD", [inst, "var"]),
  398. ("CN", []),
  399. ("CNV", ["eval"]),
  400. ]
  401. _, _, _, _, _, _, _ = \
  402. yield [("CD", [user_frame, "IP", var]),
  403. ("CD", [user_frame, "evalstack", new_evalstack]),
  404. ("CD", [new_evalstack, "prev", evalstack]),
  405. ("CD", [evalstack, "inst", inst]),
  406. ("CD", [evalstack, "phase", new_phase]),
  407. ("DE", [evalstack_link]),
  408. ("DE", [ip_link]),
  409. ]
  410. def access_eval(self, user_root):
  411. user_frame, = yield [("RD", [user_root, "frame"])]
  412. phase_link, returnvalue_link, returnvalue = \
  413. yield [("RDE", [user_frame, "phase"]),
  414. ("RDE", [user_frame, "returnvalue"]),
  415. ("RD", [user_frame, "returnvalue"]),
  416. ]
  417. value, new_phase = yield [("RD", [returnvalue, "value"]),
  418. ("CNV", ["finish"]),
  419. ]
  420. _, _, _, _ = yield [("CD", [user_frame, "phase", new_phase]),
  421. ("CD", [user_frame, "returnvalue", value]),
  422. ("DE", [phase_link]),
  423. ("DE", [returnvalue_link]),
  424. ]
  425. def resolve_init(self, user_root):
  426. user_frame, = yield [("RD", [user_root, "frame"])]
  427. symbols, evalstack, evalstack_link, ip_link, inst = \
  428. yield [("RD", [user_frame, "symbols"]),
  429. ("RD", [user_frame, "evalstack"]),
  430. ("RDE", [user_frame, "evalstack"]),
  431. ("RDE", [user_frame, "IP"]),
  432. ("RD", [user_frame, "IP"]),
  433. ]
  434. var, = yield [("RD", [inst, "var"])]
  435. variable, = yield [("RDN", [symbols, var])]
  436. if variable is None:
  437. phase_link, returnvalue_link, _globals, var_name = \
  438. yield [("RDE", [user_frame, "phase"]),
  439. ("RDE", [user_frame, "returnvalue"]),
  440. ("RD", [user_root, "globals"]),
  441. ("RV", [var]),
  442. ]
  443. variable, new_phase = \
  444. yield [("RD", [_globals, var_name]),
  445. ("CNV", ["finish"]),
  446. ]
  447. if variable is None:
  448. raise Exception("Not found as global: %s" % var_name)
  449. # Resolved a global, so this is a string
  450. # Potentially, this might even be a function that we have precompiled already!
  451. # So check whether this is the case or not
  452. if self.allow_compiled:
  453. compiled_function = getattr(compiled_functions, var_name, None)
  454. if compiled_function is not None:
  455. # We have a compiled function ready!
  456. # Now we have to bind the ID to the compiled functions
  457. # For this, we read out the body of the resolved data
  458. compiler_val, = yield [("RD", [variable, "value"])]
  459. compiler_body, = yield [("RD", [compiler_val, "body"])]
  460. self.jit.register_compiled(compiler_body, compiled_function, var_name)
  461. # If we're dealing with a function, then we might want to figure out what its body id
  462. # is now so we can suggest a name to the JIT later.
  463. if self.suggested_function_names is not None:
  464. compiler_val, = yield [("RD", [variable, "value"])]
  465. if compiler_val is not None:
  466. compiler_body, = yield [("RD", [compiler_val, "body"])]
  467. if compiler_body is not None:
  468. self.suggested_function_names[compiler_body] = var_name
  469. else:
  470. phase_link, returnvalue_link, new_phase = \
  471. yield [("RDE", [user_frame, "phase"]),
  472. ("RDE", [user_frame, "returnvalue"]),
  473. ("CNV", ["finish"]),
  474. ]
  475. _, _, _, _ = yield [("CD", [user_frame, "phase", new_phase]),
  476. ("CD", [user_frame, "returnvalue", variable]),
  477. ("DE", [phase_link]),
  478. ("DE", [returnvalue_link]),
  479. ]
  480. def assign_init(self, user_root):
  481. user_frame, = yield [("RD", [user_root, "frame"])]
  482. evalstack, evalstack_link, ip_link, inst = \
  483. yield [("RD", [user_frame, "evalstack"]),
  484. ("RDE", [user_frame, "evalstack"]),
  485. ("RDE", [user_frame, "IP"]),
  486. ("RD", [user_frame, "IP"]),
  487. ]
  488. var, new_evalstack, new_phase = \
  489. yield [("RD", [inst, "var"]),
  490. ("CN", []),
  491. ("CNV", ["value"]),
  492. ]
  493. _, _, _, _, _, _, _ = \
  494. yield [("CD", [user_frame, "IP", var]),
  495. ("CD", [user_frame, "evalstack", new_evalstack]),
  496. ("CD", [new_evalstack, "prev", evalstack]),
  497. ("CD", [evalstack, "inst", inst]),
  498. ("CD", [evalstack, "phase", new_phase]),
  499. ("DE", [evalstack_link]),
  500. ("DE", [ip_link]),
  501. ]
  502. def assign_value(self, user_root):
  503. user_frame, = yield [("RD", [user_root, "frame"])]
  504. phase_link, evalstack, returnvalue, evalstack_link, ip_link, inst = \
  505. yield [("RDE", [user_frame, "phase"]),
  506. ("RD", [user_frame, "evalstack"]),
  507. ("RD", [user_frame, "returnvalue"]),
  508. ("RDE", [user_frame, "evalstack"]),
  509. ("RDE", [user_frame, "IP"]),
  510. ("RD", [user_frame, "IP"]),
  511. ]
  512. value, new_evalstack, new_phase, evalstack_phase = \
  513. yield [("RD", [inst, "value"]),
  514. ("CN", []),
  515. ("CNV", ["init"]),
  516. ("CNV", ["assign"]),
  517. ]
  518. _, _, _, _, _, _, _, _, _, _ = \
  519. yield [("CD", [user_frame, "variable", returnvalue]),
  520. ("CD", [user_frame, "phase", new_phase]),
  521. ("CD", [user_frame, "evalstack", new_evalstack]),
  522. ("CD", [new_evalstack, "prev", evalstack]),
  523. ("CD", [evalstack, "inst", inst]),
  524. ("CD", [evalstack, "phase", evalstack_phase]),
  525. ("CD", [user_frame, "IP", value]),
  526. ("DE", [evalstack_link]),
  527. ("DE", [phase_link]),
  528. ("DE", [ip_link]),
  529. ]
  530. def assign_assign(self, user_root):
  531. user_frame, = yield [("RD", [user_root, "frame"])]
  532. phase_link, returnvalue, variable_link, variable = \
  533. yield [("RDE", [user_frame, "phase"]),
  534. ("RD", [user_frame, "returnvalue"]),
  535. ("RDE", [user_frame, "variable"]),
  536. ("RD", [user_frame, "variable"]),
  537. ]
  538. value_link, new_phase = \
  539. yield [("RDE", [variable, "value"]),
  540. ("CNV", ["finish"]),
  541. ]
  542. _, _, _, _, _ = yield [("CD", [user_frame, "phase", new_phase]),
  543. ("CD", [variable, "value", returnvalue]),
  544. ("DE", [variable_link]),
  545. ("DE", [value_link]),
  546. ("DE", [phase_link]),
  547. ]
  548. def return_init(self, user_root):
  549. user_frame, = yield [("RD", [user_root, "frame"])]
  550. inst, = yield [("RD", [user_frame, "IP"])]
  551. value, = yield [("RD", [inst, "value"])]
  552. if value is None:
  553. prev_frame, = yield [("RD", [user_frame, "prev"])]
  554. # If the callee's frame is marked with the '__exception_return' key, then
  555. # we need to throw an exception instead of just finishing here. This design
  556. # gives us O(1) state reads per jit-interpreter transition.
  557. exception_return, = yield [("RD", [user_frame, primitive_functions.EXCEPTION_RETURN_KEY])]
  558. if prev_frame is None:
  559. _, = yield [("DN", [user_root])]
  560. del self.debug_info[self.username]
  561. else:
  562. if self.debug_info[self.username]:
  563. self.debug_info[self.username].pop()
  564. _, _ = yield [("CD", [user_root, "frame", prev_frame]),
  565. ("DN", [user_frame]),
  566. ]
  567. if exception_return is not None:
  568. raise primitive_functions.InterpretedFunctionFinished(None)
  569. else:
  570. evalstack, evalstack_link, ip_link, new_evalstack, evalstack_phase = \
  571. yield [("RD", [user_frame, "evalstack"]),
  572. ("RDE", [user_frame, "evalstack"]),
  573. ("RDE", [user_frame, "IP"]),
  574. ("CN", []),
  575. ("CNV", ["eval"]),
  576. ]
  577. _, _, _, _, _, _, _ = \
  578. yield [("CD", [user_frame, "evalstack", new_evalstack]),
  579. ("CD", [new_evalstack, "prev", evalstack]),
  580. ("CD", [evalstack, "inst", inst]),
  581. ("CD", [evalstack, "phase", evalstack_phase]),
  582. ("CD", [user_frame, "IP", value]),
  583. ("DE", [evalstack_link]),
  584. ("DE", [ip_link]),
  585. ]
  586. def return_eval(self, user_root):
  587. if self.debug_info[self.username]:
  588. self.debug_info[self.username].pop()
  589. user_frame, = yield [("RD", [user_root, "frame"])]
  590. prev_frame, exception_return, returnvalue = yield [
  591. ("RD", [user_frame, "prev"]),
  592. ("RD", [user_frame, primitive_functions.EXCEPTION_RETURN_KEY]),
  593. ("RD", [user_frame, "returnvalue"])]
  594. # If the callee's frame is marked with the '__exception_return' key, then
  595. # we need to throw an exception instead of just finishing here. This design
  596. # gives us O(1) state reads per jit-interpreter transition.
  597. if exception_return is not None:
  598. yield [
  599. ("CD", [user_root, "frame", prev_frame]),
  600. ("DN", [user_frame])]
  601. raise primitive_functions.InterpretedFunctionFinished(returnvalue)
  602. else:
  603. old_returnvalue_link, = yield [("RDE", [prev_frame, "returnvalue"])]
  604. yield [
  605. ("CD", [user_root, "frame", prev_frame]),
  606. ("CD", [prev_frame, "returnvalue", returnvalue]),
  607. ("DE", [old_returnvalue_link]),
  608. ("DN", [user_frame])]
  609. def constant_init(self, user_root):
  610. user_frame, = yield [("RD", [user_root, "frame"])]
  611. phase_link, returnvalue_link, inst = \
  612. yield [("RDE", [user_frame, "phase"]),
  613. ("RDE", [user_frame, "returnvalue"]),
  614. ("RD", [user_frame, "IP"]),
  615. ]
  616. node, new_phase = yield [("RD", [inst, "node"]),
  617. ("CNV", ["finish"]),
  618. ]
  619. _, _, _, _ = yield [("CD", [user_frame, "phase", new_phase]),
  620. ("CD", [user_frame, "returnvalue", node]),
  621. ("DE", [returnvalue_link]),
  622. ("DE", [phase_link]),
  623. ]
  624. def helper_init(self, user_root):
  625. user_frame, = yield [("RD", [user_root, "frame"])]
  626. inst, = yield [("RD", [user_frame, "IP"])]
  627. next, = yield [("RD", [inst, "next"])]
  628. if next is None:
  629. ip_link, phase_link, evalstack_top = \
  630. yield [("RDE", [user_frame, "IP"]),
  631. ("RDE", [user_frame, "phase"]),
  632. ("RD", [user_frame, "evalstack"]),
  633. ]
  634. evalstack, = yield [("RD", [evalstack_top, "prev"])]
  635. evalstack_inst, evalstack_phase, evalstack_inst_link, evalstack_phase_link = \
  636. yield [("RD", [evalstack, "inst"]),
  637. ("RD", [evalstack, "phase"]),
  638. ("RDE", [evalstack, "inst"]),
  639. ("RDE", [evalstack, "phase"]),
  640. ]
  641. _, _, _, _, _, _, _, _ = \
  642. yield [("CD", [user_frame, "evalstack", evalstack]),
  643. ("CD", [user_frame, "IP", evalstack_inst]),
  644. ("CD", [user_frame, "phase", evalstack_phase]),
  645. ("DE", [ip_link]),
  646. ("DE", [phase_link]),
  647. ("DE", [evalstack_inst_link]),
  648. ("DE", [evalstack_phase_link]),
  649. ("DN", [evalstack_top]),
  650. ]
  651. else:
  652. ip_link, phase_link, new_phase = \
  653. yield [("RDE", [user_frame, "IP"]),
  654. ("RDE", [user_frame, "phase"]),
  655. ("CNV", ["init"]),
  656. ]
  657. _, _, _, _ = yield [("CD", [user_frame, "IP", next]),
  658. ("CD", [user_frame, "phase", new_phase]),
  659. ("DE", [ip_link]),
  660. ("DE", [phase_link]),
  661. ]
  662. def call_init(self, user_root):
  663. user_frame, = yield [("RD", [user_root, "frame"])]
  664. symbols, evalstack, evalstack_link, ip_link, inst = \
  665. yield [("RD", [user_frame, "symbols"]),
  666. ("RD", [user_frame, "evalstack"]),
  667. ("RDE", [user_frame, "evalstack"]),
  668. ("RDE", [user_frame, "IP"]),
  669. ("RD", [user_frame, "IP"]),
  670. ]
  671. func, params = yield [("RD", [inst, "func"]),
  672. ("RD", [inst, "params"]),
  673. ]
  674. if params is None:
  675. new_evalstack, evalstack_phase = \
  676. yield [("CN", []),
  677. ("CNV", ["call"]),
  678. ]
  679. _, _, _, _, _, _, _ = \
  680. yield [("CD", [user_frame, "evalstack", new_evalstack]),
  681. ("CD", [new_evalstack, "prev", evalstack]),
  682. ("CD", [evalstack, "inst", inst]),
  683. ("CD", [evalstack, "phase", evalstack_phase]),
  684. ("CD", [user_frame, "IP", func]),
  685. ("DE", [evalstack_link]),
  686. ("DE", [ip_link]),
  687. ]
  688. else:
  689. new_evalstack,= yield [("CN", [])]
  690. _, _, _, _, _, _, _ = \
  691. yield [("CD", [user_frame, "evalstack", new_evalstack]),
  692. ("CD", [new_evalstack, "prev", evalstack]),
  693. ("CD", [evalstack, "inst", inst]),
  694. ("CD", [evalstack, "phase", params]),
  695. ("CD", [user_frame, "IP", func]),
  696. ("DE", [evalstack_link]),
  697. ("DE", [ip_link]),
  698. ]
  699. def call_call(self, user_root):
  700. self.debug_info[self.username].append("None")
  701. user_frame, = yield [("RD", [user_root, "frame"])]
  702. inst, = yield [("RD", [user_frame, "IP"])]
  703. param, = yield [("RD", [inst, "last_param"])]
  704. if param is None:
  705. returnvalue, = yield [("RD", [user_frame, "returnvalue"])]
  706. body, = yield [("RD", [returnvalue, "body"])]
  707. self.jit.mark_entry_point(body)
  708. phase_link, frame_link, prev_phase, new_phase, new_frame, new_evalstack, new_symbols, new_returnvalue = \
  709. yield [("RDE", [user_frame, "phase"]),
  710. ("RDE", [user_root, "frame"]),
  711. ("CNV", ["finish"]),
  712. ("CNV", ["init"]),
  713. ("CN", []),
  714. ("CN", []),
  715. ("CN", []),
  716. ("CN", []),
  717. ]
  718. _, _, _, _, _, _, _, _, _, _, _ = \
  719. yield [("CD", [user_root, "frame", new_frame]),
  720. ("CD", [new_frame, "evalstack", new_evalstack]),
  721. ("CD", [new_frame, "symbols", new_symbols]),
  722. ("CD", [new_frame, "returnvalue", new_returnvalue]),
  723. ("CD", [new_frame, "caller", inst]),
  724. ("CD", [new_frame, "phase", new_phase]),
  725. ("CD", [new_frame, "IP", body]),
  726. ("CD", [new_frame, "prev", user_frame]),
  727. ("CD", [user_frame, "phase", prev_phase]),
  728. ("DE", [phase_link]),
  729. ("DE", [frame_link]),
  730. ]
  731. else:
  732. newer_frames, invoking_frames = \
  733. yield [("RRD", [user_frame, "prev"]),
  734. ("RRD", [inst, "caller"]),
  735. ]
  736. new_frame = self.find_overlapping(newer_frames, invoking_frames)
  737. phase_link, frame_link, new_symbols, new_IP = \
  738. yield [("RDE", [user_frame, "phase"]),
  739. ("RDE", [user_root, "frame"]),
  740. ("RD", [new_frame, "symbols"]),
  741. ("RD", [new_frame, "IP"]),
  742. ]
  743. signature, = yield [("RRD", [new_IP, "body"])]
  744. signature = signature[0]
  745. sig_params, last_param = \
  746. yield [("RD", [signature, "params"]),
  747. ("RD", [inst, "last_param"]),
  748. ]
  749. body, = yield [("RD", [new_IP, "body"])]
  750. self.jit.mark_entry_point(body)
  751. name, = yield [("RD", [last_param, "name"])]
  752. name_value, = yield [("RV", [name])]
  753. returnvalue, formal_parameter, new_phase, variable = \
  754. yield [("RD", [user_frame, "returnvalue"]),
  755. ("RD", [sig_params, name_value]),
  756. ("CNV", ["finish"]),
  757. ("CN", []),
  758. ]
  759. _, _, _, t1 = yield [("CD", [user_root, "frame", new_frame]),
  760. ("CD", [user_frame, "phase", new_phase]),
  761. ("CD", [variable, "value", returnvalue]),
  762. ("CE", [new_symbols, variable]),
  763. ]
  764. _, _, _ = yield [("CE", [t1, formal_parameter]),
  765. ("DE", [frame_link]),
  766. ("DE", [phase_link]),
  767. ]
  768. def find_overlapping(self, a, b):
  769. newer_frames = set(a)
  770. invoking_frames = set(b)
  771. matches = list(newer_frames.intersection(invoking_frames))
  772. if len(matches) == 1:
  773. return matches[0]
  774. elif len(matches) > 1:
  775. raise Exception("Error: multiple overlapping elements")
  776. else:
  777. raise Exception("Error: could not find any overlap")
  778. def call_param(self, user_root):
  779. user_frame, = yield [("RD", [user_root, "frame"])]
  780. inst, phase = yield [("RD", [user_frame, "IP"]),
  781. ("RD", [user_frame, "phase"]),
  782. ]
  783. params, last_param = \
  784. yield [("RD", [inst, "params"]),
  785. ("RD", [inst, "last_param"]),
  786. ]
  787. next_param, = yield [("RD", [params, "next_param"])]
  788. if params == phase:
  789. phase_link, ip_link, returnvalue, param_value, evalstack, evalstack_link = \
  790. yield [("RDE", [user_frame, "phase"]),
  791. ("RDE", [user_frame, "IP"]),
  792. ("RD", [user_frame, "returnvalue"]),
  793. ("RD", [params, "value"]),
  794. ("RD", [user_frame, "evalstack"]),
  795. ("RDE", [user_frame, "evalstack"]),
  796. ]
  797. body, = yield [("RD", [returnvalue, "body"])]
  798. new_frame, prev_evalstack, new_phase, prev_phase, new_evalstack, new_symbols, new_returnvalue = \
  799. yield [("CN", []),
  800. ("CN", []),
  801. ("CNV", ["init"]),
  802. ("CNV", ["init"]),
  803. ("CN", []),
  804. ("CN", []),
  805. ("CN", []),
  806. ]
  807. _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = \
  808. yield [("CD", [new_frame, "evalstack", new_evalstack]),
  809. ("CD", [new_frame, "symbols", new_symbols]),
  810. ("CD", [new_frame, "returnvalue", new_returnvalue]),
  811. ("CD", [new_frame, "caller", inst]),
  812. ("CD", [new_frame, "phase", new_phase]),
  813. ("CD", [new_frame, "IP", body]),
  814. ("CD", [new_frame, "prev", user_frame]),
  815. ("CD", [user_frame, "phase", prev_phase]),
  816. ("CD", [user_frame, "IP", param_value]),
  817. ("CD", [prev_evalstack, "prev", evalstack]),
  818. ("CD", [evalstack, "inst", inst]),
  819. ("CD", [user_frame, "evalstack", prev_evalstack]),
  820. ("DE", [evalstack_link]),
  821. ("DE", [ip_link]),
  822. ("DE", [phase_link]),
  823. ]
  824. if next_param is not None:
  825. _ = yield [("CD", [evalstack, "phase", next_param])]
  826. else:
  827. evalstack_phase, = \
  828. yield [("CNV", ["call"])]
  829. _ = yield [("CD", [evalstack, "phase", evalstack_phase])]
  830. else:
  831. frame_link, phase_link, newer_frames, invoking_frames = \
  832. yield [("RDE", [user_root, "frame"]),
  833. ("RDE", [user_frame, "phase"]),
  834. ("RRD", [user_frame, "prev"]),
  835. ("RRD", [inst, "caller"]),
  836. ]
  837. new_frame = self.find_overlapping(newer_frames, invoking_frames)
  838. ip_link, evalstack, evalstack_link, new_symbols, new_IP = \
  839. yield [("RDE", [user_frame, "IP"]),
  840. ("RD", [user_frame, "evalstack"]),
  841. ("RDE", [user_frame, "evalstack"]),
  842. ("RD", [new_frame, "symbols"]),
  843. ("RD", [new_frame, "IP"]),
  844. ]
  845. signature, = yield [("RRD", [new_IP, "body"])]
  846. signature = signature[0]
  847. sig_params, = yield [("RD", [signature, "params"])]
  848. if last_param == phase:
  849. prev_param, = \
  850. yield [("RRD", [last_param, "next_param"])]
  851. prev_param = prev_param[0]
  852. name, = yield [("RD", [prev_param, "name"])]
  853. name_value, = \
  854. yield [("RV", [name])]
  855. evalstack_phase, = \
  856. yield [("CNV", ["call"])]
  857. _ = yield [("CD", [evalstack, "phase", evalstack_phase])]
  858. formal_parameter, param_value = \
  859. yield [("RD", [sig_params, name_value]),
  860. ("RD", [last_param, "value"]),
  861. ]
  862. else:
  863. param_b, = yield [("RD", [user_frame, "phase"])]
  864. param_c, param_a = \
  865. yield [("RD", [param_b, "next_param"]),
  866. ("RRD", [param_b, "next_param"]),
  867. ]
  868. param_a = param_a[0]
  869. name, param_value = \
  870. yield [("RD", [param_a, "name"]),
  871. ("RD", [param_b, "value"]),
  872. ]
  873. name_value, = \
  874. yield [("RV", [name])]
  875. formal_parameter, _ = \
  876. yield [("RD", [sig_params, name_value]),
  877. ("CD", [evalstack, "phase", param_c]),
  878. ]
  879. new_phase, new_evalstack, variable, returnvalue = \
  880. yield [("CNV", ["init"]),
  881. ("CN", []),
  882. ("CN", []),
  883. ("RD", [user_frame, "returnvalue"]),
  884. ]
  885. _, _, _, _, _, _ = \
  886. yield [("CD", [user_frame, "evalstack", new_evalstack]),
  887. ("CD", [new_evalstack, "prev", evalstack]),
  888. ("CD", [evalstack, "inst", inst]),
  889. ("CD", [user_frame, "phase", new_phase]),
  890. ("CD", [user_frame, "IP", param_value]),
  891. ("CD", [variable, "value", returnvalue]),
  892. ]
  893. t1, = yield [("CE", [new_symbols, variable])]
  894. _, _, _, _ = \
  895. yield [("CE", [t1, formal_parameter]),
  896. ("DE", [phase_link]),
  897. ("DE", [ip_link]),
  898. ("DE", [evalstack_link]),
  899. ]
  900. def input_init(self, user_root):
  901. user_frame, = yield [("RD", [user_root, "frame"])]
  902. returnvalue_link, _input = \
  903. yield [("RDE", [user_frame, "returnvalue"]),
  904. ("RD", [user_root, "input"]),
  905. ]
  906. value, next, phase_link = \
  907. yield [("RD", [_input, "value"]),
  908. ("RD", [_input, "next"]),
  909. ("RDE", [user_frame, "phase"]),
  910. ]
  911. if value is not None:
  912. v = yield [("RV", [value])]
  913. _, _, finish = \
  914. yield [("CD", [user_frame, "returnvalue", value]),
  915. ("CD", [user_root, "input", next]),
  916. ("CNV", ["finish"]),
  917. ]
  918. _, _, _, _ = \
  919. yield [("CD", [user_frame, "phase", finish]),
  920. ("DN", [_input]),
  921. ("DE", [returnvalue_link]),
  922. ("DE", [phase_link]),
  923. ]
  924. self.input_value = value
  925. else:
  926. # No input yet, so just wait and don't advance IP or phase
  927. self.input_value = None
  928. self.success = False
  929. def output_init(self, user_root):
  930. user_frame, = yield [("RD", [user_root, "frame"])]
  931. evalstack, evalstack_link, ip_link, inst = \
  932. yield [("RD", [user_frame, "evalstack"]),
  933. ("RDE", [user_frame, "evalstack"]),
  934. ("RDE", [user_frame, "IP"]),
  935. ("RD", [user_frame, "IP"]),
  936. ]
  937. value, new_evalstack, evalstack_phase = \
  938. yield [("RD", [inst, "value"]),
  939. ("CN", []),
  940. ("CNV", ["output"]),
  941. ]
  942. _, _, _, _, _, _, _ = \
  943. yield [("CD", [user_frame, "evalstack", new_evalstack]),
  944. ("CD", [new_evalstack, "prev", evalstack]),
  945. ("CD", [evalstack, "inst", inst]),
  946. ("CD", [evalstack, "phase", evalstack_phase]),
  947. ("CD", [user_frame, "IP", value]),
  948. ("DE", [evalstack_link]),
  949. ("DE", [ip_link]),
  950. ]
  951. def output_output(self, user_root):
  952. user_frame, = yield [("RD", [user_root, "frame"])]
  953. returnvalue_link, returnvalue, last_output, phase_link, last_output_link, new_last_output, finish = \
  954. yield [("RDE", [user_frame, "returnvalue"]),
  955. ("RD", [user_frame, "returnvalue"]),
  956. ("RD", [user_root, "last_output"]),
  957. ("RDE", [user_frame, "phase"]),
  958. ("RDE", [user_root, "last_output"]),
  959. ("CN", []),
  960. ("CNV", ["finish"]),
  961. ]
  962. _, _, _, _, _, _ = \
  963. yield [("CD", [last_output, "value", returnvalue]),
  964. ("CD", [last_output, "next", new_last_output]),
  965. ("CD", [user_root, "last_output", new_last_output]),
  966. ("CD", [user_frame, "phase", finish]),
  967. ("DE", [last_output_link]),
  968. ("DE", [phase_link]),
  969. ]
  970. def declare_init(self, user_root):
  971. user_frame, = yield [("RD", [user_root, "frame"])]
  972. inst, = yield [("RD", [user_frame, "IP"])]
  973. new_var, symbols, phase_link, empty_node, new_phase = \
  974. yield [("RD", [inst, "var"]),
  975. ("RD", [user_frame, "symbols"]),
  976. ("RDE", [user_frame, "phase"]),
  977. ("CN", []),
  978. ("CNV", ["finish"]),
  979. ]
  980. exists, = yield [("RDN", [symbols, new_var])]
  981. if exists is None:
  982. new_edge, = yield [("CE", [symbols, empty_node])]
  983. _ = yield [("CE", [new_edge, new_var])]
  984. _, _ = yield [("CD", [user_frame, "phase", new_phase]),
  985. ("DE", [phase_link]),
  986. ]
  987. def global_init(self, user_root):
  988. user_frame, = yield [("RD", [user_root, "frame"])]
  989. inst, = yield [("RD", [user_frame, "IP"])]
  990. new_var, global_symbols, phase_link, empty_node, new_phase = \
  991. yield [("RD", [inst, "var"]),
  992. ("RD", [user_root, "globals"]),
  993. ("RDE", [user_frame, "phase"]),
  994. ("CN", []),
  995. ("CNV", ["finish"]),
  996. ]
  997. value, = yield [("RV", [new_var])]
  998. exists, = yield [("RD", [global_symbols, value])]
  999. if exists is None:
  1000. yield [("CD", [global_symbols, value, empty_node])]
  1001. _, _ = yield [("CD", [user_frame, "phase", new_phase]),
  1002. ("DE", [phase_link])
  1003. ]