carray-jit 0.1.5 → 0.1.7

data/lib/carray/jit/c_generator.rb

@@ -9,8 +9,8 @@ class CArray
     # names the block used, and casts only where a type actually changes.
     # `CARRAY_JIT_DUMP=1` prints it.
     #
-    # Every kernel has the same C signature, so one Fiddle::Function shape
-    # serves all of them; the per-kernel detail is unpacked into named locals
+    # Every kernel has the same C signature, so one function shape serves
+    # all of them; the per-kernel detail is unpacked into named locals
     # at the top of the body, where it also reads better.
     class CGenerator
 
@@ -421,6 +421,7 @@ class CArray
         @uses_real_arg = false
         @uses_real_power_complex = false
         @clamp_types = []
+        @store_types = []
         @gamma_types = []
         @complex_helpers = []
         @uses_floor_divide = false
@@ -727,6 +728,7 @@ class CArray
           :real_arg => @uses_real_arg,
           :real_power_complex => @uses_real_power_complex,
           :clamp => @clamp_types.dup,
+          :store => @store_types.dup,
           :gamma => @gamma_types.dup,
           :complex => @complex_helpers.dup,
           :index_check => @uses_index_check,
@@ -839,6 +841,7 @@ class CArray
           @uses_real_arg ||= needs[:real_arg]
           @uses_real_power_complex ||= needs[:real_power_complex]
           @clamp_types |= needs[:clamp] || []
+          @store_types |= needs[:store] || []
           @gamma_types |= needs[:gamma] || []
           @complex_helpers |= needs[:complex] || []
           @uses_index_check ||= needs[:index_check]
@@ -1095,6 +1098,31 @@ class CArray
           C
         end
         text << intrinsic_helpers
