Halide 19.0.0
Halide compiler and libraries
Loading...
Searching...
No Matches
HalideRuntime.h
Go to the documentation of this file.
1#ifndef HALIDE_HALIDERUNTIME_H
2#define HALIDE_HALIDERUNTIME_H
3
4#ifndef COMPILING_HALIDE_RUNTIME
5#ifdef __cplusplus
6#include <array>
7#include <cstddef>
8#include <cstdint>
9#include <cstring>
10#include <string_view>
11#else
12#include <stdbool.h>
13#include <stddef.h>
14#include <stdint.h>
15#include <string.h>
16#endif
17#else
18#include "runtime_internal.h"
19#endif
20
21// Note that the canonical Halide version is considered to be defined here
22// (rather than in the build system); we redundantly define the value in
23// our CMake build, so that we ensure that the in-build metadata (eg soversion)
24// matches, but keeping the canonical version here makes it easier to keep
25// downstream build systems (eg Blaze/Bazel) properly in sync with the source.
26#define HALIDE_VERSION_MAJOR 19
27#define HALIDE_VERSION_MINOR 0
28#define HALIDE_VERSION_PATCH 0
29
30#ifdef __cplusplus
31// Forward declare type to allow naming typed handles.
32// See Type.h for documentation.
33template<typename T>
35#endif
36
37#ifdef __cplusplus
38extern "C" {
39#endif
40
41#ifdef _MSC_VER
42// Note that (for MSVC) you should not use "inline" along with HALIDE_ALWAYS_INLINE;
43// it is not necessary, and may produce warnings for some build configurations.
44#define HALIDE_ALWAYS_INLINE __forceinline
45#define HALIDE_NEVER_INLINE __declspec(noinline)
46#else
47// Note that (for Posixy compilers) you should always use "inline" along with HALIDE_ALWAYS_INLINE;
48// otherwise some corner-case scenarios may erroneously report link errors.
49#define HALIDE_ALWAYS_INLINE inline __attribute__((always_inline))
50#define HALIDE_NEVER_INLINE __attribute__((noinline))
51#endif
52
53#ifndef HALIDE_MUST_USE_RESULT
54#ifdef __has_attribute
55#if __has_attribute(nodiscard)
56// C++17 or later
57#define HALIDE_MUST_USE_RESULT [[nodiscard]]
58#elif __has_attribute(warn_unused_result)
59// Clang/GCC
60#define HALIDE_MUST_USE_RESULT __attribute__((warn_unused_result))
61#else
62#define HALIDE_MUST_USE_RESULT
63#endif
64#else
65#define HALIDE_MUST_USE_RESULT
66#endif
67#endif
68
69// Annotation for AOT and JIT calls -- if undefined, use no annotation.
70// To ensure that all results are checked, do something like
71//
72// -DHALIDE_FUNCTION_ATTRS=HALIDE_MUST_USE_RESULT
73//
74// in your C++ compiler options
75#ifndef HALIDE_FUNCTION_ATTRS
76#define HALIDE_FUNCTION_ATTRS
77#endif
78
79#ifndef HALIDE_EXPORT_SYMBOL
80#ifdef _MSC_VER
81#define HALIDE_EXPORT_SYMBOL __declspec(dllexport)
82#else
83#define HALIDE_EXPORT_SYMBOL __attribute__((visibility("default")))
84#endif
85#endif
86
87#ifndef COMPILING_HALIDE_RUNTIME
88
89// ASAN builds can cause linker errors for Float16, so sniff for that and
90// don't enable it by default.
91#if defined(__has_feature)
92#if __has_feature(address_sanitizer)
93#define HALIDE_RUNTIME_ASAN_DETECTED
94#endif
95#endif
96
97#if defined(__SANITIZE_ADDRESS__) && !defined(HALIDE_RUNTIME_ASAN_DETECTED)
98#define HALIDE_RUNTIME_ASAN_DETECTED
99#endif
100
101#if !defined(HALIDE_RUNTIME_ASAN_DETECTED)
102
103// clang had _Float16 added as a reserved name in clang 8, but
104// doesn't actually support it on most platforms until clang 15.
105// Ideally there would be a better way to detect if the type
106// is supported, even in a compiler independent fashion, but
107// coming up with one has proven elusive.
108#if defined(__clang__) && (__clang_major__ >= 15) && !defined(__EMSCRIPTEN__) && !defined(__i386__)
109#if defined(__is_identifier)
110#if !__is_identifier(_Float16)
111#define HALIDE_CPP_COMPILER_HAS_FLOAT16
112#endif
113#endif
114#endif
115
116// Similarly, detecting _Float16 for gcc is problematic.
117// For now, we say that if >= v12, and compiling on x86 or arm,
118// we assume support. This may need revision.
119#if defined(__GNUC__) && (__GNUC__ >= 12)
120#if defined(__x86_64__) || (defined(__i386__) && (__GNUC__ >= 14) && defined(__SSE2__)) || ((defined(__arm__) || defined(__aarch64__)) && (__GNUC__ >= 13))
121#define HALIDE_CPP_COMPILER_HAS_FLOAT16
122#endif
123#endif
124
125#endif // !HALIDE_RUNTIME_ASAN_DETECTED
126
127#endif // !COMPILING_HALIDE_RUNTIME
128
129/** \file
130 *
131 * This file declares the routines used by Halide internally in its
132 * runtime. On platforms that support weak linking, these can be
133 * replaced with user-defined versions by defining an extern "C"
134 * function with the same name and signature.
135 *
136 * When doing Just In Time (JIT) compilation members of
137 * some_pipeline_or_func.jit_handlers() must be replaced instead. The
138 * corresponding methods are documented below.
139 *
140 * All of these functions take a "void *user_context" parameter as their
141 * first argument; if the Halide kernel that calls back to any of these
142 * functions has been compiled with the UserContext feature set on its Target,
143 * then the value of that pointer passed from the code that calls the
144 * Halide kernel is piped through to the function.
145 *
146 * Some of these are also useful to call when using the default
147 * implementation. E.g. halide_shutdown_thread_pool.
148 *
149 * Note that even on platforms with weak linking, some linker setups
150 * may not respect the override you provide. E.g. if the override is
151 * in a shared library and the halide object files are linked directly
152 * into the output, the builtin versions of the runtime functions will
153 * be called. See your linker documentation for more details. On
154 * Linux, LD_DYNAMIC_WEAK=1 may help.
155 *
156 */
157
158// Forward-declare to suppress warnings if compiling as C.
159struct halide_buffer_t;
160
161/** Print a message to stderr. Main use is to support tracing
162 * functionality, print, and print_when calls. Also called by the default
163 * halide_error. This function can be replaced in JITed code by using
164 * halide_custom_print and providing an implementation of halide_print
165 * in AOT code. See Func::set_custom_print.
166 */
167// @{
168extern void halide_print(void *user_context, const char *);
169extern void halide_default_print(void *user_context, const char *);
170typedef void (*halide_print_t)(void *, const char *);
172// @}
173
174/** Halide calls this function on runtime errors (for example bounds
175 * checking failures). This function can be replaced in JITed code by
176 * using Func::set_error_handler, or in AOT code by calling
177 * halide_set_error_handler. In AOT code on platforms that support
178 * weak linking (i.e. not Windows), you can also override it by simply
179 * defining your own halide_error.
180 */
181// @{
182extern void halide_error(void *user_context, const char *);
183extern void halide_default_error(void *user_context, const char *);
184typedef void (*halide_error_handler_t)(void *, const char *);
186// @}
187
188/** Cross-platform mutex. Must be initialized with zero and implementation
189 * must treat zero as an unlocked mutex with no waiters, etc.
190 */
194
195/** Cross platform condition variable. Must be initialized to 0. */
199
200/** A basic set of mutex and condition variable functions, which call
201 * platform specific code for mutual exclusion. Equivalent to posix
202 * calls. */
203//@{
204extern void halide_mutex_lock(struct halide_mutex *mutex);
205extern void halide_mutex_unlock(struct halide_mutex *mutex);
206extern void halide_cond_signal(struct halide_cond *cond);
207extern void halide_cond_broadcast(struct halide_cond *cond);
208extern void halide_cond_wait(struct halide_cond *cond, struct halide_mutex *mutex);
209//@}
210
211/** Functions for constructing/destroying/locking/unlocking arrays of mutexes. */
212struct halide_mutex_array;
213//@{
215extern void halide_mutex_array_destroy(void *user_context, void *array);
216extern int halide_mutex_array_lock(struct halide_mutex_array *array, int entry);
217extern int halide_mutex_array_unlock(struct halide_mutex_array *array, int entry);
218//@}
219
220/** Define halide_do_par_for to replace the default thread pool
221 * implementation. halide_shutdown_thread_pool can also be called to
222 * release resources used by the default thread pool on platforms
223 * where it makes sense. See Func::set_custom_do_task and
224 * Func::set_custom_do_par_for. Should return zero if all the jobs
225 * return zero, or an arbitrarily chosen return value from one of the
226 * jobs otherwise.
227 */
228//@{
229typedef int (*halide_task_t)(void *user_context, int task_number, uint8_t *closure);
230extern int halide_do_par_for(void *user_context,
231 halide_task_t task,
232 int min, int size, uint8_t *closure);
233extern void halide_shutdown_thread_pool(void);
234//@}
235
236/** Set a custom method for performing a parallel for loop. Returns
237 * the old do_par_for handler. */
238typedef int (*halide_do_par_for_t)(void *, halide_task_t, int, int, uint8_t *);
240
241/** An opaque struct representing a semaphore. Used by the task system for async tasks. */
245
246/** A struct representing a semaphore and a number of items that must
247 * be acquired from it. Used in halide_parallel_task_t below. */
252extern int halide_semaphore_init(struct halide_semaphore_t *, int n);
253extern int halide_semaphore_release(struct halide_semaphore_t *, int n);
254extern bool halide_semaphore_try_acquire(struct halide_semaphore_t *, int n);
255typedef int (*halide_semaphore_init_t)(struct halide_semaphore_t *, int);
256typedef int (*halide_semaphore_release_t)(struct halide_semaphore_t *, int);
258
259/** A task representing a serial for loop evaluated over some range.
260 * Note that task_parent is a pass through argument that should be
261 * passed to any dependent taks that are invoked using halide_do_parallel_tasks
262 * underneath this call. */
263typedef int (*halide_loop_task_t)(void *user_context, int min, int extent,
264 uint8_t *closure, void *task_parent);
265
266/** A parallel task to be passed to halide_do_parallel_tasks. This
267 * task may recursively call halide_do_parallel_tasks, and there may
268 * be complex dependencies between seemingly unrelated tasks expressed
269 * using semaphores. If you are using a custom task system, care must
270 * be taken to avoid potential deadlock. This can be done by carefully
271 * respecting the static metadata at the end of the task struct.*/
273 // The function to call. It takes a user context, a min and
274 // extent, a closure, and a task system pass through argument.
276
277 // The closure to pass it
279
280 // The name of the function to be called. For debugging purposes only.
281 const char *name;
282
283 // An array of semaphores that must be acquired before the
284 // function is called. Must be reacquired for every call made.
287
288 // The entire range the function should be called over. This range
289 // may be sliced up and the function called multiple times.
291
292 // A parallel task provides several pieces of metadata to prevent
293 // unbounded resource usage or deadlock.
294
295 // The first is the minimum number of execution contexts (call
296 // stacks or threads) necessary for the function to run to
297 // completion. This may be greater than one when there is nested
298 // parallelism with internal producer-consumer relationships
299 // (calling the function recursively spawns and blocks on parallel
300 // sub-tasks that communicate with each other via semaphores). If
301 // a parallel runtime calls the function when fewer than this many
302 // threads are idle, it may need to create more threads to
303 // complete the task, or else risk deadlock due to committing all
304 // threads to tasks that cannot complete without more.
305 //
306 // FIXME: Note that extern stages are assumed to only require a
307 // single thread to complete. If the extern stage is itself a
308 // Halide pipeline, this may be an underestimate.
310
311 // The calls to the function should be in serial order from min to min+extent-1, with only
312 // one executing at a time. If false, any order is fine, and
313 // concurrency is fine.
314 bool serial;
315};
316
317/** Enqueue some number of the tasks described above and wait for them
318 * to complete. While waiting, the calling threads assists with either
319 * the tasks enqueued, or other non-blocking tasks in the task
320 * system. Note that task_parent should be NULL for top-level calls
321 * and the pass through argument if this call is being made from
322 * another task. */
323extern int halide_do_parallel_tasks(void *user_context, int num_tasks,
324 struct halide_parallel_task_t *tasks,
325 void *task_parent);
326
327/** If you use the default do_par_for, you can still set a custom
328 * handler to perform each individual task. Returns the old handler. */
329//@{
330typedef int (*halide_do_task_t)(void *, halide_task_t, int, uint8_t *);
332extern int halide_do_task(void *user_context, halide_task_t f, int idx,
333 uint8_t *closure);
334//@}
335
336/** The version of do_task called for loop tasks. By default calls the
337 * loop task with the same arguments. */
338// @{
339typedef int (*halide_do_loop_task_t)(void *, halide_loop_task_t, int, int, uint8_t *, void *);
341extern int halide_do_loop_task(void *user_context, halide_loop_task_t f, int min, int extent,
342 uint8_t *closure, void *task_parent);
343//@}
344
345/** Provide an entire custom tasking runtime via function
346 * pointers. Note that do_task and semaphore_try_acquire are only ever
347 * called by halide_default_do_par_for and
348 * halide_default_do_parallel_tasks, so it's only necessary to provide
349 * those if you are mixing in the default implementations of
350 * do_par_for and do_parallel_tasks. */
351// @{
352typedef int (*halide_do_parallel_tasks_t)(void *, int, struct halide_parallel_task_t *,
353 void *task_parent);
362// @}
363
364/** The default versions of the parallel runtime functions. */
365// @{
366extern int halide_default_do_par_for(void *user_context,
367 halide_task_t task,
368 int min, int size, uint8_t *closure);
369extern int halide_default_do_parallel_tasks(void *user_context,
370 int num_tasks,
371 struct halide_parallel_task_t *tasks,
372 void *task_parent);
373extern int halide_default_do_task(void *user_context, halide_task_t f, int idx,
375extern int halide_default_do_loop_task(void *user_context, halide_loop_task_t f,
376 int min, int extent,
377 uint8_t *closure, void *task_parent);
378extern int halide_default_semaphore_init(struct halide_semaphore_t *, int n);
379extern int halide_default_semaphore_release(struct halide_semaphore_t *, int n);
381// @}
382
383struct halide_thread;
384
385/** Spawn a thread. Returns a handle to the thread for the purposes of
386 * joining it. The thread must be joined in order to clean up any
387 * resources associated with it. */
388extern struct halide_thread *halide_spawn_thread(void (*f)(void *), void *closure);
389
390/** Join a thread. */
391extern void halide_join_thread(struct halide_thread *);
392
393/** Set the number of threads used by Halide's thread pool. Returns
394 * the old number.
395 *
396 * n < 0 : error condition
397 * n == 0 : use a reasonable system default (typically, number of cpus online).
398 * n == 1 : use exactly one thread; this will always enforce serial execution
399 * n > 1 : use a pool of exactly n threads.
400 *
401 * (Note that this is only guaranteed when using the default implementations
402 * of halide_do_par_for(); custom implementations may completely ignore values
403 * passed to halide_set_num_threads().)
404 */
405extern int halide_set_num_threads(int n);
406
407/** Halide calls these functions to allocate and free memory. To
408 * replace in AOT code, use the halide_set_custom_malloc and
409 * halide_set_custom_free, or (on platforms that support weak
410 * linking), simply define these functions yourself. In JIT-compiled
411 * code use Func::set_custom_allocator.
412 *
413 * If you override them, and find yourself wanting to call the default
414 * implementation from within your override, use
415 * halide_default_malloc/free.
416 *
417 * Note that halide_malloc must return a pointer aligned to the
418 * maximum meaningful alignment for the platform for the purpose of
419 * vector loads and stores, *and* with an allocated size that is (at least)
420 * an integral multiple of that same alignment. The default implementation
421 * uses 32-byte alignment on arm and 64-byte alignment on x86. Additionally,
422 * it must be safe to read at least 8 bytes before the start and beyond the end.
423 */
424//@{
425extern void *halide_malloc(void *user_context, size_t x);
426extern void halide_free(void *user_context, void *ptr);
427extern void *halide_default_malloc(void *user_context, size_t x);
428extern void halide_default_free(void *user_context, void *ptr);
429typedef void *(*halide_malloc_t)(void *, size_t);
430typedef void (*halide_free_t)(void *, void *);
433//@}
434
435/** Halide calls these functions to interact with the underlying
436 * system runtime functions. To replace in AOT code on platforms that
437 * support weak linking, define these functions yourself, or use
438 * the halide_set_custom_load_library() and halide_set_custom_get_library_symbol()
439 * functions. In JIT-compiled code, use JITSharedRuntime::set_default_handlers().
440 *
441 * halide_load_library and halide_get_library_symbol are equivalent to
442 * dlopen and dlsym. halide_get_symbol(sym) is equivalent to
443 * dlsym(RTLD_DEFAULT, sym).
444 */
445//@{
446extern void *halide_get_symbol(const char *name);
447extern void *halide_load_library(const char *name);
448extern void *halide_get_library_symbol(void *lib, const char *name);
449extern void *halide_default_get_symbol(const char *name);
450extern void *halide_default_load_library(const char *name);
451extern void *halide_default_get_library_symbol(void *lib, const char *name);
452typedef void *(*halide_get_symbol_t)(const char *name);
453typedef void *(*halide_load_library_t)(const char *name);
454typedef void *(*halide_get_library_symbol_t)(void *lib, const char *name);
458//@}
459
460/** Called when debug_to_file is used inside %Halide code. See
461 * Func::debug_to_file for how this is called
462 *
463 * Cannot be replaced in JITted code at present.
464 */
465extern int32_t halide_debug_to_file(void *user_context, const char *filename,
466 struct halide_buffer_t *buf);
467
468/** Types in the halide type system. They can be ints, unsigned ints,
469 * or floats (of various bit-widths), or a handle (which is always 64-bits).
470 * Note that the int/uint/float values do not imply a specific bit width
471 * (the bit width is expected to be encoded in a separate value).
472 */
474#if (__cplusplus >= 201103L || _MSVC_LANG >= 201103L)
475 : uint8_t
476#endif
477{
478 halide_type_int = 0, ///< signed integers
479 halide_type_uint = 1, ///< unsigned integers
480 halide_type_float = 2, ///< IEEE floating point numbers
481 halide_type_handle = 3, ///< opaque pointer type (void *)
482 halide_type_bfloat = 4, ///< floating point numbers in the bfloat format
484
485// Note that while __attribute__ can go before or after the declaration,
486// __declspec apparently is only allowed before.
487#ifndef HALIDE_ATTRIBUTE_ALIGN
488#ifdef _MSC_VER
489#define HALIDE_ATTRIBUTE_ALIGN(x) __declspec(align(x))
490#else
491#define HALIDE_ATTRIBUTE_ALIGN(x) __attribute__((aligned(x)))
492#endif
493#endif
494
495/** A runtime tag for a type in the halide type system. Can be ints,
496 * unsigned ints, or floats of various bit-widths (the 'bits'
497 * field). Can also be vectors of the same (by setting the 'lanes'
498 * field to something larger than one). This struct should be
499 * exactly 32-bits in size. */
501 /** The basic type code: signed integer, unsigned integer, or floating point. */
502#if (__cplusplus >= 201103L || _MSVC_LANG >= 201103L)
504 halide_type_code_t code; // halide_type_code_t
505#else
507 uint8_t code; // halide_type_code_t
508#endif
509
510 /** The number of bits of precision of a single scalar value of this type. */
513
514 /** How many elements in a vector. This is 1 for scalar types. */
517
518#if (__cplusplus >= 201103L || _MSVC_LANG >= 201103L)
519 /** Construct a runtime representation of a Halide type from:
520 * code: The fundamental type from an enum.
521 * bits: The bit size of one element.
522 * lanes: The number of vector elements in the type. */
524 : code(code), bits(bits), lanes(lanes) {
525 }
526
527 /** Default constructor is required e.g. to declare halide_trace_event
528 * instances. */
530 : code((halide_type_code_t)0), bits(0), lanes(0) {
531 }
532
533 HALIDE_ALWAYS_INLINE constexpr halide_type_t with_lanes(uint16_t new_lanes) const {
534 return halide_type_t((halide_type_code_t)code, bits, new_lanes);
535 }
536
537 HALIDE_ALWAYS_INLINE constexpr halide_type_t element_of() const {
538 return with_lanes(1);
539 }
540 /** Compare two types for equality. */
541 HALIDE_ALWAYS_INLINE constexpr bool operator==(const halide_type_t &other) const {
542 return as_u32() == other.as_u32();
543 }
544
545 HALIDE_ALWAYS_INLINE constexpr bool operator!=(const halide_type_t &other) const {
546 return !(*this == other);
547 }
548
549 HALIDE_ALWAYS_INLINE constexpr bool operator<(const halide_type_t &other) const {
550 return as_u32() < other.as_u32();
551 }
552
553 /** Size in bytes for a single element, even if width is not 1, of this type. */
554 HALIDE_ALWAYS_INLINE constexpr int bytes() const {
555 return (bits + 7) / 8;
556 }
557
558 HALIDE_ALWAYS_INLINE constexpr uint32_t as_u32() const {
559 // Note that this produces a result that is identical to memcpy'ing 'this'
560 // into a u32 (on a little-endian machine, anyway), and at -O1 or greater
561 // on Clang, the compiler knows this and optimizes this into a single 32-bit move.
562 // (At -O0 it will look awful.)
563 return static_cast<uint8_t>(code) |
564 (static_cast<uint16_t>(bits) << 8) |
565 (static_cast<uint32_t>(lanes) << 16);
566 }
567#endif
568};
569
570#if (__cplusplus >= 201103L || _MSVC_LANG >= 201103L)
571static_assert(sizeof(halide_type_t) == sizeof(uint32_t), "size mismatch in halide_type_t");
572#endif
573
585
587 /** The name of the Func or Pipeline that this event refers to */
588 const char *func;
589
590 /** If the event type is a load or a store, this points to the
591 * value being loaded or stored. Use the type field to safely cast
592 * this to a concrete pointer type and retrieve it. For other
593 * events this is null. */
594 void *value;
595
596 /** For loads and stores, an array which contains the location
597 * being accessed. For vector loads or stores it is an array of
598 * vectors of coordinates (the vector dimension is innermost).
599 *
600 * For realization or production-related events, this will contain
601 * the mins and extents of the region being accessed, in the order
602 * min0, extent0, min1, extent1, ...
603 *
604 * For pipeline-related events, this will be null.
605 */
607
608 /** For halide_trace_tag, this points to a read-only null-terminated string
609 * of arbitrary text. For all other events, this will be null.
610 */
611 const char *trace_tag;
612
613 /** If the event type is a load or a store, this is the type of
614 * the data. Otherwise, the value is meaningless. */
616
617 /** The type of event */
619
620 /* The ID of the parent event (see below for an explanation of
621 * event ancestry). */
623
624 /** If this was a load or store of a Tuple-valued Func, this is
625 * which tuple element was accessed. */
627
628 /** The length of the coordinates array */
630};
631
632/** Called when Funcs are marked as trace_load, trace_store, or
633 * trace_realization. See Func::set_custom_trace. The default
634 * implementation either prints events via halide_print, or if
635 * HL_TRACE_FILE is defined, dumps the trace to that file in a
636 * sequence of trace packets. The header for a trace packet is defined
637 * below. If the trace is going to be large, you may want to make the
638 * file a named pipe, and then read from that pipe into gzip.
639 *
640 * halide_trace returns a unique ID which will be passed to future
641 * events that "belong" to the earlier event as the parent id. The
642 * ownership hierarchy looks like:
643 *
644 * begin_pipeline
645 * +--trace_tag (if any)
646 * +--trace_tag (if any)
647 * ...
648 * +--begin_realization
649 * | +--produce
650 * | | +--load/store
651 * | | +--end_produce
652 * | +--consume
653 * | | +--load
654 * | | +--end_consume
655 * | +--end_realization
656 * +--end_pipeline
657 *
658 * Threading means that ownership cannot be inferred from the ordering
659 * of events. There can be many active realizations of a given
660 * function, or many active productions for a single
661 * realization. Within a single production, the ordering of events is
662 * meaningful.
663 *
664 * Note that all trace_tag events (if any) will occur just after the begin_pipeline
665 * event, but before any begin_realization events. All trace_tags for a given Func
666 * will be emitted in the order added.
667 */
668// @}
669extern int32_t halide_trace(void *user_context, const struct halide_trace_event_t *event);
670extern int32_t halide_default_trace(void *user_context, const struct halide_trace_event_t *event);
671typedef int32_t (*halide_trace_t)(void *user_context, const struct halide_trace_event_t *);
673// @}
674
675/** The header of a packet in a binary trace. All fields are 32-bit. */
677 /** The total size of this packet in bytes. Always a multiple of
678 * four. Equivalently, the number of bytes until the next
679 * packet. */
681
682 /** The id of this packet (for the purpose of parent_id). */
684
685 /** The remaining fields are equivalent to those in halide_trace_event_t */
686 // @{
692 // @}
693
694#if (__cplusplus >= 201103L || _MSVC_LANG >= 201103L)
695 /** Get the coordinates array, assuming this packet is laid out in
696 * memory as it was written. The coordinates array comes
697 * immediately after the packet header. */
698 HALIDE_ALWAYS_INLINE const int *coordinates() const {
699 return (const int *)(this + 1);
700 }
701
702 HALIDE_ALWAYS_INLINE int *coordinates() {
703 return (int *)(this + 1);
704 }
705
706 /** Get the value, assuming this packet is laid out in memory as
707 * it was written. The packet comes immediately after the coordinates
708 * array. */
709 HALIDE_ALWAYS_INLINE const void *value() const {
710 return (const void *)(coordinates() + dimensions);
711 }
712
713 HALIDE_ALWAYS_INLINE void *value() {
714 return (void *)(coordinates() + dimensions);
715 }
716
717 /** Get the func name, assuming this packet is laid out in memory
718 * as it was written. It comes after the value. */
719 HALIDE_ALWAYS_INLINE const char *func() const {
720 return (const char *)value() + type.lanes * type.bytes();
721 }
722
723 HALIDE_ALWAYS_INLINE char *func() {
724 return (char *)value() + type.lanes * type.bytes();
725 }
726
727 /** Get the trace_tag (if any), assuming this packet is laid out in memory
728 * as it was written. It comes after the func name. If there is no trace_tag,
729 * this will return a pointer to an empty string. */
730 HALIDE_ALWAYS_INLINE const char *trace_tag() const {
731 const char *f = func();
732 // strlen may not be available here
733 while (*f++) {
734 // nothing
735 }
736 return f;
737 }
738
739 HALIDE_ALWAYS_INLINE char *trace_tag() {
740 char *f = func();
741 // strlen may not be available here
742 while (*f++) {
743 // nothing
744 }
745 return f;
746 }
747#endif
748};
749
750/** Set the file descriptor that Halide should write binary trace
751 * events to. If called with 0 as the argument, Halide outputs trace
752 * information to stdout in a human-readable format. If never called,
753 * Halide checks the for existence of an environment variable called
754 * HL_TRACE_FILE and opens that file. If HL_TRACE_FILE is not defined,
755 * it outputs trace information to stdout in a human-readable
756 * format. */
757extern void halide_set_trace_file(int fd);
758
759/** Halide calls this to retrieve the file descriptor to write binary
760 * trace events to. The default implementation returns the value set
761 * by halide_set_trace_file. Implement it yourself if you wish to use
762 * a custom file descriptor per user_context. Return zero from your
763 * implementation to tell Halide to print human-readable trace
764 * information to stdout. */
765extern int halide_get_trace_file(void *user_context);
766
767/** If tracing is writing to a file. This call closes that file
768 * (flushing the trace). Returns zero on success. */
769extern int halide_shutdown_trace(void);
770
771/** All Halide GPU or device backend implementations provide an
772 * interface to be used with halide_device_malloc, etc. This is
773 * accessed via the functions below.
774 */
775
776/** An opaque struct containing per-GPU API implementations of the
777 * device functions. */
779
780/** Each GPU API provides a halide_device_interface_t struct pointing
781 * to the code that manages device allocations. You can access these
782 * functions directly from the struct member function pointers, or by
783 * calling the functions declared below. Note that the global
784 * functions are not available when using Halide as a JIT compiler.
785 * If you are using raw halide_buffer_t in that context you must use
786 * the function pointers in the device_interface struct.
787 *
788 * The function pointers below are currently the same for every GPU
789 * API; only the impl field varies. These top-level functions do the
790 * bookkeeping that is common across all GPU APIs, and then dispatch
791 * to more API-specific functions via another set of function pointers
792 * hidden inside the impl field.
793 */
795 int (*device_malloc)(void *user_context, struct halide_buffer_t *buf,
796 const struct halide_device_interface_t *device_interface);
797 int (*device_free)(void *user_context, struct halide_buffer_t *buf);
798 int (*device_sync)(void *user_context, struct halide_buffer_t *buf);
799 void (*device_release)(void *user_context,
800 const struct halide_device_interface_t *device_interface);
801 int (*copy_to_host)(void *user_context, struct halide_buffer_t *buf);
802 int (*copy_to_device)(void *user_context, struct halide_buffer_t *buf,
803 const struct halide_device_interface_t *device_interface);
804 int (*device_and_host_malloc)(void *user_context, struct halide_buffer_t *buf,
805 const struct halide_device_interface_t *device_interface);
806 int (*device_and_host_free)(void *user_context, struct halide_buffer_t *buf);
807 int (*buffer_copy)(void *user_context, struct halide_buffer_t *src,
808 const struct halide_device_interface_t *dst_device_interface, struct halide_buffer_t *dst);
809 int (*device_crop)(void *user_context, const struct halide_buffer_t *src,
810 struct halide_buffer_t *dst);
811 int (*device_slice)(void *user_context, const struct halide_buffer_t *src,
812 int slice_dim, int slice_pos, struct halide_buffer_t *dst);
813 int (*device_release_crop)(void *user_context, struct halide_buffer_t *buf);
814 int (*wrap_native)(void *user_context, struct halide_buffer_t *buf, uint64_t handle,
815 const struct halide_device_interface_t *device_interface);
816 int (*detach_native)(void *user_context, struct halide_buffer_t *buf);
817 int (*compute_capability)(void *user_context, int *major, int *minor);
819};
820
821/** Release all data associated with the given device interface, in
822 * particular all resources (memory, texture, context handles)
823 * allocated by Halide. Must be called explicitly when using AOT
824 * compilation. This is *not* thread-safe with respect to actively
825 * running Halide code. Ensure all pipelines are finished before
826 * calling this. */
827extern void halide_device_release(void *user_context,
828 const struct halide_device_interface_t *device_interface);
829
830/** Copy image data from device memory to host memory. This must be called
831 * explicitly to copy back the results of a GPU-based filter. */
832extern int halide_copy_to_host(void *user_context, struct halide_buffer_t *buf);
833
834/** Copy image data from host memory to device memory. This should not
835 * be called directly; Halide handles copying to the device
836 * automatically. If interface is NULL and the buf has a non-zero dev
837 * field, the device associated with the dev handle will be
838 * used. Otherwise if the dev field is 0 and interface is NULL, an
839 * error is returned. */
840extern int halide_copy_to_device(void *user_context, struct halide_buffer_t *buf,
841 const struct halide_device_interface_t *device_interface);
842
843/** Copy data from one buffer to another. The buffers may have
844 * different shapes and sizes, but the destination buffer's shape must
845 * be contained within the source buffer's shape. That is, for each
846 * dimension, the min on the destination buffer must be greater than
847 * or equal to the min on the source buffer, and min+extent on the
848 * destination buffer must be less that or equal to min+extent on the
849 * source buffer. The source data is pulled from either device or
850 * host memory on the source, depending on the dirty flags. host is
851 * preferred if both are valid. The dst_device_interface parameter
852 * controls the destination memory space. NULL means host memory. */
853extern int halide_buffer_copy(void *user_context, struct halide_buffer_t *src,
854 const struct halide_device_interface_t *dst_device_interface,
855 struct halide_buffer_t *dst);
856
857/** Give the destination buffer a device allocation which is an alias
858 * for the same coordinate range in the source buffer. Modifies the
859 * device, device_interface, and the device_dirty flag only. Only
860 * supported by some device APIs (others will return
861 * halide_error_code_device_crop_unsupported). Call
862 * halide_device_release_crop instead of halide_device_free to clean
863 * up resources associated with the cropped view. Do not free the
864 * device allocation on the source buffer while the destination buffer
865 * still lives. Note that the two buffers do not share dirty flags, so
866 * care must be taken to update them together as needed. Note that src
867 * and dst are required to have the same number of dimensions.
868 *
869 * Note also that (in theory) device interfaces which support cropping may
870 * still not support cropping a crop (instead, create a new crop of the parent
871 * buffer); in practice, no known implementation has this limitation, although
872 * it is possible that some future implementations may require it. */
873extern int halide_device_crop(void *user_context,
874 const struct halide_buffer_t *src,
875 struct halide_buffer_t *dst);
876
877/** Give the destination buffer a device allocation which is an alias
878 * for a similar coordinate range in the source buffer, but with one dimension
879 * sliced away in the dst. Modifies the device, device_interface, and the
880 * device_dirty flag only. Only supported by some device APIs (others will return
881 * halide_error_code_device_crop_unsupported). Call
882 * halide_device_release_crop instead of halide_device_free to clean
883 * up resources associated with the sliced view. Do not free the
884 * device allocation on the source buffer while the destination buffer
885 * still lives. Note that the two buffers do not share dirty flags, so
886 * care must be taken to update them together as needed. Note that the dst buffer
887 * must have exactly one fewer dimension than the src buffer, and that slice_dim
888 * and slice_pos must be valid within src. */
889extern int halide_device_slice(void *user_context,
890 const struct halide_buffer_t *src,
891 int slice_dim, int slice_pos,
892 struct halide_buffer_t *dst);
893
894/** Release any resources associated with a cropped/sliced view of another
895 * buffer. */
896extern int halide_device_release_crop(void *user_context,
897 struct halide_buffer_t *buf);
898
899/** Wait for current GPU operations to complete. Calling this explicitly
900 * should rarely be necessary, except maybe for profiling. */
901extern int halide_device_sync(void *user_context, struct halide_buffer_t *buf);
902
903/**
904 * Wait for current GPU operations to complete. Calling this explicitly
905 * should rarely be necessary, except maybe for profiling.
906 * This variation of the synchronizing is useful when a synchronization is desirable
907 * without specifying any buffer to synchronize on.
908 * Calling this with a null device_interface is always illegal.
909 */
910extern int halide_device_sync_global(void *user_context, const struct halide_device_interface_t *device_interface);
911
912/** Allocate device memory to back a halide_buffer_t. */
913extern int halide_device_malloc(void *user_context, struct halide_buffer_t *buf,
914 const struct halide_device_interface_t *device_interface);
915
916/** Free device memory. */
917extern int halide_device_free(void *user_context, struct halide_buffer_t *buf);
918
919/** Wrap or detach a native device handle, setting the device field
920 * and device_interface field as appropriate for the given GPU
921 * API. The meaning of the opaque handle is specific to the device
922 * interface, so if you know the device interface in use, call the
923 * more specific functions in the runtime headers for your specific
924 * device API instead (e.g. HalideRuntimeCuda.h). */
925// @{
926extern int halide_device_wrap_native(void *user_context,
927 struct halide_buffer_t *buf,
928 uint64_t handle,
929 const struct halide_device_interface_t *device_interface);
930extern int halide_device_detach_native(void *user_context, struct halide_buffer_t *buf);
931// @}
932
933/** Selects which gpu device to use. 0 is usually the display
934 * device. If never called, Halide uses the environment variable
935 * HL_GPU_DEVICE. If that variable is unset, Halide uses the last
936 * device. Set this to -1 to use the last device. */
937extern void halide_set_gpu_device(int n);
938
939/** Halide calls this to get the desired halide gpu device
940 * setting. Implement this yourself to use a different gpu device per
941 * user_context. The default implementation returns the value set by
942 * halide_set_gpu_device, or the environment variable
943 * HL_GPU_DEVICE. */
944extern int halide_get_gpu_device(void *user_context);
945
946/** Set the soft maximum amount of memory, in bytes, that the LRU
947 * cache will use to memoize Func results. This is not a strict
948 * maximum in that concurrency and simultaneous use of memoized
949 * reults larger than the cache size can both cause it to
950 * temporariliy be larger than the size specified here.
951 */
953
954/** Given a cache key for a memoized result, currently constructed
955 * from the Func name and top-level Func name plus the arguments of
956 * the computation, determine if the result is in the cache and
957 * return it if so. (The internals of the cache key should be
958 * considered opaque by this function.) If this routine returns true,
959 * it is a cache miss. Otherwise, it will return false and the
960 * buffers passed in will be filled, via copying, with memoized
961 * data. The last argument is a list if halide_buffer_t pointers which
962 * represents the outputs of the memoized Func. If the Func does not
963 * return a Tuple, there will only be one halide_buffer_t in the list. The
964 * tuple_count parameters determines the length of the list.
965 *
966 * The return values are:
967 * -1: Signals an error.
968 * 0: Success and cache hit.
969 * 1: Success and cache miss.
970 */
971extern int halide_memoization_cache_lookup(void *user_context, const uint8_t *cache_key, int32_t size,
972 struct halide_buffer_t *realized_bounds,
973 int32_t tuple_count, struct halide_buffer_t **tuple_buffers);
974
975/** Given a cache key for a memoized result, currently constructed
976 * from the Func name and top-level Func name plus the arguments of
977 * the computation, store the result in the cache for futre access by
978 * halide_memoization_cache_lookup. (The internals of the cache key
979 * should be considered opaque by this function.) Data is copied out
980 * from the inputs and inputs are unmodified. The last argument is a
981 * list if halide_buffer_t pointers which represents the outputs of the
982 * memoized Func. If the Func does not return a Tuple, there will
983 * only be one halide_buffer_t in the list. The tuple_count parameters
984 * determines the length of the list.
985 *
986 * If there is a memory allocation failure, the store does not store
987 * the data into the cache.
988 *
989 * If has_eviction_key is true, the entry is marked with eviction_key to
990 * allow removing the key with halide_memoization_cache_evict.
991 */
992extern int halide_memoization_cache_store(void *user_context, const uint8_t *cache_key, int32_t size,
993 struct halide_buffer_t *realized_bounds,
994 int32_t tuple_count,
995 struct halide_buffer_t **tuple_buffers,
996 bool has_eviction_key, uint64_t eviction_key);
997
998/** Evict all cache entries that were tagged with the given
999 * eviction_key in the memoize scheduling directive.
1000 */
1001extern void halide_memoization_cache_evict(void *user_context, uint64_t eviction_key);
1002
1003/** If halide_memoization_cache_lookup succeeds,
1004 * halide_memoization_cache_release must be called to signal the
1005 * storage is no longer being used by the caller. It will be passed
1006 * the host pointer of one the buffers returned by
1007 * halide_memoization_cache_lookup. That is
1008 * halide_memoization_cache_release will be called multiple times for
1009 * the case where halide_memoization_cache_lookup is handling multiple
1010 * buffers. (This corresponds to memoizing a Tuple in Halide.) Note
1011 * that the host pointer must be sufficient to get to all information
1012 * the release operation needs. The default Halide cache impleemntation
1013 * accomplishes this by storing extra data before the start of the user
1014 * modifiable host storage.
1015 *
1016 * This call is like free and does not have a failure return.
1017 */
1018extern void halide_memoization_cache_release(void *user_context, void *host);
1019
1020/** Free all memory and resources associated with the memoization cache.
1021 * Must be called at a time when no other threads are accessing the cache.
1022 */
1024
1025/** Verify that a given range of memory has been initialized; only used when Target::MSAN is enabled.
1026 *
1027 * The default implementation simply calls the LLVM-provided __msan_check_mem_is_initialized() function.
1028 *
1029 * The return value should always be zero.
1030 */
1031extern int halide_msan_check_memory_is_initialized(void *user_context, const void *ptr, uint64_t len, const char *name);
1032
1033/** Verify that the data pointed to by the halide_buffer_t is initialized (but *not* the halide_buffer_t itself),
1034 * using halide_msan_check_memory_is_initialized() for checking.
1035 *
1036 * The default implementation takes pains to only check the active memory ranges
1037 * (skipping padding), and sorting into ranges to always check the smallest number of
1038 * ranges, in monotonically increasing memory order.
1039 *
1040 * Most client code should never need to replace the default implementation.
1041 *
1042 * The return value should always be zero.
1043 */
1044extern int halide_msan_check_buffer_is_initialized(void *user_context, struct halide_buffer_t *buffer, const char *buf_name);
1045
1046/** Annotate that a given range of memory has been initialized;
1047 * only used when Target::MSAN is enabled.
1048 *
1049 * The default implementation simply calls the LLVM-provided __msan_unpoison() function.
1050 *
1051 * The return value should always be zero.
1052 */
1053extern int halide_msan_annotate_memory_is_initialized(void *user_context, const void *ptr, uint64_t len);
1054
1055/** Mark the data pointed to by the halide_buffer_t as initialized (but *not* the halide_buffer_t itself),
1056 * using halide_msan_annotate_memory_is_initialized() for marking.
1057 *
1058 * The default implementation takes pains to only mark the active memory ranges
1059 * (skipping padding), and sorting into ranges to always mark the smallest number of
1060 * ranges, in monotonically increasing memory order.
1061 *
1062 * Most client code should never need to replace the default implementation.
1063 *
1064 * The return value should always be zero.
1065 */
1066extern int halide_msan_annotate_buffer_is_initialized(void *user_context, struct halide_buffer_t *buffer);
1067extern void halide_msan_annotate_buffer_is_initialized_as_destructor(void *user_context, void *buffer);
1068
1069/** The error codes that may be returned by a Halide pipeline. */
1071 /** There was no error. This is the value returned by Halide on success. */
1073
1074 /** An uncategorized error occurred. Refer to the string passed to halide_error. */
1076
1077 /** A Func was given an explicit bound via Func::bound, but this
1078 * was not large enough to encompass the region that is used of
1079 * the Func by the rest of the pipeline. */
1081
1082 /** The elem_size field of a halide_buffer_t does not match the size in
1083 * bytes of the type of that ImageParam. Probable type mismatch. */
1085
1086 /** A pipeline would access memory outside of the halide_buffer_t passed
1087 * in. */
1089
1090 /** A halide_buffer_t was given that spans more than 2GB of memory. */
1092
1093 /** A halide_buffer_t was given with extents that multiply to a number
1094 * greater than 2^31-1 */
1096
1097 /** Applying explicit constraints on the size of an input or
1098 * output buffer shrank the size of that buffer below what will be
1099 * accessed by the pipeline. */
1101
1102 /** A constraint on a size or stride of an input or output buffer
1103 * was not met by the halide_buffer_t passed in. */
1105
1106 /** A scalar parameter passed in was smaller than its minimum
1107 * declared value. */
1109
1110 /** A scalar parameter passed in was greater than its minimum
1111 * declared value. */
1113
1114 /** A call to halide_malloc returned NULL. */
1116
1117 /** A halide_buffer_t pointer passed in was NULL. */
1119
1120 /** debug_to_file failed to open or write to the specified
1121 * file. */
1123
1124 /** The Halide runtime encountered an error while trying to copy
1125 * from device to host. Turn on -debug in your target string to
1126 * see more details. */
1128
1129 /** The Halide runtime encountered an error while trying to copy
1130 * from host to device. Turn on -debug in your target string to
1131 * see more details. */
1133
1134 /** The Halide runtime encountered an error while trying to
1135 * allocate memory on device. Turn on -debug in your target string
1136 * to see more details. */
1138
1139 /** The Halide runtime encountered an error while trying to
1140 * synchronize with a device. Turn on -debug in your target string
1141 * to see more details. */
1143
1144 /** The Halide runtime encountered an error while trying to free a
1145 * device allocation. Turn on -debug in your target string to see
1146 * more details. */
1148
1149 /** Buffer has a non-zero device but no device interface, which
1150 * violates a Halide invariant. */
1152
1153 /** This part of the Halide runtime is unimplemented on this platform. */
1155
1156 /** A runtime symbol could not be loaded. */
1158
1159 /** There is a bug in the Halide compiler. */
1161
1162 /** The Halide runtime encountered an error while trying to launch
1163 * a GPU kernel. Turn on -debug in your target string to see more
1164 * details. */
1166
1167 /** The Halide runtime encountered a host pointer that violated
1168 * the alignment set for it by way of a call to
1169 * set_host_alignment */
1171
1172 /** A fold_storage directive was used on a dimension that is not
1173 * accessed in a monotonically increasing or decreasing fashion. */
1175
1176 /** A fold_storage directive was used with a fold factor that was
1177 * too small to store all the values of a producer needed by the
1178 * consumer. */
1180
1181 /** User-specified require() expression was not satisfied. */
1183
1184 /** At least one of the buffer's extents are negative. */
1186
1187 /** Call(s) to a GPU backend API failed. */
1189
1190 /** Failure recording trace packets for one of the halide_target_feature_trace features. */
1192
1193 /** A specialize_fail() schedule branch was selected at runtime. */
1195
1196 /** The Halide runtime encountered an error while trying to wrap a
1197 * native device handle. Turn on -debug in your target string to
1198 * see more details. */
1200
1201 /** The Halide runtime encountered an error while trying to detach
1202 * a native device handle. Turn on -debug in your target string
1203 * to see more details. */
1205
1206 /** The host field on an input or output was null, the device
1207 * field was not zero, and the pipeline tries to use the buffer on
1208 * the host. You may be passing a GPU-only buffer to a pipeline
1209 * which is scheduled to use it on the CPU. */
1211
1212 /** A folded buffer was passed to an extern stage, but the region
1213 * touched wraps around the fold boundary. */
1215
1216 /** Buffer has a non-null device_interface but device is 0, which
1217 * violates a Halide invariant. */
1219
1220 /** Buffer has both host and device dirty bits set, which violates
1221 * a Halide invariant. */
1223
1224 /** The halide_buffer_t * passed to a halide runtime routine is
1225 * nullptr and this is not allowed. */
1227
1228 /** The Halide runtime encountered an error while trying to copy
1229 * from one buffer to another. Turn on -debug in your target
1230 * string to see more details. */
1232
1233 /** Attempted to make cropped/sliced alias of a buffer with a device
1234 * field, but the device_interface does not support cropping. */
1236
1237 /** Cropping/slicing a buffer failed for some other reason. Turn on -debug
1238 * in your target string. */
1240
1241 /** An operation on a buffer required an allocation on a
1242 * particular device interface, but a device allocation already
1243 * existed on a different device interface. Free the old one
1244 * first. */
1246
1247 /** The dimensions field of a halide_buffer_t does not match the dimensions of that ImageParam. */
1249
1250 /** A buffer with the device_dirty flag set was passed to a
1251 * pipeline compiled with no device backends enabled, so it
1252 * doesn't know how to copy the data back from device memory to
1253 * host memory. Either call copy_to_host before calling the Halide
1254 * pipeline, or enable the appropriate device backend. */
1256
1257 /** An explicit storage bound provided is too small to store
1258 * all the values produced by the function. */
1260
1261 /** A factor used to split a loop was discovered to be zero or negative at
1262 * runtime. */
1264
1265 /** "vscale" value of Scalable Vector detected in runtime does not match
1266 * the vscale value used in compilation. */
1268
1269 /** Profiling failed for a pipeline invocation. */
1271};
1272
1273/** Halide calls the functions below on various error conditions. The
1274 * default implementations construct an error message, call
1275 * halide_error, then return the matching error code above. On
1276 * platforms that support weak linking, you can override these to
1277 * catch the errors individually. */
1278
1279/** A call into an extern stage for the purposes of bounds inference
1280 * failed. Returns the error code given by the extern stage. */
1281extern int halide_error_bounds_inference_call_failed(void *user_context, const char *extern_stage_name, int result);
1282
1283/** A call to an extern stage failed. Returned the error code given by
1284 * the extern stage. */
1285extern int halide_error_extern_stage_failed(void *user_context, const char *extern_stage_name, int result);
1286
1287/** Various other error conditions. See the enum above for a
1288 * description of each. */
1289// @{
1290extern int halide_error_explicit_bounds_too_small(void *user_context, const char *func_name, const char *var_name,
1291 int min_bound, int max_bound, int min_required, int max_required);
1292extern int halide_error_bad_type(void *user_context, const char *func_name,
1293 uint32_t type_given, uint32_t correct_type); // N.B. The last two args are the bit representation of a halide_type_t
1294extern int halide_error_bad_dimensions(void *user_context, const char *func_name,
1295 int32_t dimensions_given, int32_t correct_dimensions);
1296extern int halide_error_access_out_of_bounds(void *user_context, const char *func_name,
1297 int dimension, int min_touched, int max_touched,
1298 int min_valid, int max_valid);
1299extern int halide_error_buffer_allocation_too_large(void *user_context, const char *buffer_name,
1300 uint64_t allocation_size, uint64_t max_size);
1301extern int halide_error_buffer_extents_negative(void *user_context, const char *buffer_name, int dimension, int extent);
1302extern int halide_error_buffer_extents_too_large(void *user_context, const char *buffer_name,
1303 int64_t actual_size, int64_t max_size);
1304extern int halide_error_constraints_make_required_region_smaller(void *user_context, const char *buffer_name,
1305 int dimension,
1306 int constrained_min, int constrained_extent,
1307 int required_min, int required_extent);
1308extern int halide_error_constraint_violated(void *user_context, const char *var, int val,
1309 const char *constrained_var, int constrained_val);
1310extern int halide_error_param_too_small_i64(void *user_context, const char *param_name,
1311 int64_t val, int64_t min_val);
1312extern int halide_error_param_too_small_u64(void *user_context, const char *param_name,
1313 uint64_t val, uint64_t min_val);
1314extern int halide_error_param_too_small_f64(void *user_context, const char *param_name,
1315 double val, double min_val);
1316extern int halide_error_param_too_large_i64(void *user_context, const char *param_name,
1317 int64_t val, int64_t max_val);
1318extern int halide_error_param_too_large_u64(void *user_context, const char *param_name,
1319 uint64_t val, uint64_t max_val);
1320extern int halide_error_param_too_large_f64(void *user_context, const char *param_name,
1321 double val, double max_val);
1322extern int halide_error_out_of_memory(void *user_context);
1323extern int halide_error_buffer_argument_is_null(void *user_context, const char *buffer_name);
1324extern int halide_error_debug_to_file_failed(void *user_context, const char *func,
1325 const char *filename, int error_code);
1326extern int halide_error_unaligned_host_ptr(void *user_context, const char *func_name, int alignment);
1327extern int halide_error_host_is_null(void *user_context, const char *func_name);
1328extern int halide_error_bad_fold(void *user_context, const char *func_name, const char *var_name,
1329 const char *loop_name);
1330extern int halide_error_bad_extern_fold(void *user_context, const char *func_name,
1331 int dim, int min, int extent, int valid_min, int fold_factor);
1332
1333extern int halide_error_fold_factor_too_small(void *user_context, const char *func_name, const char *var_name,
1334 int fold_factor, const char *loop_name, int required_extent);
1335extern int halide_error_requirement_failed(void *user_context, const char *condition, const char *message);
1336extern int halide_error_specialize_fail(void *user_context, const char *message);
1337extern int halide_error_no_device_interface(void *user_context);
1338extern int halide_error_device_interface_no_device(void *user_context);
1339extern int halide_error_host_and_device_dirty(void *user_context);
1340extern int halide_error_buffer_is_null(void *user_context, const char *routine);
1341extern int halide_error_device_dirty_with_no_device_support(void *user_context, const char *buffer_name);
1342extern int halide_error_storage_bound_too_small(void *user_context, const char *func_name, const char *var_name,
1343 int provided_size, int required_size);
1344extern int halide_error_device_crop_failed(void *user_context);
1345extern int halide_error_split_factor_not_positive(void *user_context, const char *func_name, const char *orig, const char *outer, const char *inner, const char *factor_str, int factor);
1346extern int halide_error_vscale_invalid(void *user_context, const char *func_name, int runtime_vscale, int compiletime_vscale);
1347// @}
1348
1349/** Optional features a compilation Target can have.
1350 * Be sure to keep this in sync with the Feature enum in Target.h and the implementation of
1351 * get_runtime_compatible_target in Target.cpp if you add a new feature.
1352 */
1354 halide_target_feature_jit = 0, ///< Generate code that will run immediately inside the calling process.
1355 halide_target_feature_debug, ///< Turn on debug info and output for runtime code.
1356 halide_target_feature_no_asserts, ///< Disable all runtime checks, for slightly tighter code.
1357 halide_target_feature_no_bounds_query, ///< Disable the bounds querying functionality.
1358
1359 halide_target_feature_sse41, ///< Use SSE 4.1 and earlier instructions. Only relevant on x86.
1360 halide_target_feature_avx, ///< Use AVX 1 instructions. Only relevant on x86.
1361 halide_target_feature_avx2, ///< Use AVX 2 instructions. Only relevant on x86.
1362 halide_target_feature_fma, ///< Enable x86 FMA instruction
1363 halide_target_feature_fma4, ///< Enable x86 (AMD) FMA4 instruction set
1364 halide_target_feature_f16c, ///< Enable x86 16-bit float support
1365
1366 halide_target_feature_armv7s, ///< Generate code for ARMv7s. Only relevant for 32-bit ARM.
1367 halide_target_feature_no_neon, ///< Avoid using NEON instructions. Only relevant for 32-bit ARM.
1368
1369 halide_target_feature_vsx, ///< Use VSX instructions. Only relevant on POWERPC.
1370 halide_target_feature_power_arch_2_07, ///< Use POWER ISA 2.07 new instructions. Only relevant on POWERPC.
1371
1372 halide_target_feature_cuda, ///< Enable the CUDA runtime. Defaults to compute capability 2.0 (Fermi)
1373 halide_target_feature_cuda_capability30, ///< Enable CUDA compute capability 3.0 (Kepler)
1374 halide_target_feature_cuda_capability32, ///< Enable CUDA compute capability 3.2 (Tegra K1)
1375 halide_target_feature_cuda_capability35, ///< Enable CUDA compute capability 3.5 (Kepler)
1376 halide_target_feature_cuda_capability50, ///< Enable CUDA compute capability 5.0 (Maxwell)
1377 halide_target_feature_cuda_capability61, ///< Enable CUDA compute capability 6.1 (Pascal)
1378 halide_target_feature_cuda_capability70, ///< Enable CUDA compute capability 7.0 (Volta)
1379 halide_target_feature_cuda_capability75, ///< Enable CUDA compute capability 7.5 (Turing)
1380 halide_target_feature_cuda_capability80, ///< Enable CUDA compute capability 8.0 (Ampere)
1381 halide_target_feature_cuda_capability86, ///< Enable CUDA compute capability 8.6 (Ampere)
1382
1383 halide_target_feature_opencl, ///< Enable the OpenCL runtime.
1384 halide_target_feature_cl_doubles, ///< Enable double support on OpenCL targets
1385 halide_target_feature_cl_atomic64, ///< Enable 64-bit atomics operations on OpenCL targets
1386
1387 halide_target_feature_user_context, ///< Generated code takes a user_context pointer as first argument
1388
1389 halide_target_feature_profile, ///< Launch a sampling profiler alongside the Halide pipeline that monitors and reports the runtime used by each Func
1390 halide_target_feature_no_runtime, ///< Do not include a copy of the Halide runtime in any generated object file or assembly
1391
1392 halide_target_feature_metal, ///< Enable the (Apple) Metal runtime.
1393
1394 halide_target_feature_c_plus_plus_mangling, ///< Generate C++ mangled names for result function, et al
1395
1396 halide_target_feature_large_buffers, ///< Enable 64-bit buffer indexing to support buffers > 2GB. Ignored if bits != 64.
1397
1398 halide_target_feature_hvx_128, ///< Enable HVX 128 byte mode.
1399 halide_target_feature_hvx_v62, ///< Enable Hexagon v62 architecture.
1400 halide_target_feature_fuzz_float_stores, ///< On every floating point store, set the last bit of the mantissa to zero. Pipelines for which the output is very different with this feature enabled may also produce very different output on different processors.
1401 halide_target_feature_soft_float_abi, ///< Enable soft float ABI. This only enables the soft float ABI calling convention, which does not necessarily use soft floats.
1402 halide_target_feature_msan, ///< Enable hooks for MSAN support.
1403 halide_target_feature_avx512, ///< Enable the base AVX512 subset supported by all AVX512 architectures. The specific feature sets are AVX-512F and AVX512-CD. See https://en.wikipedia.org/wiki/AVX-512 for a description of each AVX subset.
1404 halide_target_feature_avx512_knl, ///< Enable the AVX512 features supported by Knight's Landing chips, such as the Xeon Phi x200. This includes the base AVX512 set, and also AVX512-CD and AVX512-ER.
1405 halide_target_feature_avx512_skylake, ///< Enable the AVX512 features supported by Skylake Xeon server processors. This adds AVX512-VL, AVX512-BW, and AVX512-DQ to the base set. The main difference from the base AVX512 set is better support for small integer ops. Note that this does not include the Knight's Landing features. Note also that these features are not available on Skylake desktop and mobile processors.
1406 halide_target_feature_avx512_cannonlake, ///< Enable the AVX512 features expected to be supported by future Cannonlake processors. This includes all of the Skylake features, plus AVX512-IFMA and AVX512-VBMI.
1407 halide_target_feature_avx512_zen4, ///< Enable the AVX512 features supported by Zen4 processors. This include all of the Cannonlake features, plus AVX512-VNNI, AVX512-BF16, and more.
1408 halide_target_feature_avx512_sapphirerapids, ///< Enable the AVX512 features supported by Sapphire Rapids processors. This include all of the Zen4 features, plus AVX-VNNI and AMX instructions.
1409 halide_target_feature_trace_loads, ///< Trace all loads done by the pipeline. Equivalent to calling Func::trace_loads on every non-inlined Func.
1410 halide_target_feature_trace_stores, ///< Trace all stores done by the pipeline. Equivalent to calling Func::trace_stores on every non-inlined Func.
1411 halide_target_feature_trace_realizations, ///< Trace all realizations done by the pipeline. Equivalent to calling Func::trace_realizations on every non-inlined Func.
1413 halide_target_feature_hvx_v65, ///< Enable Hexagon v65 architecture.
1414 halide_target_feature_hvx_v66, ///< Enable Hexagon v66 architecture.
1415 halide_target_feature_hvx_v68, ///< Enable Hexagon v68 architecture.
1416 halide_target_feature_cl_half, ///< Enable half support on OpenCL targets
1417 halide_target_feature_strict_float, ///< Turn off all non-IEEE floating-point optimization. Currently applies only to LLVM targets.
1418 halide_target_feature_tsan, ///< Enable hooks for TSAN support.
1419 halide_target_feature_asan, ///< Enable hooks for ASAN support.
1420 halide_target_feature_d3d12compute, ///< Enable Direct3D 12 Compute runtime.
1421 halide_target_feature_check_unsafe_promises, ///< Insert assertions for promises.
1422 halide_target_feature_hexagon_dma, ///< Enable Hexagon DMA buffers.
1423 halide_target_feature_embed_bitcode, ///< Emulate clang -fembed-bitcode flag.
1424 halide_target_feature_enable_llvm_loop_opt, ///< Enable loop vectorization + unrolling in LLVM. Overrides halide_target_feature_disable_llvm_loop_opt. (Ignored for non-LLVM targets.)
1425 halide_target_feature_wasm_mvponly, ///< Disable all extensions to WebAssembly codegen (including +sign-ext and +nontrapping-fptoint, which are on by default).
1426 halide_target_feature_wasm_simd128, ///< Enable +simd128 instructions for WebAssembly codegen.
1427 halide_target_feature_wasm_threads, ///< Enable use of threads in WebAssembly codegen. Requires the use of a wasm runtime that provides pthread-compatible wrappers (typically, Emscripten with the -pthreads flag). Unsupported under WASI.
1428 halide_target_feature_wasm_bulk_memory, ///< Enable +bulk-memory instructions for WebAssembly codegen.
1429 halide_target_feature_webgpu, ///< Enable the WebGPU runtime.
1430 halide_target_feature_sve, ///< Enable ARM Scalable Vector Extensions
1431 halide_target_feature_sve2, ///< Enable ARM Scalable Vector Extensions v2
1432 halide_target_feature_egl, ///< Force use of EGL support.
1433 halide_target_feature_arm_dot_prod, ///< Enable ARMv8.2-a dotprod extension (i.e. udot and sdot instructions)
1434 halide_target_feature_arm_fp16, ///< Enable ARMv8.2-a half-precision floating point data processing
1435 halide_llvm_large_code_model, ///< Use the LLVM large code model to compile
1436 halide_target_feature_rvv, ///< Enable RISCV "V" Vector Extension
1437 halide_target_feature_armv8a, ///< Enable ARMv8a instructions
1438 halide_target_feature_armv81a, ///< Enable ARMv8.1a instructions
1439 halide_target_feature_armv82a, ///< Enable ARMv8.2a instructions
1440 halide_target_feature_armv83a, ///< Enable ARMv8.3a instructions
1441 halide_target_feature_armv84a, ///< Enable ARMv8.4a instructions
1442 halide_target_feature_armv85a, ///< Enable ARMv8.5a instructions
1443 halide_target_feature_armv86a, ///< Enable ARMv8.6a instructions
1444 halide_target_feature_armv87a, ///< Enable ARMv8.7a instructions
1445 halide_target_feature_armv88a, ///< Enable ARMv8.8a instructions
1446 halide_target_feature_armv89a, ///< Enable ARMv8.9a instructions
1447 halide_target_feature_sanitizer_coverage, ///< Enable hooks for SanitizerCoverage support.
1448 halide_target_feature_profile_by_timer, ///< Alternative to halide_target_feature_profile using timer interrupt for systems without threads or applicartions that need to avoid them.
1449 halide_target_feature_spirv, ///< Enable SPIR-V code generation support.
1450 halide_target_feature_vulkan, ///< Enable Vulkan runtime support.
1451 halide_target_feature_vulkan_int8, ///< Enable Vulkan 8-bit integer support.
1452 halide_target_feature_vulkan_int16, ///< Enable Vulkan 16-bit integer support.
1453 halide_target_feature_vulkan_int64, ///< Enable Vulkan 64-bit integer support.
1454 halide_target_feature_vulkan_float16, ///< Enable Vulkan 16-bit float support.
1455 halide_target_feature_vulkan_float64, ///< Enable Vulkan 64-bit float support.
1456 halide_target_feature_vulkan_version10, ///< Enable Vulkan v1.0 runtime target support.
1457 halide_target_feature_vulkan_version12, ///< Enable Vulkan v1.2 runtime target support.
1458 halide_target_feature_vulkan_version13, ///< Enable Vulkan v1.3 runtime target support.
1459 halide_target_feature_semihosting, ///< Used together with Target::NoOS for the baremetal target built with semihosting library and run with semihosting mode where minimum I/O communication with a host PC is available.
1460 halide_target_feature_avx10_1, ///< Intel AVX10 version 1 support. vector_bits is used to indicate width.
1461 halide_target_feature_x86_apx, ///< Intel x86 APX support. Covers initial set of features released as APX: egpr,push2pop2,ppx,ndd .
1462 halide_target_feature_end ///< A sentinel. Every target is considered to have this feature, and setting this feature does nothing.
1464
1465/** This function is called internally by Halide in some situations to determine
1466 * if the current execution environment can support the given set of
1467 * halide_target_feature_t flags. The implementation must do the following:
1468 *
1469 * -- If there are flags set in features that the function knows *cannot* be supported, return 0.
1470 * -- Otherwise, return 1.
1471 * -- Note that any flags set in features that the function doesn't know how to test should be ignored;
1472 * this implies that a return value of 1 means "not known to be bad" rather than "known to be good".
1473 *
1474 * In other words: a return value of 0 means "It is not safe to use code compiled with these features",
1475 * while a return value of 1 means "It is not obviously unsafe to use code compiled with these features".
1476 *
1477 * The default implementation simply calls halide_default_can_use_target_features.
1478 *
1479 * Note that `features` points to an array of `count` uint64_t; this array must contain enough
1480 * bits to represent all the currently known features. Any excess bits must be set to zero.
1481 */
1482// @{
1483extern int halide_can_use_target_features(int count, const uint64_t *features);
1484typedef int (*halide_can_use_target_features_t)(int count, const uint64_t *features);
1486// @}
1487
1488/**
1489 * This is the default implementation of halide_can_use_target_features; it is provided
1490 * for convenience of user code that may wish to extend halide_can_use_target_features
1491 * but continue providing existing support, e.g.
1492 *
1493 * int halide_can_use_target_features(int count, const uint64_t *features) {
1494 * if (features[halide_target_somefeature >> 6] & (1LL << (halide_target_somefeature & 63))) {
1495 * if (!can_use_somefeature()) {
1496 * return 0;
1497 * }
1498 * }
1499 * return halide_default_can_use_target_features(count, features);
1500 * }
1501 */
1502extern int halide_default_can_use_target_features(int count, const uint64_t *features);
1503
1504typedef struct halide_dimension_t {
1505#if (__cplusplus >= 201103L || _MSVC_LANG >= 201103L)
1506 int32_t min = 0, extent = 0, stride = 0;
1507
1508 // Per-dimension flags. None are defined yet (This is reserved for future use).
1509 uint32_t flags = 0;
1510
1513 : min(m), extent(e), stride(s), flags(f) {
1514 }
1515
1516 HALIDE_ALWAYS_INLINE bool operator==(const halide_dimension_t &other) const {
1517 return (min == other.min) &&
1518 (extent == other.extent) &&
1519 (stride == other.stride) &&
1520 (flags == other.flags);
1521 }
1522
1523 HALIDE_ALWAYS_INLINE bool operator!=(const halide_dimension_t &other) const {
1524 return !(*this == other);
1525 }
1526#else
1528
1529 // Per-dimension flags. None are defined yet (This is reserved for future use).
1531#endif
1533
1534#ifdef __cplusplus
1535} // extern "C"
1536#endif
1537
1540
1541/**
1542 * The raw representation of an image passed around by generated
1543 * Halide code. It includes some stuff to track whether the image is
1544 * not actually in main memory, but instead on a device (like a
1545 * GPU). For a more convenient C++ wrapper, use Halide::Buffer<T>. */
1546typedef struct halide_buffer_t {
1547 /** A device-handle for e.g. GPU memory used to back this buffer. */
1549
1550 /** The interface used to interpret the above handle. */
1552
1553 /** A pointer to the start of the data in main memory. In terms of
1554 * the Halide coordinate system, this is the address of the min
1555 * coordinates (defined below). */
1557
1558 /** flags with various meanings. */
1560
1561 /** The type of each buffer element. */
1563
1564 /** The dimensionality of the buffer. */
1566
1567 /** The shape of the buffer. Halide does not own this array - you
1568 * must manage the memory for it yourself. */
1570
1571 /** Pads the buffer up to a multiple of 8 bytes */
1572 void *padding;
1573
1574#if (__cplusplus >= 201103L || _MSVC_LANG >= 201103L)
1575 /** Convenience methods for accessing the flags */
1576 // @{
1577 HALIDE_ALWAYS_INLINE bool get_flag(halide_buffer_flags flag) const {
1578 return (flags & flag) != 0;
1579 }
1580
1581 HALIDE_ALWAYS_INLINE void set_flag(halide_buffer_flags flag, bool value) {
1582 if (value) {
1583 flags |= flag;
1584 } else {
1585 flags &= ~uint64_t(flag);
1586 }
1587 }
1588
1589 HALIDE_MUST_USE_RESULT HALIDE_ALWAYS_INLINE bool host_dirty() const {
1590 return get_flag(halide_buffer_flag_host_dirty);
1591 }
1592
1593 HALIDE_MUST_USE_RESULT HALIDE_ALWAYS_INLINE bool device_dirty() const {
1594 return get_flag(halide_buffer_flag_device_dirty);
1595 }
1596
1597 HALIDE_ALWAYS_INLINE void set_host_dirty(bool v = true) {
1598 set_flag(halide_buffer_flag_host_dirty, v);
1599 }
1600
1601 HALIDE_ALWAYS_INLINE void set_device_dirty(bool v = true) {
1603 }
1604 // @}
1605
1606 /** The total number of elements this buffer represents. Equal to
1607 * the product of the extents */
1608 HALIDE_ALWAYS_INLINE size_t number_of_elements() const {
1609 size_t s = 1;
1610 for (int i = 0; i < dimensions; i++) {
1611 s *= dim[i].extent;
1612 }
1613 return s;
1614 }
1615
1616 /** Offset to the element with the lowest address.
1617 * If all strides are positive, equal to zero.
1618 * Offset is in elements, not bytes.
1619 * Unlike begin(), this is ok to call on an unallocated buffer. */
1620 HALIDE_ALWAYS_INLINE ptrdiff_t begin_offset() const {
1621 ptrdiff_t index = 0;
1622 for (int i = 0; i < dimensions; i++) {
1623 const int stride = dim[i].stride;
1624 if (stride < 0) {
1625 index += stride * (ptrdiff_t)(dim[i].extent - 1);
1626 }
1627 }
1628 return index;
1629 }
1630
1631 /** An offset to one beyond the element with the highest address.
1632 * Offset is in elements, not bytes.
1633 * Unlike end(), this is ok to call on an unallocated buffer. */
1634 HALIDE_ALWAYS_INLINE ptrdiff_t end_offset() const {
1635 ptrdiff_t index = 0;
1636 for (int i = 0; i < dimensions; i++) {
1637 const int stride = dim[i].stride;
1638 if (stride > 0) {
1639 index += stride * (ptrdiff_t)(dim[i].extent - 1);
1640 }
1641 }
1642 index += 1;
1643 return index;
1644 }
1645
1646 /** A pointer to the element with the lowest address.
1647 * If all strides are positive, equal to the host pointer.
1648 * Illegal to call on an unallocated buffer. */
1649 HALIDE_ALWAYS_INLINE uint8_t *begin() const {
1650 return host + begin_offset() * type.bytes();
1651 }
1652
1653 /** A pointer to one beyond the element with the highest address.
1654 * Illegal to call on an unallocated buffer. */
1655 HALIDE_ALWAYS_INLINE uint8_t *end() const {
1656 return host + end_offset() * type.bytes();
1657 }
1658
1659 /** The total number of bytes spanned by the data in memory. */
1660 HALIDE_ALWAYS_INLINE size_t size_in_bytes() const {
1661 return (size_t)(end_offset() - begin_offset()) * type.bytes();
1662 }
1663
1664 /** A pointer to the element at the given location. */
1665 HALIDE_ALWAYS_INLINE uint8_t *address_of(const int *pos) const {
1666 ptrdiff_t index = 0;
1667 for (int i = 0; i < dimensions; i++) {
1668 index += (ptrdiff_t)dim[i].stride * (pos[i] - dim[i].min);
1669 }
1670 return host + index * type.bytes();
1671 }
1672
1673 /** Attempt to call device_sync for the buffer. If the buffer
1674 * has no device_interface (or no device_sync), this is a quiet no-op.
1675 * Calling this explicitly should rarely be necessary, except for profiling. */
1676 HALIDE_ALWAYS_INLINE int device_sync(void *ctx = nullptr) {
1678 return device_interface->device_sync(ctx, this);
1679 }
1680 return 0;
1681 }
1682
1683 /** Check if an input buffer passed extern stage is a querying
1684 * bounds. Compared to doing the host pointer check directly,
1685 * this both adds clarity to code and will facilitate moving to
1686 * another representation for bounds query arguments. */
1687 HALIDE_ALWAYS_INLINE bool is_bounds_query() const {
1688 return host == nullptr && device == 0;
1689 }
1690
1691#endif
1693
1694#ifdef __cplusplus
1695extern "C" {
1696#endif
1697
1698#ifndef HALIDE_ATTRIBUTE_DEPRECATED
1699#ifdef HALIDE_ALLOW_DEPRECATED
1700#define HALIDE_ATTRIBUTE_DEPRECATED(x)
1701#else
1702#ifdef _MSC_VER
1703#define HALIDE_ATTRIBUTE_DEPRECATED(x) __declspec(deprecated(x))
1704#else
1705#define HALIDE_ATTRIBUTE_DEPRECATED(x) __attribute__((deprecated(x)))
1706#endif
1707#endif
1708#endif
1709
1710/** halide_scalar_value_t is a simple union able to represent all the well-known
1711 * scalar values in a filter argument. Note that it isn't tagged with a type;
1712 * you must ensure you know the proper type before accessing. Most user
1713 * code will never need to create instances of this struct; its primary use
1714 * is to hold def/min/max values in a halide_filter_argument_t. (Note that
1715 * this is conceptually just a union; it's wrapped in a struct to ensure
1716 * that it doesn't get anonymized by LLVM.)
1717 */
1719 union {
1720 bool b;
1729 float f32;
1730 double f64;
1731 void *handle;
1732 } u;
1733#ifdef __cplusplus
1735 u.u64 = 0;
1736 }
1737#endif
1738};
1739
1745
1746/*
1747 These structs must be robust across different compilers and settings; when
1748 modifying them, strive for the following rules:
1749
1750 1) All fields are explicitly sized. I.e. must use int32_t and not "int"
1751 2) All fields must land on an alignment boundary that is the same as their size
1752 3) Explicit padding is added to make that so
1753 4) The sizeof the struct is padded out to a multiple of the largest natural size thing in the struct
1754 5) don't forget that 32 and 64 bit pointers are different sizes
1755*/
1756
1757/**
1758 * Obsolete version of halide_filter_argument_t; only present in
1759 * code that wrote halide_filter_metadata_t version 0.
1760 */
1768
1769/**
1770 * halide_filter_argument_t is essentially a plain-C-struct equivalent to
1771 * Halide::Argument; most user code will never need to create one.
1772 */
1774 const char *name; // name of the argument; will never be null or empty.
1775 int32_t kind; // actually halide_argument_kind_t
1776 int32_t dimensions; // always zero for scalar arguments
1778 // These pointers should always be null for buffer arguments,
1779 // and *may* be null for scalar arguments. (A null value means
1780 // there is no def/min/max/estimate specified for this argument.)
1782 // This pointer should always be null for scalar arguments,
1783 // and *may* be null for buffer arguments. If not null, it should always
1784 // point to an array of dimensions*2 pointers, which will be the (min, extent)
1785 // estimates for each dimension of the buffer. (Note that any of the pointers
1786 // may be null as well.)
1788};
1789
1791#ifdef __cplusplus
1792 static const int32_t VERSION = 1;
1793#endif
1794
1795 /** version of this metadata; currently always 1. */
1797
1798 /** The number of entries in the arguments field. This is always >= 1. */
1800
1801 /** An array of the filters input and output arguments; this will never be
1802 * null. The order of arguments is not guaranteed (input and output arguments
1803 * may come in any order); however, it is guaranteed that all arguments
1804 * will have a unique name within a given filter. */
1806
1807 /** The Target for which the filter was compiled. This is always
1808 * a canonical Target string (ie a product of Target::to_string). */
1809 const char *target;
1810
1811 /** The function name of the filter. */
1812 const char *name;
1813};
1814
1815/** halide_register_argv_and_metadata() is a **user-defined** function that
1816 * must be provided in order to use the registration.cc files produced
1817 * by Generators when the 'registration' output is requested. Each registration.cc
1818 * file provides a static initializer that calls this function with the given
1819 * filter's argv-call variant, its metadata, and (optionally) and additional
1820 * textual data that the build system chooses to tack on for its own purposes.
1821 * Note that this will be called at static-initializer time (i.e., before
1822 * main() is called), and in an unpredictable order. Note that extra_key_value_pairs
1823 * may be nullptr; if it's not null, it's expected to be a null-terminated list
1824 * of strings, with an even number of entries. */
1826 int (*filter_argv_call)(void **),
1827 const struct halide_filter_metadata_t *filter_metadata,
1828 const char *const *extra_key_value_pairs);
1829
1830/** The functions below here are relevant for pipelines compiled with
1831 * the -profile target flag, which runs a sampling profiler thread
1832 * alongside the pipeline. */
1833
1834/** Per-Func state tracked by the sampling profiler. */
1835struct HALIDE_ATTRIBUTE_ALIGN(8) halide_profiler_func_stats {
1836 /** Total time taken evaluating this Func (in nanoseconds). */
1837 uint64_t time;
1838
1839 /** The current memory allocation of this Func. */
1840 uint64_t memory_current;
1841
1842 /** The peak memory allocation of this Func. */
1843 uint64_t memory_peak;
1844
1845 /** The total memory allocation of this Func. */
1846 uint64_t memory_total;
1847
1848 /** The peak stack allocation of this Func's threads. */
1849 uint64_t stack_peak;
1850
1851 /** The average number of thread pool worker threads active while computing this Func. */
1852 uint64_t active_threads_numerator, active_threads_denominator;
1853
1854 /** The name of this Func. A global constant string. */
1855 const char *name;
1856
1857 /** The total number of memory allocation of this Func. */
1858 int num_allocs;
1859};
1860
1861/** Per-pipeline state tracked by the sampling profiler. These exist
1862 * in a linked list. */
1863struct HALIDE_ATTRIBUTE_ALIGN(8) halide_profiler_pipeline_stats {
1864 /** Total time spent in this pipeline (in nanoseconds) */
1865 uint64_t time;
1866
1867 /** The current memory allocation of funcs in this pipeline. */
1868 uint64_t memory_current;
1869
1870 /** The peak memory allocation of funcs in this pipeline. */
1871 uint64_t memory_peak;
1872
1873 /** The total memory allocation of funcs in this pipeline. */
1874 uint64_t memory_total;
1875
1876 /** The average number of thread pool worker threads doing useful
1877 * work while computing this pipeline. */
1878 uint64_t active_threads_numerator, active_threads_denominator;
1879
1880 /** The name of this pipeline. A global constant string. */
1881 const char *name;
1882
1883 /** An array containing states for each Func in this pipeline. */
1884 struct halide_profiler_func_stats *funcs;
1885
1886 /** The next pipeline_stats pointer. It's a void * because types
1887 * in the Halide runtime may not currently be recursive. */
1888 void *next;
1889
1890 /** The number of funcs in this pipeline. */
1891 int num_funcs;
1892
1893 /** The number of times this pipeline has been run. */
1894 int runs;
1895
1896 /** The total number of samples taken inside of this pipeline. */
1897 int samples;
1898
1899 /** The total number of memory allocation of funcs in this pipeline. */
1900 int num_allocs;
1901};
1902
1903/** Per-invocation-of-a-pipeline state. Lives on the stack of the Halide
1904 * code. Exists in a doubly-linked list to that it can be cleanly
1905 * removed. */
1906struct HALIDE_ATTRIBUTE_ALIGN(8) halide_profiler_instance_state {
1907 /** Time billed to funcs in this instance by the sampling thread. */
1908 uint64_t billed_time;
1909
1910 /** Wall clock time of the start of the instance. */
1911 uint64_t start_time;
1912
1913 /** The current memory allocation of funcs in this instance. */
1914 uint64_t memory_current;
1915
1916 /** The peak memory allocation of funcs in this instance. */
1917 uint64_t memory_peak;
1918
1919 /** The total memory allocation of funcs in this instance. */
1920 uint64_t memory_total;
1921
1922 /** The average number of thread pool worker threads doing useful
1923 * work while computing this instance. */
1924 uint64_t active_threads_numerator, active_threads_denominator;
1925
1926 /** A pointer to the next running instance, so that the running instances
1927 * can exist in a linked list. */
1928 struct halide_profiler_instance_state *next;
1929
1930 /** A pointer to the address of the next pointer of the previous instance,
1931 * so that this can be removed from the linked list when the instance
1932 * terminates. */
1933 struct halide_profiler_instance_state **prev_next;
1934
1935 /** Information shared across all instances. The stats above are merged into
1936 * it when the instance is retired. */
1937 struct halide_profiler_pipeline_stats *pipeline_stats;
1938
1939 /** An array containing states for each Func in this instance of this pipeline. */
1940 struct halide_profiler_func_stats *funcs;
1941
1942 /** The id of the current running Func. Set by the pipeline, read
1943 * periodically by the profiler thread. */
1944 int current_func;
1945
1946 /** The number of threads currently doing work on this pipeline instance. */
1947 int active_threads;
1948
1949 /** The number of samples taken by this instance. */
1950 int samples;
1951
1952 /** The total number of memory allocation of funcs in this instance. */
1953 int num_allocs;
1954
1955 /** Whether or not this instance should count towards pipeline
1956 * statistics. */
1957 int should_collect_statistics;
1958};
1959
1960/** The global state of the profiler. */
1962 /** Guards access to the fields below. If not locked, the sampling
1963 * profiler thread is free to modify things below (including
1964 * reordering the linked list of pipeline stats). */
1966
1967 /** A linked list of stats gathered for each pipeline. */
1968 struct halide_profiler_pipeline_stats *pipelines;
1969
1970 /** Retrieve remote profiler state. Used so that the sampling
1971 * profiler can follow along with execution that occurs elsewhere,
1972 * e.g. on a DSP. If null, it reads from the int above instead. */
1973
1974 /** Sampling thread reference to be joined at shutdown. */
1975 struct halide_thread *sampling_thread;
1976
1977 /** The running instances of Halide pipelines. */
1978 struct halide_profiler_instance_state *instances;
1979
1980 /** If this callback is defined, the profiler asserts that there is a single
1981 * live instance, and then uses it to get the current func and number of
1982 * active threads insted of reading the fields in the instance. This is used
1983 * so that the profiler can follow along with execution that occurs
1984 * elsewhere (e.g. on an accelerator). */
1985 void (*get_remote_profiler_state)(int *func, int *active_workers);
1986
1987 /** The amount of time the profiler thread sleeps between samples in
1988 * microseconds. Defaults to 1000. To change it call
1989 * halide_profiler_get_state and mutate this field. */
1991
1992 /** Set to 1 when you want the profiler to wait for all running instances to
1993 * finish and then stop gracefully. */
1995};
1996
1997/** Get a pointer to the global profiler state for programmatic
1998 * inspection. Lock it before using to pause the profiler. */
2000
2001/** Get a pointer to the pipeline state associated with pipeline_name.
2002 * This function grabs the global profiler state's lock on entry. */
2003extern struct halide_profiler_pipeline_stats *halide_profiler_get_pipeline_state(const char *pipeline_name);
2004
2005/** Collects profiling information. Intended to be called from a timer
2006 * interrupt handler if timer based profiling is being used.
2007 * State argument is acquired via halide_profiler_get_pipeline_state.
2008 * prev_t argument is the previous time and can be used to set a more
2009 * accurate time interval if desired. */
2011
2012/** Reset profiler state cheaply. May leave threads running or some memory
2013 * allocated but all accumulated statistics are reset. Blocks until all running
2014 * profiled Halide pipelines exit. */
2015extern void halide_profiler_reset(void);
2016
2017/** Reset all profiler state. Blocks until all running profiled Halide
2018 * pipelines exit. */
2020
2021/** Print out timing statistics for everything run since the last
2022 * reset. Also happens at process exit. */
2023extern void halide_profiler_report(void *user_context);
2024
2025/** These routines are called to temporarily disable and then reenable
2026 * the profiler. */
2027//@{
2030//@}
2031
2032/// \name "Float16" functions
2033/// These functions operate of bits (``uint16_t``) representing a half
2034/// precision floating point number (IEEE-754 2008 binary16).
2035//{@
2036
2037/** Read bits representing a half precision floating point number and return
2038 * the float that represents the same value */
2040
2041/** Read bits representing a half precision floating point number and return
2042 * the double that represents the same value */
2044
2045// TODO: Conversion functions to half
2046
2047//@}
2048
2049// Allocating and freeing device memory is often very slow. The
2050// methods below give Halide's runtime permission to hold onto device
2051// memory to service future requests instead of returning it to the
2052// underlying device API. The API does not manage an allocation pool,
2053// all it does is provide access to a shared counter that acts as a
2054// limit on the unused memory not yet returned to the underlying
2055// device API. It makes callbacks to participants when memory needs to
2056// be released because the limit is about to be exceeded (either
2057// because the limit has been reduced, or because the memory owned by
2058// some participant becomes unused).
2059
2060/** Tell Halide whether or not it is permitted to hold onto device
2061 * allocations to service future requests instead of returning them
2062 * eagerly to the underlying device API. Many device allocators are
2063 * quite slow, so it can be beneficial to set this to true. The
2064 * default value for now is false.
2065 *
2066 * Note that if enabled, the eviction policy is very simplistic. The
2067 * 32 most-recently used allocations are preserved, regardless of
2068 * their size. Additionally, if a call to cuMalloc results in an
2069 * out-of-memory error, the entire cache is flushed and the allocation
2070 * is retried. See https://github.com/halide/Halide/issues/4093
2071 *
2072 * If set to false, releases all unused device allocations back to the
2073 * underlying device APIs. For finer-grained control, see specific
2074 * methods in each device api runtime.
2075 *
2076 * Note that if the flag is set to true, this call *must* succeed and return
2077 * a value of halide_error_code_success (i.e., zero); if you replace
2078 * the implementation of this call in the runtime, you must honor this contract.
2079 * */
2080extern int halide_reuse_device_allocations(void *user_context, bool);
2081
2082/** Determines whether on device_free the memory is returned
2083 * immediately to the device API, or placed on a free list for future
2084 * use. Override and switch based on the user_context for
2085 * finer-grained control. By default just returns the value most
2086 * recently set by the method above. */
2087extern bool halide_can_reuse_device_allocations(void *user_context);
2088
2093
2094/** Register a callback to be informed when
2095 * halide_reuse_device_allocations(false) is called, and all unused
2096 * device allocations must be released. The object passed should have
2097 * global lifetime, and its next field will be clobbered. */
2099
2100#ifdef __cplusplus
2101} // End extern "C"
2102#endif
2103
2104#if (__cplusplus >= 201103L || _MSVC_LANG >= 201103L)
2105
2106namespace {
2107
2108template<typename T>
2109struct check_is_pointer {
2110 static constexpr bool value = false;
2111};
2112
2113template<typename T>
2114struct check_is_pointer<T *> {
2115 static constexpr bool value = true;
2116};
2117
2118} // namespace
2119
2120/** Construct the halide equivalent of a C type */
2121template<typename T>
2122HALIDE_ALWAYS_INLINE constexpr halide_type_t halide_type_of() {
2123 // Create a compile-time error if T is not a pointer (without
2124 // using any includes - this code goes into the runtime).
2125 // (Note that we can't have uninitialized variables in constexpr functions,
2126 // even if those variables aren't used.)
2127 static_assert(check_is_pointer<T>::value, "Expected a pointer type here");
2129}
2130
2131#ifdef HALIDE_CPP_COMPILER_HAS_FLOAT16
2132template<>
2133HALIDE_ALWAYS_INLINE constexpr halide_type_t halide_type_of<_Float16>() {
2134 return halide_type_t(halide_type_float, 16);
2135}
2136#endif
2137
2138template<>
2139HALIDE_ALWAYS_INLINE constexpr halide_type_t halide_type_of<float>() {
2140 return halide_type_t(halide_type_float, 32);
2141}
2142
2143template<>
2144HALIDE_ALWAYS_INLINE constexpr halide_type_t halide_type_of<double>() {
2145 return halide_type_t(halide_type_float, 64);
2146}
2147
2148template<>
2149HALIDE_ALWAYS_INLINE constexpr halide_type_t halide_type_of<bool>() {
2151}
2152
2153template<>
2154HALIDE_ALWAYS_INLINE constexpr halide_type_t halide_type_of<uint8_t>() {
2156}
2157
2158template<>
2159HALIDE_ALWAYS_INLINE constexpr halide_type_t halide_type_of<uint16_t>() {
2160 return halide_type_t(halide_type_uint, 16);
2161}
2162
2163template<>
2164HALIDE_ALWAYS_INLINE constexpr halide_type_t halide_type_of<uint32_t>() {
2165 return halide_type_t(halide_type_uint, 32);
2166}
2167
2168template<>
2169HALIDE_ALWAYS_INLINE constexpr halide_type_t halide_type_of<uint64_t>() {
2170 return halide_type_t(halide_type_uint, 64);
2171}
2172
2173template<>
2174HALIDE_ALWAYS_INLINE constexpr halide_type_t halide_type_of<int8_t>() {
2175 return halide_type_t(halide_type_int, 8);
2176}
2177
2178template<>
2179HALIDE_ALWAYS_INLINE constexpr halide_type_t halide_type_of<int16_t>() {
2180 return halide_type_t(halide_type_int, 16);
2181}
2182
2183template<>
2184HALIDE_ALWAYS_INLINE constexpr halide_type_t halide_type_of<int32_t>() {
2185 return halide_type_t(halide_type_int, 32);
2186}
2187
2188template<>
2189HALIDE_ALWAYS_INLINE constexpr halide_type_t halide_type_of<int64_t>() {
2190 return halide_type_t(halide_type_int, 64);
2191}
2192
2193#ifndef COMPILING_HALIDE_RUNTIME
2194
2195// These structures are used by `function_info_header` files
2196// (generated by passing `-e function_info_header` to a Generator).
2197// The generated files contain documentation on the proper usage.
2198namespace HalideFunctionInfo {
2199
2200enum ArgumentKind { InputScalar = 0,
2201 InputBuffer = 1,
2202 OutputBuffer = 2 };
2203
2204struct ArgumentInfo {
2205 std::string_view name;
2206 ArgumentKind kind;
2207 int32_t dimensions; // always zero for scalar arguments
2208 halide_type_t type;
2209};
2210
2211} // namespace HalideFunctionInfo
2212
2213#endif // COMPILING_HALIDE_RUNTIME
2214
2215#endif // (__cplusplus >= 201103L || _MSVC_LANG >= 201103L)
2216
2217#endif // HALIDE_HALIDERUNTIME_H
void halide_set_custom_parallel_runtime(halide_do_par_for_t, halide_do_task_t, halide_do_loop_task_t, halide_do_parallel_tasks_t, halide_semaphore_init_t, halide_semaphore_try_acquire_t, halide_semaphore_release_t)
int halide_memoization_cache_lookup(void *user_context, const uint8_t *cache_key, int32_t size, struct halide_buffer_t *realized_bounds, int32_t tuple_count, struct halide_buffer_t **tuple_buffers)
Given a cache key for a memoized result, currently constructed from the Func name and top-level Func ...
int halide_error_bad_extern_fold(void *user_context, const char *func_name, int dim, int min, int extent, int valid_min, int fold_factor)
int halide_device_sync(void *user_context, struct halide_buffer_t *buf)
Wait for current GPU operations to complete.
int halide_default_do_task(void *user_context, halide_task_t f, int idx, uint8_t *closure)
int halide_do_par_for(void *user_context, halide_task_t task, int min, int size, uint8_t *closure)
void *(* halide_load_library_t)(const char *name)
int halide_error_bad_fold(void *user_context, const char *func_name, const char *var_name, const char *loop_name)
int(* halide_semaphore_release_t)(struct halide_semaphore_t *, int)
void halide_profiler_lock(struct halide_profiler_state *)
These routines are called to temporarily disable and then reenable the profiler.
void halide_cond_signal(struct halide_cond *cond)
void * halide_default_get_library_symbol(void *lib, const char *name)
int halide_do_loop_task(void *user_context, halide_loop_task_t f, int min, int extent, uint8_t *closure, void *task_parent)
halide_load_library_t halide_set_custom_load_library(halide_load_library_t user_load_library)
int halide_device_crop(void *user_context, const struct halide_buffer_t *src, struct halide_buffer_t *dst)
Give the destination buffer a device allocation which is an alias for the same coordinate range in th...
int halide_semaphore_init(struct halide_semaphore_t *, int n)
halide_get_symbol_t halide_set_custom_get_symbol(halide_get_symbol_t user_get_symbol)
double halide_float16_bits_to_double(uint16_t)
Read bits representing a half precision floating point number and return the double that represents t...
void * halide_malloc(void *user_context, size_t x)
Halide calls these functions to allocate and free memory.
void *(* halide_get_library_symbol_t)(void *lib, const char *name)
int halide_msan_annotate_buffer_is_initialized(void *user_context, struct halide_buffer_t *buffer)
Mark the data pointed to by the halide_buffer_t as initialized (but not the halide_buffer_t itself),...
void halide_default_print(void *user_context, const char *)
halide_target_feature_t
Optional features a compilation Target can have.
@ halide_target_feature_large_buffers
Enable 64-bit buffer indexing to support buffers > 2GB. Ignored if bits != 64.
@ halide_target_feature_fma
Enable x86 FMA instruction.
@ halide_target_feature_wasm_bulk_memory
Enable +bulk-memory instructions for WebAssembly codegen.
@ halide_target_feature_tsan
Enable hooks for TSAN support.
@ halide_target_feature_msan
Enable hooks for MSAN support.
@ halide_target_feature_avx512_zen4
Enable the AVX512 features supported by Zen4 processors. This include all of the Cannonlake features,...
@ halide_target_feature_wasm_threads
Enable use of threads in WebAssembly codegen. Requires the use of a wasm runtime that provides pthrea...
@ halide_target_feature_trace_loads
Trace all loads done by the pipeline. Equivalent to calling Func::trace_loads on every non-inlined Fu...
@ halide_target_feature_enable_llvm_loop_opt
Enable loop vectorization + unrolling in LLVM. Overrides halide_target_feature_disable_llvm_loop_opt....
@ halide_target_feature_no_asserts
Disable all runtime checks, for slightly tighter code.
@ halide_target_feature_cl_doubles
Enable double support on OpenCL targets.
@ halide_target_feature_rvv
Enable RISCV "V" Vector Extension.
@ halide_target_feature_avx2
Use AVX 2 instructions. Only relevant on x86.
@ halide_target_feature_trace_realizations
Trace all realizations done by the pipeline. Equivalent to calling Func::trace_realizations on every ...
@ halide_target_feature_c_plus_plus_mangling
Generate C++ mangled names for result function, et al.
@ halide_target_feature_vulkan_float16
Enable Vulkan 16-bit float support.
@ halide_target_feature_no_runtime
Do not include a copy of the Halide runtime in any generated object file or assembly.
@ halide_target_feature_hvx_v65
Enable Hexagon v65 architecture.
@ halide_target_feature_debug
Turn on debug info and output for runtime code.
@ halide_target_feature_embed_bitcode
Emulate clang -fembed-bitcode flag.
@ halide_target_feature_armv86a
Enable ARMv8.6a instructions.
@ halide_target_feature_wasm_simd128
Enable +simd128 instructions for WebAssembly codegen.
@ halide_target_feature_vulkan
Enable Vulkan runtime support.
@ halide_target_feature_end
A sentinel. Every target is considered to have this feature, and setting this feature does nothing.
@ halide_llvm_large_code_model
Use the LLVM large code model to compile.
@ halide_target_feature_profile_by_timer
Alternative to halide_target_feature_profile using timer interrupt for systems without threads or app...
@ halide_target_feature_semihosting
Used together with Target::NoOS for the baremetal target built with semihosting library and run with ...
@ halide_target_feature_soft_float_abi
Enable soft float ABI. This only enables the soft float ABI calling convention, which does not necess...
@ halide_target_feature_sve2
Enable ARM Scalable Vector Extensions v2.
@ halide_target_feature_d3d12compute
Enable Direct3D 12 Compute runtime.
@ halide_target_feature_cuda_capability86
Enable CUDA compute capability 8.6 (Ampere)
@ halide_target_feature_armv89a
Enable ARMv8.9a instructions.
@ halide_target_feature_avx512_skylake
Enable the AVX512 features supported by Skylake Xeon server processors. This adds AVX512-VL,...
@ halide_target_feature_avx512_cannonlake
Enable the AVX512 features expected to be supported by future Cannonlake processors....
@ halide_target_feature_metal
Enable the (Apple) Metal runtime.
@ halide_target_feature_hvx_128
Enable HVX 128 byte mode.
@ halide_target_feature_cuda_capability70
Enable CUDA compute capability 7.0 (Volta)
@ halide_target_feature_fma4
Enable x86 (AMD) FMA4 instruction set.
@ halide_target_feature_cuda_capability30
Enable CUDA compute capability 3.0 (Kepler)
@ halide_target_feature_no_neon
Avoid using NEON instructions. Only relevant for 32-bit ARM.
@ halide_target_feature_cuda_capability61
Enable CUDA compute capability 6.1 (Pascal)
@ halide_target_feature_armv7s
Generate code for ARMv7s. Only relevant for 32-bit ARM.
@ halide_target_feature_spirv
Enable SPIR-V code generation support.
@ halide_target_feature_trace_pipeline
Trace the pipeline.
@ halide_target_feature_armv88a
Enable ARMv8.8a instructions.
@ halide_target_feature_cl_atomic64
Enable 64-bit atomics operations on OpenCL targets.
@ halide_target_feature_egl
Force use of EGL support.
@ halide_target_feature_hvx_v68
Enable Hexagon v68 architecture.
@ halide_target_feature_avx10_1
Intel AVX10 version 1 support. vector_bits is used to indicate width.
@ halide_target_feature_profile
Launch a sampling profiler alongside the Halide pipeline that monitors and reports the runtime used b...
@ halide_target_feature_strict_float
Turn off all non-IEEE floating-point optimization. Currently applies only to LLVM targets.
@ halide_target_feature_cuda_capability35
Enable CUDA compute capability 3.5 (Kepler)
@ halide_target_feature_armv8a
Enable ARMv8a instructions.
@ halide_target_feature_asan
Enable hooks for ASAN support.
@ halide_target_feature_armv87a
Enable ARMv8.7a instructions.
@ halide_target_feature_cl_half
Enable half support on OpenCL targets.
@ halide_target_feature_vulkan_float64
Enable Vulkan 64-bit float support.
@ halide_target_feature_arm_dot_prod
Enable ARMv8.2-a dotprod extension (i.e. udot and sdot instructions)
@ halide_target_feature_avx512_sapphirerapids
Enable the AVX512 features supported by Sapphire Rapids processors. This include all of the Zen4 feat...
@ halide_target_feature_vulkan_version13
Enable Vulkan v1.3 runtime target support.
@ halide_target_feature_vulkan_version12
Enable Vulkan v1.2 runtime target support.
@ halide_target_feature_sse41
Use SSE 4.1 and earlier instructions. Only relevant on x86.
@ halide_target_feature_power_arch_2_07
Use POWER ISA 2.07 new instructions. Only relevant on POWERPC.
@ halide_target_feature_opencl
Enable the OpenCL runtime.
@ halide_target_feature_trace_stores
Trace all stores done by the pipeline. Equivalent to calling Func::trace_stores on every non-inlined ...
@ halide_target_feature_hexagon_dma
Enable Hexagon DMA buffers.
@ halide_target_feature_avx512
Enable the base AVX512 subset supported by all AVX512 architectures. The specific feature sets are AV...
@ halide_target_feature_avx512_knl
Enable the AVX512 features supported by Knight's Landing chips, such as the Xeon Phi x200....
@ halide_target_feature_cuda_capability50
Enable CUDA compute capability 5.0 (Maxwell)
@ halide_target_feature_arm_fp16
Enable ARMv8.2-a half-precision floating point data processing.
@ halide_target_feature_armv82a
Enable ARMv8.2a instructions.
@ halide_target_feature_hvx_v62
Enable Hexagon v62 architecture.
@ halide_target_feature_armv84a
Enable ARMv8.4a instructions.
@ halide_target_feature_cuda
Enable the CUDA runtime. Defaults to compute capability 2.0 (Fermi)
@ halide_target_feature_armv81a
Enable ARMv8.1a instructions.
@ halide_target_feature_webgpu
Enable the WebGPU runtime.
@ halide_target_feature_sanitizer_coverage
Enable hooks for SanitizerCoverage support.
@ halide_target_feature_cuda_capability80
Enable CUDA compute capability 8.0 (Ampere)
@ halide_target_feature_wasm_mvponly
Disable all extensions to WebAssembly codegen (including +sign-ext and +nontrapping-fptoint,...
@ halide_target_feature_f16c
Enable x86 16-bit float support.
@ halide_target_feature_vulkan_int16
Enable Vulkan 16-bit integer support.
@ halide_target_feature_cuda_capability32
Enable CUDA compute capability 3.2 (Tegra K1)
@ halide_target_feature_armv85a
Enable ARMv8.5a instructions.
@ halide_target_feature_jit
Generate code that will run immediately inside the calling process.
@ halide_target_feature_avx
Use AVX 1 instructions. Only relevant on x86.
@ halide_target_feature_cuda_capability75
Enable CUDA compute capability 7.5 (Turing)
@ halide_target_feature_check_unsafe_promises
Insert assertions for promises.
@ halide_target_feature_vsx
Use VSX instructions. Only relevant on POWERPC.
@ halide_target_feature_vulkan_int8
Enable Vulkan 8-bit integer support.
@ halide_target_feature_armv83a
Enable ARMv8.3a instructions.
@ halide_target_feature_vulkan_int64
Enable Vulkan 64-bit integer support.
@ halide_target_feature_user_context
Generated code takes a user_context pointer as first argument.
@ halide_target_feature_no_bounds_query
Disable the bounds querying functionality.
@ halide_target_feature_vulkan_version10
Enable Vulkan v1.0 runtime target support.
@ halide_target_feature_fuzz_float_stores
On every floating point store, set the last bit of the mantissa to zero. Pipelines for which the outp...
@ halide_target_feature_sve
Enable ARM Scalable Vector Extensions.
@ halide_target_feature_x86_apx
Intel x86 APX support. Covers initial set of features released as APX: egpr,push2pop2,...
@ halide_target_feature_hvx_v66
Enable Hexagon v66 architecture.
void halide_free(void *user_context, void *ptr)
bool halide_semaphore_try_acquire(struct halide_semaphore_t *, int n)
halide_buffer_flags
@ halide_buffer_flag_device_dirty
@ halide_buffer_flag_host_dirty
bool halide_default_semaphore_try_acquire(struct halide_semaphore_t *, int n)
int halide_error_buffer_allocation_too_large(void *user_context, const char *buffer_name, uint64_t allocation_size, uint64_t max_size)
void halide_cond_wait(struct halide_cond *cond, struct halide_mutex *mutex)
int(* halide_do_par_for_t)(void *, halide_task_t, int, int, uint8_t *)
Set a custom method for performing a parallel for loop.
int halide_set_num_threads(int n)
Set the number of threads used by Halide's thread pool.
int halide_copy_to_host(void *user_context, struct halide_buffer_t *buf)
Copy image data from device memory to host memory.
int halide_default_do_par_for(void *user_context, halide_task_t task, int min, int size, uint8_t *closure)
The default versions of the parallel runtime functions.
int halide_msan_annotate_memory_is_initialized(void *user_context, const void *ptr, uint64_t len)
Annotate that a given range of memory has been initialized; only used when Target::MSAN is enabled.
struct halide_profiler_state * halide_profiler_get_state(void)
Get a pointer to the global profiler state for programmatic inspection.
int halide_error_bad_dimensions(void *user_context, const char *func_name, int32_t dimensions_given, int32_t correct_dimensions)
int halide_mutex_array_unlock(struct halide_mutex_array *array, int entry)
int halide_error_constraint_violated(void *user_context, const char *var, int val, const char *constrained_var, int constrained_val)
int halide_default_do_loop_task(void *user_context, halide_loop_task_t f, int min, int extent, uint8_t *closure, void *task_parent)
void halide_profiler_reset(void)
Reset profiler state cheaply.
int(* halide_task_t)(void *user_context, int task_number, uint8_t *closure)
Define halide_do_par_for to replace the default thread pool implementation.
void halide_mutex_lock(struct halide_mutex *mutex)
A basic set of mutex and condition variable functions, which call platform specific code for mutual e...
halide_trace_event_code_t
@ halide_trace_consume
@ halide_trace_load
@ halide_trace_tag
@ halide_trace_store
@ halide_trace_begin_pipeline
@ halide_trace_end_pipeline
@ halide_trace_end_produce
@ halide_trace_produce
@ halide_trace_end_consume
@ halide_trace_end_realization
@ halide_trace_begin_realization
struct halide_profiler_pipeline_stats * halide_profiler_get_pipeline_state(const char *pipeline_name)
Get a pointer to the pipeline state associated with pipeline_name.
int halide_do_task(void *user_context, halide_task_t f, int idx, uint8_t *closure)
halide_malloc_t halide_set_custom_malloc(halide_malloc_t user_malloc)
int halide_error_device_dirty_with_no_device_support(void *user_context, const char *buffer_name)
int halide_default_semaphore_init(struct halide_semaphore_t *, int n)
void halide_msan_annotate_buffer_is_initialized_as_destructor(void *user_context, void *buffer)
void * halide_get_library_symbol(void *lib, const char *name)
void(* halide_error_handler_t)(void *, const char *)
void halide_device_release(void *user_context, const struct halide_device_interface_t *device_interface)
Release all data associated with the given device interface, in particular all resources (memory,...
int halide_error_bounds_inference_call_failed(void *user_context, const char *extern_stage_name, int result)
Halide calls the functions below on various error conditions.
int halide_error_buffer_extents_negative(void *user_context, const char *buffer_name, int dimension, int extent)
int halide_error_buffer_is_null(void *user_context, const char *routine)
void halide_mutex_unlock(struct halide_mutex *mutex)
int halide_error_constraints_make_required_region_smaller(void *user_context, const char *buffer_name, int dimension, int constrained_min, int constrained_extent, int required_min, int required_extent)
int halide_error_out_of_memory(void *user_context)
void * halide_get_symbol(const char *name)
Halide calls these functions to interact with the underlying system runtime functions.
int32_t halide_debug_to_file(void *user_context, const char *filename, struct halide_buffer_t *buf)
Called when debug_to_file is used inside Halide code.
int halide_error_no_device_interface(void *user_context)
struct halide_thread * halide_spawn_thread(void(*f)(void *), void *closure)
Spawn a thread.
int halide_error_debug_to_file_failed(void *user_context, const char *func, const char *filename, int error_code)
struct halide_dimension_t halide_dimension_t
int halide_error_requirement_failed(void *user_context, const char *condition, const char *message)
void halide_memoization_cache_release(void *user_context, void *host)
If halide_memoization_cache_lookup succeeds, halide_memoization_cache_release must be called to signa...
int(* halide_can_use_target_features_t)(int count, const uint64_t *features)
void halide_register_argv_and_metadata(int(*filter_argv_call)(void **), const struct halide_filter_metadata_t *filter_metadata, const char *const *extra_key_value_pairs)
halide_register_argv_and_metadata() is a user-defined function that must be provided in order to use ...
void *(* halide_get_symbol_t)(const char *name)
int halide_error_param_too_large_f64(void *user_context, const char *param_name, double val, double max_val)
int halide_msan_check_memory_is_initialized(void *user_context, const void *ptr, uint64_t len, const char *name)
Verify that a given range of memory has been initialized; only used when Target::MSAN is enabled.
int(* halide_do_loop_task_t)(void *, halide_loop_task_t, int, int, uint8_t *, void *)
The version of do_task called for loop tasks.
int halide_error_buffer_extents_too_large(void *user_context, const char *buffer_name, int64_t actual_size, int64_t max_size)
int32_t halide_trace(void *user_context, const struct halide_trace_event_t *event)
Called when Funcs are marked as trace_load, trace_store, or trace_realization.
int halide_error_extern_stage_failed(void *user_context, const char *extern_stage_name, int result)
A call to an extern stage failed.
halide_can_use_target_features_t halide_set_custom_can_use_target_features(halide_can_use_target_features_t)
int halide_error_host_is_null(void *user_context, const char *func_name)
void halide_set_trace_file(int fd)
Set the file descriptor that Halide should write binary trace events to.
int halide_memoization_cache_store(void *user_context, const uint8_t *cache_key, int32_t size, struct halide_buffer_t *realized_bounds, int32_t tuple_count, struct halide_buffer_t **tuple_buffers, bool has_eviction_key, uint64_t eviction_key)
Given a cache key for a memoized result, currently constructed from the Func name and top-level Func ...
int halide_buffer_copy(void *user_context, struct halide_buffer_t *src, const struct halide_device_interface_t *dst_device_interface, struct halide_buffer_t *dst)
Copy data from one buffer to another.
int halide_error_vscale_invalid(void *user_context, const char *func_name, int runtime_vscale, int compiletime_vscale)
int halide_error_fold_factor_too_small(void *user_context, const char *func_name, const char *var_name, int fold_factor, const char *loop_name, int required_extent)
int halide_error_param_too_small_f64(void *user_context, const char *param_name, double val, double min_val)
int halide_error_param_too_large_i64(void *user_context, const char *param_name, int64_t val, int64_t max_val)
int halide_error_param_too_small_u64(void *user_context, const char *param_name, uint64_t val, uint64_t min_val)
void(* halide_print_t)(void *, const char *)
halide_trace_t halide_set_custom_trace(halide_trace_t trace)
void halide_print(void *user_context, const char *)
Print a message to stderr.
bool(* halide_semaphore_try_acquire_t)(struct halide_semaphore_t *, int)
void halide_profiler_report(void *user_context)
Print out timing statistics for everything run since the last reset.
void halide_set_gpu_device(int n)
Selects which gpu device to use.
void halide_mutex_array_destroy(void *user_context, void *array)
int32_t halide_default_trace(void *user_context, const struct halide_trace_event_t *event)
int halide_default_can_use_target_features(int count, const uint64_t *features)
This is the default implementation of halide_can_use_target_features; it is provided for convenience ...
int halide_reuse_device_allocations(void *user_context, bool)
Tell Halide whether or not it is permitted to hold onto device allocations to service future requests...
int halide_error_param_too_small_i64(void *user_context, const char *param_name, int64_t val, int64_t min_val)
halide_type_code_t
Types in the halide type system.
@ halide_type_float
IEEE floating point numbers.
@ halide_type_handle
opaque pointer type (void *)
@ halide_type_bfloat
floating point numbers in the bfloat format
@ halide_type_int
signed integers
@ halide_type_uint
unsigned integers
int halide_device_malloc(void *user_context, struct halide_buffer_t *buf, const struct halide_device_interface_t *device_interface)
Allocate device memory to back a halide_buffer_t.
bool halide_can_reuse_device_allocations(void *user_context)
Determines whether on device_free the memory is returned immediately to the device API,...
int halide_mutex_array_lock(struct halide_mutex_array *array, int entry)
void(* halide_free_t)(void *, void *)
int halide_error_storage_bound_too_small(void *user_context, const char *func_name, const char *var_name, int provided_size, int required_size)
int(* halide_loop_task_t)(void *user_context, int min, int extent, uint8_t *closure, void *task_parent)
A task representing a serial for loop evaluated over some range.
void halide_profiler_shutdown(void)
Reset all profiler state.
int halide_error_specialize_fail(void *user_context, const char *message)
int halide_error_device_interface_no_device(void *user_context)
int halide_error_host_and_device_dirty(void *user_context)
int halide_error_access_out_of_bounds(void *user_context, const char *func_name, int dimension, int min_touched, int max_touched, int min_valid, int max_valid)
int halide_error_explicit_bounds_too_small(void *user_context, const char *func_name, const char *var_name, int min_bound, int max_bound, int min_required, int max_required)
Various other error conditions.
void * halide_default_malloc(void *user_context, size_t x)
void * halide_default_load_library(const char *name)
int halide_error_buffer_argument_is_null(void *user_context, const char *buffer_name)
int halide_default_semaphore_release(struct halide_semaphore_t *, int n)
void halide_default_error(void *user_context, const char *)
int halide_device_slice(void *user_context, const struct halide_buffer_t *src, int slice_dim, int slice_pos, struct halide_buffer_t *dst)
Give the destination buffer a device allocation which is an alias for a similar coordinate range in t...
int halide_error_device_crop_failed(void *user_context)
void halide_default_free(void *user_context, void *ptr)
void halide_shutdown_thread_pool(void)
#define HALIDE_MUST_USE_RESULT
void halide_memoization_cache_evict(void *user_context, uint64_t eviction_key)
Evict all cache entries that were tagged with the given eviction_key in the memoize scheduling direct...
halide_do_par_for_t halide_set_custom_do_par_for(halide_do_par_for_t do_par_for)
void halide_join_thread(struct halide_thread *)
Join a thread.
halide_error_code_t
The error codes that may be returned by a Halide pipeline.
@ halide_error_code_no_device_interface
Buffer has a non-zero device but no device interface, which violates a Halide invariant.
@ halide_error_code_symbol_not_found
A runtime symbol could not be loaded.
@ halide_error_code_bad_fold
A fold_storage directive was used on a dimension that is not accessed in a monotonically increasing o...
@ halide_error_code_fold_factor_too_small
A fold_storage directive was used with a fold factor that was too small to store all the values of a ...
@ halide_error_code_split_factor_not_positive
A factor used to split a loop was discovered to be zero or negative at runtime.
@ halide_error_code_device_interface_no_device
Buffer has a non-null device_interface but device is 0, which violates a Halide invariant.
@ halide_error_code_param_too_large
A scalar parameter passed in was greater than its minimum declared value.
@ halide_error_code_param_too_small
A scalar parameter passed in was smaller than its minimum declared value.
@ halide_error_code_access_out_of_bounds
A pipeline would access memory outside of the halide_buffer_t passed in.
@ halide_error_code_specialize_fail
A specialize_fail() schedule branch was selected at runtime.
@ halide_error_code_unimplemented
This part of the Halide runtime is unimplemented on this platform.
@ halide_error_code_requirement_failed
User-specified require() expression was not satisfied.
@ halide_error_code_bad_extern_fold
A folded buffer was passed to an extern stage, but the region touched wraps around the fold boundary.
@ halide_error_code_incompatible_device_interface
An operation on a buffer required an allocation on a particular device interface, but a device alloca...
@ halide_error_code_internal_error
There is a bug in the Halide compiler.
@ halide_error_code_buffer_extents_negative
At least one of the buffer's extents are negative.
@ halide_error_code_constraints_make_required_region_smaller
Applying explicit constraints on the size of an input or output buffer shrank the size of that buffer...
@ halide_error_code_copy_to_device_failed
The Halide runtime encountered an error while trying to copy from host to device.
@ halide_error_code_vscale_invalid
"vscale" value of Scalable Vector detected in runtime does not match the vscale value used in compila...
@ halide_error_code_generic_error
An uncategorized error occurred.
@ halide_error_code_device_crop_failed
Cropping/slicing a buffer failed for some other reason.
@ halide_error_code_success
There was no error.
@ halide_error_code_copy_to_host_failed
The Halide runtime encountered an error while trying to copy from device to host.
@ halide_error_code_trace_failed
Failure recording trace packets for one of the halide_target_feature_trace features.
@ halide_error_code_device_sync_failed
The Halide runtime encountered an error while trying to synchronize with a device.
@ halide_error_code_buffer_argument_is_null
A halide_buffer_t pointer passed in was NULL.
@ halide_error_code_bad_dimensions
The dimensions field of a halide_buffer_t does not match the dimensions of that ImageParam.
@ halide_error_code_device_malloc_failed
The Halide runtime encountered an error while trying to allocate memory on device.
@ halide_error_code_host_and_device_dirty
Buffer has both host and device dirty bits set, which violates a Halide invariant.
@ halide_error_code_debug_to_file_failed
debug_to_file failed to open or write to the specified file.
@ halide_error_code_gpu_device_error
Call(s) to a GPU backend API failed.
@ halide_error_code_buffer_is_null
The halide_buffer_t * passed to a halide runtime routine is nullptr and this is not allowed.
@ halide_error_code_device_crop_unsupported
Attempted to make cropped/sliced alias of a buffer with a device field, but the device_interface does...
@ halide_error_code_device_buffer_copy_failed
The Halide runtime encountered an error while trying to copy from one buffer to another.
@ halide_error_code_device_free_failed
The Halide runtime encountered an error while trying to free a device allocation.
@ halide_error_code_buffer_allocation_too_large
A halide_buffer_t was given that spans more than 2GB of memory.
@ halide_error_code_bad_type
The elem_size field of a halide_buffer_t does not match the size in bytes of the type of that ImagePa...
@ halide_error_code_device_run_failed
The Halide runtime encountered an error while trying to launch a GPU kernel.
@ halide_error_code_device_dirty_with_no_device_support
A buffer with the device_dirty flag set was passed to a pipeline compiled with no device backends ena...
@ halide_error_code_cannot_profile_pipeline
Profiling failed for a pipeline invocation.
@ halide_error_code_explicit_bounds_too_small
A Func was given an explicit bound via Func::bound, but this was not large enough to encompass the re...
@ halide_error_code_buffer_extents_too_large
A halide_buffer_t was given with extents that multiply to a number greater than 2^31-1.
@ halide_error_code_device_detach_native_failed
The Halide runtime encountered an error while trying to detach a native device handle.
@ halide_error_code_storage_bound_too_small
An explicit storage bound provided is too small to store all the values produced by the function.
@ halide_error_code_out_of_memory
A call to halide_malloc returned NULL.
@ halide_error_code_device_wrap_native_failed
The Halide runtime encountered an error while trying to wrap a native device handle.
@ halide_error_code_constraint_violated
A constraint on a size or stride of an input or output buffer was not met by the halide_buffer_t pass...
@ halide_error_code_unaligned_host_ptr
The Halide runtime encountered a host pointer that violated the alignment set for it by way of a call...
@ halide_error_code_host_is_null
The host field on an input or output was null, the device field was not zero, and the pipeline tries ...
void * halide_load_library(const char *name)
void halide_memoization_cache_set_size(int64_t size)
Set the soft maximum amount of memory, in bytes, that the LRU cache will use to memoize Func results.
#define HALIDE_ALWAYS_INLINE
void halide_cond_broadcast(struct halide_cond *cond)
int halide_device_free(void *user_context, struct halide_buffer_t *buf)
Free device memory.
void halide_profiler_unlock(struct halide_profiler_state *)
void halide_memoization_cache_cleanup(void)
Free all memory and resources associated with the memoization cache.
int halide_device_sync_global(void *user_context, const struct halide_device_interface_t *device_interface)
Wait for current GPU operations to complete.
int halide_error_param_too_large_u64(void *user_context, const char *param_name, uint64_t val, uint64_t max_val)
int32_t(* halide_trace_t)(void *user_context, const struct halide_trace_event_t *)
int(* halide_do_task_t)(void *, halide_task_t, int, uint8_t *)
If you use the default do_par_for, you can still set a custom handler to perform each individual task...
halide_free_t halide_set_custom_free(halide_free_t user_free)
int halide_default_do_parallel_tasks(void *user_context, int num_tasks, struct halide_parallel_task_t *tasks, void *task_parent)
struct halide_mutex_array * halide_mutex_array_create(uint64_t sz)
int halide_get_gpu_device(void *user_context)
Halide calls this to get the desired halide gpu device setting.
int(* halide_semaphore_init_t)(struct halide_semaphore_t *, int)
halide_do_loop_task_t halide_set_custom_do_loop_task(halide_do_loop_task_t do_task)
int halide_device_detach_native(void *user_context, struct halide_buffer_t *buf)
void * halide_default_get_symbol(const char *name)
int halide_copy_to_device(void *user_context, struct halide_buffer_t *buf, const struct halide_device_interface_t *device_interface)
Copy image data from host memory to device memory.
halide_get_library_symbol_t halide_set_custom_get_library_symbol(halide_get_library_symbol_t user_get_library_symbol)
void halide_error(void *user_context, const char *)
Halide calls this function on runtime errors (for example bounds checking failures).
int halide_device_release_crop(void *user_context, struct halide_buffer_t *buf)
Release any resources associated with a cropped/sliced view of another buffer.
int halide_can_use_target_features(int count, const uint64_t *features)
This function is called internally by Halide in some situations to determine if the current execution...
int halide_error_split_factor_not_positive(void *user_context, const char *func_name, const char *orig, const char *outer, const char *inner, const char *factor_str, int factor)
int halide_error_bad_type(void *user_context, const char *func_name, uint32_t type_given, uint32_t correct_type)
halide_do_task_t halide_set_custom_do_task(halide_do_task_t do_task)
int halide_do_parallel_tasks(void *user_context, int num_tasks, struct halide_parallel_task_t *tasks, void *task_parent)
Enqueue some number of the tasks described above and wait for them to complete.
void *(* halide_malloc_t)(void *, size_t)
int halide_device_wrap_native(void *user_context, struct halide_buffer_t *buf, uint64_t handle, const struct halide_device_interface_t *device_interface)
Wrap or detach a native device handle, setting the device field and device_interface field as appropr...
int halide_get_trace_file(void *user_context)
Halide calls this to retrieve the file descriptor to write binary trace events to.
int halide_shutdown_trace(void)
If tracing is writing to a file.
float halide_float16_bits_to_float(uint16_t)
Read bits representing a half precision floating point number and return the float that represents th...
int halide_error_unaligned_host_ptr(void *user_context, const char *func_name, int alignment)
int halide_profiler_sample(struct halide_profiler_state *s, uint64_t *prev_t)
Collects profiling information.
void halide_register_device_allocation_pool(struct halide_device_allocation_pool *)
Register a callback to be informed when halide_reuse_device_allocations(false) is called,...
#define HALIDE_ATTRIBUTE_ALIGN(x)
int halide_msan_check_buffer_is_initialized(void *user_context, struct halide_buffer_t *buffer, const char *buf_name)
Verify that the data pointed to by the halide_buffer_t is initialized (but not the halide_buffer_t it...
int(* halide_do_parallel_tasks_t)(void *, int, struct halide_parallel_task_t *, void *task_parent)
Provide an entire custom tasking runtime via function pointers.
halide_argument_kind_t
@ halide_argument_kind_output_buffer
@ halide_argument_kind_input_scalar
@ halide_argument_kind_input_buffer
int halide_semaphore_release(struct halide_semaphore_t *, int n)
struct halide_buffer_t halide_buffer_t
The raw representation of an image passed around by generated Halide code.
bool operator<(const ConstantInterval &a, const ConstantInterval &b)
Expr with_lanes(const Expr &x, int lanes)
Rewrite the expression x to have lanes lanes.
auto operator==(const Other &a, const GeneratorParam< T > &b) -> decltype(a==(T) b)
Equality comparison between GeneratorParam<T> and any type that supports operator== with T.
Definition Generator.h:1130
auto operator!=(const Other &a, const GeneratorParam< T > &b) -> decltype(a !=(T) b)
Inequality comparison between between GeneratorParam<T> and any type that supports operator!...
Definition Generator.h:1143
unsigned __INT64_TYPE__ uint64_t
signed __INT64_TYPE__ int64_t
__UINTPTR_TYPE__ uintptr_t
signed __INT32_TYPE__ int32_t
unsigned __INT8_TYPE__ uint8_t
__PTRDIFF_TYPE__ ptrdiff_t
WEAK void(*)(void *, const char *) halide_set_custom_print(void(*print)(void *, const char *))
unsigned __INT16_TYPE__ uint16_t
__SIZE_TYPE__ size_t
unsigned __INT32_TYPE__ uint32_t
signed __INT16_TYPE__ int16_t
signed __INT8_TYPE__ int8_t
WEAK void(*)(void *, const char *) halide_set_error_handler(void(*handler)(void *, const char *))
The raw representation of an image passed around by generated Halide code.
void * padding
Pads the buffer up to a multiple of 8 bytes.
int32_t dimensions
The dimensionality of the buffer.
halide_dimension_t * dim
The shape of the buffer.
uint64_t device
A device-handle for e.g.
uint8_t * host
A pointer to the start of the data in main memory.
struct halide_type_t type
The type of each buffer element.
const struct halide_device_interface_t * device_interface
The interface used to interpret the above handle.
uint64_t flags
flags with various meanings.
Cross platform condition variable.
uintptr_t _private[1]
struct halide_device_allocation_pool * next
int(* release_unused)(void *user_context)
Each GPU API provides a halide_device_interface_t struct pointing to the code that manages device all...
int(* device_slice)(void *user_context, const struct halide_buffer_t *src, int slice_dim, int slice_pos, struct halide_buffer_t *dst)
int(* device_and_host_malloc)(void *user_context, struct halide_buffer_t *buf, const struct halide_device_interface_t *device_interface)
const struct halide_device_interface_impl_t * impl
int(* wrap_native)(void *user_context, struct halide_buffer_t *buf, uint64_t handle, const struct halide_device_interface_t *device_interface)
int(* compute_capability)(void *user_context, int *major, int *minor)
int(* device_release_crop)(void *user_context, struct halide_buffer_t *buf)
int(* device_crop)(void *user_context, const struct halide_buffer_t *src, struct halide_buffer_t *dst)
void(* device_release)(void *user_context, const struct halide_device_interface_t *device_interface)
int(* copy_to_host)(void *user_context, struct halide_buffer_t *buf)
int(* copy_to_device)(void *user_context, struct halide_buffer_t *buf, const struct halide_device_interface_t *device_interface)
int(* device_free)(void *user_context, struct halide_buffer_t *buf)
int(* device_sync)(void *user_context, struct halide_buffer_t *buf)
int(* detach_native)(void *user_context, struct halide_buffer_t *buf)
int(* device_and_host_free)(void *user_context, struct halide_buffer_t *buf)
int(* device_malloc)(void *user_context, struct halide_buffer_t *buf, const struct halide_device_interface_t *device_interface)
int(* buffer_copy)(void *user_context, struct halide_buffer_t *src, const struct halide_device_interface_t *dst_device_interface, struct halide_buffer_t *dst)
Obsolete version of halide_filter_argument_t; only present in code that wrote halide_filter_metadata_...
const struct halide_scalar_value_t * min
const struct halide_scalar_value_t * def
const struct halide_scalar_value_t * max
struct halide_type_t type
halide_filter_argument_t is essentially a plain-C-struct equivalent to Halide::Argument; most user co...
const struct halide_scalar_value_t * scalar_estimate
const struct halide_scalar_value_t * scalar_max
int64_t const *const * buffer_estimates
const struct halide_scalar_value_t * scalar_def
struct halide_type_t type
const struct halide_scalar_value_t * scalar_min
const char * name
The function name of the filter.
int32_t version
version of this metadata; currently always 1.
const struct halide_filter_argument_t * arguments
An array of the filters input and output arguments; this will never be null.
int32_t num_arguments
The number of entries in the arguments field.
const char * target
The Target for which the filter was compiled.
A type traits template to provide a halide_handle_cplusplus_type value from a C++ type.
Definition Type.h:256
struct halide_mutex * array
Cross-platform mutex.
uintptr_t _private[1]
A parallel task to be passed to halide_do_parallel_tasks.
struct halide_semaphore_acquire_t * semaphores
halide_loop_task_t fn
The global state of the profiler.
void(* get_remote_profiler_state)(int *func, int *active_workers)
If this callback is defined, the profiler asserts that there is a single live instance,...
struct halide_thread * sampling_thread
Retrieve remote profiler state.
int sleep_time
The amount of time the profiler thread sleeps between samples in microseconds.
struct halide_profiler_pipeline_stats * pipelines
A linked list of stats gathered for each pipeline.
struct halide_mutex lock
Guards access to the fields below.
struct halide_profiler_instance_state * instances
The running instances of Halide pipelines.
int shutdown
Set to 1 when you want the profiler to wait for all running instances to finish and then stop gracefu...
halide_scalar_value_t is a simple union able to represent all the well-known scalar values in a filte...
union halide_scalar_value_t::@3 u
A struct representing a semaphore and a number of items that must be acquired from it.
struct halide_semaphore_t * semaphore
An opaque struct representing a semaphore.
void * value
If the event type is a load or a store, this points to the value being loaded or stored.
int32_t * coordinates
For loads and stores, an array which contains the location being accessed.
const char * func
The name of the Func or Pipeline that this event refers to.
const char * trace_tag
For halide_trace_tag, this points to a read-only null-terminated string of arbitrary text.
struct halide_type_t type
If the event type is a load or a store, this is the type of the data.
int32_t value_index
If this was a load or store of a Tuple-valued Func, this is which tuple element was accessed.
enum halide_trace_event_code_t event
The type of event.
int32_t dimensions
The length of the coordinates array.
The header of a packet in a binary trace.
uint32_t size
The total size of this packet in bytes.
int32_t id
The id of this packet (for the purpose of parent_id).
enum halide_trace_event_code_t event
struct halide_type_t type
The remaining fields are equivalent to those in halide_trace_event_t.
A runtime tag for a type in the halide type system.
uint8_t bits
The number of bits of precision of a single scalar value of this type.
uint16_t lanes
How many elements in a vector.
uint8_t code
The basic type code: signed integer, unsigned integer, or floating point.