Now, let's put the concepts from this chapter into practice by integrating a simple C++ function into our JAX workflow. While JAX and XLA are highly optimized, you might encounter situations where you need to leverage existing C++ libraries or implement custom, performance-critical operations directly in a lower-level language.

We'll explore two primary ways to achieve this: using callbacks for simpler integration and outlining the steps for creating a full custom primitive for deeper integration. For this hands-on example, we will focus on implementing the callback approach using ctypes and jax.pure_callback.

Scenario: A Custom Element-wise Operation

Imagine we have a specific element-wise operation we want to perform, defined by the function $f(x) = x^2 + 10$ . While trivial to implement directly in JAX, we'll pretend it's a complex legacy calculation implemented in C++ that we want to call.

Step 1: The C++ Implementation

First, let's write our simple C++ function. We need to ensure it has C linkage (extern "C") to prevent C++ name mangling, making it easily callable from Python via ctypes. We'll operate on arrays of doubles.

// custom_op.cpp
#include <vector>
#include <cmath> // For std::pow if needed, though x*x is simpler

// Use extern "C" to prevent C++ name mangling
extern "C" {
    // Function takes input array, output array, and size
    void custom_elementwise_func(const double* input, double* output, int size) {
        for (int i = 0; i < size; ++i) {
            output[i] = input[i] * input[i] + 10.0;
        }
    }
}

Step 2: Compile the C++ Code into a Shared Library

Now, we compile this C++ code into a shared library (.so on Linux/macOS, .dll on Windows). The specific command might vary slightly based on your compiler (g++ or clang) and operating system.

On Linux:

g++ -shared -fPIC -o custom_op.so custom_op.cpp

On macOS:

g++ -shared -o custom_op.dylib custom_op.cpp

On Windows (using MinGW/MSVC): (Command might differ)

g++ -shared -o custom_op.dll custom_op.cpp -Wl,--out-implib,libcustom_op.a

Make sure the compiled library (e.g., custom_op.so) is in a location where Python can find it, typically the current working directory for this example.

Step 3: Python Wrapper using `ctypes`

We'll use Python's built-in ctypes library to load the shared library and define the function signature for our custom_elementwise_func.

import ctypes
import numpy as np
import jax
import jax.numpy as jnp
from jax.experimental import host_callback as hcb # Using alias for brevity
from jax.experimental import pure_callback # Preferred for pure functions

# Load the shared library
try:
    # Adjust the path/name based on your OS and compilation
    lib = ctypes.CDLL('./custom_op.so') # Linux example
    # lib = ctypes.CDLL('./custom_op.dylib') # macOS example
    # lib = ctypes.CDLL('./custom_op.dll') # Windows example
except OSError as e:
    print(f"Error loading shared library: {e}")
    print("Ensure the C++ code is compiled and the library is in the correct path.")
    # Exit or handle error appropriately
    exit()


# Define the argument types and return type for the C function
lib.custom_elementwise_func.argtypes = [
    ctypes.POINTER(ctypes.c_double), # const double* input
    ctypes.POINTER(ctypes.c_double), # double* output
    ctypes.c_int                     # int size
]
lib.custom_elementwise_func.restype = None # void return type

# Create a Python wrapper function that handles NumPy array conversion
def custom_op_numpy(x_np: np.ndarray) -> np.ndarray:
    """Calls the C++ function using NumPy arrays."""
    if x_np.dtype != np.float64:
        # Ensure data is double precision as expected by C++
        x_np = x_np.astype(np.float64)

    # Ensure input is contiguous in memory
    x_np = np.ascontiguousarray(x_np)

    # Create an output array of the same shape and type
    output_np = np.empty_like(x_np)
    size = x_np.size

    # Get pointers to the data buffers
    input_ptr = x_np.ctypes.data_as(ctypes.POINTER(ctypes.c_double))
    output_ptr = output_np.ctypes.data_as(ctypes.POINTER(ctypes.c_double))

    # Call the C function
    lib.custom_elementwise_func(input_ptr, output_ptr, size)

    return output_np

# Test the NumPy wrapper directly (optional)
test_input_np = np.array([1.0, 2.0, 3.0], dtype=np.float64)
result_np = custom_op_numpy(test_input_np)
print(f"NumPy wrapper test: Input={test_input_np}, Output={result_np}")
# Expected output: [11. 14. 19.]

This Python wrapper custom_op_numpy takes a NumPy array, ensures it's the correct type (float64) and contiguous, prepares an output array, gets memory pointers using ctypes, calls the C function, and returns the result as a NumPy array.

Step 4: Integrate with JAX using `pure_callback`

Now, we integrate this NumPy-based function into JAX. Since our C++ function is mathematically pure (no side effects, output depends only on input), jax.pure_callback is the appropriate tool. It allows JAX to trace the function's shape/dtype behavior and integrate it into JIT-compiled computations, although the C++ code itself won't be optimized by XLA.

def custom_op_jax_via_callback(x: jax.Array) -> jax.Array:
    """JAX function calling the C++ code via pure_callback."""
    # Define the shape and dtype of the expected output
    # It's the same as the input for this element-wise operation
    result_shape_dtype = jax.ShapeDtypeStruct(x.shape, x.dtype)

    # Use pure_callback
    # Arguments:
    # 1. The callback function (takes NumPy arrays, returns NumPy array)
    # 2. The shape/dtype structure of the result
    # 3. The input JAX array(s)
    # vectorized=True tells JAX it can handle batch dimensions automatically
    # if the underlying C/Python function is designed for it (ours is implicitly).
    result = pure_callback(
        custom_op_numpy, result_shape_dtype, x, vectorized=True
    )
    return result

