ggml : pool naming changes + coding style fixes

diff --git a/examples/replit/main.cpp b/examples/replit/main.cpp
index 1ed265bfb0d62b616f8f2853b3bbb50c4b3cb0ad..aed7f268b6f151024f69bb0074e9531010b5ae2e 100644 (file)
--- a/examples/replit/main.cpp
+++ b/examples/replit/main.cpp
@@ -5,6 +5,7 @@
 
 #include <cassert>
 #include <cmath>
+#include <cinttypes>
 #include <cstddef>
 #include <cstdio>
 #include <cstring>
@@ -342,7 +343,7 @@ bool replit_model_load(const std::string & fname, replit_model & model, replit_t
 
         const size_t memory_size = ggml_nbytes(model.memory_k) + ggml_nbytes(model.memory_v);
 
-        printf("%s: memory_size = %8.2f MB, n_mem = %lld\n", __func__, memory_size / 1024.0 / 1024.0, n_mem);
+        printf("%s: memory_size = %8.2f MB, n_mem = %" PRIu64 "\n", __func__, memory_size / 1024.0 / 1024.0, n_mem);
     }
 
     // load weights

diff --git a/include/ggml/ggml.h b/include/ggml/ggml.h
index 3e9c06a670d5ef9d6dd10de40fea1cedb6fc2a73..b88c35bae72670d52ca6ce4ae2ca2dfe5a69e8f8 100644 (file)
--- a/include/ggml/ggml.h
+++ b/include/ggml/ggml.h
@@ -1175,16 +1175,16 @@ extern "C" {
             int                   s,
             int                   d);
 
