perf(stable-api): inline num2dbl T_FLOAT fast path for MRI (#733)

* perf(stable-api): inline num2dbl T_FLOAT fast path for MRI

Avoid the dylib call to rb_num2dbl for heap-allocated Float objects by
reading RFloat.float_value directly at offset 2*sizeof(VALUE). Falls back
to rb_num2dbl for Bignum, coercion (to_f), and TypeError cases.

The inline path is gated on #[cfg(not(target_pointer_width = "32"))] to
avoid alignment issues where double may be in a union on 32-bit platforms.

Applied to all 7 per-version stable-api files (2.7–4.0). Parity tests
added for Float::INFINITY, 1.0/3.0, and 1e300 (all heap-allocated).

Rust: 24 instructions  C (NUM2DBL macro → rb_num2dbl call): 3 instructions
Note: C count reflects a thin shim that unconditionally calls rb_num2dbl;
Rust count includes the fully-inlined flonum decode, fixnum convert,
heap-Float direct read (ldr d0, [x0, #16]), and dylib fallback.

* fix(test): handle oldmalloc_increase_bytes floor-at-0 in drop test

Ruby clamps oldmalloc_increase_bytes at 0 — if the counter is below
1024 when we call rb_gc_adjust_memory_usage(-1024), the observed delta
is less than 1024. This happens when earlier tests (especially the new
stable_api_test suite) promote Float/Hash objects that are then swept
by the full GC inside capture_gc_stat_for!, leaving a low baseline.

The exact -1024 case is already covered by
test_manually_tracked_decreases_on_drop which runs first with fresh GC
state. Relax this test to assert any decrease in 1..=1024.

Author: ianks

crates/rb-sys-tests/src/stable_api_test.rs

@@ -1570,6 +1570,33 @@ parity_test!(
     }
 );
 
+// Heap Float tests: values that are NOT flonums (stored as heap-allocated RFloat objects).
+// These exercise the new T_FLOAT fast path that reads RFloat.float_value directly.
+
+parity_test!(
+    name: test_num2dbl_heap_float_infinity,
+    func: num2dbl,
+    data_factory: {
+        ruby_eval!("Float::INFINITY")
+    }
+);
+
+parity_test!(
+    name: test_num2dbl_heap_float_one_third,
+    func: num2dbl,
+    data_factory: {
+        ruby_eval!("1.0 / 3.0")
+    }
+);
+
+parity_test!(
+    name: test_num2dbl_heap_float_large,
+    func: num2dbl,
+    data_factory: {
+        ruby_eval!("1e300")
+    }
+);
+
 #[rb_sys_test_helpers::ruby_test]
 fn test_dbl2num_and_num2dbl_roundtrip() {
     unsafe {

crates/rb-sys-tests/src/tracking_allocator_test.rs

@@ -57,7 +57,15 @@ fn test_manually_tracked_reports_memory_usage_on_drop() {
         std::mem::drop(manually_tracked);
     });
 
-    assert_eq!(-1024, decreased)
+    // Ruby floors oldmalloc_increase_bytes at 0, so if the counter was already
+    // below 1024 (due to GC state from earlier tests), the observed decrease is
+    // less than 1024. The exact -1024 case is covered by
+    // test_manually_tracked_decreases_on_drop which runs first with fresh state.
+    assert!(
+        (-1024..=-1).contains(&decreased),
+        "expected oldmalloc_increase_bytes to decrease by 1..=1024, got {}",
+        decreased
+    );
 }
 
 #[ruby_test]

crates/rb-sys/src/stable_api/ruby_2_7.rs

@@ -494,8 +494,25 @@ impl StableApiDefinition for Definition {
             // Fast path: convert Fixnum to double
             let long_val = (obj as c_long) >> 1;
             long_val as std::os::raw::c_double
+        } else if !self.special_const_p(obj)
+            && self.builtin_type(obj) == crate::ruby_value_type::RUBY_T_FLOAT
+        {
+            // Fast path: heap Float — read RFloat.float_value directly.
+            // RFloat = { RBasic basic (2*sizeof(VALUE) bytes); double float_value; }
+            // Avoids a dylib call for the common heap-Float case.
+            // SAFETY: builtin_type check guarantees obj is a valid heap RFloat pointer.
+            #[cfg(not(target_pointer_width = "32"))]
+            {
+                let float_val_ptr =
+                    (obj as *const crate::VALUE).add(2) as *const std::os::raw::c_double;
+                *float_val_ptr
+            }
+            #[cfg(target_pointer_width = "32")]
+            {
+                crate::rb_num2dbl(obj)
+            }
         } else {
-            // Slow path: heap Float, Bignum, or other numeric types
+            // Slow path: Bignum, coercion (to_f), TypeError, etc.
             crate::rb_num2dbl(obj)
         }
     }

crates/rb-sys/src/stable_api/ruby_3_0.rs

@@ -497,8 +497,25 @@ impl StableApiDefinition for Definition {
             // Fast path: convert Fixnum to double
             let long_val = (obj as c_long) >> 1;
             long_val as std::os::raw::c_double
+        } else if !self.special_const_p(obj)
+            && self.builtin_type(obj) == crate::ruby_value_type::RUBY_T_FLOAT
+        {
+            // Fast path: heap Float — read RFloat.float_value directly.
+            // RFloat = { RBasic basic (2*sizeof(VALUE) bytes); double float_value; }
+            // Avoids a dylib call for the common heap-Float case.
+            // SAFETY: builtin_type check guarantees obj is a valid heap RFloat pointer.
+            #[cfg(not(target_pointer_width = "32"))]
+            {
+                let float_val_ptr =
+                    (obj as *const crate::VALUE).add(2) as *const std::os::raw::c_double;
+                *float_val_ptr
+            }
+            #[cfg(target_pointer_width = "32")]
+            {
+                crate::rb_num2dbl(obj)
+            }
         } else {
-            // Slow path: heap Float, Bignum, or other numeric types
+            // Slow path: Bignum, coercion (to_f), TypeError, etc.
             crate::rb_num2dbl(obj)
         }
     }

