carray 3.0.2 → 3.0.4

data/ext/ca_obj_string.c

@@ -11,7 +11,7 @@
 
   Surface data_type is CA_OBJECT (== storage): unlike the NonNumeric Faces
   (CATime etc.) there is no CA_FIXLEN gate.  Per-cell fetch returns
-  the stored String VALUE directly (no storage_to_scalar decode).  Numeric
+  the stored String VALUE directly (no storage_to_element decode).  Numeric
   dispatch lands on the :object kernels, so String-meaningful ops (+, sort
   via <=>) work and nonsensical ones raise at the Ruby method call.
 
@@ -20,6 +20,7 @@
 --------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"
 #include "ca_obj_face.h"
 
 typedef struct {
@@ -75,7 +76,7 @@ const rb_data_type_t castring_data_type = {
     .flags = RUBY_TYPED_FREE_IMMEDIATELY
 };
 
-static int8_t CA_OBJ_STRING;
+int8_t CA_OBJ_STRING;     /* non-static: read by the store path in carray_access.c */
 static VALUE rb_cCAString;
 
 /* ------------------------------------------------------------------- */
@@ -88,6 +89,12 @@ ca_string_setup (CAString *ca, CArray *parent)
              "CAString requires object storage (parent.data_type != CA_OBJECT)");
   }
 
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
+  }
+
   ca->obj_type  = CA_OBJ_STRING;
   ca->data_type = CA_OBJECT;
   /* ORDERABLE + COMPARABLE, and both hold by construction: a storage cell
@@ -112,9 +119,6 @@ ca_string_setup (CAString *ca, CArray *parent)
   ca->attach    = 0;
   ca->nosync    = 0;
 
-  if ( ca_has_mask(parent) ) {
-    ca_create_mask((CArray *) ca);
-  }
 
   if ( ca_is_scalar(parent) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
@@ -130,8 +134,11 @@ ca_string_setup (CAString *ca, CArray *parent)
 CAString *
 ca_string_new (CArray *parent)
 {
-  CAString *ca = (CAString *) ca_array_alloc(CA_OBJ_STRING, parent->ndim);
+  CAString *ca;
+  ca_string_setup(NULL, parent);
+  ca = (CAString *) ca_array_alloc(CA_OBJ_STRING, parent->ndim);
   ca_string_setup(ca, parent);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -169,18 +176,6 @@ ca_string_func_allocate (void *ap)
   ca->ptr = ca->parent->ptr;
 }
 
-static void
-ca_string_func_create_mask (void *ap)
-{
-  CAString *ca = (CAString *) ap;
-  ca_update_mask(ca->parent);
-  if ( ! ca->parent->mask ) {
-    ca_create_mask(ca->parent);
-  }
-  ca->mask = (CArray *) ca_refer_new(ca->parent->mask,
-                                      CA_BOOLEAN, ca->ndim, ca->dim, 0, 0);
-}
-
 ca_operation_function_t ca_string_func = {
   -1, /* CA_OBJ_STRING — filled by ca_install_obj_type */
   CA_VIEW_ARRAY,
