fix more refs

Author: dbsanfte

tools/cvector-generator/cvector-generator.cpp

@@ -98,8 +98,8 @@ struct callback_data {
     // NOTE: final layer is ignored. we only have (n_layers - 1) to process
     std::vector<struct ggml_tensor *> calc_diff() {
         for (float il = 0; il < v_pos.size(); il++) {
-            float * a = (float *) v_pos[il]->data;
-            float * b = (float *) v_neg[il]->data;
+            float * a = (float *) tensor_data(v_pos[il]);
+            float * b = (float *) tensor_data(v_neg[il]);
             size_t n_elem = ggml_nelements(v_pos[il]);
             for (size_t j = 0; j < n_elem; j++) {
                 a[j] -= b[j];
@@ -141,7 +141,7 @@ struct callback_data {
         struct ggml_tensor * diff_filtered = ggml_new_tensor_2d(
             ctx_ggml, GGML_TYPE_F32, n_embd, n_nonzero_rows);
         ggml_format_name(diff_filtered, "diff_filtered_%s", a->name);
-        diff_filtered->data = malloc(ggml_nbytes(diff_filtered));
+        tensor_set_data(diff_filtered, malloc(ggml_nbytes(diff_filtered)));
 
         // copy non-zero rows
         for (int dest_row = 0; dest_row < n_nonzero_rows; dest_row++) {
@@ -159,9 +159,9 @@ struct callback_data {
 
     // we don't implement destructor, because we want to reuse callback_data. we just want to free the tensors
     void reset() {
-        for (auto ptr : v_pos) free(ptr->data);
-        for (auto ptr : v_neg) free(ptr->data);
-        for (auto ptr : v_diff_filtered) free(ptr->data);
+        for (auto ptr : v_pos) free(tensor_data(ptr));
+        for (auto ptr : v_neg) free(tensor_data(ptr));
+        for (auto ptr : v_diff_filtered) free(tensor_data(ptr));
         v_pos.clear();
         v_neg.clear();
         v_diff_filtered.clear();
@@ -208,7 +208,7 @@ struct train_context {
             std::vector<uint8_t> empty;
             v_diff_tmp.push_back(empty);
             auto t = ggml_new_tensor_1d(ctx_ggml, GGML_TYPE_F32, n_embd);
-            t->data = malloc(ggml_nbytes(t)); // TODO: get rid of malloc if possible
+            tensor_set_data(t, malloc(ggml_nbytes(t))); // TODO: get rid of malloc if possible
             v_final.push_back(t);
         }
     }
@@ -221,7 +221,7 @@ struct train_context {
             auto & diff_tmp = v_diff_tmp[il];
             size_t curr_size = diff_tmp.size();
             diff_tmp.resize(curr_size + ggml_nbytes(t));
-            memcpy(diff_tmp.data() + curr_size, t->data, ggml_nbytes(t));
+            memcpy(diff_tmp.data() + curr_size, tensor_data(t), ggml_nbytes(t));
         }
     }
 
@@ -238,7 +238,7 @@ struct train_context {
                 ? ggml_new_tensor_2d(ctx_ggml, GGML_TYPE_F32, n_rows, n_embd)
                 : ggml_new_tensor_2d(ctx_ggml, GGML_TYPE_F32, n_embd, n_rows);
             ggml_set_name(diff, (std::string("diff_") + std::to_string(il)).c_str());
-            diff->data = malloc(ggml_nbytes(diff)); // TODO: get rid of this malloc if possible
+            tensor_set_data(diff, malloc(ggml_nbytes(diff))); // TODO: get rid of this malloc if possible
             if (transpose) {
                 // copy data & transpose
                 float * arr = (float *) diff_tmp.data();
@@ -250,7 +250,7 @@ struct train_context {
                 }
             } else {
                 // only copy
-                memcpy(diff->data, diff_tmp.data(), ggml_nbytes(diff));
+                memcpy(tensor_data(diff), diff_tmp.data(), ggml_nbytes(diff));
             }
             v_diff.push_back(diff);
             print_debug_tensor(diff);
@@ -260,8 +260,8 @@ struct train_context {
     }
 
     ~train_context() {
-        for (auto ptr : v_final) free(ptr->data);
-        for (auto ptr : v_diff) free(ptr->data);
+        for (auto ptr : v_final) free(tensor_data(ptr));
+        for (auto ptr : v_diff) free(tensor_data(ptr));
         // no need to free v_diff_tmp, since we didn't use malloc
         ggml_free(ctx_ggml);
     }

tools/cvector-generator/pca.hpp

@@ -102,7 +102,7 @@ struct pca_model {
         ggml_set_name(dev_square,      "dev_square");
         ggml_set_name(dev_eigenvector, "dev_eigenvector");
         buffer = ggml_backend_alloc_ctx_tensors(ctx, backend);
-        ggml_backend_tensor_set(dev_input, t_input->data, 0, ggml_nbytes(t_input));
+        ggml_backend_tensor_set(dev_input, tensor_data(t_input), 0, ggml_nbytes(t_input));
 
         // initialize eigenvector to random normalized vector
         {
@@ -285,7 +285,7 @@ static void power_iteration(
 
     // get output tensor
     GGML_ASSERT(last_eigenvector);
-    ggml_backend_tensor_get(last_eigenvector, output->data, 0, ggml_nbytes(last_eigenvector));
+    ggml_backend_tensor_get(last_eigenvector, tensor_data(output), 0, ggml_nbytes(last_eigenvector));
     //print_debug_tensor(output);
     ggml_gallocr_free(allocr);
 

tools/imatrix/imatrix.cpp

@@ -247,7 +247,7 @@ bool IMatrixCollector::collect_imatrix(struct ggml_tensor * t, bool ask, void *
         ggml_backend_tensor_get(src1, m_src1_data.data(), 0, src1_nbytes);
     }
 
-    const char * data = is_host ? (const char *) src1->data : m_src1_data.data();
+    const char * data = is_host ? (const char *) tensor_data(src1) : m_src1_data.data();
     GGML_ASSERT(src1->nb[0] == ggml_element_size(src1));
 
     // TODO: 4d? (is that even used in practice?)
@@ -576,10 +576,10 @@ void IMatrixCollector::save_imatrix(int32_t n_chunk) const {
             ggml_format_name(counts, "%s.counts", name.c_str());
 
             for (int32_t j = 0; j < nval; ++j) {
-                ((float *) in_sum2->data)[j] = (float) stat.values[j];
+                ((float *) tensor_data(in_sum2))[j] = (float) stat.values[j];
             }
             for (int32_t j = 0; j < nmat; ++j) {
-                ((float *) counts->data)[j] = (float) stat.counts[j];
+                ((float *) tensor_data(counts))[j] = (float) stat.counts[j];
             }
 
             gguf_add_tensor(ctx_gguf, in_sum2);
@@ -786,10 +786,10 @@ bool IMatrixCollector::load_imatrix(const char * file_name) {
 
         // Recreate the state as expected by save_imatrix()
         for (int64_t j = 0; j < nval; j++) {
-            e.values[j] += ((const float *) in_sum2->data)[j];
+            e.values[j] += ((const float *) tensor_data(in_sum2))[j];
         }
         for (int64_t j = 0; j < ncounts; j++) {
-            e.counts[j] += std::lround(((const float *) counts->data)[j]);
+            e.counts[j] += std::lround(((const float *) tensor_data(counts))[j]);
         }
     }
 

tools/quantize/quantize.cpp

@@ -286,10 +286,10 @@ static int load_imatrix(const std::string & imatrix_file, std::vector<std::strin
         e.resize(ggml_nelements(sums));
         float max_count = 0.0f;
         for (int64_t j = 0; j < ne1; ++j) {
-            const float count = ((const float *) counts->data)[j];
+            const float count = ((const float *) tensor_data(counts))[j];
             if (count > 0.0f) {
                 for (int64_t i = 0; i < ne0; ++i) {
-                    e[j*ne0 + i] = ((const float *) sums->data)[j*ne0 + i] / count;
+                    e[j*ne0 + i] = ((const float *) tensor_data(sums))[j*ne0 + i] / count;
                 }
             } else {
                 // Partial imatrix data, this tensor never got any input during calibration