hyperion-rb 2.10.1 → 2.12.0

data/ext/hyperion_http/page_cache_internal.h

@@ -0,0 +1,132 @@
+/* ----------------------------------------------------------------------
+ * page_cache_internal.h — internal C-ext sharing surface.
+ *
+ * 2.12-D — exposes the request-parsing + lookup + write helpers built by
+ * `page_cache.c`'s C accept loop so the io_uring sibling
+ * (`io_uring_loop.c`) can reuse them rather than copy-pasting. The
+ * helpers stay `static` inside `page_cache.c` and the symbols below are
+ * thin extern wrappers — one indirection per call, but the io_uring
+ * loop calls them at most once per request, so the cost is negligible
+ * (single-direct-call jump) compared to the syscall savings the loop
+ * delivers.
+ *
+ * NOT public surface. NOT installed in any include path. The header
+ * lives next to the .c files and is included only by the in-tree C
+ * sources.
+ * ---------------------------------------------------------------------- */
+#ifndef HYP_PAGE_CACHE_INTERNAL_H
+#define HYP_PAGE_CACHE_INTERNAL_H
+
+#include <stddef.h>
+#include <sys/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Method classification (mirrors `hyp_pc_method_t` in page_cache.c). The
+ * io_uring loop uses this via `pc_internal_classify_method` to decide
+ * how much of the cached response to write (HEAD = headers only, GET =
+ * full response). */
+typedef enum {
+    PC_INTERNAL_METHOD_GET   = 0,
+    PC_INTERNAL_METHOD_HEAD  = 1,
+    PC_INTERNAL_METHOD_OTHER = 2
+} pc_internal_method_t;
+
+/* End-of-headers scanner. Returns the byte offset PAST the trailing
+ * CRLFCRLF, or -1 if not found. */
+long pc_internal_find_eoh(const char *buf, size_t len);
+
+/* Request-line parser. On success fills *m_off, *m_len, *p_off, *p_len
+ * with offsets/lengths of METHOD and PATH inside `buf`, and returns the
+ * length of the request line including the trailing CRLF. Returns -1
+ * on malformed input or non-HTTP/1.1 versions (HTTP/1.0 differs in
+ * keep-alive defaults; the caller must hand it off to Ruby). */
+long pc_internal_parse_request_line(const char *buf, size_t len,
+                                    size_t *m_off, size_t *m_len,
+                                    size_t *p_off, size_t *p_len);
+
+/* Header-block scanner. `start` and `end` bracket the headers section
+ * (between request-line end and the closing CRLFCRLF). Reports:
+ *   *connection_close — Connection: close seen
+ *   *has_body         — non-zero Content-Length OR Transfer-Encoding
+ *   *upgrade_seen     — Upgrade or HTTP2-Settings seen
+ * Returns 0 on success, -1 on malformed framing. */
+int pc_internal_scan_headers(const char *buf, size_t start, size_t end,
+                             int *connection_close, int *has_body,
+                             int *upgrade_seen);
+
+/* Method classifier. Returns GET / HEAD / OTHER. */
+pc_internal_method_t pc_internal_classify_method(const char *m, size_t len);
+
+/* Snapshot the response bytes for `(path, kind)` into a freshly malloc'd
+ * buffer. On hit: returns the malloc'd buffer (caller must `free()` it)
+ * and writes the byte length into *out_len. On miss: returns NULL and
+ * sets *out_len = 0. The buffer is whatever the page cache's lookup
+ * picks given the recheck/staleness rules; the io_uring loop writes it
+ * verbatim. Takes the C-side cache lock briefly; releases it before
+ * returning. Returns NULL on OOM as well — the caller treats both as
+ * "couldn't serve from C, hand off to Ruby". */
+char *pc_internal_snapshot_response(const char *path, size_t path_len,
+                                    pc_internal_method_t kind,
+                                    size_t *out_len);
+
+/* Apply TCP_NODELAY to an accepted fd (best-effort; failures swallowed). */
+void pc_internal_apply_tcp_nodelay(int fd);
+
+/* Lifecycle hook fire wrapper. The io_uring loop calls this AFTER the
+ * write completion arrives so observers see a finished request. The
+ * C-side gate (`lifecycle_active`) is checked inside; the wrapper is
+ * a no-op when no callback is registered or the gate is off. Must be
+ * called under the GVL. */
+void pc_internal_fire_lifecycle(const char *method, size_t mlen,
+                                const char *path, size_t plen);
+
+/* Whether the lifecycle gate is currently on. The io_uring loop reads
+ * this BEFORE re-acquiring the GVL — when it's off, the loop skips
+ * the rb_thread_call_with_gvl round-trip entirely. */
+int pc_internal_lifecycle_active(void);
+
+/* Handoff wrapper — invokes the registered Ruby callback with
+ * (fd, partial_buffer_or_nil). Must be called under the GVL. Closes
+ * the fd locally if no callback is registered or if the callback
+ * raised. */
+void pc_internal_handoff(int client_fd, const char *partial, size_t partial_len);
+
+/* Read the stop flag flipped by `PageCache.stop_accept_loop`. Both the
+ * 2.12-C accept4 loop AND the 2.12-D io_uring loop honour it as a
+ * graceful-shutdown signal. */
+int pc_internal_stop_requested(void);
+
+/* Reset the stop flag to 0. Called by the loop entry points
+ * (`run_static_accept_loop`, `run_static_io_uring_loop`) so a previous
+ * invocation's `stop_accept_loop` doesn't immediately tear down a
+ * fresh loop. Specs hammer this path between examples — the 2.12-C
+ * loop resets inline; the io_uring sibling needs the same surface. */
+void pc_internal_reset_stop(void);
+
+/* 2.12-E — bump the per-process served-request counter (atomic; safe
+ * to call from any thread / fiber / accept-loop context). Both the
+ * 2.12-C accept4 loop and the 2.12-D io_uring loop call this after
+ * a successful response write so the SO_REUSEPORT distribution audit
+ * (`PageCache.c_loop_requests_total`) sees ticks regardless of which
+ * loop variant is active. */
+void pc_internal_tick_request(void);
+
+/* 2.12-E — reset the per-process served-request counter. Mirrors the
+ * stop-flag reset rationale: loop entry points call this so a prior
+ * invocation's count doesn't bleed into the new loop's snapshot. */
+void pc_internal_reset_requests_served(void);
+
+/* The 64 KiB header-cap shared with `page_cache.c`. Re-declared here
+ * so io_uring_loop.c doesn't need to mirror the magic number. */
+#ifndef PC_INTERNAL_MAX_HEADER_BYTES
+#define PC_INTERNAL_MAX_HEADER_BYTES 65536
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HYP_PAGE_CACHE_INTERNAL_H */

