hypercast 0.1.0-aarch64-linux → 0.2.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4d1833782f7f522eccac5ec7b42093b3938f370177088898b2ad8dd4de75e9c
-  data.tar.gz: a8510c912cd6a1ec2d89afac1dc726173080594fd7d59cbc9b24b37cbb063dab
+  metadata.gz: 4413f5f3ec544107c724ad495a86ca78f0b5d88c06caacbece6c7e5c75b39746
+  data.tar.gz: d5e49cb6a3bacdbbeeabafe78954bea6de0ead9973fb22e945339a5c3f19ed97
 SHA512:
-  metadata.gz: 43e9c8810af57e464d3dc6ea93aac23d19221a32da79029b030866a52784a3dd466865c99644e98b68a3537230baf307fe0db579b7c748934b9a897e0dfe9341
-  data.tar.gz: df57134e54feea30a56ad2f8ed614493f14d077f9cb51e9d585be3758ad0a8b0d56e90091439bbcd3adee1886dfb781154b5b012ec43f5abf448d8732d1244b2
+  metadata.gz: 05ce5c94b6f3f1ccfd0e9d40bfcb6710acb0b5332141703519a8b74a244d273d9948cf8048873c80fcc475adfaa9c5c85c421559044fa653f6f4343440ea456b
+  data.tar.gz: fbec449055ddc9b1d0cee98b325e1287feedf493f4c69d3b76a3ba3c99e6588c38349b0da343ebd7561a20e2993d924e13a7b582aa0026a19d5ca93db7ac5a50

data/README.md

@@ -48,9 +48,17 @@ midnight, and durations come back as exact `Rational` seconds across the core's
    duration door. The Fiddle fallback lands at ~3.5 µs: parity with `Time.iso8601`, sitting
    on Fiddle's measured 1.6 µs per-call marshalling floor.
 
-   Separator detection is free here: `1.234.567,89` under `NumFormat::DETECT` runs
-   1.073M i/s against 1.092M i/s for the same text under a declared eurozone format —
-   inside the error bars.
+   Separator detection is free here: `1.234.567,89` under `NumFormat::DETECT` runs at
+   591 ns against 570 ns for the same text under a declared eurozone format — inside the
+   error bars. Both of those were ~990 ns in 0.1.0, for a reason that had nothing to do
+   with parsing: every format other than `INVARIANT` paid three method dispatches and two
+   `String` allocations per call to read its separators back out of the `Data`. `DETECT`
+   is now identity-matched like `INVARIANT`, and any other format is resolved once per
+   thread and memoized by identity — anchored in a thread-variable so the memo's key can
+   never be a recycled address — which turned the per-call cost into one pointer compare.
+   The three reason Symbols and the option Symbols (`:seconds`, `:month_day_year`, …) are
+   cached the same way, so a fault or a declared option is a pointer compare too, never a
+   `Symbol#name` materialization.
 
 **The honest trade-off, and Ruby's one real loss:** the civil date-time door is *slower*
 than `strptime` — 1.30 µs against `DateTime.strptime`'s 1.02 µs, and the date door 1.04 µs
@@ -63,9 +71,38 @@ defaults to `+00:00`, which is an artifact of the type, not a zone the parse ass
 
 On the Fiddle fallback the doors are parity-at-best — Fiddle's
 per-call floor is the mechanism's price, kept because it's the universal zero-compile
