Halide 22.0.0 Halide compiler and libraries

Public Member Functions | List of all members
Halide::Callable Class Reference

`#include <Callable.h>`

## Public Member Functions
| Callable ()
| Construct a default Callable. More...
bool | defined () const
| Return true if the Callable is well-defined and usable, false if it is a default-constructed empty Callable. More...
template<typename... Args>
HALIDE_FUNCTION_ATTRS int | operator() (JITUserContext *context, Args &&...args) const
template<typename... Args>
HALIDE_FUNCTION_ATTRS int | operator() (Args &&...args) const
template<typename First , typename... Rest>
std::function< int(First, Rest...)> | make_std_function () const
| This allows us to construct a std::function<> that wraps the Callable. More...
int | call_argv_fast (size_t argc, const void *const *argv) const
| Unsafe low-overhead way of invoking the Callable. More...

## Detailed Description

Definition at line 82 of file Callable.h.

## Constructor & Destructor Documentation

## ◆ Callable()

Halide::Callable::Callable | ( |  | ) |

Construct a default Callable.

This is not usable (trying to call it will fail). The defined() method will return false.

## Member Function Documentation

## ◆ defined()

bool Halide::Callable::defined | ( |  | ) | const

Return true if the Callable is well-defined and usable, false if it is a default-constructed empty Callable.

## ◆ operator()() [1/2]

template<typename... Args>

HALIDE_FUNCTION_ATTRS int Halide::Callable::operator() | ( | JITUserContext * | context,
|  | Args &&... | args
| ) |  | const
| inline

Definition at line 314 of file Callable.h.

## ◆ operator()() [2/2]

template<typename... Args>

HALIDE_FUNCTION_ATTRS int Halide::Callable::operator() | ( | Args &&... | args | ) | const
| inline

Definition at line 320 of file Callable.h.

## ◆ make_std_function()

template<typename First , typename... Rest>

std::function< int(First, Rest...)> Halide::Callable::make_std_function | ( |  | ) | const
| inline

This allows us to construct a std::function<> that wraps the Callable.

This is nice in that it is, well, just a std::function, but also in that since the argument-count-and-type checking are baked into the language, we can do the relevant checking only once – when we first create the std::function – and skip it on all actual calls to the function, making it slightly more efficient. It's also more type-forgiving, in that the usual C++ numeric coercion rules apply here.

The downside is that there isn't (currently) any way to automatically infer the static types reliably, since we may be using (e.g.) a Param<void>, where the type in question isn't available to the C++ compiler. This means that the coder must supply the correct type signature when calling this function – but the good news is that if you get it wrong, this function will fail when you call it. (In other words: it can't choose the right thing for you, but it can tell you when you do the wrong thing.)

TODO: it's possible that we could infer the correct signatures in some cases, and only fail for the ambiguous cases, but that would require a lot more template-fu here and elsewhere. I think this is good enough for now.

TODO: is it possible to annotate the result of a std::function<> with HALIDE_FUNCTION_ATTRS?

Definition at line 347 of file Callable.h.

References call_argv_fast().

## ◆ call_argv_fast()

int Halide::Callable::call_argv_fast | ( | size_t | argc,
|  | const void *const * | argv
| ) |  | const

Unsafe low-overhead way of invoking the Callable.

This function relies on the same calling convention as the argv-based functions generated for ahead-of-time compiled Halide pilelines.

Very rough specifications of the calling convention (but check the source code to be sure):

- Arguments are passed in the same order as they appear in the C function argument list.
- The first entry in argv must always be a JITUserContext*. Please, note that this means that argv[0] actually contains JITUserContext**.
- All scalar arguments are passed by pointer, not by value, regardless of size.
- All buffer arguments (input or output) are passed as halide_buffer_t*.

Referenced by make_std_function().

The documentation for this class was generated from the following file:

- src/Callable.h