rudy4 0.2.0

data/experiments/exp_nonregression.d

@@ -0,0 +1,209 @@
+/// EXPERIMENT 11 — Documented non-goals (backlog item 9).
+///
+/// This experiment exists to put *evidence* behind the three documented
+/// non-goals rather than silence:
+///
+///   1. Fiber switching across D frames — a Ruby Fiber may switch stacks
+///      while D frames sit below on the fiber's stack. Simple value
+///      round-trips work (D frames are plain C frames and survive the
+///      switch), but D's GC registers the *thread* stack, not Ruby's
+///      separate fiber stacks — so a D heap object reachable only from a
+///      fiber-stack local has no root. NOT SUPPORTED as a guarantee; the
+///      probes below show what does work and mark what is not.
+///   2. Ractor-shareability — a D-wrapped object is an opaque non-Ruby
+///      object with a D-runtime-owned payload; it is not shareable and
+///      cannot be moved to another Ractor safely. D runtime TLS also has
+///      to initialise on the Ractor's foreign thread. NOT SUPPORTED.
+///   3. Interruptibility of a long GVL-held D call — while D holds the
+///      GVL, Ruby cannot run its signal/interrupt checks, so Ctrl-C
+///      during `fib(40)` is delivered only after the D call returns.
+///      Inherent to holding the GVL, not a rudy bug (the GVL-released
+///      variant IS interruptible — that is the whole point of
+///      `rb_thread_call_without_gvl`).
+///
+/// Probe surface (module `DNonReg`):
+///   DNonReg.fib(n)            — pure-D tree recursion (the "fib(40)" case)
+///   DNonReg.sleep_gvl(ms)     — busy-wait holding the GVL (uninterruptible)
+///   DNonReg.nap_nogvl(ms)     — busy-wait with the GVL released (interruptible)
+///   DNonReg.helper_check()    — new/delete a D object whose ctor takes a
+///                               live Ruby VALUE (per-thread D runtime probe)
+///   DNonRegBox.new(x, y)      — a D-wrapped (protocol'd) object to ferry
+///   DNonRegBox#[] / #[]=      — read / frozen-guarded write
+///   DNonRegBox#roundtrip { }  — read, Ruby-yield, read again (Fiber probe)
+///
+/// The interruptibility probe lives in the Ruby suite (it forks a
+/// subprocess and signals it); everything else is in-process.
+
+module exp_nonregression;
+
+import rudy.bind.value;
+import rudy.convert;
+import rudy.typeddata;
+import rudy.objproto;
+import rudy.defs;
+
+import core.runtime : rt_init;
+import core.time : MonoTime, msecs;
+import std.string : format;
+
+private:
+
+// ------------------------------------------------------------------ fib
+// The fresh-stack case from the backlog: a long, pure-D, GVL-held call.
+long nr_fib(long n)
+{
+    return n < 2 ? n : nr_fib(n - 1) + nr_fib(n - 2);
+}
+
+// ---------------------------------------------------- GVL / no-GVL waits
+// Busy-wait holding the GVL: Ruby's signal checks cannot run until we
+// return. This is the "Ctrl-C during fib(40) is late" case, made
+// deterministic with a wall-clock bound instead of a CPU-bound fib.
+long nr_sleep_gvl(long ms)
+{
+    auto t0 = MonoTime.currTime;
+    while ((MonoTime.currTime - t0) < msecs(ms))
+    { /* spin with the GVL held */ }
+    return ms;
+}
+
+private __gshared long g_nogvl_ms = 0;
+// Set by the unblock function when Ruby asks the blocking region to stop
+// (e.g. SIGINT while the GVL is released). A COOPERATING body checks it;
+// with a no-op ubf the wait would still run to completion.
+private __gshared bool g_nogvl_abort = false;
+
+extern (C) void* nr_nap_body(void* data)
+{
+    auto t0 = MonoTime.currTime;
+    while (!g_nogvl_abort && (MonoTime.currTime - t0) < msecs(g_nogvl_ms))
+    { /* spin with the GVL released — no Ruby API touched */ }
+    return null;
+}
+
+extern (C) void nr_nap_ubf(void* data)
+{
+    g_nogvl_abort = true;   // the cancellation hook
+}
+
+// Same wait, but with the GVL released via rb_thread_call_without_gvl:
+// Ruby keeps running on other threads and CAN deliver an interrupt — the
+// ubf flips g_nogvl_abort and the body bails out early.
+long nr_nap_nogvl(long ms)
+{
+    g_nogvl_ms = ms;
+    g_nogvl_abort = false;
+    rb_thread_call_without_gvl(&nr_nap_body, null, &nr_nap_ubf, null);
+    return ms;
+}
+
+// ---------------------------------------------------- D runtime probe
+// A D object whose constructor takes a live Ruby VALUE (so the
+// constructor touches the D GC/runtime, not just the stack). Created and
+// deleted entirely inside the call: from a Ractor this exercises
+// druntime initialisation on a foreign thread.
+class DHelper
+{
+    VALUE tag_ = Qnil_;
+    long n_ = 0;
+
+    this(VALUE tag, long n)
+    {
+        tag_ = tag;
+        n_ = n;
+    }
+
+    long compute() const
+    {
+        return n_ * 2;
+    }
+
+    ~this() {}
+}
+
+long nr_helper_check()
+{
+    auto h = new DHelper(rb_str_new("probe", 5), 21);
+    scope (exit) destroy(h);
+    return h.compute();
+}
+
+// ---------------------------------------------------- wrapped box
+struct Box
+{
+    double x, y;
+}
+
+mixin RudyTypedData!(Box, "box");
+
+private string box_inspect(ref const Box p)
+{
+    return format("x=%g y=%g", p.x, p.y);
+}
+
+mixin RudyObjectProtocol!(Box, "box", null, null, null, box_inspect);
+
+// `box_proto_install` (generated) installs the allocator + initialize_copy
+// + ==/eql?/hash/inspect. `box_get` (generated by RudyTypedData) reads the
+// wrapped struct back out.
+
+extern (C) VALUE box_init(VALUE self, VALUE x, VALUE y)
+{
+    Box* p = box_get(self);
+    p.x = d_type!double(x);
+    p.y = d_type!double(y);
+    return self;
+}
+
+extern (C) VALUE box_nth(VALUE self, VALUE k)
+{
+    Box* p = box_get(self);
+    return d_type!long(k) == 0 ? to_ruby_value(p.x) : to_ruby_value(p.y);
+}
+
+extern (C) VALUE box_set(VALUE self, VALUE k, VALUE v)
+{
+    rb_check_frozen(self);
+    Box* p = box_get(self);
+    if (d_type!long(k) == 0) p.x = d_type!double(v);
+    else p.y = d_type!double(v);
+    return v;
+}
+
+// read -> yield to Ruby -> read again: the D frame and the wrapped struct
+// must both survive a Fiber switch performed inside the block. The block
+// is captured via the C API (rb_block_given_p + rb_block_proc) because
+// this is a hand-written method; a def!'d function would take RubyBlock.
+extern (C) VALUE box_roundtrip(VALUE self, VALUE)
+{
+    Box* p = box_get(self);
+    double before = p.x;
+    if (rb_block_given_p() != 0)
+    {
+        VALUE proc = rb_block_proc();
+        rb_funcallv(proc, rb_intern("call"), 0, null);
+    }
+    double after = p.x;
+    return to_ruby_value(before == after ? before : -1.0);
+}
+
+public:
+
+pragma(mangle, "Init_exp_nonregression")
+extern (C) void Init_exp_nonregression()
+{
+    rt_init();
+
+    VALUE m = rb_define_module("DNonReg");
+    def!("DNonReg", nr_fib, "fib");
+    def!("DNonReg", nr_sleep_gvl, "sleep_gvl");
+    def!("DNonReg", nr_nap_nogvl, "nap_nogvl");
+    def!("DNonReg", nr_helper_check, "helper_check");
+
+    VALUE c = rb_define_class("DNonRegBox", rb_cObject);
+    box_proto_install(c);
+    rb_define_method(c, "initialize", cast(AnyMethod) &box_init, 2);
+    rb_define_method(c, "[]", cast(AnyMethod) &box_nth, 1);
+    rb_define_method(c, "[]=", cast(AnyMethod) &box_set, 2);
+    rb_define_method(c, "roundtrip", cast(AnyMethod) &box_roundtrip, 0);
+}