# Test the JAX function
x_jax = jnp.arange(1.0, 5.0, dtype=jnp.float64)
y_jax = custom_op_jax_via_callback(x_jax)

print(f"JAX callback test (eager): Input={x_jax}, Output={y_jax}")
# Expected output: [11. 14. 19. 26.]

# Verify that it works under JIT compilation
custom_op_jax_jit = jax.jit(custom_op_jax_via_callback)
y_jax_jit = custom_op_jax_jit(x_jax)

# Ensure computation completes before printing
y_jax_jit.block_until_ready()

print(f"JAX callback test (JIT): Input={x_jax}, Output={y_jax_jit}")
# Expected output: [11. 14. 19. 26.]

# Verify differentiation (will fail without custom rules!)
try:
    grad_func = jax.grad(lambda x: jnp.sum(custom_op_jax_via_callback(x)))
    g = grad_func(x_jax)
    print(f"Gradient calculation: {g}")
except Exception as e:
    print(f"\nGradient calculation failed as expected: {e}")
    print("Callbacks like pure_callback are not automatically differentiable.")

As demonstrated, pure_callback allows the C++ function (wrapped in Python) to be called from JIT-compiled JAX code. However, note the crucial limitation: JAX cannot automatically differentiate through the callback. The C++ code is opaque to JAX's autodiff system.

Alternative: Custom Primitive (Conceptual Outline)

If you need full integration, including automatic differentiation and potential XLA optimization for the call itself (though not the C++ internals), you would define a custom JAX primitive. This is a more involved process:

Define the Primitive: Create a jax.core.Primitive instance.

# Example structure - requires more imports and detail
# from jax import core
# custom_op_p = core.Primitive("custom_op")

Implement Abstract Evaluation: Define a function that tells JAX the output shape and dtype based on the input shapes and dtypes. This is used during tracing.

# def custom_op_abstract_eval(x_abstract):
#     # For element-wise, output shape/dtype is same as input
#     return jax.core.ShapedArray(x_abstract.shape, x_abstract.dtype)
# custom_op_p.def_abstract_eval(custom_op_abstract_eval)

Implement Lowering Rule(s): This is the most complex step. You need to tell XLA how to execute your primitive on each backend (CPU, GPU, TPU). This often involves writing code using XLA's HLO (High-Level Operations) instructions or using mechanisms like xla_client.ops.CustomCall to invoke your pre-compiled C++ function from the XLA-generated code.

# from jax.interpreters import xla
# def custom_op_xla_translation(ctx, x_operand, **params):
#      # Code to generate XLA HLO that calls the C++ function
#      # This might involve using XLA's ExternalCall or similar
#      # ... highly dependent on backend and XLA details ...
#      pass
# xla.register_translation(custom_op_p, custom_op_xla_translation)

Implement Differentiation Rule(s): Define the JVP (forward-mode) and/or VJP (reverse-mode) rules for your primitive. For our example

f(x) = x^2 + 10

, the derivative is

f'(x) = 2x

. You would implement rules that compute the JVP

(v \mapsto 2x \odot v)

and VJP

(v \mapsto 2x \odot v)

, where

\odot

is element-wise multiplication.

# from jax.interpreters import ad
# def custom_op_jvp_rule(primals, tangents):
#     (x,) = primals
#     (x_dot,) = tangents
#     y = custom_op_p.bind(x) # Call the primitive for primal output
#     # Derivative is 2*x, so JVP is (2*x) * x_dot
#     y_dot = (2 * x) * x_dot
#     return y, y_dot
# ad.primitive_jvps[custom_op_p] = custom_op_jvp_rule
#
# # Similarly for VJP rule (needed for jax.grad)
# def custom_op_vjp_rule(cotangent, x):
#    # VJP is mathematically equivalent to JVP for elementwise * scalar function
#    # vjp = lambda v: (2*x) * v
#    # return vjp(cotangent)
#    return (2 * x) * cotangent
# ad.primitive_transposes[custom_op_p] = custom_op_vjp_rule

Create Binding Function: Create a user-facing Python function that calls your primitive using primitive.bind().
```
# def custom_op_jax_via_primitive(x):
#    return custom_op_p.bind(x)
```

Creating a custom primitive provides the tightest integration but requires understanding JAX's internals and potentially XLA.

Summary

In this practice, we successfully integrated a simple C++ function into JAX using ctypes and jax.pure_callback. This approach is effective when you need to call external, pure functions from JIT-compiled code but do not require automatic differentiation through the external code.

Callbacks (pure_callback, host_callback): Easier to implement for existing code, good for non-differentiable parts or interfacing with systems having side-effects (host_callback). They act as opaque calls within the JAX computation graph. pure_callback is preferred for functionally pure external code.
Custom Primitives: Offer full integration, including potential backend optimization of the call itself and enabling automatic differentiation if rules are provided. This method is significantly more complex, requiring definitions for abstract evaluation, backend lowering, and differentiation.

Choose the method based on your specific needs regarding performance, differentiation, and the complexity you are willing to manage. For many use cases involving calling external libraries without needing gradients through them, callbacks provide a practical solution.

Practice: Integrating a C++ Function