halide 19.0.0__cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

halide/include/HalideRuntimeCuda.h

@@ -0,0 +1,89 @@
+#ifndef HALIDE_HALIDERUNTIMECUDA_H
+#define HALIDE_HALIDERUNTIMECUDA_H
+
+// Don't include HalideRuntime.h if the contents of it were already pasted into a generated header above this one
+#ifndef HALIDE_HALIDERUNTIME_H
+
+#include "HalideRuntime.h"
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** \file
+ *  Routines specific to the Halide Cuda runtime.
+ */
+
+#define HALIDE_RUNTIME_CUDA
+
+extern const struct halide_device_interface_t *halide_cuda_device_interface();
+
+/** These are forward declared here to allow clients to override the
+ *  Halide Cuda runtime. Do not call them. */
+// @{
+extern int halide_cuda_initialize_kernels(void *user_context, void **state_ptr,
+                                          const char *src, int size);
+extern int halide_cuda_run(void *user_context,
+                           void *state_ptr,
+                           const char *entry_name,
+                           int blocksX, int blocksY, int blocksZ,
+                           int threadsX, int threadsY, int threadsZ,
+                           int shared_mem_bytes,
+                           size_t arg_sizes[],
+                           void *args[],
+                           int8_t arg_is_buffer[]);
+extern void halide_cuda_finalize_kernels(void *user_context, void *state_ptr);
+// @}
+
+/** Set the underlying cuda device poiner for a buffer. The device
+ * pointer should be allocated using cuMemAlloc or similar and must
+ * have an extent large enough to cover that specified by the
+ * halide_buffer_t extent fields. The dev field of the halide_buffer_t
+ * must be NULL when this routine is called. This call can fail due to
+ * being passed an invalid device pointer. The device and host dirty
+ * bits are left unmodified. */
+extern int halide_cuda_wrap_device_ptr(void *user_context, struct halide_buffer_t *buf, uint64_t device_ptr);
+
+/** Disconnect this halide_buffer_t from the device pointer it was
+ * previously wrapped around. Should only be called for a
+ * halide_buffer_t that halide_cuda_wrap_device_ptr was previously
+ * called on. The device field of the halide_buffer_t will be NULL on
+ * return.
+ */
+extern int halide_cuda_detach_device_ptr(void *user_context, struct halide_buffer_t *buf);
+
+/** Return the underlying device pointer for a halide_buffer_t. This buffer
+ *  must be valid on a Cuda device, or not have any associated device
+ *  memory. If there is no device memory (dev field is NULL), this
+ *  returns 0.
+ */
+extern uintptr_t halide_cuda_get_device_ptr(void *user_context, struct halide_buffer_t *buf);
+
+/** Release any currently-unused device allocations back to the cuda
+ * driver. See halide_reuse_device_allocations. */
+extern int halide_cuda_release_unused_device_allocations(void *user_context);
+
+// These typedefs treat both a CUcontext and a CUstream as a void *,
+// to avoid dependencies on cuda headers.
+typedef int (*halide_cuda_acquire_context_t)(void *,   // user_context
+                                             void **,  // cuda context out parameter
+                                             bool);    // should create a context if none exist
+typedef int (*halide_cuda_release_context_t)(void * /* user_context */);
+typedef int (*halide_cuda_get_stream_t)(void *,    // user_context
+                                        void *,    // context
+                                        void **);  // stream out parameter
+
+/** Set custom methods to acquire and release cuda contexts and streams */
+// @{
+extern halide_cuda_acquire_context_t halide_set_cuda_acquire_context(halide_cuda_acquire_context_t handler);
+extern halide_cuda_release_context_t halide_set_cuda_release_context(halide_cuda_release_context_t handler);
+extern halide_cuda_get_stream_t halide_set_cuda_get_stream(halide_cuda_get_stream_t handler);
+// @}
+
+#ifdef __cplusplus
+}  // End extern "C"
+#endif
+
+#endif  // HALIDE_HALIDERUNTIMECUDA_H

