From 2ae6b220cc639ecc9cdfdabfe7be36aa2ed98b15 Mon Sep 17 00:00:00 2001
From: Tylo <tylo@norceresearch.no>
Date: Tue, 23 Jun 2020 17:45:43 +0200
Subject: Improved representation storage for CArray. Stores "owned" as highest
 bit in xdim.

---
 examples/demos.c |  7 +++++--
 stc/carray.h     | 62 +++++++++++++++++++++++++++++++++-----------------------
 stc/cdefs.h      | 29 +++++++++++++-------------
 stc/chash.h      |  2 +-
 stc/clist.h      |  2 +-
 5 files changed, 58 insertions(+), 44 deletions(-)

diff --git a/examples/demos.c b/examples/demos.c
index e05fa269..e8530b90 100644
--- a/examples/demos.c
+++ b/examples/demos.c
@@ -172,13 +172,16 @@ void mapdemo3()
 
 declare_CArray(f, float);
 
-int arraydemo1()
+void arraydemo1()
 {
     printf("\nARRAYDEMO1\n");
     CArray3_f a3 = carray3_f_make(30, 20, 10, 0.f);
     carray3_f_data(a3, 5, 4)[3] = 10.2f;         // a3[5][4][3]
     CArray2_f a2 = carray3_f_at(a3, 5);          // sub-array reference (no data copy).
 
+    printf("a3: %zu: (%zu, %zu, %zu) = %zu\n", sizeof(a3), carray_xdim(a3), carray_ydim(a3), carray_zdim(a3), carray3_size(a3));
+    printf("a2: %zu: (%zu, %zu) = %zu\n", sizeof(a2), carray_xdim(a2), carray_ydim(a2), carray2_size(a2));
+
     printf("%f\n", carray2_f_value(a2, 4, 3));   // readonly lookup a2[4][3] (=10.2f)
     printf("%f\n", carray2_f_data(a2, 4)[3]);    // same, but this is writable.
     printf("%f\n", carray2_f_at(a2, 4).data[3]); // same, via sub-array access.
@@ -186,7 +189,7 @@ int arraydemo1()
     printf("%f\n", carray3_f_value(a3, 5, 4, 3)); // same data location, via a3 array.
     printf("%f\n", carray3_f_data(a3, 5, 4)[3]);
     printf("%f\n", carray3_f_at2(a3, 5, 4).data[3]);
-    
+
     carray2_f_destroy(&a2); // does nothing, since it is a sub-array.
     carray3_f_destroy(&a3); // also invalidates a2.
 }
diff --git a/stc/carray.h b/stc/carray.h
index a5c9571c..214bc976 100644
--- a/stc/carray.h
+++ b/stc/carray.h
@@ -49,12 +49,23 @@ int main()
 }
 */
 
-#define carray_xdim(a)  ((a).xdim)
-#define carray_ydim(a)  ((a)._yxdim / (a).xdim)
+#define carray_xdim(a)  ((a)._xdim & ~_carray_own)
+#define carray_ydim(a)  _carray_ydim(&(a)._yxdim)
 #define carray_zdim(a)  ((a)._zdim)
-#define carray1_size(a) ((a).xdim)
+#define carray1_size(a) carray_xdim(a)
 #define carray2_size(a) ((a)._yxdim)
-#define carray3_size(a) ((a)._zdim * (a)._yxdim)
+#define carray3_size(a) _carray3_size(&(a)._zdim)
+
+
+enum {_carray_own = 1ull << ((sizeof(size_t) << 3) - 1)};
+
+static inline size_t _carray_ydim(const size_t* yxdim) {
+    return yxdim[0] / (yxdim[-1] & ~_carray_own);
+}
+static inline size_t _carray3_size(const size_t* zdim) {
+    return zdim[0] * zdim[-1];
+}
+
 
 #define declare_CArray(...) c_MACRO_OVERLOAD(declare_CArray, __VA_ARGS__)
 
@@ -64,90 +75,91 @@ int main()
 
 #define declare_CArray_3(tag, Value, valueDestroy) \
     typedef struct { \
-        Value *data; uint32_t owned, xdim; \
+        Value *data; \
+        size_t _xdim; \
     } CArray1_##tag; \
  \
     typedef struct { \
-        Value *data; uint32_t owned, xdim; \
-        size_t _yxdim; \
+        Value *data; \
+        size_t _xdim, _yxdim; \
     } CArray2_##tag; \
  \
     typedef struct { \
-        Value *data; uint32_t owned, xdim; \
-        size_t _yxdim; uint32_t _zdim; \
+        Value *data; \
+        size_t _xdim, _yxdim, _zdim; \
     } CArray3_##tag; \
  \
     static inline void \
     carray1_##tag##_destroy(CArray1_##tag* self) { \
         const size_t n = carray1_size(*self); Value* a = self->data; \