@@ -191,7 +186,7 @@ ca_operation_function_t ca_string_func = {
   ca_face_sync,
   ca_face_detach,
   ca_face_fill_data,
-  ca_string_func_create_mask,
+  ca_view_func_create_mask,
   ca_face_xfer_index,
   ca_face_xfer_addrs,
   NULL,                              /* fold_stride: identity Face is not foldable */
@@ -203,6 +198,69 @@ ca_operation_function_t ca_string_func = {
 
 /* ------------------------------------------------------------------- */
 
+/* A CAString cell is a String; UNDEF (a masked cell) is no value.  Refuse
+   anything else, naming what it is, so a cell of a CAString always answers
+   the String operations. */
+NORETURN(static void ca_string_refuse_cell (VALUE v, const char *where));
+
+static void
+ca_string_refuse_cell (VALUE v, const char *where)
+{
+  if ( NIL_P(v) ) {
+    rb_raise(rb_eTypeError,
+             "%s is nil, not a String (a CAString holds Strings; "
+             "UNDEF masks a cell)", where);
+  }
+  rb_raise(rb_eTypeError,
+           "%s is of class %s, not a String (a CAString holds Strings; "
+           "UNDEF masks a cell)", where, rb_obj_classname(v));
+}
+
+/* Every cell of `parent` that is not masked is a String. */
+static void
+ca_string_check_cells (VALUE parent_val, CArray *parent)
+{
+  ca_size_t i;
+  char where[64];
+  if ( ca_is_entity(parent) && parent->ptr ) {
+    VALUE *p = (VALUE *) parent->ptr;
+    boolean8_t *m = ( parent->mask && parent->mask->ptr )
+                    ? (boolean8_t *) parent->mask->ptr : NULL;
+    for (i = 0; i < parent->elements; i++) {
+      if ( m && m[i] ) continue;
+      if ( ! RB_TYPE_P(p[i], T_STRING) ) {
+        snprintf(where, sizeof(where), "cell %" PRId64, (int64_t) i);
+        ca_string_refuse_cell(p[i], where);
+      }
+    }
+  }
+  else {
+    volatile VALUE list =
+      rb_funcall(rb_funcall(parent_val, rb_intern("flatten"), 0),
+                 rb_intern("to_a"), 0);
+    long n = RARRAY_LEN(list), j;
+    for (j = 0; j < n; j++) {
+      VALUE v = rb_ary_entry(list, j);
+      if ( v == CA_UNDEF ) continue;
+      if ( ! RB_TYPE_P(v, T_STRING) ) {
+        snprintf(where, sizeof(where), "cell %ld", j);
+        ca_string_refuse_cell(v, where);
+      }
+    }
+  }
+}
+
+/* The write hook: a value stored into a CAString is a String. */
+static VALUE
+ca_string_element_to_storage (VALUE self, VALUE v)
+{
+  (void) self;
+  if ( ! RB_TYPE_P(v, T_STRING) ) {
+    ca_string_refuse_cell(v, "a value stored into a CAString");
+  }
+  return v;
+}
+
 /* CAString.wrap(object_array) — zero-copy Face wrap of a CA_OBJECT array */
 VALUE
 rb_ca_string_wrap (VALUE parent_val)
@@ -214,6 +272,8 @@ rb_ca_string_wrap (VALUE parent_val)
   rb_check_carray_object(parent_val);
   TypedData_Get_Struct(parent_val, CArray, &carray_data_type, parent);
 
+  ca_string_setup(NULL, parent);
+  ca_string_check_cells(parent_val, parent);
   ca  = ca_string_new(parent);
   obj = ca_wrap_struct(ca);
   rb_ca_set_parent(obj, parent_val);
@@ -239,11 +299,13 @@ rb_ca_string_initialize_copy (VALUE self, VALUE other)
 {
   CAString *ca, *cs;
   TypedData_Get_Struct(self,  CAString, &castring_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CAString, &castring_data_type, cs);
   if ( ca_func[CA_OBJ_STRING].pool_init ) {
     ca_array_pool_alloc(ca, CA_OBJ_STRING, cs->parent->ndim);
   }
   ca_string_setup(ca, cs->parent);
+  ca_view_inherit_mask((VALUE) ca);
   return self;
 }
 
@@ -268,7 +330,11 @@ Init_ca_obj_string (void)
                                  rb_ca_string_initialize_copy, 1);
   rb_define_singleton_method(rb_cCAString, "wrap", rb_ca_string_wrap_method, 1);
 
-  /* VALUE storage is per-process, so the Face cannot be carried across
-     multi-parent constructions (CAStack / Marshal / MemoryView). */
-  ca_face_register_state_portable(CA_OBJ_STRING, 0);
+  ca_face_register_element_to_storage(CA_OBJ_STRING,
+                                      ca_string_element_to_storage);
+
+  /* A cell is the String itself, so the Face is the same over any parent:
+     CAStack / CAMeld / concatenate can carry it (unlike CAConstString, whose
+     cells point into one parent's buffer). */
+  ca_face_register_state_portable(CA_OBJ_STRING, 1);
 }