halide/include/HalideRuntimeD3D12Compute.h

@@ -0,0 +1,91 @@
+#ifndef HALIDE_HALIDERUNTIMED3D12COMPUTE_H
+#define HALIDE_HALIDERUNTIMED3D12COMPUTE_H
+
+// Don't include HalideRuntime.h if the contents of it were already pasted into a generated header above this one
+#ifndef HALIDE_HALIDERUNTIME_H
+
+#include "HalideRuntime.h"
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** \file
+ *  Routines specific to the Halide Direct3D 12 Compute runtime.
+ */
+
+extern const struct halide_device_interface_t *halide_d3d12compute_device_interface();
+
+/** These are forward declared here to allow clients to override the
+ *  Halide Direct3D 12 Compute runtime. Do not call them. */
+// @{
+extern int halide_d3d12compute_initialize_kernels(void *user_context, void **state_ptr,
+                                                  const char *src, int size);
+
+extern int halide_d3d12compute_run(void *user_context,
+                                   void *state_ptr,
+                                   const char *entry_name,
+                                   int blocksX, int blocksY, int blocksZ,
+                                   int threadsX, int threadsY, int threadsZ,
+                                   int shared_mem_bytes,
+                                   struct halide_type_t arg_types[], void *args[], int8_t arg_is_buffer[]);
+extern void halide_d3d12compute_finalize_kernels(void *user_context, void *state_ptr);
+// @}
+
+/** Set the underlying ID3D12Resource for a halide_buffer_t. The memory backing
+ * the resource should be managed by the caller (via a default/device heap) and
+ * must be large enough to cover the extent of the halide_buffer_t. The device
+ * field of the halide_buffer_t must be NULL when this routine is called. This
+ * call can fail due to running out of memory or if an invalid D3D12 resource is
+ * passed. The device and host dirty bits are left unmodified. */
+extern int halide_d3d12compute_wrap_buffer(void *user_context, struct halide_buffer_t *buf, uint64_t d3d12_resource);
+
+/** Disconnect a halide_buffer_t from the ID3D12Resource it was previously
+ * wrapped around. Should only be called for a halide_buffer_t that
+ * halide_d3d12compute_wrap_buffer was previously called on. Frees any
+ * storage associated with the binding of the halide_buffer_t and the
+ * buffer, but does not free the ID3D12Resource. The dev field of the
+ * halide_buffer_t will be NULL on return.
+ */
+extern int halide_d3d12compute_detach_buffer(void *user_context, struct halide_buffer_t *buf);
+
+/** Return the underlying ID3D12Resource for a halide_buffer_t. This resource
+ * must be valid on an D3D12 device, unless halide_buffer_t has no associated
+ * resource. If there is no device memory (device field is NULL), returns 0.
+ */
+extern uintptr_t halide_d3d12compute_get_buffer(void *user_context, struct halide_buffer_t *buf);
+
+struct halide_d3d12compute_device;
+struct halide_d3d12compute_command_queue;
+
+/** This prototype is exported as applications will typically need to
+ * replace it to get Halide filters to execute on the same device and
+ * command queue used for other purposes. The halide_d3d12compute_device is an
+ * ID3D12Device and halide_d3d12compute_command_queue is an ID3D12CommandQueue.
+ * No reference counting is done by Halide on these objects. They must remain
+ * valid until all off the following are true:
+ * - A balancing halide_d3d12compute_release_context has occurred for each
+ *     halide_d3d12compute_acquire_context which returned the device/queue
+ * - All Halide filters using the context information have completed
+ * - All halide_buffer_t objects on the device have had
+ *     halide_device_free called or have been detached via
+ *     halide_d3d12compute_detach_buffer.
+ * - halide_device_release has been called on the interface returned from
+ *     halide_d3d12compute_device_interface(). (This releases the programs on the context.)
+ */
+extern int halide_d3d12compute_acquire_context(void *user_context, struct halide_d3d12compute_device **device_ret,
+                                               struct halide_d3d12compute_command_queue **queue_ret, bool create);
+
+/** This call balances each successful halide_d3d12compute_acquire_context call.
+ * If halide_d3d12compute_acquire_context is replaced, this routine must be replaced
+ * as well.
+ */
+extern int halide_d3d12compute_release_context(void *user_context);
+
+#ifdef __cplusplus
+}  // End extern "C"
+#endif
+
+#endif  // HALIDE_HALIDERUNTIMED3D12COMPUTE_H

