raptor 0.8.0 → 0.9.0

data/ext/raptor_bpf/reuseport_select.bpf.c

@@ -0,0 +1,63 @@
+#include <linux/bpf.h>
+#include <bpf/bpf_helpers.h>
+
+#define MAX_WORKERS 64
+
+// Per-worker listening sockets, keyed by worker index.
+struct {
+  __uint(type, BPF_MAP_TYPE_REUSEPORT_SOCKARRAY);
+  __type(key, __u32);
+  __type(value, __u64);
+  __uint(max_entries, MAX_WORKERS);
+} socks SEC(".maps");
+
+// Worker count at slot 0, per-worker backlog at slots 1..N.
+struct {
+  __uint(type, BPF_MAP_TYPE_ARRAY);
+  __type(key, __u32);
+  __type(value, __u32);
+  __uint(max_entries, MAX_WORKERS + 1);
+} loads SEC(".maps");
+
+// Routes each incoming connection to the worker with the lowest backlog,
+// with a random tie-break when loads are equal.
+SEC("sk_reuseport")
+int select_least_loaded(struct sk_reuseport_md *ctx) {
+  __u32 count_key = 0;
+  __u32 *count_ptr = bpf_map_lookup_elem(&loads, &count_key);
+  if (!count_ptr || *count_ptr == 0) {
+    return SK_DROP;
+  }
+  __u32 num_workers = *count_ptr;
+  if (num_workers > MAX_WORKERS) {
+    num_workers = MAX_WORKERS;
+  }
+
+  __u32 min_load = ~0u;
+  __u32 max_load = 0;
+  __u32 min_idx = 0;
+
+  for (__u32 worker_idx = 0; worker_idx < MAX_WORKERS; worker_idx++) {
+    if (worker_idx >= num_workers) {
+      break;
+    }
+    __u32 worker_key = worker_idx + 1;
+    __u32 *load_ptr = bpf_map_lookup_elem(&loads, &worker_key);
+    if (!load_ptr) {
+      continue;
+    }
+    if (*load_ptr < min_load) {
+      min_load = *load_ptr;
+      min_idx = worker_idx;
+    }
+    if (*load_ptr > max_load) {
+      max_load = *load_ptr;
+    }
+  }
+
+  __u32 chosen_idx = (min_load == max_load) ? (bpf_get_prandom_u32() % num_workers) : min_idx;
+  bpf_sk_select_reuseport(ctx, &socks, &chosen_idx, 0);
+  return SK_PASS;
+}
+
+char _license[] SEC("license") = "GPL";

data/ext/raptor_http/extconf.rb

@@ -2,6 +2,6 @@
 
 require "mkmf"
 
-append_cflags("-fvisibility=hidden")
+append_cflags(["-fvisibility=hidden", "-Wno-type-limits"])
 
 create_makefile("raptor/raptor_http")

data/ext/raptor_native/extconf.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+append_cflags("-fvisibility=hidden")
+
+create_makefile("raptor/raptor_native")

data/ext/raptor_native/raptor_native.c

