runtime.py 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183
  1. import modelverse_kernel.primitives as primitive_functions
  2. class JitCompilationFailedException(Exception):
  3. """A type of exception that is raised when the jit fails to compile a function."""
  4. pass
  5. MUTABLE_FUNCTION_KEY = "mutable"
  6. """A dictionary key for functions that are mutable."""
  7. FUNCTION_BODY_KEY = "body"
  8. """A dictionary key for function bodies."""
  9. KWARGS_PARAMETER_NAME = "kwargs"
  10. """The name of the kwargs parameter in jitted functions."""
  11. CALL_FUNCTION_NAME = "__call_function"
  12. """The name of the '__call_function' function, in the jitted function scope."""
  13. GET_INPUT_FUNCTION_NAME = "__get_input"
  14. """The name of the '__get_input' function, in the jitted function scope."""
  15. JIT_THUNK_CONSTANT_FUNCTION_NAME = "__jit_thunk_constant_function"
  16. """The name of the jit_thunk_constant_function function in the JIT's global context."""
  17. JIT_THUNK_GLOBAL_FUNCTION_NAME = "__jit_thunk_global"
  18. """The name of the jit_thunk_global function in the JIT's global context."""
  19. UNREACHABLE_FUNCTION_NAME = "__unreachable"
  20. """The name of the unreachable function in the JIT's global context."""
  21. LOCALS_NODE_NAME = "jit_locals"
  22. """The name of the node that is connected to all JIT locals in a given function call."""
  23. LOCALS_EDGE_NAME = "jit_locals_edge"
  24. """The name of the edge that connects the LOCALS_NODE_NAME node to a user root."""
  25. GLOBAL_NOT_FOUND_MESSAGE_FORMAT = "Not found as global: %s"
  26. """The format of the 'not found as global' message. Takes a single argument."""
  27. BASELINE_JIT_ORIGIN_NAME = "baseline-jit"
  28. """The origin name for functions that were produced by the baseline JIT."""
  29. FAST_JIT_ORIGIN_NAME = "fast-jit"
  30. """The origin name for functions that were produced by the fast JIT."""
  31. def format_stack_frame(function_name, debug_info, origin='unknown'):
  32. """Formats a stack frame, which consists of a function name, debug
  33. information and an origin."""
  34. if function_name is None:
  35. function_name = 'unknown function'
  36. if debug_info is None:
  37. debug_info = '[unknown location] '
  38. return '%sin %s (%s)' % (debug_info, function_name, origin)
  39. def format_trace_message(debug_info, function_name, origin='unknown'):
  40. """Creates a formatted trace message."""
  41. return 'TRACE: %s' % format_stack_frame(function_name, debug_info, origin)
  42. def call_function(function_id, named_arguments, **kwargs):
  43. """Runs the function with the given id, passing it the specified argument dictionary."""
  44. task_root = kwargs['task_root']
  45. kernel = kwargs['mvk']
  46. body_id, is_mutable = yield [
  47. ("RD", [function_id, FUNCTION_BODY_KEY]),
  48. ("RD", [function_id, MUTABLE_FUNCTION_KEY])]
  49. # Try to jit the function here. We might be able to avoid building the stack
  50. # frame.
  51. def handle_jit_failed(_):
  52. """Interprets the function."""
  53. interpreter_args = {'body_id' : body_id, 'named_arguments' : named_arguments}
  54. interpreter_args.update(kwargs)
  55. yield [("TAIL_CALL_KWARGS", [interpret_function_body, interpreter_args])]
  56. if is_mutable is not None:
  57. kernel.jit.mark_no_jit(body_id)
  58. yield [("TAIL_CALL_ARGS", [handle_jit_failed, ()])]
  59. else:
  60. kernel.jit.mark_entry_point(body_id)
  61. yield [("TRY", [])]
  62. yield [("CATCH", [JitCompilationFailedException, handle_jit_failed])]
  63. # Try to compile.
  64. compiled_func, = yield [("CALL_ARGS", [kernel.jit_compile, (task_root, body_id)])]
  65. yield [("END_TRY", [])]
  66. # Add the keyword arguments to the argument dictionary.
  67. named_arguments.update(kwargs)
  68. # Run the function.
  69. yield [("TAIL_CALL_KWARGS", [compiled_func, named_arguments])]
  70. def interpret_function(function_id, named_arguments, **kwargs):
  71. """Makes the interpreter run the function with the given id for the specified
  72. argument dictionary."""
  73. body_id, = yield [("RD", [function_id, FUNCTION_BODY_KEY])]
  74. args = {'body_id' : body_id, named_arguments : named_arguments}
  75. args.update(kwargs)
  76. yield [("TAIL_CALL_KWARGS", [interpret_function_body, args])]
  77. def interpret_function_body(body_id, named_arguments, **kwargs):
  78. """Makes the interpreter run the function body with the given id for the specified
  79. argument dictionary."""
  80. task_root = kwargs['task_root']
  81. kernel = kwargs['mvk']
  82. user_frame, = yield [("RD", [task_root, "frame"])]
  83. inst, = yield [("RD", [user_frame, "IP"])]
  84. kernel.jit.mark_entry_point(body_id)
  85. # Create a new stack frame.
  86. frame_link, new_phase, new_frame, new_evalstack, new_symbols, \
  87. new_returnvalue, intrinsic_return = \
  88. yield [("RDE", [task_root, "frame"]),
  89. ("CNV", ["init"]),
  90. ("CN", []),
  91. ("CN", []),
  92. ("CN", []),
  93. ("CN", []),
  94. ("CN", [])
  95. ]
  96. _, _, _, _, _, _, _, _, _, _ = \
  97. yield [("CD", [task_root, "frame", new_frame]),
  98. ("CD", [new_frame, "evalstack", new_evalstack]),
  99. ("CD", [new_frame, "symbols", new_symbols]),
  100. ("CD", [new_frame, "returnvalue", new_returnvalue]),
  101. ("CD", [new_frame, "caller", inst]),
  102. ("CD", [new_frame, "phase", new_phase]),
  103. ("CD", [new_frame, "IP", body_id]),
  104. ("CD", [new_frame, "prev", user_frame]),
  105. ("CD", [
  106. new_frame,
  107. primitive_functions.EXCEPTION_RETURN_KEY,
  108. intrinsic_return]),
  109. ("DE", [frame_link])
  110. ]
  111. # Put the parameters in the new stack frame's symbol table.
  112. (parameter_vars, parameter_names, _), = yield [
  113. ("CALL_ARGS", [kernel.jit.jit_signature, (body_id,)])]
  114. parameter_dict = dict(zip(parameter_names, parameter_vars))
  115. for (key, value) in named_arguments.items():
  116. param_var = parameter_dict[key]
  117. variable, = yield [("CN", [])]
  118. yield [("CD", [variable, "value", value])]
  119. symbol_edge, = yield [("CE", [new_symbols, variable])]
  120. yield [("CE", [symbol_edge, param_var])]
  121. taskname = kwargs['taskname']
  122. def exception_handler(ex):
  123. # print('Returning from interpreted function. Result: %s' % ex.result)
  124. raise primitive_functions.PrimitiveFinished(ex.result)
  125. # Create an exception handler to catch and translate InterpretedFunctionFinished.
  126. yield [("TRY", [])]
  127. yield [("CATCH", [primitive_functions.InterpretedFunctionFinished, exception_handler])]
  128. while 1:
  129. result, = yield [("CALL_ARGS", [kernel.execute_rule, (taskname,)])]
  130. # An instruction has completed. Forward it.
  131. yield result
  132. class UnreachableCodeException(Exception):
  133. """The type of exception that is thrown when supposedly unreachable code is executed."""
  134. pass
  135. def unreachable():
  136. """Marks unreachable code."""
  137. raise UnreachableCodeException('An unreachable statement was reached.')
  138. def get_input(**parameters):
  139. """Retrieves input."""
  140. mvk = parameters["mvk"]
  141. task_root = parameters["task_root"]
  142. while 1:
  143. yield [("CALL_ARGS", [mvk.input_init, (task_root,)])]
  144. # Finished
  145. if mvk.success:
  146. # Got some input, so we can access it
  147. raise primitive_functions.PrimitiveFinished(mvk.input_value)
  148. else:
  149. # No input, so yield None but don't stop
  150. yield None