data/ext/ca_obj_tile.c

@@ -16,6 +16,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"
 #include "ca_composite_dispatch.h"
 #include "ca_obj_face.h"  /* CA_FACE_LIFT_IF_FACE */
 
@@ -75,17 +76,24 @@ ca_tile_setup (CATile *ca, CArray *parent, ca_size_t *reps)
   ndim      = parent->ndim;
   bytes     = parent->bytes;
 
-  elements = 1;
-  for (i = 0; i < ndim; i++) {
-    if ( reps[i] <= 0 ) {
-      rb_raise(rb_eIndexError,
-               "invalid reps for %d-th dimension (must be positive)", i);
-    }
-    if ( parent->dim[i] <= 0 ) {
-      rb_raise(rb_eIndexError,
-               "invalid parent dim for %d-th dimension", i);
+  {
+    ca_size_t tiled[CA_RANK_MAX];
+    for (i = 0; i < ndim; i++) {
+      if ( reps[i] <= 0 ) {
+        rb_raise(rb_eIndexError,
+                 "invalid reps for %d-th dimension (must be positive)", i);
+      }
+      if ( __builtin_mul_overflow(parent->dim[i], reps[i], &tiled[i]) ) {
+        rb_raise(rb_eArgError, "too large byte length");
+      }
     }
-    elements *= parent->dim[i] * reps[i];
+    elements = ca_shape_elements(ndim, tiled, bytes);
+  }
+
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
   }
 
   ca->obj_type  = CA_OBJ_TILE;
@@ -108,9 +116,6 @@ ca_tile_setup (CATile *ca, CArray *parent, ca_size_t *reps)
     ca->dim[i]  = parent->dim[i] * reps[i];
   }
 
-  if ( ca_has_mask(parent) ) {
-    ca_create_mask(ca);
-  }
 
   return 0;
 }
