12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496 |
- import modelverse_kernel.primitives as primitive_functions
- import modelverse_kernel.compiled as compiled_functions
- from modelverse_kernel.request_handler import RequestHandler
- import modelverse_kernel.jit as jit
- from collections import defaultdict
- import sys
- import time
- import json
- if sys.version > '3': # pragma: no cover
- string_types = (str,)
- else:
- string_types = (str, unicode)
- PROFILE = False
- class ModelverseKernel(object):
-
- counter = 0
- def __init__(self, root):
- self.root = root
- self.returnvalue = None
- # request_handlers is a dictionary of tasknames to dictionaries of operations
- # to request handlers. In generics notation:
- #
- # Dictionary<
- # Username,
- # Dictionary<
- # Operation,
- # RequestHandler>>
- #
- self.request_handlers = {}
- self.allow_compiled = True
- # `self.jit` handles most JIT-related functionality.
- self.jit = jit.ModelverseJit()
- self.jit.compiled_function_lookup = lambda func_name : getattr(compiled_functions, func_name, None)
- self.jit.body_cache = {}
- self.debug_info = defaultdict(list)
- if PROFILE:
- self.prev_timers = {}
- self.end_timers = {}
- self.profiling = True
- self.profile_file = open("../profiling_results", 'w')
- else:
- self.profiling = False
- def try_to_protect(self, var):
- if isinstance(var, dict) and "id" in var and var['id'] is not None:
- return set([var['id']])
- elif type(var) == int:
- return set([var])
- elif isinstance(var, dict):
- protect = set()
- for v in var.values():
- protect |= self.try_to_protect(v)
- return protect
- elif isinstance(var, list):
- protect = set()
- for v in var:
- protect |= self.try_to_protect(v)
- return protect
- elif isinstance(var, set):
- protect = set()
- for v in var:
- protect |= self.try_to_protect(v)
- return protect
- return set()
- def protect_temporary_variables(self, taskname):
- generators = []
- for h in self.request_handlers.values():
- for handler in h.values():
- for generator in handler.generator_stack:
- generators.append(generator)
- to_protect = set()
- for gen in generators:
- try:
- variables = gen.gi_frame.f_locals
- for var in variables.values():
- to_protect |= self.try_to_protect(var)
- except:
- pass
- # Create the node to which everything is attached
- self.fixed_node, = yield [("CN", [])]
- yield [("CE", [self.root, self.fixed_node])]
- yield [("CE", [self.fixed_node, node]) for node in to_protect]
- yield [("RETURN", [None])]
- def unprotect_temporary_variables(self, taskname):
- yield [("DN", [self.fixed_node])]
- yield [("RETURN", [None])]
- def execute_yields(self, taskname, operation, params, reply):
- self.taskname = taskname
- if taskname not in self.request_handlers:
- self.request_handlers[taskname] = {}
- self.jit.cache.setdefault(taskname, {})
- if operation not in self.request_handlers[taskname]:
- # Create the generator for the function to execute
- self.request_handlers[taskname][operation] = RequestHandler()
- handler = self.request_handlers[taskname][operation]
- if len(handler.generator_stack) == 0:
- handler.push_generator(getattr(self, operation)(taskname, *params))
- return handler.handle_request(reply)
- def execute_rule(self, taskname):
- task_root, = yield [("RD", [self.root, taskname])]
- if task_root is None:
- yield [("SLEEP", [0.01, False])]
- yield None
- else:
- task_frame, = yield [("RD", [task_root, "frame"])]
- self.inst, phase = yield [("RD", [task_frame, "IP"]),
- ("RD", [task_frame, "phase"]),
- ]
- self.new_debug, self.phase_v, inst_v = \
- yield [("RD", [self.inst, "__debug"]),
- ("RV", [phase]),
- ("RV", [self.inst]),
- ]
- if self.new_debug is not None:
- if self.debug_info[taskname]:
- self.debug_info[taskname][-1], = yield [("RV", [self.new_debug])]
- if self.phase_v == "finish":
- gen = self.helper_init(task_root)
- elif self.inst is None:
- raise Exception("Instruction pointer could not be found!")
- elif isinstance(self.phase_v, string_types):
- if self.phase_v == "init" and self.jit.is_jittable_entry_point(self.inst):
- #print("%-30s(%s)" % ("COMPILED " + str(self.jit.jitted_entry_points[self.inst]), phase_v))
- gen = self.execute_jit(task_root, self.inst, taskname, store=True, resolve=False)
- elif inst_v is None:
- raise Exception("%s: error understanding command (%s, %s)" % (self.debug_info[taskname], inst_v, self.phase_v))
- else:
- gen = self.get_inst_phase_generator(inst_v, self.phase_v, task_root)
- elif inst_v is None:
- raise Exception("%s: error understanding command (%s, %s)" % (self.debug_info[taskname], inst_v, self.phase_v))
- elif inst_v["value"] == "call":
- #print("%-30s(%s)" % ("call", "param"))
- gen = self.call_param(task_root)
- else:
- raise Exception("%s: error understanding command (%s, %s)" % (self.debug_info[taskname], inst_v, self.phase_v))
- yield [("CALL", [gen])]
- yield [("FINISH", [])]
- def get_inst_phase_generator(self, inst_v, phase_v, task_root):
- """Gets a generator for the given instruction in the given phase,
- for the specified task root."""
- #print("%-30s(%s) -- %s" % (inst_v["value"], phase_v, taskname))
- return getattr(self, "%s_%s" % (inst_v["value"], phase_v))(task_root)
- ##########################
- ### Process primitives ###
- ##########################
- def load_primitives(self, taskname):
- yield [("CALL_ARGS", [self.load_primitives_from, (taskname, 'primitives', primitive_functions)])]
- yield [("FINISH", [])]
- def load_primitives_from(self, taskname, source_name, source):
- hierarchy, = yield [("RD", [self.root, "__hierarchy"])]
- primitives, = yield [("RD", [hierarchy, source_name])]
- keys, = yield [("RDK", [primitives])]
- function_names = yield [("RV", [f]) for f in keys]
- signatures = yield [("RDN", [primitives, f]) for f in keys]
- bodies = yield [("RD", [f, "body"]) for f in signatures]
- for i in range(len(keys)):
- self.jit.register_compiled(bodies[i], getattr(source, function_names[i]), function_names[i])
- yield [("RETURN", [None])]
- def print_instruction(self, inst, indent, nested_indent=None):
- """
- intrinsics = {"integer_addition": (lambda x, y: "(%s + %s)" % (x, y)),
- "string_join": (lambda x, y: "(str(%s) + str(%s))" % (x, y)),
- }
- """
- intrinsics = {}
- if nested_indent is None:
- nested_indent = indent
- inst_type, = yield [("RV", [inst])]
- instruction = "(no_printer_for_%s)" % inst_type["value"]
- prev = ""
- if inst_type["value"] == "if":
- cond, true, false = yield [("RD", [inst, "cond"]),
- ("RD", [inst, "then"]),
- ("RD", [inst, "else"])]
- (prev_cond, instruction_cond), = yield [("CALL_ARGS", [self.print_instruction, (cond, 0, indent)])]
- (prev_true, instruction_true), = yield [("CALL_ARGS", [self.print_instruction, (true, indent+1)])]
- if false:
- (prev_false, instruction_false), = yield [("CALL_ARGS", [self.print_instruction, (false, indent+1)])]
- false = (" " * indent + "else:\n%s%s") % (prev_false, instruction_false)
- else:
- false = ""
- instruction = prev_cond + \
- " " * indent + "if 'value' not in %s:\n" % instruction_cond + \
- " " * (indent + 1) + "%s['value'], = yield [('RV', [%s['id']])]\n" % (instruction_cond, instruction_cond) + \
- " " * indent + "if (%s['value']):\n" % instruction_cond + \
- prev_true + \
- instruction_true + \
- false
- elif inst_type["value"] == "constant":
- node, = yield [("RD", [inst, "node"])]
- node_value, = yield [("RV", [node])]
- if node_value is not None:
- # There is a value to the node, so replicate the value
- if isinstance(node_value, string_types):
- value = '"%s"' % node_value.replace('"', '\\"').replace("'", "\\'").replace('\t', '\\t').replace('\n', '\\n')
- else:
- value = str(node_value)
- instruction = "constant_" + str(ModelverseKernel.counter)
- ModelverseKernel.counter += 1
- prev = " " * nested_indent + instruction + " = {'value': " + value + "}\n"
- else:
- # Node is None, meaning that it was not about the value, but the node itself...
- instruction = "{'id': %s}" % str(node)
- elif inst_type["value"] == "return":
- value, = yield [("RD", [inst, "value"])]
- if value:
- (prev_value, instruction_value), = yield [("CALL_ARGS", [self.print_instruction, (value, 0, indent)])]
- instruction = prev_value + " " * indent + "yield [('RETURN', [%s])]\n" % instruction_value
- else:
- instruction = " " * indent + "yield [('RETURN', [None])]\n"
- elif inst_type["value"] == "declare":
- instruction = ""
- elif inst_type["value"] == "global":
- instruction = ""
- elif inst_type["value"] == "break":
- instruction = " " * indent + "break\n"
- elif inst_type["value"] == "continue":
- instruction = " " * indent + "continue\n"
- elif inst_type["value"] == "input":
- prev = " " * nested_indent + "_inputs, = yield [('RD', [_root, 'input'])]\n" + \
- " " * nested_indent + "val, val_e, nxt = yield [('RD', [_inputs, 'value']), ('RDE', [_inputs, 'value']), ('RD', [_inputs, 'next'])]\n" + \
- " " * nested_indent + "_, val_e = yield [('DE', [val_e]), ('RDE', [_root, 'input'])]\n" + \
- " " * nested_indent + "yield [('CD', [_root, 'input', nxt]), ('DE', [val_e])]\n" + \
- " " * nested_indent + "_result = {'id': val}\n"
- instruction = "_result"
- elif inst_type["value"] == "output":
- value, = yield [("RD", [inst, "value"])]
- (prev, instruction), = yield [("CALL_ARGS", [self.print_instruction, (value, 0, indent)])]
- instruction = prev + \
- " " * indent + "if 'id' not in %s:\n" % instruction + \
- " " * (indent + 1) + "%s['id'], = yield [('CNV', [%s['value']])]\n" % (instruction, instruction) + \
- " " * indent + "_outputs, _outputs_e = yield [('RD', [_root, 'last_output']), ('RDE', [_root, 'last_output'])]\n" + \
- " " * indent + "_, _new = yield [('CD', [_outputs, 'value', %s['id']]), ('CN', [])]\n" % instruction + \
- " " * indent + "yield [('CD', [_outputs, 'next', _new]), ('DE', [_outputs_e]), ('CD', [_root, 'last_output', _new])]\n"
- elif inst_type["value"] == "resolve":
- value, = yield [("RD", [inst, "var"])]
- str_value, = yield [("RV", [value])]
- if str_value:
- # Is a global
- prev = \
- " " * nested_indent + "%s = _mvk.jit.cache[_taskname].get('%s', None)\n" % (str_value, str_value) + \
- " " * nested_indent + "if %s is None:\n" % str_value + \
- " " * (nested_indent + 1) + "%s, = yield [('RD', [_globs, '%s'])]\n" % (str_value, str_value) + \
- " " * (nested_indent + 1) + "%s, = yield [('RD', [%s, 'value'])]\n" % (str_value, str_value) + \
- " " * (nested_indent + 1) + "%s = {'id': %s}\n" % (str_value, str_value) + \
- " " * (nested_indent + 1) + "_mvk.jit.cache[_taskname]['%s'] = %s\n" % (str_value, str_value)
- instruction = str_value
- if self.jit.get_global_body_id(str_value) is None:
- val, = yield [("RD", [self.root, self.taskname])]
- val, = yield [("RD", [val, 'globals'])]
- val, = yield [("RD", [val, str_value])]
- val, = yield [("RD", [val, 'value'])]
- val, = yield [("RD", [val, 'body'])]
- self.jit.register_global(val, str_value)
- else:
- # Is a local
- instruction = "var_%s" % value
- elif inst_type["value"] == "assign":
- var, val = yield [("RD", [inst, "var"]),
- ("RD", [inst, "value"])]
- (prev_var, instruction_var), = yield [("CALL_ARGS", [self.print_instruction, (var, 0, indent)])]
- (prev_val, instruction_val), = yield [("CALL_ARGS", [self.print_instruction, (val, 0, indent)])]
- instruction = prev_val + " " * indent + instruction_var + " = " + instruction_val + "\n"
- if prev_var:
- # Got something to do before the variable is usable, so this is a global!
- # Therefore we actually do the operation in the Modelverse as well!
- instruction += \
- " " * nested_indent + "_var, = yield [('RD', [_globs, '%s'])]\n" % instruction_var + \
- " " * nested_indent + "if _var is None:\n" + \
- " " * (nested_indent + 1) + "_var, = yield [('CN', [])]\n" + \
- " " * (nested_indent + 1) + "yield [('CD', [_globs, '%s', _var])]\n" % instruction_var + \
- " " * nested_indent + "_old_edge, = yield [('RDE', [_var, 'value'])]\n" + \
- " " * nested_indent + "if 'id' not in %s:\n" % instruction_var + \
- " " * (nested_indent + 1) + "%s['id'], = yield [('CNV', [%s['value']])]\n" % (instruction_var, instruction_var) + \
- " " * nested_indent + "yield [('CD', [_var, 'value', %s['id']]), ('DE', [_old_edge])]\n" % instruction_var + \
- " " * nested_indent + "_mvk.jit.cache[_taskname]['%s'] = %s\n" % (instruction_var, instruction_var)
- elif inst_type["value"] == "call":
- func_name, = yield [("RD", [inst, "func"])]
- (prev_func_name, func_name), = yield [("CALL_ARGS", [self.print_instruction, (func_name, nested_indent, nested_indent)])]
- param_list = {}
- param, = yield [("RD", [inst, "params"])]
- computation = ""
- while param:
- value, name = yield [("RD", [param, "value"]), ("RD", [param, "name"])]
- name, = yield [("RV", [name])]
- (prev_res, instruction_res), = yield [("CALL_ARGS", [self.print_instruction, (value, 0, nested_indent)])]
- param, = yield [("RD", [param, "next_param"])]
- computation += prev_res
- param_list[name] = instruction_res
- value = "func_result_" + str(ModelverseKernel.counter)
- ModelverseKernel.counter += 1
- param_list = "{" + ", ".join(["'%s': %s" % (k, v) for k, v in param_list.items()]) + "}"
- actual_computation = "$$INDENT$$%s, = yield [('CALL_ARGS', [_mvk.execute_jit, (_root, %s['id'], _taskname, %s)])]\n" % (value, func_name, param_list)
- if indent == 0:
- # No indent, meaning that we use it inline
- # Therefore, we output the prev and value individually
- prev, instruction = prev_func_name + computation + actual_computation.replace("$$INDENT$$", " " * nested_indent), value
- else:
- # Some indentation, meaning that we don't even use the return value
- # Therefore, we only do the yield
- prev, instruction = prev_func_name + computation, actual_computation.replace("$$INDENT$$", " " * indent)
- elif inst_type["value"] == "access":
- value, = yield [("RD", [inst, "var"])]
- (prev, instruction), = yield [("CALL_ARGS", [self.print_instruction, (value, 0, nested_indent)])]
- elif inst_type["value"] == "while":
- cond, body = yield [("RD", [inst, "cond"]),
- ("RD", [inst, "body"])]
- (prev_cond, instruction_cond), = yield [("CALL_ARGS", [self.print_instruction, (cond, 0, indent+1)])]
- (prev_body, instruction_body), = yield [("CALL_ARGS", [self.print_instruction, (body, indent+1)])]
- instruction = " " * indent + "__counter_%s = 0\n" % inst + \
- " " * indent + "while 1:\n" + prev_cond + \
- " " * (indent + 1) + "if 'value' not in %s:\n" % instruction_cond + \
- " " * (indent + 2) + "%s['value'], = yield [('RV', [%s['id']])]\n" % (instruction_cond, instruction_cond) + \
- " " * (indent + 1) + "if not (%s['value']):\n" % instruction_cond + \
- " " * (indent + 2) + "break\n" + \
- " " * (indent + 1) + "else:\n" + \
- " " * (indent + 2) + "__counter_%s += 1\n" % inst + \
- " " * (indent + 2) + "if __counter_%s > 20:\n" % inst + \
- " " * (indent + 3) + "yield None\n" + \
- " " * (indent + 3) + "__counter_%s = 0\n" % inst + \
- prev_body + instruction_body
- next_inst, = yield [("RD", [inst, "next"])]
- if next_inst:
- (prev_next, inst_next), = yield [("CALL_ARGS", [self.print_instruction, (next_inst, indent)])]
- next_inst = prev_next + inst_next
- else:
- next_inst = ""
- yield [('RETURN', [(prev, instruction + next_inst)])]
- def read_function(self, inst, suggested_name):
- initial_instruction = inst
- (params, _, is_mutable), = yield [("CALL_ARGS", [self.jit.jit_signature, (inst,)])]
- if is_mutable:
- print("Ignoring mutable or unreadable: %s" % suggested_name)
- raise jit.JitCompilationFailedException("FAIL")
- (prev, printed), = yield [("CALL_ARGS", [self.print_instruction, (inst, 1)])]
- preamble = " _mvk = kwargs['mvk']\n" + \
- " _root = kwargs['task_root']\n" + \
- " _taskname = kwargs['taskname']\n" + \
- " _globs = _mvk.jit.cache[_taskname].get('_globs', None)\n" + \
- " if _globs is None:\n" + \
- " _globs, = yield [('RD', [kwargs['task_root'], 'globals'])]\n" + \
- " _mvk.jit.cache[_taskname]['_globs'] = _globs\n"
- printed = preamble + prev + printed
- if params:
- 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
- else:
- func = "def " + suggested_name + "(**kwargs):\n" + printed
- try:
- # Try to write out the generated code
- with open('/tmp/%s' % suggested_name, 'w') as f:
- f.write(func)
- except:
- pass
- yield [("RETURN", [func])]
- def execute_jit(self, task_root, inst, taskname, params = {}, store=False, resolve=True):
- # execute_jit
- if resolve:
- try:
- inst = self.jit.body_cache[inst]
- except KeyError:
- body, = yield [("RD", [inst, "body"])]
- self.jit.body_cache[inst] = body
- inst = body
- if store:
- task_frame, = yield [("RD", [task_root, "frame"])]
- symbols, = yield [("RD", [task_frame, "symbols"])]
- dict_keys_ref, = yield [("RDK", [symbols])]
- if dict_keys_ref:
- dict_keys_ref_n = yield [("RD", [i, "name"]) for i in dict_keys_ref]
- dict_keys = yield [("RV", [i]) for i in dict_keys_ref_n]
- dict_values_elem = yield [("RDN", [symbols, i]) for i in dict_keys_ref]
- dict_values = yield [("RD", [i, "value"]) for i in dict_values_elem]
- parameters = dict(zip(dict_keys, dict_values))
- parameters.update(params)
- for p in parameters.keys():
- if not isinstance(parameters[p], dict):
- parameters[p] = {'id': parameters[p]}
- params = parameters
-
- params["root"] = self.root
- params["task_root"] = task_root
- params["taskname"] = taskname
- params["mvk"] = self
- # Have the JIT compile the function.
- if inst is None:
- suggested_name = self.jit.get_global_name(inst)
- if suggested_name is None:
- suggested_name = "func_%s" % str(inst)
- raise ValueError('body_id cannot be None: ' + str(suggested_name))
- elif inst in self.jit.jitted_entry_points:
- compiled_func = self.jit.jit_globals[self.jit.jitted_entry_points[inst]]
- else:
- compiled_func = self.jit.lookup_compiled_body(inst)
- if compiled_func is None:
- suggested_name = self.jit.get_global_name(inst)
- if suggested_name is None:
- suggested_name = "func_%s" % str(inst)
- compiled_func, = yield [("CALL_ARGS", [self.read_function, (inst, suggested_name)])]
- compiled_func = self.merge_function(compiled_func, suggested_name)
- self.jit.register_compiled(inst, compiled_func, suggested_name)
- # Run the compiled function.
- if self.profiling:
- self.profile_file.write(json.dumps([gen.__name__ for gen in self.request_handlers[taskname]['execute_rule'].generator_stack if gen is not None and gen.__name__ not in ['execute_rule', 'execute_jit']] + [time.time() - self.prev_timers[taskname]]) + "\n")
- self.prev_timers[taskname] = time.time()
- if compiled_func == primitive_functions.dict_read:
- if "value" not in params['b']:
- params['b']['value'], = yield [("RV", [params['b']['id']])]
- result, = yield [("RD", [params['a']['id'], params['b']['value']])]
- result = {'id': result}
- else:
- results = yield [("CALL_KWARGS", [compiled_func, params])]
- if results is None:
- raise Exception("%s: primitive finished without returning a value!" % (self.debug_info[taskname]))
- else:
- result, = results
- if result is None:
- result = {'id': None, 'value': None}
- if self.profiling:
- self.profile_file.write(json.dumps([gen.__name__ for gen in self.request_handlers[taskname]['execute_rule'].generator_stack if gen is not None and gen.__name__ not in ['execute_rule', 'execute_jit']] + [compiled_func.__name__, time.time() - self.prev_timers[taskname]]) + "\n")
- self.prev_timers[taskname] = time.time()
- if store:
- # Clean up the current stack, as if a return happened
- old_frame, exception_return = yield [
- ("RD", [task_frame, "prev"]),
- ("RD", [task_frame, primitive_functions.EXCEPTION_RETURN_KEY])]
- if "id" not in result:
- result['id'], = yield [("CNV", [result['value']])]
- if exception_return is not None:
- # The caller has requested that we throw an exception instead of injecting
- # the return value into the caller's frame. Read the comment at
- # primitive_functions.EXCEPTION_RETURN_KEY for the rationale behind this design.
- yield [("CD", [task_root, "frame", old_frame]),
- ("DN", [task_frame])]
- raise primitive_functions.InterpretedFunctionFinished(result)
- else:
- lnk, = yield [("RDE", [old_frame, "returnvalue"])]
- _, _, _, _ = yield [("CD", [old_frame, "returnvalue", result['id']]),
- ("CD", [task_root, "frame", old_frame]),
- ("DE", [lnk]),
- ("DN", [task_frame]),
- ]
- else:
- yield [("RETURN", [result])]
- yield [("RETURN", [None])]
- def merge_function(self, func, name):
- exec(func, self.jit.jit_globals)
- return self.jit.jit_globals[name]
- ########################################
- ### Execute input and output methods ###
- ########################################
- def get_output(self, taskname):
- task_root, = yield [("RD", [self.root, taskname])]
- first_output, = yield [("RD", [task_root, "output"])]
- next_output, rv = yield [("RD", [first_output, "next"]),
- ("RD", [first_output, "value"]),
- ]
- if next_output is None:
- self.success = False
- self.returnvalue = None
- else:
- rv_value, _, _ = \
- yield [("RV", [rv]),
- ("CD", [task_root, "output", next_output]),
- ("DN", [first_output]),
- ]
- self.returnvalue = rv_value
- self.success = True
- #print("OUTPUT: (%s, %s)" % (taskname, self.returnvalue))
- yield [("FINISH", [])]
- def set_input(self, taskname, value):
- task_root, = yield [("RD", [self.root, taskname])]
- old_input, link, new_input, new_value = \
- yield [("RD", [task_root, "last_input"]),
- ("RDE", [task_root, "last_input"]),
- ("CN", []),
- ("CNV", [value]),
- ]
- if new_value == None:
- new_value = self.root
- _, _, _, _ = yield [("CD", [task_root, "last_input", new_input]),
- ("CD", [old_input, "next", new_input]),
- ("CD", [old_input, "value", new_value]),
- ("DE", [link])
- ]
- #print("INPUT: (%s, %s)" % (taskname, value))
- self.returnvalue = {"id": 100, "value": "success"}
- yield [("FINISH", [])]
- #############################################
- ### Transformation rules for instructions ###
- #############################################
- def continue_init(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- inst, = yield [("RD", [task_frame, "IP"])]
- while_inst, = yield [("RD", [inst, "while"])]
- old_evalstack_link, old_phase_link, evalstack_roots = \
- yield [("RDE", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "phase"]),
- ("RRD", [while_inst, self.taskname]),
- ]
- if len(evalstack_roots) == 1:
- evalstack_root = evalstack_roots[0]
- else:
- print("Got roots: " + str(evalstack_roots))
- raise Exception("Could not process continue statement!")
- prev_evalstack_roots, old_evalstack_phase_link = \
- yield [("RRD", [evalstack_root, "prev"]),
- ("RDE", [evalstack_root, "phase"]),
- ]
- if len(prev_evalstack_roots) == 1:
- prev_evalstack_root = prev_evalstack_roots[0]
- else:
- raise Exception("Could not process continue statement!")
- new_evalstack_root, new_phase_while, new_phase_inst, prev_evalstack_root_link = \
- yield [("CN", []),
- ("CNV", ["init"]),
- ("CNV", ["finish"]),
- ("RDE", [prev_evalstack_root, "prev"]),
- ]
- _, _, _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "evalstack", new_evalstack_root]),
- ("CD", [new_evalstack_root, "prev", evalstack_root]),
- ("CD", [task_frame, "phase", new_phase_inst]),
- ("CD", [evalstack_root, "phase", new_phase_while]),
- ("DE", [old_evalstack_link]),
- ("DE", [prev_evalstack_root_link]),
- ("DE", [old_phase_link]),
- ("DE", [old_evalstack_phase_link]),
- ]
- yield [("RETURN", [None])]
- def break_init(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- inst, = yield [("RD", [task_frame, "IP"])]
- while_inst, = yield [("RD", [inst, "while"])]
- old_evalstack_link, old_phase_link, evalstack_roots = \
- yield [("RDE", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "phase"]),
- ("RRD", [while_inst, self.taskname]),
- ]
- if len(evalstack_roots) == 1:
- evalstack_root = evalstack_roots[0]
- else:
- raise Exception("Could not process break statement!")
- prev_evalstack_roots, old_evalstack_phase_link = \
- yield [("RRD", [evalstack_root, "prev"]),
- ("RDE", [evalstack_root, "phase"]),
- ]
- if len(prev_evalstack_roots) == 1:
- prev_evalstack_root = prev_evalstack_roots[0]
- else:
- raise Exception("Could not process break statement!")
- new_evalstack_root, new_phase_while, new_phase_inst, prev_evalstack_root_link = \
- yield [("CN", []),
- ("CNV", ["finish"]),
- ("CNV", ["finish"]),
- ("RDE", [prev_evalstack_root, "prev"]),
- ]
- _, _, _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "evalstack", new_evalstack_root]),
- ("CD", [new_evalstack_root, "prev", evalstack_root]),
- ("CD", [task_frame, "phase", new_phase_inst]),
- ("CD", [evalstack_root, "phase", new_phase_while]),
- ("DE", [old_evalstack_link]),
- ("DE", [prev_evalstack_root_link]),
- ("DE", [old_phase_link]),
- ("DE", [old_evalstack_phase_link]),
- ]
- yield [("RETURN", [None])]
- def if_init(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- evalstack, evalstack_link = \
- yield [("RD", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "evalstack"]),
- ]
- inst, ip_link = yield [("RD", [task_frame, "IP"]),
- ("RDE", [task_frame, "IP"]),
- ]
- cond, = yield [("RD", [inst, "cond"])]
- new_evalstack, new_phase = \
- yield [("CN", []),
- ("CNV", ["cond"]),
- ]
- _, _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "evalstack", new_evalstack]),
- ("CD", [new_evalstack, "prev", evalstack]),
- ("CD", [task_frame, "IP", cond]),
- ("CD", [evalstack, "inst", inst]),
- ("CD", [evalstack, "phase", new_phase]),
- ("DE", [evalstack_link]),
- ("DE", [ip_link]),
- ]
- yield [("RETURN", [None])]
- def if_cond(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- returnvalue, inst = yield [("RD", [task_frame, "returnvalue"]),
- ("RD", [task_frame, "IP"]),
- ]
- returnvalue_v, = yield [("RV", [returnvalue])]
- _else, = yield [("RD", [inst, "else"])]
- if returnvalue_v:
- phase_link, evalstack, evalstack_link, ip_link, _then, new_evalstack, evalstack_phase, new_phase = \
- yield [("RDE", [task_frame, "phase"]),
- ("RD", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "IP"]),
- ("RD", [inst, "then"]),
- ("CN", []),
- ("CNV", ["finish"]),
- ("CNV", ["init"]),
- ]
- _, _, _, _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "evalstack", new_evalstack]),
- ("CD", [task_frame, "IP", _then]),
- ("CD", [new_evalstack, "prev", evalstack]),
- ("CD", [evalstack, "inst", inst]),
- ("CD", [evalstack, "phase", evalstack_phase]),
- ("CD", [task_frame, "phase", new_phase]),
- ("DE", [evalstack_link]),
- ("DE", [ip_link]),
- ("DE", [phase_link]),
- ]
- elif _else is None:
- phase_link, new_phase = \
- yield [("RDE", [task_frame, "phase"]),
- ("CNV", ["finish"]),
- ]
- _, _ = yield [("CD", [task_frame, "phase", new_phase]),
- ("DE", [phase_link]),
- ]
- else:
- phase_link, evalstack, evalstack_link, ip_link = \
- yield [("RDE", [task_frame, "phase"]),
- ("RD", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "IP"]),
- ]
- new_evalstack, new_phase, evalstack_phase = \
- yield [("CN", []),
- ("CNV", ["init"]),
- ("CNV", ["finish"]),
- ]
- _, _, _, _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "evalstack", new_evalstack]),
- ("CD", [task_frame, "IP", _else]),
- ("CD", [new_evalstack, "prev", evalstack]),
- ("CD", [evalstack, "inst", inst]),
- ("CD", [evalstack, "phase", evalstack_phase]),
- ("CD", [task_frame, "phase", new_phase]),
- ("DE", [evalstack_link]),
- ("DE", [ip_link]),
- ("DE", [phase_link]),
- ]
- yield [("RETURN", [None])]
- def while_init(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- evalstack, evalstack_link, ip_link, inst = \
- yield [("RD", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "IP"]),
- ("RD", [task_frame, "IP"]),
- ]
- cond, new_evalstack, new_phase = \
- yield [("RD", [inst, "cond"]),
- ("CN", []),
- ("CNV", ["cond"]),
- ]
- _, _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "evalstack", new_evalstack]),
- ("CD", [new_evalstack, "prev", evalstack]),
- ("CD", [task_frame, "IP", cond]),
- ("CD", [evalstack, "phase", new_phase]),
- ("CD", [evalstack, "inst", inst]),
- ("DE", [evalstack_link]),
- ("DE", [ip_link]),
- ]
- yield [("RETURN", [None])]
- def while_cond(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- returnvalue, = yield [("RD", [task_frame, "returnvalue"])]
- returnvalue_v, = yield [("RV", [returnvalue])]
- if returnvalue_v:
- phase_link, evalstack, evalstack_link, ip_link, inst = \
- yield [("RDE", [task_frame, "phase"]),
- ("RD", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "IP"]),
- ("RD", [task_frame, "IP"]),
- ]
- body, = yield [("RD", [inst, "body"])]
- new_evalstack, new_phase, evalstack_phase = \
- yield [("CN", []),
- ("CNV", ["init"]),
- ("CNV", ["init"]),
- ]
- _, _, _, _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "IP", body]),
- ("CD", [task_frame, "phase", new_phase]),
- ("CD", [task_frame, "evalstack", new_evalstack]),
- ("CD", [new_evalstack, "prev", evalstack]),
- ("CD", [evalstack, "inst", inst]),
- ("CD", [evalstack, "phase", evalstack_phase]),
- ("DE", [evalstack_link]),
- ("DE", [ip_link]),
- ("DE", [phase_link]),
- ]
- # Check if we already have a taskname link to the evalstack
- links, = yield [("RD", [evalstack, self.taskname])]
- if links is None:
- yield [("CD", [evalstack, self.taskname, inst])]
- else:
- phase_link, new_phase = \
- yield [("RDE", [task_frame, "phase"]),
- ("CNV", ["finish"]),
- ]
- _, _ = yield [("CD", [task_frame, "phase", new_phase]),
- ("DE", [phase_link])
- ]
- yield [("RETURN", [None])]
- def access_init(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- evalstack, evalstack_link, inst, ip_link = \
- yield [("RD", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "evalstack"]),
- ("RD", [task_frame, "IP"]),
- ("RDE", [task_frame, "IP"]),
- ]
- var, new_evalstack, new_phase = \
- yield [("RD", [inst, "var"]),
- ("CN", []),
- ("CNV", ["eval"]),
- ]
- _, _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "IP", var]),
- ("CD", [task_frame, "evalstack", new_evalstack]),
- ("CD", [new_evalstack, "prev", evalstack]),
- ("CD", [evalstack, "inst", inst]),
- ("CD", [evalstack, "phase", new_phase]),
- ("DE", [evalstack_link]),
- ("DE", [ip_link]),
- ]
- yield [("RETURN", [None])]
- def access_eval(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- phase_link, returnvalue_link, returnvalue = \
- yield [("RDE", [task_frame, "phase"]),
- ("RDE", [task_frame, "returnvalue"]),
- ("RD", [task_frame, "returnvalue"]),
- ]
- value, new_phase = yield [("RD", [returnvalue, "value"]),
- ("CNV", ["finish"]),
- ]
- _, _, _, _ = yield [("CD", [task_frame, "phase", new_phase]),
- ("CD", [task_frame, "returnvalue", value]),
- ("DE", [phase_link]),
- ("DE", [returnvalue_link]),
- ]
- yield [("RETURN", [None])]
- def resolve_init(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- symbols, evalstack, evalstack_link, ip_link, inst = \
- yield [("RD", [task_frame, "symbols"]),
- ("RD", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "IP"]),
- ("RD", [task_frame, "IP"]),
- ]
- var, = yield [("RD", [inst, "var"])]
- variable, = yield [("RDN", [symbols, var])]
- if variable is None:
- phase_link, returnvalue_link, _globals, var_name = \
- yield [("RDE", [task_frame, "phase"]),
- ("RDE", [task_frame, "returnvalue"]),
- ("RD", [task_root, "globals"]),
- ("RV", [var]),
- ]
- variable, new_phase = \
- yield [("RD", [_globals, var_name]),
- ("CNV", ["finish"]),
- ]
- if variable is None:
- globs, = yield [("RDK", [_globals])]
- print("Globals: " + str(globs))
- globs = yield [("RV", [i]) for i in globs]
- print("Resolved globals: " + str(globs))
- raise Exception(jit.GLOBAL_NOT_FOUND_MESSAGE_FORMAT % var_name)
- # Resolved a global, so this is a string
- # Potentially, this might even be a function that we have precompiled already!
- # So check whether this is the case or not
- if self.allow_compiled:
- compiled_function = getattr(compiled_functions, var_name, None)
- if compiled_function is not None:
- # We have a compiled function ready!
- # Now we have to bind the ID to the compiled functions
- # For this, we read out the body of the resolved data
- compiler_val, = yield [("RD", [variable, "value"])]
- compiler_body, = yield [("RD", [compiler_val, "body"])]
- self.jit.register_compiled(compiler_body, compiled_function, var_name)
- # If we're dealing with a function, then we might want to figure out what its body id
- # is now so we can suggest a name to the JIT later.
- if self.jit.get_global_body_id(var_name) is None:
- compiler_val, = yield [("RD", [variable, "value"])]
- if compiler_val is not None:
- compiler_body, = yield [("RD", [compiler_val, "body"])]
- if compiler_body is not None:
- self.jit.register_global(compiler_body, var_name)
- else:
- phase_link, returnvalue_link, new_phase = \
- yield [("RDE", [task_frame, "phase"]),
- ("RDE", [task_frame, "returnvalue"]),
- ("CNV", ["finish"]),
- ]
- _, _, _, _ = yield [("CD", [task_frame, "phase", new_phase]),
- ("CD", [task_frame, "returnvalue", variable]),
- ("DE", [phase_link]),
- ("DE", [returnvalue_link]),
- ]
- yield [("RETURN", [None])]
- def assign_init(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- evalstack, evalstack_link, ip_link, inst = \
- yield [("RD", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "IP"]),
- ("RD", [task_frame, "IP"]),
- ]
- var, new_evalstack, new_phase = \
- yield [("RD", [inst, "var"]),
- ("CN", []),
- ("CNV", ["value"]),
- ]
- _, _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "IP", var]),
- ("CD", [task_frame, "evalstack", new_evalstack]),
- ("CD", [new_evalstack, "prev", evalstack]),
- ("CD", [evalstack, "inst", inst]),
- ("CD", [evalstack, "phase", new_phase]),
- ("DE", [evalstack_link]),
- ("DE", [ip_link]),
- ]
- yield [("RETURN", [None])]
- def assign_value(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- phase_link, evalstack, returnvalue, evalstack_link, ip_link, inst = \
- yield [("RDE", [task_frame, "phase"]),
- ("RD", [task_frame, "evalstack"]),
- ("RD", [task_frame, "returnvalue"]),
- ("RDE", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "IP"]),
- ("RD", [task_frame, "IP"]),
- ]
- value, new_evalstack, new_phase, evalstack_phase = \
- yield [("RD", [inst, "value"]),
- ("CN", []),
- ("CNV", ["init"]),
- ("CNV", ["assign"]),
- ]
- _, _, _, _, _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "variable", returnvalue]),
- ("CD", [task_frame, "phase", new_phase]),
- ("CD", [task_frame, "evalstack", new_evalstack]),
- ("CD", [new_evalstack, "prev", evalstack]),
- ("CD", [evalstack, "inst", inst]),
- ("CD", [evalstack, "phase", evalstack_phase]),
- ("CD", [task_frame, "IP", value]),
- ("DE", [evalstack_link]),
- ("DE", [phase_link]),
- ("DE", [ip_link]),
- ]
- yield [("RETURN", [None])]
- def assign_assign(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- phase_link, returnvalue, variable_link, variable = \
- yield [("RDE", [task_frame, "phase"]),
- ("RD", [task_frame, "returnvalue"]),
- ("RDE", [task_frame, "variable"]),
- ("RD", [task_frame, "variable"]),
- ]
- value_link, new_phase = \
- yield [("RDE", [variable, "value"]),
- ("CNV", ["finish"]),
- ]
- _, _, _, _, _ = yield [("CD", [task_frame, "phase", new_phase]),
- ("CD", [variable, "value", returnvalue]),
- ("DE", [variable_link]),
- ("DE", [value_link]),
- ("DE", [phase_link]),
- ]
- yield [("RETURN", [None])]
-
- def return_init(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- inst, = yield [("RD", [task_frame, "IP"])]
- value, = yield [("RD", [inst, "value"])]
- if value is None:
- prev_frame, = yield [("RD", [task_frame, "prev"])]
- # If the callee's frame is marked with the '__exception_return' key, then
- # we need to throw an exception instead of just finishing here. This design
- # gives us O(1) state reads per jit-interpreter transition.
- exception_return, = yield [("RD", [task_frame, primitive_functions.EXCEPTION_RETURN_KEY])]
- if prev_frame is None:
- _, = yield [("DN", [task_root])]
- del self.debug_info[self.taskname]
- #print("Cleanup task " + str(self.taskname))
- else:
- if self.debug_info[self.taskname]:
- self.debug_info[self.taskname].pop()
- _, _ = yield [("CD", [task_root, "frame", prev_frame]),
- ("DN", [task_frame]),
- ]
- if exception_return is not None:
- raise primitive_functions.InterpretedFunctionFinished(None)
- else:
- evalstack, evalstack_link, ip_link, new_evalstack, evalstack_phase = \
- yield [("RD", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "IP"]),
- ("CN", []),
- ("CNV", ["eval"]),
- ]
- _, _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "evalstack", new_evalstack]),
- ("CD", [new_evalstack, "prev", evalstack]),
- ("CD", [evalstack, "inst", inst]),
- ("CD", [evalstack, "phase", evalstack_phase]),
- ("CD", [task_frame, "IP", value]),
- ("DE", [evalstack_link]),
- ("DE", [ip_link]),
- ]
- yield [("RETURN", [None])]
- def return_eval(self, task_root):
- if self.debug_info[self.taskname]:
- self.debug_info[self.taskname].pop()
- task_frame, = yield [("RD", [task_root, "frame"])]
- prev_frame, = yield [("RD", [task_frame, "prev"])]
- if prev_frame is None:
- _, = yield [("DN", [task_root])]
- del self.debug_info[self.taskname]
- exception_return, returnvalue = yield [
- ("RD", [task_frame, primitive_functions.EXCEPTION_RETURN_KEY]),
- ("RD", [task_frame, "returnvalue"])]
- # If the callee's frame is marked with the '__exception_return' key, then
- # we need to throw an exception instead of just finishing here. This design
- # gives us O(1) state reads per jit-interpreter transition.
- if exception_return is not None:
- yield [
- ("CD", [task_root, "frame", prev_frame]),
- ("DN", [task_frame])]
- raise primitive_functions.InterpretedFunctionFinished(returnvalue)
- else:
- old_returnvalue_link, = yield [("RDE", [prev_frame, "returnvalue"])]
- yield [
- ("CD", [task_root, "frame", prev_frame]),
- ("CD", [prev_frame, "returnvalue", returnvalue]),
- ("DE", [old_returnvalue_link]),
- ("DN", [task_frame])]
- yield [("RETURN", [None])]
- def constant_init(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- phase_link, returnvalue_link, inst = \
- yield [("RDE", [task_frame, "phase"]),
- ("RDE", [task_frame, "returnvalue"]),
- ("RD", [task_frame, "IP"]),
- ]
- node, new_phase = yield [("RD", [inst, "node"]),
- ("CNV", ["finish"]),
- ]
- _, _, _, _ = yield [("CD", [task_frame, "phase", new_phase]),
- ("CD", [task_frame, "returnvalue", node]),
- ("DE", [returnvalue_link]),
- ("DE", [phase_link]),
- ]
- yield [("RETURN", [None])]
- def helper_init(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- inst, = yield [("RD", [task_frame, "IP"])]
- next, = yield [("RD", [inst, "next"])]
- if next is None:
- ip_link, phase_link, evalstack_top = \
- yield [("RDE", [task_frame, "IP"]),
- ("RDE", [task_frame, "phase"]),
- ("RD", [task_frame, "evalstack"]),
- ]
- evalstack, = yield [("RD", [evalstack_top, "prev"])]
- evalstack_inst, evalstack_phase, evalstack_inst_link, evalstack_phase_link = \
- yield [("RD", [evalstack, "inst"]),
- ("RD", [evalstack, "phase"]),
- ("RDE", [evalstack, "inst"]),
- ("RDE", [evalstack, "phase"]),
- ]
- _, _, _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "evalstack", evalstack]),
- ("CD", [task_frame, "IP", evalstack_inst]),
- ("CD", [task_frame, "phase", evalstack_phase]),
- ("DE", [ip_link]),
- ("DE", [phase_link]),
- ("DE", [evalstack_inst_link]),
- ("DE", [evalstack_phase_link]),
- ("DN", [evalstack_top]),
- ]
- else:
- ip_link, phase_link, new_phase = \
- yield [("RDE", [task_frame, "IP"]),
- ("RDE", [task_frame, "phase"]),
- ("CNV", ["init"]),
- ]
- _, _, _, _ = yield [("CD", [task_frame, "IP", next]),
- ("CD", [task_frame, "phase", new_phase]),
- ("DE", [ip_link]),
- ("DE", [phase_link]),
- ]
- yield [("RETURN", [None])]
- def call_init(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- symbols, evalstack, evalstack_link, ip_link, inst = \
- yield [("RD", [task_frame, "symbols"]),
- ("RD", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "IP"]),
- ("RD", [task_frame, "IP"]),
- ]
- func, params = yield [("RD", [inst, "func"]),
- ("RD", [inst, "params"]),
- ]
-
- if params is None:
- new_evalstack, evalstack_phase = \
- yield [("CN", []),
- ("CNV", ["call"]),
- ]
- _, _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "evalstack", new_evalstack]),
- ("CD", [new_evalstack, "prev", evalstack]),
- ("CD", [evalstack, "inst", inst]),
- ("CD", [evalstack, "phase", evalstack_phase]),
- ("CD", [task_frame, "IP", func]),
- ("DE", [evalstack_link]),
- ("DE", [ip_link]),
- ]
- else:
- new_evalstack,= yield [("CN", [])]
- _, _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "evalstack", new_evalstack]),
- ("CD", [new_evalstack, "prev", evalstack]),
- ("CD", [evalstack, "inst", inst]),
- ("CD", [evalstack, "phase", params]),
- ("CD", [task_frame, "IP", func]),
- ("DE", [evalstack_link]),
- ("DE", [ip_link]),
- ]
- yield [("RETURN", [None])]
- def call_call(self, task_root):
- self.debug_info[self.taskname].append("None")
- task_frame, = yield [("RD", [task_root, "frame"])]
- inst, = yield [("RD", [task_frame, "IP"])]
- param, = yield [("RD", [inst, "last_param"])]
- if param is None:
- returnvalue, = yield [("RD", [task_frame, "returnvalue"])]
- body, = yield [("RD", [returnvalue, "body"])]
- self.jit.mark_entry_point(body)
- phase_link, frame_link, prev_phase, new_phase, new_frame, new_evalstack, new_symbols, new_returnvalue = \
- yield [("RDE", [task_frame, "phase"]),
- ("RDE", [task_root, "frame"]),
- ("CNV", ["finish"]),
- ("CNV", ["init"]),
- ("CN", []),
- ("CN", []),
- ("CN", []),
- ("CN", []),
- ]
- _, _, _, _, _, _, _, _, _, _, _ = \
- yield [("CD", [task_root, "frame", new_frame]),
- ("CD", [new_frame, "evalstack", new_evalstack]),
- ("CD", [new_frame, "symbols", new_symbols]),
- ("CD", [new_frame, "returnvalue", new_returnvalue]),
- ("CD", [new_frame, "caller", inst]),
- ("CD", [new_frame, "phase", new_phase]),
- ("CD", [new_frame, "IP", body]),
- ("CD", [new_frame, "prev", task_frame]),
- ("CD", [task_frame, "phase", prev_phase]),
- ("DE", [phase_link]),
- ("DE", [frame_link]),
- ]
- else:
- newer_frames, invoking_frames = \
- yield [("RRD", [task_frame, "prev"]),
- ("RRD", [inst, "caller"]),
- ]
- new_frame = self.find_overlapping(newer_frames, invoking_frames)
- phase_link, frame_link, new_symbols, new_IP = \
- yield [("RDE", [task_frame, "phase"]),
- ("RDE", [task_root, "frame"]),
- ("RD", [new_frame, "symbols"]),
- ("RD", [new_frame, "IP"]),
- ]
- signature, = yield [("RRD", [new_IP, "body"])]
- signature = signature[0]
- sig_params, last_param = \
- yield [("RD", [signature, "params"]),
- ("RD", [inst, "last_param"]),
- ]
- self.jit.mark_entry_point(new_IP)
-
- name, = yield [("RD", [last_param, "name"])]
- name_value, = yield [("RV", [name])]
- returnvalue, formal_parameter, new_phase, variable = \
- yield [("RD", [task_frame, "returnvalue"]),
- ("RD", [sig_params, name_value]),
- ("CNV", ["finish"]),
- ("CN", []),
- ]
- _, _, _, t1 = yield [("CD", [task_root, "frame", new_frame]),
- ("CD", [task_frame, "phase", new_phase]),
- ("CD", [variable, "value", returnvalue]),
- ("CE", [new_symbols, variable]),
- ]
- _, _, _ = yield [("CE", [t1, formal_parameter]),
- ("DE", [frame_link]),
- ("DE", [phase_link]),
- ]
- yield [("RETURN", [None])]
- def find_overlapping(self, a, b):
- newer_frames = set(a)
- invoking_frames = set(b)
- matches = list(newer_frames.intersection(invoking_frames))
- if len(matches) == 1:
- return matches[0]
- elif len(matches) > 1:
- raise Exception("Error: multiple overlapping elements")
- else:
- raise Exception("Error: could not find any overlap")
- def call_param(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- inst, phase = yield [("RD", [task_frame, "IP"]),
- ("RD", [task_frame, "phase"]),
- ]
- params, last_param = \
- yield [("RD", [inst, "params"]),
- ("RD", [inst, "last_param"]),
- ]
- next_param, = yield [("RD", [params, "next_param"])]
- if params == phase:
- phase_link, ip_link, returnvalue, param_value, evalstack, evalstack_link = \
- yield [("RDE", [task_frame, "phase"]),
- ("RDE", [task_frame, "IP"]),
- ("RD", [task_frame, "returnvalue"]),
- ("RD", [params, "value"]),
- ("RD", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "evalstack"]),
- ]
- body, = yield [("RD", [returnvalue, "body"])]
- new_frame, prev_evalstack, new_phase, prev_phase, new_evalstack, new_symbols, new_returnvalue = \
- yield [("CN", []),
- ("CN", []),
- ("CNV", ["init"]),
- ("CNV", ["init"]),
- ("CN", []),
- ("CN", []),
- ("CN", []),
- ]
- _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = \
- yield [("CD", [new_frame, "evalstack", new_evalstack]),
- ("CD", [new_frame, "symbols", new_symbols]),
- ("CD", [new_frame, "returnvalue", new_returnvalue]),
- ("CD", [new_frame, "caller", inst]),
- ("CD", [new_frame, "phase", new_phase]),
- ("CD", [new_frame, "IP", body]),
- ("CD", [new_frame, "prev", task_frame]),
- ("CD", [task_frame, "phase", prev_phase]),
- ("CD", [task_frame, "IP", param_value]),
- ("CD", [prev_evalstack, "prev", evalstack]),
- ("CD", [evalstack, "inst", inst]),
- ("CD", [task_frame, "evalstack", prev_evalstack]),
- ("DE", [evalstack_link]),
- ("DE", [ip_link]),
- ("DE", [phase_link]),
- ]
- if next_param is not None:
- _ = yield [("CD", [evalstack, "phase", next_param])]
- else:
- evalstack_phase, = \
- yield [("CNV", ["call"])]
- _ = yield [("CD", [evalstack, "phase", evalstack_phase])]
- else:
- frame_link, phase_link, newer_frames, invoking_frames = \
- yield [("RDE", [task_root, "frame"]),
- ("RDE", [task_frame, "phase"]),
- ("RRD", [task_frame, "prev"]),
- ("RRD", [inst, "caller"]),
- ]
- new_frame = self.find_overlapping(newer_frames, invoking_frames)
- ip_link, evalstack, evalstack_link, new_symbols, new_IP = \
- yield [("RDE", [task_frame, "IP"]),
- ("RD", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "evalstack"]),
- ("RD", [new_frame, "symbols"]),
- ("RD", [new_frame, "IP"]),
- ]
- signature, = yield [("RRD", [new_IP, "body"])]
- signature = signature[0]
- sig_params, = yield [("RD", [signature, "params"])]
- if last_param == phase:
- prev_param, = \
- yield [("RRD", [last_param, "next_param"])]
- prev_param = prev_param[0]
- name, = yield [("RD", [prev_param, "name"])]
- name_value, = \
- yield [("RV", [name])]
- evalstack_phase, = \
- yield [("CNV", ["call"])]
- _ = yield [("CD", [evalstack, "phase", evalstack_phase])]
- formal_parameter, param_value = \
- yield [("RD", [sig_params, name_value]),
- ("RD", [last_param, "value"]),
- ]
- else:
- param_b, = yield [("RD", [task_frame, "phase"])]
- param_c, param_a = \
- yield [("RD", [param_b, "next_param"]),
- ("RRD", [param_b, "next_param"]),
- ]
- param_a = param_a[0]
- name, param_value = \
- yield [("RD", [param_a, "name"]),
- ("RD", [param_b, "value"]),
- ]
- name_value, = \
- yield [("RV", [name])]
- formal_parameter, _ = \
- yield [("RD", [sig_params, name_value]),
- ("CD", [evalstack, "phase", param_c]),
- ]
- new_phase, new_evalstack, variable, returnvalue = \
- yield [("CNV", ["init"]),
- ("CN", []),
- ("CN", []),
- ("RD", [task_frame, "returnvalue"]),
- ]
- _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "evalstack", new_evalstack]),
- ("CD", [new_evalstack, "prev", evalstack]),
- ("CD", [evalstack, "inst", inst]),
- ("CD", [task_frame, "phase", new_phase]),
- ("CD", [task_frame, "IP", param_value]),
- ("CD", [variable, "value", returnvalue]),
- ]
- t1, = yield [("CE", [new_symbols, variable])]
- _, _, _, _ = \
- yield [("CE", [t1, formal_parameter]),
- ("DE", [phase_link]),
- ("DE", [ip_link]),
- ("DE", [evalstack_link]),
- ]
- yield [("RETURN", [None])]
- def input_init(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- returnvalue_link, _input = \
- yield [("RDE", [task_frame, "returnvalue"]),
- ("RD", [task_root, "input"]),
- ]
- value, next, phase_link = \
- yield [("RD", [_input, "value"]),
- ("RD", [_input, "next"]),
- ("RDE", [task_frame, "phase"]),
- ]
- if value is not None:
- v = yield [("RV", [value])]
- _, _, finish = \
- yield [("CD", [task_frame, "returnvalue", value]),
- ("CD", [task_root, "input", next]),
- ("CNV", ["finish"]),
- ]
- _, _, _, _ = \
- yield [("CD", [task_frame, "phase", finish]),
- ("DN", [_input]),
- ("DE", [returnvalue_link]),
- ("DE", [phase_link]),
- ]
- self.input_value = value
- else:
- # No input yet, so just wait and don't advance IP or phase
- self.input_value = None
- ex = primitive_functions.SleepKernel(0.1, True)
- raise ex
- yield [("RETURN", [None])]
- def output_init(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- evalstack, evalstack_link, ip_link, inst = \
- yield [("RD", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "evalstack"]),
- ("RDE", [task_frame, "IP"]),
- ("RD", [task_frame, "IP"]),
- ]
- value, new_evalstack, evalstack_phase = \
- yield [("RD", [inst, "value"]),
- ("CN", []),
- ("CNV", ["output"]),
- ]
- _, _, _, _, _, _, _ = \
- yield [("CD", [task_frame, "evalstack", new_evalstack]),
- ("CD", [new_evalstack, "prev", evalstack]),
- ("CD", [evalstack, "inst", inst]),
- ("CD", [evalstack, "phase", evalstack_phase]),
- ("CD", [task_frame, "IP", value]),
- ("DE", [evalstack_link]),
- ("DE", [ip_link]),
- ]
- yield [("RETURN", [None])]
- def output_output(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- returnvalue_link, returnvalue, last_output, phase_link, last_output_link, new_last_output, finish = \
- yield [("RDE", [task_frame, "returnvalue"]),
- ("RD", [task_frame, "returnvalue"]),
- ("RD", [task_root, "last_output"]),
- ("RDE", [task_frame, "phase"]),
- ("RDE", [task_root, "last_output"]),
- ("CN", []),
- ("CNV", ["finish"]),
- ]
- _, _, _, _, _, _ = \
- yield [("CD", [last_output, "value", returnvalue]),
- ("CD", [last_output, "next", new_last_output]),
- ("CD", [task_root, "last_output", new_last_output]),
- ("CD", [task_frame, "phase", finish]),
- ("DE", [last_output_link]),
- ("DE", [phase_link]),
- ]
- yield [("RETURN", [None])]
- def declare_init(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- inst, = yield [("RD", [task_frame, "IP"])]
- new_var, symbols, phase_link, empty_node, new_phase = \
- yield [("RD", [inst, "var"]),
- ("RD", [task_frame, "symbols"]),
- ("RDE", [task_frame, "phase"]),
- ("CN", []),
- ("CNV", ["finish"]),
- ]
- exists, = yield [("RDN", [symbols, new_var])]
- if exists is None:
- new_edge, = yield [("CE", [symbols, empty_node])]
- _ = yield [("CE", [new_edge, new_var])]
- _, _ = yield [("CD", [task_frame, "phase", new_phase]),
- ("DE", [phase_link]),
- ]
- yield [("RETURN", [None])]
- def global_init(self, task_root):
- task_frame, = yield [("RD", [task_root, "frame"])]
- inst, = yield [("RD", [task_frame, "IP"])]
- new_var, global_symbols, phase_link, empty_node, new_phase = \
- yield [("RD", [inst, "var"]),
- ("RD", [task_root, "globals"]),
- ("RDE", [task_frame, "phase"]),
- ("CN", []),
- ("CNV", ["finish"]),
- ]
- value, = yield [("RV", [new_var])]
- exists, = yield [("RDE", [global_symbols, value])]
- if exists is not None:
- yield [("DE", [exists])]
-
- yield [("CD", [global_symbols, value, empty_node])]
- _, _ = yield [("CD", [task_frame, "phase", new_phase]),
- ("DE", [phase_link])
- ]
- yield [("RETURN", [None])]
|