carray-jit 0.1.6 → 0.1.7

data/lib/carray/jit/compiler.rb

@@ -1,8 +1,9 @@
 require "digest"
 require "fileutils"
 require "rbconfig"
+require "securerandom"
 require "tmpdir"
-require "fiddle"
+require "carray/jit/native"
 require "monitor"
 
 class CArray
@@ -44,7 +45,7 @@ class CArray
 
       # Every generated object exports the same fixed names -- carray_jit_kernel,
       # carray_jit_slab, the border and error helpers -- because each one is a
-      # module of its own.  Fiddle.dlopen passes RTLD_GLOBAL, so on ELF those
+      # module of its own.  Native opens each with RTLD_GLOBAL, so on ELF those
       # names all land in one flat namespace and an intra-module call resolves
       # to the first definition loaded: a later kernel's carray_jit_slab calls
       # an earlier kernel's carray_jit_kernel, which takes a different number
@@ -83,10 +84,11 @@ class CArray
       LINK = (RbConfig::CONFIG["host_os"] =~ /darwin/ ?
                 ["-undefined", "dynamic_lookup"] : []).freeze
 
-      # Kernels retained on disk.  Each costs about 17 KB, so the default is
-      # roughly 9 MB -- far more than any real program compiles, but a bound
-      # all the same.
-      DEFAULT_ENTRY_LIMIT = 512
+      # Kernels retained on disk.  Each costs about 30 KB, object and source,
+      # so the default is roughly 60 MB.  Rebuilding is what a bound too low
+      # costs -- on macOS a new object's first load is checked by the system,
+      # around 200 ms each -- and this gem's own suite wants some 1300.
+      DEFAULT_ENTRY_LIMIT = 2000
 
       class << self
 
@@ -223,7 +225,7 @@ class CArray
           removed
         end
 
-        # Returns [Fiddle handle, whether it was compiled rather than reused].
+        # Returns [Native library, whether it was compiled rather than reused].
         #
         # `header` says where the kernel was written.  It is written into the
         # .c file but kept out of the digest: two call sites that produce the
@@ -231,14 +233,16 @@ class CArray
         # kernel does not throw its object away.  The file then names the
         # first site that compiled it, which is a place the code was written
         # rather than the only one.
-        # One compile at a time in a process.  The staging path a build
-        # compiles to is named for the process, so two threads building at
-        # once wrote the same file and whichever renamed first left the other
-        # renaming a path that was gone -- a bare Errno::ENOENT out of three
-        # threads in four.  Serialising them also spares the second thread the
-        # build: it takes the lock after the first has renamed, and finds the
-        # object where a later run would.  Reentrant, so that a build reached
-        # from inside another -- which none is today -- would not stop here.
+        # One compile at a time in a process, which spares a second thread the
+        # build: it takes the lock after the first has published, and finds
+        # the object where a later run would.  It is not what keeps two builds
+        # apart -- each stages under a name of its own (#staging_name), so
+        # builds that meet anyway, as Ractors would, each publish a whole
+        # object.  Until the names were that, two threads staged to one path
+        # and whichever renamed first left the other renaming a path that was
+        # gone -- a bare Errno::ENOENT out of three threads in four.
+        # Reentrant, so that a build reached from inside another -- which
+        # none is today -- would not stop here.
         LOCK = Monitor.new
 
         def build (source, function_name, header: nil, flags: FLAGS)
@@ -266,12 +270,17 @@ class CArray
           end
 
           source_path = File.join(directory, "#{key}.c")
-          File.write(source_path, header.to_s + source)
-          # Build to a unique path and rename, so a concurrent process never
-          # loads a half-written object.
-          staging_path = "#{object_path}.#{Process.pid}"
+          # Both written to a path of this build's own and renamed into
+          # place, so that nothing -- another build, another process -- ever
+          # reads half of either.  A rename onto a path another build has
+          # just published replaces the same bytes.
+          staging = staging_name
+          staged_source = "#{source_path}.#{staging}"
+          staging_path = "#{object_path}.#{staging}"
           handle =
             begin
+              File.write(staged_source, header.to_s + source)
+              File.rename(staged_source, source_path)
               compile(source_path, staging_path, flags)
               # Opened before it is published, under the name only this
               # process knows.  Published first, the object stands in the
@@ -291,6 +300,7 @@ class CArray
               # that cannot compile.  The staging file would be swept in five
               # minutes; it goes now, beside the source it came from.
               remove_entry(object_path)