halide/include/HalideRuntimeHexagonDma.h

@@ -0,0 +1,104 @@
+#ifndef HALIDE_HALIDERUNTIMEHEXAGONDMA_H
+#define HALIDE_HALIDERUNTIMEHEXAGONDMA_H
+
+/** \file
+ *  Routines specific to the Halide Hexagon DMA host-side runtime.
+ */
+
+// Don't include HalideRuntime.h if the contents of it were already pasted into a generated header above this one
+#ifndef HALIDE_HALIDERUNTIME_H
+
+#include "HalideRuntime.h"
+
+#endif
+
+// Don't include HalideRuntimeHexagonHost.h if the contents of it were already pasted into a generated header above this one
+#ifndef HALIDE_HALIDERUNTIMEHEXAGONHOST_H
+
+#include "HalideRuntimeHexagonHost.h"
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \defgroup rt_hexagon_dma Halide Hexagon DMA runtime
+ * @{
+ */
+
+/**
+ * Image Formats to prepare the application for DMA Transfer
+ */
+typedef enum {
+    halide_hexagon_fmt_RawData,
+    halide_hexagon_fmt_NV12,
+    halide_hexagon_fmt_NV12_Y,
+    halide_hexagon_fmt_NV12_UV,
+    halide_hexagon_fmt_P010,
+    halide_hexagon_fmt_P010_Y,
+    halide_hexagon_fmt_P010_UV,
+    halide_hexagon_fmt_TP10,
+    halide_hexagon_fmt_TP10_Y,
+    halide_hexagon_fmt_TP10_UV,
+    halide_hexagon_fmt_NV124R,
+    halide_hexagon_fmt_NV124R_Y,
+    halide_hexagon_fmt_NV124R_UV
+} halide_hexagon_image_fmt_t;
+
+extern const struct halide_device_interface_t *halide_hexagon_dma_device_interface();
+
+/** This API is used to set up the DMA device interface to be used for DMA transfer. This also internally
+ * creates the DMA device handle and populates all the Buffer related parameters (width, height, stride)
+ * to be used for DMA configuration.
+ */
+extern int halide_hexagon_dma_device_wrap_native(void *user_context, struct halide_buffer_t *buf,
+                                                 uint64_t mem);
+
+/** Detach the Input/Output Buffer from DMA device handle and deallocate the DMA device handle buffer allocation
+ * This API also frees up the DMA device and makes it available for another usage.
+ */
+extern int halide_hexagon_dma_device_detach_native(void *user_context, struct halide_buffer_t *buf);
+
+/** This API will allocate a DMA Engine needed for DMA read/write. This is the first step Before
+ * a buffer can be used in a copy operation (i.e. a DMA read/write operation).
+ */
+extern int halide_hexagon_dma_allocate_engine(void *user_context, void **dma_engine);
+
+/** This API free up the allocated DMA engine. This need to be called after a user program ends
+ * all the DMA Operations and make it available for subsequent DMA transfers */
+extern int halide_hexagon_dma_deallocate_engine(void *user_context, void *dma_engine);
+
+/** This API Prepares a buffer for DMA Read Operation. This will setup the DMA format, direction (read).
+ * Will also make necessary adjustments to the DMA frame parameters based on Image format provided.
+ */
+extern int halide_hexagon_dma_prepare_for_copy_to_host(void *user_context, struct halide_buffer_t *buf,
+                                                       void *dma_engine, bool is_ubwc, halide_hexagon_image_fmt_t fmt);
+
+/** This API Prepares a buffer for DMA Write Operation. This will setup the DMA format, direction (write).
+ * Will also make necessary adjustments to the DMA frame parameters based on Image format provided.
+ */
+extern int halide_hexagon_dma_prepare_for_copy_to_device(void *user_context, struct halide_buffer_t *buf,
+                                                         void *dma_engine, bool is_ubwc,
+                                                         halide_hexagon_image_fmt_t fmt);
+
+/** This API is used to frees up the DMA Resources associated with the buffer.
+ * TODO: Currently this API is a dummy as all the necessary freeing is done in an another API.
+ * This will be used in future.
+ */
+extern int halide_hexagon_dma_unprepare(void *user_context, struct halide_buffer_t *buf);
+
+/** This API is used to setup the hexagon Operation modes. We will setup the necessary Operating frequency
+ * based on the power mode chosen. Check the structure halide_hexagon_power_mode_t defined in Halide HalideRuntimeHexagonHost.h
+ * for the supported power modes.
+ */
+extern int halide_hexagon_dma_power_mode_voting(void *user_context, halide_hexagon_power_mode_t cornercase);
+
+///@}
+
+#ifdef __cplusplus
+}  // End extern "C"
+#endif
+
+#endif  // HALIDE_HALIDERUNTIMEHEXAGONDMA_H