-path. (Benchmark forensics worth knowing: the doors read 4.3 µs until per-call
-`Fiddle::Pointer.malloc` finalizers were hoisted to thread-local scratch — receipts
-include their own archaeology.)
+path. 0.2.0 still took ~20% off its numeric doors (`i32` 3.37 → 2.62 µs, `f64` 3.31 →
+2.76 µs, same session) by not building things per call that never changed: the integer
+doors interpolated and interned their `:cast_*` Symbol on every call, every door went
+through a splat-and-resplat dispatcher, and every numeric call copied the format's 12
+packed bytes into scratch — each format now owns one native pointer, memoized by identity,
+passed straight through. (Benchmark forensics worth knowing: the doors read 4.3 µs until
+per-call `Fiddle::Pointer.malloc` finalizers were hoisted to thread-local scratch —
+receipts include their own archaeology.)
+
+## Verifying provenance
+
+Every gem RubyGems.org serves — the universal fallback and each of the six precompiled
+platform gems — carries its own GitHub build-provenance attestation, signed directly by
+this repo's own `release.yml` (the `rubygems-publish` job attests `ruby/pkg/*.gem` right
+before the push), so plain `--repo` verifies any of them:
+
+```sh
+gem fetch hypercast -v X.Y.Z --platform <platform>   # or omit --platform for the universal gem
+gh attestation verify hypercast-X.Y.Z-<platform>.gem --repo SkunkWerkx/HyperCast
+```
+
+That's the release's second layer of checking, not the only one: before any gem gets built,
+the same job verifies every native binary it packs (six FFI libs, twelve Magnus extensions —
+two ABIs per platform) against *their own* attestations — those are signed from
+`SkunkWerkx/.github` by `hyper-build-native.yml`, so that check needs
+`--signer-repo SkunkWerkx/.github` added — and refuses to proceed on an unverified one.
+RubyGems.org has no unpublish and no duplicate-version overwrite, so this all happens while a
+bad artifact is still reversible. The release run's job summary then re-fetches every gem
+from the CDN and records attested-vs-served digests, turning "rubygems.org stores an upload
+verbatim" into a per-release measurement rather than an assumption — see
+[csharp/README.md's provenance section](../csharp/README.md#native-binary-provenance) for
+more on why `--signer-repo` is needed for some artifacts here and not others.
 
 ## Install
 
@@ -73,11 +110,41 @@ include their own archaeology.)
 gem install hypercast
 ```
 
-Five gems are published per release: one universal `ruby`-platform gem (pure Fiddle, all six
-platforms' natives bundled) plus four precompiled Magnus platform gems (`x86_64-linux`,
-`aarch64-linux`, `x86_64-darwin`, `arm64-darwin`) that `gem install` auto-selects when they
-match. Nobody ever compiles anything; Windows and any unmatched platform land on the
-universal gem's Fiddle backend, which replays the same corpus green.
+Seven gems are published per release: one universal `ruby`-platform gem (pure Fiddle, all
+six platforms' natives bundled) plus six precompiled Magnus platform gems (`x86_64-linux`,
+`aarch64-linux`, `x86_64-darwin`, `arm64-darwin`, `x64-mingw-ucrt`, `aarch64-mingw-ucrt`)
+that `gem install` auto-selects when they match. Nobody ever compiles anything.
+
+Selection has **two** axes here, unlike every other binding in this repo. A Magnus extension
+is bound to one Ruby minor ABI — there is no `abi3` equivalent to collapse the version axis
+the way [the Python binding's](../python/) wheels do — so each platform gem is a "fat" gem
+carrying one compiled extension per supported Ruby, under `lib/hypercast/<minor>/`, and picks
+one at `require` time:
+
+| Ruby | the six platforms above | anywhere else (musl/Alpine, …) |
+| --- | --- | --- |
+| 4.0 (primary) | Magnus, `backend: :native` | Fiddle |
+| 3.4 (floor, until its EOL 2028-03-31) | Magnus, `backend: :native` | Fiddle |
+| 3.2 / 3.3 | Fiddle | Fiddle |
+
+The platform gems declare `required_ruby_version >= 3.4, < 4.1` precisely so RubyGems
+*declines* them outside that range and resolves the universal gem instead — a wrong-ABI
+extension must never be installed in the first place. On Windows it would at least fail to
+load cleanly (the extension imports `<arch>-ucrt-ruby<minor>.dll` by name —
+`x64-ucrt-ruby400.dll` on x64, `aarch64-ucrt-ruby400.dll` on ARM), but Linux extensions don't
+link libruby at all, so one can load successfully against the wrong ABI and misbehave later.
+Every cell in that table replays the same corpus green.
+
+Both Windows architectures get a Magnus gem, and the reasoning that once kept them on Fiddle
+was backwards: MinGW is the *only* Windows flavour `rb-sys` targets (`x64-mingw-ucrt` and
+`aarch64-mingw-ucrt`, both `supported: true` in its own `data/toolchains.json`); the one it
+has no support for is MSVC. Windows is also where the Fiddle fallback cost the most, so these
+are the most worthwhile gems in the set. Both extensions are built for the `gnullvm` Rust
+targets rather than `gnu` — the same mingw-w64/UCRT ABI RubyInstaller's Ruby uses, linked
+with LLVM and compiler-rt instead of GCC and a statically-linked libgcc, which is what keeps
+the shipped extension small. The build script, and the two flags that are load-bearing on
+the ARM leg (a static libunwind, and a clang-spelled `--target` for bindgen), live in the
+forge's `hyper-build-native.yml`, shared with every other Hyper* repo.
 
 See [the repo root README](../README.md) for the full door table, the receipts, and the
 state of every other language binding.

data/lib/hypercast/runtime.rb

@@ -29,8 +29,10 @@ module HyperCast
     @functions = nil
 
     class << self
-      def call(symbol, *args)
-        functions.fetch(symbol).call(*args)
+      # The door's Fiddle::Function, for the caller to invoke directly — a splat-through
+      # `call(symbol, *args)` here built and re-splatted an Array on every cast.
+      def function(symbol)
+        functions.fetch(symbol)
       end
 
       private

data/lib/hypercast.rb

@@ -23,7 +23,7 @@ require_relative "hypercast/runtime"
 module HyperCast
   # This gem's own version — kept in lockstep with hypercast.gemspec by the
   # prepare-release workflow, so the two can never drift apart again.
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 
   # The success case of a verdict: a cast value.
   Success = Data.define(:value)
@@ -120,11 +120,14 @@ module HyperCast
       .each do |door, unpack|
       sizes = { "c" => 1, "C" => 1, "s<" => 2, "S<" => 2, "l<" => 4, "L<" => 4, "q<" => 8, "Q<" => 8 }
       size = sizes.fetch(unpack)
+      # Resolved once here, not inside the method: interpolating a Symbol per call built a
+      # String and interned it on every integer cast.
+      symbol = :"cast_#{door}"
       # Integer doors: the target type's own range, declared grouping, accounting parens,
       # non-negative exponent, and 0x/&H/0b two's-complement radix prefixes. Ruby Integer
       # is unbounded, so u64 comes back as the true unsigned value.
       define_method(door) do |text, format|
-        numeric(:"cast_#{door}", text, format, size) { |out| out.unpack1(unpack) }
+        numeric(symbol, text, format, size) { |out| out.unpack1(unpack) }
       end
     end
 
@@ -161,7 +164,7 @@ module HyperCast
       code = UNIX_PRECISIONS.fetch(precision)
       bytes = utf8(text)
       out, fault, = scratch
-      rc = Runtime.call(:cast_unix, input_ptr(bytes), bytes.bytesize, code, out, fault)
+      rc = Runtime.function(:cast_unix).call(input_ptr(bytes), bytes.bytesize, code, out, fault)
       verdict(rc, fault) { instant(out[0, 16]) }
     end
 
@@ -179,7 +182,7 @@ module HyperCast
       code = EXCEL_EPOCHS.fetch(epoch)
       bytes = utf8(text)
       out, fault, = scratch
-      rc = Runtime.call(:cast_excel_serial, input_ptr(bytes), bytes.bytesize, code, out, fault)
+      rc = Runtime.function(:cast_excel_serial).call(input_ptr(bytes), bytes.bytesize, code, out, fault)
       verdict(rc, fault) { instant(out[0, 16]) }
     end
 
@@ -198,7 +201,7 @@ module HyperCast
         code = DATE_ORDERS.fetch(order)
         bytes = utf8(text)
         out, fault, = scratch
-        rc = Runtime.call(:cast_date_ordered, input_ptr(bytes), bytes.bytesize, code, out, fault)
+        rc = Runtime.function(:cast_date_ordered).call(input_ptr(bytes), bytes.bytesize, code, out, fault)
         verdict(rc, fault) do
           year, month, day = out[0, 4].unpack("S<CC")
           Date.new(year, month, day)
@@ -218,7 +221,7 @@ module HyperCast
       code = DATE_ORDERS.fetch(order)
       bytes = utf8(text)
       out, fault, = scratch
-      rc = Runtime.call(:cast_datetime, input_ptr(bytes), bytes.bytesize, code, out, fault)
+      rc = Runtime.function(:cast_datetime).call(input_ptr(bytes), bytes.bytesize, code, out, fault)
       verdict(rc, fault) do
         year, month, day, nanos = out[0, 16].unpack("S<CCx4Q<")
         second_of_day, frac = nanos.divmod(1_000_000_000)
@@ -261,14 +264,16 @@ module HyperCast
       bytes.empty? ? nil : bytes
     end
 
-    # One 36-byte scratch allocation per thread, reused by every call: out-value at 0
-    # (16 bytes covers every door), fault span at 16, NumFormat at 24. Two
-    # Fiddle::Pointer.malloc(..., RUBY_FREE) calls per cast — each registering a GC
-    # finalizer — measured as the dominant per-call cost by an order of magnitude.
+    # One 24-byte scratch allocation per thread, reused by every call: out-value at 0
+    # (16 bytes covers every door), fault span at 16. Two Fiddle::Pointer.malloc(...,
+    # RUBY_FREE) calls per cast — each registering a GC finalizer — measured as the
+    # dominant per-call cost by an order of magnitude. The NumFormat no longer lives here:
+    # each format owns its own packed pointer (see packed_cache), so a numeric call copies
+    # nothing into scratch before crossing.
     def scratch
       Thread.current[:hypercast_scratch] ||= begin
-        base = Fiddle::Pointer.malloc(36, Fiddle::RUBY_FREE)
-        [base, base + 16, base + 24]
+        base = Fiddle::Pointer.malloc(24, Fiddle::RUBY_FREE)
+        [base, base + 16]
       end
     end
 
@@ -288,24 +293,31 @@ module HyperCast
     # The shared body of every format-free door: one native call over the scratch buffers.
     def plain(symbol, text, out_size)
       bytes = utf8(text)
-      out, fault, = scratch
-      rc = Runtime.call(symbol, input_ptr(bytes), bytes.bytesize, out, fault)
+      out, fault = scratch
+      rc = Runtime.function(symbol).call(input_ptr(bytes), bytes.bytesize, out, fault)
       verdict(rc, fault) { yield(out[0, out_size]) }
     end
 
-    # The shared body of the integer/real doors: plain, plus the packed NumFormat.
+    # The shared body of the integer/real doors: plain, plus the format's own packed
+    # pointer, passed straight through — no per-call copy of the 12 bytes into scratch.
     def numeric(symbol, text, format, out_size)
       bytes = utf8(text)
-      out, fault, raw_format = scratch
-      raw_format[0, 12] = packed_cache[format]
-      rc = Runtime.call(symbol, input_ptr(bytes), bytes.bytesize, raw_format, out, fault)
+      out, fault = scratch
+      rc = Runtime.function(symbol).call(input_ptr(bytes), bytes.bytesize, packed_cache[format], out, fault)
       verdict(rc, fault) { yield(out[0, out_size]) }
     end
 
-    # Identity-keyed memo of NumFormat#packed — formats are reused constants in practice,
-    # and re-packing per call is a measurable allocation. The race is benign (idempotent).
+    # Identity-keyed memo (compare_by_identity — a pointer hash, not Data's structural
+    # #hash over two Strings and an Integer) of a native 12-byte RawNumFormat per format
+    # object, filled once from NumFormat#packed. Formats are reused constants in practice,
+    # so the common call finds its pointer in one lookup and packs nothing. The Hash holds
+    # the format, so a key can never be a recycled address; the race is benign (idempotent).
     def packed_cache
-      @packed_cache ||= Hash.new { |cache, format| cache[format] = format.packed }
+      @packed_cache ||= Hash.new do |cache, format|
+        pointer = Fiddle::Pointer.malloc(12, Fiddle::RUBY_FREE)
+        pointer[0, 12] = format.packed
+        cache[format] = pointer
+      end.compare_by_identity
     end
 
     # Builds a UTC Time from the core's protobuf-shaped {seconds, nanos} pair, exactly.
@@ -325,10 +337,24 @@ HyperCast::BACKEND =
   if ENV["HYPERCAST_PURE"]
     :fiddle
   else
+    # Two layouts, and both have to work. A released platform gem is a "fat" gem carrying one
+    # extension per supported Ruby ABI under lib/hypercast/<minor>/ (see the Rakefile's
+    # native:gem task for why an ABI-per-file is unavoidable — Magnus has no `abi3`
+    # equivalent). CI's in-job staging and a local `cargo build --release --features ruby`
+    # instead drop a single extension flat at lib/. Trying the versioned path first and the
+    # flat one second means neither has to know the other exists.
+    #
+    # A miss on both is not an error: it means this Ruby/platform combination has no
+    # precompiled extension, which is precisely what the Fiddle backend is for.
     begin
-      require "hypercast_native"
+      require "hypercast/#{RUBY_VERSION[/\d+\.\d+/]}/hypercast_native"
       :native
     rescue LoadError
-      :fiddle
+      begin
+        require "hypercast_native"
+        :native
+      rescue LoadError
+        :fiddle
+      end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hypercast
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: aarch64-linux
 authors:
 - Brian Buvinghausen
@@ -64,6 +64,8 @@ files:
 - LICENSE
 - README.md
 - lib/hypercast.rb
+- lib/hypercast/3.4/hypercast_native.so
+- lib/hypercast/4.0/hypercast_native.so
 - lib/hypercast/native/linux-arm64/libhypercast.so
 - lib/hypercast/native/linux-x64/libhypercast.so
 - lib/hypercast/native/osx-arm64/libhypercast.dylib
@@ -72,7 +74,6 @@ files:
 - lib/hypercast/native/win-x64/hypercast.dll
 - lib/hypercast/native_platform.rb
 - lib/hypercast/runtime.rb
-- lib/hypercast_native.so
 homepage: https://github.com/SkunkWerkx/HyperCast
 licenses:
 - MIT
@@ -85,14 +86,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.4'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '4.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Allocation-free scalar parsing as Success/Fault verdicts over a native Rust
   core