data/lib/hyperion/connection.rb

@@ -135,6 +135,12 @@ module Hyperion
       # keep the existing pattern of caching boot-time refs as ivars so
       # the per-request observe stays a single Hash lookup.
       @path_templater = path_templater || Hyperion::Metrics.default_path_templater
+      # 2.12-E — per-worker request counter label. Cached once per
+      # Connection (Process.pid is process-constant — re-reading it per
+      # request would allocate the to_s String every time the operator
+      # asked Ruby for the symbol/label). Each Connection lives in
+      # exactly one process, so the cache is tight and never stale.
+      @worker_id = Process.pid.to_s
       # 2.10-D — direct-dispatch route table.  The hot-path lookup
       # is `@route_table&.lookup(method, path)` so the nil-default
       # case (no operator-registered direct routes — the
@@ -307,6 +313,14 @@ module Hyperion
         @metrics.increment(:bytes_read, body_end)
         @metrics.increment(:requests_total)
         @metrics.increment(:requests_in_flight)
+        # 2.12-E — per-worker request counter for the SO_REUSEPORT
+        # load-balancing audit. Worker_id is the OS pid (matches the
+        # 2.4-C `hyperion_io_uring_workers_active` convention). Single
+        # location for every Ruby-side dispatch shape: regular Rack
+        # via `dispatch_request`, direct dispatch via `dispatch_direct!`,
+        # and the StaticEntry fast path via `dispatch_direct_static!`
+        # all flow through this point in `serve`.
+        @metrics.tick_worker_request(@worker_id)
         # 2.4-C: capture start time for the per-route duration histogram.
         # Same Process.clock_gettime that the access-log path was already
         # paying — at default-ON log_requests the second call here is

data/lib/hyperion/dispatch_mode.rb

@@ -46,8 +46,26 @@ module Hyperion
     #                          escape hatch via `env['hyperion.dispatch_mode']
     #                          = :inline_blocking` for routes the auto-
     #                          detect doesn't catch.
+    # 2.12-C — `:c_accept_loop_h1` is a connection-wide mode (NOT a
+    # per-response override): the entire accept-and-serve loop runs in
+    # C via `Hyperion::Http::PageCache.run_static_accept_loop`. Engaged
+    # only when the operator's route table is composed entirely of
+    # `Server.handle_static`-registered routes AND the listener is
+    # plain TCP. Counted under `:requests_dispatch_c_accept_loop_h1`
+    # at engage time (one bump per worker boot) so operators can see
+    # the path is on without scraping the per-request `:c_accept_loop_requests`
+    # counter.
+    # 2.12-D — `:c_accept_loop_io_uring_h1` is a sibling of
+    # `:c_accept_loop_h1`. Engaged when the operator opts into
+    # `HYPERION_IO_URING_ACCEPT=1` AND the C ext was compiled with
+    # liburing AND the runtime probe succeeded. Same eligibility gates
+    # as `:c_accept_loop_h1` (handle_static-only routes, plain TCP),
+    # different syscall shape (single `io_uring_enter` per N requests
+    # vs. N×3 syscalls). Counted under
+    # `:requests_dispatch_c_accept_loop_io_uring_h1` so operators can
+    # confirm the path is on without scraping logs.
     MODES = %i[tls_h2 tls_h1_inline async_io_h1_inline threadpool_h1 inline_h1_no_pool
-               inline_blocking].freeze
+               inline_blocking c_accept_loop_h1 c_accept_loop_io_uring_h1].freeze
 
     INLINE_MODES = %i[tls_h1_inline async_io_h1_inline inline_h1_no_pool inline_blocking].freeze
 