-    enum ggml_pool_op {
-        GGML_POOL_MAX,
-        GGML_POOL_AVG,
-        GGML_NUM_POOL_OPS
+    enum ggml_op_pool {
+        GGML_OP_POOL_MAX,
+        GGML_OP_POOL_AVG,
+        GGML_OP_POOL_COUNT,
     };
 
     GGML_API struct ggml_tensor* ggml_pool_1d(
             struct ggml_context * ctx,
             struct ggml_tensor  * a,
-            enum ggml_pool_op     op,
+            enum ggml_op_pool     op,
             int                   k0, // kernel size
             int                   s0, // stride
             int                   p0); // padding
@@ -1192,7 +1192,7 @@ extern "C" {
     GGML_API struct ggml_tensor* ggml_pool_2d(
             struct ggml_context * ctx,
             struct ggml_tensor  * a,
-            enum ggml_pool_op     op,
+            enum ggml_op_pool     op,
             int                   k0,
             int                   k1,
             int                   s0,

diff --git a/src/ggml.c b/src/ggml.c
index 32054a46a9d42873689a5c57fa67eef62336fb93..3d10dd00d71f79215b59d8b7d2aeaafe6a335a2a 100644 (file)
--- a/src/ggml.c
+++ b/src/ggml.c
@@ -3889,6 +3889,8 @@ static const char * GGML_OP_SYMBOL[GGML_OP_COUNT] = {
 
 static_assert(GGML_OP_COUNT == 68, "GGML_OP_COUNT != 68");
 
+static_assert(GGML_OP_POOL_COUNT == 2, "GGML_OP_POOL_COUNT != 2");
+
 static_assert(sizeof(struct ggml_object)%GGML_MEM_ALIGN == 0, "ggml_object size must be a multiple of GGML_MEM_ALIGN");
 static_assert(sizeof(struct ggml_tensor)%GGML_MEM_ALIGN == 0, "ggml_tensor size must be a multiple of GGML_MEM_ALIGN");
 
@@ -7230,7 +7232,7 @@ static int64_t ggml_calc_pool_output_size(int64_t ins, int ks, int s, int p) {
 struct ggml_tensor* ggml_pool_1d(
         struct ggml_context * ctx,
         struct ggml_tensor  * a,
-        enum ggml_pool_op     op,
+        enum ggml_op_pool     op,
         int                   k0,
         int                   s0,
         int                   p0) {
@@ -7269,7 +7271,7 @@ struct ggml_tensor* ggml_pool_1d(
 struct ggml_tensor* ggml_pool_2d(
         struct ggml_context * ctx,
         struct ggml_tensor  * a,
-        enum ggml_pool_op     op,
+        enum ggml_op_pool     op,
         int                   k0,
         int                   k1,
         int                   s0,
@@ -13113,7 +13115,7 @@ static void ggml_compute_forward_conv_2d(
 
 static void ggml_compute_forward_pool_1d_sk_p0(
         const struct ggml_compute_params * params,
-        const enum ggml_pool_op op,
+        const enum ggml_op_pool op,
         const struct ggml_tensor * src,
         const int k,
         struct ggml_tensor * dst) {
@@ -13124,44 +13126,40 @@ static void ggml_compute_forward_pool_1d_sk_p0(
         return;
     }
 
-    const char* cdata = (const char*)src->data;
-    const char* const data_end = cdata + ggml_nbytes(src);
-    float* drow = (float*)dst->data;
+    const char * cdata = (const char *)src->data;
+    const char * const data_end = cdata + ggml_nbytes(src);
+    float * drow = (float *)dst->data;
+
     const int64_t rs = dst->ne[0];
+
     while (cdata < data_end) {
-        const float* const srow = (const float*)cdata;
+        const float * const srow = (const float *)cdata;
 
         int j = 0;
-        static_assert(GGML_NUM_POOL_OPS == 2, "GGML_NUM_POOL_OPS != 2");
+
         for (int64_t i = 0; i < rs; ++i) {
             switch (op) {
-            case GGML_POOL_AVG:
-                drow[i] = 0;
-                break;
-            case GGML_POOL_MAX:
-                drow[i] = -FLT_MAX;
-                break;
+                case GGML_OP_POOL_AVG:   drow[i] = 0;        break;
+                case GGML_OP_POOL_MAX:   drow[i] = -FLT_MAX; break;
+                case GGML_OP_POOL_COUNT: GGML_ASSERT(false); break;
             }
             for (int ki = 0; ki < k; ++ki) {
                 switch (op) {
-                case GGML_POOL_AVG:
-                    drow[i] += srow[j];
-                    break;
-                case GGML_POOL_MAX:
-                    if (srow[j] > drow[i]) drow[i] = srow[j];
-                    break;
+                    case GGML_OP_POOL_AVG:                          drow[i] += srow[j]; break;
+                    case GGML_OP_POOL_MAX:   if (srow[j] > drow[i]) drow[i]  = srow[j]; break;
+                    case GGML_OP_POOL_COUNT:                        GGML_ASSERT(false); break;
                 }
                 ++j;
             }
             switch (op) {
-            case GGML_POOL_AVG:
-                drow[i] /= k;
-                break;
+                case GGML_OP_POOL_AVG:         drow[i] /= k; break;
+                case GGML_OP_POOL_MAX:                       break;
+                case GGML_OP_POOL_COUNT: GGML_ASSERT(false); break;
             }
         }
 
         cdata += src->nb[1];
-        drow += rs;
+        drow  += rs;
     }
 }
 
@@ -13174,7 +13172,7 @@ static void ggml_compute_forward_pool_1d(
     struct ggml_tensor* dst) {
     GGML_ASSERT(opt0->ne[0] == 4);
     const int* opts = (const int*)opt0->data;
-    enum ggml_pool_op op = opts[0];
+    enum ggml_op_pool op = opts[0];
     const int k0 = opts[1];
     const int s0 = opts[2];
     const int p0 = opts[3];
@@ -13188,7 +13186,7 @@ static void ggml_compute_forward_pool_1d(
 
 static void ggml_compute_forward_pool_2d_sk_p0(
     const struct ggml_compute_params * params,
-    const enum ggml_pool_op op,
+    const enum ggml_op_pool op,
     const struct ggml_tensor * src,
     const int k0,
     const int k1,
@@ -13200,55 +13198,51 @@ static void ggml_compute_forward_pool_2d_sk_p0(
         return;
     }
 
-    const char* cdata = (const char*)src->data;
-    const char* const data_end = cdata + ggml_nbytes(src);
+    const char * cdata = (const char*)src->data;
+    const char * const data_end = cdata + ggml_nbytes(src);
 
     const int64_t px = dst->ne[0];
     const int64_t py = dst->ne[1];
     const int64_t pa = px * py;
-    float* dplane = (float*)dst->data;
+
+    float * dplane = (float *)dst->data;
 
     const int ka = k0 * k1;
 
     while (cdata < data_end) {
-        static_assert(GGML_NUM_POOL_OPS == 2, "GGML_NUM_POOL_OPS != 2");
         for (int oy = 0; oy < py; ++oy) {
             float * const drow = dplane + oy * px;
             for (int ox = 0; ox < px; ++ox) {
                 float * const out =  drow + ox;
                 switch (op) {
-                case GGML_POOL_AVG:
-                    *out = 0;
-                    break;
-                case GGML_POOL_MAX:
-                    *out = -FLT_MAX;
-                    break;
+                    case GGML_OP_POOL_AVG:     *out = 0;        break;
+                    case GGML_OP_POOL_MAX:     *out = -FLT_MAX; break;
+                    case GGML_OP_POOL_COUNT: GGML_ASSERT(false); break;
                 }
+
                 const int ix = ox * k0;
                 const int iy = oy * k1;
+
                 for (int ky = 0; ky < k1; ++ky) {
-                    const float* const srow = (const float*)(cdata + src->nb[1] * (iy + ky));
+                    const float * const srow = (const float *)(cdata + src->nb[1] * (iy + ky));
                     for (int kx = 0; kx < k0; ++kx) {
                         int j = ix + kx;
                         switch (op) {
-                        case GGML_POOL_AVG:
-                            *out += srow[j];
-                            break;
-                        case GGML_POOL_MAX:
-                            if (srow[j] > *out) *out = srow[j];
-                            break;
+                            case GGML_OP_POOL_AVG:                     *out += srow[j]; break;
+                            case GGML_OP_POOL_MAX: if (srow[j] > *out) *out  = srow[j]; break;
+                            case GGML_OP_POOL_COUNT:                GGML_ASSERT(false); break;
                         }
                     }
                 }
                 switch (op) {
-                case GGML_POOL_AVG:
-                    *out /= ka;
-                    break;
+                    case GGML_OP_POOL_AVG:           *out /= ka; break;
+                    case GGML_OP_POOL_MAX:                       break;
+                    case GGML_OP_POOL_COUNT: GGML_ASSERT(false); break;
                 }
             }
         }
 
-        cdata += src->nb[2];
+        cdata  += src->nb[2];
         dplane += pa;
     }
 }
@@ -13262,7 +13256,7 @@ static void ggml_compute_forward_pool_2d(
     struct ggml_tensor * dst) {
     GGML_ASSERT(opt0->ne[0] == 7);
     const int* opts = (const int*)opt0->data;
-    enum ggml_pool_op op = opts[0];
+    enum ggml_op_pool op = opts[0];
     const int k0 = opts[1];
     const int k1 = opts[2];
     const int s0 = opts[3];

diff --git a/tests/test-pool.c b/tests/test-pool.c
index 14f831f179c9ee147cb7b71bc7d6e64613bfcfc4..cdf00f4ec989f129d38ddbdb41ebe6b040da260a 100644 (file)
--- a/tests/test-pool.c
+++ b/tests/test-pool.c
@@ -21,11 +21,11 @@ int main(int argc, const char** argv) {
 
     // avg pool 1d
     {
-        struct ggml_context* ctx = make_ctx();
-        struct ggml_tensor* t = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 10, 2);
+        struct ggml_context * ctx = make_ctx();
+        struct ggml_tensor * t = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 10, 2);
         memcpy(t->data, buf_f32, ggml_nbytes(t));
 
-        struct ggml_tensor* t_pooled = ggml_pool_1d(ctx, t, GGML_POOL_AVG, 3, 3, 0);
+        struct ggml_tensor * t_pooled = ggml_pool_1d(ctx, t, GGML_OP_POOL_AVG, 3, 3, 0);
         GGML_ASSERT(t_pooled->ne[0] == 3);
         GGML_ASSERT(t_pooled->ne[1] == 2);
         GGML_ASSERT(t_pooled->ne[2] == 1);
@@ -34,7 +34,8 @@ int main(int argc, const char** argv) {
 
         ggml_graph_compute_with_ctx(ctx, &graph, 4);
 
-        const float* output = ggml_get_data_f32(t_pooled);
+        const float * output = ggml_get_data_f32(t_pooled);
+
         GGML_ASSERT(output[0] == 2);
         GGML_ASSERT(output[1] == 5);
         GGML_ASSERT(output[2] == 8);
@@ -47,11 +48,11 @@ int main(int argc, const char** argv) {
 
     // max pool 1d
     {
-        struct ggml_context* ctx = make_ctx();
-        struct ggml_tensor* t = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 10, 2);
+        struct ggml_context * ctx = make_ctx();
+        struct ggml_tensor * t = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 10, 2);
         memcpy(t->data, buf_f32, ggml_nbytes(t));
 
-        struct ggml_tensor* t_pooled = ggml_pool_1d(ctx, t, GGML_POOL_MAX, 3, 3, 0);
+        struct ggml_tensor * t_pooled = ggml_pool_1d(ctx, t, GGML_OP_POOL_MAX, 3, 3, 0);
         GGML_ASSERT(t_pooled->ne[0] == 3);
         GGML_ASSERT(t_pooled->ne[1] == 2);
         GGML_ASSERT(t_pooled->ne[2] == 1);
@@ -60,7 +61,7 @@ int main(int argc, const char** argv) {
 
         ggml_graph_compute_with_ctx(ctx, &graph, 4);
 
-        const float* output = ggml_get_data_f32(t_pooled);
+        const float * output = ggml_get_data_f32(t_pooled);
         GGML_ASSERT(output[0] == 3);
         GGML_ASSERT(output[1] == 6);
         GGML_ASSERT(output[2] == 9);
@@ -73,11 +74,11 @@ int main(int argc, const char** argv) {
 
     // avg pool 2d
     {
-        struct ggml_context* ctx = make_ctx();
-        struct ggml_tensor* t = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, 10, 10, 2);
+        struct ggml_context * ctx = make_ctx();
+        struct ggml_tensor * t = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, 10, 10, 2);
         memcpy(t->data, buf_f32, ggml_nbytes(t));
 
-        struct ggml_tensor* t_pooled = ggml_pool_2d(ctx, t, GGML_POOL_AVG, 3, 4, 3, 4, 0, 0);
+        struct ggml_tensor * t_pooled = ggml_pool_2d(ctx, t, GGML_OP_POOL_AVG, 3, 4, 3, 4, 0, 0);
         GGML_ASSERT(t_pooled->ne[0] == 3);
         GGML_ASSERT(t_pooled->ne[1] == 2);
         GGML_ASSERT(t_pooled->ne[2] == 2);
@@ -87,7 +88,7 @@ int main(int argc, const char** argv) {
 
         ggml_graph_compute_with_ctx(ctx, &graph, 4);
 
-        const float* output = ggml_get_data_f32(t_pooled);
+        const float * output = ggml_get_data_f32(t_pooled);
         GGML_ASSERT(output[0] == 17);
         GGML_ASSERT(output[1] == 20);
         GGML_ASSERT(output[2] == 23);
@@ -107,11 +108,11 @@ int main(int argc, const char** argv) {
 
     // max pool 2d
     {
-        struct ggml_context* ctx = make_ctx();
-        struct ggml_tensor* t = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, 10, 10, 2);
+        struct ggml_context * ctx = make_ctx();
+        struct ggml_tensor * t = ggml_new_tensor_3d(ctx, GGML_TYPE_F32, 10, 10, 2);
         memcpy(t->data, buf_f32, ggml_nbytes(t));
 
-        struct ggml_tensor* t_pooled = ggml_pool_2d(ctx, t, GGML_POOL_MAX, 3, 4, 3, 4, 0, 0);
+        struct ggml_tensor * t_pooled = ggml_pool_2d(ctx, t, GGML_OP_POOL_MAX, 3, 4, 3, 4, 0, 0);
         GGML_ASSERT(t_pooled->ne[0] == 3);
         GGML_ASSERT(t_pooled->ne[1] == 2);
         GGML_ASSERT(t_pooled->ne[2] == 2);
@@ -121,7 +122,7 @@ int main(int argc, const char** argv) {
 
         ggml_graph_compute_with_ctx(ctx, &graph, 4);
 
-        const float* output = ggml_get_data_f32(t_pooled);
+        const float * output = ggml_get_data_f32(t_pooled);
         GGML_ASSERT(output[0] == 33);
         GGML_ASSERT(output[1] == 36);
         GGML_ASSERT(output[2] == 39);