@@ -0,0 +1,99 @@
+#ifdef __linux__
+#define _GNU_SOURCE 1
+#endif
+
+#include "ruby.h"
+#include "ruby/io.h"
+#include <sys/uio.h>
+#include <errno.h>
+#include <limits.h>
+
+#ifdef __linux__
+#include <sched.h>
+#include <unistd.h>
+#endif
+
+static VALUE eEAGAINWaitWritable;
+
+static VALUE raptor_native_writev_nonblock(VALUE self, VALUE io, VALUE strings) {
+  (void)self;
+  Check_Type(strings, T_ARRAY);
+  long len = RARRAY_LEN(strings);
+  if (len == 0) return LONG2NUM(0);
+  if (len > IOV_MAX) len = IOV_MAX;
+
+  int fd = rb_io_descriptor(io);
+  struct iovec *iov = alloca(len * sizeof(struct iovec));
+
+  for (long i = 0; i < len; i++) {
+    VALUE str = RARRAY_AREF(strings, i);
+    Check_Type(str, T_STRING);
+    iov[i].iov_base = RSTRING_PTR(str);
+    iov[i].iov_len = RSTRING_LEN(str);
+  }
+
+  ssize_t written;
+  while ((written = writev(fd, iov, (int)len)) < 0) {
+    if (errno == EINTR) continue;
+    if (errno == EAGAIN || errno == EWOULDBLOCK) rb_raise(eEAGAINWaitWritable, "writev would block");
+    rb_sys_fail("writev");
+  }
+
+  return LONG2NUM((long)written);
+}
+
+static VALUE raptor_native_pin_to_cpu(VALUE self, VALUE cpu) {
+  (void)self;
+#ifdef __linux__
+  int worker_index = NUM2INT(cpu);
+  cpu_set_t current;
+  CPU_ZERO(&current);
+  if (sched_getaffinity(0, sizeof(current), &current) < 0) rb_sys_fail("sched_getaffinity");
+
+  int cpu_id = -1;
+  int seen = 0;
+  for (int candidate = 0; candidate < CPU_SETSIZE; candidate++) {
+    if (!CPU_ISSET(candidate, &current)) continue;
+    if (seen == worker_index) { cpu_id = candidate; break; }
+    seen++;
+  }
+  if (cpu_id < 0) return Qfalse;
+
+  cpu_set_t set;
+  CPU_ZERO(&set);
+  CPU_SET(cpu_id, &set);
+  if (sched_setaffinity(0, sizeof(set), &set) < 0) rb_sys_fail("sched_setaffinity");
+  return Qtrue;
+#else
+  (void)cpu;
+  return Qfalse;
+#endif
+}
+
+static VALUE raptor_native_cpu_count(VALUE self) {
+  (void)self;
+#ifdef __linux__
+  cpu_set_t set;
+  CPU_ZERO(&set);
+  if (sched_getaffinity(0, sizeof(set), &set) < 0) rb_sys_fail("sched_getaffinity");
+  return LONG2NUM((long)CPU_COUNT(&set));
+#else
+  return LONG2NUM(0);
+#endif
+}
+
+RUBY_FUNC_EXPORTED void Init_raptor_native(void) {
+  rb_ext_ractor_safe(true);
+
+  VALUE mRaptor = rb_define_module("Raptor");
+  VALUE mVectorIO = rb_define_module_under(mRaptor, "VectorIO");
+  VALUE mCPU = rb_define_module_under(mRaptor, "CPU");
+
+  rb_define_singleton_method(mVectorIO, "writev_nonblock", raptor_native_writev_nonblock, 2);
+
+  rb_define_singleton_method(mCPU, "pin", raptor_native_pin_to_cpu, 1);
+  rb_define_singleton_method(mCPU, "count", raptor_native_cpu_count, 0);
+
+  eEAGAINWaitWritable = rb_const_get(rb_cIO, rb_intern("EAGAINWaitWritable"));
+  rb_global_variable(&eEAGAINWaitWritable);
+}

data/lib/raptor/binder.rb

@@ -61,6 +61,16 @@ module Raptor
     # @rbs @listeners: Array[TCPServer | UNIXServer | SslListener]
     # @rbs @uri_listeners: Hash[String, Array[TCPServer | UNIXServer | SslListener]]
 
+    # Array of bind URIs.
+    #
+    # @return [Array<String>] the bind URIs
+    attr_reader :bind_uris
+
+    # Kernel listen() queue depth for TCP/SSL listeners.
+    #
+    # @return [Integer] the socket backlog
+    attr_reader :socket_backlog
+
     # Array of listening sockets.
     #
     # @return [Array<TCPServer, UNIXServer, SslListener>] the server sockets
@@ -244,11 +254,15 @@ module Raptor
 
       host = host[1..-2] if host&.start_with?("[")
 
-      tcp_server = TCPServer.new(host, port)
-      tcp_server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
-      tcp_server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, true) if Socket.const_defined?(:SO_REUSEPORT)
-      tcp_server.listen @socket_backlog
+      addrinfo = Addrinfo.tcp(host, port)
+      socket = Socket.new(addrinfo.afamily, Socket::SOCK_STREAM, 0)
+      socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+      socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, true) if Socket.const_defined?(:SO_REUSEPORT)
+      socket.bind(addrinfo)
+      socket.listen(@socket_backlog)
 
+      tcp_server = TCPServer.for_fd(socket.fileno)
+      socket.autoclose = false
       [tcp_server]
     end
 

data/lib/raptor/cli.rb

@@ -229,7 +229,7 @@ module Raptor
         end
 
         opts.on("-b", "--bind URI", String, "Bind address (default: tcp://0.0.0.0:9292)") do |bind|
-          if @options[:binds] == DEFAULT_OPTIONS[:binds]
+          if @options[:binds].equal?(DEFAULT_OPTIONS[:binds])
             @options[:binds] = [bind]
           else
             @options[:binds] << bind

data/lib/raptor/cluster.rb

@@ -9,8 +9,9 @@ require "ractor-pool"
 
 require_relative "log"
 require_relative "binder"
-require_relative "server"
 require_relative "reactor"
+require_relative "server"
+require_relative "reuseport_bpf"
 require_relative "http1"
 require_relative "http2"
 require_relative "stats"