+        @store_types.each do |storage|
+          low, high = STORE_BOUNDS.fetch(storage)
+          c_type = storage_c_type(storage)
+          text << <<~C
+            /* A real number stored into an #{storage} cell keeps its integer
+               part, as CArray's store does.  One with no #{storage} to keep --
+               a NaN, an infinity, a number past the range -- is refused as
+               CArray refuses it: C leaves that conversion undefined, and the
+               machines answer it differently. */
+            static inline #{c_type}
+            carray_jit_store_#{storage} (double value, int32_t *error)
+            {
+              if ( value > #{low} && value < #{high} ) {
+                return (#{c_type}) value;
+              }
+              if ( error ) {
+                *error = isnan(value) ? #{FLOAT_NAN_CODE} :
+                         isinf(value) ? ( value > 0 ? #{FLOAT_INFINITY_CODE} : #{FLOAT_NEGATIVE_INFINITY_CODE} ) :
+                         #{STORE_RANGE_CODES.fetch(storage)};
+              }
+              return 0;
+            }
+
+          C
+        end
         @clamp_types.each do |type|
           suffix, c_type, has_nan = CLAMP_C_TYPES.fetch(type)
           refusal = lambda { |test, code|
@@ -1749,6 +1777,14 @@ class CArray
       # Each axis carries a start, a limit and a step.  The step is a compiled
       # constant when it is one, because `i++` is what lets the loop vectorise
       # and that is the case nearly every kernel is in.
+      #
+      # The limit and a step that is not a constant are read into locals
+      # before the loop, not out of `bounds` at each test.  `bounds` is an
+      # `int64_t *`, and so is an int64 array the body writes: the compiler
+      # cannot tell that a store into the array leaves the limit alone, reads
+      # it again after every cell, and having no trip count does not vectorise
+      # the loop at all.  A kernel writing a float64 or int32 array never met
+      # this, which is why it went unseen; test_vectorization.rb keeps it seen.
       def loop_open
         @rank.times.map { |axis|
           indent = "  " + "  " * axis
@@ -1760,17 +1796,18 @@ class CArray
           # way to report does not pay for the test at all.
           guard = @body_reports ? "#{indent}  if ( *error ) break;\n" : ""
           start = "bounds[#{3 * axis}]"
-          limit = "bounds[#{3 * axis + 1}]"
+          limit = "#{index}__limit"
           step = @steps[axis]
-          if step && step.negative?
-            advance = step == -1 ? "#{index}--" : "#{index} += bounds[#{3 * axis + 2}]"
-            "#{indent}for (int64_t #{index} = #{start}; #{index} > #{limit}; " \
-            "#{advance}) {\n#{guard}"
+          locals = "#{index} = #{start}, #{limit} = bounds[#{3 * axis + 1}]"
+          if step && step.abs == 1
+            advance = step == -1 ? "#{index}--" : "#{index}++"
           else
-            advance = step == 1 ? "#{index}++" : "#{index} += bounds[#{3 * axis + 2}]"
-            "#{indent}for (int64_t #{index} = #{start}; #{index} < #{limit}; " \
-            "#{advance}) {\n#{guard}"
+            locals += ", #{index}__step = bounds[#{3 * axis + 2}]"
+            advance = "#{index} += #{index}__step"
           end
+          comparison = ( step and step.negative? ) ? ">" : "<"
+          "#{indent}for (int64_t #{locals}; #{index} #{comparison} #{limit}; " \
+          "#{advance}) {\n#{guard}"
         }.join
       end
 
@@ -1834,6 +1871,14 @@ class CArray
       FLOAT_NEGATIVE_INFINITY_CODE = -5
       INTEGER_RANGE_CODE = -6
 
+      # And what a real number stored into an integer cell reports where the
+      # cell's type has no integer for it, one code for each type, so the
+      # message can name the type as CArray's own store does.
+      STORE_RANGE_CODES = {
+        "int8"  => -7,  "int16"  => -8,  "int32"  => -9,  "int64"  => -10,
+        "uint8" => -11, "uint16" => -12, "uint32" => -13, "uint64" => -14,
+      }.freeze
+
       # The fixed failures a body reports, as the exception each one raises.
       # A kernel and a compiled function both look here, so the two say the
       # same thing for the same cell.
@@ -1842,6 +1887,24 @@ class CArray
         FLOAT_INFINITY_CODE => [FloatDomainError, "Infinity"],
         FLOAT_NEGATIVE_INFINITY_CODE => [FloatDomainError, "-Infinity"],
         INTEGER_RANGE_CODE => [RangeError, "a rounded Float is past the range of int64"],
+        **STORE_RANGE_CODES.to_h { |storage, code|
+          [code, [RangeError, "a Float is out of range for #{storage}"]]
+        },
+      }.freeze
+
+      # The bounds a real number has to fall strictly between for its integer
+      # part to be a value of the type, written as doubles, which hold every
+      # one of them exactly.  CArray's store keeps the integer part, so -0.5
+      # goes into a uint8 cell as 0, and 255.9 as 255.
+      STORE_BOUNDS = {
+        "int8"   => ["-129.0", "128.0"],
+        "int16"  => ["-32769.0", "32768.0"],
+        "int32"  => ["-2147483649.0", "2147483648.0"],
+        "int64"  => ["-9223372036854777856.0", "9223372036854775808.0"],
+        "uint8"  => ["-1.0", "256.0"],
+        "uint16" => ["-1.0", "65536.0"],
+        "uint32" => ["-1.0", "4294967296.0"],
+        "uint64" => ["-1.0", "18446744073709551616.0"],
       }.freeze
 
       RAISE_CODE_FLOOR = 3
@@ -2588,9 +2651,9 @@ class CArray
         # expression written into it carried, and the branches the write
         # stands in.  A write reached because a missing cell said so was
         # reached for no reason, whichever of the three it writes.
+        masked = @masked ? combine_masks(@carried_masks + [emit_mask(write.expression)]) : nil
         mask = if @masked
-                 "#{indent}#{local_array_reference(write, :mask)} = " \
-                 "#{combine_masks(@carried_masks + [emit_mask(write.expression)])};\n"
+                 "#{indent}#{local_array_reference(write, :mask)} = #{masked};\n"
                else
                  ""
                end
@@ -2600,10 +2663,10 @@ class CArray
           "#{indent}#{COMPUTATION_C_TYPES.fetch(type)} #{temporary};\n" +
             emit_conditional_statement(expression, temporary, type, indent) +
             "#{indent}#{target} = " \
-            "#{cast_to_storage(temporary, type, write.storage)};\n" + mask
+            "#{cast_to_storage(temporary, type, write.storage, masked: masked)};\n" + mask
         else
           type = complex_storage_of_power(expression, write.storage) || expression.type
-          value = cast_to_storage(emit(expression, type), type, write.storage)
+          value = cast_to_storage(emit(expression, type), type, write.storage, masked: masked)
           "#{indent}#{target} = #{value};\n" + mask
         end
       end
@@ -2999,13 +3062,41 @@ class CArray
         @storage_types.fetch(array)
       end
 
-      def cast_to_storage (text, type, storage)
+      # A captured array's element type is matched at the call
+      # (`address_buffer`), after the build, and raises before the kernel
+      # runs.  Where the declaration spells the pointer differently from the
+      # array's own, the address is cast to it, so that check is the one that
+      # answers: gcc refuses an incompatible pointer at compile time where
+      # clang only warns.  `long long *` is such a spelling for an int64
+      # array, which the check accepts and gcc does not.  A body's own
+      # pointer parameter is no captured array and is handed on as it is:
+      # its type was declared in C.
+      def emit_array_argument (argument, parameter)
+        address = emit(argument, :address)
+        return address unless @storage_types.key?(argument.array)
+        own = "#{storage_c_type(array_storage(argument.array))} *"
+        declared = parameter.decayed.sub(/\Aconst\s+/, "")
+        declared == own ? address : "(#{parameter.decayed})#{address}"
+      end
+
+      # `masked` is the C of the written cell's mask, for a write whose mask
+      # the error slot does not already know about: a missing cell holds
+      # whatever was under its mask, which is no value to refuse.
+      def cast_to_storage (text, type, storage, masked: nil)
         # Storing into a boolean array normalises: CArray's boolean is a byte
         # holding 0 or 1, and a kernel is not the place that invariant stops
         # being true.
         return "(uint8_t)((#{text}) ? 1 : 0)" if boolean_storage?(storage)
         target = storage_c_type(storage)
         return text if COMPUTATION_C_TYPES.fetch(type) == target
+        if [:double, :float].include?(type) and STORE_BOUNDS.key?(storage)
+          @store_types |= [storage]
+          error = error_argument
+          if masked and masked != "0"
+            error = "(#{masked} ? (int32_t *) 0 : #{error})"
+          end
+          return "carray_jit_store_#{storage}(#{text}, #{error})"
+        end
         "(#{target})(#{text})"
       end
 
@@ -3563,8 +3654,9 @@ class CArray
           c_function = @c_functions.fetch(node.name)
           arguments = node.arguments.zip(c_function.parameters)
                           .map { |argument, parameter|
-                            if argument.is_a?(ArrayAddress) ||
-                               argument.is_a?(LocalArrayAddress)
+                            if argument.is_a?(ArrayAddress)
+                              emit_array_argument(argument, parameter)
+                            elsif argument.is_a?(LocalArrayAddress)
                               emit(argument, :address)
                             else
                               emit(argument, parameter.computation)
@@ -3623,12 +3715,15 @@ class CArray
          "#{emit(node.high, type)}, #{error_argument})", LEAF_PRECEDENCE]
       end
 
-      # `isnan` and `isfinite` are C's own, and take a number of any width.
-      # A Complex answers `finite?` the way Ruby answers it -- both parts
-      # finite -- through a helper, so that the number is computed once.
-      # An Integer is finite whatever it holds, and goes through `isfinite`
-      # all the same rather than being answered here: the read it stands for
-      # is a read, and dropping it would drop what the read reports.
+      # `isnan` and `isfinite` are C's own, and take a real floating number
+      # of either width.  A Complex answers `finite?` the way Ruby answers
+      # it -- both parts finite -- through a helper, so that the number is
+      # computed once.  An Integer is finite whatever it holds, and goes
+      # through `isfinite` all the same rather than being answered here: the
+      # read it stands for is a read, and dropping it would drop what the
+      # read reports.  It goes in as a double, because C asks for a floating
+      # argument and gcc refuses an integer one where clang lets it pass;
+      # every integer converts to a finite double.
       def emit_numeric_predicate (node)
         type = node.operand.type
         function = node.name == :nan? ? "isnan" : "isfinite"
@@ -3636,7 +3731,11 @@ class CArray
           return emit_helper_call("complex_finite", [emit(node.operand, type)],
                                   type == :float_complex)
         end
-        ["#{function}(#{emit(node.operand, type)})", LEAF_PRECEDENCE]
+        operand = emit(node.operand, type)
+        if TypeAssignment::INTEGER_TYPES.include?(type)
+          operand = "(double)(#{operand})"
+        end
+        ["#{function}(#{operand})", LEAF_PRECEDENCE]
       end
 
       def emit_mask_test (node)

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

@@ -40,7 +40,17 @@ class CArray
       # multiply and an add into one rounding, so it compiles with
       # -ffp-contract=off.  Here the reference is the eager kernel, which was
       # built with whatever CArray settled on.
-      FLAGS = ["-fPIC", "-shared", *CArray::BUILD_FLAGS.split, *DYNAMIC_LOOKUP].freeze
+      #
+      # Except between nodes.  CArray computes each node in a kernel of its
+      # own, so no node's multiply meets the next node's add; this object
+      # writes the expression as one statement per node in a single loop.
+      # clang contracts within a statement by default, which leaves that
+      # alone, but gcc defaults to -ffp-contract=fast and contracts across
+      # statements: on x86 with -march=native, `a * b + c` lost a rounding in
+      # 3296 of 30000 cells.  -ffp-contract=on keeps a contraction inside a
+      # node's own body, as CArray's kernel has it, and none between nodes.
+      FLAGS = ["-fPIC", "-shared", *CArray::BUILD_FLAGS.split,
+               "-ffp-contract=on", *DYNAMIC_LOOKUP].freeze
 
       C_TYPES = {
         float64: "double",  float32: "float",
@@ -73,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
@@ -117,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
@@ -128,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
@@ -246,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
@@ -351,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
@@ -387,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"
@@ -398,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