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