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