curb 1.3.7 → 1.4.0

data/ext/curb_multi.c

@@ -32,6 +32,7 @@
 #include <sys/time.h>
 #include <time.h>
 #endif
+#include <limits.h>
 #include <stdint.h>
 #include <stdarg.h>
 
@@ -62,7 +63,40 @@
   #include <fcntl.h>
 #endif
 
-#if defined(HAVE_CURL_MULTI_WAIT) && !defined(HAVE_RB_THREAD_FD_SELECT)
+/*
+ * Prefer curl_multi_poll for the blocking perform loop: it uses poll(), so it
+ * has no FD_SETSIZE limit (select-based waiting cannot see sockets numbered
+ * above 1024 and degrades to fixed sleeps), and curl_multi_wakeup lets the
+ * unblocking function end the wait immediately for Thread#raise, Thread#kill
+ * and signal delivery.
+ */
+#if defined(HAVE_CURL_MULTI_POLL) && defined(HAVE_CURL_MULTI_WAKEUP) && defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+#define CURB_USE_MULTI_POLL 1
+#endif
+
+#ifdef CURB_USE_MULTI_POLL
+struct multi_poll_args {
+  CURLM *handle;
+  int timeout_ms;
+  int numfds;
+  CURLMcode code;
+};
+
+static void *curb_multi_poll_without_gvl(void *p) {
+  struct multi_poll_args *args = p;
+  args->code = curl_multi_poll(args->handle, NULL, 0, args->timeout_ms, &args->numfds);
+  return NULL;
+}
+
+/* Unblocking function: curl_multi_wakeup is safe to call from another thread
+ * while curl_multi_poll is blocked on the same handle. A wakeup that arrives
+ * after the poll returned only makes the next poll return early once. */
+static void curb_multi_poll_ubf(void *handle) {
+  curl_multi_wakeup((CURLM *)handle);
+}
+#endif
+
+#if defined(HAVE_CURL_MULTI_WAIT) && !defined(HAVE_RB_THREAD_FD_SELECT) && !defined(CURB_USE_MULTI_POLL)
 struct wait_args {
   CURLM *handle;
   long timeout_ms;
@@ -76,10 +110,16 @@ static void *curl_multi_wait_wrapper(void *p) {
 #endif
 
 static VALUE cRubyFiber;
+static VALUE cRubyRactor;
 static ID id_fiber_blocking_p;
 static ID id_fiber_scheduler;
 static ID id_kernel_sleep;
 static ID id_io_wait;
+static ID id_ractor_current;
+static ID id_ractor_aref;
+static ID id_ractor_aset;
+static ID id_ractor_default_timeout_key;
+static ID id_ractor_autoclose_key;
 
 /*
  * Ruby 3.0 introduced the Fiber scheduler at the Ruby level, but did not ship
@@ -163,6 +203,7 @@ static ID id_deferred_exception_ivar;
 static ID id_deferred_exception_source_id_ivar;
 static ID id_native_safety_signatures_ivar;
 static ID id_socket_io_cache_ivar;
+static ID id_socket_poller_io_ivar;
 
 #ifdef RDOC_NEVER_DEFINED
   mCurl = rb_define_module("Curl");
@@ -173,6 +214,32 @@ VALUE cCurlMulti;
 static long cCurlMutiDefaulttimeout = 100; /* milliseconds */
 static char cCurlMutiAutoClose = 0;
 
+/* Ruby 3.0+ provides storage owned by the current Ractor. Keep configurable
+ * defaults there so separate Ractors never race on process-global C values.
+ * Rubies without Ractor retain the historical process-wide settings. */
+static VALUE curb_multi_ractor_setting(ID key) {
+  VALUE current;
+
+  if (NIL_P(cRubyRactor)) return Qundef;
+  current = rb_funcall(cRubyRactor, id_ractor_current, 0);
+  return rb_funcall(current, id_ractor_aref, 1, ID2SYM(key));
+}
+
+static void curb_multi_set_ractor_setting(ID key, VALUE value) {
+  VALUE current = rb_funcall(cRubyRactor, id_ractor_current, 0);
+  rb_funcall(current, id_ractor_aset, 2, ID2SYM(key), value);
+}
+
+static long curb_multi_default_timeout(void) {
+  VALUE value = curb_multi_ractor_setting(id_ractor_default_timeout_key);
+  return (UNDEF_P(value) || NIL_P(value)) ? cCurlMutiDefaulttimeout : NUM2LONG(value);
+}
+
+static int curb_multi_autoclose_enabled(void) {
+  VALUE value = curb_multi_ractor_setting(id_ractor_autoclose_key);
+  return (UNDEF_P(value) || NIL_P(value)) ? cCurlMutiAutoClose == 1 : RTEST(value);
+}
+
 static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int result);
 static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy);
 static void rb_curl_multi_read_info(VALUE self, CURLM *mptr);