@@ -118,8 +123,11 @@ ca_tile_setup (CATile *ca, CArray *parent, ca_size_t *reps)
 CATile *
 ca_tile_new (CArray *parent, ca_size_t *reps)
 {
-  CATile *ca = ALLOC(CATile);
+  CATile *ca;
+  ca_tile_setup(NULL, parent, reps);
+  ca = ALLOC(CATile);
   ca_tile_setup(ca, parent, reps);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -196,6 +204,7 @@ static void
 ca_tile_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
                           ca_size_t *strides, void *data, int dir)
 {
+  if ( ca_region_is_empty(((CArray *) ap)->ndim, counts) ) return;
   CATile   *ca = (CATile *) ap;
   CArray   *parent = ca->parent;
   int8_t    ndim = ca->ndim;
@@ -233,6 +242,7 @@ ca_tile_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
     ca_size_t idx[CA_RANK_MAX], doff = 0, base = 0;
     for (k = 0; k < ndim; k++) base += starts[k] * tnative[k];
     for (k = 0; k < ndim; k++) idx[k] = 0;
+    /* empty: the slot returns on an empty region at its entry */
     while (1) {
       ca_size_t toff = base, tidx[CA_RANK_MAX];
       for (k = 0; k < ndim; k++) toff += idx[k] * strides[k];
@@ -247,6 +257,7 @@ ca_tile_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   }
 
   for (k = 0; k < ndim; k++) o[k] = 0;
+  /* empty: the slot returns on an empty region at its entry */
   while (1) {
     ca_size_t pbase = 0, doff = 0, i;
     for (k = 0; k < inner; k++) {
@@ -392,7 +403,7 @@ ca_tile_func_allocate (void *ap)
 {
   CATile *ca = (CATile *) ap;
   ca_attach(ca->parent);
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
 }
 
 static void
@@ -400,7 +411,7 @@ ca_tile_func_attach (void *ap)
 {
   CATile *ca = (CATile *) ap;
   ca_attach(ca->parent);
-  ca->ptr = xmalloc(ca_length(ca));
+  ca->ptr = ca_alloc_cells((CArray *) ca);
   ca_tile_attach_into(ca, ca->ptr);
 }
 
@@ -445,10 +456,13 @@ ca_tile_func_xfer_all (void *ap, void *data, int dir)
     parent->ptr = parent_scratch;
     if ( dir == CA_XFER_GET ) ca_tile_attach_into(ca, (char *) data);
     else                       ca_tile_sync_from(ca, (char *) data);
+    /* Put parent->ptr back before the PUT: the PUT can raise (a lazy
+       backing's sync failing), and the scratch is gone once this
+       frame is. */
+    parent->ptr = parent_ptr_saved;
     if ( dir == CA_XFER_PUT ) {
       ca_xfer_all(parent, parent_scratch, CA_XFER_PUT);
     }
-    parent->ptr = parent_ptr_saved;
     ALLOCV_END(holder);
   }
 }
@@ -466,10 +480,7 @@ static void
 ca_tile_func_create_mask (void *ap)
 {
   CATile *ca = (CATile *) ap;
-  ca_update_mask(ca->parent);
-  if ( ! ca->parent->mask ) {
-    ca_create_mask(ca->parent);
-  }
+  ca_create_mask(ca->parent);
   ca->mask = (CArray *) ca_tile_new(ca->parent->mask, ca->reps);
 }
 
@@ -571,11 +582,14 @@ rb_ca_tile_initialize_copy (VALUE self, VALUE other)
 {
   CATile *ca, *cs;
   TypedData_Get_Struct(self,  CATile, &catile_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CATile, &catile_data_type, cs);
   ca_tile_setup(ca, cs->parent, cs->reps);
+  ca_view_inherit_mask((VALUE) ca);
   return self;
 }
 
+#ifdef CARRAY_DEV_BUILD
 /* Debug-only accessor returning the tile descriptor as a Hash.
    Naming: leading underscore signals internal use. */
 static VALUE
@@ -597,6 +611,7 @@ rb_ca_tile_descriptor (VALUE self)
   rb_hash_aset(hash, ID2SYM(rb_intern("ndim")), INT2NUM(ca->ndim));
   return hash;
 }
+#endif
 
 void
 Init_ca_obj_tile (void)
@@ -616,7 +631,9 @@ Init_ca_obj_tile (void)
   rb_define_method(rb_cCATile, "initialize_copy",
                                       rb_ca_tile_initialize_copy, 1);
 
+#ifdef CARRAY_DEV_BUILD
   /* Debug-only descriptor accessor. */
   rb_define_method(rb_cCATile, "_tile_descriptor",
                                       rb_ca_tile_descriptor, 0);
+#endif
 }

data/ext/ca_obj_time.c

@@ -14,6 +14,7 @@
 --------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"
 #include "ca_obj_face.h"
 
 /* unit enum (base epoch is 1970-01-01) */
@@ -36,7 +37,7 @@ enum {
 typedef struct {
   /* === CAView prefix === */
   int16_t    obj_type;
-  int8_t     data_type;        /* fixed to CA_INT64 */
+  int8_t     data_type;        /* surface: CA_FIXLEN (storage is the int64 parent) */
   int8_t     ndim;
   int32_t    flags;            /* CA_FLAG_IS_FACE set */
   ca_size_t  bytes;            /* fixed to sizeof(int64_t) */
@@ -153,6 +154,21 @@ rb_ca_time_element_initialize (VALUE self, VALUE value, VALUE unit)
   return self;
 }
 
+/* dup / clone copy the value and the unit (the allocator leaves both 0). */
+static VALUE
+rb_ca_time_element_initialize_copy (VALUE self, VALUE orig)
+{
+  CATimeElement *s, *o;
+  if ( self == orig ) {
+    return self;
+  }
+  rb_check_frozen(self);
+  TypedData_Get_Struct(self, CATimeElement, &catime_element_data_type, s);
+  TypedData_Get_Struct(orig, CATimeElement, &catime_element_data_type, o);
+  *s = *o;
+  return self;
+}
+
 static VALUE
 rb_ca_time_element_value (VALUE self)
 {
@@ -182,6 +198,12 @@ ca_time_setup (CATime *ca, CArray *parent, int8_t unit, int64_t count)
              "CATime requires int64 storage (parent.data_type != CA_INT64)");
   }
 