-        if (self->owned) {for (size_t i=0; i<n; ++i) valueDestroy(&a[i]); free(a);} \
+        if (self->_xdim & _carray_own) {for (size_t i=0; i<n; ++i) valueDestroy(&a[i]); free(a);} \
     } \
     static inline void \
     carray2_##tag##_destroy(CArray2_##tag* self) { \
         const size_t n = carray2_size(*self); Value* a = self->data; \
-        if (self->owned) {for (size_t i=0; i<n; ++i) valueDestroy(&a[i]); free(a);} \
+        if (self->_xdim & _carray_own) {for (size_t i=0; i<n; ++i) valueDestroy(&a[i]); free(a);} \
     } \
     static inline void \
     carray3_##tag##_destroy(CArray3_##tag* self) { \
         const size_t n = carray3_size(*self); Value* a = self->data; \
-        if (self->owned) {for (size_t i=0; i<n; ++i) valueDestroy(&a[i]); free(a);} \
+        if (self->_xdim & _carray_own) {for (size_t i=0; i<n; ++i) valueDestroy(&a[i]); free(a);} \
     } \
  \
     static inline CArray1_##tag \
     carray1_##tag##_make(size_t xdim, Value val) { \
-        Value* m = c_new_2(Value, xdim); \
+        Value* m = c_new_N(Value, xdim); \
         for (size_t i=0; i<xdim; ++i) m[i] = val; \
-        CArray1_##tag a = {m, true, xdim}; \
+        CArray1_##tag a = {m, xdim | _carray_own}; \
         return a; \
     } \
     static inline CArray2_##tag \
     carray2_##tag##_make(size_t ydim, size_t xdim, Value val) { \
         size_t n = ydim * xdim; \
-        Value* m = c_new_2(Value, n); \
+        Value* m = c_new_N(Value, n); \
         for (size_t i=0; i<n; ++i) m[i] = val; \
-        CArray2_##tag a = {m, true, xdim, ydim * xdim}; \
+        CArray2_##tag a = {m, xdim | _carray_own, ydim * xdim}; \
         return a; \
     } \
     static inline CArray3_##tag \
     carray3_##tag##_make(size_t zdim, size_t ydim, size_t xdim, Value val) { \
         size_t n = zdim * ydim * xdim; \
-        Value* m = c_new_2(Value, n); \
+        Value* m = c_new_N(Value, n); \
         for (size_t i=0; i<n; ++i) m[i] = val; \
-        CArray3_##tag a = {m, true, xdim, ydim * xdim, zdim}; \
+        CArray3_##tag a = {m, xdim | _carray_own, ydim * xdim, zdim}; \
         return a; \
     } \
  \
     static inline CArray1_##tag \
     carray2_##tag##_at(CArray2_##tag a, size_t y) { \
-        CArray1_##tag sub = {a.data + y*a.xdim, false, a.xdim}; \
+        CArray1_##tag sub = {a.data + y*carray_xdim(a), carray_xdim(a)}; \
         return sub; \
     } \
     static inline Value* \
     carray2_##tag##_data(CArray2_##tag a, size_t y) { \
-        return a.data + y*a.xdim; \
+        return a.data + y*carray_xdim(a); \
     } \
     static inline Value \
     carray2_##tag##_value(CArray2_##tag a, size_t y, size_t x) { \
-        return a.data[ y*a.xdim + x ]; \
+        return a.data[ y*carray_xdim(a) + x ]; \
     } \
  \
     static inline CArray2_##tag \
     carray3_##tag##_at(CArray3_##tag a, size_t z) { \
-        CArray2_##tag sub = {a.data + z*a._yxdim, false, a.xdim, a._yxdim}; \
+        CArray2_##tag sub = {a.data + z*a._yxdim, carray_xdim(a), a._yxdim}; \
         return sub; \
     } \
     static inline CArray1_##tag \
     carray3_##tag##_at2(CArray3_##tag a, size_t z, size_t y) { \
-        CArray1_##tag sub = {a.data + z*a._yxdim + y*a.xdim, false, a.xdim}; \
+        CArray1_##tag sub = {a.data + z*a._yxdim + y*carray_xdim(a), carray_xdim(a)}; \
         return sub; \
     } \
     static inline Value* \
     carray3_##tag##_data(CArray3_##tag a, size_t z, size_t y) { \
-        return a.data + z*a._yxdim + y*a.xdim; \
+        return a.data + z*a._yxdim + y*carray_xdim(a); \
     } \
     static inline Value \
     carray3_##tag##_value(CArray3_##tag a, size_t z, size_t y, size_t x) { \