@@ -91,6 +92,7 @@ module Raptor
     # @rbs @phased_restart_requested: bool
     # @rbs @phased_restarting: bool
     # @rbs @hot_restart_requested: bool
+    # @rbs @bpf_active: bool
 
     # Creates a new Cluster with the specified configuration.
     #
@@ -204,6 +206,8 @@ module Raptor
 
       File.open(@pid_file, File::CREAT | File::EXCL | File::WRONLY) { |file| file.write(Process.pid.to_s) } if @pid_file
 
+      @bpf_active = ReuseportBPF.setup(@worker_count)
+
       @worker_count.times { |index| spawn_worker(index) }
 
       stats_file_thread = if @stats_file
@@ -232,6 +236,7 @@ module Raptor
       File.delete(@stats_file) rescue nil if @stats_file
       File.delete(@pid_file) rescue nil if @pid_file
       @stats.unmap
+      @binder.close
     end
 
     # Returns stats for all worker processes.
@@ -439,6 +444,8 @@ module Raptor
       trap("USR1", "IGNORE")
       trap("USR2", "IGNORE")
 
+      Raptor::CPU.pin(index) if Raptor::CPU.count >= @worker_count
+
       started_at = Process.clock_gettime(Process::CLOCK_REALTIME)
       request_count = 0
 
@@ -501,7 +508,25 @@ module Raptor
       )
       reactor_thread = reactor.run
 
-      server = Server.new(@binder, reactor, thread_pool, http1, http2, connection_options: @connection_options, drain_accept_queue: @drain_accept_queue)
+      worker_listeners = if @bpf_active
+        bpf_listeners = ReuseportBPF.create_worker_listeners(@binder.bind_uris, index, @binder.socket_backlog)
+        non_tcp_listeners = @binder.listeners.reject { |listener| listener.is_a?(TCPServer) }
+        bpf_listeners + non_tcp_listeners
+      else
+        @binder.listeners
+      end
+
+      server = Server.new(
+        @binder,
+        reactor,
+        thread_pool,
+        http1,
+        http2,
+        connection_options: @connection_options,
+        drain_accept_queue: @drain_accept_queue,
+        listeners: worker_listeners,
+        worker_index: (index if @bpf_active)
+      )
       server_thread = server.run
 
       Log.info "Worker #{index} booted"

data/lib/raptor/http.rb

@@ -4,6 +4,7 @@
 require "rack"
 
 require_relative "version"
+require_relative "raptor_native"
 
 module Raptor
   # Shared HTTP utilities used by both the HTTP/1.x and HTTP/2 handlers:
@@ -51,6 +52,46 @@ module Raptor
       end
     end
 
+    # Writes `strings` in full via a single `writev(2)` syscall when possible,
+    # falling back to per-string writes on partial results. Bounded by
+    # `timeout` so a slow client can't pin the writing thread.
+    #
+    # @param socket [TCPSocket] the socket to write to
+    # @param strings [Array<String>] the buffers to write in order
+    # @param timeout [Integer] seconds to wait for the socket to become writable on each retry
+    # @return [void]
+    # @raise [WriteError] if the socket is not writable within the timeout or raises IOError
+    #
+    # @rbs (TCPSocket socket, Array[String] strings, ?timeout: Integer) -> void
+    def self.socket_writev(socket, strings, timeout: WRITE_TIMEOUT)
+      total = strings.sum(&:bytesize)
+      return if total.zero?
+
+      begin
+        written = Raptor::VectorIO.writev_nonblock(socket, strings)
+      rescue IO::WaitWritable
+        raise WriteError unless socket.wait_writable(timeout)
+        retry
+      rescue IOError
+        raise WriteError
+      end
+
+      return if written == total
+
+      offset = 0
+      strings.each do |string|
+        size = string.bytesize
+        if written >= offset + size
+          offset += size
+        else
+          start = written - offset
+          socket_write(socket, start.zero? ? string : string.byteslice(start..-1), timeout: timeout)
+          offset += size
+          written = offset
+        end
+      end
+    end
+
     # Writes a Common Log Format entry to `io`. Write failures are silently
     # ignored.
     #

data/lib/raptor/http1.rb

@@ -22,6 +22,7 @@ module Raptor
     FILE_CHUNK_SIZE = 64 * 1024
     MAX_CHUNK_OVERHEAD = 16 * 1024
     READ_BUFFER_SIZE = 64 * 1024
+    RESPONSE_BUFFER_CAPACITY = 4 * 1024
     KEEPALIVE_READ_TIMEOUT = 0.001
     MAX_KEEPALIVE_REQUESTS = 100
 