halide/include/HalideRuntimeHexagonHost.h

@@ -0,0 +1,157 @@
+#ifndef HALIDE_HALIDERUNTIMEHEXAGONHOST_H
+#define HALIDE_HALIDERUNTIMEHEXAGONHOST_H
+
+// Don't include HalideRuntime.h if the contents of it were already pasted into a generated header above this one
+#ifndef HALIDE_HALIDERUNTIME_H
+
+#include "HalideRuntime.h"
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** \file
+ *  Routines specific to the Halide Hexagon host-side runtime.
+ */
+
+#define HALIDE_RUNTIME_HEXAGON
+
+typedef int halide_hexagon_handle_t;
+
+extern const struct halide_device_interface_t *halide_hexagon_device_interface();
+
+/** Check if the Hexagon runtime (libhalide_hexagon_host.so) is
+ * available. If it is not, pipelines using Hexagon will fail. */
+extern bool halide_is_hexagon_available(void *user_context);
+
+/** The device handle for Hexagon is simply a pointer and size, stored
+ * in the dev field of the halide_buffer_t. If the buffer is allocated in a
+ * particular way (ion_alloc), the buffer will be shared with Hexagon
+ * (not copied). The device field of the halide_buffer_t must be NULL when this
+ * routine is called. This call can fail due to running out of memory
+ * or being passed an invalid device handle. The device and host
+ * dirty bits are left unmodified. */
+extern int halide_hexagon_wrap_device_handle(void *user_context, struct halide_buffer_t *buf,
+                                             void *ptr, uint64_t size);
+
+/** Disconnect this halide_buffer_t from the device handle it was
+ * previously wrapped around. Should only be called for a
+ * halide_buffer_t that halide_hexagon_wrap_device_handle was
+ * previously called on. Frees any storage associated with the binding
+ * of the halide_buffer_t and the device handle, but does not free the
+ * device handle. The device field of the halide_buffer_t will be NULL
+ * on return. */
+extern int halide_hexagon_detach_device_handle(void *user_context, struct halide_buffer_t *buf);
+
+/** Return the underlying device handle for a halide_buffer_t. If there is
+ * no device memory (dev field is NULL), this returns 0. */
+extern void *halide_hexagon_get_device_handle(void *user_context, struct halide_buffer_t *buf);
+extern uint64_t halide_hexagon_get_device_size(void *user_context, struct halide_buffer_t *buf);
+
+/** Return a pointer to the module_state. */
+extern void *halide_hexagon_get_module_state(void *user_context, void **host);
+
+/** Power HVX on and off. Calling a Halide pipeline will do this
+ * automatically on each pipeline invocation; however, it costs a
+ * small but possibly significant amount of time for short running
+ * pipelines. To avoid this cost, HVX can be powered on prior to
+ * running several pipelines, and powered off afterwards. If HVX is
+ * powered on, subsequent calls to power HVX on will be cheap. */
+// @{
+extern int halide_hexagon_power_hvx_on(void *user_context);
+extern int halide_hexagon_power_hvx_off(void *user_context);
+extern void halide_hexagon_power_hvx_off_as_destructor(void *user_context, void * /* obj */);
+// @}
+
+/** Power modes for Hexagon. */
+typedef enum halide_hexagon_power_mode_t {
+    halide_hexagon_power_low = 0,
+    halide_hexagon_power_nominal = 1,
+    halide_hexagon_power_turbo = 2,
+    halide_hexagon_power_default = 3,  /// Resets power to its default state.
+    halide_hexagon_power_low_plus = 4,
+    halide_hexagon_power_low_2 = 5,
+    halide_hexagon_power_nominal_plus = 6,
+
+    // These are deprecated.
+    halide_hvx_power_low = halide_hexagon_power_low,
+    halide_hvx_power_nominal = halide_hexagon_power_nominal,
+    halide_hvx_power_turbo = halide_hexagon_power_turbo,
+    halide_hvx_power_default = halide_hexagon_power_default,
+} halide_hexagon_power_mode_t;
+
+/** More detailed power settings to control Hexagon.
+ * @param set_mips - Set to TRUE to request MIPS
+ * @param mipsPerThread - mips requested per thread, to establish a minimal clock frequency per HW thread
+ * @param mipsTotal - Total mips requested, to establish total number of MIPS required across all HW threads
+ * @param set_bus_bw - Set to TRUE to request bus_bw
+ * @param bwMeagabytesPerSec - Max bus BW requested (megabytes per second)
+ * @param busbwUsagePercentage - Percentage of time during which bwBytesPerSec BW is required from the bus (0..100)
+ * @param set_latency - Set to TRUE to set latency
+ * @param latency - maximum hardware wakeup latency in microseconds.  The
+ *                  higher the value the deeper state of sleep
+ *                  that can be entered but the longer it may
+ *                  take to awaken. Only values > 0 are supported (1 microsecond is the smallest valid value)
+ */
+typedef struct {
+    bool set_mips;
+    unsigned int mipsPerThread;
+    unsigned int mipsTotal;
+    bool set_bus_bw;
+    unsigned int bwMegabytesPerSec;
+    unsigned short busbwUsagePercentage;
+    bool set_latency;
+    int latency;
+} halide_hexagon_power_t;
+
+// This is deprecated.
+typedef halide_hexagon_power_t halide_hvx_power_perf_t;
+
+/** Set a performance target for Hexagon. Hexagon applications can
+ * vote for the performance levels they want, which may or may not be
+ * respected by Hexagon. Applications should be careful not to leave
+ * Hexagon in a high power state for too long. These functions can
+ * significantly increase standby power consumption. Use
+ * halide_hexagon_power_default to reset performance to the default
+ * power state. */
+// @{
+extern int halide_hexagon_set_performance_mode(void *user_context, halide_hexagon_power_mode_t mode);
+extern int halide_hexagon_set_performance(void *user_context, halide_hexagon_power_t *perf);
+// @}
+
+/** Set the default priority for Halide Hexagon user threads:
+ *   - Valid priority values range from 1 to 255
+ *   - Smaller number for higher priority
+ *   - The highest priority for a user thread is 1
+ *   - Priority 0 is reserved for OS usage
+ * If this routine is not called, the priority will default to 100.
+ * This is intended to be called before dispatching any pipeline. */
+// @{
+extern int halide_hexagon_set_thread_priority(void *user_context, int priority);
+// @}
+
+/** These are forward declared here to allow clients to override the
+ *  Halide Hexagon runtime. Do not call them. */
+// @{
+extern int halide_hexagon_initialize_kernels(void *user_context,
+                                             void **module_ptr,
+                                             const uint8_t *code, uint64_t code_size,
+                                             const uint8_t *runtime, uint64_t runtime_size);
+extern int halide_hexagon_run(void *user_context,
+                              void *module_ptr,
+                              const char *name,
+                              halide_hexagon_handle_t *function,
+                              uint64_t arg_sizes[],
+                              void *args[],
+                              int arg_flags[]);
+extern void halide_hexagon_finalize_kernels(void *user_context, void *state_ptr);
+extern int halide_hexagon_device_release(void *user_context);
+// @}
+
+#ifdef __cplusplus
+}  // End extern "C"
+#endif
+
+#endif  // HALIDE_HALIDERUNTIMEHEXAGONHOST_H

