modelverse/kernel/modelverse_jit/runtime.py

import modelverse_kernel.primitives as primitive_functions

class JitCompilationFailedException(Exception):
    """A type of exception that is raised when the jit fails to compile a function."""
    pass

def call_function(function_id, named_arguments, **kwargs):
    """Makes the interpreter run the function with the given id with the specified
       argument dictionary."""
    user_root = kwargs['user_root']
    kernel = kwargs['mvk']
    body_id, = yield [("RD", [function_id, "body"])]
    kernel.jit.mark_entry_point(body_id)

    # Try to jit the function here. We might be able to avoid building the stack
    # frame.
    def handle_jit_failed(_):
        interpreter_args = {'body_id' : body_id, 'named_arguments' : named_arguments}
        interpreter_args.update(kwargs)
        yield [("TAIL_CALL_KWARGS", [interpret_function, interpreter_args])]

    yield [("TRY", [])]
    yield [("CATCH", [JitCompilationFailedException, handle_jit_failed])]
    # Try to compile.
    compiled_func, = yield [("CALL_ARGS", [kernel.jit_compile, (user_root, body_id)])]
    yield [("END_TRY", [])]
    # Add the keyword arguments to the argument dictionary.
    named_arguments.update(kwargs)
    # Run the function.
    yield [("TAIL_CALL_KWARGS", [compiled_func, named_arguments])]

def interpret_function(body_id, named_arguments, **kwargs):
    """Makes the interpreter run the function with the given id with the specified
       argument dictionary."""
    user_root = kwargs['user_root']
    kernel = kwargs['mvk']
    user_frame, = yield [("RD", [user_root, "frame"])]
    inst, = yield [("RD", [user_frame, "IP"])]

    # Create a new stack frame.
    frame_link, new_phase, new_frame, new_evalstack, new_symbols, \
        new_returnvalue, intrinsic_return = \
                    yield [("RDE", [user_root, "frame"]),
                           ("CNV", ["init"]),
                           ("CN", []),
                           ("CN", []),
                           ("CN", []),
                           ("CN", []),
                           ("CN", [])
                          ]

    _, _, _, _, _, _, _, _, _, _ = \
                    yield [("CD", [user_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_id]),
                           ("CD", [new_frame, "prev", user_frame]),
                           ("CD", [
                               new_frame,
                               primitive_functions.EXCEPTION_RETURN_KEY,
                               intrinsic_return]),
                           ("DE", [frame_link])
                          ]

    # Put the parameters in the new stack frame's symbol table.
    (parameter_vars, parameter_names), = yield [
        ("CALL_ARGS", [kernel.jit.jit_parameters, (body_id,)])]
    parameter_dict = dict(zip(parameter_names, parameter_vars))

    for (key, value) in named_arguments.items():
        param_var = parameter_dict[key]
        variable, = yield [("CN", [])]
        yield [("CD", [variable, "value", value])]
        symbol_edge, = yield [("CE", [new_symbols, variable])]
        yield [("CE", [symbol_edge, param_var])]

    username = kwargs['username']
    def exception_handler(ex):
        print('Returning from interpreted function. Result: %s' % ex.result)
        raise primitive_functions.PrimitiveFinished(ex.result)

    # Create an exception handler to catch and translate InterpretedFunctionFinished.
    yield [("TRY", [])]
    yield [("CATCH", [primitive_functions.InterpretedFunctionFinished, exception_handler])]
    while 1:
        result, = yield [("CALL_ARGS", [kernel.execute_rule, (username,)])]
        # An instruction has completed. Forward it.
        yield result

def get_input(**parameters):
    """Retrieves input."""
    mvk = parameters["mvk"]
    user_root = parameters["user_root"]
    while 1:
        yield [("CALL_ARGS", [mvk.input_init, (user_root,)])]
        # Finished
        if mvk.success:
            # Got some input, so we can access it
            raise primitive_functions.PrimitiveFinished(mvk.input_value)
        else:
            # No input, so yield None but don't stop
            yield None