@@ -170,6 +171,19 @@ module Raptor
       Http.socket_write(socket, string, timeout: @write_timeout)
     end
 
+    # Instance-level wrapper around {Http.socket_writev} that applies the
+    # configured `write_timeout`.
+    #
+    # @param socket [TCPSocket] the socket to write to
+    # @param strings [Array<String>] the buffers to write in order
+    # @return [void]
+    # @raise [Http::WriteError] if the socket is not writable within the timeout or raises IOError
+    #
+    # @rbs (TCPSocket socket, Array[String] strings) -> void
+    def socket_writev(socket, strings)
+      Http.socket_writev(socket, strings, timeout: @write_timeout)
+    end
+
     # Signals eager keep-alive loops to stop processing further requests on
     # their connections. In-flight requests complete normally.
     #
@@ -194,8 +208,10 @@ module Raptor
     #
     # @rbs (TCPSocket socket, Integer id, Reactor reactor, AtomicThreadPool thread_pool, String remote_addr, String url_scheme) -> void
     def eager_accept(socket, id, reactor, thread_pool, remote_addr, url_scheme)
-      data = begin
-        socket.read_nonblock(READ_BUFFER_SIZE)
+      buffer = (Thread.current[:raptor_read_buffer] ||= String.new(capacity: READ_BUFFER_SIZE))
+
+      begin
+        socket.read_nonblock(READ_BUFFER_SIZE, buffer)
       rescue IO::WaitReadable
         reactor.add(
           id: id,
@@ -209,9 +225,6 @@ module Raptor
         return
       end
 
-      buffer = String.new
-      buffer << data
-
       while socket.respond_to?(:pending) && socket.pending > 0
         buffer << socket.read_nonblock(socket.pending)
       end
@@ -530,8 +543,10 @@ module Raptor
           return
         end
 
-        data = begin
-          socket.read_nonblock(READ_BUFFER_SIZE)
+        buffer = (Thread.current[:raptor_read_buffer] ||= String.new(capacity: READ_BUFFER_SIZE))
+
+        begin
+          socket.read_nonblock(READ_BUFFER_SIZE, buffer)
         rescue IO::WaitReadable
           reactor.persist(socket, id, request_count, remote_addr: remote_addr, url_scheme: url_scheme)
           return
@@ -540,9 +555,6 @@ module Raptor
           return
         end
 
-        buffer = String.new
-        buffer << data
-
         while socket.respond_to?(:pending) && socket.pending > 0
           buffer << socket.read_nonblock(socket.pending)
         end
@@ -631,7 +643,7 @@ module Raptor
       reactor.persist(socket, id, request_count, remote_addr: remote_addr, url_scheme: url_scheme)
       state = {
         id: id,
-        buffer: buffer,
+        buffer: buffer.dup,
         env: env,
         request_count: request_count,
         parse_data: parse_data,
@@ -922,7 +934,8 @@ module Raptor
       end
     end
 
-    # Builds the HTTP status line string.
+    # Returns the HTTP status line for `status`. Callers must not retain the
+    # returned string across further calls on the same thread.
     #
     # @param http_version [String] "HTTP/1.1" or "HTTP/1.0"
     # @param status [Integer] HTTP status code
@@ -931,7 +944,10 @@ module Raptor
     # @rbs (String http_version, Integer status) -> String
     def build_status_line(http_version, status)
       cache = http_version == HTTP_11 ? STATUS_LINE_CACHE_11 : STATUS_LINE_CACHE_10
-      cache[status].dup
+      response = (Thread.current[:raptor_response_buffer] ||= String.new(capacity: RESPONSE_BUFFER_CAPACITY))
+      response.clear
+      response << cache[status]
+      response
     end
 
     # Writes response headers and delegates body writing to the hijack callback.
@@ -1106,10 +1122,7 @@ module Raptor
       end
     end
 
-    # Writes a single-element array body, optionally buffering it with the headers.
-    #
-    # Small bodies are concatenated with the headers into one write to reduce
-    # system call overhead.
+    # Writes a single-element array body to the socket.
     #
     # @param socket [TCPSocket] the client socket
     # @param response [String] headers already serialized, to be written before the body
@@ -1125,11 +1138,8 @@ module Raptor
       if use_chunked
         response << "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n"
         socket_write(socket, response)
-      elsif chunk.bytesize < BODY_BUFFER_THRESHOLD
-        socket_write(socket, response << chunk)
       else
-        socket_write(socket, response)
-        socket_write(socket, chunk)
+        socket_writev(socket, [response, chunk])
       end
     end
 
@@ -1156,10 +1166,8 @@ module Raptor
       else
         body_array.each do |chunk|
           raise TypeError, "body must yield String values" unless chunk.is_a?(String)
-
-          response << chunk
         end
-        socket_write(socket, response)
+        socket_writev(socket, [response, *body_array])
       end
     end
 

data/lib/raptor/reuseport_bpf.rb

@@ -0,0 +1,108 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require "socket"
+require "uri"
+
+begin
+  require "libbpf-ruby"
+rescue LoadError
+end
+
+module Raptor
+  # Routes incoming connections across worker processes to the worker with
+  # the lowest reactor backlog.
+  #
+  # Auto-enabled on Linux when the `libbpf-ruby` gem is installed and the
+  # BPF object file has been compiled. Falls back silently to standard
+  # `SO_REUSEPORT` when either is missing. Raises when the kernel refuses
+  # the BPF program. Wraps `tcp://` bindings only; non-tcp bindings are
+  # left to the binder's shared listeners.
+  #
+  module ReuseportBPF
+    LIBBPF_LOADED = !!defined?(LibBPFRuby)
+    BPF_OBJECT_PATH = File.expand_path("../../ext/raptor_bpf/reuseport_select.bpf.o", __dir__)
+
+    # Whether the preconditions for BPF-directed reuseport are met on this
+    # platform. Does not imply that the kernel will accept the program.
+    #
+    # @return [Boolean]
+    #
+    # @rbs () -> bool
+    def self.supported?
+      LIBBPF_LOADED && File.exist?(BPF_OBJECT_PATH)
+    end
+
+    # Prepares BPF-directed routing for `worker_count` workers.
+    #
+    # Returns true when BPF-directed dispatch is active. Returns false
+    # when the platform is unsupported. Raises when the kernel refuses
+    # the program.
+    #
+    # @param worker_count [Integer] number of worker processes that will bind sockets
+    # @return [Boolean]
+    #
+    # @rbs (Integer worker_count) -> bool
+    def self.setup(worker_count)
+      return false unless supported?
+
+      @object = LibBPFRuby::Object.new(BPF_OBJECT_PATH)
+      @program_fd = @object.program_fd("select_least_loaded")
+      @socks_fd = @object.map_fd("socks")
+      @loads_fd = @object.map_fd("loads")
+
+      LibBPFRuby.map_update(@loads_fd, [0].pack("L"), [worker_count].pack("L"))
+      true
+    end
+
+    # Returns tcp listening sockets bound and registered for `worker_index`.
+    # Skips non-tcp bind URIs.
+    #
+    # @param bind_uris [Array<String>] the configured bind URIs
+    # @param worker_index [Integer] slot index for this worker in the socks map
+    # @param socket_backlog [Integer] kernel listen() queue depth
+    # @return [Array<TCPServer>] the tcp listening sockets created for this worker
+    #
+    # @rbs (Array[String] bind_uris, Integer worker_index, Integer socket_backlog) -> Array[TCPServer]
+    def self.create_worker_listeners(bind_uris, worker_index, socket_backlog)
+      @load_key = [worker_index + 1].pack("L")
+      @load_value = String.new("\x00\x00\x00\x00", encoding: Encoding::ASCII_8BIT)
+
+      bind_uris.filter_map do |bind_uri|
+        uri = URI(bind_uri)
+        next unless uri.scheme == "tcp"
+
+        host = uri.host
+        host = host[1..-2] if host&.start_with?("[")
+
+        addrinfo = Addrinfo.tcp(host, uri.port)
+        socket = Socket.new(addrinfo.afamily, Socket::SOCK_STREAM, 0)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, true)
+        socket.bind(addrinfo)
+        socket.listen(socket_backlog)
+
+        LibBPFRuby.sockmap_update(@socks_fd, [worker_index].pack("L"), socket)
+        LibBPFRuby.attach_reuseport(socket, @program_fd)
+
+        tcp_server = TCPServer.for_fd(socket.fileno)
+        socket.autoclose = false
+        tcp_server
+      end
+    end
+
+    # Publishes this worker's current backlog to the BPF map.
+    #
+    # @param backlog [Integer] the worker's current reactor backlog
+    # @return [void]
+    #
+    # @rbs (Integer backlog) -> void
+    def self.update_load(backlog)
+      @load_value.setbyte(0, backlog & 0xff)
+      @load_value.setbyte(1, (backlog >> 8) & 0xff)
+      @load_value.setbyte(2, (backlog >> 16) & 0xff)
+      @load_value.setbyte(3, (backlog >> 24) & 0xff)
+      LibBPFRuby.map_update(@loads_fd, @load_key, @load_value)
+    end
+  end
+end