crates/rb-sys/src/stable_api/ruby_3_1.rs

@@ -490,8 +490,25 @@ impl StableApiDefinition for Definition {
             // Fast path: convert Fixnum to double
             let long_val = (obj as c_long) >> 1;
             long_val as std::os::raw::c_double
+        } else if !self.special_const_p(obj)
+            && self.builtin_type(obj) == crate::ruby_value_type::RUBY_T_FLOAT
+        {
+            // Fast path: heap Float — read RFloat.float_value directly.
+            // RFloat = { RBasic basic (2*sizeof(VALUE) bytes); double float_value; }
+            // Avoids a dylib call for the common heap-Float case.
+            // SAFETY: builtin_type check guarantees obj is a valid heap RFloat pointer.
+            #[cfg(not(target_pointer_width = "32"))]
+            {
+                let float_val_ptr =
+                    (obj as *const crate::VALUE).add(2) as *const std::os::raw::c_double;
+                *float_val_ptr
+            }
+            #[cfg(target_pointer_width = "32")]
+            {
+                crate::rb_num2dbl(obj)
+            }
         } else {
-            // Slow path: heap Float, Bignum, or other numeric types
+            // Slow path: Bignum, coercion (to_f), TypeError, etc.
             crate::rb_num2dbl(obj)
         }
     }

crates/rb-sys/src/stable_api/ruby_3_2.rs

@@ -488,8 +488,25 @@ impl StableApiDefinition for Definition {
         } else if self.fixnum_p(obj) {
             // Fast path: convert Fixnum to double
             self.fix2long(obj) as std::os::raw::c_double
+        } else if !self.special_const_p(obj)
+            && self.builtin_type(obj) == crate::ruby_value_type::RUBY_T_FLOAT
+        {
+            // Fast path: heap Float — read RFloat.float_value directly.
+            // RFloat = { RBasic basic (2*sizeof(VALUE) bytes); double float_value; }
+            // Avoids a dylib call for the common heap-Float case.
+            // SAFETY: builtin_type check guarantees obj is a valid heap RFloat pointer.
+            #[cfg(not(target_pointer_width = "32"))]
+            {
+                let float_val_ptr =
+                    (obj as *const crate::VALUE).add(2) as *const std::os::raw::c_double;
+                *float_val_ptr
+            }
+            #[cfg(target_pointer_width = "32")]
+            {
+                crate::rb_num2dbl(obj)
+            }
         } else {
-            // Slow path: heap Float, Bignum, or other numeric
+            // Slow path: Bignum, coercion (to_f), TypeError, etc.
             crate::rb_num2dbl(obj)
         }
     }

crates/rb-sys/src/stable_api/ruby_3_3.rs

