Automatic module jitting with jit_module

A common usage pattern is to have an entire module containing user-defined functions that all need to be jitted. One option to accomplish this is to manually apply the @jit decorator to each function definition. This approach works and is great in many cases. However, for large modules with many functions, manually jit-wrapping each function definition can be tedious. For these situations, Numba provides another option, the jit_module function, to automatically replace functions declared in a module with their jit-wrapped equivalents.

It’s important to note the conditions under which jit_module will not impact a function:

  1. Functions which have already been wrapped with a Numba decorator (e.g. jit, vectorize, cfunc, etc.) are not impacted by jit_module.

  2. Functions which are declared outside the module from which jit_module is called are not automatically jit-wrapped.

  3. Function declarations which occur logically after calling jit_module are not impacted.

All other functions in a module will have the @jit decorator automatically applied to them. See the following section for an example use case.

Note

This feature is for use by module authors. jit_module should not be called outside the context of a module containing functions to be jitted.

Example usage

Let’s assume we have a Python module we’ve created, mymodule.py (shown below), which contains several functions. Some of these functions are defined in mymodule.py while others are imported from other modules. We wish to have all the functions which are defined in mymodule.py jitted using jit_module.

# mymodule.py

from numba import jit, jit_module

def inc(x):
   return x + 1

def add(x, y):
   return x + y

import numpy as np
# Use NumPy's mean function
mean = np.mean

@jit(nogil=True)
def mul(a, b):
   return a * b

jit_module(nopython=True, error_model="numpy")

def div(a, b):
    return a / b

There are several things to note in the above example:

  • Both the inc and add functions will be replaced with their jit-wrapped equivalents with compilation options nopython=True and error_model="numpy".

  • The mean function, because it’s defined outside of mymodule.py in NumPy, will not be modified.

  • mul will not be modified because it has been manually decorated with jit.

  • div will not be automatically jit-wrapped because it is declared after jit_module is called.

When the above module is imported, we have:

>>> import mymodule
>>> mymodule.inc
CPUDispatcher(<function inc at 0x1032f86a8>)
>>> mymodule.mean
<function mean at 0x1096b8950>

API

Warning

This feature is experimental. The supported features may change with or without notice.

numba.jit_module(\*\*kwargs)

Automatically jit-wraps functions defined in a Python module

Note that jit_module should only be called at the end of the module to be jitted. In addition, only functions which are defined in the module jit_module is called from are considered for automatic jit-wrapping. See the Numba documentation for more information about what can/cannot be jitted.

Parameters

kwargs – Keyword arguments to pass to jit such as nopython or error_model.