main.py 76 KB

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