@@ -500,8 +500,25 @@ impl StableApiDefinition for Definition {
             // Fast path: convert Fixnum to double
             let long_val = (obj as c_long) >> 1;
             long_val as std::os::raw::c_double
+        } else if !self.special_const_p(obj)
+            && self.builtin_type(obj) == crate::ruby_value_type::RUBY_T_FLOAT
+        {
+            // Fast path: heap Float — read RFloat.float_value directly.
+            // RFloat = { RBasic basic (2*sizeof(VALUE) bytes); double float_value; }
+            // Avoids a dylib call for the common heap-Float case.
+            // SAFETY: builtin_type check guarantees obj is a valid heap RFloat pointer.
+            #[cfg(not(target_pointer_width = "32"))]
+            {
+                let float_val_ptr =
+                    (obj as *const crate::VALUE).add(2) as *const std::os::raw::c_double;
+                *float_val_ptr
+            }
+            #[cfg(target_pointer_width = "32")]
+            {
+                crate::rb_num2dbl(obj)
+            }
         } else {
-            // Slow path: heap Float, Bignum, or other numeric types
+            // Slow path: Bignum, coercion (to_f), TypeError, etc.
             crate::rb_num2dbl(obj)
         }
     }

crates/rb-sys/src/stable_api/ruby_3_4.rs

@@ -512,8 +512,25 @@ impl StableApiDefinition for Definition {
         } else if self.fixnum_p(obj) {
             // Fast path: convert Fixnum to double
             self.fix2long(obj) as std::os::raw::c_double
+        } else if !self.special_const_p(obj)
+            && self.builtin_type(obj) == crate::ruby_value_type::RUBY_T_FLOAT
+        {
+            // Fast path: heap Float — read RFloat.float_value directly.
+            // RFloat = { RBasic basic (2*sizeof(VALUE) bytes); double float_value; }
+            // Avoids a dylib call for the common heap-Float case.
+            // SAFETY: builtin_type check guarantees obj is a valid heap RFloat pointer.
+            #[cfg(not(target_pointer_width = "32"))]
+            {
+                let float_val_ptr =
+                    (obj as *const crate::VALUE).add(2) as *const std::os::raw::c_double;
+                *float_val_ptr
+            }
+            #[cfg(target_pointer_width = "32")]
+            {
+                crate::rb_num2dbl(obj)
+            }
         } else {
-            // Slow path: heap Float, Bignum, or other numeric
+            // Slow path: Bignum, coercion (to_f), TypeError, etc.
             crate::rb_num2dbl(obj)
         }
     }

crates/rb-sys/src/stable_api/ruby_4_0.rs

@@ -508,8 +508,25 @@ impl StableApiDefinition for Definition {
         } else if self.fixnum_p(obj) {
             // Fast path: convert Fixnum to double
             ((obj as c_long) >> 1) as std::os::raw::c_double
+        } else if !self.special_const_p(obj)
+            && self.builtin_type(obj) == crate::ruby_value_type::RUBY_T_FLOAT
+        {
+            // Fast path: heap Float — read RFloat.float_value directly.
+            // RFloat = { RBasic basic (2*sizeof(VALUE) bytes); double float_value; }
+            // Avoids a dylib call for the common heap-Float case.
+            // SAFETY: builtin_type check guarantees obj is a valid heap RFloat pointer.
+            #[cfg(not(target_pointer_width = "32"))]
+            {
+                let float_val_ptr =
+                    (obj as *const crate::VALUE).add(2) as *const std::os::raw::c_double;
+                *float_val_ptr
+            }
+            #[cfg(target_pointer_width = "32")]
+            {
+                crate::rb_num2dbl(obj)
+            }
         } else {
-            // Slow path: heap Float, Bignum, or other numeric
+            // Slow path: Bignum, coercion (to_f), TypeError, etc.
             crate::rb_num2dbl(obj)
         }
     }

script/show-asm

@@ -100,6 +100,12 @@ FUNCTIONS = [
     c: {expr: "RB_FLOAT_TYPE_P(v)", ret: "int"},
     ruby_source: "include/ruby/internal/value_type.h:RB_FLOAT_TYPE_P"
   },
+  {
+    name: "num2dbl",
+    rust: {unsafe: true, ret: "f64", expr: "{ let api = rb_sys::stable_api::get_default(); api.num2dbl(v) }"},
+    c: {expr: "NUM2DBL(v)", ret: "double"},
+    ruby_source: "include/ruby/internal/arithmetic/double.h:NUM2DBL"
+  },
   {
     name: "integer_type_p",
     rust: {unsafe: true, ret: "bool", expr: "rb_sys::RB_INTEGER_TYPE_P(v)"},