carray 3.0.3 → 3.0.4

data/ext/carray_lazy.c

@@ -1,6 +1,6 @@
 /* ---------------------------------------------------------------------------
 
-  CALazyMarker view + the shared lazy arena.
+  CALazyMarker view + the lazy arena.
 
   CALazyMarker is a zero-cost marker that holds a CArray entity and
   causes `.sqrt` / `.sin` / etc. on it to build a lazy CAMonOp tree
@@ -11,7 +11,7 @@
   is a pure pass-through: every CArray operation delegates to the
   parent.  Detection happens via ca_is_lazy_view().
 
-  ca_lazy_arena is the shared slot-pool arena that CAMonOp / CABinOp
+  ca_lazy_arena is the per-Ractor slot-pool arena that CAMonOp / CABinOp
   / CAMonCmp / CABinCmp use for scratch during to_ca; slot buffers
   stay alive across calls to amortise mmap into steady-state reuse.
 
@@ -80,10 +80,6 @@ ca_lazy_marker_setup (CALazyMarker *ca, CArray *parent)
 
   memcpy(ca->dim, parent->dim, parent->ndim * sizeof(ca_size_t));
 
-  if ( ca_has_mask(parent) ) {
-    ca_create_mask(ca);
-  }
-
   if ( ca_is_scalar(parent) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
   }
@@ -105,8 +101,10 @@ ca_lazy_marker_setup (CALazyMarker *ca, CArray *parent)
 CALazyMarker *
 ca_lazy_marker_new (CArray *parent)
 {
+  /* check: the setup checks nothing */
   CALazyMarker *ca = ALLOC(CALazyMarker);
   ca_lazy_marker_setup(ca, parent);
+  ca_fill_or_free((CArray *) ca, ca_view_inherit_mask, (VALUE) ca);
   return ca;
 }
 
@@ -360,7 +358,6 @@ ca_gc_local (void)
   return g;
 }
 
-static void ca_lazy_arena_mark_object_slots (void);
 
 /* Returns the depth to hand back to ca_gc_hold_pop_to, so nested holds
    unwind in order.  Pushing is best-effort at the ceiling: a chain
@@ -437,32 +434,6 @@ ca_gc_release_buffer (void *ptr)
   }
 }
 
-static VALUE ca_gc_guard = Qnil;
-
-/* The wrapped pointer must be non-NULL: Ruby's GC skips the mark
-   function of a TypedData whose data pointer is NULL. */
-static int ca_gc_guard_body = 0;
-
-/* The arena's object slots.  The holds are marked per Ractor above. */
-static void
-ca_gc_guard_mark (void *ptr)
-{
-  (void) ptr;
-  ca_lazy_arena_mark_object_slots();
-}
-
-static void
-ca_gc_guard_free (void *ptr)
-{
-  (void) ptr;
-}
-
-static const rb_data_type_t ca_gc_guard_data_type = {
-  "carray_object_gc_guard",
-  { ca_gc_guard_mark, ca_gc_guard_free, NULL, },
-  0, 0, RUBY_TYPED_FREE_IMMEDIATELY
-};
-
 /* ------------------------------------------------------------------- */
 /* ca_lazy_arena                                                        */
 /* ------------------------------------------------------------------- */
