main.py 75 KB

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