cont : const correctness

ggml/include/ggml-backend.h

@@ -96,7 +96,7 @@ extern "C" {
     GGML_API void ggml_backend_tensor_get   (const struct ggml_tensor * tensor,       void * data, size_t offset, size_t size);
     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);
     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);
-    GGML_API void ggml_backend_tensor_set_n (const struct ggml_tensor * const * tensors, const void * data, const size_t * offsets, const size_t * sizes, const size_t * data_offsets, size_t n_tensors);
+    GGML_API void ggml_backend_tensor_set_n (      struct ggml_tensor * const * tensors, const void * data, const size_t * offsets, const size_t * sizes, const size_t * data_offsets, size_t n_tensors);
     GGML_API void ggml_backend_tensor_get_n (const struct ggml_tensor * const * tensors,       void * data, const size_t * offsets, const size_t * sizes, const size_t * data_offsets, size_t n_tensors);
     GGML_API void ggml_backend_tensor_memset(      struct ggml_tensor * tensor,     uint8_t value, size_t offset, size_t size);
 

ggml/src/ggml-backend-impl.h

@@ -69,7 +69,7 @@ extern "C" {
         // (optional) reset any internal state due to tensor initialization, such as tensor extras
         void         (*reset)        (ggml_backend_buffer_t buffer);
         // (optional) batched tensor data copies
-        void         (*set_tensor_n) (ggml_backend_buffer_t buffer, const struct ggml_tensor * const * tensors, const void * const * data, const size_t * offsets, const size_t * sizes, size_t n_tensors);
+        void         (*set_tensor_n) (ggml_backend_buffer_t buffer,       struct ggml_tensor * const * tensors, const void * const * data, const size_t * offsets, const size_t * sizes, size_t n_tensors);
         void         (*get_tensor_n) (ggml_backend_buffer_t buffer, const struct ggml_tensor * const * tensors,       void * const * data, const size_t * offsets, const size_t * sizes, size_t n_tensors);
         // (optional) batched tensor copies: returns true if all copies were performed, false if unsupported and no copies were performed
         bool         (*cpy_tensor_n) (ggml_backend_buffer_t buffer, const struct ggml_tensor * const * srcs, struct ggml_tensor * const * dsts, size_t n_tensors);

ggml/src/ggml-backend.cpp

@@ -602,7 +602,7 @@ void ggml_backend_tensor_get_2d(const struct ggml_tensor * tensor, void * data,
     buf->iface.get_tensor_2d(buf, tensor, data, offset, size, n_copies, stride_tensor, stride_data);
 }
 
-void ggml_backend_tensor_set_n(const struct ggml_tensor * const * tensors, const void * data,
+void ggml_backend_tensor_set_n(struct ggml_tensor * const * tensors, const void * data,
         const size_t * offsets, const size_t * sizes, const size_t * data_offsets, size_t n_tensors) {
     if (n_tensors == 0) {
         return;
@@ -642,7 +642,7 @@ void ggml_backend_tensor_set_n(const struct ggml_tensor * const * tensors, const
         }, groups);
 
         for (size_t g = 0; g < groups.size(); g++) {
-            std::vector<const ggml_tensor *> g_tensors;
+            std::vector<ggml_tensor *> g_tensors;
             std::vector<size_t> g_offsets;
             std::vector<size_t> g_sizes;
             std::vector<size_t> g_data_offsets;
@@ -666,13 +666,13 @@ void ggml_backend_tensor_set_n(const struct ggml_tensor * const * tensors, const
     size_t base_offset = 0, size = 0, stride_tensor = 0, stride_data = 0;
     if (ggml_backend_tensor_batch_is_2d(tensors, offsets, sizes, data_offsets, n_tensors,
                 &base_offset, &size, &stride_tensor, &stride_data)) {
-        ggml_backend_tensor_set_2d(const_cast<struct ggml_tensor *>(tensors[0]), data_ptrs[0], base_offset, size,
+        ggml_backend_tensor_set_2d(tensors[0], data_ptrs[0], base_offset, size,
                 n_tensors, stride_tensor, stride_data);
         return;
     }
 
     for (size_t i = 0; i < n_tensors; i++) {
-        ggml_backend_tensor_set(const_cast<struct ggml_tensor *>(tensors[i]), data_ptrs[i], offsets[i], sizes[i]);
+        ggml_backend_tensor_set(tensors[i], data_ptrs[i], offsets[i], sizes[i]);
     }
 }
 

ggml/src/ggml-cuda/ggml-cuda.cu

@@ -861,7 +861,7 @@ static void ggml_backend_cuda_buffer_get_tensor_2d(ggml_backend_buffer_t buffer,
     CUDA_CHECK(cudaStreamSynchronize(cudaStreamPerThread));
 }
 
-static void ggml_backend_cuda_buffer_set_tensor_n(ggml_backend_buffer_t buffer, const struct ggml_tensor * const * tensors, const void * const * data, const size_t * offsets, const size_t * sizes, size_t n_tensors) {
+static void ggml_backend_cuda_buffer_set_tensor_n(ggml_backend_buffer_t buffer, struct ggml_tensor * const * tensors, const void * const * data, const size_t * offsets, const size_t * sizes, size_t n_tensors) {
     ggml_backend_cuda_buffer_context * ctx = (ggml_backend_cuda_buffer_context *)buffer->context;
 
     ggml_cuda_set_device(ctx->device);

ggml/src/ggml-metal/ggml-metal-device.h

@@ -362,7 +362,7 @@ bool   ggml_metal_buffer_is_shared(ggml_metal_buffer_t buf);
 void   ggml_metal_buffer_memset_tensor(ggml_metal_buffer_t buf, struct ggml_tensor * tensor, uint8_t value, size_t offset, size_t size);
 void   ggml_metal_buffer_set_tensor   (ggml_metal_buffer_t buf, struct ggml_tensor * tensor, const void * data, size_t offset, size_t size);
 void   ggml_metal_buffer_get_tensor   (ggml_metal_buffer_t buf, const struct ggml_tensor * tensor, void * data, size_t offset, size_t size);
-void   ggml_metal_buffer_set_tensor_n (ggml_metal_buffer_t buf, const struct ggml_tensor * const * tensors, const void * const * data, const size_t * offsets, const size_t * sizes, size_t n_tensors);
+void   ggml_metal_buffer_set_tensor_n (ggml_metal_buffer_t buf, struct ggml_tensor * const * tensors, const void * const * data, const size_t * offsets, const size_t * sizes, size_t n_tensors);
 void   ggml_metal_buffer_get_tensor_n (ggml_metal_buffer_t buf, const struct ggml_tensor * const * tensors,       void * const * data, const size_t * offsets, const size_t * sizes, size_t n_tensors);
 bool   ggml_metal_buffer_cpy_tensor   (ggml_metal_buffer_t buf, const struct ggml_tensor * src, struct ggml_tensor * dst);
 bool   ggml_metal_buffer_cpy_tensor_n (ggml_metal_buffer_t buf, const struct ggml_tensor * const * srcs, struct ggml_tensor * const * dsts, size_t n_tensors);

ggml/src/ggml-metal/ggml-metal-device.m

@@ -2463,7 +2463,7 @@ static bool ggml_metal_buffer_data_span(const void * const * data, const size_t
     return found;
 }
 
-void ggml_metal_buffer_set_tensor_n(ggml_metal_buffer_t buf, const struct ggml_tensor * const * tensors, const void * const * data,
+void ggml_metal_buffer_set_tensor_n(ggml_metal_buffer_t buf, struct ggml_tensor * const * tensors, const void * const * data,
         const size_t * offsets, const size_t * sizes, size_t n_tensors) {
     if (buf->is_shared) {
         for (size_t i = 0; i < n_tensors; i++) {

ggml/src/ggml-metal/ggml-metal.cpp

@@ -68,7 +68,7 @@ static void ggml_backend_metal_buffer_shared_get_tensor(ggml_backend_buffer_t bu
     ggml_metal_buffer_get_tensor(ctx, tensor, data, offset, size);
 }
 
-static void ggml_backend_metal_buffer_shared_set_tensor_n(ggml_backend_buffer_t buffer, const struct ggml_tensor * const * tensors, const void * const * data, const size_t * offsets, const size_t * sizes, size_t n_tensors) {
+static void ggml_backend_metal_buffer_shared_set_tensor_n(ggml_backend_buffer_t buffer, struct ggml_tensor * const * tensors, const void * const * data, const size_t * offsets, const size_t * sizes, size_t n_tensors) {
     ggml_metal_buffer_t ctx = (ggml_metal_buffer_t)buffer->context;
 
     GGML_ASSERT(ggml_metal_buffer_is_shared(ctx));
@@ -177,7 +177,7 @@ static void ggml_backend_metal_buffer_private_get_tensor(ggml_backend_buffer_t b
     ggml_metal_buffer_get_tensor(ctx, tensor, data, offset, size);
 }
 
-static void ggml_backend_metal_buffer_private_set_tensor_n(ggml_backend_buffer_t buffer, const struct ggml_tensor * const * tensors, const void * const * data, const size_t * offsets, const size_t * sizes, size_t n_tensors) {
+static void ggml_backend_metal_buffer_private_set_tensor_n(ggml_backend_buffer_t buffer, struct ggml_tensor * const * tensors, const void * const * data, const size_t * offsets, const size_t * sizes, size_t n_tensors) {
     ggml_metal_buffer_t ctx = (ggml_metal_buffer_t)buffer->context;
 
     GGML_ASSERT(!ggml_metal_buffer_is_shared(ctx));

src/llama-context.cpp

@@ -3000,7 +3000,7 @@ public:
             return;
         }
 
-        std::vector<const ggml_tensor *> tensors;
+        std::vector<ggml_tensor *> tensors;
         std::vector<size_t> offsets;
         std::vector<size_t> sizes;
         std::vector<size_t> data_offsets;

tests/test-backend-tensor.cpp

@@ -15,7 +15,6 @@ static bool run_tensor_n_case(
         const std::vector<size_t> & data_offsets) {
     const size_t n = tensors.size();
 
-    std::vector<const ggml_tensor *> const_tensors(tensors.begin(), tensors.end());
     std::vector<uint8_t> data(256, 0);
     std::vector<uint8_t> out(256, 0);
 
@@ -26,9 +25,9 @@ static bool run_tensor_n_case(
         memset(data.data() + data_offsets[i], (int) (0x40 + i*0x10), sizes[i]);
     }
 
-    ggml_backend_tensor_set_n(const_tensors.data(), data.data(), offsets.data(), sizes.data(), data_offsets.data(), n);
+    ggml_backend_tensor_set_n(tensors.data(), data.data(), offsets.data(), sizes.data(), data_offsets.data(), n);
 
-    ggml_backend_tensor_get_n(const_tensors.data(), out.data(), offsets.data(), sizes.data(), data_offsets.data(), n);
+    ggml_backend_tensor_get_n(tensors.data(), out.data(), offsets.data(), sizes.data(), data_offsets.data(), n);
 
     for (size_t i = 0; i < n; i++) {
         if (sizes[i] == 0) {