@@ -485,12 +456,13 @@ static const rb_data_type_t ca_gc_guard_data_type = {
    as the largest request it has served (e.g. N=1M f64, depth-8 chain =
    8 × 8MB = 64MB kept resident).  A request no free slot can hold grows
    a free slot; a new slot opens only while every warm one is in use.
-   When all 32 are in use the acquire raises: this signals a programming
+   Past 256 MB the idle slots are given back at the next top-level entry
+   (ca_lazy_arena_trim).  When all 32 are in use the acquire raises: this signals a programming
    error or a pathological chain rather than a graceful fallback.
 
-   CAREFUL: single-thread only -- thread-safety across concurrent access
-   is not a goal (see guides/devel/04_attach_lifecycle.md).  The arena is
-   process-global static state. */
+   One arena per Ractor (see ca_lazy_arena_get).  Within a Ractor it is
+   not guarded: thread-safety across concurrent access is not a goal (see
+   guides/devel/04_attach_lifecycle.md). */
 
 #define CA_LAZY_ARENA_SLOTS 32
 
@@ -509,29 +481,109 @@ typedef struct ca_lazy_arena {
   ca_size_t debug_reuse_count;            /* test: how many acquire = reuse */
 } ca_lazy_arena_t;
 
-static ca_lazy_arena_t ca_lazy_arena = {0};
+/* One arena per Ractor: the slots are handed out by pointer and toggled
+   without a lock, so two Ractors sharing them would hand the same buffer
+   to both.  The storage marks the object slots in use and frees the
+   buffers when the Ractor ends. */
+static rb_ractor_local_key_t ca_lazy_arena_key;
+
+static void ca_lazy_arena_mark_object_slots (ca_lazy_arena_t *arena);
+
+static void
+ca_lazy_arena_mark (void *ptr)
+{
+  if ( ptr ) ca_lazy_arena_mark_object_slots((ca_lazy_arena_t *) ptr);
+}
+
+static void
+ca_lazy_arena_free (void *ptr)
+{
+  ca_lazy_arena_t *arena = (ca_lazy_arena_t *) ptr;
+  int i;
+  if ( arena == NULL ) return;
+  for ( i = 0; i < CA_LAZY_ARENA_SLOTS; i++ ) {
+    if ( arena->slots[i].ptr ) ruby_xfree(arena->slots[i].ptr);
+  }
+  ruby_xfree(arena);
+}
+
+static const struct rb_ractor_local_storage_type ca_lazy_arena_type = {
+  ca_lazy_arena_mark, ca_lazy_arena_free
+};
+
+static ca_lazy_arena_t *
+ca_lazy_arena_get (void)
+{
+  ca_lazy_arena_t *arena =
+    (ca_lazy_arena_t *) rb_ractor_local_storage_ptr(ca_lazy_arena_key);
+  if ( arena == NULL ) {
+    arena = ZALLOC(ca_lazy_arena_t);
+    rb_ractor_local_storage_ptr_set(ca_lazy_arena_key, arena);
+  }
+  return arena;
+}
+
+/* Above this the arena returns memory: the idle slots are freed, the
+   smallest first, until what it holds is under the limit.  The largest
+   slot is always kept, so a workload that repeats one request keeps its
+   warm buffer however large it is. */
+#define CA_LAZY_ARENA_KEEP_BYTES ((ca_size_t) 256 << 20)
+
+static void
+ca_lazy_arena_trim (ca_lazy_arena_t *arena)
+{
+  ca_size_t total = 0;
+  int i, largest = -1;
+  for ( i = 0; i < CA_LAZY_ARENA_SLOTS; i++ ) {
+    if ( arena->slots[i].ptr == NULL ) continue;
+    total += arena->slots[i].bytes;
+    if ( largest < 0 || arena->slots[i].bytes > arena->slots[largest].bytes ) {
+      largest = i;
+    }
+  }
+  while ( total > CA_LAZY_ARENA_KEEP_BYTES ) {
+    int smallest = -1;
+    for ( i = 0; i < CA_LAZY_ARENA_SLOTS; i++ ) {
+      ca_lazy_arena_slot_t *s = &arena->slots[i];
+      if ( s->ptr == NULL || s->in_use || i == largest ) continue;
+      if ( smallest < 0 || s->bytes < arena->slots[smallest].bytes ) {
+        smallest = i;
+      }
+    }
+    if ( smallest < 0 ) break;
+    total -= arena->slots[smallest].bytes;
+    xfree(arena->slots[smallest].ptr);
+    arena->slots[smallest].ptr   = NULL;
+    arena->slots[smallest].bytes = 0;
+  }
+}
 
 void
 ca_lazy_arena_enter (void)
 {
-  if ( ca_lazy_arena.depth == 0 ) {
+  ca_lazy_arena_t *arena = ca_lazy_arena_get();
+  if ( arena->depth == 0 ) {
+    /* Only a slot no one holds is freed: a lazy view's attach takes
+       scratch outside any enter / exit bracket. */
+    ca_lazy_arena_trim(arena);
     /* Top-level reset to recover from a prior exception that left
        slots in_use without a matching release.  Safe because
        depth==0 means no nested caller is mid-acquire. */
     int i;
     for ( i = 0; i < CA_LAZY_ARENA_SLOTS; i++ ) {
-      ca_lazy_arena.slots[i].in_use = 0;
-      ca_lazy_arena.slots[i].object_elements = 0;
+      arena->slots[i].in_use = 0;
+      arena->slots[i].object_elements = 0;
     }
   }
-  ca_lazy_arena.depth++;
+  arena->depth++;
 }
 
 void
 ca_lazy_arena_exit (void)
 {
-  if ( ca_lazy_arena.depth > 0 ) {
-    ca_lazy_arena.depth--;
+  ca_lazy_arena_t *arena = ca_lazy_arena_get();
+  if ( arena->depth > 0 ) {
+    arena->depth--;
   }
   /* Keep all slot buffers, and leave in_use and the object tags alone.
      A scratch can be acquired outside any enter/exit bracket -- a lazy
@@ -599,12 +651,13 @@ ca_lazy_arena_release_held (VALUE arg)
 void *
 ca_lazy_arena_acquire (ca_size_t bytes)
 {
+  ca_lazy_arena_t *arena = ca_lazy_arena_get();
   int i, best, empty;
   ca_size_t best_bytes;
 
   if ( bytes <= 0 ) bytes = 1;
 
-  ca_lazy_arena.debug_acquire_count++;
+  arena->debug_acquire_count++;
 
   /* Pass 1: best-fit among unused warm slots (smallest >= bytes).
      CAREFUL: ca_size_t is signed int64_t, so the "no match yet"
@@ -613,7 +666,7 @@ ca_lazy_arena_acquire (ca_size_t bytes)
   best = -1;
   best_bytes = CA_LENGTH_MAX;
   for ( i = 0; i < CA_LAZY_ARENA_SLOTS; i++ ) {
-    ca_lazy_arena_slot_t *s = &ca_lazy_arena.slots[i];
+    ca_lazy_arena_slot_t *s = &arena->slots[i];
     if ( s->in_use ) continue;
     if ( s->ptr == NULL ) continue;
     if ( s->bytes < bytes ) continue;
@@ -623,10 +676,10 @@ ca_lazy_arena_acquire (ca_size_t bytes)
     }
   }
   if ( best >= 0 ) {
-    ca_lazy_arena.slots[best].in_use = 1;
-    ca_lazy_arena.slots[best].object_elements = 0;
-    ca_lazy_arena.debug_reuse_count++;
-    return ca_lazy_arena.slots[best].ptr;
+    arena->slots[best].in_use = 1;
+    arena->slots[best].object_elements = 0;
+    arena->debug_reuse_count++;
+    return arena->slots[best].ptr;
   }
 
 
@@ -642,7 +695,7 @@ ca_lazy_arena_acquire (ca_size_t bytes)
   best = -1;
   best_bytes = -1;
   for ( i = 0; i < CA_LAZY_ARENA_SLOTS; i++ ) {
-    ca_lazy_arena_slot_t *s = &ca_lazy_arena.slots[i];
+    ca_lazy_arena_slot_t *s = &arena->slots[i];
     if ( s->in_use || s->ptr == NULL ) continue;
     if ( s->bytes > best_bytes ) {
       best = i;
@@ -650,34 +703,34 @@ ca_lazy_arena_acquire (ca_size_t bytes)
     }
   }
   if ( best >= 0 ) {
-    ca_lazy_arena_slot_t *s = &ca_lazy_arena.slots[best];
+    ca_lazy_arena_slot_t *s = &arena->slots[best];
     void *old = s->ptr;
     s->ptr   = NULL;
     s->bytes = 0;
     xfree(old);
-    s->ptr    = xmalloc(bytes);
+    s->ptr    = xmalloc(bytes);  /* cells: ca_lazy_arena_acquire_object clears object slots */
     s->bytes  = bytes;
     s->in_use = 1;
     s->object_elements = 0;
-    ca_lazy_arena.debug_xmalloc_count++;
+    arena->debug_xmalloc_count++;
     return s->ptr;
   }
 
   /* Pass 3: every warm slot is in use.  Open an empty one. */
   empty = -1;
   for ( i = 0; i < CA_LAZY_ARENA_SLOTS; i++ ) {
-    if ( ca_lazy_arena.slots[i].ptr == NULL ) {
+    if ( arena->slots[i].ptr == NULL ) {
       empty = i;
       break;
     }
   }
   if ( empty >= 0 ) {
-    ca_lazy_arena.slots[empty].ptr    = xmalloc(bytes);
-    ca_lazy_arena.slots[empty].bytes  = bytes;
-    ca_lazy_arena.slots[empty].in_use = 1;
-    ca_lazy_arena.slots[empty].object_elements = 0;
-    ca_lazy_arena.debug_xmalloc_count++;
-    return ca_lazy_arena.slots[empty].ptr;
+    arena->slots[empty].ptr    = xmalloc(bytes);  /* cells: ca_lazy_arena_acquire_object clears object slots */
+    arena->slots[empty].bytes  = bytes;
+    arena->slots[empty].in_use = 1;
+    arena->slots[empty].object_elements = 0;
+    arena->debug_xmalloc_count++;
+    return arena->slots[empty].ptr;
   }
 
   /* Pass 4: all CA_LAZY_ARENA_SLOTS in use simultaneously.  This is
@@ -692,12 +745,13 @@ ca_lazy_arena_acquire (ca_size_t bytes)
 void
 ca_lazy_arena_release (void *ptr)
 {
+  ca_lazy_arena_t *arena = ca_lazy_arena_get();
   int i;
   if ( ptr == NULL ) return;
   for ( i = 0; i < CA_LAZY_ARENA_SLOTS; i++ ) {
-    if ( ca_lazy_arena.slots[i].ptr == ptr ) {
-      ca_lazy_arena.slots[i].in_use = 0;
-      ca_lazy_arena.slots[i].object_elements = 0;
+    if ( arena->slots[i].ptr == ptr ) {
+      arena->slots[i].in_use = 0;
+      arena->slots[i].object_elements = 0;
       return;
     }
   }
@@ -716,21 +770,18 @@ ca_lazy_arena_release (void *ptr)
 void *
 ca_lazy_arena_acquire_object (ca_size_t n_elements)
 {
+  ca_lazy_arena_t *arena = ca_lazy_arena_get();
   void *ptr;
   int i;
 
   if ( n_elements < 0 ) n_elements = 0;
   ptr = ca_lazy_arena_acquire(n_elements * (ca_size_t) sizeof(VALUE));
 
-  {
-    VALUE *p = (VALUE *) ptr;
-    ca_size_t n = n_elements;
-    while ( n-- ) *p++ = Qnil;
-  }
+  ca_object_cells_clear(ptr, n_elements);
 
   for ( i = 0; i < CA_LAZY_ARENA_SLOTS; i++ ) {
-    if ( ca_lazy_arena.slots[i].ptr == ptr ) {
-      ca_lazy_arena.slots[i].object_elements = n_elements;
+    if ( arena->slots[i].ptr == ptr ) {
+      arena->slots[i].object_elements = n_elements;
       break;
     }
   }
@@ -738,11 +789,11 @@ ca_lazy_arena_acquire_object (ca_size_t n_elements)
 }
 
 static void
-ca_lazy_arena_mark_object_slots (void)
+ca_lazy_arena_mark_object_slots (ca_lazy_arena_t *arena)
 {
   int i;
   for ( i = 0; i < CA_LAZY_ARENA_SLOTS; i++ ) {
-    ca_lazy_arena_slot_t *s = &ca_lazy_arena.slots[i];
+    ca_lazy_arena_slot_t *s = &arena->slots[i];
     ca_size_t n;
     VALUE *p;
     if ( ! s->in_use || s->object_elements <= 0 ) continue;
@@ -754,45 +805,52 @@ ca_lazy_arena_mark_object_slots (void)
 
 /* Test instrumentation — exposed to Ruby for the arena smoke and
    regression assertions.  Not user-facing API. */
+#ifdef CARRAY_DEV_BUILD
 static VALUE
 rb_ca_lazy_arena_s_reset_counters (VALUE klass)
 {
-  ca_lazy_arena.debug_acquire_count = 0;
-  ca_lazy_arena.debug_xmalloc_count = 0;
-  ca_lazy_arena.debug_reuse_count   = 0;
+  ca_lazy_arena_t *arena = ca_lazy_arena_get();
+  arena->debug_acquire_count = 0;
+  arena->debug_xmalloc_count = 0;
+  arena->debug_reuse_count   = 0;
   return Qnil;
 }
 
 static VALUE
 rb_ca_lazy_arena_s_acquire_count (VALUE klass)
 {
-  return SIZE2NUM(ca_lazy_arena.debug_acquire_count);
+  ca_lazy_arena_t *arena = ca_lazy_arena_get();
+  return SIZE2NUM(arena->debug_acquire_count);
 }
 
 static VALUE
 rb_ca_lazy_arena_s_xmalloc_count (VALUE klass)
 {
-  return SIZE2NUM(ca_lazy_arena.debug_xmalloc_count);
+  ca_lazy_arena_t *arena = ca_lazy_arena_get();
+  return SIZE2NUM(arena->debug_xmalloc_count);
 }
 
 static VALUE
 rb_ca_lazy_arena_s_reuse_count (VALUE klass)
 {
-  return SIZE2NUM(ca_lazy_arena.debug_reuse_count);
+  ca_lazy_arena_t *arena = ca_lazy_arena_get();
+  return SIZE2NUM(arena->debug_reuse_count);
 }
 
 static VALUE
 rb_ca_lazy_arena_s_depth (VALUE klass)
 {
-  return INT2NUM(ca_lazy_arena.depth);
+  ca_lazy_arena_t *arena = ca_lazy_arena_get();
+  return INT2NUM(arena->depth);
 }
 
 static VALUE
 rb_ca_lazy_arena_s_slot_in_use_count (VALUE klass)
 {
+  ca_lazy_arena_t *arena = ca_lazy_arena_get();
   int i, n = 0;
   for ( i = 0; i < CA_LAZY_ARENA_SLOTS; i++ ) {
-    if ( ca_lazy_arena.slots[i].in_use ) n++;
+    if ( arena->slots[i].in_use ) n++;
   }
   return INT2NUM(n);
 }
@@ -806,16 +864,18 @@ rb_ca_lazy_arena_s_slot_in_use_count (VALUE klass)
 static VALUE
 rb_ca_lazy_arena_s_slot_capacities (VALUE klass)
 {
+  ca_lazy_arena_t *arena = ca_lazy_arena_get();
   int i;
   VALUE arr = rb_ary_new();
   (void) klass;
   for ( i = 0; i < CA_LAZY_ARENA_SLOTS; i++ ) {
-    if ( ca_lazy_arena.slots[i].ptr != NULL ) {
-      rb_ary_push(arr, SIZE2NUM(ca_lazy_arena.slots[i].bytes));
+    if ( arena->slots[i].ptr != NULL ) {
+      rb_ary_push(arr, SIZE2NUM(arena->slots[i].bytes));
     }
   }
   return arr;
 }
+#endif /* CARRAY_DEV_BUILD */
 
 /* ------------------------------------------------------------------- */
 
@@ -835,6 +895,7 @@ rb_ca_lazy_marker_initialize_copy (VALUE self, VALUE other)
   ca_check_uninitialized(ca);
   TypedData_Get_Struct(other, CALazyMarker, &calazy_marker_data_type, cs);
   ca_lazy_marker_setup(ca, cs->parent);
+  ca_view_inherit_mask((VALUE) ca);
   return self;
 }
 
@@ -857,16 +918,13 @@ Init_carray_lazy (void)
 
   ca_gc_local_key = rb_ractor_local_storage_ptr_newkey(&ca_gc_local_type);
 
-  /* Hidden, never collected: its mark function is what keeps the
-     arena's CA_OBJECT slots reachable. */
-  ca_gc_guard = TypedData_Wrap_Struct(rb_cObject, &ca_gc_guard_data_type,
-                                      &ca_gc_guard_body);
-  rb_gc_register_mark_object(ca_gc_guard);
+  ca_lazy_arena_key = rb_ractor_local_storage_ptr_newkey(&ca_lazy_arena_type);
 
   rb_define_alloc_func(rb_cCALazyMarker, rb_ca_lazy_marker_s_allocate);
   rb_define_method(rb_cCALazyMarker, "initialize_copy",
                                       rb_ca_lazy_marker_initialize_copy, 1);
 
+#ifdef CARRAY_DEV_BUILD
   /* Arena test instrumentation (not user-facing).  Bound on CArray
      for symmetry with CAMonOp / CABinOp counters, but the arena is
      a singleton process-wide state. */
@@ -884,6 +942,7 @@ Init_carray_lazy (void)
                              rb_ca_lazy_arena_s_slot_in_use_count, 0);
   rb_define_singleton_method(rb_cCArray, "__lazy_arena_slot_capacities__",
                              rb_ca_lazy_arena_s_slot_capacities, 0);
+#endif
 
   Init_ca_mask_of_operands();
 }
@@ -1056,18 +1115,18 @@ ca_lazy_req_pull (void *operand, const ca_lazy_req_t *req, void *buf, int dir)
 VALUE
 ca_lazy_evaluated (VALUE self)
 {
-  static ID id_evaluator = 0, id_fusion, id_evaluate;
+  /* rb_intern caches each literal by itself; a shared guard over several
+     IDs would let a second Ractor read one not yet set. */
+  ID id_evaluator = rb_intern("@expression_evaluator");
+  ID id_fusion    = rb_intern("Fusion");
+  ID id_evaluate  = rb_intern("evaluate");
   CArray *ca;
-  if ( ! id_evaluator ) {
-    id_evaluator = rb_intern("@expression_evaluator");
-    id_fusion    = rb_intern("Fusion");
-    id_evaluate  = rb_intern("evaluate");
-  }
   GetCArray(self, ca);
   if ( ! ca_is_lazy_view(ca) ) {
     return Qnil;
   }
-  if ( ! RTEST(rb_attr_get(rb_cCArray, id_evaluator)) ) {
+  /* registered in the main Ractor, and asked only there */
+  if ( ! ca_in_main_ractor() || ! RTEST(rb_attr_get(rb_cCArray, id_evaluator)) ) {
     return Qnil;
   }
   return rb_funcall(rb_const_get(rb_cCArray, id_fusion), id_evaluate, 1, self);
@@ -1306,6 +1365,7 @@ NORETURN(static void ca_mask_of_operands_read_only (void));
 static void
 ca_mask_of_operands_read_only (void)
 {
+  /* read-only-check: says it is the mask, which no lazy node owns */
   rb_raise(rb_eRuntimeError, "the mask of a lazy operation is read-only");
 }
 
@@ -1359,8 +1419,8 @@ ca_mask_of_operands_func_xfer_all (void *ap, void *data, int dir)
 static VALUE
 ca_mask_of_operands_fill_buffer (VALUE arg)
 {
-  CAMaskOfOperands *ca = (CAMaskOfOperands *) arg;
-  ca_mask_of_operands_func_xfer_all(ca, ca->ptr, CA_XFER_GET);
+  void **a = (void **) arg;
+  ca_mask_of_operands_func_xfer_all(a[0], a[1], CA_XFER_GET);
   return Qnil;
 }
 
@@ -1370,21 +1430,19 @@ static void
 ca_mask_of_operands_func_attach (void *ap)
 {
   CAMaskOfOperands *ca = (CAMaskOfOperands *) ap;
-  int tag = 0;
-  ca->ptr = xmalloc(ca->elements);
-  rb_protect(ca_mask_of_operands_fill_buffer, (VALUE) ca, &tag);
-  if ( tag ) {
-    xfree(ca->ptr);
-    ca->ptr = NULL;
-    rb_jump_tag(tag);
-  }
+  char *buf = ca_alloc_cells((CArray *) ca);
+  void *a[2];
+  a[0] = ca;
+  a[1] = buf;
+  ca_fill_or_xfree(buf, ca_mask_of_operands_fill_buffer, (VALUE) a);
+  ca->ptr = buf;
 }
 
 static void
 ca_mask_of_operands_func_allocate (void *ap)
 {
   CAMaskOfOperands *ca = (CAMaskOfOperands *) ap;
-  ca->ptr = xmalloc(ca->elements);
+  ca->ptr = ca_alloc_cells((CArray *) ca);
   memset(ca->ptr, 0, ca->elements);
 }
 
@@ -1454,7 +1512,12 @@ Init_ca_mask_of_operands (void)
 
    An operand can be given a mask later unless it is broadcast from one
    cell (a scalar the expression made from a literal), a value array, or a
-   read-only entity.  The shared mask is read-only, as the operation is. */
+   read-only entity.  The shared mask is read-only, as the operation is.
+
+   With no masked operand the mask is still made when asked for (a view
+   over the operation that masks cells of its own, such as a shift with
+   fill UNDEF, needs one to lie over): it reads all false until an
+   operand is given a mask. */
 CArray *
 ca_lazy_operation_mask (CArray *operation, int mode)
 {
@@ -1475,10 +1538,6 @@ ca_lazy_operation_mask (CArray *operation, int mode)
     }
   }
 
-  if ( n_masked == 0 ) {
-    return NULL;
-  }
-
   if ( mode == CA_LAZY_MASK_OR && n_masked == 1 && n_open == 0
        && masked->elements == operation->elements ) {
     CArray *shared = (CArray *) ca_refer_new(masked->mask, CA_BOOLEAN,