cui-llama.rn 1.2.0 → 1.2.2

package/cpp/ggml-backend.h

@@ -12,43 +12,52 @@ extern "C" {
     typedef struct lm_ggml_backend_event * lm_ggml_backend_event_t;
     typedef struct lm_ggml_backend * lm_ggml_backend_t;
     typedef void * lm_ggml_backend_graph_plan_t;
+    typedef struct lm_ggml_backend_reg * lm_ggml_backend_reg_t;
+    typedef struct lm_ggml_backend_device * lm_ggml_backend_dev_t;
+
 
     //
-    // Backend buffer
+    // Backend buffer type
     //
 
-    // buffer type
-    LM_GGML_API           const char *          lm_ggml_backend_buft_name            (lm_ggml_backend_buffer_type_t buft);
-    LM_GGML_API LM_GGML_CALL lm_ggml_backend_buffer_t lm_ggml_backend_buft_alloc_buffer    (lm_ggml_backend_buffer_type_t buft, size_t size);
-    LM_GGML_API           size_t                lm_ggml_backend_buft_get_alignment   (lm_ggml_backend_buffer_type_t buft);
-    LM_GGML_API           size_t                lm_ggml_backend_buft_get_max_size    (lm_ggml_backend_buffer_type_t buft);
-    LM_GGML_API LM_GGML_CALL size_t                lm_ggml_backend_buft_get_alloc_size  (lm_ggml_backend_buffer_type_t buft, struct lm_ggml_tensor * tensor);
-    LM_GGML_API           bool                  lm_ggml_backend_buft_is_host         (lm_ggml_backend_buffer_type_t buft);
+    LM_GGML_API const char *          lm_ggml_backend_buft_name          (lm_ggml_backend_buffer_type_t buft);
+    LM_GGML_API lm_ggml_backend_buffer_t lm_ggml_backend_buft_alloc_buffer  (lm_ggml_backend_buffer_type_t buft, size_t size);
+    LM_GGML_API size_t                lm_ggml_backend_buft_get_alignment (lm_ggml_backend_buffer_type_t buft);
+    LM_GGML_API size_t                lm_ggml_backend_buft_get_max_size  (lm_ggml_backend_buffer_type_t buft);
+    LM_GGML_API size_t                lm_ggml_backend_buft_get_alloc_size(lm_ggml_backend_buffer_type_t buft, struct lm_ggml_tensor * tensor);
+    LM_GGML_API bool                  lm_ggml_backend_buft_is_host       (lm_ggml_backend_buffer_type_t buft);
+    LM_GGML_API lm_ggml_backend_dev_t    lm_ggml_backend_buft_get_device    (lm_ggml_backend_buffer_type_t buft);
+
+    //
+    // Backend buffer
+    //
 
-    // buffer
     enum lm_ggml_backend_buffer_usage {
         LM_GGML_BACKEND_BUFFER_USAGE_ANY = 0,
         LM_GGML_BACKEND_BUFFER_USAGE_WEIGHTS = 1,
         LM_GGML_BACKEND_BUFFER_USAGE_COMPUTE = 2,
     };
 
-    LM_GGML_API           const char *                   lm_ggml_backend_buffer_name          (lm_ggml_backend_buffer_t buffer);
-    LM_GGML_API           void                           lm_ggml_backend_buffer_free          (lm_ggml_backend_buffer_t buffer);
-    LM_GGML_API           void *                         lm_ggml_backend_buffer_get_base      (lm_ggml_backend_buffer_t buffer);
-    LM_GGML_API           size_t                         lm_ggml_backend_buffer_get_size      (lm_ggml_backend_buffer_t buffer);
-    LM_GGML_API LM_GGML_CALL void                           lm_ggml_backend_buffer_init_tensor   (lm_ggml_backend_buffer_t buffer, struct lm_ggml_tensor * tensor);
-    LM_GGML_API           size_t                         lm_ggml_backend_buffer_get_alignment (lm_ggml_backend_buffer_t buffer);
-    LM_GGML_API           size_t                         lm_ggml_backend_buffer_get_max_size  (lm_ggml_backend_buffer_t buffer);
-    LM_GGML_API           size_t                         lm_ggml_backend_buffer_get_alloc_size(lm_ggml_backend_buffer_t buffer, struct lm_ggml_tensor * tensor);
-    LM_GGML_API           void                           lm_ggml_backend_buffer_clear         (lm_ggml_backend_buffer_t buffer, uint8_t value);
-    LM_GGML_API           bool                           lm_ggml_backend_buffer_is_host       (lm_ggml_backend_buffer_t buffer);
-    LM_GGML_API           void                           lm_ggml_backend_buffer_set_usage     (lm_ggml_backend_buffer_t buffer, enum lm_ggml_backend_buffer_usage usage);
-    LM_GGML_API           enum lm_ggml_backend_buffer_usage lm_ggml_backend_buffer_get_usage     (lm_ggml_backend_buffer_t buffer);
-    LM_GGML_API           lm_ggml_backend_buffer_type_t     lm_ggml_backend_buffer_get_type      (lm_ggml_backend_buffer_t buffer);
-    LM_GGML_API           void                           lm_ggml_backend_buffer_reset         (lm_ggml_backend_buffer_t buffer);
+    LM_GGML_API const char *                   lm_ggml_backend_buffer_name          (lm_ggml_backend_buffer_t buffer);
+    LM_GGML_API void                           lm_ggml_backend_buffer_free          (lm_ggml_backend_buffer_t buffer);
+    LM_GGML_API void *                         lm_ggml_backend_buffer_get_base      (lm_ggml_backend_buffer_t buffer);
+    LM_GGML_API size_t                         lm_ggml_backend_buffer_get_size      (lm_ggml_backend_buffer_t buffer);
+    LM_GGML_API void                           lm_ggml_backend_buffer_init_tensor   (lm_ggml_backend_buffer_t buffer, struct lm_ggml_tensor * tensor);
+    LM_GGML_API size_t                         lm_ggml_backend_buffer_get_alignment (lm_ggml_backend_buffer_t buffer);
+    LM_GGML_API size_t                         lm_ggml_backend_buffer_get_max_size  (lm_ggml_backend_buffer_t buffer);
+    LM_GGML_API size_t                         lm_ggml_backend_buffer_get_alloc_size(lm_ggml_backend_buffer_t buffer, struct lm_ggml_tensor * tensor);
+    LM_GGML_API void                           lm_ggml_backend_buffer_clear         (lm_ggml_backend_buffer_t buffer, uint8_t value);
+    LM_GGML_API bool                           lm_ggml_backend_buffer_is_host       (lm_ggml_backend_buffer_t buffer);
+    LM_GGML_API void                           lm_ggml_backend_buffer_set_usage     (lm_ggml_backend_buffer_t buffer, enum lm_ggml_backend_buffer_usage usage);
+    LM_GGML_API enum lm_ggml_backend_buffer_usage lm_ggml_backend_buffer_get_usage     (lm_ggml_backend_buffer_t buffer);
+    LM_GGML_API lm_ggml_backend_buffer_type_t     lm_ggml_backend_buffer_get_type      (lm_ggml_backend_buffer_t buffer);
+    LM_GGML_API void                           lm_ggml_backend_buffer_reset         (lm_ggml_backend_buffer_t buffer);
+
+    // tensor copy between different backends
+    LM_GGML_API void lm_ggml_backend_tensor_copy(struct lm_ggml_tensor * src, struct lm_ggml_tensor * dst);
 
     //
-    // Backend
+    // Backend (stream)
     //
 
     LM_GGML_API lm_ggml_guid_t  lm_ggml_backend_guid(lm_ggml_backend_t backend);
@@ -64,9 +73,9 @@ extern "C" {
     LM_GGML_API void lm_ggml_backend_tensor_get_async(lm_ggml_backend_t backend, const struct lm_ggml_tensor * tensor,       void * data, size_t offset, size_t size);
 
     // "offset" refers to the offset of the tensor data for setting/getting data
-    LM_GGML_API LM_GGML_CALL void lm_ggml_backend_tensor_set(      struct lm_ggml_tensor * tensor, const void * data, size_t offset, size_t size);
-    LM_GGML_API LM_GGML_CALL void lm_ggml_backend_tensor_get(const struct lm_ggml_tensor * tensor,       void * data, size_t offset, size_t size);
-    LM_GGML_API LM_GGML_CALL void lm_ggml_backend_tensor_memset(   struct lm_ggml_tensor * tensor,     uint8_t value, size_t offset, size_t size);
+    LM_GGML_API void lm_ggml_backend_tensor_set(      struct lm_ggml_tensor * tensor, const void * data, size_t offset, size_t size);
+    LM_GGML_API void lm_ggml_backend_tensor_get(const struct lm_ggml_tensor * tensor,       void * data, size_t offset, size_t size);
+    LM_GGML_API void lm_ggml_backend_tensor_memset(   struct lm_ggml_tensor * tensor,     uint8_t value, size_t offset, size_t size);
 
     LM_GGML_API void lm_ggml_backend_synchronize(lm_ggml_backend_t backend);
 
@@ -76,65 +85,121 @@ extern "C" {
     LM_GGML_API enum lm_ggml_status lm_ggml_backend_graph_plan_compute (lm_ggml_backend_t backend, lm_ggml_backend_graph_plan_t plan);
     LM_GGML_API enum lm_ggml_status lm_ggml_backend_graph_compute      (lm_ggml_backend_t backend, struct lm_ggml_cgraph * cgraph);
     LM_GGML_API enum lm_ggml_status lm_ggml_backend_graph_compute_async(lm_ggml_backend_t backend, struct lm_ggml_cgraph * cgraph);
+
+    // NOTE: will be removed, use device version instead
     LM_GGML_API bool lm_ggml_backend_supports_op(lm_ggml_backend_t backend, const struct lm_ggml_tensor * op);
     LM_GGML_API bool lm_ggml_backend_supports_buft(lm_ggml_backend_t backend, lm_ggml_backend_buffer_type_t buft);
     LM_GGML_API bool lm_ggml_backend_offload_op(lm_ggml_backend_t backend, const struct lm_ggml_tensor * op);
 
-    // tensor copy between different backends
-    LM_GGML_API void lm_ggml_backend_tensor_copy(struct lm_ggml_tensor * src, struct lm_ggml_tensor * dst);
-
     // asynchronous copy
     // the copy is performed after all the currently queued operations in backend_src
     // backend_dst will wait for the copy to complete before performing other operations
     // automatic fallback to sync copy if async is not supported
     LM_GGML_API void lm_ggml_backend_tensor_copy_async(lm_ggml_backend_t backend_src, lm_ggml_backend_t backend_dst, struct lm_ggml_tensor * src, struct lm_ggml_tensor * dst);
 
-    // events
-    LM_GGML_API lm_ggml_backend_event_t   lm_ggml_backend_event_new        (lm_ggml_backend_t backend);
-    LM_GGML_API void                   lm_ggml_backend_event_free       (lm_ggml_backend_event_t event);
-    LM_GGML_API void                   lm_ggml_backend_event_record     (lm_ggml_backend_event_t event);
-    LM_GGML_API void                   lm_ggml_backend_event_synchronize(lm_ggml_backend_event_t event);
-    LM_GGML_API void                   lm_ggml_backend_event_wait       (lm_ggml_backend_t backend, lm_ggml_backend_event_t event);
+    LM_GGML_API lm_ggml_backend_dev_t lm_ggml_backend_get_device(lm_ggml_backend_t backend);
 
     //
-    // CPU backend
+    // Events
     //
 
-    LM_GGML_API lm_ggml_backend_t lm_ggml_backend_cpu_init(void);
+    LM_GGML_API lm_ggml_backend_event_t lm_ggml_backend_event_new(lm_ggml_backend_dev_t device);
+    LM_GGML_API void                 lm_ggml_backend_event_free(lm_ggml_backend_event_t event);
+    LM_GGML_API void                 lm_ggml_backend_event_record(lm_ggml_backend_event_t event, lm_ggml_backend_t backend);
+    LM_GGML_API void                 lm_ggml_backend_event_synchronize(lm_ggml_backend_event_t event);
+    LM_GGML_API void                 lm_ggml_backend_event_wait(lm_ggml_backend_t backend, lm_ggml_backend_event_t event);
 
-    LM_GGML_API LM_GGML_CALL bool lm_ggml_backend_is_cpu                (lm_ggml_backend_t backend);
-    LM_GGML_API           void lm_ggml_backend_cpu_set_n_threads     (lm_ggml_backend_t backend_cpu, int n_threads);
-    LM_GGML_API           void lm_ggml_backend_cpu_set_threadpool    (lm_ggml_backend_t backend_cpu, lm_ggml_threadpool_t threadpool);
-    LM_GGML_API           void lm_ggml_backend_cpu_set_abort_callback(lm_ggml_backend_t backend_cpu, lm_ggml_abort_callback abort_callback, void * abort_callback_data);
+    //
+    // Backend device
+    //
 
-    // Create a backend buffer from an existing pointer
-    LM_GGML_API LM_GGML_CALL lm_ggml_backend_buffer_t lm_ggml_backend_cpu_buffer_from_ptr(void * ptr, size_t size);
+    enum lm_ggml_backend_dev_type {
+        LM_GGML_BACKEND_DEVICE_TYPE_CPU,
+        LM_GGML_BACKEND_DEVICE_TYPE_GPU,
+        // devices with full capabilities (excludes backends such as BLAS that only support matrix multiplication)
+        LM_GGML_BACKEND_DEVICE_TYPE_CPU_FULL,
+        LM_GGML_BACKEND_DEVICE_TYPE_GPU_FULL
+    };
 
-    LM_GGML_API LM_GGML_CALL lm_ggml_backend_buffer_type_t lm_ggml_backend_cpu_buffer_type(void);
+    // functionality supported by the device
+    struct lm_ggml_backend_dev_caps {
+        // asynchronous operations
+        bool async;
+        // pinned host buffer
+        bool host_buffer;
+        // creating buffers from host ptr
+        bool buffer_from_host_ptr;
+        // event synchronization
+        bool events;
+    };
 
-#ifdef LM_GGML_USE_CPU_HBM
-    LM_GGML_API lm_ggml_backend_buffer_type_t lm_ggml_backend_cpu_hbm_buffer_type(void);
-#endif
+    // all the device properties
+    struct lm_ggml_backend_dev_props {
+        const char * name;
+        const char * description;
+        size_t memory_free;
+        size_t memory_total;
+        enum lm_ggml_backend_dev_type type;
+        struct lm_ggml_backend_dev_caps caps;
+    };
+
+    LM_GGML_API const char *                  lm_ggml_backend_dev_name(lm_ggml_backend_dev_t device);
+    LM_GGML_API const char *                  lm_ggml_backend_dev_description(lm_ggml_backend_dev_t device);
+    LM_GGML_API void                          lm_ggml_backend_dev_memory(lm_ggml_backend_dev_t device, size_t * free, size_t * total);
+    LM_GGML_API enum lm_ggml_backend_dev_type    lm_ggml_backend_dev_type(lm_ggml_backend_dev_t device);
+    LM_GGML_API void                          lm_ggml_backend_dev_get_props(lm_ggml_backend_dev_t device, struct lm_ggml_backend_dev_props * props);
+    LM_GGML_API lm_ggml_backend_reg_t            lm_ggml_backend_dev_backend_reg(lm_ggml_backend_dev_t device);
+    LM_GGML_API lm_ggml_backend_t                lm_ggml_backend_dev_init(lm_ggml_backend_dev_t device, const char * params);
+    LM_GGML_API lm_ggml_backend_buffer_type_t    lm_ggml_backend_dev_buffer_type(lm_ggml_backend_dev_t device);
+    LM_GGML_API lm_ggml_backend_buffer_type_t    lm_ggml_backend_dev_host_buffer_type(lm_ggml_backend_dev_t device);
+    LM_GGML_API lm_ggml_backend_buffer_t         lm_ggml_backend_dev_buffer_from_host_ptr(lm_ggml_backend_dev_t device, void * ptr, size_t size, size_t max_tensor_size);
+
+    LM_GGML_API bool                          lm_ggml_backend_dev_supports_op(lm_ggml_backend_dev_t device, const struct lm_ggml_tensor * op);
+    LM_GGML_API bool                          lm_ggml_backend_dev_supports_buft(lm_ggml_backend_dev_t device, lm_ggml_backend_buffer_type_t buft);
+    LM_GGML_API bool                          lm_ggml_backend_dev_offload_op(lm_ggml_backend_dev_t device, const struct lm_ggml_tensor * op);
 
     //
-    // Backend registry
+    // Backend (reg)
     //
 
-    // The backend registry is a registry of all the available backends, and allows initializing backends in a generic way
+    LM_GGML_API const char *       lm_ggml_backend_reg_name(lm_ggml_backend_reg_t reg);
+    LM_GGML_API size_t             lm_ggml_backend_reg_dev_count(lm_ggml_backend_reg_t reg);
+    LM_GGML_API lm_ggml_backend_dev_t lm_ggml_backend_reg_dev_get(lm_ggml_backend_reg_t reg, size_t index);
+    LM_GGML_API void *             lm_ggml_backend_reg_get_proc_address(lm_ggml_backend_reg_t reg, const char * name);
 
-    LM_GGML_API size_t                     lm_ggml_backend_reg_get_count(void);
-    LM_GGML_API size_t                     lm_ggml_backend_reg_find_by_name(const char * name); // returns index of backend with name, or SIZE_MAX if not found
-    LM_GGML_API lm_ggml_backend_t             lm_ggml_backend_reg_init_backend_from_str(const char * backend_str); // str is backend_name:params (params is optional)
-    LM_GGML_API const char *               lm_ggml_backend_reg_get_name(size_t i);
-    LM_GGML_API lm_ggml_backend_t             lm_ggml_backend_reg_init_backend(size_t i, const char * params); // params is backend-specific
-    LM_GGML_API lm_ggml_backend_buffer_type_t lm_ggml_backend_reg_get_default_buffer_type(size_t i);
-    LM_GGML_API lm_ggml_backend_buffer_t      lm_ggml_backend_reg_alloc_buffer(size_t i, size_t size);
+
+    // Functions that may be obtained using lm_ggml_backend_reg_get_proc_address
+    typedef lm_ggml_backend_buffer_type_t (*lm_ggml_backend_split_buffer_type_t)(const float *);
+    typedef void (*lm_ggml_backend_set_n_threads_t)(lm_ggml_backend_t, int);
+
+    //
+    // Backend registry
+    //
+
+    // Backend (reg) enumeration
+    LM_GGML_API size_t             lm_ggml_backend_reg_count(void);
+    LM_GGML_API lm_ggml_backend_reg_t lm_ggml_backend_reg_get(size_t index);
+    LM_GGML_API lm_ggml_backend_reg_t lm_ggml_backend_reg_by_name(const char * name);
+
+    // Device enumeration
+    LM_GGML_API size_t             lm_ggml_backend_dev_count(void);
+    LM_GGML_API lm_ggml_backend_dev_t lm_ggml_backend_dev_get(size_t index);
+    LM_GGML_API lm_ggml_backend_dev_t lm_ggml_backend_dev_by_name(const char * name);
+    LM_GGML_API lm_ggml_backend_dev_t lm_ggml_backend_dev_by_type(enum lm_ggml_backend_dev_type type);
+
+    // Direct backend (stream) initialization
+    // = lm_ggml_backend_dev_init(lm_ggml_backend_dev_by_name(name), params)
+    LM_GGML_API lm_ggml_backend_t lm_ggml_backend_init_by_name(const char * name, const char * params);
+    // = lm_ggml_backend_dev_init(lm_ggml_backend_dev_by_type(type), params)
+    LM_GGML_API lm_ggml_backend_t lm_ggml_backend_init_by_type(enum lm_ggml_backend_dev_type type, const char * params);
+    // = lm_ggml_backend_dev_init(lm_ggml_backend_dev_by_type(GPU_FULL) OR lm_ggml_backend_dev_by_type(CPU_FULL), NULL)
+    LM_GGML_API lm_ggml_backend_t lm_ggml_backend_init_best(void);
 
     //
     // Backend scheduler
     //
 
-    // The backend scheduler allows for multiple backends to be used together
+    // The backend scheduler allows for multiple backend devices to be used together
     // Handles compute buffer allocation, assignment of tensors to backends, and copying of tensors between backends
     // The backends are selected based on:
     // - the backend that supports the operation
@@ -169,9 +234,9 @@ extern "C" {
     }
     */
 
-    struct lm_ggml_backend_sched;
     typedef struct lm_ggml_backend_sched * lm_ggml_backend_sched_t;
 
+    // Evaluation callback for each node in the graph (set with lm_ggml_backend_sched_set_eval_callback)
     // when ask == true, the scheduler wants to know if the user wants to observe this node
     // this allows the scheduler to batch nodes together in order to evaluate them in a single call
     //
@@ -185,7 +250,7 @@ extern "C" {
     LM_GGML_API void                 lm_ggml_backend_sched_free(lm_ggml_backend_sched_t sched);
 
     // Initialize backend buffers from a measure graph
-    LM_GGML_API bool                 lm_ggml_backend_sched_reserve(lm_ggml_backend_sched_t sched, struct lm_ggml_cgraph * measure_graph);
+    LM_GGML_API bool                 lm_ggml_backend_sched_reserve(lm_ggml_backend_sched_t sched, struct lm_ggml_cgraph * measure_graph); // returns success
 
     LM_GGML_API int                  lm_ggml_backend_sched_get_n_backends(lm_ggml_backend_sched_t sched);
     LM_GGML_API lm_ggml_backend_t       lm_ggml_backend_sched_get_backend(lm_ggml_backend_sched_t sched, int i);
@@ -200,7 +265,7 @@ extern "C" {
     LM_GGML_API lm_ggml_backend_t       lm_ggml_backend_sched_get_tensor_backend(lm_ggml_backend_sched_t sched, struct lm_ggml_tensor * node);
 
     // Allocate and compute graph on the backend scheduler
-    LM_GGML_API bool                 lm_ggml_backend_sched_alloc_graph(lm_ggml_backend_sched_t sched, struct lm_ggml_cgraph * graph);
+    LM_GGML_API bool                 lm_ggml_backend_sched_alloc_graph(lm_ggml_backend_sched_t sched, struct lm_ggml_cgraph * graph); // returns success
     LM_GGML_API enum lm_ggml_status     lm_ggml_backend_sched_graph_compute(lm_ggml_backend_sched_t sched, struct lm_ggml_cgraph * graph);
     LM_GGML_API enum lm_ggml_status     lm_ggml_backend_sched_graph_compute_async(lm_ggml_backend_sched_t sched, struct lm_ggml_cgraph * graph);
     LM_GGML_API void                 lm_ggml_backend_sched_synchronize(lm_ggml_backend_sched_t sched);
@@ -226,7 +291,7 @@ extern "C" {
     LM_GGML_API struct lm_ggml_backend_graph_copy lm_ggml_backend_graph_copy(lm_ggml_backend_t backend, struct lm_ggml_cgraph * graph);
     LM_GGML_API void                           lm_ggml_backend_graph_copy_free(struct lm_ggml_backend_graph_copy copy);
 
-    typedef bool (*LM_GGML_CALL lm_ggml_backend_eval_callback)(int node_index, struct lm_ggml_tensor * t1, struct lm_ggml_tensor * t2, void * user_data);
+    typedef bool (*lm_ggml_backend_eval_callback)(int node_index, struct lm_ggml_tensor * t1, struct lm_ggml_tensor * t2, void * user_data);
 
     // Compare the output of two backends
     LM_GGML_API bool lm_ggml_backend_compare_graph_backend(lm_ggml_backend_t backend1, lm_ggml_backend_t backend2, struct lm_ggml_cgraph * graph, lm_ggml_backend_eval_callback callback, void * user_data);
@@ -235,6 +300,26 @@ extern "C" {
     LM_GGML_API void lm_ggml_backend_tensor_alloc(lm_ggml_backend_buffer_t buffer, struct lm_ggml_tensor * tensor, void * addr);
     LM_GGML_API void lm_ggml_backend_view_init(struct lm_ggml_tensor * tensor);
 
+    //
+    // CPU backend
+    //
+
+    LM_GGML_API lm_ggml_backend_t lm_ggml_backend_cpu_init(void);
+
+    LM_GGML_API bool lm_ggml_backend_is_cpu                (lm_ggml_backend_t backend);
+    LM_GGML_API void lm_ggml_backend_cpu_set_n_threads     (lm_ggml_backend_t backend_cpu, int n_threads);
+    LM_GGML_API void lm_ggml_backend_cpu_set_threadpool    (lm_ggml_backend_t backend_cpu, lm_ggml_threadpool_t threadpool);
+    LM_GGML_API void lm_ggml_backend_cpu_set_abort_callback(lm_ggml_backend_t backend_cpu, lm_ggml_abort_callback abort_callback, void * abort_callback_data);
+
+    // Create a backend buffer from an existing pointer
+    LM_GGML_API lm_ggml_backend_buffer_t      lm_ggml_backend_cpu_buffer_from_ptr(void * ptr, size_t size);
+    LM_GGML_API lm_ggml_backend_buffer_type_t lm_ggml_backend_cpu_buffer_type(void);
+
+    LM_GGML_API lm_ggml_backend_reg_t lm_ggml_backend_cpu_reg(void);
+
+#ifdef LM_GGML_USE_CPU_HBM
+    LM_GGML_API lm_ggml_backend_buffer_type_t lm_ggml_backend_cpu_hbm_buffer_type(void);
+#endif
 
 #ifdef  __cplusplus
 }

package/cpp/ggml-impl.h

@@ -33,6 +33,21 @@ extern "C" {
 #endif
 #endif
 
+//
+// logging
+//
+
+LM_GGML_ATTRIBUTE_FORMAT(2, 3)
+void lm_ggml_log_internal        (enum lm_ggml_log_level level, const char * format, ...);
+void lm_ggml_log_callback_default(enum lm_ggml_log_level level, const char * text, void * user_data);
+
+#define LM_GGML_LOG(...)       lm_ggml_log_internal(LM_GGML_LOG_LEVEL_NONE , __VA_ARGS__)
+#define LM_GGML_LOG_INFO(...)  lm_ggml_log_internal(LM_GGML_LOG_LEVEL_INFO , __VA_ARGS__)
+#define LM_GGML_LOG_WARN(...)  lm_ggml_log_internal(LM_GGML_LOG_LEVEL_WARN , __VA_ARGS__)
+#define LM_GGML_LOG_ERROR(...) lm_ggml_log_internal(LM_GGML_LOG_LEVEL_ERROR, __VA_ARGS__)
+#define LM_GGML_LOG_DEBUG(...) lm_ggml_log_internal(LM_GGML_LOG_LEVEL_DEBUG, __VA_ARGS__)
+#define LM_GGML_LOG_CONT(...)  lm_ggml_log_internal(LM_GGML_LOG_LEVEL_CONT , __VA_ARGS__)
+
 // bitset
 
 typedef uint32_t lm_ggml_bitset_t;

package/cpp/ggml-metal.h

@@ -1,3 +1,5 @@
+// Note: this description is outdated
+//
 // An interface allowing to compute lm_ggml_cgraph with Metal
 //
 // This is a fully functional interface that extends ggml with GPU support for Apple devices.
@@ -25,9 +27,6 @@
 #include <stddef.h>
 #include <stdbool.h>
 
-// max memory buffers that can be mapped to the device
-#define LM_GGML_METAL_MAX_BUFFERS 64
-
 struct lm_ggml_tensor;
 struct lm_ggml_cgraph;
 
@@ -40,19 +39,17 @@ extern "C" {
 // user-code should use only these functions
 //
 
-LM_GGML_API void lm_ggml_backend_metal_log_set_callback(lm_ggml_log_callback log_callback, void * user_data);
-
 LM_GGML_API lm_ggml_backend_t lm_ggml_backend_metal_init(void);
 
 LM_GGML_API bool lm_ggml_backend_is_metal(lm_ggml_backend_t backend);
 
-LM_GGML_API LM_GGML_CALL lm_ggml_backend_buffer_t lm_ggml_backend_metal_buffer_from_ptr(void * data, size_t size, size_t max_size);
-
-LM_GGML_API void lm_ggml_backend_metal_set_n_cb(lm_ggml_backend_t backend, int n_cb);
+LM_GGML_DEPRECATED(
+        LM_GGML_API lm_ggml_backend_buffer_t lm_ggml_backend_metal_buffer_from_ptr(void * data, size_t size, size_t max_size),
+        "obsoleted by the new device interface - https://github.com/ggerganov/llama.cpp/pull/9713");
 
 LM_GGML_API void lm_ggml_backend_metal_set_abort_callback(lm_ggml_backend_t backend, lm_ggml_abort_callback abort_callback, void * user_data);
 
-LM_GGML_API LM_GGML_CALL lm_ggml_backend_buffer_type_t lm_ggml_backend_metal_buffer_type(void);
+LM_GGML_API lm_ggml_backend_buffer_type_t lm_ggml_backend_metal_buffer_type(void);
 
 // helper to check if the device supports a specific family
 // ideally, the user code should be doing these checks
@@ -62,6 +59,8 @@ LM_GGML_API bool lm_ggml_backend_metal_supports_family(lm_ggml_backend_t backend
 // capture all command buffers committed the next time `lm_ggml_backend_graph_compute` is called
 LM_GGML_API void lm_ggml_backend_metal_capture_next_compute(lm_ggml_backend_t backend);
 
+LM_GGML_API lm_ggml_backend_reg_t lm_ggml_backend_metal_reg(void);
+
 #ifdef __cplusplus
 }
 #endif