Improved representation storage for CArray. Stores "owned" as highest bit in xdim.

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; \