-        return a.data[ z*a._yxdim + y*a.xdim + x ]; \
+        return a.data[ z*a._yxdim + y*carray_xdim(a) + x ]; \
     } \
     typedef Value CArrayValue_##tag
    
diff --git a/stc/cdefs.h b/stc/cdefs.h
index fd66e2f8..6169229b 100644
--- a/stc/cdefs.h
+++ b/stc/cdefs.h
@@ -51,25 +51,24 @@
 #define c_OVERLOAD_SELECT(NAME, NUM) c_CAT( NAME ## _, NUM)
 
 #define c_MACRO_OVERLOAD(NAME, ...) c_OVERLOAD_SELECT(NAME, c_VA_ARG_SIZE(__VA_ARGS__))(__VA_ARGS__)
+//#define test(...)     c_MACRO_OVERLOAD(test, __VA_ARGS__)  //#define test_1(x) a(x) //#define test_2(x,y) b(x,y)
 
-#define c_new(...)      c_MACRO_OVERLOAD(c_new, __VA_ARGS__)
-#define c_new_1(T)      ((T *) malloc(sizeof(T)))
-#define c_new_2(T, n)   ((T *) malloc(sizeof(T) * (n)))
+#define c_new(T)        ((T *) malloc(sizeof(T)))
+#define c_new_N(T, n)   ((T *) malloc(sizeof(T) * (n)))
 
-#define c_struct(S)     typedef struct S S; struct S
-#define                 c_max_alloca   (1000)
-#define                 c_swap(T, x, y) { T __t = x; x = y; y = __t; }
+#define c_max_alloca    (1000)
+#define c_swap(T, x, y) { T __t = x; x = y; y = __t; }
 
-#define                 c_defaultInitRaw(x)    (x)
-#define                 c_defaultGetRaw(ptr)   (*(ptr))
-#define                 c_defaultCompare(x, y) (*(x) == *(y) ? 0 : *(x) < *(y) ? -1 : 1)
-#define                 c_noCompare(x, y)      (0)
-#define                 c_defaultEquals(x, y)  (*(x) == *(y))
-#define                 c_memEquals(x, y)      (memcmp(x, y, sizeof(*(y))) == 0)
-#define                 c_emptyDestroy(p)      ((void)0)
+#define c_defaultInitRaw(x)    (x)
+#define c_defaultGetRaw(ptr)   (*(ptr))
+#define c_defaultCompare(x, y) (*(x) == *(y) ? 0 : *(x) < *(y) ? -1 : 1)
+#define c_noCompare(x, y)      (0)
+#define c_defaultEquals(x, y)  (*(x) == *(y))
+#define c_memEquals(x, y)      (memcmp(x, y, sizeof(*(y))) == 0)
+#define c_emptyDestroy(p)      ((void)0)
 
-#define                 c_foreach(it, prefix, container) \
-                            for (prefix##_iter_t it = prefix##_begin(&container); it.item; it = prefix##_next(it))
+#define c_foreach(it, prefix, container) \
+            for (prefix##_iter_t it = prefix##_begin(&container); it.item; it = prefix##_next(it))
 
 /* One-byte-at-a-time hash based on Murmur's mix */
 static inline uint32_t  c_defaultHash(const void *data, size_t len) {
diff --git a/stc/chash.h b/stc/chash.h
index 8157b2c2..8e17d071 100644
--- a/stc/chash.h
+++ b/stc/chash.h
@@ -288,7 +288,7 @@ chash_##tag##_reserve(CHash_##tag* self, size_t newcap) { \
     size_t oldcap = chash_bucketCount(*self); newcap |= 1; \
     if (chash_size(*self) >= newcap * self->maxLoadPercent * 0.01) return oldcap; \
     CHash_##tag tmp = { \
-        c_new_2(CHashEntry_##tag, newcap), \
+        c_new_N(CHashEntry_##tag, newcap), \
         (uint8_t *) calloc(newcap, sizeof(uint8_t)), \
         self->_size, (uint32_t) newcap, \
         self->maxLoadPercent, self->shrinkLimitPercent \
diff --git a/stc/clist.h b/stc/clist.h
index 81af6e53..4dcd6e26 100644
--- a/stc/clist.h
+++ b/stc/clist.h
@@ -227,7 +227,7 @@
     }
 
 #define _clist_insertAfter(self, tag, node, val) \
-    CListNode_##tag *entry = c_new_1(CListNode_##tag), \
+    CListNode_##tag *entry = c_new (CListNode_##tag), \
                     *next = self->last ? node->next : entry; \
     entry->value = val; \
     entry->next = next; \
-- 
cgit v1.2.3