+              unlink(staged_source)
               unlink(staging_path)
               raise
             end
@@ -469,15 +479,23 @@ class CArray
           end
         end
 
-        # A process killed mid-compile leaves `<key>.bundle.<pid>` behind.
-        # Those match neither the entry glob nor the prune glob, so without
-        # this they would sit in the cache for good.  Only swept on a miss,
-        # to keep it off the reuse path.
+        # The suffix one build stages its files under: the process, and a
+        # random part for the build within it.  Not a counter, which would be
+        # state shared between the threads and Ractors that build at once.
+        def staging_name
+          "#{Process.pid}.#{SecureRandom.hex(4)}"
+        end
+
+        # A process killed mid-compile leaves `<key>.bundle.<staging>` behind,
+        # and `<key>.c.<staging>` if it was killed sooner.  Those match neither
+        # the entry glob nor the prune glob, so without this they would sit in
+        # the cache for good.  Only swept on a miss, to keep it off the reuse
+        # path.
         STAGING_MAXIMUM_AGE = 300
 
         def sweep_staging (directory)
           now = Time.now
-          Dir[File.join(directory, "*#{shared_object_suffix}.*")].each do |path|
+          Dir[File.join(directory, "*{#{shared_object_suffix},.c}.*")].each do |path|
             next unless File.file?(path)
             age = now - File.mtime(path) rescue 0
             next if age < STAGING_MAXIMUM_AGE
@@ -572,8 +590,8 @@ class CArray
         # rebuilt.  A freshly compiled object that will not load is a real
         # failure and is raised by #load_new_object.
         def load_shared_object (path)
-          Fiddle.dlopen(path)
-        rescue Fiddle::DLError
+          Native.open_library(path, global: true)
+        rescue Native::LinkError
           nil
         end
 

data/lib/carray/jit/expression.rb

@@ -83,9 +83,11 @@ class CArray
           # Held here so that the buffers outlive the call.
           dim = out.dim.pack("q*")
           steps = strided.flat_map { |slot| slot_strides(bases, slot) }.pack("q*")
+          constants = packed_constants(plan) or return false
           args = [out.elements]
-          args << Fiddle::Pointer[dim] if walks_axes?(plan, strided)
-          args << Fiddle::Pointer[steps] unless strided.empty?
+          args << dim if walks_axes?(plan, strided)
+          args << steps unless strided.empty?
+          args << constants unless constants.empty?
           kernel.call(*args, *pointers(plan, bases))
         end
         true
@@ -127,10 +129,9 @@ class CArray
         @strided = strided
         source = source_for(plan, aliased) or return nil
         handle, = Compiler.build(source, "carray_jit_expression", flags: FLAGS)
-        Fiddle::Function.new(handle["carray_jit_expression"],
-                             [Fiddle::TYPE_LONG_LONG] +
-                               [Fiddle::TYPE_VOIDP] * (1 + arity(plan, strided)),
-                             Fiddle::TYPE_VOID)
+        Native.function(Native.address(handle, "carray_jit_expression"),
+                        [:long_long] + [:pointer] * (1 + arity(plan, strided)),
+                        :void, release_gvl: true)
       rescue CompilationError
         nil
       end
@@ -138,7 +139,63 @@ class CArray
       def arity (plan, strided)
         plan.leaves.size + plan.leaves.count { |array| array.has_mask? } +
           (plan.masked ? 1 : 0) + (walks_axes?(plan, strided) ? 1 : 0) +