+  /* ca == NULL asks for the checks above only, so that a constructor can
+     run them before it allocates. */
+  if ( ca == NULL ) {
+    return 0;
+  }
+
   ca->obj_type  = CA_OBJ_TIME;
   /* The surface data_type is CA_FIXLEN, not CA_INT64: this routes
      mkkernel dispatch onto the ca_*_not_implement stubs so numeric
@@ -209,9 +231,6 @@ ca_time_setup (CATime *ca, CArray *parent, int8_t unit, int64_t count)
   ca->unit      = unit;
   ca->count     = count;
 
-  if ( ca_has_mask(parent) ) {
-    ca_create_mask((CArray *) ca);
-  }
 
   if ( ca_is_scalar(parent) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
@@ -227,8 +246,11 @@ ca_time_setup (CATime *ca, CArray *parent, int8_t unit, int64_t count)
 CATime *
 ca_time_new (CArray *parent, int8_t unit, int64_t count)
 {
-  CATime *ca = (CATime *) ca_array_alloc(CA_OBJ_TIME, parent->ndim);
+  CATime *ca;
+  ca_time_setup(NULL, parent, unit, count);
+  ca = (CATime *) ca_array_alloc(CA_OBJ_TIME, parent->ndim);
   ca_time_setup(ca, parent, unit, count);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -266,18 +288,6 @@ ca_time_func_allocate (void *ap)
   ca->ptr = ca->parent->ptr;
 }
 
-static void
-ca_time_func_create_mask (void *ap)
-{
-  CATime *ca = (CATime *) ap;
-  ca_update_mask(ca->parent);
-  if ( ! ca->parent->mask ) {
-    ca_create_mask(ca->parent);
-  }
-  ca->mask = (CArray *) ca_refer_new(ca->parent->mask,
-                                      CA_BOOLEAN, ca->ndim, ca->dim, 0, 0);
-}
-
 ca_operation_function_t ca_time_func = {
   -1, /* CA_OBJ_TIME — filled by ca_install_obj_type */
   CA_VIEW_ARRAY,
@@ -288,7 +298,7 @@ ca_operation_function_t ca_time_func = {
   ca_face_sync,
   ca_face_detach,
   ca_face_fill_data,
-  ca_time_func_create_mask,
+  ca_view_func_create_mask,
   ca_face_xfer_index,
   ca_face_xfer_addrs,
   NULL,                              /* fold_stride: identity Face is not foldable */
@@ -401,7 +411,7 @@ rb_ca_time_wrap (VALUE parent_val, int8_t unit, int64_t count)
   return obj;
 }
 
-/* __wrap__(raw, unit_spec) — primitive; unit_spec is Symbol / String /
+/* wrap_storage(raw, unit_spec) — primitive; unit_spec is Symbol / String /
    Resolution / nil (normalized here). */
 static VALUE
 rb_ca_time_wrap_method (VALUE klass, VALUE raw, VALUE unit_spec)
@@ -422,16 +432,16 @@ rb_ca_time_unit (VALUE self)
   return ca_time_resolution(ca->count, ca->unit);
 }
 
