Public issue detail

Runaway CPU investigation for perl: busy poll at Perl_runops_standard

perl is stuck in a likely busy poll loop: 100.00% of sampled CPU passed through Perl_runops_standard, with repeated pselect6 x4.

highpackage: perl-basesource: perlscore: 106reports: 3patch attempt ready

Last seen: 2026-05-19 02:26 UTC. Public JSON: /v1/issues/019d4017-20f8-7752-9734-0bcd71623118

Pull-request-ready diff

This is the current best public patch attempt for the issue. The downloadable .patch now includes a short cover letter so it reads like something you could send upstream with git am. If you only want the raw diff, grab the .diff instead.

best patchcreated: 2026-05-11 17:44 UTCvalidation: ready

perl likely remains stuck in a busy-poll loop. A diagnosis report and patch proposal were created locally.

Suggested subject

pp_sselect: preserve tiny positive select timeouts

Commit message.

Perl's four-argument `select` converts a Perl timeout value to `struct timeval`, the seconds/microseconds structure passed to the platform `select` call. A strictly positive timeout below one microsecond was truncated to `0s, 0us`, making it behave like an explicit non-blocking poll. Preserve that distinction by rounding such tiny positive timeouts up to one microsecond.

Problem. perl is stuck in a likely busy poll loop: 100.00% of sampled CPU passed through Perl_runops_standard, with repeated pselect6 x4.

How this patch connects to the issue.

Fixer observed `/usr/bin/perl` using CPU with samples in `Perl_runops_standard` and repeated `pselect6`, consistent with a busy poll loop. That failure was observed by Fixer and not independently reproduced because the evidence bundle has no script entrypoint, command line, or full strace body.

The cautious runtime-side cause addressed here is in `pp_sselect`: a positive Perl timeout smaller than one microsecond was truncated to a zero `struct timeval`, so `PerlSock_select` received a zero-time poll. I changed the conversion to keep the original non-negative timeout and set `tv_usec` to `1` when truncation would otherwise erase a positive timeout. I also fixed the local `Time::HiRes` test guard and added a regression in `t/op/sselect.t`.

The expected effect is that tiny positive `select` timeouts no longer spin as immediate polls. The patch follows the existing subsystem helpers and conventions already in `pp_sselect`, including `SvGETMAGIC`, `SvNV_nomg`, `PerlSock_select`, `Zero`, `Newx`, `Safefree`, `SvSETMAGIC`, and `SvSetMagicSV`; no new platform or allocation API was introduced. The prior Fixer patch was improved by using a more realistic timing threshold for the one-microsecond minimum.

Files touched

pp_sys.c
t/op/sselect.t

Validation

Fixer marked this proposal `ready` on 2026-05-11 17:44 UTC.
The underlying issue cluster has 3 report(s) and was last seen 2026-05-19 02:26 UTC.
The published diff touches pp_sys.c, t/op/sselect.t.
Ran the project-level entrypoint: `./Configure -des -Dusedevel && make -j2 && make test_harness` `Configure` and `make -j2` completed, and `op/sselect.t` passed during the full harness. The full harness did not complete cleanly: it reported unrelated tree/environment failures in `porting/manifest.t` for files not in `MANIFEST`, and `porting/regen.t` reported missing `lib/.gitignore` plus generated files not up to date. Later the PTY became quiet in the CPAN test section with no matching `perl`/`make` child visible from a separate process check, so I interrupted it. Focused validation passed: `make test_harness TEST_FILES="op/sselect.t"` Result: `PASS`, 1 file, 24 tests. Bounded independent signal check: Before, installed Perl showed tiny positive timeouts spinning like zero-timeout polls: `zero_iters=1743270 tiny_iters=1735492`. After the patch, built Perl showed the tiny timeout no longer spinning at the same rate: `zero_iters=1677689 tiny_iters=4800`.

Download .patch Raw diff Browse successful patches

diff --git a/pp_sys.c b/pp_sys.c
index ed0ec79..000fb43 100644
--- a/pp_sys.c
+++ b/pp_sys.c
@@ -1356,6 +1356,7 @@ PP_wrapped(pp_sselect, 4, 0)
     char *s;
     SV *sv;
     NV value;
+    NV orig_timeout;
     I32 maxlen = 0;
     I32 nfound;
     struct timeval timebuf;
