raptor 0.8.0 → 0.10.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_http/raptor_http.c

@@ -4,6 +4,7 @@
  */
 
 #include "ruby.h"
+#include "ruby/encoding.h"
 #include <assert.h>
 #include <string.h>
 #include <ctype.h>
@@ -44,6 +45,75 @@ static VALUE global_server_protocol;
 static VALUE global_request_path;
 static VALUE global_fragment;
 
+struct common_field {
+  const char *name;
+  size_t len;
+  VALUE interned;
+};
+
+#define FIELD(name) { name, sizeof(name) - 1, Qnil }
+
+static struct common_field common_fields[] = {
+  FIELD("HTTP_HOST"),
+  FIELD("HTTP_USER_AGENT"),
+  FIELD("HTTP_CONNECTION"),
+  FIELD("HTTP_ACCEPT"),
+  FIELD("HTTP_ACCEPT_ENCODING"),
+  FIELD("HTTP_ACCEPT_LANGUAGE"),
+  FIELD("HTTP_ACCEPT_CHARSET"),
+  FIELD("HTTP_COOKIE"),
+  FIELD("HTTP_REFERER"),
+  FIELD("HTTP_CACHE_CONTROL"),
+  FIELD("HTTP_PRAGMA"),
+
+  FIELD("CONTENT_LENGTH"),
+  FIELD("CONTENT_TYPE"),
+  FIELD("HTTP_TRANSFER_ENCODING"),
+
+  FIELD("HTTP_AUTHORIZATION"),
+  FIELD("HTTP_ORIGIN"),
+  FIELD("HTTP_EXPECT"),
+
+  FIELD("HTTP_IF_MATCH"),
+  FIELD("HTTP_IF_NONE_MATCH"),
+  FIELD("HTTP_IF_MODIFIED_SINCE"),
+  FIELD("HTTP_IF_UNMODIFIED_SINCE"),
+  FIELD("HTTP_IF_RANGE"),
+  FIELD("HTTP_RANGE"),
+
+  FIELD("HTTP_UPGRADE"),
+  FIELD("HTTP_UPGRADE_INSECURE_REQUESTS"),
+
+  FIELD("HTTP_SEC_FETCH_DEST"),
+  FIELD("HTTP_SEC_FETCH_MODE"),
+  FIELD("HTTP_SEC_FETCH_SITE"),
+  FIELD("HTTP_SEC_FETCH_USER"),
+  FIELD("HTTP_SEC_CH_UA"),
+  FIELD("HTTP_SEC_CH_UA_MOBILE"),
+  FIELD("HTTP_SEC_CH_UA_PLATFORM"),
+  FIELD("HTTP_DNT"),
+
+  FIELD("HTTP_X_FORWARDED_FOR"),
+  FIELD("HTTP_X_FORWARDED_HOST"),
+  FIELD("HTTP_X_FORWARDED_PROTO"),
+  FIELD("HTTP_X_FORWARDED_SCHEME"),
+  FIELD("HTTP_X_FORWARDED_SSL"),
+  FIELD("HTTP_X_REAL_IP")
+};
+
+#undef FIELD
+
+#define NUM_COMMON_FIELDS (sizeof(common_fields) / sizeof(common_fields[0]))
+
+static VALUE raptor_http_intern_field(const char *buf, size_t len) {
+  for (size_t i = 0; i < NUM_COMMON_FIELDS; i++) {
+    if (common_fields[i].len == len && memcmp(common_fields[i].name, buf, len) == 0) {
+      return common_fields[i].interned;
+    }
+  }
+  return rb_enc_interned_str(buf, len, rb_utf8_encoding());
+}
+
 static inline void upcase_header_char(char *c) {
   if (*c >= 'a' && *c <= 'z')
     *c &= ~0x20;
@@ -294,16 +364,19 @@ tr26:
     else if (parser->field_len == 12 && memcmp(field_ptr, "CONTENT_TYPE", 12) == 0)
       needs_http_prefix = 0;
 
+    size_t key_len;
     if (needs_http_prefix) {
       memcpy(parser->buf, "HTTP_", 5);
       memcpy(parser->buf + 5, field_ptr, parser->field_len);
-      parser->buf[5 + parser->field_len] = '\0';
+      key_len = 5 + parser->field_len;
+      parser->buf[key_len] = '\0';
     } else {
       memcpy(parser->buf, field_ptr, parser->field_len);
-      parser->buf[parser->field_len] = '\0';
+      key_len = parser->field_len;
+      parser->buf[key_len] = '\0';
     }
 
-    VALUE key = rb_str_new2(parser->buf);
+    VALUE key = raptor_http_intern_field(parser->buf, key_len);
     VALUE value = rb_str_new(PTR_TO(mark), value_len);
 
     char *value_ptr = RSTRING_PTR(value);
@@ -351,16 +424,19 @@ tr29:
     else if (parser->field_len == 12 && memcmp(field_ptr, "CONTENT_TYPE", 12) == 0)
       needs_http_prefix = 0;
 
+    size_t key_len;
     if (needs_http_prefix) {
       memcpy(parser->buf, "HTTP_", 5);
       memcpy(parser->buf + 5, field_ptr, parser->field_len);
-      parser->buf[5 + parser->field_len] = '\0';
+      key_len = 5 + parser->field_len;
+      parser->buf[key_len] = '\0';
     } else {
       memcpy(parser->buf, field_ptr, parser->field_len);
-      parser->buf[parser->field_len] = '\0';
+      key_len = parser->field_len;
+      parser->buf[key_len] = '\0';
     }
 
-    VALUE key = rb_str_new2(parser->buf);
+    VALUE key = raptor_http_intern_field(parser->buf, key_len);
     VALUE value = rb_str_new(PTR_TO(mark), value_len);
 
     char *value_ptr = RSTRING_PTR(value);
@@ -1237,6 +1313,11 @@ RUBY_FUNC_EXPORTED void Init_raptor_http(void) {
   global_request_path = rb_str_new2("PATH_INFO");
   global_fragment = rb_str_new2("FRAGMENT");
 
+  for (size_t i = 0; i < NUM_COMMON_FIELDS; i++) {
+    common_fields[i].interned = rb_enc_interned_str(common_fields[i].name, common_fields[i].len, rb_utf8_encoding());
+    rb_global_variable(&common_fields[i].interned);
+  }
+
   rb_define_alloc_func(cHttpParser, parser_alloc);
   rb_define_method(cHttpParser, "execute", parser_execute, 3);
   rb_define_method(cHttpParser, "finished?", parser_finished_p, 0);

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,16 @@ 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.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      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.
     #