-/* storage_to_scalar implemented in C to avoid per-cell Ruby method dispatch
-   on the fetch hot path.  CAREFUL: there must be no Ruby `storage_to_scalar`
+/* storage_to_element implemented in C to avoid per-cell Ruby method dispatch
+   on the fetch hot path.  CAREFUL: there must be no Ruby `storage_to_element`
    def in lib/carray/time.rb — require order would let a Ruby version
-   shadow this C method (the Ruby `scalar_to_storage` write hook is a
+   shadow this C method (the Ruby `element_to_storage` write hook is a
    distinct method and does not collide).
    Since the Face surface is CA_FIXLEN, fetch delivers an 8-byte raw
    String.  Decode it as the parent int64 (= storage), then construct
    CATime::Element(epoch, unit). */
 static VALUE
-rb_ca_time_storage_to_scalar (VALUE self, VALUE raw)
+rb_ca_time_storage_to_element (VALUE self, VALUE raw)
 {
   CATime *ca;
   CATimeElement *s;
@@ -443,7 +453,7 @@ rb_ca_time_storage_to_scalar (VALUE self, VALUE raw)
   if ( TYPE(raw) == T_STRING ) {
     if ( RSTRING_LEN(raw) != (long) sizeof(int64_t) ) {
       rb_raise(rb_eArgError,
-               "CATime#storage_to_scalar: expected %lu bytes, got %ld",
+               "CATime#storage_to_element: expected %lu bytes, got %ld",
                (unsigned long) sizeof(int64_t), RSTRING_LEN(raw));
     }
     memcpy(&epoch, RSTRING_PTR(raw), sizeof(int64_t));
@@ -476,11 +486,13 @@ rb_ca_time_initialize_copy (VALUE self, VALUE other)
 {
   CATime *ca, *cs;
   TypedData_Get_Struct(self,  CATime, &catime_data_type, ca);
+  ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CATime, &catime_data_type, cs);
   if ( ca_func[CA_OBJ_TIME].pool_init ) {
     ca_array_pool_alloc(ca, CA_OBJ_TIME, cs->parent->ndim);
   }
   ca_time_setup(ca, cs->parent, cs->unit, cs->count);
+  ca_view_inherit_mask((VALUE) ca);
   return self;
 }
 
@@ -514,15 +526,15 @@ Init_ca_obj_time (void)
   rb_define_method(rb_cCATime, "initialize_copy",
                                      rb_ca_time_initialize_copy, 1);
 
-  rb_define_singleton_method(rb_cCATime, "__wrap__",
-                                     rb_ca_time_wrap_method, 2);
+  rb_define_private_method(rb_singleton_class(rb_cCATime), "wrap_storage",
+                           rb_ca_time_wrap_method, 2);
   rb_define_method(rb_cCATime, "unit", rb_ca_time_unit, 0);
-  rb_define_method(rb_cCATime, "storage_to_scalar",
-                                     rb_ca_time_storage_to_scalar, 1);
-  /* Registers the C-level fast path so CA_FACE_STORAGE_TO_SCALAR_IF_FACE can
+  rb_define_method(rb_cCATime, "storage_to_element",
+                                     rb_ca_time_storage_to_element, 1);
+  /* Registers the C-level fast path so CA_FACE_STORAGE_TO_ELEMENT_IF_FACE can
      skip rb_funcall on the hot path. */
-  ca_face_register_storage_to_scalar(CA_OBJ_TIME,
-                                     rb_ca_time_storage_to_scalar);
+  ca_face_register_storage_to_element(CA_OBJ_TIME,
+                                     rb_ca_time_storage_to_element);
   ca_face_register_state_compatible(CA_OBJ_TIME,
                                     ca_time_state_compatible);
   /* unit is pure metadata (= no per-parent buffer), so the Face wrap can
@@ -541,6 +553,8 @@ Init_ca_obj_time (void)
                        rb_ca_time_element_s_allocate);
   rb_define_method(rb_cCATimeElement, "initialize",
                    rb_ca_time_element_initialize, 2);
+  rb_define_method(rb_cCATimeElement, "initialize_copy",
+                   rb_ca_time_element_initialize_copy, 1);
   rb_define_method(rb_cCATimeElement, "value",
                    rb_ca_time_element_value, 0);
   rb_define_method(rb_cCATimeElement, "unit",