data/experiments/exp_objproto.d

@@ -0,0 +1,123 @@
+/// EXPERIMENT 10 — Object protocol for wrapped structs.
+///
+/// A RudyTypedData wrapper without object-protocol methods is a
+/// second-class Ruby citizen:
+///   - dup/clone shallow-copy the WRAPPER: two handles, one struct —
+///     mutating the copy mutates the "original" (finding #19)
+///   - == never fires (Object#== is identity), Hash keys collide on
+///     identity hash (finding #20),
+///   - freeze() sets a flag nothing enforces: mutators write straight
+///     through into the "frozen" struct (finding #20),
+///   - inspect shows #<Class:0x...> (finding #21),
+///   - allocate()/initialize_copy don't exist — Ruby-level dup/clone
+///     crash with "allocator undefined" (finding #22).
+///
+/// The RudyObjectProtocol mixin generates the C-API-standard fix:
+///   allocate   = rb_data_typed_object_zalloc (zeroed T in Ruby's heap)
+///   initialize_copy = in-place struct copy (dup AND clone route
+///                through this one hook; clone propagates frozen state)
+///   == / eql?  = memcmp over T.sizeof (custom equalsHook allowed)
+///   hash       = FNV-1a over T.sizeof (==/hash contract holds)
+///   inspect    = "#<Name inner>" via hook
+/// And mutators guard themselves with rb_check_frozen — the exported
+/// C-API freeze enforcement, wired at def! registration sites.
+///
+/// Torture surface (Vec2, malloc'd in Init-set variants):
+///   DVec2.new/[]  — construct via protocol'd class
+///   dup/clone     — independence, frozen-state propagation
+///   ==/hash       — Hash keying, Dictionary-style lookups
+///   inspect       — human-readable output
+///   freeze        — FrozenError from guarded mutators, read methods OK
+///   GC storm      — dup'd wrappers + Ruby GC.collect + D GC.collect
+
+module exp_objproto;
+
+import rudy.bind.value;
+import rudy.convert;
+import rudy.typeddata;
+import rudy.objproto;
+import rudy.defs;
+
+import core.runtime : rt_init;
+import core.stdc.stdlib : malloc, free;
+import core.memory : GC;
+import std.string : format;
+
+private:
+
+struct Vec2
+{
+    double x, y;
+    double extra;   // padding makes byte-compare non-trivial
+}
+
+mixin RudyTypedData!(Vec2, "vec2");
+
+private string vec2_inspect(ref const Vec2 p)
+{
+    return format("x=%g y=%g", p.x, p.y);
+}
+
+mixin RudyObjectProtocol!(Vec2, "vec2",
+                          null, null, null,
+                          vec2_inspect);
+
+__gshared VALUE vec2_klass;
+
+// ---- mutators: rb_check_frozen wired by hand (the C-API guard) ----
+
+extern (C) VALUE vec2_set(VALUE self, VALUE k, VALUE v)
+{
+    rb_check_frozen(self);
+    Vec2* p = vec2_get(self);
+    switch (d_type!long(k)) {
+        case 0: p.x = d_type!double(v); break;
+        case 1: p.y = d_type!double(v); break;
+        default: p.extra = d_type!double(v); break;
+    }
+    return v;
+}
+
+extern (C) VALUE vec2_nth(VALUE self, VALUE k)
+{
+    Vec2* p = vec2_get(self);
+    final switch (d_type!long(k)) {
+        case 0: return to_ruby_value(p.x);
+        case 1: return to_ruby_value(p.y);
+        case 2: return to_ruby_value(p.extra);
+    }
+}
+
+// ---- init ---------------------------------------------------------
+
+pragma(mangle, "Init_exp_objproto")
+extern (C) void Init_exp_objproto()
+{
+    rt_init();
+
+    VALUE c = rb_define_class("DRudyVec", rb_cObject);
+    vec2_klass = c;
+
+    // the object protocol (allocate/initialize_copy/==/eql?/hash/inspect)
+    vec2_proto_install(c);
+
+    // simple 2-arg initialize (zalloc'd struct, then set)
+    rb_define_method(c, "initialize", cast(AnyMethod) &vec2_init, 2);
+    rb_define_method(c, "[]", cast(AnyMethod) &vec2_nth, 1);
+    rb_define_method(c, "[]=", cast(AnyMethod) &vec2_set, 2);
+    rb_define_method(c, "norm2", cast(AnyMethod) &vec2_norm2, 0);
+}
+
+extern (C) VALUE vec2_init(VALUE self, VALUE x, VALUE y)
+{
+    Vec2* p = vec2_get(self);
+    p.x = d_type!double(x);
+    p.y = d_type!double(y);
+    return self;
+}
+
+extern (C) VALUE vec2_norm2(VALUE self)
+{
+    Vec2* p = vec2_get(self);
+    return to_ruby_value(p.x * p.x + p.y * p.y);
+}

