Brunobkr/llama.cpp_AlgMor24_github

1#pragma once2 3#include "ggml.h"4#include "ggml-alloc.h"5 6#ifdef GGML_BACKEND_SHARED7#    if defined(_WIN32) && !defined(__MINGW32__)8#        ifdef GGML_BACKEND_BUILD9#            define GGML_BACKEND_API __declspec(dllexport) extern10#        else11#            define GGML_BACKEND_API __declspec(dllimport) extern12#        endif13#    else14#        define GGML_BACKEND_API __attribute__ ((visibility ("default"))) extern15#    endif16#else17#    define GGML_BACKEND_API extern18#endif19 20#ifdef  __cplusplus21extern "C" {22#endif23 24    typedef struct ggml_backend_buffer_type * ggml_backend_buffer_type_t;25    typedef struct ggml_backend_buffer * ggml_backend_buffer_t;26    typedef struct ggml_backend_event * ggml_backend_event_t;27    typedef struct ggml_backend * ggml_backend_t;28    typedef void * ggml_backend_graph_plan_t;29    typedef struct ggml_backend_reg * ggml_backend_reg_t;30    typedef struct ggml_backend_device * ggml_backend_dev_t;31 32 33    //34    // Backend buffer type35    //36 37    GGML_API const char *          ggml_backend_buft_name          (ggml_backend_buffer_type_t buft);38    GGML_API ggml_backend_buffer_t ggml_backend_buft_alloc_buffer  (ggml_backend_buffer_type_t buft, size_t size);39    GGML_API size_t                ggml_backend_buft_get_alignment (ggml_backend_buffer_type_t buft);40    GGML_API size_t                ggml_backend_buft_get_max_size  (ggml_backend_buffer_type_t buft);41    GGML_API size_t                ggml_backend_buft_get_alloc_size(ggml_backend_buffer_type_t buft, const struct ggml_tensor * tensor);42    GGML_API bool                  ggml_backend_buft_is_host       (ggml_backend_buffer_type_t buft);43    GGML_API ggml_backend_dev_t    ggml_backend_buft_get_device    (ggml_backend_buffer_type_t buft);44 45    //46    // Backend buffer47    //48 49    enum ggml_backend_buffer_usage {50        GGML_BACKEND_BUFFER_USAGE_ANY = 0,51        GGML_BACKEND_BUFFER_USAGE_WEIGHTS = 1,52        GGML_BACKEND_BUFFER_USAGE_COMPUTE = 2,53    };54 55    GGML_API const char *                   ggml_backend_buffer_name          (ggml_backend_buffer_t buffer);56    GGML_API void                           ggml_backend_buffer_free          (ggml_backend_buffer_t buffer);57    GGML_API void *                         ggml_backend_buffer_get_base      (ggml_backend_buffer_t buffer);58    GGML_API size_t                         ggml_backend_buffer_get_size      (ggml_backend_buffer_t buffer);59    GGML_API enum ggml_status               ggml_backend_buffer_init_tensor   (ggml_backend_buffer_t buffer, struct ggml_tensor * tensor);60    GGML_API size_t                         ggml_backend_buffer_get_alignment (ggml_backend_buffer_t buffer);61    GGML_API size_t                         ggml_backend_buffer_get_max_size  (ggml_backend_buffer_t buffer);62    GGML_API size_t                         ggml_backend_buffer_get_alloc_size(ggml_backend_buffer_t buffer, const struct ggml_tensor * tensor);63    GGML_API void                           ggml_backend_buffer_clear         (ggml_backend_buffer_t buffer, uint8_t value);64    GGML_API bool                           ggml_backend_buffer_is_host       (ggml_backend_buffer_t buffer);65    GGML_API void                           ggml_backend_buffer_set_usage     (ggml_backend_buffer_t buffer, enum ggml_backend_buffer_usage usage);66    GGML_API enum ggml_backend_buffer_usage ggml_backend_buffer_get_usage     (ggml_backend_buffer_t buffer);67    GGML_API ggml_backend_buffer_type_t     ggml_backend_buffer_get_type      (ggml_backend_buffer_t buffer);68    GGML_API void                           ggml_backend_buffer_reset         (ggml_backend_buffer_t buffer);69 70    // tensor copy between different backends71    GGML_API void ggml_backend_tensor_copy(const struct ggml_tensor * src, struct ggml_tensor * dst);72 73    //74    // Backend (stream)75    //76 77    GGML_API ggml_guid_t  ggml_backend_guid(ggml_backend_t backend);78    GGML_API const char * ggml_backend_name(ggml_backend_t backend);79    GGML_API void         ggml_backend_free(ggml_backend_t backend);80 81    GGML_API ggml_backend_buffer_type_t ggml_backend_get_default_buffer_type(ggml_backend_t backend);82    GGML_API ggml_backend_buffer_t      ggml_backend_alloc_buffer(ggml_backend_t backend, size_t size);83    GGML_API size_t                     ggml_backend_get_alignment(ggml_backend_t backend);84    GGML_API size_t                     ggml_backend_get_max_size(ggml_backend_t backend);85 86    GGML_API void ggml_backend_tensor_set_async   (ggml_backend_t backend,       struct ggml_tensor * tensor, const void * data, size_t offset, size_t size);87    GGML_API void ggml_backend_tensor_get_async   (ggml_backend_t backend, const struct ggml_tensor * tensor,       void * data, size_t offset, size_t size);88    GGML_API void ggml_backend_tensor_set_2d_async(ggml_backend_t backend,       struct ggml_tensor * tensor, const void * data, size_t offset, size_t size, size_t n_copies, size_t stride_tensor, size_t stride_data);89    GGML_API void ggml_backend_tensor_get_2d_async(ggml_backend_t backend, const struct ggml_tensor * tensor,       void * data, size_t offset, size_t size, size_t n_copies, size_t stride_tensor, size_t stride_data);90 91    // "offset" refers to the offset in tensor->data for setting/getting data92    GGML_API void ggml_backend_tensor_set   (      struct ggml_tensor * tensor, const void * data, size_t offset, size_t size);93    GGML_API void ggml_backend_tensor_get   (const struct ggml_tensor * tensor,       void * data, size_t offset, size_t size);94    GGML_API void ggml_backend_tensor_set_2d(      struct ggml_tensor * tensor, const void * data, size_t offset, size_t size, size_t n_copies, size_t stride_tensor, size_t stride_data);95    GGML_API void ggml_backend_tensor_get_2d(const struct ggml_tensor * tensor,       void * data, size_t offset, size_t size, size_t n_copies, size_t stride_tensor, size_t stride_data);96    GGML_API void ggml_backend_tensor_memset(      struct ggml_tensor * tensor,     uint8_t value, size_t offset, size_t size);97 98    GGML_API void ggml_backend_synchronize(ggml_backend_t backend);99 100    GGML_API ggml_backend_graph_plan_t ggml_backend_graph_plan_create(ggml_backend_t backend, struct ggml_cgraph * cgraph);101    GGML_API void                      ggml_backend_graph_plan_free  (ggml_backend_t backend, ggml_backend_graph_plan_t plan);102 103    GGML_API enum ggml_status ggml_backend_graph_plan_compute (ggml_backend_t backend, ggml_backend_graph_plan_t plan);104    GGML_API enum ggml_status ggml_backend_graph_compute      (ggml_backend_t backend, struct ggml_cgraph * cgraph);105    GGML_API enum ggml_status ggml_backend_graph_compute_async(ggml_backend_t backend, struct ggml_cgraph * cgraph);106 107    // NOTE: will be removed, use device version instead108    GGML_API bool ggml_backend_supports_op(ggml_backend_t backend, const struct ggml_tensor * op);109    GGML_API bool ggml_backend_supports_buft(ggml_backend_t backend, ggml_backend_buffer_type_t buft);110    GGML_API bool ggml_backend_offload_op(ggml_backend_t backend, const struct ggml_tensor * op);111 112    // asynchronous copy113    // the copy is performed after all the currently queued operations in backend_src114    // backend_dst will wait for the copy to complete before performing other operations115    // automatic fallback to sync copy if async is not supported116    GGML_API void ggml_backend_tensor_copy_async(ggml_backend_t backend_src, ggml_backend_t backend_dst, const struct ggml_tensor * src, struct ggml_tensor * dst);117 118    GGML_API ggml_backend_dev_t ggml_backend_get_device(ggml_backend_t backend);119 120    //121    // Events122    //123 124    GGML_API ggml_backend_event_t ggml_backend_event_new(ggml_backend_dev_t device);125    GGML_API void                 ggml_backend_event_free(ggml_backend_event_t event);126    GGML_API void                 ggml_backend_event_record(ggml_backend_event_t event, ggml_backend_t backend);127    GGML_API void                 ggml_backend_event_synchronize(ggml_backend_event_t event);128    GGML_API void                 ggml_backend_event_wait(ggml_backend_t backend, ggml_backend_event_t event);129 130    //131    // Backend device132    //133 134    enum ggml_backend_dev_type {135        // CPU device using system memory136        GGML_BACKEND_DEVICE_TYPE_CPU,137        // GPU device using dedicated memory138        GGML_BACKEND_DEVICE_TYPE_GPU,139        // integrated GPU device using host memory140        GGML_BACKEND_DEVICE_TYPE_IGPU,141        // accelerator devices intended to be used together with the CPU backend (e.g. BLAS or AMX)142        GGML_BACKEND_DEVICE_TYPE_ACCEL,143        // "meta" device wrapping multiple other devices for tensor parallelism144        GGML_BACKEND_DEVICE_TYPE_META,145    };146 147    // functionality supported by the device148    struct ggml_backend_dev_caps {149        // asynchronous operations150        bool async;151        // pinned host buffer152        bool host_buffer;153        // creating buffers from host ptr154        bool buffer_from_host_ptr;155        // event synchronization156        bool events;157    };158 159    // all the device properties160    struct ggml_backend_dev_props {161        // device name162        const char * name;163        // device description164        const char * description;165        // device free memory in bytes166        size_t memory_free;167        // device total memory in bytes168        size_t memory_total;169        // device type170        enum ggml_backend_dev_type type;171        // device id172        //   for PCI devices, this should be the lower-case PCI bus id formatted as "domain:bus:device.function" (e.g. "0000:c1:00.0")173        //   if the id is unknown, this should be NULL174        const char * device_id;175        // device capabilities176        struct ggml_backend_dev_caps caps;177    };178 179    GGML_API const char *                  ggml_backend_dev_name(ggml_backend_dev_t device);180    GGML_API const char *                  ggml_backend_dev_description(ggml_backend_dev_t device);181    GGML_API void                          ggml_backend_dev_memory(ggml_backend_dev_t device, size_t * free, size_t * total);182    GGML_API enum ggml_backend_dev_type    ggml_backend_dev_type(ggml_backend_dev_t device);183    GGML_API void                          ggml_backend_dev_get_props(ggml_backend_dev_t device, struct ggml_backend_dev_props * props);184    GGML_API ggml_backend_reg_t            ggml_backend_dev_backend_reg(ggml_backend_dev_t device);185    GGML_API ggml_backend_t                ggml_backend_dev_init(ggml_backend_dev_t device, const char * params);186    GGML_API ggml_backend_buffer_type_t    ggml_backend_dev_buffer_type(ggml_backend_dev_t device);187    GGML_API ggml_backend_buffer_type_t    ggml_backend_dev_host_buffer_type(ggml_backend_dev_t device);188    GGML_API ggml_backend_buffer_t         ggml_backend_dev_buffer_from_host_ptr(ggml_backend_dev_t device, void * ptr, size_t size, size_t max_tensor_size);189 190    GGML_API bool                          ggml_backend_dev_supports_op(ggml_backend_dev_t device, const struct ggml_tensor * op);191    GGML_API bool                          ggml_backend_dev_supports_buft(ggml_backend_dev_t device, ggml_backend_buffer_type_t buft);192    GGML_API bool                          ggml_backend_dev_offload_op(ggml_backend_dev_t device, const struct ggml_tensor * op);193 194    //195    // Backend (reg)196    //197 198    GGML_API const char *       ggml_backend_reg_name(ggml_backend_reg_t reg);199    GGML_API size_t             ggml_backend_reg_dev_count(ggml_backend_reg_t reg);200    GGML_API ggml_backend_dev_t ggml_backend_reg_dev_get(ggml_backend_reg_t reg, size_t index);201    GGML_API void *             ggml_backend_reg_get_proc_address(ggml_backend_reg_t reg, const char * name);202 203    // Common functions that may be obtained using ggml_backend_reg_get_proc_address204 205    // Context management and operations for faster communication between backends, used for tensor parallelism (meta backend)206    typedef void * (*ggml_backend_comm_init_t)(ggml_backend_t * backends, size_t n_backends);207    typedef void   (*ggml_backend_comm_free_t)(void * comm_ctx);208    typedef bool   (*ggml_backend_comm_allreduce_tensor_t)(void * comm_ctx, struct ggml_tensor ** tensors);209 210    // Split buffer type for tensor parallelism (old)211    typedef ggml_backend_buffer_type_t   (*ggml_backend_split_buffer_type_t)(int main_device, const float * tensor_split);212    // Set the number of threads for the backend213    typedef void                         (*ggml_backend_set_n_threads_t)(ggml_backend_t backend, int n_threads);214    // Get additional buffer types provided by the device (returns a NULL-terminated array)215    typedef ggml_backend_buffer_type_t * (*ggml_backend_dev_get_extra_bufts_t)(ggml_backend_dev_t device);216    // Set the abort callback for the backend217    typedef void                         (*ggml_backend_set_abort_callback_t)(ggml_backend_t backend, ggml_abort_callback abort_callback, void * abort_callback_data);218    // Get a list of feature flags supported by the backend (returns a NULL-terminated array)219    struct ggml_backend_feature {220        const char * name;221        const char * value;222    };223    typedef struct ggml_backend_feature * (*ggml_backend_get_features_t)(ggml_backend_reg_t reg);224 225    //226    // Backend registry227    //228 229    GGML_API void ggml_backend_register(ggml_backend_reg_t reg);230 231    GGML_API void ggml_backend_device_register(ggml_backend_dev_t device);232 233    // Backend (reg) enumeration234    GGML_API size_t             ggml_backend_reg_count(void);235    GGML_API ggml_backend_reg_t ggml_backend_reg_get(size_t index);236    GGML_API ggml_backend_reg_t ggml_backend_reg_by_name(const char * name);237 238    // Device enumeration239    GGML_API size_t             ggml_backend_dev_count(void);240    GGML_API ggml_backend_dev_t ggml_backend_dev_get(size_t index);241    GGML_API ggml_backend_dev_t ggml_backend_dev_by_name(const char * name);242    GGML_API ggml_backend_dev_t ggml_backend_dev_by_type(enum ggml_backend_dev_type type);243 244    // Direct backend (stream) initialization245    // = ggml_backend_dev_init(ggml_backend_dev_by_name(name), params)246    GGML_API ggml_backend_t ggml_backend_init_by_name(const char * name, const char * params);247    // = ggml_backend_dev_init(ggml_backend_dev_by_type(type), params)248    GGML_API ggml_backend_t ggml_backend_init_by_type(enum ggml_backend_dev_type type, const char * params);249    // = ggml_backend_dev_init(ggml_backend_dev_by_type(GPU) OR ggml_backend_dev_by_type(CPU), NULL)250    GGML_API ggml_backend_t ggml_backend_init_best(void);251 252    // Load a backend from a dynamic library and register it253    GGML_API ggml_backend_reg_t ggml_backend_load(const char * path);254    // Unload a backend if loaded dynamically and unregister it255    GGML_API void               ggml_backend_unload(ggml_backend_reg_t reg);256    // Load all known backends from dynamic libraries257    GGML_API void               ggml_backend_load_all(void);258    GGML_API void               ggml_backend_load_all_from_path(const char * dir_path);259 260    //261    // Backend scheduler262    //263 264    // The backend scheduler allows for multiple backend devices to be used together265    // Handles compute buffer allocation, assignment of tensors to backends, and copying of tensors between backends266    // The backends are selected based on:267    // - the backend that supports the operation268    // - the location of the pre-allocated tensors (e.g. the weights)269    /*270      Example usage:271 272        // operations that use tensors allocated in a buffer with USAGE_WEIGHTS will be assigned273        // preferably to run on the same backend as the buffer274        ggml_backend_buffer_set_usage(buf_weights, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);275 276        sched = ggml_backend_sched_new({backend_gpu, backend_gpu2, backend_cpu}, NULL, num_backends, GGML_DEFAULT_GRAPH_SIZE, false, true);277 278        // initialize buffers from a max size graph (optional)279        reserve_graph = build_graph(sched, max_batch_size);280 281        // manually assign nodes to a backend (optional, should not be needed in most cases)282        struct ggml_tensor * node = ggml_mul_mat(ctx, ...);283        ggml_backend_sched_set_tensor_backend(sched, node, backend_gpu);284 285        ggml_backend_sched_reserve(sched, reserve_graph);286 287        // compute288        graph = build_graph(sched); // the graph and its tensors are single-use in terms of allocation, multi-use in terms of computation289        for (int i = 0; i < 10; ++i) {290            ggml_backend_sched_graph_compute(sched, graph); // on the first iteration the graph is allocated automatically291        }292 293        // if there are graph inputs:294        graph = build_graph(sched); // get a new graph that is not allocated (the metadata for the old graph is freed once ggml_free is called)295        ggml_backend_sched_reset(sched); // clear the allocation of the previous graph296        ggml_backend_sched_alloc_graph(sched, graph); // explicitly allocate the new graph but do not execute it297        ggml_backend_tensor_set(input_tensor, ...); // copy data to the newly allocated graph tensors298        ggml_backend_sched_graph_compute(sched, graph); // execute the graph299 300        // as an alternative to the above it is also possible to assign the inputs to a dedicated context and301        // allocate them statically via ggml_backend_alloc_ctx_tensors302    }303    */304 305    typedef struct ggml_backend_sched * ggml_backend_sched_t;306 307    // Evaluation callback for each node in the graph (set with ggml_backend_sched_set_eval_callback)308    // when ask == true, the scheduler wants to know if the user wants to observe this node309    // this allows the scheduler to batch nodes together in order to evaluate them in a single call310    //311    // when ask == false, the scheduler is passing the node tensor to the user for observation312    // if the user returns false, the scheduler will cancel the graph compute313    //314    typedef bool (*ggml_backend_sched_eval_callback)(struct ggml_tensor * t, bool ask, void * user_data);315 316    // Initialize a backend scheduler, backends with low index are given priority over backends with high index317    GGML_API ggml_backend_sched_t ggml_backend_sched_new(ggml_backend_t * backends, ggml_backend_buffer_type_t * bufts, int n_backends, size_t graph_size, bool parallel, bool op_offload);318    GGML_API void                 ggml_backend_sched_free(ggml_backend_sched_t sched);319 320    // Initialize backend buffers from a measure graph321    GGML_API void                 ggml_backend_sched_reserve_size(ggml_backend_sched_t sched, struct ggml_cgraph * measure_graph, size_t * sizes);322    GGML_API bool                 ggml_backend_sched_reserve(ggml_backend_sched_t sched, struct ggml_cgraph * measure_graph); // returns success323 324    GGML_API int                  ggml_backend_sched_get_n_backends(ggml_backend_sched_t sched);325    GGML_API ggml_backend_t       ggml_backend_sched_get_backend(ggml_backend_sched_t sched, int i);326 327    // Get the number of splits of the last graph328    GGML_API int                  ggml_backend_sched_get_n_splits(ggml_backend_sched_t sched);329    GGML_API int                  ggml_backend_sched_get_n_copies(ggml_backend_sched_t sched);330 331    GGML_API ggml_backend_buffer_type_t ggml_backend_sched_get_buffer_type(ggml_backend_sched_t sched, ggml_backend_t backend);332    GGML_API size_t                     ggml_backend_sched_get_buffer_size(ggml_backend_sched_t sched, ggml_backend_t backend);333 334    GGML_API void                 ggml_backend_sched_set_tensor_backend(ggml_backend_sched_t sched, struct ggml_tensor * node, ggml_backend_t backend);335    GGML_API ggml_backend_t       ggml_backend_sched_get_tensor_backend(ggml_backend_sched_t sched, struct ggml_tensor * node);336 337    // Split graph without allocating it338    GGML_API void                 ggml_backend_sched_split_graph(ggml_backend_sched_t sched, struct ggml_cgraph * graph);339 340    // Allocate and compute graph on the backend scheduler341    GGML_API bool                 ggml_backend_sched_alloc_graph(ggml_backend_sched_t sched, struct ggml_cgraph * graph); // returns success342    GGML_API enum ggml_status     ggml_backend_sched_graph_compute(ggml_backend_sched_t sched, struct ggml_cgraph * graph);343    GGML_API enum ggml_status     ggml_backend_sched_graph_compute_async(ggml_backend_sched_t sched, struct ggml_cgraph * graph);344    GGML_API void                 ggml_backend_sched_synchronize(ggml_backend_sched_t sched);345 346    // Reset all assignments and allocators - must be called before changing the node backends or allocating a new graph.347    // This in effect deallocates all tensors that were previously allocated and leaves them with dangling pointers.348    // The correct way to use this API is to discard the deallocated tensors and create new ones.349    GGML_API void                 ggml_backend_sched_reset(ggml_backend_sched_t sched);350 351    // Set a callback to be called for each resulting node during graph compute352    GGML_API void                 ggml_backend_sched_set_eval_callback(ggml_backend_sched_t sched, ggml_backend_sched_eval_callback callback, void * user_data);353 354    //355    // Meta backend356    //357 358#define GGML_BACKEND_META_MAX_DEVICES 16359 360    enum ggml_backend_meta_split_axis {361        // tensor split by tensor dimensions:362        GGML_BACKEND_SPLIT_AXIS_0 = 0,363        GGML_BACKEND_SPLIT_AXIS_1 = 1,364        GGML_BACKEND_SPLIT_AXIS_2 = 2,365        GGML_BACKEND_SPLIT_AXIS_3 = 3,366 367        GGML_BACKEND_SPLIT_AXIS_MIRRORED = 10, // all values on all backends368        GGML_BACKEND_SPLIT_AXIS_PARTIAL  = 11, // each backend has a partial sum369 370        // for internal bookkeeping only:371        GGML_BACKEND_SPLIT_AXIS_NONE    = 98,372        GGML_BACKEND_SPLIT_AXIS_UNKNOWN = 99,373    };374    GGML_API const char * ggml_backend_meta_split_axis_name(enum ggml_backend_meta_split_axis split_axis);375 376    struct ggml_backend_meta_split_state {377        enum ggml_backend_meta_split_axis axis;378 379        // for tensors with axis >= 0 && axis < GGML_MAX_DIMS:380        //   - each device has a slice of the tensor along the split axis381        //   - most tensors have n_segments == 1 and a contiguous slice of the tensor data382        //   - some tensors have an inhomogenenous data layout along the split axis,383        //     those tensors are divided into segments which are each individually split across devices384        //   - ne has one entry per segment and device and that segment repeats nr times,385        //     in total when accounting for repetitions the segments add up to ggml_tensor::ne for that axis,386        //     the outer/inner loops are over segments/devices like [seg0_dev0_r0, seg0_dev1_r0, seg0_dev0_r1, seg0_dev1_r1, seg1_dev0_r0, seg1_dev1_r0],387        //   - for example, a transformer may have a fused QKV matrix rather than 3 matrices, those would be 3 separate segments388        //     that each need to be split individually across devices so that each device gets a slice of Q, K, and V,389        //     the Q matrix can be larger than the K and V matrices so this can either be expressed as 3 segments or as 2 segments390        //     where the segment for K/V repeats twice391        int64_t  ne[16*GGML_BACKEND_META_MAX_DEVICES];392        uint32_t nr[16];393        uint32_t n_segments;394    };395 396    // function to assign split states for statically allocated tensors, compute tensor split states will be assigned to be compatible:397    typedef struct ggml_backend_meta_split_state(*ggml_backend_meta_get_split_state_t)(const struct ggml_tensor * tensor, void * userdata);398 399    // create a new meta device from "simple" devices, meta buffer type/buffer/backend is then derived from this:400    // TODO: this looks a bit strange - a backend API creates a device. I think we should try401    //       express this as a backend registry functionality instead402    GGML_API ggml_backend_dev_t ggml_backend_meta_device(403        ggml_backend_dev_t * devs, size_t n_devs, ggml_backend_meta_get_split_state_t get_split_state, void * get_split_state_ud);404 405    //406    // Utils407    //408 409    struct ggml_backend_graph_copy {410        ggml_backend_buffer_t buffer;411        struct ggml_context * ctx_allocated;412        struct ggml_context * ctx_unallocated;413        struct ggml_cgraph * graph;414    };415 416    // Copy a graph to a different backend417    GGML_API struct ggml_backend_graph_copy ggml_backend_graph_copy(ggml_backend_t backend, struct ggml_cgraph * graph);418    GGML_API void                           ggml_backend_graph_copy_free(struct ggml_backend_graph_copy copy);419 420    typedef bool (*ggml_backend_eval_callback)(int node_index, struct ggml_tensor * t1, struct ggml_tensor * t2, void * user_data);421 422    // Compare the output of two backends423    GGML_API bool ggml_backend_compare_graph_backend(ggml_backend_t backend1, ggml_backend_t backend2, struct ggml_cgraph * graph, ggml_backend_eval_callback callback, void * user_data, struct ggml_tensor const * const * test_nodes, size_t num_test_nodes);424 425    // Tensor initialization426    GGML_API enum ggml_status ggml_backend_tensor_alloc(ggml_backend_buffer_t buffer, struct ggml_tensor * tensor, void * addr);427    GGML_API enum ggml_status ggml_backend_view_init(struct ggml_tensor * tensor);428 429    // CPU buffer types are always available430    GGML_API ggml_backend_buffer_t      ggml_backend_cpu_buffer_from_ptr(void * ptr, size_t size);431    GGML_API ggml_backend_buffer_type_t ggml_backend_cpu_buffer_type(void);432 433#ifdef  __cplusplus434}435#endif436