main.py 74 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477
  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_kernel.jit as jit
  5. from collections import defaultdict
  6. import sys
  7. import time
  8. if sys.version > '3': # pragma: no cover
  9. string_types = (str,)
  10. else:
  11. string_types = (str, unicode)
  12. class ModelverseKernel(object):
  13. counter = 0
  14. def __init__(self, root):
  15. self.root = root
  16. self.returnvalue = None
  17. # request_handlers is a dictionary of tasknames to dictionaries of operations
  18. # to request handlers. In generics notation:
  19. #
  20. # Dictionary<
  21. # Username,
  22. # Dictionary<
  23. # Operation,
  24. # RequestHandler>>
  25. #
  26. self.request_handlers = {}
  27. self.allow_compiled = True
  28. # `self.jit` handles most JIT-related functionality.
  29. self.jit = jit.ModelverseJit()
  30. self.jit.compiled_function_lookup = lambda func_name : getattr(compiled_functions, func_name, None)
  31. self.jit.body_cache = {}
  32. self.debug_info = defaultdict(list)
  33. def try_to_protect(self, var):
  34. if isinstance(var, dict) and "id" in var and var['id'] is not None:
  35. return set([var['id']])
  36. elif type(var) == int:
  37. return set([var])
  38. elif isinstance(var, dict):
  39. protect = set()
  40. for v in var.values():
  41. protect |= self.try_to_protect(v)
  42. return protect
  43. elif isinstance(var, list):
  44. protect = set()
  45. for v in var:
  46. protect |= self.try_to_protect(v)
  47. return protect
  48. elif isinstance(var, set):
  49. protect = set()
  50. for v in var:
  51. protect |= self.try_to_protect(v)
  52. return protect
  53. return set()
  54. def protect_temporary_variables(self, taskname):
  55. generators = []
  56. for h in self.request_handlers.values():
  57. for handler in h.values():
  58. for generator in handler.generator_stack:
  59. generators.append(generator)
  60. to_protect = set()
  61. for gen in generators:
  62. try:
  63. variables = gen.gi_frame.f_locals
  64. for var in variables.values():
  65. to_protect |= self.try_to_protect(var)
  66. except:
  67. pass
  68. # Create the node to which everything is attached
  69. self.fixed_node, = yield [("CN", [])]
  70. yield [("CE", [self.root, self.fixed_node])]
  71. yield [("CE", [self.fixed_node, node]) for node in to_protect]
  72. yield [("RETURN", [None])]
  73. def unprotect_temporary_variables(self, taskname):
  74. yield [("DN", [self.fixed_node])]
  75. yield [("RETURN", [None])]
  76. def execute_yields(self, taskname, operation, params, reply):
  77. self.taskname = taskname
  78. if taskname not in self.request_handlers:
  79. self.request_handlers[taskname] = {}
  80. self.jit.cache.setdefault(taskname, {})
  81. if operation not in self.request_handlers[taskname]:
  82. # Create the generator for the function to execute
  83. self.request_handlers[taskname][operation] = RequestHandler()
  84. handler = self.request_handlers[taskname][operation]
  85. if len(handler.generator_stack) == 0:
  86. handler.push_generator(getattr(self, operation)(taskname, *params))
  87. return handler.handle_request(reply)
  88. def execute_rule(self, taskname):
  89. task_root, = yield [("RD", [self.root, taskname])]
  90. if task_root is None:
  91. yield None
  92. else:
  93. task_frame, = yield [("RD", [task_root, "frame"])]
  94. self.inst, phase = yield [("RD", [task_frame, "IP"]),
  95. ("RD", [task_frame, "phase"]),
  96. ]
  97. self.new_debug, self.phase_v, inst_v = \
  98. yield [("RD", [self.inst, "__debug"]),
  99. ("RV", [phase]),
  100. ("RV", [self.inst]),
  101. ]
  102. if self.new_debug is not None:
  103. if self.debug_info[taskname]:
  104. self.debug_info[taskname][-1], = yield [("RV", [self.new_debug])]
  105. if self.phase_v == "finish":
  106. gen = self.helper_init(task_root)
  107. elif self.inst is None:
  108. raise Exception("Instruction pointer could not be found!")
  109. elif isinstance(self.phase_v, string_types):
  110. if self.phase_v == "init" and self.jit.is_jittable_entry_point(self.inst):
  111. #print("%-30s(%s)" % ("COMPILED " + str(self.jit.jitted_entry_points[self.inst]), phase_v))
  112. gen = self.execute_jit(task_root, self.inst, taskname, store=True, resolve=False)
  113. elif inst_v is None:
  114. raise Exception("%s: error understanding command (%s, %s)" % (self.debug_info[taskname], inst_v, self.phase_v))
  115. else:
  116. #print("%-30s(%s) -- %s" % (inst_v["value"], self.phase_v, taskname))
  117. gen = self.get_inst_phase_generator(inst_v, self.phase_v, task_root)
  118. elif inst_v is None:
  119. raise Exception("%s: error understanding command (%s, %s)" % (self.debug_info[taskname], inst_v, self.phase_v))
  120. elif inst_v["value"] == "call":
  121. #print("%-30s(%s)" % ("call", "param"))
  122. gen = self.call_param(task_root)
  123. else:
  124. raise Exception("%s: error understanding command (%s, %s)" % (self.debug_info[taskname], inst_v, self.phase_v))
  125. yield [("CALL", [gen])]
  126. yield [("FINISH", [])]
  127. def get_inst_phase_generator(self, inst_v, phase_v, task_root):
  128. """Gets a generator for the given instruction in the given phase,
  129. for the specified task root."""
  130. #print("%-30s(%s) -- %s" % (inst_v["value"], phase_v, taskname))
  131. return getattr(self, "%s_%s" % (inst_v["value"], phase_v))(task_root)
  132. ##########################
  133. ### Process primitives ###
  134. ##########################
  135. def load_primitives(self, taskname):
  136. yield [("CALL_ARGS", [self.load_primitives_from, (taskname, 'primitives', primitive_functions)])]
  137. yield [("FINISH", [])]
  138. def load_primitives_from(self, taskname, source_name, source):
  139. hierarchy, = yield [("RD", [self.root, "__hierarchy"])]
  140. primitives, = yield [("RD", [hierarchy, source_name])]
  141. keys, = yield [("RDK", [primitives])]
  142. function_names = yield [("RV", [f]) for f in keys]
  143. signatures = yield [("RDN", [primitives, f]) for f in keys]
  144. bodies = yield [("RD", [f, "body"]) for f in signatures]
  145. for i in range(len(keys)):
  146. self.jit.register_compiled(bodies[i], getattr(source, function_names[i]), function_names[i])
  147. yield [("RETURN", [None])]
  148. def print_instruction(self, inst, indent, nested_indent=None):
  149. """
  150. intrinsics = {"integer_addition": (lambda x, y: "(%s + %s)" % (x, y)),
  151. "string_join": (lambda x, y: "(str(%s) + str(%s))" % (x, y)),
  152. }
  153. """
  154. intrinsics = {}
  155. if nested_indent is None:
  156. nested_indent = indent
  157. inst_type, = yield [("RV", [inst])]
  158. instruction = "(no_printer_for_%s)" % inst_type["value"]
  159. prev = ""
  160. if inst_type["value"] == "if":
  161. cond, true, false = yield [("RD", [inst, "cond"]),
  162. ("RD", [inst, "then"]),
  163. ("RD", [inst, "else"])]
  164. (prev_cond, instruction_cond), = yield [("CALL_ARGS", [self.print_instruction, (cond, 0, indent)])]
  165. (prev_true, instruction_true), = yield [("CALL_ARGS", [self.print_instruction, (true, indent+1)])]
  166. if false:
  167. (prev_false, instruction_false), = yield [("CALL_ARGS", [self.print_instruction, (false, indent+1)])]
  168. false = (" " * indent + "else:\n%s%s") % (prev_false, instruction_false)
  169. else:
  170. false = ""
  171. instruction = prev_cond + \
  172. " " * indent + "if 'value' not in %s:\n" % instruction_cond + \
  173. " " * (indent + 1) + "%s['value'], = yield [('RV', [%s['id']])]\n" % (instruction_cond, instruction_cond) + \
  174. " " * indent + "if (%s['value']):\n" % instruction_cond + \
  175. prev_true + \
  176. instruction_true + \
  177. false
  178. elif inst_type["value"] == "constant":
  179. node, = yield [("RD", [inst, "node"])]
  180. node_value, = yield [("RV", [node])]
  181. if node_value is not None:
  182. # There is a value to the node, so replicate the value
  183. if isinstance(node_value, string_types):
  184. value = '"%s"' % node_value.replace('"', '\\"').replace("'", "\\'").replace('\t', '\\t').replace('\n', '\\n')
  185. else:
  186. value = str(node_value)
  187. instruction = "constant_" + str(ModelverseKernel.counter)
  188. ModelverseKernel.counter += 1
  189. prev = " " * nested_indent + instruction + " = {'value': " + value + "}\n"
  190. else:
  191. # Node is None, meaning that it was not about the value, but the node itself...
  192. instruction = "{'id': %s}" % str(node)
  193. elif inst_type["value"] == "return":
  194. value, = yield [("RD", [inst, "value"])]
  195. if value:
  196. (prev_value, instruction_value), = yield [("CALL_ARGS", [self.print_instruction, (value, 0, indent)])]
  197. instruction = prev_value + " " * indent + "yield [('RETURN', [%s])]\n" % instruction_value
  198. else:
  199. instruction = " " * indent + "yield [('RETURN', [None])]\n"
  200. elif inst_type["value"] == "declare":
  201. instruction = ""
  202. elif inst_type["value"] == "global":
  203. instruction = ""
  204. elif inst_type["value"] == "break":
  205. instruction = " " * indent + "break\n"
  206. elif inst_type["value"] == "continue":
  207. instruction = " " * indent + "continue\n"
  208. elif inst_type["value"] == "input":
  209. prev = " " * nested_indent + "_inputs, = yield [('RD', [_root, 'input'])]\n" + \
  210. " " * nested_indent + "while 1:\n" + \
  211. " " * (nested_indent + 1) + "val, = yield [('RD', [_inputs, 'value'])]\n" + \
  212. " " * (nested_indent + 1) + "if val is not None:\n" + \
  213. " " * (nested_indent + 2) + "val_e, = yield [('RDE', [_inputs, 'value'])]\n" + \
  214. " " * (nested_indent + 2) + "_, val_e = yield [('DE', [val_e]), ('RDE', [_root, 'input'])]\n" + \
  215. " " * (nested_indent + 2) + "_, nxt = yield [('DE', [val_e]), ('RD', [_inputs, 'next'])]\n" + \
  216. " " * (nested_indent + 2) + "yield [('CD', [_root, 'input', nxt])]\n" + \
  217. " " * (nested_indent + 2) + "_result = {'id': val}\n" + \
  218. " " * (nested_indent + 2) + "break\n" + \
  219. " " * (nested_indent + 1) + "else:\n" + \
  220. " " * (nested_indent + 2) + "yield None\n"
  221. instruction = "_result"
  222. elif inst_type["value"] == "output":
  223. value, = yield [("RD", [inst, "value"])]
  224. (prev, instruction), = yield [("CALL_ARGS", [self.print_instruction, (value, 0, indent)])]
  225. instruction = prev + \
  226. " " * indent + "if 'id' not in %s:\n" % instruction + \
  227. " " * (indent + 1) + "%s['id'], = yield [('CNV', [%s['value']])]\n" % (instruction, instruction) + \
  228. " " * indent + "_outputs, _outputs_e = yield [('RD', [_root, 'last_output']), ('RDE', [_root, 'last_output'])]\n" + \
  229. " " * indent + "_, _new = yield [('CD', [_outputs, 'value', %s['id']]), ('CN', [])]\n" % instruction + \
  230. " " * indent + "yield [('CD', [_outputs, 'next', _new]), ('DE', [_outputs_e]), ('CD', [_root, 'last_output', _new])]\n"
  231. elif inst_type["value"] == "resolve":
  232. value, = yield [("RD", [inst, "var"])]
  233. str_value, = yield [("RV", [value])]
  234. if str_value:
  235. # Is a global
  236. prev = \
  237. " " * nested_indent + "%s = _mvk.jit.cache[_taskname].get('%s', None)\n" % (str_value, str_value) + \
  238. " " * nested_indent + "if %s is None:\n" % str_value + \
  239. " " * (nested_indent + 1) + "%s, = yield [('RD', [_globs, '%s'])]\n" % (str_value, str_value) + \
  240. " " * (nested_indent + 1) + "%s, = yield [('RD', [%s, 'value'])]\n" % (str_value, str_value) + \
  241. " " * (nested_indent + 1) + "%s = {'id': %s}\n" % (str_value, str_value) + \
  242. " " * (nested_indent + 1) + "_mvk.jit.cache[_taskname]['%s'] = %s\n" % (str_value, str_value)
  243. instruction = str_value
  244. if self.jit.get_global_body_id(str_value) is None:
  245. val, = yield [("RD", [self.root, self.taskname])]
  246. val, = yield [("RD", [val, 'globals'])]
  247. val, = yield [("RD", [val, str_value])]
  248. val, = yield [("RD", [val, 'value'])]
  249. val, = yield [("RD", [val, 'body'])]
  250. self.jit.register_global(val, str_value)
  251. else:
  252. # Is a local
  253. instruction = "var_%s" % value
  254. elif inst_type["value"] == "assign":
  255. var, val = yield [("RD", [inst, "var"]),
  256. ("RD", [inst, "value"])]
  257. (prev_var, instruction_var), = yield [("CALL_ARGS", [self.print_instruction, (var, 0, indent)])]
  258. (prev_val, instruction_val), = yield [("CALL_ARGS", [self.print_instruction, (val, 0, indent)])]
  259. instruction = prev_val + " " * indent + instruction_var + " = " + instruction_val + "\n"
  260. if prev_var:
  261. # Got something to do before the variable is usable, so this is a global!
  262. # Therefore we actually do the operation in the Modelverse as well!
  263. instruction += \
  264. " " * nested_indent + "_var, = yield [('RD', [_globs, '%s'])]\n" % instruction_var + \
  265. " " * nested_indent + "if _var is None:\n" + \
  266. " " * (nested_indent + 1) + "_var, = yield [('CN', [])]\n" + \
  267. " " * (nested_indent + 1) + "yield [('CD', [_globs, '%s', _var])]\n" % instruction_var + \
  268. " " * nested_indent + "_old_edge, = yield [('RDE', [_var, 'value'])]\n" + \
  269. " " * nested_indent + "if 'id' not in %s:\n" % instruction_var + \
  270. " " * (nested_indent + 1) + "%s['id'], = yield [('CNV', [%s['value']])]\n" % (instruction_var, instruction_var) + \
  271. " " * nested_indent + "yield [('CD', [_var, 'value', %s['id']]), ('DE', [_old_edge])]\n" % instruction_var + \
  272. " " * nested_indent + "_mvk.jit.cache[_taskname]['%s'] = %s\n" % (instruction_var, instruction_var)
  273. #" " * nested_indent + "_mvk.jit.register_global('%s', %s['id'])\n" % (instruction_var, instruction_var) + \
  274. elif inst_type["value"] == "call":
  275. func_name, = yield [("RD", [inst, "func"])]
  276. (prev_func_name, func_name), = yield [("CALL_ARGS", [self.print_instruction, (func_name, nested_indent, nested_indent)])]
  277. param_list = {}
  278. param, = yield [("RD", [inst, "params"])]
  279. computation = ""
  280. while param:
  281. value, = yield [("RD", [param, "value"])]
  282. name, = yield [("RD", [param, "name"])]
  283. name, = yield [("RV", [name])]
  284. (prev_res, instruction_res), = yield [("CALL_ARGS", [self.print_instruction, (value, 0, nested_indent)])]
  285. param, = yield [("RD", [param, "next_param"])]
  286. computation += prev_res
  287. param_list[name] = instruction_res
  288. value = "func_result_" + str(ModelverseKernel.counter)
  289. ModelverseKernel.counter += 1
  290. param_list = "{" + ", ".join(["'%s': %s" % (k, v) for k, v in param_list.items()]) + "}"
  291. actual_computation = "$$INDENT$$%s, = yield [('CALL_ARGS', [_mvk.execute_jit, (_root, %s['id'], _taskname, %s)])]\n" % (value, func_name, param_list)
  292. if indent == 0:
  293. # No indent, meaning that we use it inline
  294. # Therefore, we output the prev and value individually
  295. prev, instruction = prev_func_name + computation + actual_computation.replace("$$INDENT$$", " " * nested_indent), value
  296. else:
  297. # Some indentation, meaning that we don't even use the return value
  298. # Therefore, we only do the yield
  299. prev, instruction = prev_func_name + computation, actual_computation.replace("$$INDENT$$", " " * indent)
  300. elif inst_type["value"] == "access":
  301. value, = yield [("RD", [inst, "var"])]
  302. (prev, instruction), = yield [("CALL_ARGS", [self.print_instruction, (value, 0, nested_indent)])]
  303. elif inst_type["value"] == "while":
  304. cond, body = yield [("RD", [inst, "cond"]),
  305. ("RD", [inst, "body"])]
  306. (prev_cond, instruction_cond), = yield [("CALL_ARGS", [self.print_instruction, (cond, 0, indent+1)])]
  307. (prev_body, instruction_body), = yield [("CALL_ARGS", [self.print_instruction, (body, indent+1)])]
  308. instruction = " " * indent + "while 1:\n" + prev_cond + \
  309. " " * (indent + 1) + "if 'value' not in %s:\n" % instruction_cond + \
  310. " " * (indent + 2) + "%s['value'], = yield [('RV', [%s['id']])]\n" % (instruction_cond, instruction_cond) + \
  311. " " * (indent + 1) + "if not (%s['value']):\n" % instruction_cond + \
  312. " " * (indent + 2) + "break\n" + \
  313. " " * (indent + 1) + "else:\n" + \
  314. " " * (indent + 2) + "yield None\n" + \
  315. prev_body + instruction_body
  316. next_inst, = yield [("RD", [inst, "next"])]
  317. if next_inst:
  318. (prev_next, inst_next), = yield [("CALL_ARGS", [self.print_instruction, (next_inst, indent)])]
  319. next_inst = prev_next + inst_next
  320. else:
  321. next_inst = ""
  322. yield [('RETURN', [(prev, instruction + next_inst)])]
  323. def read_function(self, inst, suggested_name):
  324. initial_instruction = inst
  325. (params, _, is_mutable), = yield [("CALL_ARGS", [self.jit.jit_signature, (inst,)])]
  326. if is_mutable:
  327. print("Ignoring mutable or unreadable: %s" % suggested_name)
  328. raise jit.JitCompilationFailedException("FAIL")
  329. #print("Reading function: %s" % suggested_name)
  330. (prev, printed), = yield [("CALL_ARGS", [self.print_instruction, (inst, 1)])]
  331. preamble = " _globs, = yield [('RD', [kwargs['task_root'], 'globals'])]\n" + \
  332. " _root = kwargs['task_root']\n" + \
  333. " _taskname = kwargs['taskname']\n" + \
  334. " _mvk = kwargs['mvk']\n"
  335. printed = preamble + prev + printed
  336. #print("Total printed function: ")
  337. if params:
  338. func = "def " + suggested_name + "(" + ", ".join([chr(ord('a') + i) for i in range(len(params))]) + ", **kwargs):\n" + "".join([" var_%s = %s\n" % (param, chr(ord('a') + i)) for i, param in enumerate(params)]) + printed
  339. else:
  340. func = "def " + suggested_name + "(**kwargs):\n" + printed
  341. #print(func)
  342. # To write out all generated functions
  343. #with open('/tmp/junk/%s' % suggested_name, 'w') as f:
  344. # f.write(func)
  345. yield [("RETURN", [func])]
  346. def execute_jit(self, task_root, inst, taskname, params = {}, store=False, resolve=True):
  347. # execute_jit
  348. if resolve:
  349. try:
  350. inst = self.jit.body_cache[inst]
  351. except KeyError:
  352. body, = yield [("RD", [inst, "body"])]
  353. self.jit.body_cache[inst] = body
  354. inst = body
  355. if store:
  356. task_frame, = yield [("RD", [task_root, "frame"])]
  357. symbols, = yield [("RD", [task_frame, "symbols"])]
  358. dict_keys_ref, = yield [("RDK", [symbols])]
  359. if dict_keys_ref:
  360. dict_keys_ref_n = yield [("RD", [i, "name"]) for i in dict_keys_ref]
  361. dict_keys = yield [("RV", [i]) for i in dict_keys_ref_n]
  362. dict_values_elem = yield [("RDN", [symbols, i]) for i in dict_keys_ref]
  363. dict_values = yield [("RD", [i, "value"]) for i in dict_values_elem]
  364. parameters = dict(zip(dict_keys, dict_values))
  365. parameters.update(params)
  366. for p in parameters.keys():
  367. if not isinstance(parameters[p], dict):
  368. parameters[p] = {'id': parameters[p]}
  369. params = parameters
  370. params["root"] = self.root
  371. params["task_root"] = task_root
  372. params["taskname"] = taskname
  373. params["mvk"] = self
  374. # Have the JIT compile the function.
  375. if inst is None:
  376. suggested_name = self.jit.get_global_name(inst)
  377. if suggested_name is None:
  378. suggested_name = "func_%s" % str(inst)
  379. raise ValueError('body_id cannot be None: ' + str(suggested_name))
  380. elif inst in self.jit.jitted_entry_points:
  381. compiled_func = self.jit.jit_globals[self.jit.jitted_entry_points[inst]]
  382. else:
  383. compiled_func = self.jit.lookup_compiled_body(inst)
  384. if compiled_func is None:
  385. suggested_name = self.jit.get_global_name(inst)
  386. if suggested_name is None:
  387. suggested_name = "func_%s" % str(inst)
  388. compiled_func, = yield [("CALL_ARGS", [self.read_function, (inst, suggested_name)])]
  389. compiled_func = self.merge_function(compiled_func, suggested_name)
  390. self.jit.register_compiled(inst, compiled_func, suggested_name)
  391. # Run the compiled function.
  392. results = yield [("CALL_KWARGS", [compiled_func, params])]
  393. if results is None:
  394. raise Exception("%s: primitive finished without returning a value!" % (self.debug_info[taskname]))
  395. else:
  396. result, = results
  397. #print("Got result: " + str(result))
  398. if result is None:
  399. result = {'id': None, 'value': None}
  400. if store:
  401. # Clean up the current stack, as if a return happened
  402. old_frame, exception_return = yield [
  403. ("RD", [task_frame, "prev"]),
  404. ("RD", [task_frame, primitive_functions.EXCEPTION_RETURN_KEY])]
  405. #if self.debug_info[self.taskname]:
  406. # self.debug_info[self.taskname].pop()
  407. if "id" not in result:
  408. result['id'], = yield [("CNV", [result['value']])]
  409. if exception_return is not None:
  410. # The caller has requested that we throw an exception instead of injecting
  411. # the return value into the caller's frame. Read the comment at
  412. # primitive_functions.EXCEPTION_RETURN_KEY for the rationale behind this design.
  413. yield [("CD", [task_root, "frame", old_frame]),
  414. ("DN", [task_frame])]
  415. raise primitive_functions.InterpretedFunctionFinished(result)
  416. else:
  417. lnk, = yield [("RDE", [old_frame, "returnvalue"])]
  418. _, _, _, _ = yield [("CD", [old_frame, "returnvalue", result['id']]),
  419. ("CD", [task_root, "frame", old_frame]),
  420. ("DE", [lnk]),
  421. ("DN", [task_frame]),
  422. ]
  423. else:
  424. yield [("RETURN", [result])]
  425. yield [("RETURN", [None])]
  426. def merge_function(self, func, name):
  427. exec(func, self.jit.jit_globals)
  428. return self.jit.jit_globals[name]
  429. ########################################
  430. ### Execute input and output methods ###
  431. ########################################
  432. def get_output(self, taskname):
  433. task_root, = yield [("RD", [self.root, taskname])]
  434. first_output, = yield [("RD", [task_root, "output"])]
  435. next_output, rv = yield [("RD", [first_output, "next"]),
  436. ("RD", [first_output, "value"]),
  437. ]
  438. if next_output is None:
  439. self.success = False
  440. self.returnvalue = None
  441. else:
  442. rv_value, _, _ = \
  443. yield [("RV", [rv]),
  444. ("CD", [task_root, "output", next_output]),
  445. ("DN", [first_output]),
  446. ]
  447. self.returnvalue = rv_value
  448. self.success = True
  449. #print("OUTPUT: (%s, %s)" % (taskname, self.returnvalue))
  450. yield [("FINISH", [])]
  451. def set_input(self, taskname, value):
  452. task_root, = yield [("RD", [self.root, taskname])]
  453. old_input, link, new_input, new_value = \
  454. yield [("RD", [task_root, "last_input"]),
  455. ("RDE", [task_root, "last_input"]),
  456. ("CN", []),
  457. ("CNV", [value]),
  458. ]
  459. _, _, _, _ = yield [("CD", [task_root, "last_input", new_input]),
  460. ("CD", [old_input, "next", new_input]),
  461. ("CD", [old_input, "value", new_value]),
  462. ("DE", [link])
  463. ]
  464. #print("INPUT: (%s, %s)" % (taskname, value))
  465. self.returnvalue = {"id": 100, "value": "success"}
  466. yield [("FINISH", [])]
  467. #############################################
  468. ### Transformation rules for instructions ###
  469. #############################################
  470. def continue_init(self, task_root):
  471. task_frame, = yield [("RD", [task_root, "frame"])]
  472. inst, = yield [("RD", [task_frame, "IP"])]
  473. while_inst, = yield [("RD", [inst, "while"])]
  474. old_evalstack_link, old_phase_link, evalstack_roots = \
  475. yield [("RDE", [task_frame, "evalstack"]),
  476. ("RDE", [task_frame, "phase"]),
  477. ("RRD", [while_inst, self.taskname]),
  478. ]
  479. if len(evalstack_roots) == 1:
  480. evalstack_root = evalstack_roots[0]
  481. else:
  482. print("Got roots: " + str(evalstack_roots))
  483. raise Exception("Could not process continue statement!")
  484. prev_evalstack_roots, old_evalstack_phase_link = \
  485. yield [("RRD", [evalstack_root, "prev"]),
  486. ("RDE", [evalstack_root, "phase"]),
  487. ]
  488. if len(prev_evalstack_roots) == 1:
  489. prev_evalstack_root = prev_evalstack_roots[0]
  490. else:
  491. raise Exception("Could not process continue statement!")
  492. new_evalstack_root, new_phase_while, new_phase_inst, prev_evalstack_root_link = \
  493. yield [("CN", []),
  494. ("CNV", ["init"]),
  495. ("CNV", ["finish"]),
  496. ("RDE", [prev_evalstack_root, "prev"]),
  497. ]
  498. _, _, _, _, _, _, _, _ = \
  499. yield [("CD", [task_frame, "evalstack", new_evalstack_root]),
  500. ("CD", [new_evalstack_root, "prev", evalstack_root]),
  501. ("CD", [task_frame, "phase", new_phase_inst]),
  502. ("CD", [evalstack_root, "phase", new_phase_while]),
  503. ("DE", [old_evalstack_link]),
  504. ("DE", [prev_evalstack_root_link]),
  505. ("DE", [old_phase_link]),
  506. ("DE", [old_evalstack_phase_link]),
  507. ]
  508. yield [("RETURN", [None])]
  509. def break_init(self, task_root):
  510. task_frame, = yield [("RD", [task_root, "frame"])]
  511. inst, = yield [("RD", [task_frame, "IP"])]
  512. while_inst, = yield [("RD", [inst, "while"])]
  513. old_evalstack_link, old_phase_link, evalstack_roots = \
  514. yield [("RDE", [task_frame, "evalstack"]),
  515. ("RDE", [task_frame, "phase"]),
  516. ("RRD", [while_inst, self.taskname]),
  517. ]
  518. if len(evalstack_roots) == 1:
  519. evalstack_root = evalstack_roots[0]
  520. else:
  521. raise Exception("Could not process break statement!")
  522. prev_evalstack_roots, old_evalstack_phase_link = \
  523. yield [("RRD", [evalstack_root, "prev"]),
  524. ("RDE", [evalstack_root, "phase"]),
  525. ]
  526. if len(prev_evalstack_roots) == 1:
  527. prev_evalstack_root = prev_evalstack_roots[0]
  528. else:
  529. raise Exception("Could not process break statement!")
  530. new_evalstack_root, new_phase_while, new_phase_inst, prev_evalstack_root_link = \
  531. yield [("CN", []),
  532. ("CNV", ["finish"]),
  533. ("CNV", ["finish"]),
  534. ("RDE", [prev_evalstack_root, "prev"]),
  535. ]
  536. _, _, _, _, _, _, _, _ = \
  537. yield [("CD", [task_frame, "evalstack", new_evalstack_root]),
  538. ("CD", [new_evalstack_root, "prev", evalstack_root]),
  539. ("CD", [task_frame, "phase", new_phase_inst]),
  540. ("CD", [evalstack_root, "phase", new_phase_while]),
  541. ("DE", [old_evalstack_link]),
  542. ("DE", [prev_evalstack_root_link]),
  543. ("DE", [old_phase_link]),
  544. ("DE", [old_evalstack_phase_link]),
  545. ]
  546. yield [("RETURN", [None])]
  547. def if_init(self, task_root):
  548. task_frame, = yield [("RD", [task_root, "frame"])]
  549. evalstack, evalstack_link = \
  550. yield [("RD", [task_frame, "evalstack"]),
  551. ("RDE", [task_frame, "evalstack"]),
  552. ]
  553. inst, ip_link = yield [("RD", [task_frame, "IP"]),
  554. ("RDE", [task_frame, "IP"]),
  555. ]
  556. cond, = yield [("RD", [inst, "cond"])]
  557. new_evalstack, new_phase = \
  558. yield [("CN", []),
  559. ("CNV", ["cond"]),
  560. ]
  561. _, _, _, _, _, _, _ = \
  562. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  563. ("CD", [new_evalstack, "prev", evalstack]),
  564. ("CD", [task_frame, "IP", cond]),
  565. ("CD", [evalstack, "inst", inst]),
  566. ("CD", [evalstack, "phase", new_phase]),
  567. ("DE", [evalstack_link]),
  568. ("DE", [ip_link]),
  569. ]
  570. yield [("RETURN", [None])]
  571. def if_cond(self, task_root):
  572. task_frame, = yield [("RD", [task_root, "frame"])]
  573. returnvalue, inst = yield [("RD", [task_frame, "returnvalue"]),
  574. ("RD", [task_frame, "IP"]),
  575. ]
  576. returnvalue_v, = yield [("RV", [returnvalue])]
  577. _else, = yield [("RD", [inst, "else"])]
  578. if returnvalue_v:
  579. phase_link, evalstack, evalstack_link, ip_link, _then, new_evalstack, evalstack_phase, new_phase = \
  580. yield [("RDE", [task_frame, "phase"]),
  581. ("RD", [task_frame, "evalstack"]),
  582. ("RDE", [task_frame, "evalstack"]),
  583. ("RDE", [task_frame, "IP"]),
  584. ("RD", [inst, "then"]),
  585. ("CN", []),
  586. ("CNV", ["finish"]),
  587. ("CNV", ["init"]),
  588. ]
  589. _, _, _, _, _, _, _, _, _ = \
  590. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  591. ("CD", [task_frame, "IP", _then]),
  592. ("CD", [new_evalstack, "prev", evalstack]),
  593. ("CD", [evalstack, "inst", inst]),
  594. ("CD", [evalstack, "phase", evalstack_phase]),
  595. ("CD", [task_frame, "phase", new_phase]),
  596. ("DE", [evalstack_link]),
  597. ("DE", [ip_link]),
  598. ("DE", [phase_link]),
  599. ]
  600. elif _else is None:
  601. phase_link, new_phase = \
  602. yield [("RDE", [task_frame, "phase"]),
  603. ("CNV", ["finish"]),
  604. ]
  605. _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  606. ("DE", [phase_link]),
  607. ]
  608. else:
  609. phase_link, evalstack, evalstack_link, ip_link = \
  610. yield [("RDE", [task_frame, "phase"]),
  611. ("RD", [task_frame, "evalstack"]),
  612. ("RDE", [task_frame, "evalstack"]),
  613. ("RDE", [task_frame, "IP"]),
  614. ]
  615. new_evalstack, new_phase, evalstack_phase = \
  616. yield [("CN", []),
  617. ("CNV", ["init"]),
  618. ("CNV", ["finish"]),
  619. ]
  620. _, _, _, _, _, _, _, _, _ = \
  621. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  622. ("CD", [task_frame, "IP", _else]),
  623. ("CD", [new_evalstack, "prev", evalstack]),
  624. ("CD", [evalstack, "inst", inst]),
  625. ("CD", [evalstack, "phase", evalstack_phase]),
  626. ("CD", [task_frame, "phase", new_phase]),
  627. ("DE", [evalstack_link]),
  628. ("DE", [ip_link]),
  629. ("DE", [phase_link]),
  630. ]
  631. yield [("RETURN", [None])]
  632. def while_init(self, task_root):
  633. task_frame, = yield [("RD", [task_root, "frame"])]
  634. evalstack, evalstack_link, ip_link, inst = \
  635. yield [("RD", [task_frame, "evalstack"]),
  636. ("RDE", [task_frame, "evalstack"]),
  637. ("RDE", [task_frame, "IP"]),
  638. ("RD", [task_frame, "IP"]),
  639. ]
  640. cond, new_evalstack, new_phase = \
  641. yield [("RD", [inst, "cond"]),
  642. ("CN", []),
  643. ("CNV", ["cond"]),
  644. ]
  645. _, _, _, _, _, _, _ = \
  646. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  647. ("CD", [new_evalstack, "prev", evalstack]),
  648. ("CD", [task_frame, "IP", cond]),
  649. ("CD", [evalstack, "phase", new_phase]),
  650. ("CD", [evalstack, "inst", inst]),
  651. ("DE", [evalstack_link]),
  652. ("DE", [ip_link]),
  653. ]
  654. yield [("RETURN", [None])]
  655. def while_cond(self, task_root):
  656. task_frame, = yield [("RD", [task_root, "frame"])]
  657. returnvalue, = yield [("RD", [task_frame, "returnvalue"])]
  658. returnvalue_v, = yield [("RV", [returnvalue])]
  659. if returnvalue_v:
  660. phase_link, evalstack, evalstack_link, ip_link, inst = \
  661. yield [("RDE", [task_frame, "phase"]),
  662. ("RD", [task_frame, "evalstack"]),
  663. ("RDE", [task_frame, "evalstack"]),
  664. ("RDE", [task_frame, "IP"]),
  665. ("RD", [task_frame, "IP"]),
  666. ]
  667. body, = yield [("RD", [inst, "body"])]
  668. new_evalstack, new_phase, evalstack_phase = \
  669. yield [("CN", []),
  670. ("CNV", ["init"]),
  671. ("CNV", ["init"]),
  672. ]
  673. _, _, _, _, _, _, _, _, _ = \
  674. yield [("CD", [task_frame, "IP", body]),
  675. ("CD", [task_frame, "phase", new_phase]),
  676. ("CD", [task_frame, "evalstack", new_evalstack]),
  677. ("CD", [new_evalstack, "prev", evalstack]),
  678. ("CD", [evalstack, "inst", inst]),
  679. ("CD", [evalstack, "phase", evalstack_phase]),
  680. ("DE", [evalstack_link]),
  681. ("DE", [ip_link]),
  682. ("DE", [phase_link]),
  683. ]
  684. # Check if we already have a taskname link to the evalstack
  685. links, = yield [("RD", [evalstack, self.taskname])]
  686. if links is None:
  687. yield [("CD", [evalstack, self.taskname, inst])]
  688. else:
  689. phase_link, new_phase = \
  690. yield [("RDE", [task_frame, "phase"]),
  691. ("CNV", ["finish"]),
  692. ]
  693. _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  694. ("DE", [phase_link])
  695. ]
  696. yield [("RETURN", [None])]
  697. def access_init(self, task_root):
  698. task_frame, = yield [("RD", [task_root, "frame"])]
  699. evalstack, evalstack_link, inst, ip_link = \
  700. yield [("RD", [task_frame, "evalstack"]),
  701. ("RDE", [task_frame, "evalstack"]),
  702. ("RD", [task_frame, "IP"]),
  703. ("RDE", [task_frame, "IP"]),
  704. ]
  705. var, new_evalstack, new_phase = \
  706. yield [("RD", [inst, "var"]),
  707. ("CN", []),
  708. ("CNV", ["eval"]),
  709. ]
  710. _, _, _, _, _, _, _ = \
  711. yield [("CD", [task_frame, "IP", var]),
  712. ("CD", [task_frame, "evalstack", new_evalstack]),
  713. ("CD", [new_evalstack, "prev", evalstack]),
  714. ("CD", [evalstack, "inst", inst]),
  715. ("CD", [evalstack, "phase", new_phase]),
  716. ("DE", [evalstack_link]),
  717. ("DE", [ip_link]),
  718. ]
  719. yield [("RETURN", [None])]
  720. def access_eval(self, task_root):
  721. task_frame, = yield [("RD", [task_root, "frame"])]
  722. phase_link, returnvalue_link, returnvalue = \
  723. yield [("RDE", [task_frame, "phase"]),
  724. ("RDE", [task_frame, "returnvalue"]),
  725. ("RD", [task_frame, "returnvalue"]),
  726. ]
  727. value, new_phase = yield [("RD", [returnvalue, "value"]),
  728. ("CNV", ["finish"]),
  729. ]
  730. _, _, _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  731. ("CD", [task_frame, "returnvalue", value]),
  732. ("DE", [phase_link]),
  733. ("DE", [returnvalue_link]),
  734. ]
  735. yield [("RETURN", [None])]
  736. def resolve_init(self, task_root):
  737. task_frame, = yield [("RD", [task_root, "frame"])]
  738. symbols, evalstack, evalstack_link, ip_link, inst = \
  739. yield [("RD", [task_frame, "symbols"]),
  740. ("RD", [task_frame, "evalstack"]),
  741. ("RDE", [task_frame, "evalstack"]),
  742. ("RDE", [task_frame, "IP"]),
  743. ("RD", [task_frame, "IP"]),
  744. ]
  745. var, = yield [("RD", [inst, "var"])]
  746. variable, = yield [("RDN", [symbols, var])]
  747. if variable is None:
  748. phase_link, returnvalue_link, _globals, var_name = \
  749. yield [("RDE", [task_frame, "phase"]),
  750. ("RDE", [task_frame, "returnvalue"]),
  751. ("RD", [task_root, "globals"]),
  752. ("RV", [var]),
  753. ]
  754. variable, new_phase = \
  755. yield [("RD", [_globals, var_name]),
  756. ("CNV", ["finish"]),
  757. ]
  758. if variable is None:
  759. globs, = yield [("RDK", [_globals])]
  760. print("Globals: " + str(globs))
  761. globs = yield [("RV", [i]) for i in globs]
  762. print("Resolved globals: " + str(globs))
  763. raise Exception(jit.GLOBAL_NOT_FOUND_MESSAGE_FORMAT % var_name)
  764. # Resolved a global, so this is a string
  765. # Potentially, this might even be a function that we have precompiled already!
  766. # So check whether this is the case or not
  767. if self.allow_compiled:
  768. compiled_function = getattr(compiled_functions, var_name, None)
  769. if compiled_function is not None:
  770. # We have a compiled function ready!
  771. # Now we have to bind the ID to the compiled functions
  772. # For this, we read out the body of the resolved data
  773. compiler_val, = yield [("RD", [variable, "value"])]
  774. compiler_body, = yield [("RD", [compiler_val, "body"])]
  775. self.jit.register_compiled(compiler_body, compiled_function, var_name)
  776. # If we're dealing with a function, then we might want to figure out what its body id
  777. # is now so we can suggest a name to the JIT later.
  778. if self.jit.get_global_body_id(var_name) is None:
  779. compiler_val, = yield [("RD", [variable, "value"])]
  780. if compiler_val is not None:
  781. compiler_body, = yield [("RD", [compiler_val, "body"])]
  782. if compiler_body is not None:
  783. self.jit.register_global(compiler_body, var_name)
  784. else:
  785. phase_link, returnvalue_link, new_phase = \
  786. yield [("RDE", [task_frame, "phase"]),
  787. ("RDE", [task_frame, "returnvalue"]),
  788. ("CNV", ["finish"]),
  789. ]
  790. _, _, _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  791. ("CD", [task_frame, "returnvalue", variable]),
  792. ("DE", [phase_link]),
  793. ("DE", [returnvalue_link]),
  794. ]
  795. yield [("RETURN", [None])]
  796. def assign_init(self, task_root):
  797. task_frame, = yield [("RD", [task_root, "frame"])]
  798. evalstack, evalstack_link, ip_link, inst = \
  799. yield [("RD", [task_frame, "evalstack"]),
  800. ("RDE", [task_frame, "evalstack"]),
  801. ("RDE", [task_frame, "IP"]),
  802. ("RD", [task_frame, "IP"]),
  803. ]
  804. var, new_evalstack, new_phase = \
  805. yield [("RD", [inst, "var"]),
  806. ("CN", []),
  807. ("CNV", ["value"]),
  808. ]
  809. _, _, _, _, _, _, _ = \
  810. yield [("CD", [task_frame, "IP", var]),
  811. ("CD", [task_frame, "evalstack", new_evalstack]),
  812. ("CD", [new_evalstack, "prev", evalstack]),
  813. ("CD", [evalstack, "inst", inst]),
  814. ("CD", [evalstack, "phase", new_phase]),
  815. ("DE", [evalstack_link]),
  816. ("DE", [ip_link]),
  817. ]
  818. yield [("RETURN", [None])]
  819. def assign_value(self, task_root):
  820. task_frame, = yield [("RD", [task_root, "frame"])]
  821. phase_link, evalstack, returnvalue, evalstack_link, ip_link, inst = \
  822. yield [("RDE", [task_frame, "phase"]),
  823. ("RD", [task_frame, "evalstack"]),
  824. ("RD", [task_frame, "returnvalue"]),
  825. ("RDE", [task_frame, "evalstack"]),
  826. ("RDE", [task_frame, "IP"]),
  827. ("RD", [task_frame, "IP"]),
  828. ]
  829. value, new_evalstack, new_phase, evalstack_phase = \
  830. yield [("RD", [inst, "value"]),
  831. ("CN", []),
  832. ("CNV", ["init"]),
  833. ("CNV", ["assign"]),
  834. ]
  835. _, _, _, _, _, _, _, _, _, _ = \
  836. yield [("CD", [task_frame, "variable", returnvalue]),
  837. ("CD", [task_frame, "phase", new_phase]),
  838. ("CD", [task_frame, "evalstack", new_evalstack]),
  839. ("CD", [new_evalstack, "prev", evalstack]),
  840. ("CD", [evalstack, "inst", inst]),
  841. ("CD", [evalstack, "phase", evalstack_phase]),
  842. ("CD", [task_frame, "IP", value]),
  843. ("DE", [evalstack_link]),
  844. ("DE", [phase_link]),
  845. ("DE", [ip_link]),
  846. ]
  847. yield [("RETURN", [None])]
  848. def assign_assign(self, task_root):
  849. task_frame, = yield [("RD", [task_root, "frame"])]
  850. phase_link, returnvalue, variable_link, variable = \
  851. yield [("RDE", [task_frame, "phase"]),
  852. ("RD", [task_frame, "returnvalue"]),
  853. ("RDE", [task_frame, "variable"]),
  854. ("RD", [task_frame, "variable"]),
  855. ]
  856. value_link, new_phase = \
  857. yield [("RDE", [variable, "value"]),
  858. ("CNV", ["finish"]),
  859. ]
  860. _, _, _, _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  861. ("CD", [variable, "value", returnvalue]),
  862. ("DE", [variable_link]),
  863. ("DE", [value_link]),
  864. ("DE", [phase_link]),
  865. ]
  866. yield [("RETURN", [None])]
  867. def return_init(self, task_root):
  868. task_frame, = yield [("RD", [task_root, "frame"])]
  869. inst, = yield [("RD", [task_frame, "IP"])]
  870. value, = yield [("RD", [inst, "value"])]
  871. if value is None:
  872. prev_frame, = yield [("RD", [task_frame, "prev"])]
  873. # If the callee's frame is marked with the '__exception_return' key, then
  874. # we need to throw an exception instead of just finishing here. This design
  875. # gives us O(1) state reads per jit-interpreter transition.
  876. exception_return, = yield [("RD", [task_frame, primitive_functions.EXCEPTION_RETURN_KEY])]
  877. if prev_frame is None:
  878. _, = yield [("DN", [task_root])]
  879. del self.debug_info[self.taskname]
  880. #print("Cleanup task " + str(self.taskname))
  881. else:
  882. if self.debug_info[self.taskname]:
  883. self.debug_info[self.taskname].pop()
  884. _, _ = yield [("CD", [task_root, "frame", prev_frame]),
  885. ("DN", [task_frame]),
  886. ]
  887. if exception_return is not None:
  888. raise primitive_functions.InterpretedFunctionFinished(None)
  889. else:
  890. evalstack, evalstack_link, ip_link, new_evalstack, evalstack_phase = \
  891. yield [("RD", [task_frame, "evalstack"]),
  892. ("RDE", [task_frame, "evalstack"]),
  893. ("RDE", [task_frame, "IP"]),
  894. ("CN", []),
  895. ("CNV", ["eval"]),
  896. ]
  897. _, _, _, _, _, _, _ = \
  898. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  899. ("CD", [new_evalstack, "prev", evalstack]),
  900. ("CD", [evalstack, "inst", inst]),
  901. ("CD", [evalstack, "phase", evalstack_phase]),
  902. ("CD", [task_frame, "IP", value]),
  903. ("DE", [evalstack_link]),
  904. ("DE", [ip_link]),
  905. ]
  906. yield [("RETURN", [None])]
  907. def return_eval(self, task_root):
  908. if self.debug_info[self.taskname]:
  909. self.debug_info[self.taskname].pop()
  910. task_frame, = yield [("RD", [task_root, "frame"])]
  911. prev_frame, = yield [("RD", [task_frame, "prev"])]
  912. if prev_frame is None:
  913. _, = yield [("DN", [task_root])]
  914. del self.debug_info[self.taskname]
  915. exception_return, returnvalue = yield [
  916. ("RD", [task_frame, primitive_functions.EXCEPTION_RETURN_KEY]),
  917. ("RD", [task_frame, "returnvalue"])]
  918. # If the callee's frame is marked with the '__exception_return' key, then
  919. # we need to throw an exception instead of just finishing here. This design
  920. # gives us O(1) state reads per jit-interpreter transition.
  921. if exception_return is not None:
  922. yield [
  923. ("CD", [task_root, "frame", prev_frame]),
  924. ("DN", [task_frame])]
  925. raise primitive_functions.InterpretedFunctionFinished(returnvalue)
  926. else:
  927. old_returnvalue_link, = yield [("RDE", [prev_frame, "returnvalue"])]
  928. yield [
  929. ("CD", [task_root, "frame", prev_frame]),
  930. ("CD", [prev_frame, "returnvalue", returnvalue]),
  931. ("DE", [old_returnvalue_link]),
  932. ("DN", [task_frame])]
  933. yield [("RETURN", [None])]
  934. def constant_init(self, task_root):
  935. task_frame, = yield [("RD", [task_root, "frame"])]
  936. phase_link, returnvalue_link, inst = \
  937. yield [("RDE", [task_frame, "phase"]),
  938. ("RDE", [task_frame, "returnvalue"]),
  939. ("RD", [task_frame, "IP"]),
  940. ]
  941. node, new_phase = yield [("RD", [inst, "node"]),
  942. ("CNV", ["finish"]),
  943. ]
  944. _, _, _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  945. ("CD", [task_frame, "returnvalue", node]),
  946. ("DE", [returnvalue_link]),
  947. ("DE", [phase_link]),
  948. ]
  949. yield [("RETURN", [None])]
  950. def helper_init(self, task_root):
  951. task_frame, = yield [("RD", [task_root, "frame"])]
  952. inst, = yield [("RD", [task_frame, "IP"])]
  953. next, = yield [("RD", [inst, "next"])]
  954. if next is None:
  955. ip_link, phase_link, evalstack_top = \
  956. yield [("RDE", [task_frame, "IP"]),
  957. ("RDE", [task_frame, "phase"]),
  958. ("RD", [task_frame, "evalstack"]),
  959. ]
  960. evalstack, = yield [("RD", [evalstack_top, "prev"])]
  961. evalstack_inst, evalstack_phase, evalstack_inst_link, evalstack_phase_link = \
  962. yield [("RD", [evalstack, "inst"]),
  963. ("RD", [evalstack, "phase"]),
  964. ("RDE", [evalstack, "inst"]),
  965. ("RDE", [evalstack, "phase"]),
  966. ]
  967. _, _, _, _, _, _, _, _ = \
  968. yield [("CD", [task_frame, "evalstack", evalstack]),
  969. ("CD", [task_frame, "IP", evalstack_inst]),
  970. ("CD", [task_frame, "phase", evalstack_phase]),
  971. ("DE", [ip_link]),
  972. ("DE", [phase_link]),
  973. ("DE", [evalstack_inst_link]),
  974. ("DE", [evalstack_phase_link]),
  975. ("DN", [evalstack_top]),
  976. ]
  977. else:
  978. ip_link, phase_link, new_phase = \
  979. yield [("RDE", [task_frame, "IP"]),
  980. ("RDE", [task_frame, "phase"]),
  981. ("CNV", ["init"]),
  982. ]
  983. _, _, _, _ = yield [("CD", [task_frame, "IP", next]),
  984. ("CD", [task_frame, "phase", new_phase]),
  985. ("DE", [ip_link]),
  986. ("DE", [phase_link]),
  987. ]
  988. yield [("RETURN", [None])]
  989. def call_init(self, task_root):
  990. task_frame, = yield [("RD", [task_root, "frame"])]
  991. symbols, evalstack, evalstack_link, ip_link, inst = \
  992. yield [("RD", [task_frame, "symbols"]),
  993. ("RD", [task_frame, "evalstack"]),
  994. ("RDE", [task_frame, "evalstack"]),
  995. ("RDE", [task_frame, "IP"]),
  996. ("RD", [task_frame, "IP"]),
  997. ]
  998. func, params = yield [("RD", [inst, "func"]),
  999. ("RD", [inst, "params"]),
  1000. ]
  1001. if params is None:
  1002. new_evalstack, evalstack_phase = \
  1003. yield [("CN", []),
  1004. ("CNV", ["call"]),
  1005. ]
  1006. _, _, _, _, _, _, _ = \
  1007. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  1008. ("CD", [new_evalstack, "prev", evalstack]),
  1009. ("CD", [evalstack, "inst", inst]),
  1010. ("CD", [evalstack, "phase", evalstack_phase]),
  1011. ("CD", [task_frame, "IP", func]),
  1012. ("DE", [evalstack_link]),
  1013. ("DE", [ip_link]),
  1014. ]
  1015. else:
  1016. new_evalstack,= yield [("CN", [])]
  1017. _, _, _, _, _, _, _ = \
  1018. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  1019. ("CD", [new_evalstack, "prev", evalstack]),
  1020. ("CD", [evalstack, "inst", inst]),
  1021. ("CD", [evalstack, "phase", params]),
  1022. ("CD", [task_frame, "IP", func]),
  1023. ("DE", [evalstack_link]),
  1024. ("DE", [ip_link]),
  1025. ]
  1026. yield [("RETURN", [None])]
  1027. def call_call(self, task_root):
  1028. self.debug_info[self.taskname].append("None")
  1029. task_frame, = yield [("RD", [task_root, "frame"])]
  1030. inst, = yield [("RD", [task_frame, "IP"])]
  1031. param, = yield [("RD", [inst, "last_param"])]
  1032. if param is None:
  1033. returnvalue, = yield [("RD", [task_frame, "returnvalue"])]
  1034. body, = yield [("RD", [returnvalue, "body"])]
  1035. self.jit.mark_entry_point(body)
  1036. phase_link, frame_link, prev_phase, new_phase, new_frame, new_evalstack, new_symbols, new_returnvalue = \
  1037. yield [("RDE", [task_frame, "phase"]),
  1038. ("RDE", [task_root, "frame"]),
  1039. ("CNV", ["finish"]),
  1040. ("CNV", ["init"]),
  1041. ("CN", []),
  1042. ("CN", []),
  1043. ("CN", []),
  1044. ("CN", []),
  1045. ]
  1046. _, _, _, _, _, _, _, _, _, _, _ = \
  1047. yield [("CD", [task_root, "frame", new_frame]),
  1048. ("CD", [new_frame, "evalstack", new_evalstack]),
  1049. ("CD", [new_frame, "symbols", new_symbols]),
  1050. ("CD", [new_frame, "returnvalue", new_returnvalue]),
  1051. ("CD", [new_frame, "caller", inst]),
  1052. ("CD", [new_frame, "phase", new_phase]),
  1053. ("CD", [new_frame, "IP", body]),
  1054. ("CD", [new_frame, "prev", task_frame]),
  1055. ("CD", [task_frame, "phase", prev_phase]),
  1056. ("DE", [phase_link]),
  1057. ("DE", [frame_link]),
  1058. ]
  1059. else:
  1060. newer_frames, invoking_frames = \
  1061. yield [("RRD", [task_frame, "prev"]),
  1062. ("RRD", [inst, "caller"]),
  1063. ]
  1064. new_frame = self.find_overlapping(newer_frames, invoking_frames)
  1065. phase_link, frame_link, new_symbols, new_IP = \
  1066. yield [("RDE", [task_frame, "phase"]),
  1067. ("RDE", [task_root, "frame"]),
  1068. ("RD", [new_frame, "symbols"]),
  1069. ("RD", [new_frame, "IP"]),
  1070. ]
  1071. signature, = yield [("RRD", [new_IP, "body"])]
  1072. signature = signature[0]
  1073. sig_params, last_param = \
  1074. yield [("RD", [signature, "params"]),
  1075. ("RD", [inst, "last_param"]),
  1076. ]
  1077. self.jit.mark_entry_point(new_IP)
  1078. name, = yield [("RD", [last_param, "name"])]
  1079. name_value, = yield [("RV", [name])]
  1080. returnvalue, formal_parameter, new_phase, variable = \
  1081. yield [("RD", [task_frame, "returnvalue"]),
  1082. ("RD", [sig_params, name_value]),
  1083. ("CNV", ["finish"]),
  1084. ("CN", []),
  1085. ]
  1086. _, _, _, t1 = yield [("CD", [task_root, "frame", new_frame]),
  1087. ("CD", [task_frame, "phase", new_phase]),
  1088. ("CD", [variable, "value", returnvalue]),
  1089. ("CE", [new_symbols, variable]),
  1090. ]
  1091. _, _, _ = yield [("CE", [t1, formal_parameter]),
  1092. ("DE", [frame_link]),
  1093. ("DE", [phase_link]),
  1094. ]
  1095. yield [("RETURN", [None])]
  1096. def find_overlapping(self, a, b):
  1097. newer_frames = set(a)
  1098. invoking_frames = set(b)
  1099. matches = list(newer_frames.intersection(invoking_frames))
  1100. if len(matches) == 1:
  1101. return matches[0]
  1102. elif len(matches) > 1:
  1103. raise Exception("Error: multiple overlapping elements")
  1104. else:
  1105. raise Exception("Error: could not find any overlap")
  1106. def call_param(self, task_root):
  1107. task_frame, = yield [("RD", [task_root, "frame"])]
  1108. inst, phase = yield [("RD", [task_frame, "IP"]),
  1109. ("RD", [task_frame, "phase"]),
  1110. ]
  1111. params, last_param = \
  1112. yield [("RD", [inst, "params"]),
  1113. ("RD", [inst, "last_param"]),
  1114. ]
  1115. next_param, = yield [("RD", [params, "next_param"])]
  1116. if params == phase:
  1117. phase_link, ip_link, returnvalue, param_value, evalstack, evalstack_link = \
  1118. yield [("RDE", [task_frame, "phase"]),
  1119. ("RDE", [task_frame, "IP"]),
  1120. ("RD", [task_frame, "returnvalue"]),
  1121. ("RD", [params, "value"]),
  1122. ("RD", [task_frame, "evalstack"]),
  1123. ("RDE", [task_frame, "evalstack"]),
  1124. ]
  1125. body, = yield [("RD", [returnvalue, "body"])]
  1126. new_frame, prev_evalstack, new_phase, prev_phase, new_evalstack, new_symbols, new_returnvalue = \
  1127. yield [("CN", []),
  1128. ("CN", []),
  1129. ("CNV", ["init"]),
  1130. ("CNV", ["init"]),
  1131. ("CN", []),
  1132. ("CN", []),
  1133. ("CN", []),
  1134. ]
  1135. _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = \
  1136. yield [("CD", [new_frame, "evalstack", new_evalstack]),
  1137. ("CD", [new_frame, "symbols", new_symbols]),
  1138. ("CD", [new_frame, "returnvalue", new_returnvalue]),
  1139. ("CD", [new_frame, "caller", inst]),
  1140. ("CD", [new_frame, "phase", new_phase]),
  1141. ("CD", [new_frame, "IP", body]),
  1142. ("CD", [new_frame, "prev", task_frame]),
  1143. ("CD", [task_frame, "phase", prev_phase]),
  1144. ("CD", [task_frame, "IP", param_value]),
  1145. ("CD", [prev_evalstack, "prev", evalstack]),
  1146. ("CD", [evalstack, "inst", inst]),
  1147. ("CD", [task_frame, "evalstack", prev_evalstack]),
  1148. ("DE", [evalstack_link]),
  1149. ("DE", [ip_link]),
  1150. ("DE", [phase_link]),
  1151. ]
  1152. if next_param is not None:
  1153. _ = yield [("CD", [evalstack, "phase", next_param])]
  1154. else:
  1155. evalstack_phase, = \
  1156. yield [("CNV", ["call"])]
  1157. _ = yield [("CD", [evalstack, "phase", evalstack_phase])]
  1158. else:
  1159. frame_link, phase_link, newer_frames, invoking_frames = \
  1160. yield [("RDE", [task_root, "frame"]),
  1161. ("RDE", [task_frame, "phase"]),
  1162. ("RRD", [task_frame, "prev"]),
  1163. ("RRD", [inst, "caller"]),
  1164. ]
  1165. new_frame = self.find_overlapping(newer_frames, invoking_frames)
  1166. ip_link, evalstack, evalstack_link, new_symbols, new_IP = \
  1167. yield [("RDE", [task_frame, "IP"]),
  1168. ("RD", [task_frame, "evalstack"]),
  1169. ("RDE", [task_frame, "evalstack"]),
  1170. ("RD", [new_frame, "symbols"]),
  1171. ("RD", [new_frame, "IP"]),
  1172. ]
  1173. signature, = yield [("RRD", [new_IP, "body"])]
  1174. signature = signature[0]
  1175. sig_params, = yield [("RD", [signature, "params"])]
  1176. if last_param == phase:
  1177. prev_param, = \
  1178. yield [("RRD", [last_param, "next_param"])]
  1179. prev_param = prev_param[0]
  1180. name, = yield [("RD", [prev_param, "name"])]
  1181. name_value, = \
  1182. yield [("RV", [name])]
  1183. evalstack_phase, = \
  1184. yield [("CNV", ["call"])]
  1185. _ = yield [("CD", [evalstack, "phase", evalstack_phase])]
  1186. formal_parameter, param_value = \
  1187. yield [("RD", [sig_params, name_value]),
  1188. ("RD", [last_param, "value"]),
  1189. ]
  1190. else:
  1191. param_b, = yield [("RD", [task_frame, "phase"])]
  1192. param_c, param_a = \
  1193. yield [("RD", [param_b, "next_param"]),
  1194. ("RRD", [param_b, "next_param"]),
  1195. ]
  1196. param_a = param_a[0]
  1197. name, param_value = \
  1198. yield [("RD", [param_a, "name"]),
  1199. ("RD", [param_b, "value"]),
  1200. ]
  1201. name_value, = \
  1202. yield [("RV", [name])]
  1203. formal_parameter, _ = \
  1204. yield [("RD", [sig_params, name_value]),
  1205. ("CD", [evalstack, "phase", param_c]),
  1206. ]
  1207. new_phase, new_evalstack, variable, returnvalue = \
  1208. yield [("CNV", ["init"]),
  1209. ("CN", []),
  1210. ("CN", []),
  1211. ("RD", [task_frame, "returnvalue"]),
  1212. ]
  1213. _, _, _, _, _, _ = \
  1214. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  1215. ("CD", [new_evalstack, "prev", evalstack]),
  1216. ("CD", [evalstack, "inst", inst]),
  1217. ("CD", [task_frame, "phase", new_phase]),
  1218. ("CD", [task_frame, "IP", param_value]),
  1219. ("CD", [variable, "value", returnvalue]),
  1220. ]
  1221. t1, = yield [("CE", [new_symbols, variable])]
  1222. _, _, _, _ = \
  1223. yield [("CE", [t1, formal_parameter]),
  1224. ("DE", [phase_link]),
  1225. ("DE", [ip_link]),
  1226. ("DE", [evalstack_link]),
  1227. ]
  1228. yield [("RETURN", [None])]
  1229. def input_init(self, task_root):
  1230. task_frame, = yield [("RD", [task_root, "frame"])]
  1231. returnvalue_link, _input = \
  1232. yield [("RDE", [task_frame, "returnvalue"]),
  1233. ("RD", [task_root, "input"]),
  1234. ]
  1235. value, next, phase_link = \
  1236. yield [("RD", [_input, "value"]),
  1237. ("RD", [_input, "next"]),
  1238. ("RDE", [task_frame, "phase"]),
  1239. ]
  1240. if value is not None:
  1241. v = yield [("RV", [value])]
  1242. _, _, finish = \
  1243. yield [("CD", [task_frame, "returnvalue", value]),
  1244. ("CD", [task_root, "input", next]),
  1245. ("CNV", ["finish"]),
  1246. ]
  1247. _, _, _, _ = \
  1248. yield [("CD", [task_frame, "phase", finish]),
  1249. ("DN", [_input]),
  1250. ("DE", [returnvalue_link]),
  1251. ("DE", [phase_link]),
  1252. ]
  1253. self.input_value = value
  1254. else:
  1255. # No input yet, so just wait and don't advance IP or phase
  1256. self.input_value = None
  1257. ex = primitive_functions.SleepKernel(0.1, True)
  1258. raise ex
  1259. yield [("RETURN", [None])]
  1260. def output_init(self, task_root):
  1261. task_frame, = yield [("RD", [task_root, "frame"])]
  1262. evalstack, evalstack_link, ip_link, inst = \
  1263. yield [("RD", [task_frame, "evalstack"]),
  1264. ("RDE", [task_frame, "evalstack"]),
  1265. ("RDE", [task_frame, "IP"]),
  1266. ("RD", [task_frame, "IP"]),
  1267. ]
  1268. value, new_evalstack, evalstack_phase = \
  1269. yield [("RD", [inst, "value"]),
  1270. ("CN", []),
  1271. ("CNV", ["output"]),
  1272. ]
  1273. _, _, _, _, _, _, _ = \
  1274. yield [("CD", [task_frame, "evalstack", new_evalstack]),
  1275. ("CD", [new_evalstack, "prev", evalstack]),
  1276. ("CD", [evalstack, "inst", inst]),
  1277. ("CD", [evalstack, "phase", evalstack_phase]),
  1278. ("CD", [task_frame, "IP", value]),
  1279. ("DE", [evalstack_link]),
  1280. ("DE", [ip_link]),
  1281. ]
  1282. yield [("RETURN", [None])]
  1283. def output_output(self, task_root):
  1284. task_frame, = yield [("RD", [task_root, "frame"])]
  1285. returnvalue_link, returnvalue, last_output, phase_link, last_output_link, new_last_output, finish = \
  1286. yield [("RDE", [task_frame, "returnvalue"]),
  1287. ("RD", [task_frame, "returnvalue"]),
  1288. ("RD", [task_root, "last_output"]),
  1289. ("RDE", [task_frame, "phase"]),
  1290. ("RDE", [task_root, "last_output"]),
  1291. ("CN", []),
  1292. ("CNV", ["finish"]),
  1293. ]
  1294. _, _, _, _, _, _ = \
  1295. yield [("CD", [last_output, "value", returnvalue]),
  1296. ("CD", [last_output, "next", new_last_output]),
  1297. ("CD", [task_root, "last_output", new_last_output]),
  1298. ("CD", [task_frame, "phase", finish]),
  1299. ("DE", [last_output_link]),
  1300. ("DE", [phase_link]),
  1301. ]
  1302. yield [("RETURN", [None])]
  1303. def declare_init(self, task_root):
  1304. task_frame, = yield [("RD", [task_root, "frame"])]
  1305. inst, = yield [("RD", [task_frame, "IP"])]
  1306. new_var, symbols, phase_link, empty_node, new_phase = \
  1307. yield [("RD", [inst, "var"]),
  1308. ("RD", [task_frame, "symbols"]),
  1309. ("RDE", [task_frame, "phase"]),
  1310. ("CN", []),
  1311. ("CNV", ["finish"]),
  1312. ]
  1313. exists, = yield [("RDN", [symbols, new_var])]
  1314. if exists is None:
  1315. new_edge, = yield [("CE", [symbols, empty_node])]
  1316. _ = yield [("CE", [new_edge, new_var])]
  1317. _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  1318. ("DE", [phase_link]),
  1319. ]
  1320. yield [("RETURN", [None])]
  1321. def global_init(self, task_root):
  1322. task_frame, = yield [("RD", [task_root, "frame"])]
  1323. inst, = yield [("RD", [task_frame, "IP"])]
  1324. new_var, global_symbols, phase_link, empty_node, new_phase = \
  1325. yield [("RD", [inst, "var"]),
  1326. ("RD", [task_root, "globals"]),
  1327. ("RDE", [task_frame, "phase"]),
  1328. ("CN", []),
  1329. ("CNV", ["finish"]),
  1330. ]
  1331. value, = yield [("RV", [new_var])]
  1332. exists, = yield [("RDE", [global_symbols, value])]
  1333. if exists is not None:
  1334. yield [("DE", [exists])]
  1335. yield [("CD", [global_symbols, value, empty_node])]
  1336. _, _ = yield [("CD", [task_frame, "phase", new_phase]),
  1337. ("DE", [phase_link])
  1338. ]
  1339. yield [("RETURN", [None])]