halide/include/HalideRuntimeMetal.h

@@ -0,0 +1,112 @@
+#ifndef HALIDE_HALIDERUNTIMEMETAL_H
+#define HALIDE_HALIDERUNTIMEMETAL_H
+
+// Don't include HalideRuntime.h if the contents of it were already pasted into a generated header above this one
+#ifndef HALIDE_HALIDERUNTIME_H
+
+#include "HalideRuntime.h"
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** \file
+ *  Routines specific to the Halide Metal runtime.
+ */
+
+#define HALIDE_RUNTIME_METAL
+
+extern const struct halide_device_interface_t *halide_metal_device_interface();
+
+/** These are forward declared here to allow clients to override the
+ *  Halide Metal runtime. Do not call them. */
+// @{
+extern int halide_metal_initialize_kernels(void *user_context, void **state_ptr,
+                                           const char *src, int size);
+void halide_metal_finalize_kernels(void *user_context, void *state_ptr);
+
+extern int halide_metal_run(void *user_context,
+                            void *state_ptr,
+                            const char *entry_name,
+                            int blocksX, int blocksY, int blocksZ,
+                            int threadsX, int threadsY, int threadsZ,
+                            int shared_mem_bytes,
+                            struct halide_type_t arg_types[],
+                            void *args[],
+                            int8_t arg_is_buffer[]);
+// @}
+
+/** Set the underlying MTLBuffer for a halide_buffer_t. This memory should be
+ * allocated using newBufferWithLength:options or similar and must
+ * have an extent large enough to cover that specified by the halide_buffer_t
+ * extent fields. The dev field of the halide_buffer_t must be NULL when this
+ * routine is called. This call can fail due to running out of memory
+ * or being passed an invalid buffer. The device and host dirty bits
+ * are left unmodified. */
+extern int halide_metal_wrap_buffer(void *user_context, struct halide_buffer_t *buf, uint64_t buffer);
+
+/** Disconnect a halide_buffer_t from the memory it was previously
+ * wrapped around. Should only be called for a halide_buffer_t that
+ * halide_metal_wrap_buffer was previously called on. Frees any
+ * storage associated with the binding of the halide_buffer_t and the
+ * buffer, but does not free the MTLBuffer. The dev field of the
+ * halide_buffer_t will be NULL on return.
+ */
+extern int halide_metal_detach_buffer(void *user_context, struct halide_buffer_t *buf);
+
+/** Return the underlying MTLBuffer for a halide_buffer_t. This buffer must be
+ * valid on an Metal device, or not have any associated device
+ * memory. If there is no device memory (dev field is NULL), this
+ * returns 0.
+ */
+extern uintptr_t halide_metal_get_buffer(void *user_context, struct halide_buffer_t *buf);
+
+/** Returns the offset associated with the Metal Buffer allocation via device_crop or device_slice. */
+extern uint64_t halide_metal_get_crop_offset(void *user_context, struct halide_buffer_t *buf);
+
+struct halide_metal_device;
+struct halide_metal_command_queue;
+struct halide_metal_command_buffer;
+
+/** This prototype is exported as applications will typically need to
+ * replace it to get Halide filters to execute on the same device and
+ * command queue used for other purposes. The halide_metal_device is an
+ * id \<MTLDevice\> and halide_metal_command_queue is an id \<MTLCommandQueue\>.
+ * No reference counting is done by Halide on these objects. They must remain
+ * valid until all off the following are true:
+ * - A balancing halide_metal_release_context has occurred for each
+ *     halide_metal_acquire_context which returned the device/queue
+ * - All Halide filters using the context information have completed
+ * - All halide_buffer_t objects on the device have had
+ *     halide_device_free called or have been detached via
+ *     halide_metal_detach_buffer.
+ * - halide_device_release has been called on the interface returned from
+ *     halide_metal_device_interface(). (This releases the programs on the context.)
+ */
+extern int halide_metal_acquire_context(void *user_context, struct halide_metal_device **device_ret,
+                                        struct halide_metal_command_queue **queue_ret, bool create);
+
+/** This call balances each successful halide_metal_acquire_context call.
+ * If halide_metal_acquire_context is replaced, this routine must be replaced
+ * as well.
+ */
+extern int halide_metal_release_context(void *user_context);
+
+/** This function is called as part of the callback when a Metal command buffer completes.
+ * The return value, if not halide_error_code_success, will be stashed in Metal runtime and returned
+ * to the next call into the runtime, and the error string will be saved as well.
+ * The error string will be freed by the caller. The return value must be a valid Halide error code.
+ * This is called from the Metal driver, and thus:
+ * - Any user_context must be preserved between the call to halide_metal_run and the corresponding callback
+ * - The function must be thread-safe
+ */
+extern int halide_metal_command_buffer_completion_handler(void *user_context, struct halide_metal_command_buffer *buffer,
+                                                          char **returned_error_string);
+
+#ifdef __cplusplus
+}  // End extern "C"
+#endif
+
+#endif  // HALIDE_HALIDERUNTIMEMETAL_H