@@ -563,12 +630,18 @@ static VALUE ruby_curl_multi_initialize(VALUE self) {
  * call-seq:
  *   Curl::Multi.default_timeout = 4 => 4
  *
- * Set the global default time out for all Curl::Multi Handles.  This value is used
- * when libcurl cannot determine a timeout value when calling curl_multi_timeout.
+ * Set the default timeout for Curl::Multi handles in the current Ractor. On
+ * Rubies without Ractor this remains process-wide. This value is used when
+ * libcurl cannot determine a timeout value when calling curl_multi_timeout.
  *
  */
 VALUE ruby_curl_multi_set_default_timeout(VALUE klass, VALUE timeout) {
-  cCurlMutiDefaulttimeout = NUM2LONG(timeout);
+  long value = NUM2LONG(timeout);
+  if (NIL_P(cRubyRactor)) {
+    cCurlMutiDefaulttimeout = value;
+  } else {
+    curb_multi_set_ractor_setting(id_ractor_default_timeout_key, LONG2NUM(value));
+  }
   return timeout;
 }
 
@@ -576,23 +649,29 @@ VALUE ruby_curl_multi_set_default_timeout(VALUE klass, VALUE timeout) {
  * call-seq:
  *   Curl::Multi.default_timeout = 4 => 4
  *
- * Get the global default time out for all Curl::Multi Handles.
+ * Get the current Ractor's default timeout for Curl::Multi handles.
  *
  */
 VALUE ruby_curl_multi_get_default_timeout(VALUE klass) {
-  return LONG2NUM(cCurlMutiDefaulttimeout);
+  return LONG2NUM(curb_multi_default_timeout());
 }
 
 /*
  * call-seq:
  *   Curl::Multi.autoclose = true => true
  *
- * Automatically close open connections after each request. Otherwise, the connection will remain open 
- * for reuse until the next GC
+ * Automatically close open connections after each request in the current
+ * Ractor. Otherwise, the connection will remain open for reuse until the next
+ * GC.
  *
  */
 VALUE ruby_curl_multi_set_autoclose(VALUE klass, VALUE onoff) {
-  cCurlMutiAutoClose = ((onoff == Qtrue) ? 1 : 0);
+  VALUE value = onoff == Qtrue ? Qtrue : Qfalse;
+  if (NIL_P(cRubyRactor)) {
+    cCurlMutiAutoClose = RTEST(value) ? 1 : 0;
+  } else {
+    curb_multi_set_ractor_setting(id_ractor_autoclose_key, value);
+  }
   return onoff;
 }
 
@@ -600,11 +679,11 @@ VALUE ruby_curl_multi_set_autoclose(VALUE klass, VALUE onoff) {
  * call-seq:
  *   Curl::Multi.autoclose => true|false
  *
- * Get the global default autoclose setting for all Curl::Multi Handles.
+ * Get the current Ractor's default autoclose setting for Curl::Multi handles.
  *
  */
 VALUE ruby_curl_multi_get_autoclose(VALUE klass) {
-  return cCurlMutiAutoClose == 1 ? Qtrue : Qfalse;
+  return curb_multi_autoclose_enabled() ? Qtrue : Qfalse;
 }
 
 /*
@@ -739,7 +818,7 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
     }
   }
 
-  rbce->multi_attachment_generation++;
+  rbce->multi_attachment_generation = ++rbcm->attachment_sequence;
   st_insert(rbcm->attached, (st_data_t)rbce, (st_data_t)easy);
 
   /* track a reference to associated multi handle */
@@ -859,42 +938,17 @@ struct multi_complete_callback_args {
   ruby_curl_multi *rbcm;
   ruby_curl_easy *rbce;
   int result;
-  st_table *attached_snapshot;
+  /* rbcm->attachment_sequence before the callbacks ran; easies stamped later
+   * were attached (or re-attached) by the callbacks. */
+  unsigned long attachment_sequence_before;
 };
 
-static int snapshot_attached_easy_i(st_data_t key, st_data_t val, st_data_t arg) {
-  st_table *snapshot = (st_table *)arg;
-  ruby_curl_easy *rbce = (ruby_curl_easy *)key;
-
-  if (!rbce) {
-    return ST_CONTINUE;
-  }
-
-  st_insert(snapshot, key, (st_data_t)rbce->multi_attachment_generation);
-  return ST_CONTINUE;
-}
-
-static st_table *capture_attached_easy_snapshot(ruby_curl_multi *rbcm) {
-  st_table *snapshot = st_init_numtable();
-
-  if (!snapshot) {
-    rb_raise(rb_eNoMemError, "Failed to allocate multi callback snapshot table");
-  }
-
-  if (rbcm && rbcm->attached) {
-    st_foreach(rbcm->attached, snapshot_attached_easy_i, (st_data_t)snapshot);
-  }
-
-  return snapshot;
-}
-
 struct collect_new_attached_easies_ctx {
-  st_table *snapshot;
+  unsigned long attachment_sequence_before;
   VALUE easies;
 };
 
 static int collect_new_attached_easies_i(st_data_t key, st_data_t val, st_data_t arg) {
-  st_data_t existing = 0;
   ruby_curl_easy *rbce = (ruby_curl_easy *)key;
   struct collect_new_attached_easies_ctx *ctx = (struct collect_new_attached_easies_ctx *)arg;
 
@@ -902,24 +956,25 @@ static int collect_new_attached_easies_i(st_data_t key, st_data_t val, st_data_t
     return ST_CONTINUE;
   }
 
-  if (!ctx->snapshot || !st_lookup(ctx->snapshot, key, &existing) ||
-      existing != (st_data_t)rbce->multi_attachment_generation) {
+  if (rbce->multi_attachment_generation > ctx->attachment_sequence_before) {
     rb_ary_push(ctx->easies, (VALUE)val);
   }
 
   return ST_CONTINUE;
 }
 
-static void rb_curl_multi_remove_added_easies_since_snapshot(VALUE self, ruby_curl_multi *rbcm, st_table *snapshot) {
+/* Only runs when a completion callback raised, so this walk over the
+ * attached table stays off the per-completion path. */
+static void rb_curl_multi_remove_easies_attached_since(VALUE self, ruby_curl_multi *rbcm, unsigned long attachment_sequence_before) {
   struct collect_new_attached_easies_ctx ctx;
   VALUE easies = rb_ary_new();
   long index;
 
-  if (!rbcm || !snapshot || !rbcm->attached) {
+  if (!rbcm || !rbcm->attached) {
     return;
   }
 
-  ctx.snapshot = snapshot;
+  ctx.attachment_sequence_before = attachment_sequence_before;
   ctx.easies = easies;
   st_foreach(rbcm->attached, collect_new_attached_easies_i, (st_data_t)&ctx);
 
@@ -956,7 +1011,7 @@ static void stash_and_raise_status_callback_error_if_unmasked(struct multi_compl
   }
 
   stash_multi_exception_if_unset(args->self, exception, args->easy);
-  rb_curl_multi_remove_added_easies_since_snapshot(args->self, args->rbcm, args->attached_snapshot);
+  rb_curl_multi_remove_easies_attached_since(args->self, args->rbcm, args->attachment_sequence_before);
   rb_exc_raise(exception);
 }
 
@@ -1059,11 +1114,6 @@ static VALUE rb_curl_multi_finish_completion_callbacks(VALUE argp) {
     args->rbce->multi = Qnil;
   }
 
-  if (args->attached_snapshot) {
-    st_free_table(args->attached_snapshot);
-    args->attached_snapshot = NULL;
-  }
-
   return Qnil;
 }
 
@@ -1124,7 +1174,7 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
     rbcm,
     rbce,
     result,
-    capture_attached_easy_snapshot(rbcm)
+    rbcm->attachment_sequence
   };
   rb_ensure(rb_curl_multi_run_completion_callbacks, (VALUE)&args,
             rb_curl_multi_finish_completion_callbacks, (VALUE)&args);
@@ -1171,21 +1221,14 @@ static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_runnin
   CURLMcode mcode;
 
   /*
-   * curl_multi_perform will return CURLM_CALL_MULTI_PERFORM only when it wants to be called again immediately.
-   * When things are fine and there is nothing immediate it wants done, it'll return CURLM_OK.
-   *
-   * It will perform all pending actions on all added easy handles attached to this multi handle. We will loop
-   * here as long as mcode is CURLM_CALL_MULTIPERFORM.
+   * Perform all pending actions on every easy handle attached to this multi
+   * handle. libcurl stopped returning CURLM_CALL_MULTI_PERFORM here in 7.20
+   * (curb supports 7.58+); should it appear, treat it as success: the drive
+   * loop calls curl_multi_perform again on its next pass.
    */
-  do {
-    mcode = curl_multi_perform(multi_handle, still_running);
-  } while (mcode == CURLM_CALL_MULTI_PERFORM);
+  mcode = curl_multi_perform(multi_handle, still_running);
 
-  /*
-   * Nothing more to do, check if an error occured in the loop above and raise an exception if necessary.
-   */
-
-  if (mcode != CURLM_OK) {
+  if (mcode != CURLM_OK && mcode != CURLM_CALL_MULTI_PERFORM) {
     raise_curl_multi_error_exception(mcode);
   }
 
@@ -1200,10 +1243,36 @@ static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_runnin
 
 #if defined(HAVE_CURL_MULTI_SOCKET_ACTION) && defined(HAVE_CURLMOPT_SOCKETFUNCTION) && defined(HAVE_CURLMOPT_TIMERFUNCTION) && defined(HAVE_RB_THREAD_FD_SELECT) && !defined(_WIN32)
 /* ---- socket-action implementation (scheduler-friendly) ---- */
+
+/*
+ * Under a fiber scheduler, mirror libcurl's socket interest into a kernel
+ * event queue (epoll or kqueue) and wait on that single descriptor with the
+ * scheduler's io_wait hook. Every scheduler implements io_wait, so this avoids
+ * the optional io_select hook (which Async implements by starting a thread
+ * per call) and the one-descriptor fallback for schedulers without it.
+ */
+#if defined(HAVE_SYS_EPOLL_H) && defined(HAVE_EPOLL_CREATE1)
+#include <sys/epoll.h>
+#define CURB_SOCKET_POLLER 1
+#define CURB_SOCKET_POLLER_EPOLL 1
+#define CURB_SOCKET_POLLER_NAME "epoll"
+#elif defined(HAVE_SYS_EVENT_H) && defined(HAVE_KQUEUE)
+#include <sys/types.h>
+#include <sys/event.h>
+#define CURB_SOCKET_POLLER 1
+#define CURB_SOCKET_POLLER_KQUEUE 1
+#define CURB_SOCKET_POLLER_NAME "kqueue"
+#endif
+
+/* Events harvested per poller read; more are collected on following rounds. */
+#define CURB_SOCKET_POLLER_BATCH 64
+
 typedef struct {
   st_table *sock_map;     /* key: int fd, value: int 'what' (CURL_POLL_*) */
   long long timeout_deadline_ms; /* absolute deadline for CURL_SOCKET_TIMEOUT */
   VALUE io_cache;         /* fd -> IO wrapper for fiber-scheduler waits */
+  int poller_fd;          /* epoll/kqueue descriptor, or -1 when unused */
+  VALUE poller_io;        /* IO wrapper for poller_fd passed to io_wait */
 } multi_socket_ctx;
 
 static long long multi_socket_current_time_ms(void) {
@@ -1294,12 +1363,77 @@ static int multi_socket_cselect_flags_for_wait_events(int events) {
   return flags;
 }
 
+#ifdef CURB_SOCKET_POLLER
+static int multi_socket_poller_create(void) {
+#if defined(CURB_SOCKET_POLLER_EPOLL)
+  return epoll_create1(EPOLL_CLOEXEC);
+#else
+  int fd = kqueue();
+  if (fd >= 0) fcntl(fd, F_SETFD, FD_CLOEXEC);
+  return fd;
+#endif
+}
+
+/*
+ * Bring the poller's interest for fd from old_what to new_what, where each is
+ * a CURL_POLL_IN/OUT/INOUT mask and 0 means "not registered". Registration is
+ * level-triggered so readiness left unconsumed is reported again. Errors are
+ * ignored: the kernel drops closed descriptors from both epoll and kqueue on
+ * its own, so a stale delete or a re-add after fd reuse is harmless.
+ */
+static void multi_socket_poller_update(multi_socket_ctx *ctx, int fd, int old_what, int new_what) {
+  if (!ctx || ctx->poller_fd < 0 || old_what == new_what) return;
+#if defined(CURB_SOCKET_POLLER_EPOLL)
+  {
+    struct epoll_event ev;
+    memset(&ev, 0, sizeof(ev));
+    ev.data.fd = fd;
+    if (new_what & CURL_POLL_IN) ev.events |= EPOLLIN;
+    if (new_what & CURL_POLL_OUT) ev.events |= EPOLLOUT;
+
+    if (new_what == 0) {
+      epoll_ctl(ctx->poller_fd, EPOLL_CTL_DEL, fd, &ev);
+    } else if (old_what == 0) {
+      if (epoll_ctl(ctx->poller_fd, EPOLL_CTL_ADD, fd, &ev) != 0 && errno == EEXIST) {
+        epoll_ctl(ctx->poller_fd, EPOLL_CTL_MOD, fd, &ev);
+      }
+    } else if (epoll_ctl(ctx->poller_fd, EPOLL_CTL_MOD, fd, &ev) != 0 && errno == ENOENT) {
+      epoll_ctl(ctx->poller_fd, EPOLL_CTL_ADD, fd, &ev);
+    }
+  }
+#else
+  {
+    /* kqueue tracks read and write as separate filters. Apply each change on
+     * its own so one failing change cannot skip the others. */
+    struct kevent change;
+    int old_read = (old_what & CURL_POLL_IN) != 0;
+    int new_read = (new_what & CURL_POLL_IN) != 0;
+    int old_write = (old_what & CURL_POLL_OUT) != 0;
+    int new_write = (new_what & CURL_POLL_OUT) != 0;
+
+    if (old_read != new_read) {
+      EV_SET(&change, fd, EVFILT_READ, new_read ? EV_ADD : EV_DELETE, 0, 0, NULL);
+      kevent(ctx->poller_fd, &change, 1, NULL, 0, NULL);
+    }
+    if (old_write != new_write) {
+      EV_SET(&change, fd, EVFILT_WRITE, new_write ? EV_ADD : EV_DELETE, 0, 0, NULL);
+      kevent(ctx->poller_fd, &change, 1, NULL, 0, NULL);
+    }
+  }
+#endif
+}
+#endif
+
 static void multi_socket_forget_fd(multi_socket_ctx *ctx, int fd) {
   st_data_t key = (st_data_t)fd;
   st_data_t rec;
 
   if (!ctx) return;
-  if (ctx->sock_map) st_delete(ctx->sock_map, &key, &rec);
+  if (ctx->sock_map && st_delete(ctx->sock_map, &key, &rec)) {
+#ifdef CURB_SOCKET_POLLER
+    multi_socket_poller_update(ctx, fd, (int)rec, 0);
+#endif
+  }
   if (!NIL_P(ctx->io_cache)) rb_hash_delete(ctx->io_cache, INT2NUM(fd));
 }
 
@@ -1329,10 +1463,14 @@ static int multi_socket_cb(CURL *easy, curl_socket_t s, int what, void *userp, v
   } else {
     /* store current interest mask for this fd */
     st_data_t key = (st_data_t)fd;
-    st_data_t old_what;
-    if (st_lookup(ctx->sock_map, key, &old_what) && (int)old_what != what && !NIL_P(ctx->io_cache)) {
+    st_data_t old_what = 0;
+    int tracked = st_lookup(ctx->sock_map, key, &old_what);
+    if (tracked && (int)old_what != what && !NIL_P(ctx->io_cache)) {
       rb_hash_delete(ctx->io_cache, INT2NUM(fd));
     }
+#ifdef CURB_SOCKET_POLLER
+    multi_socket_poller_update(ctx, fd, tracked ? (int)old_what : 0, what);
+#endif
     st_insert(ctx->sock_map, (st_data_t)fd, (st_data_t)what);
 #if CURB_SOCKET_DEBUG
     {
@@ -1412,13 +1550,6 @@ static int st_pick_one_i(st_data_t key, st_data_t val, st_data_t argp) {
   s->found = 1;
   return ST_STOP;
 }
-struct counter_state { int count; };
-static int st_count_i(st_data_t k, st_data_t v, st_data_t argp) {
-  (void)k; (void)v;
-  struct counter_state *c = (struct counter_state *)argp;
-  c->count++;
-  return ST_CONTINUE;
-}
 
 static const char *multi_socket_io_mode_for_curl_poll(int what) {
   if (what == CURL_POLL_IN) return "r";
@@ -1443,6 +1574,112 @@ static VALUE multi_socket_io_for_fd_protected(VALUE argp) {
   return multi_socket_io_for_fd(a->ctx, a->fd, a->what);
 }
 
+#ifdef CURB_SOCKET_POLLER
+static VALUE multi_socket_poller_io(VALUE self, multi_socket_ctx *ctx) {
+  if (NIL_P(ctx->poller_io)) {
+    VALUE io = rb_funcall(rb_cIO, rb_intern("for_fd"), 2, INT2NUM(ctx->poller_fd), rb_str_new_cstr("r"));
+    /* The drive loop's ensure closes poller_fd itself. */
+    rb_funcall(io, rb_intern("autoclose="), 1, Qfalse);
+    ctx->poller_io = io;
+    rb_ivar_set(self, id_socket_poller_io_ivar, io);
+  }
+  return ctx->poller_io;
+}
+
+/*
+ * Report readiness the way select() does: an error or hangup marks the socket
+ * ready for whatever libcurl is waiting on, and libcurl then observes the
+ * condition from the read or write itself. (CURL_CSELECT_ERR would make it
+ * fail the transfer outright, even with response data still buffered.)
+ */
+static int multi_socket_poller_flags(int ready_in, int ready_out, int failed, int what) {
+  int flags = 0;
+
+  if (ready_in) flags |= CURL_CSELECT_IN;
+  if (ready_out) flags |= CURL_CSELECT_OUT;
+  if (failed) flags |= multi_socket_cselect_flags_for_curl_poll(what);
+
+  return flags;
+}
+
+static void multi_socket_poller_act(ruby_curl_multi *rbcm, multi_socket_ctx *ctx, int fd, int ready_in, int ready_out, int failed, int *dispatched) {
+  st_data_t what;
+  int flags;
+  CURLMcode mrc;
+
+  /* An earlier action in this batch may have made libcurl drop the socket. */
+  if (!st_lookup(ctx->sock_map, (st_data_t)fd, &what)) return;
+
+  flags = multi_socket_poller_flags(ready_in, ready_out, failed, (int)what);
+  if (!flags) return;
+
+#if CURB_SOCKET_DEBUG
+  {
+    char b[32];
+    curb_debugf("[curb.socket] poller socket_action fd=%d flags=%s", fd, cselect_flags_str(flags, b, sizeof(b)));
+  }
+#endif
+  mrc = curl_multi_socket_action(rbcm->handle, (curl_socket_t)fd, flags, &rbcm->running);
+  if (mrc != CURLM_OK) raise_curl_multi_error_exception(mrc);
+  (*dispatched)++;
+}
+
+/* Collect pending poller events without blocking and hand each ready socket
+ * to libcurl. Returns the number of socket actions performed. */
+static int multi_socket_poller_dispatch(ruby_curl_multi *rbcm, multi_socket_ctx *ctx) {
+  int dispatched = 0;
+  int rounds = 0;
+  /* kqueue reports read and write readiness as separate events. */
+  int max_rounds = (int)((ctx->sock_map->num_entries * 2) / CURB_SOCKET_POLLER_BATCH) + 1;
+  int n, i;
+
+  do {
+#if defined(CURB_SOCKET_POLLER_EPOLL)
+    struct epoll_event events[CURB_SOCKET_POLLER_BATCH];
+    n = epoll_wait(ctx->poller_fd, events, CURB_SOCKET_POLLER_BATCH, 0);
+    if (n < 0) {
+      if (errno != EINTR) rb_sys_fail("epoll_wait");
+      n = 0;
+    }
+    for (i = 0; i < n; i++) {
+      uint32_t ev = events[i].events;
+      multi_socket_poller_act(rbcm, ctx, events[i].data.fd,
+                              (ev & EPOLLIN) != 0, (ev & EPOLLOUT) != 0,
+                              (ev & (EPOLLERR | EPOLLHUP)) != 0, &dispatched);
+    }
+#else
+    struct kevent events[CURB_SOCKET_POLLER_BATCH];
+    struct timespec no_wait = {0, 0};
+    n = kevent(ctx->poller_fd, NULL, 0, events, CURB_SOCKET_POLLER_BATCH, &no_wait);
+    if (n < 0) {
+      if (errno != EINTR) rb_sys_fail("kevent");
+      n = 0;
+    }
+    for (i = 0; i < n; i++) {
+      if (events[i].flags & EV_ERROR) continue;
+      multi_socket_poller_act(rbcm, ctx, (int)events[i].ident,
+                              events[i].filter == EVFILT_READ, events[i].filter == EVFILT_WRITE,
+                              0, &dispatched);
+    }
+#endif
+  } while (n == CURB_SOCKET_POLLER_BATCH && ++rounds < max_rounds);
+
+  return dispatched;
+}
+
+/* Wait for any tracked socket through the scheduler's io_wait hook on the
+ * poller descriptor, then dispatch whatever became ready. */
+static int multi_socket_poller_wait(VALUE self, ruby_curl_multi *rbcm, multi_socket_ctx *ctx, VALUE scheduler, struct timeval *tv) {
+  VALUE io = multi_socket_poller_io(self, ctx);
+  double timeout_s = (double)tv->tv_sec + ((double)tv->tv_usec / 1e6);
+
+  /* The hook's return value varies across schedulers; the non-blocking
+   * dispatch below is the source of truth for what is ready. */
+  curb_fiber_scheduler_io_wait(scheduler, io, INT2NUM(RB_WAITFD_IN), rb_float_new(timeout_s));
+  return multi_socket_poller_dispatch(rbcm, ctx);
+}
+#endif
+
 #if defined(HAVE_RB_FIBER_SCHEDULER_IO_SELECT) && defined(HAVE_RB_FIBER_SCHEDULER_CURRENT)
 struct build_io_select_arrays_args {
   multi_socket_ctx *ctx;
@@ -1526,7 +1763,7 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
 
     while (rbcm->running) {
     struct timeval tv = {0, 0};
-    long wait_ms = cCurlMutiDefaulttimeout;
+    long wait_ms = curb_multi_default_timeout();
 
     if (multi_socket_timer_due(ctx)) {
       ctx->timeout_deadline_ms = -1;
@@ -1558,13 +1795,7 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
       if (st.found) { wait_fd = st.fd; wait_what = st.what; }
     }
 
-    /* Count tracked fds for logging */
-    int count_tracked = 0;
-    if (ctx->sock_map) {
-      struct counter_state cs = { 0 };
-      st_foreach(ctx->sock_map, st_count_i, (st_data_t)&cs);
-      count_tracked = cs.count;
-    }
+    int count_tracked = ctx->sock_map ? (int)ctx->sock_map->num_entries : 0;
 
     curb_debugf("[curb.socket] wait phase: tracked_fds=%d fd=%d what=%d tv=%ld.%06ld", count_tracked, wait_fd, wait_what, (long)tv.tv_sec, (long)tv.tv_usec);
 
@@ -1573,7 +1804,22 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
     int ready_flags = 0;
 
 	    int handled_wait = 0;
-	    if (count_tracked > 1) {
+#ifdef CURB_SOCKET_POLLER
+	    if (count_tracked > 0 && ctx->poller_fd >= 0) {
+	      VALUE scheduler = curb_fiber_scheduler_current();
+	      if (scheduler != Qnil) {
+	        /* Ready sockets are dispatched inside, so any_ready stays 0 and
+	         * the single-fd dispatch below is skipped. */
+	        int dispatched = multi_socket_poller_wait(self, rbcm, ctx, scheduler, &tv);
+	        curb_debugf("[curb.socket] poller wait dispatched=%d", dispatched);
+	        did_timeout = !dispatched && multi_socket_timer_due(ctx);
+	        handled_wait = 1;
+	      }
+	    }
+#endif
+	    if (handled_wait) {
+	      /* The poller already waited and dispatched. */
+	    } else if (count_tracked > 1) {
 #if defined(HAVE_RB_FIBER_SCHEDULER_IO_SELECT) && defined(HAVE_RB_FIBER_SCHEDULER_CURRENT)
 	      {
 	        VALUE scheduler = curb_fiber_scheduler_current();
@@ -1843,6 +2089,9 @@ static VALUE ruby_curl_multi_socket_drive_body(VALUE argp) {
   return Qtrue;
 }
 struct socket_cleanup_args { VALUE self; ruby_curl_multi *rbcm; multi_socket_ctx *ctx; };
+static VALUE multi_socket_close_io(VALUE io) {
+  return rb_funcall(io, rb_intern("close"), 0);
+}
 static VALUE ruby_curl_multi_socket_drive_ensure(VALUE argp) {
   struct socket_cleanup_args *c = (struct socket_cleanup_args *)argp;
   if (c->rbcm && c->rbcm->handle) {
@@ -1860,10 +2109,27 @@ static VALUE ruby_curl_multi_socket_drive_ensure(VALUE argp) {
       rb_hash_clear(c->ctx->io_cache);
     }
     c->ctx->io_cache = Qnil;
+    if (!NIL_P(c->ctx->poller_io)) {
+      /* Let Ruby and the scheduler drop the wrapper before the descriptor
+       * goes away. autoclose is off, so this leaves poller_fd open. Keep any
+       * exception already propagating out of the drive loop. */
+      VALUE errinfo = rb_errinfo();
+      int state = 0;
+      rb_protect(multi_socket_close_io, c->ctx->poller_io, &state);
+      rb_set_errinfo(errinfo);
+      c->ctx->poller_io = Qnil;
+    }
+    if (c->ctx->poller_fd >= 0) {
+      close(c->ctx->poller_fd);
+      c->ctx->poller_fd = -1;
+    }
   }
   if (!NIL_P(c->self) && rb_ivar_defined(c->self, id_socket_io_cache_ivar)) {
     rb_funcall(c->self, rb_intern("remove_instance_variable"), 1, ID2SYM(id_socket_io_cache_ivar));
   }
+  if (!NIL_P(c->self) && rb_ivar_defined(c->self, id_socket_poller_io_ivar)) {
+    rb_funcall(c->self, rb_intern("remove_instance_variable"), 1, ID2SYM(id_socket_poller_io_ivar));
+  }
   return Qnil;
 }
 
@@ -1882,7 +2148,17 @@ static VALUE ruby_curl_multi_socket_perform_impl(int argc, VALUE *argv, VALUE se
   ctx.sock_map = st_init_numtable();
   ctx.timeout_deadline_ms = -1;
   ctx.io_cache = rb_hash_new();
+  ctx.poller_fd = -1;
+  ctx.poller_io = Qnil;
   rb_ivar_set(self, id_socket_io_cache_ivar, ctx.io_cache);
+#ifdef CURB_SOCKET_POLLER
+  /* Only fiber-scheduler waits use the poller; thread-level waits keep using
+   * rb_thread_fd_select. If it cannot be created the loop falls back to the
+   * io_select/io_wait paths. */
+  if (curb_fiber_scheduler_current() != Qnil) {
+    ctx.poller_fd = multi_socket_poller_create();
+  }
+#endif
 
   /* install socket/timer callbacks */
   curl_multi_setopt(rbcm->handle, CURLMOPT_SOCKETFUNCTION, multi_socket_cb);
@@ -1896,7 +2172,7 @@ static VALUE ruby_curl_multi_socket_perform_impl(int argc, VALUE *argv, VALUE se
   rb_ensure(ruby_curl_multi_socket_drive_body, (VALUE)&body_args, ruby_curl_multi_socket_drive_ensure, (VALUE)&ensure_args);
 
   /* finalize */
-  if (cCurlMutiAutoClose == 1) {
+  if (curb_multi_autoclose_enabled()) {
     rbcm->allow_close_during_perform = 1;
     rb_funcall(self, rb_intern("_autoclose"), 0);
     rbcm->allow_close_during_perform = 0;
@@ -1976,17 +2252,19 @@ static void *curb_select_without_gvl(void *args) {
 static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
   CURLMcode mcode;
   ruby_curl_multi *rbcm;
+  long timeout_milliseconds;
+  VALUE block = Qnil;
+#ifndef CURB_USE_MULTI_POLL
   int maxfd, rc = -1;
   fd_set fdread, fdwrite, fdexcep;
 #ifdef _WIN32
   fd_set crt_fdread, crt_fdwrite, crt_fdexcep;
 #endif
-  long timeout_milliseconds;
   struct timeval tv = {0, 0};
   struct timeval tv_100ms = {0, 100000};
-  VALUE block = Qnil;
 #if !defined(HAVE_RB_THREAD_FD_SELECT) && (defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
   struct _select_set fdset_args;
+#endif
 #endif
 
   rb_scan_args(argc, argv, "0&", &block);
@@ -1997,7 +2275,7 @@ static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
     clear_multi_deferred_exception_source_id_if_any(self);
   }
 
-  timeout_milliseconds = cCurlMutiDefaulttimeout;
+  timeout_milliseconds = curb_multi_default_timeout();
 
   // Run curl_multi_perform for the first time to get the ball rolling
   rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
@@ -2037,12 +2315,36 @@ static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
         continue;
       }
 
-      if (timeout_milliseconds < 0 || timeout_milliseconds > cCurlMutiDefaulttimeout) {
-        timeout_milliseconds = cCurlMutiDefaulttimeout; /* libcurl doesn't know how long to wait, use a default timeout */
+      if (timeout_milliseconds < 0 || timeout_milliseconds > curb_multi_default_timeout()) {
+        timeout_milliseconds = curb_multi_default_timeout(); /* libcurl doesn't know how long to wait, use a default timeout */
                                                         /* or buggy versions libcurl sometimes reports huge timeouts... let's cap it */
       }
 
-#if defined(HAVE_CURL_MULTI_WAIT) && !defined(HAVE_RB_THREAD_FD_SELECT)
+#if defined(CURB_USE_MULTI_POLL)
+      {
+        struct multi_poll_args poll_args;
+        poll_args.handle     = rbcm->handle;
+        poll_args.timeout_ms = timeout_milliseconds > INT_MAX ? INT_MAX : (int)timeout_milliseconds;
+        poll_args.numfds     = 0;
+        poll_args.code       = CURLM_OK;
+        /*
+         * Wait with the GVL released. curl_multi_poll sleeps for the full
+         * timeout even when libcurl has no sockets to watch, so no separate
+         * idle sleep is needed. Pending interrupts are checked when
+         * rb_thread_call_without_gvl returns. Like rb_thread_fd_select, this
+         * wait does not consult the fiber scheduler; perform routes to the
+         * socket-action loop when a scheduler is active.
+         */
+        rb_thread_call_without_gvl(curb_multi_poll_without_gvl, &poll_args,
+                                   curb_multi_poll_ubf, rbcm->handle);
+        if (poll_args.code != CURLM_OK) {
+          raise_curl_multi_error_exception(poll_args.code);
+        }
+        rb_curl_multi_run(self, rbcm->handle, &(rbcm->running));
+        rb_curl_multi_read_info(self, rbcm->handle);
+        rb_curl_multi_yield_if_given(self, block);
+      }
+#elif defined(HAVE_CURL_MULTI_WAIT) && !defined(HAVE_RB_THREAD_FD_SELECT)
       {
         struct wait_args wait_args;
         wait_args.handle     = rbcm->handle;
@@ -2076,8 +2378,10 @@ static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
       }
 #else
 
-      tv.tv_sec  = 0; /* never wait longer than 1 second */
-      tv.tv_usec = (int)(timeout_milliseconds * 1000); /* XXX: int is the right type for OSX, what about linux? */
+      /* Split into seconds and microseconds: a raw select() rejects a
+       * tv_usec of 1000000 or more, which default_timeout > 1000 produced. */
+      tv.tv_sec  = timeout_milliseconds / 1000;
+      tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
 
       FD_ZERO(&fdread);
       FD_ZERO(&fdwrite);
@@ -2177,7 +2481,7 @@ static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
     rb_curl_multi_yield_if_given(self, block);
   } while( rbcm->running );
 
-  if (cCurlMutiAutoClose  == 1) {
+  if (curb_multi_autoclose_enabled()) {
     rbcm->allow_close_during_perform = 1;
     rb_funcall(self, rb_intern("_autoclose"), 0);
     rbcm->allow_close_during_perform = 0;
@@ -2244,6 +2548,19 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
   return ruby_curl_multi_with_perform_guard(argc, argv, self, ruby_curl_multi_perform_impl);
 }
 
+/*
+ * Name of the kernel event queue the socket-action loop waits on under a
+ * fiber scheduler ("epoll" or "kqueue"), or nil when this build has none.
+ */
+static VALUE ruby_curl_multi_socket_poller(VALUE klass) {
+  (void)klass;
+#ifdef CURB_SOCKET_POLLER
+  return rb_str_new_cstr(CURB_SOCKET_POLLER_NAME);
+#else
+  return Qnil;
+#endif
+}
+
 #if defined(HAVE_CURL_MULTI_SOCKET_ACTION) && defined(HAVE_CURLMOPT_SOCKETFUNCTION) && defined(HAVE_CURLMOPT_TIMERFUNCTION) && defined(HAVE_RB_THREAD_FD_SELECT) && !defined(_WIN32)
 VALUE ruby_curl_multi_socket_perform(int argc, VALUE *argv, VALUE self) {
   return ruby_curl_multi_with_perform_guard(argc, argv, self, ruby_curl_multi_socket_perform_impl);
@@ -2309,6 +2626,20 @@ void init_curb_multi() {
   idCall = rb_intern("call");
   cRubyFiber = rb_const_get(rb_cObject, rb_intern("Fiber"));
   rb_global_variable(&cRubyFiber);
+  cRubyRactor = Qnil;
+  id_ractor_current = rb_intern("current");
+  id_ractor_aref = rb_intern("[]");
+  id_ractor_aset = rb_intern("[]=");
+  id_ractor_default_timeout_key = rb_intern("__curb_multi_default_timeout");
+  id_ractor_autoclose_key = rb_intern("__curb_multi_autoclose");
+  if (rb_const_defined(rb_cObject, rb_intern("Ractor"))) {
+    VALUE ractor = rb_const_get(rb_cObject, rb_intern("Ractor"));
+    VALUE current = rb_funcall(ractor, id_ractor_current, 0);
+    if (rb_respond_to(current, id_ractor_aref) && rb_respond_to(current, id_ractor_aset)) {
+      cRubyRactor = ractor;
+    }
+  }
+  rb_global_variable(&cRubyRactor);
   id_fiber_blocking_p = rb_intern("blocking?");
   id_fiber_scheduler = rb_intern("scheduler");
   id_kernel_sleep = rb_intern("kernel_sleep");
@@ -2317,6 +2648,7 @@ void init_curb_multi() {
   id_deferred_exception_source_id_ivar = rb_intern("@__curb_deferred_exception_source_id");
   id_native_safety_signatures_ivar = rb_intern("@__curb_native_safety_signatures");
   id_socket_io_cache_ivar = rb_intern("@__curb_socket_io_cache");
+  id_socket_poller_io_ivar = rb_intern("@__curb_socket_poller_io");
   cCurlMulti = rb_define_class_under(mCurl, "Multi", rb_cObject);
 
   rb_define_alloc_func(cCurlMulti, ruby_curl_multi_alloc);
@@ -2343,6 +2675,7 @@ void init_curb_multi() {
 #if defined(HAVE_CURL_MULTI_SOCKET_ACTION) && defined(HAVE_CURLMOPT_SOCKETFUNCTION) && defined(HAVE_CURLMOPT_TIMERFUNCTION) && defined(HAVE_RB_THREAD_FD_SELECT) && !defined(_WIN32)
   rb_define_private_method(cCurlMulti, "_socket_perform", ruby_curl_multi_socket_perform, -1);
 #endif
+  rb_define_private_method(rb_singleton_class(cCurlMulti), "_socket_poller", ruby_curl_multi_socket_poller, 0);
   rb_define_method(cCurlMulti, "_close", ruby_curl_multi_close, 0);
   rb_define_private_method(cCurlMulti, "_mark_closed", ruby_curl_multi_mark_closed, 0);
 }