@@ -1439,12 +1440,15 @@ PP_wrapped(pp_sselect, 4, 0)
     sv = SP[4];
     SvGETMAGIC(sv);
     if (SvOK(sv)) {
-        value = SvNV_nomg(sv);
-        if (value < 0.0)
-            value = 0.0;
-        timebuf.tv_sec = (time_t)value;
-        value -= (NV)timebuf.tv_sec;
+        orig_timeout = SvNV_nomg(sv);
+        if (orig_timeout < 0.0)
+            orig_timeout = 0.0;
+        timebuf.tv_sec = (time_t)orig_timeout;
+        value = orig_timeout - (NV)timebuf.tv_sec;
         timebuf.tv_usec = (long)(value * 1000000.0);
+        /* Keep a positive Perl timeout from becoming a zero-time poll. */
+        if (orig_timeout > 0.0 && timebuf.tv_sec == 0 && timebuf.tv_usec == 0)
+            timebuf.tv_usec = 1;
     }
     else
         tbuf = NULL;
diff --git a/t/op/sselect.t b/t/op/sselect.t
index 32420cc..449fb2d 100644
--- a/t/op/sselect.t
+++ b/t/op/sselect.t
@@ -7,13 +7,13 @@ BEGIN {
     chdir 't' if -d 't';
     require './test.pl';
     set_up_inc('.', '../lib');
-    $hires = eval 'use Time::HiResx "time"; 1';
+    $hires = eval 'use Time::HiRes "time"; 1';
 }
 
 skip_all("Win32 miniperl has no socket select")
   if $^O eq "MSWin32" && is_miniperl();
 
-plan (23);
+plan (24);
 
 my $blank = "";
 eval {select undef, $blank, $blank, 0};
@@ -79,6 +79,27 @@ $diff = $t1-$t0;
 ok($diff >= $sleep-$under, "select(\$e,u,u,\$sleep): at least $sleep seconds have passed");
 note("diff=$diff under=$under");
 
+if ($hires) {
+    my $tiny = 0.0000005;
+    my $iters = 10_000;
+    my $min_extra = 0.002;
+
+    $t0 = time;
+    select undef, undef, undef, 0 for 1..$iters;
+    my $zero_time = time - $t0;
+
+    $t0 = time;
+    select undef, undef, undef, $tiny for 1..$iters;
+    my $tiny_time = time - $t0;
+
+    ok($tiny_time >= $zero_time + $min_extra,
+        "select(u,u,u,small positive timeout): not a non-blocking poll");
+    note("zero_time=$zero_time tiny_time=$tiny_time min_extra=$min_extra");
+}
+else {
+    skip("Need Time::HiRes for tiny-timeout behavior check", 1);
+}
+
 # [perl #120102] CORE::select ignoring timeout var's magic
 
 {

Technical snapshot

Fixer did not retain a representative backtrace for this issue, but it did retain the strongest public runtime signals that drove the diagnosis and patch attempt.

Observed runtime evidence

Why Fixer classified it this way: The trace repeatedly returns to a poll-family syscall without meaningful blocking, which suggests a busy event-loop wakeup.
Wait site: poll_schedule_timeout.constprop.0
Hot path: Perl_runops_standard (100.00% sampled CPU)
Repeated loop: pselect6 -> pselect6 -> pselect6
Top syscalls: pselect6 x4
Package: perl-base

Possible duplicates

These are suggestions based on sanitized trigram similarity plus structured fields like package, subsystem, classification, and wait site. They are not auto-merged.

Runaway CPU investigation for perl: busy poll at unresolved offset in perl

possible duplicate

perl is stuck in a likely busy poll loop: 100.00% of sampled CPU passed through unresolved offset, with repeated thread backtraces show 1 thread(s) around 0x00007f25577e97d2 in ?? () from target:<path>.

highpackage: perl-basesource: perlscore: 106reports: 2successful triagesimilarity: 99%

Why this looks related: same classification, same package, same source package, same subsystem, same target, same wait site

Last seen: 2026-05-16 03:22 UTC. Public page: /issues/019dc07f-d19d-7cd0-8771-a7f51e5fec2b. Public JSON: /v1/issues/019dc07f-d19d-7cd0-8771-a7f51e5fec2b

Runaway CPU investigation for python3.13: busy poll at read_tsc

possible duplicate

python3.13 is stuck in a likely busy poll loop: 50.00% of sampled CPU passed through read_tsc, with repeated thread backtraces show 1 thread(s) around 0x00007f1c6e7efe92 in pthread_attr_destroy () from target:<path>.

highpackage: python3.13-minimalsource: python3.13score: 106reports: 2similarity: 65%