4.6. Execution engine — Anaconda Enterprise 4.4 documentation

Anaconda Enterprise: Documentation

# 4.6. Execution engine

The execution engine is where actual code generation and execution happens. The currently supported LLVM version (LLVM 3.8) exposes one execution engine, named MCJIT.

## 4.6.1. Functions

`llvmlite.binding.` `create_mcjit_compiler`(module, target_machine)

  Create a MCJIT-powered engine from the given module and target_machine. A `ExecutionEngine` instance is returned. The module need not contain any code.

`llvmlite.binding.` `check_jit_execution`()

  Ensure the system allows creation of executable memory ranges for JIT-compiled code. If some security mechanism (such as SELinux) prevents it, an exception is raised. Otherwise the function returns silently.

  Calling this function early can help diagnose system configuration issues, instead of letting JIT-compiled functions crash mysteriously.

## 4.6.2. The ExecutionEngine class

class `llvmlite.binding.` `ExecutionEngine`

  A wrapper around a LLVM execution engine. The following methods and properties are available:

  `add_module`(module)

    Add the module (a `ModuleRef` instance) for code generation. When this method is called, ownership of the module is transferred to the execution engine.

  `finalize_object`()

    Make sure all modules owned by the execution engine are fully processed and “usable” for execution.

  `get_pointer_to_function`(gv)

    Warning

    This function is deprecated. User should use `ExecutionEngine.get_function_address()` and `ExecutionEngine.get_global_value_address()` instead

    Return the address of the function value gv, as an integer. The value should have been looked up on one of the modules owned by the execution engine.

    Note

    This method may implicitly generate code for the object being looked up.

    Note

    This function is formerly an alias to `get_pointer_to_global()`, which is now removed because it returns an invalid address in MCJIT when given a non-function global value.

  `get_function_address`(name)

    Return the address of the function named name as an integer.

  `get_global_value_address`(name)

    Return the address of the global value named name as an integer.

  `remove_module`(module)

    Remove the module (a `ModuleRef` instance) from the modules owned by the execution engine. This allows releasing the resources owned by the module without destroying the execution engine.

  `set_object_cache`(notify_func=None, getbuffer_func=None)

    Set the object cache callbacks for this engine.

    notify_func, if given, is called whenever the engine has finished compiling a module. It is passed two arguments `(module, buffer)`. The first argument module is a `ModuleRef` instance. The second argument buffer is a bytes object of the code generated for the module. The return value is ignored.

    getbuffer_func, if given, is called before the engine starts compiling a module. It is passed one argument, module, a `ModuleRef` instance of the module being compiled. The function can return `None`, in which case the module will be compiled normally. Or it can return a bytes object of native code for the module, which will bypass compilation entirely.

  `target_data`

    The `TargetData` used by the execution engine.