halide/include/HalideRuntimeOpenCL.h

@@ -0,0 +1,119 @@
+#ifndef HALIDE_HALIDERUNTIMEOPENCL_H
+#define HALIDE_HALIDERUNTIMEOPENCL_H
+
+// Don't include HalideRuntime.h if the contents of it were already pasted into a generated header above this one
+#ifndef HALIDE_HALIDERUNTIME_H
+
+#include "HalideRuntime.h"
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** \file
+ *  Routines specific to the Halide OpenCL runtime.
+ */
+
+#define HALIDE_RUNTIME_OPENCL
+
+extern const struct halide_device_interface_t *halide_opencl_device_interface();
+extern const struct halide_device_interface_t *halide_opencl_image_device_interface();
+
+/** These are forward declared here to allow clients to override the
+ *  Halide OpenCL runtime. Do not call them. */
+// @{
+extern int halide_opencl_initialize_kernels(void *user_context, void **state_ptr,
+                                            const char *src, int size);
+extern int halide_opencl_run(void *user_context,
+                             void *state_ptr,
+                             const char *entry_name,
+                             int blocksX, int blocksY, int blocksZ,
+                             int threadsX, int threadsY, int threadsZ,
+                             int shared_mem_bytes,
+                             size_t arg_sizes[],
+                             void *args[],
+                             int8_t arg_is_buffer[]);
+extern void halide_opencl_finalize_kernels(void *user_context, void *state_ptr);
+// @}
+
+/** Set the platform name for OpenCL to use (e.g. "Intel" or
+ * "NVIDIA"). The argument is copied internally. The opencl runtime
+ * will select a platform that includes this as a substring. If never
+ * called, Halide uses the environment variable HL_OCL_PLATFORM_NAME,
+ * or defaults to the first available platform. */
+extern void halide_opencl_set_platform_name(const char *n);
+
+/** Halide calls this to get the desired OpenCL platform
+ * name. Implement this yourself to use a different platform per
+ * user_context. The default implementation returns the value set by
+ * halide_set_ocl_platform_name, or the value of the environment
+ * variable HL_OCL_PLATFORM_NAME. The output is valid until the next
+ * call to halide_set_ocl_platform_name. */
+extern const char *halide_opencl_get_platform_name(void *user_context);
+
+/** Set the device type for OpenCL to use. The argument is copied
+ * internally. It must be "cpu", "gpu", or "acc". If never called,
+ * Halide uses the environment variable HL_OCL_DEVICE_TYPE. */
+extern void halide_opencl_set_device_type(const char *n);
+
+/** Halide calls this to gets the desired OpenCL device
+ * type. Implement this yourself to use a different device type per
+ * user_context. The default implementation returns the value set by
+ * halide_set_ocl_device_type, or the environment variable
+ * HL_OCL_DEVICE_TYPE. The result is valid until the next call to
+ * halide_set_ocl_device_type. */
+extern const char *halide_opencl_get_device_type(void *user_context);
+
+/** Set the additional build options for OpenCL to use. The argument
+ * is copied internally. If never called,
+ * Halide uses the environment variable HL_OCL_BUILD_OPTIONS. */
+extern void halide_opencl_set_build_options(const char *n);
+
+/** Halide calls this to gets the additional build options for OpenCL to
+ * use. Implement this yourself to use a different build options per
+ * user_context. The default implementation returns the value set by
+ * halide_opencl_set_build_options, or the environment variable
+ * HL_OCL_BUILD_OPTIONS. The result is valid until the next call to
+ * halide_opencl_set_build_options. */
+extern const char *halide_opencl_get_build_options(void *user_context);
+
+/** Set the underlying cl_mem for a halide_buffer_t. This memory should be
+ * allocated using clCreateBuffer or similar and must have an extent
+ * large enough to cover that specified by the halide_buffer_t extent
+ * fields. The dev field of the halide_buffer_t must be NULL when this
+ * routine is called. This call can fail due to running out of memory
+ * or being passed an invalid device pointer. The device and host
+ * dirty bits are left unmodified. */
+extern int halide_opencl_wrap_cl_mem(void *user_context, struct halide_buffer_t *buf, uint64_t device_ptr);
+
+/** Same as halide_opencl_wrap_cl_mem but wraps a cl_mem created with
+ * clCreateImage
+ */
+extern int halide_opencl_image_wrap_cl_mem(void *user_context, struct halide_buffer_t *buf, uint64_t device_ptr);
+
+/** Disconnect a halide_buffer_t from the memory it was previously
+ * wrapped around. Should only be called for a halide_buffer_t that
+ * halide_opencl_wrap_device_ptr was previously called on. Frees any
+ * storage associated with the binding of the halide_buffer_t and the
+ * device pointer, but does not free the cl_mem. The dev field of the
+ * halide_buffer_t will be NULL on return.
+ */
+extern int halide_opencl_detach_cl_mem(void *user_context, struct halide_buffer_t *buf);
+
+/** Return the underlying cl_mem for a halide_buffer_t. This buffer must be
+ *  valid on an OpenCL device, or not have any associated device
+ *  memory. If there is no device memory (dev field is NULL), this
+ *  returns 0.
+ */
+extern uintptr_t halide_opencl_get_cl_mem(void *user_context, struct halide_buffer_t *buf);
+
+/** Returns the offset associated with the OpenCL memory allocation via device_crop or device_slice. */
+extern uint64_t halide_opencl_get_crop_offset(void *user_context, halide_buffer_t *buf);
+
+#ifdef __cplusplus
+}  // End extern "C"
+#endif
+
+#endif  // HALIDE_HALIDERUNTIMEOPENCL_H