main.py 71 KB

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