-          (strided.empty? ? 0 : 1)
+          (strided.empty? ? 0 : 1) + (constant_nodes(plan).empty? ? 0 : 1)
+      end
+
+      # The values the kernel does not have written into it: each constant,
+      # and the fill of each shifted read that fills.  They arrive at the call
+      # instead.  Written into the C as literals, they were the compiler's to
+      # fold, and it folded what CArray computes as arithmetic: `x * -1.0`
+      # became a negation, which flips the sign of a NaN that the multiply
+      # in CArray's own kernel leaves as it is.  A value the compiler cannot
+      # see is one it computes with as written.
+      def constant_nodes (plan)
+        plan.nodes.each_with_index.filter_map { |node, i|
+          case node
+          when CArray::Fusion::Const then [i, node]
+          when CArray::Fusion::Shifted
+            [i, CArray::Fusion::Const.new(node.fill, node.data_type)] if node.bounds.uniq == [:fill]
+          end
+        }
+      end
+
+      # One slot of CONSTANT_SLOT bytes per value, in the order of
+      # #constant_nodes, each read back with memcpy so that no slot need be
+      # aligned.  Nil for a value that has no bytes in its type -- the plan is
+      # then declined.
+      def packed_constants (plan)
+        constant_nodes(plan).map { |_, node| constant_bytes(node) or return nil }.join
+      end
+
+      CONSTANT_SLOT = 8
+
+      PACKING = {
+        float64: "d", float32: "f",
+        int8:  "c", int16:  "s", int32:  "l", int64:  "q",
+        uint8: "C", uint16: "S", uint32: "L", uint64: "Q",
+        boolean: "C",
+      }.freeze
+
+      def constant_bytes (node)
+        directive = PACKING[node.data_type] or return nil
+        value = node.value
+        value = case node.data_type
+                when :float64, :float32 then Float(value)
+                when :boolean then truth(value) ? 1 : 0
+                else value.is_a?(Float) ? (value.finite? ? value.to_i : (return nil)) : Integer(value)
+                end
+        [value].pack(directive).ljust(CONSTANT_SLOT, "\0")
+      rescue TypeError, ArgumentError, RangeError
+        nil
+      end
+
+      # The constants read into locals before the loop, where they stay for
+      # every cell.
+      def constant_lines (plan)
+        constant_nodes(plan).each_with_index.map { |(i, node), j|
+          type = C_TYPES.fetch(node.data_type)
+          "  #{type} c#{i}; memcpy(&c#{i}, constants + #{j * CONSTANT_SLOT}, sizeof c#{i});"
+        }
       end
 
       # A plan that reads an operand shifted, or by strides, needs to know
@@ -256,9 +313,10 @@ class CArray
 
           #{helpers}
           void
