main.py 74 KB

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