data/experiments/exp_perf.d

@@ -0,0 +1,81 @@
+/// EXPERIMENT 3 — Performance & GC torture.
+///
+/// Torture elements:
+/// - tight loops crossing the boundary with def!-converted args
+/// - Ruby-side GC running while D holds wrapped pointers
+/// - fibonacci recursion through the boundary each level (worst case)
+/// - big arrays/hashes converted wholesale
+
+module exp_perf;
+
+import rudy.bind.value;
+import rudy.convert;
+import rudy.defs;
+import std.string : toStringz;
+
+private:
+
+// classic def! — ulong params decode correctly now (issue #1 fixed):
+// the trampoline used to pass TAGGED VALUEs to any ulong param.
+ulong perf_fib(ulong n)
+{
+    ulong fib(ulong k) { return k < 2 ? k : fib(k - 1) + fib(k - 2); }
+    // recursion stays in D — this measures D-side speed
+    return fib(n);
+}
+
+// boundary-crossing fib: each level goes back out to Ruby and returns
+extern (C) VALUE perf_fib_boundary(VALUE self, VALUE n)
+{
+    ulong k = d_type!ulong(n);
+    if (k < 2) return to_ruby_value(k);
+    VALUE[1] av1 = [to_ruby_value(k - 1)];
+    VALUE[1] av2 = [to_ruby_value(k - 2)];
+    VALUE mod = rb_const_get(rb_cObject, rb_intern("ExpPerf"));
+    ulong a = d_type!ulong(rb_funcallv(mod, rb_intern("fib_boundary"), 1, av1.ptr));
+    ulong b = d_type!ulong(rb_funcallv(mod, rb_intern("fib_boundary"), 1, av2.ptr));
+    return to_ruby_value(a + b);
+}
+
+// build a 100k-element Array of Floats in D, sum in D
+extern (C) VALUE perf_build(VALUE self, VALUE n)
+{
+    long len = d_type!long(n);
+    VALUE ary = rb_ary_new_capa(len);
+    double total = 0.0; // uninit double is NaN in D
+    foreach (i; 0 .. len)
+    {
+        double v = i * 0.5;
+        total += v;
+        rb_ary_push(ary, to_ruby_value(v));
+    }
+    // return [array, sum]
+    VALUE res = rb_ary_new_capa(2);
+    rb_ary_push(res, ary);
+    rb_ary_push(res, to_ruby_value(total));
+    return res;
+}
+
+// stress to_ruby_value on AAs (Hash) — 10k keys
+extern (C) VALUE perf_hash(VALUE self, VALUE n)
+{
+    long len = d_type!long(n);
+    int[int] aa;
+    foreach (int i; 0 .. cast(int) len)
+        aa[i] = i * i;
+    return to_ruby_value(aa);
+}
+
+public:
+
+pragma(mangle, "Init_exp_perf")
+extern (C) void Init_exp_perf()
+{
+    VALUE m = rb_define_module("ExpPerf");
+    def!("ExpPerf", perf_fib, "fib");
+    rb_define_module_function(m, "fib_boundary", cast(AnyMethod) &perf_fib_boundary, 1);
+    rb_define_module_function(m, "build",        cast(AnyMethod) &perf_build, 1);
+    rb_define_module_function(m, "hash",         cast(AnyMethod) &perf_hash, 1);
+    rb_define_const(m, "PI", to_ruby_value(3.141592653589793));
+    rb_define_const(m, "GREETING", to_ruby_value("hello from D"));
+}