-          carray_jit_expression (int64_t elements#{walking ? ", const int64_t *dim" : ""}#{@strided.empty? ? "" : ", const int64_t *steps"}, #{out_type} *#{restrict}out#{mask_parameter(plan, restrict)}#{parameters(plan, restrict)})
+          carray_jit_expression (int64_t elements#{walking ? ", const int64_t *dim" : ""}#{@strided.empty? ? "" : ", const int64_t *steps"}#{constant_nodes(plan).empty? ? "" : ", const unsigned char *constants"}, #{out_type} *#{restrict}out#{mask_parameter(plan, restrict)}#{parameters(plan, restrict)})
           {
           #{stride_lines(plan).join("\n")}
+          #{constant_lines(plan).join("\n")}
           #{loop(plan, body + result, walking && (statements(plan, :inside) + result)).join("\n")}
           }
         C
@@ -361,7 +419,7 @@ class CArray
         when CArray::Fusion::Shifted
           shifted_line(plan, node, i, type)
         when CArray::Fusion::Const
-          ["#{type} v#{i} = #{literal(node)};",
+          ["#{type} v#{i} = c#{i};",
            *(plan.masked ? ["uint8_t m#{i} = 0;"] : [])]
         when CArray::Fusion::Op
           statement = substitute(node, i, type) or return nil
@@ -397,8 +455,7 @@ class CArray
         clamped = (0...ndim).map { |k| "c#{i}_#{k}" }
         lines << "#{type} v#{i} = #{cell("a#{node.index}", type, flat, clamped)};"
         if bounds.first == :fill
-          fill = CArray::Fusion::Const.new(node.fill, node.data_type)
-          lines << "if ( ! s#{i}_in ) { v#{i} = #{literal(fill)}; }"
+          lines << "if ( ! s#{i}_in ) { v#{i} = c#{i}; }"
         end
         if plan.masked
           inner = node.masked ? cell("k#{node.index}", "uint8_t", flat, clamped) : "0"
@@ -408,23 +465,6 @@ class CArray
         lines
       end
 
-      def literal (node)
-        case node.data_type
-        when :float64, :float32 then float_literal(node.value.to_f)
-        when :boolean           then truth(node.value) ? 1 : 0
-        else node.value.to_s
-        end
-      end
-
-      # `%.17g` writes -0.0 as "-0", which C reads as the integer 0 negated,
-      # and writes NaN and the infinities as words C does not know.
-      def float_literal (value)
-        return "NAN" if value.nan?
-        return (value > 0 ? "INFINITY" : "(-INFINITY)") if value.infinite?
-        text = "%.17g" % value
-        text.match?(/[.e]/) ? text : "#{text}.0"
-      end
-
       # A boolean cell as CArray stores it: 0 is false, as is false.
       def truth (value)
         value.is_a?(Numeric) ? value != 0 : !!value

data/lib/carray/jit/kernel.rb

@@ -1,4 +1,4 @@
-require "fiddle"
+require "carray/jit/native"
 require "carray/jit/sweep"
 
 class CArray
@@ -7,8 +7,9 @@ class CArray
     # A compiled kernel, bound to one set of array data types and one set of
     # scalar types.
     #
-    # Every kernel has the same C signature, so the Fiddle::Function shape is
-    # fixed and the per-kernel detail travels in the six buffers.
+    # Every kernel has the same C signature, so the shape of the function
+    # Native makes is fixed and the per-kernel detail travels in the six
+    # buffers.
     class CompiledKernel
 
       # @!attribute [r] source
@@ -54,6 +55,12 @@ class CArray
         @rank = analyzer.rank
         @index_names = analyzer.index_names
         @written_arrays = analyzer.written_arrays
+        # Which operands the sweep writes, in CArray's spelling: one character
+        # per operand.  Decided by the body, so spelled once rather than on
+        # every call.
+        @fsync = @arrays.map { |name|
+          @written_arrays.include?(name) ? "1" : "0"
+        }.join.freeze
         @array_ranks = analyzer.array_ranks
         @inner_ranges = analyzer.inner_ranges
         @unbounded_indices = analyzer.unbounded_indices
@@ -126,9 +133,8 @@ class CArray
         @handle, @compiled = Compiler.build(generator.generate_slab(SLAB_NAME),
                                             CGenerator::FUNCTION_NAME,
                                             header: generator.provenance)
-        @function = Fiddle::Function.new(@handle[CGenerator::FUNCTION_NAME],
-                                         [Fiddle::TYPE_VOIDP] * 10,
-                                         Fiddle::TYPE_VOID)
+        @function = Native.function(Native.address(@handle, CGenerator::FUNCTION_NAME),
+                                    [:pointer] * 10, :void, release_gvl: true)
       end
 
       # `bounds` is one [start, limit, step] per axis.
@@ -209,9 +215,6 @@ class CArray
       # arguments the kernel's own loop takes are the ones a chunk arrives as.
       def sweep (array_values, scalar_values, c_function_values = {})
         arrays = @arrays.map { |name| array_values.fetch(name) }
-        fsync = @arrays.map { |name|
-          @written_arrays.include?(name) ? "1" : "0"
-        }.join
 
         error = [0].pack("l")
         reals = packed_reals(scalar_values)
@@ -233,12 +236,10 @@ class CArray
         # signature has the slots.
         masks = ("\0" * 8)
 
-        held = [buffer(reals), buffer(integers), buffer(functions),
-                buffer(data), masks, masks, error]
-        error = in_one_block(held) { |context, slots|
-          Sweep.call(slab_pointer, fsync, arrays, context)
-          slots.last[0, error.bytesize]
-        }
+        # The slab writes the error slot in `error` itself.
+        Sweep.run(slab_pointer, @fsync, arrays,
+                  buffer(reals), buffer(integers), buffer(functions),
+                  buffer(data), masks, masks, error)
 
         packed.each_with_index do |(array, item), index|
           next if array.equal?(item)
@@ -332,7 +333,7 @@ class CArray
          @shape_scalar_names.map { |name| scalars[name] }]
       end
 
-      # A kernel is shared, and Fiddle lets go of the GVL for the call, so two
+      # A kernel is shared, and its call lets go of the GVL, so two
       # threads can be reading one plan while a third prepares another.  That
       # is sound only while nothing in a plan is written after it is published
       # -- and a box is arrays inside an array, so freezing the top of it
@@ -456,7 +457,7 @@ class CArray
       end
 
       def slab_pointer
-        @slab_pointer ||= @handle[SLAB_NAME]
+        @slab_pointer ||= Native.address(@handle, SLAB_NAME)
       end
 
       # Resolved when the frame is first walked rather than at build time: a
@@ -464,8 +465,8 @@ class CArray
       # runs its interior first.
       def border_function
         @border_function ||=
-          Fiddle::Function.new(@handle[CGenerator::BORDER_NAME],
-                               [Fiddle::TYPE_VOIDP] * 10, Fiddle::TYPE_VOID)
+          Native.function(Native.address(@handle, CGenerator::BORDER_NAME),
+                          [:pointer] * 10, :void, release_gvl: true)
       end
 
       # What a C function may be handed as a pointer, and what has to be true
@@ -523,7 +524,7 @@ class CArray
 
       def address_buffer (name, array)
         @address_parameters.fetch(name).each do |parameter|
-          wanted = CDeclaration::DATA_TYPES.fetch(parameter.element.fiddle)
+          wanted = CDeclaration::DATA_TYPES.fetch(parameter.element.abi)
           unless array.data_type_name == wanted.to_s
             raise Unsupported,
                   "`#{name}` is handed to a C function as `#{parameter.text}`, " \
@@ -553,37 +554,12 @@ class CArray
         Access.classify(array)[:entity] ? array : array.copy
       end
 
-      # A pointer into an empty string is not something Fiddle can hand over,
-      # and a kernel with no scalars has an empty buffer.
+      # A pointer into an empty string is not something Native is asked to
+      # hand over, and a kernel with no scalars has an empty buffer.
       def buffer (packed)
         packed.empty? ? "\0" * 8 : packed
       end
 
-      # Copies `parts` into one block of C memory, each part 8-byte aligned,
-      # after a table of their addresses, and yields a pointer to the table
-      # and a pointer to each part; the block is freed when this returns.
-      #
-      # For a call that is handed addresses inside other memory rather than
-      # arguments: a Ruby String's bytes may be moved by GC compaction, and
-      # an address taken from one and packed elsewhere is not one Ruby knows
-      # to keep in place.  Memory from malloc is never moved.
-      def in_one_block (parts)
-        table = parts.size * Fiddle::SIZEOF_VOIDP
-        offsets = parts.each_with_object([]) { |part, list|
-          last = list.empty? ? table : list.last + parts[list.size - 1].bytesize
-          list << ((last + 7) & ~7)
-        }
-        size = offsets.last + parts.last.bytesize
-        Fiddle::Pointer.malloc(size, Fiddle::RUBY_FREE) do |block|
-          slots = parts.zip(offsets).map { |part, offset|
-            block[offset, part.bytesize] = part
-            block + offset
-          }
-          block[0, table] = slots.map(&:to_i).pack("Q*")
-          yield block, slots
-        end
-      end
-
       # The xfer tier transfers a box rather than the whole view.  The box
       # is the loop range grown by how far the kernel reaches from the cell it
       # is on -- per array, because two arrays in one kernel need not be read

data/lib/carray/jit/native.rb

@@ -0,0 +1,149 @@
+require "fiddle"
+require "fiddle/import"
+require "carray/jit/errors"
+
+class CArray
+  module JIT
+
+    # Everything this library asks of the layer that reaches C from Ruby, and
+    # the one place that layer is named.  The rest of the library says what
+    # it wants -- open this object, find this symbol, make a function of
+    # these types, read these bytes -- in the words below, and only this
+    # file knows that Fiddle is what answers.
+    #
+    # That is so the layer can be replaced by changing one file.  Fiddle does
+    # not let a call be made from a Ractor other than the main one, and a
+    # layer that does would be a second version of this module rather than a
+    # second version of the library (devel/PROPOSAL_FFI_SEAM.md).
+    #
+    # What is asked:
+    #
+    # - a shared object opened, and the libraries already loaded searched
+    # - a symbol's address found in one
+    # - a function made from an address and its types, and called
+    # - bytes read and written at an address
+    # - a Ruby object handed to C as the VALUE it is
+    #
+    # A function is called by calling what #function returns: its #call is
+    # the layer's own, so nothing stands between a kernel and the C beyond
+    # what the layer itself costs.  The arguments it takes for a `:pointer`
+    # are an Integer address, a String -- whose bytes are what C is handed --
+    # or nil.
+    # @private
+    module Native
+
+      # The C types a function is made with, by this library's names for
+      # them.  `:pointer` is any pointer; a function's arguments say what it
+      # points at only to the C, which is all that needs to know.
+      TYPES = {
+        void:       Fiddle::TYPE_VOID,
+        pointer:    Fiddle::TYPE_VOIDP,
+        char:       Fiddle::TYPE_CHAR,
+        uchar:      Fiddle::TYPE_UCHAR,
+        short:      Fiddle::TYPE_SHORT,
+        ushort:     Fiddle::TYPE_USHORT,
+        int:        Fiddle::TYPE_INT,
+        uint:       Fiddle::TYPE_UINT,
+        long:       Fiddle::TYPE_LONG,
+        ulong:      Fiddle::TYPE_ULONG,
+        long_long:  Fiddle::TYPE_LONG_LONG,
+        ulong_long: Fiddle::TYPE_ULONG_LONG,
+        float:      Fiddle::TYPE_FLOAT,
+        double:     Fiddle::TYPE_DOUBLE,
+      }.freeze
+
+      # The other way round, for what Fiddle's parser answers.  Every code it
+      # gives for a spelling CDeclaration hands it is one of the fourteen
+      # above: `size_t` and the other platform words arrive as the code of
+      # whichever of these they are on this machine.
+      NAMES = TYPES.invert.freeze
+      private_constant :NAMES
+
+      POINTER_SIZE = Fiddle::SIZEOF_VOIDP
+
+      # What a library is, for a caller that was handed one.  `jit_extern`'s
+      # `from:` takes one of these as it stands.
+      Library = Fiddle::Handle
+
+      # Raised when a library will not open or a symbol is not in it.
+      LinkError = Fiddle::DLError
+
+      PARSER = ::Object.new.extend(Fiddle::CParser)
+      private_constant :PARSER
+
+      # Opens a shared object.  `global:` is whether its symbols join the
+      # process-wide namespace -- RTLD_GLOBAL -- and it is a required word
+      # because layers differ on what they do unasked: Fiddle opens globally,
+      # and a layer that opened locally would change which definition a name
+      # in one generated object resolves to (see Compiler's link flags).
+      # Fiddle has no word for the other way, and nothing here asks for it.
+      def self.open_library (path, global:)
+        raise ArgumentError, "Fiddle opens a library only globally" unless global
+        Fiddle::Handle.new(path, Fiddle::RTLD_LAZY | Fiddle::RTLD_GLOBAL)
+      end
+
+      # What the process has already loaded, searched as one library.
+      def self.loaded_libraries
+        Fiddle::Handle::DEFAULT
+      end
+
+      # The address of `name` in `library`, as an Integer.
+      def self.address (library, name)
+        library[name]
+      end
+
+      # A function at `address` taking `arguments` and returning `result`,
+      # each one of the names in TYPES.
+      #
+      # `release_gvl:` is whether the GVL is let go for the length of a call,
+      # and it is a required word because layers differ on what they do
+      # unasked -- Fiddle lets it go, FFI keeps it.  Letting it go is right
+      # for C that touches no Ruby value, which is every generated kernel; it
+      # is wrong for C that does, which is CArray's own sweep.
+      def self.function (address, arguments, result, release_gvl:, name: nil)
+        types = arguments.map { |type| TYPES.fetch(type) }
+        options = name ? { name: name } : {}
+        return Fiddle::Function.new(address, types, TYPES.fetch(result), **options) if release_gvl
+        begin
+          Fiddle::Function.new(address, types, TYPES.fetch(result),
+                               need_gvl: true, **options)
+        rescue ArgumentError
+          # A Fiddle too old to be told.  It is also too old to have let go
+          # of the GVL in the first place -- the keyword and the releasing
+          # arrived together -- so what is left here is what that Fiddle
+          # would have done anyway.
+          Fiddle::Function.new(address, types, TYPES.fetch(result), **options)
+        end
+      end
+
+      # The type a C spelling is on this machine, as a name in TYPES, or nil
+      # where it is not one.  The spelling is one CDeclaration has already
+      # put in order: `unsigned long` rather than `long unsigned`, `void *`
+      # for any pointer.
+      def self.c_type (spelling)
+        NAMES.fetch(PARSER.parse_ctype(spelling))
+      rescue StandardError
+        nil
+      end
+
+      # `size` bytes at `address`, as a String.  Fiddle::Pointer.read and
+      # .write are not in the fiddle Ruby 3.2 ships (1.1.1).
+      def self.read (address, size)
+        Fiddle::Pointer.new(address)[0, size]
+      end
+
+      # `bytes` written at `address`.
+      def self.write (address, bytes)
+        Fiddle::Pointer.new(address)[0, bytes.bytesize] = bytes
+      end
+
+      # `object` as the VALUE C sees -- for CArray's own C, which takes the
+      # array itself rather than its memory.
+      def self.value (object)
+        Fiddle.dlwrap(object)
+      end
+
+    end
+
+  end
+end