leptris 1.9.311.1 → 1.9.311.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a00351d2185cc9432a2a675feb686a11e616e9bfc4ed930ed5c3737e7eee8cbf
-  data.tar.gz: 93aa8c74620619e74b7a28a4f83569a2154df36c600edd0f8126cf2129d39bda
+  metadata.gz: a004384f7927ff6e71fd0277c1920ca6890a69c9dee52f36f267c85807cf8b0b
+  data.tar.gz: a02220a1a36d2016d947f35065d204a92811fc99559b8e5d596f0c5278d4089a
 SHA512:
-  metadata.gz: 169251ef7965e3ff58646406f37bbebc1308732d7e5dc3ab400b1e766df5142bde0d887acba8e3eb2eb1b22ef5f71dc934ca76b8f01c7baff96f2ee55ab41872
-  data.tar.gz: 9e84022d8a35c5135b1fdf7f7b60531c4ba2231f9f462c48b9051de2f268b84bb9a042d2d1298f3e06aa74898364a71c6a25b57010d81c265f44da571112b74a
+  metadata.gz: 7f599ca78c88649f4778c81644947dc939fcbfe2db06179f4b7785d62bb46ce3ea4fc86ccf6b589d5f83b06ea1ab3e0686a1427fba31ad27ca7b67c39b6993a2
+  data.tar.gz: d1030e40b0903052901e5a245b17531f44ad7ee718daefc303644e7bebc630debea0594bd930273fdcaabe0c9745951263965706e54fdf5ffb583f2bc58bd4e1

data/CHANGELOG.md