data/experiments/exp_wrap.d

@@ -0,0 +1,186 @@
+/// EXPERIMENT 1 — Wrap a real D struct as a Ruby object.
+///
+/// Torture elements:
+/// - heap-allocated D state (Matrix) owned by a Ruby object via
+///   rb_data_object_wrap with mark/free callbacks
+/// - recursive algorithm (determinant by Laplace) crossing the D/Ruby
+///   boundary on every level
+/// - mutation from Ruby (set) vs read (get)
+/// - GC pressure: allocate/discard many wrappers in a loop
+///
+/// Uses VALUE passthrough args (trampoline-supported) for self.
+
+module exp_wrap;
+
+import rudy.bind.value;
+import rudy.convert;
+import rudy.defs;
+import core.memory : GC;
+
+
+private static class RudyWrapError : Error { this(string m) { super(m); } }
+
+private:
+
+struct Matrix
+{
+    size_t rows, cols;
+    double* data;   // malloc'd, freed by the wrap free func
+
+    ref double at(size_t r, size_t c) { return data[r * cols + c]; }
+}
+
+// FINDING: rb_data_object_get is an inline C macro (RDATA(obj)->data),
+// NOT exported by libruby. Since rudy avoids struct access, we keep a
+// D-side registry: wrapper VALUE (via rb_obj_id) -> Matrix*, cleaned up
+// in the free callback via a reverse map.
+private Matrix*[ulong] registry;        // key: rb_obj_id(wrapper)
+private ulong[void*] reverse_registry;  // key: Matrix* -> rb_obj_id
+private VALUE dmatrix_class;            // set in Init, used by stress
+private VALUE expwrap_keep;              // Ruby Array that pins the latest wrapper
+
+extern (C) void matrix_free(void* p)
+{
+    import core.stdc.stdlib : free;
+    auto m = cast(Matrix*) p;
+    if (auto pid = p in reverse_registry)
+    {
+        registry.remove(*pid);
+        reverse_registry.remove(p);
+    }
+    if (m && m.data) free(m.data);
+    if (m) free(m);
+}
+
+private Matrix* get_matrix(VALUE self)
+{
+    auto pid = rb_obj_id(self);
+    auto pm = pid in registry;
+    if (pm is null)
+        rudy_raise(rb_eRuntimeError, "unregistered DMatrix (internal error)");
+    return *pm;
+}
+
+// Matrix allocated by `alloc` — the RUBY_DATA_FUNC shape for alloc funcs
+extern (C) VALUE dmat_alloc(VALUE klass)
+{
+    import core.stdc.stdlib : calloc;
+    auto m = cast(Matrix*) calloc(1, Matrix.sizeof);
+    VALUE obj = rb_data_object_wrap(klass, cast(void*) m, null, &matrix_free);
+    // store registry entries keyed by object identity
+    auto id = rb_obj_id(obj);
+    registry[id] = m;
+    reverse_registry[m] = id;
+    return obj;
+}
+
+extern (C) VALUE dmat_initialize(VALUE self, VALUE r, VALUE c)
+{
+    auto m = get_matrix(self);
+    m.rows = cast(size_t) d_type!long(r);
+    m.cols = cast(size_t) d_type!long(c);
+    import core.stdc.stdlib : calloc;
+    m.data = cast(double*) calloc(Matrix.sizeof, m.rows * m.cols);
+    return self;
+}
+
+extern (C) VALUE dmat_set(VALUE self, VALUE r, VALUE c, VALUE v)
+{
+    auto m = get_matrix(self);
+    m.at(d_type!long(r), d_type!long(c)) = d_type!double(v);
+    return v;
+}
+
+extern (C) VALUE dmat_get(VALUE self, VALUE r, VALUE c)
+{
+    auto m = get_matrix(self);
+    return to_ruby_value(m.at(d_type!long(r), d_type!long(c)));
+}
+
+double matrix_det(Matrix* m)
+{
+    if (m.rows == 1) return m.at(0, 0);
+    if (m.rows == 2) return m.at(0, 0) * m.at(1, 1) - m.at(0, 1) * m.at(1, 0);
+    double det = 0.0;   // NB: bare `double det;` is NaN in D!
+    foreach (j; 0 .. m.cols)
+    {
+        Matrix minor;
+        minor.rows = m.rows - 1;
+        minor.cols = m.cols - 1;
+        import core.stdc.stdlib : malloc;
+        minor.data = cast(double*) malloc(double.sizeof * minor.rows * minor.cols);
+        scope (exit) { import core.stdc.stdlib : free; free(minor.data); }
+        foreach (ri; 0 .. minor.rows)
+            foreach (ci; 0 .. minor.cols)
+                minor.at(ri, ci) =
+                    m.at(ri + 1, ci < j ? ci : ci + 1);
+        double sign = (j % 2) ? -1.0 : 1.0;
+        det += sign * m.at(0, j) * matrix_det(&minor);
+    }
+    return det;
+}
+
+extern (C) VALUE dmat_det(VALUE self)
+{
+    auto m = get_matrix(self);
+    return to_ruby_value(matrix_det(m));
+}
+
+extern (C) VALUE dmat_to_a(VALUE self)
+{
+    auto m = get_matrix(self);
+    VALUE outer = rb_ary_new_capa(cast(C_long) m.rows);
+    foreach (r; 0 .. m.rows)
+    {
+        VALUE row = rb_ary_new_capa(cast(C_long) m.cols);
+        foreach (c; 0 .. m.cols)
+            rb_ary_push(row, to_ruby_value(m.at(r, c)));
+        rb_ary_push(outer, row);
+    }
+    return outer;
+}
+
+// stress: allocate & drop 100_000 wrappers; if free callbacks never fire,
+// we leak ~100k * (Matrix + data) — watch RSS
+extern (C) VALUE dmat_stress(VALUE self, VALUE n)
+{
+    foreach (i; 0 .. d_type!long(n))
+    {
+        import core.stdc.stdlib : calloc, malloc;
+        auto m = cast(Matrix*) calloc(1, Matrix.sizeof);
+        m.rows = m.cols = 4;
+        m.data = cast(double*) malloc(double.sizeof * 16);
+        VALUE obj = rb_data_object_wrap(dmatrix_class, cast(void*) m, null, &matrix_free);
+        auto id = rb_obj_id(obj);
+        registry[id] = m;
+        reverse_registry[m] = id;
+        rb_ary_store(expwrap_keep, 0, obj); // keep only last; free func cleans registry
+    }
+    GC.collect;
+    // ask Ruby to GC too
+    VALUE mod = rb_const_get(rb_cObject, rb_intern("GC"));
+    rb_funcallv(mod, rb_intern("start"), 0, null);
+    return Qnil_;
+}
+
+public:
+
+pragma(mangle, "Init_exp_wrap")
+extern (C) void Init_exp_wrap()
+{
+    VALUE cDMatrix = rb_define_class("DMatrix", rb_cObject);
+    rb_define_alloc_func(cDMatrix, &dmat_alloc);
+    rb_define_method(cDMatrix, "initialize", cast(AnyMethod) &dmat_initialize, 2);
+    rb_define_method(cDMatrix, "[]",        cast(AnyMethod) &dmat_get, 2);
+    rb_define_method(cDMatrix, "[]=",        cast(AnyMethod) &dmat_set, 3);
+    rb_define_method(cDMatrix, "det",        cast(AnyMethod) &dmat_det, 0);
+    rb_define_method(cDMatrix, "to_a",       cast(AnyMethod) &dmat_to_a, 0);
+    rb_define_method(cDMatrix, "stress",     cast(AnyMethod) &dmat_stress, 1);
+    VALUE dext = rb_define_module("ExpWrap");
+    dmatrix_class = cDMatrix;
+    expwrap_keep = rb_ary_new();
+    rb_iv_set(dext, "@keep", expwrap_keep);
+    // root the keep-array so GC never collects it (it's reachable from the
+    // module, but belt & braces since we hold a raw D reference)
+    rb_gc_register_address(&expwrap_keep);
+}