data/lib/hyperion/h2_codec.rb

@@ -45,11 +45,36 @@ module Hyperion
       @cglue_available == true
     end
 
+    # 2.11-B — operator-controllable gate that overlays CGlue
+    # availability. The Encoder/Decoder hot paths probe this (NOT
+    # `cglue_available?`) so a `HYPERION_H2_NATIVE_HPACK=v2` boot can
+    # force the Fiddle path even on a host where the C glue loaded
+    # successfully. This is the bench-isolation knob 2.11-B's
+    # `bench/h2_rails_shape.sh` needs to compare native-v2 against
+    # native-v3 honestly — without it, "native" and "cglue" variants
+    # would always pick the same physical path.
+    #
+    # `Http2Handler#initialize` writes the gate based on the env var;
+    # tests can flip `@cglue_disabled` directly. Default false (i.e.,
+    # gate is OPEN — same physical behavior as 2.4-A through 2.10).
+    def self.cglue_active?
+      cglue_available? && !@cglue_disabled
+    end
+
+    def self.cglue_disabled=(value)
+      @cglue_disabled = value ? true : false
+    end
+
+    def self.cglue_disabled
+      @cglue_disabled == true
+    end
+
     # Force a reload (test seam). Unsets the memoized state so the next
     # `available?` call probes the filesystem again.
     def self.reset!
       @available = nil
       @cglue_available = nil
+      @cglue_disabled = false
       @lib = nil
     end
 
@@ -126,7 +151,13 @@ module Hyperion
         # into a new owned String — that's the contract callers rely
         # on (`protocol-http2`'s Compressor#encode returns a String,
         # not a slice into shared mutable memory).
-        if H2Codec.cglue_available?
+        #
+        # 2.11-B — probe `cglue_active?` (NOT `cglue_available?`) so an
+        # operator-set `HYPERION_H2_NATIVE_HPACK=v2` boot routes through
+        # Fiddle even when the C glue is physically present. Same
+        # branch shape; one extra ivar read on the hot path which
+        # disappears under YJIT inlining.
+        if H2Codec.cglue_active?
           # Pad the scratch String with zero bytes so its length matches
           # capacity — the C ext writes into RSTRING_PTR up to RSTRING_LEN
           # and then truncates back via rb_str_set_len after encoding.
@@ -272,7 +303,8 @@ module Hyperion
         # 2.4-A — fast path: reuse a per-decoder scratch and dispatch
         # through the C glue. The Rust ABI writes `[u32 name_len][name]
         # [u32 val_len][val]` repeated; we unpack that in Ruby.
-        if H2Codec.cglue_available?
+        # 2.11-B — `cglue_active?` overlays an operator-set v2 force.
+        if H2Codec.cglue_active?
           if capacity > @scratch_out_capacity
             new_cap = @scratch_out_capacity
             new_cap *= 2 while new_cap < capacity
@@ -412,9 +444,24 @@ module Hyperion
     def self.candidate_paths
       gem_lib = File.expand_path('../hyperion_h2_codec', __dir__)
       ext_target = File.expand_path('../../ext/hyperion_h2_codec/target/release', __dir__)
-      %w[libhyperion_h2_codec.dylib libhyperion_h2_codec.so].flat_map do |name|
-        [File.join(gem_lib, name), File.join(ext_target, name)]
-      end
+      # 2.11-B fix: order suffixes by host OS. Pre-2.11-B this was a
+      # static `[dylib, so]` order, which broke on Linux hosts that
+      # had a stale macOS `.dylib` on the path (e.g. a developer rsync
+      # leaking the `target/release` artifact across platforms). Fiddle
+      # would try the `.dylib` first, choke on the Mach-O binary with
+      # `ArgumentError: invalid byte sequence in UTF-8` from libffi,
+      # and the rescue in `load!` would silently fall back to the Ruby
+      # HPACK path with no warning visible to bench harnesses.
+      #
+      # Ordering by `host_os` makes Linux pick `.so` first and ignore
+      # any orphan `.dylib`; macOS keeps the `.dylib`-first behavior
+      # for back-compat with existing dev environments.
+      suffixes = if /darwin|mac/i.match?(RbConfig::CONFIG['host_os'])
+                   %w[libhyperion_h2_codec.dylib libhyperion_h2_codec.so]
+                 else
+                   %w[libhyperion_h2_codec.so libhyperion_h2_codec.dylib]
+                 end
+      suffixes.flat_map { |name| [File.join(gem_lib, name), File.join(ext_target, name)] }
     end
 
     # FFI wrappers — kept thin so callers don't see Fiddle::Pointer