@@ -1,3 +1,38 @@
+## [1.9.311.3] - 2026-10-06
+
+### Performance
+
+- **Same-document splices stop paying the cross-document sweep
+  (#374, the fresh-doc 0.80x follow-up)**: every fast splice path
+  is reached only after `foreign_to?` said no — the child's
+  document IS this one — so the post-splice
+  `invalidate_cross_document!` (a method call plus two ivar reads
+  that always returned at the equal check) was dead weight on the
+  hottest construction loop. Removed from the add_child /
+  prepend_child / sibling-insert fast paths and their FFI tails
+  (the foreign and batch paths keep their sweeps); `add_child` no
+  longer runs the Ruby-side readonly/version gate twice when the
+  C face self-gates. Measured under load with interleaved
+  CPU-time medians (3 rounds, 15k appends): add_child 1.69 →
+  1.41 µs/call (~16%), programmatic build ~14%.
+
+## [1.9.311.2] - 2026-10-06
+
+### Fixed
+
+- **Absorbed sources alive at exit no longer double-free the pool
+  (#386)**: `Document#absorb`'s handle-only contract was enforced
+  only by the explicit `#free` — the C lifetime handle's dfree
+  and the no-native Ruby finalizer still called
+  `leptris_document_free`, destroying a pool already owned (and
+  released) by the absorber. Libraries that pin adopted-source
+  documents (moxml's lifetime pins) aborted at exit-time
+  finalization (`leptris_pool_destroy` → `free_small_botch`). The
+  absorbed flag now lives where every release path reads it: the
+  shared `Freed` struct (Ruby finalizer) and the C handle
+  (`doc_handle_mark_absorbed`; dfree is handle-only when the pool
+  moved). Both paths pinned by subprocess regression specs.
+
 ## [1.9.311.1] - 2026-10-06
 
 ### Fixed

data/ext/leptris/native/native.c

@@ -2682,15 +2682,21 @@ static VALUE nf_fast_inner_xml(VALUE self, VALUE addr)
  * Ruby-finalizer path (which stays for LEPTRIS_NO_NATIVE). */
 struct doc_handle {
     void *doc;
+    /* Pool ownership transferred to an absorber (engine #1548):
+     * the destination's free performs the real release, so this
+     * handle's dfree is HANDLE-ONLY (#386: malloc_zone_error /
+     * free_small_botch when an absorbed source survived to
+     * exit-time finalization after its destination's release). */
+    int absorbed;
 };
 
 static void dh_free(void *p)
 {
     struct doc_handle *h = p;
-    if (h->doc) {
+    if (h->doc && !h->absorbed) {
         f_doc_free(h->doc);
-        h->doc = NULL;
     }
+    h->doc = NULL;
 }
 
 static size_t dh_size(const void *p)
@@ -2888,6 +2894,22 @@ static VALUE nf_doc_handle_release(VALUE self, VALUE document)
     return Qnil;
 }
 
+/* Absorption bookkeeping (#386, engine #1548): Document#absorb
+ * calls this on the SOURCE right after the engine transfers pool
+ * ownership — the handle's dfree becomes handle-only, matching
+ * the Ruby-side Freed flag the no-native finalizer reads. */
+static VALUE nf_doc_handle_mark_absorbed(VALUE self, VALUE document)
+{
+    VALUE handle = rb_ivar_get(document, id_iv_doc_handle);
+    (void)self;
+    if (handle != Qnil) {
+        struct doc_handle *h;
+        TypedData_Get_Struct(handle, struct doc_handle, &dh_type, h);
+        h->absorbed = 1;
+    }
+    return Qnil;
+}
+
 /* The full Document.create in one dispatch: engine create,
  * binding wrapper (ivar-seeded, bypassing initialize), and the
  * lifetime handle. Returns Qnil when the engine refuses. */
@@ -3158,6 +3180,8 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
                               nf_doc_handle_attach, 1);
     rb_define_module_function(m_native, "doc_handle_release",
                               nf_doc_handle_release, 1);
+    rb_define_module_function(m_native, "doc_handle_mark_absorbed",
+                              nf_doc_handle_mark_absorbed, 1);
     rb_define_module_function(m_native, "create_binding_document",
                               nf_create_binding_document, 0);
     c_doc_handle = rb_define_class_under(m_xml, "DocHandle", rb_cObject);

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.311.1"
+  VERSION = "1.9.311.3"
 end

data/lib/leptris/xml/document.rb

@@ -11,7 +11,9 @@ class Leptris::XML::Document
   # the explicit `free` path and the finalizer. This eliminates the
   # double-free that FFI::AutoPointer's release proc caused when
   # `Document#free` was called explicitly and then GC ran.
-  Freed = Struct.new(:state)  # state: :alive | :freed
+  # +absorbed+ (engine #1548, #386): pool ownership moved to an
+  # absorber — the finalizer must never call the engine free.
+  Freed = Struct.new(:state, :absorbed)  # state: :alive | :freed
 
   # Mutation version: advanced by every data mutation (via
   # Node#ensure_writable!, root=, add_pi). Node memos stamp the
@@ -286,7 +288,7 @@ class Leptris::XML::Document
 
   def self.finalizer(address, freed)
     proc do
-      next if freed.state == :freed
+      next if freed.state == :freed || freed.absorbed
       freed.state = :freed
       Leptris::XML::FFI.leptris_document_free(::FFI::Pointer.new(address))
     end
@@ -591,8 +593,16 @@ class Leptris::XML::Document
   # objects by hand): the absorbed document's #free skips the
   # engine release, and splice seams skip source-side removals
   # because absorbed splices MOVE the node (nothing to remove).
+  # The flag is mirrored into every release path (#386): the
+  # shared Freed struct (the no-native Ruby finalizer reads it)
+  # and the C lifetime handle (dh_free must be handle-only when
+  # the pool belongs to the absorber).
   def mark_absorbed_into(destination)
     @absorbed_into = destination
+    @freed.absorbed = true
+    if defined?(Leptris::XML::NATIVE_FAST)
+      Leptris::XML::Native.doc_handle_mark_absorbed(self)
+    end
   end
 
   def absorbed_into?(destination)

data/lib/leptris/xml/element.rb

@@ -446,7 +446,6 @@ class Leptris::XML::Element < Leptris::XML::Node
     if native_fast_children?
       unless Leptris::XML::Native.insert_binding_child(
         @document, @c_address, node.c_ptr.address, 1).nil?
-        Leptris::XML::Node.invalidate_cross_document!(node, @document)
         return node
       end
     end
@@ -456,7 +455,6 @@ class Leptris::XML::Element < Leptris::XML::Node
     end
     Leptris::XML::FFI.check_status(
       Leptris::XML::FFI.leptris_element_prepend_child(c_ptr, node.c_ptr))
-    Leptris::XML::Node.invalidate_cross_document!(node, @document)
     node
   end
 
@@ -481,7 +479,6 @@ class Leptris::XML::Element < Leptris::XML::Node
     if native_fast_children?
       unless Leptris::XML::Native.insert_binding_child(
         @document, @c_address, node.c_ptr.address, 2).nil?
-        Leptris::XML::Node.invalidate_cross_document!(node, @document)
         return node
       end
     end
@@ -491,7 +488,6 @@ class Leptris::XML::Element < Leptris::XML::Node
     end
     Leptris::XML::FFI.check_status(
       Leptris::XML::FFI.leptris_element_insert_after(c_ptr, node.c_ptr))
-    Leptris::XML::Node.invalidate_cross_document!(node, @document)
     node
   end
 
@@ -516,7 +512,6 @@ class Leptris::XML::Element < Leptris::XML::Node
     if native_fast_children?
       unless Leptris::XML::Native.insert_binding_child(
         @document, @c_address, node.c_ptr.address, 3).nil?
-        Leptris::XML::Node.invalidate_cross_document!(node, @document)
         return node
       end
     end
@@ -526,7 +521,6 @@ class Leptris::XML::Element < Leptris::XML::Node
     end
     Leptris::XML::FFI.check_status(
       Leptris::XML::FFI.leptris_element_insert_before(c_ptr, node.c_ptr))
-    Leptris::XML::Node.invalidate_cross_document!(node, @document)
     node
   end
 
@@ -672,7 +666,6 @@ class Leptris::XML::Element < Leptris::XML::Node
   end
 
   def add_child(node_or_markup)
-    ensure_writable!
     case node_or_markup
     when Leptris::XML::Node
       # Foreign-child adoption (1.9.304, #1528): the engine
@@ -686,22 +679,24 @@ class Leptris::XML::Element < Leptris::XML::Node
       # readonly/liveness gates, the provable no-op lift
       # predicate, the version bump, and the engine append. Qnil
       # means the child needs the namespace lift — fall through
-      # to the full path.
+      # to the full path. Same-document children cannot reach
+      # here from another document (foreign ones routed above),
+      # so there is no cross-document sweep to run (#374): the
+      # C-side version bump invalidates this document's memos.
       if native_fast_children?
         # The face raises on failure (TODO.perf/36); Qnil = the
         # child needs the lift — the full path handles it.
         unless Leptris::XML::Native.append_binding_child(
           @document, @c_address, node_or_markup.c_ptr.address).nil?
-          Leptris::XML::Node.invalidate_cross_document!(node_or_markup, @document)
           return node_or_markup
         end
       end
+      ensure_writable!
       unless Leptris::XML::Element.skip_adoption_lift?(node_or_markup)
         Leptris::XML::Element.lift_namespaces_for_adoption(node_or_markup, namespaces)
       end
       Leptris::XML::FFI.check_status(
         Leptris::XML::FFI.leptris_element_append_child(c_ptr, node_or_markup.c_ptr))
-      Leptris::XML::Node.invalidate_cross_document!(node_or_markup, @document)
       node_or_markup
     when String
       # TODO.perf/34: one dispatch parses the markup and appends
@@ -721,6 +716,7 @@ class Leptris::XML::Element < Leptris::XML::Node
         # path (it re-fails fast)
         Leptris::XML::DocumentFragment.parse(node_or_markup, @document)
       end
+      ensure_writable!
       frag = Leptris::XML::DocumentFragment.parse(node_or_markup, @document)
       added = []
       frag.children.each do |n|
@@ -741,6 +737,7 @@ class Leptris::XML::Element < Leptris::XML::Node
   # original is removed after (the source loses the node, as
   # every pre-304 caller observed).
   def append_installed(node)
+    ensure_writable!
     unless Leptris::XML::Element.skip_adoption_lift?(node)
       Leptris::XML::Element.lift_namespaces_for_adoption(node, namespaces)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.311.1
+  version: 1.9.311.3
 platform: ruby
 authors:
 - Ribose Inc.