Fix silent hang restoring CPU turbo at exit

The at_exit turbo/boost restore ran 'sudo -S' with stderr routed to /dev/null, so on long runs (past sudo's credential cache) it blocked waiting for a password whose prompt was invisible -- indistinguishable from a hang, and it left turbo disabled.

Keep the sudo timestamp warm with a background 'sudo -n -v' thread, and make the restore use 'sudo -n' so it fails fast and prints the manual command instead of blocking. Applies to both Intel and AMD.

Author: eightbitraptor

lib/cpu_config.rb

@@ -52,6 +52,24 @@ def maximize_frequency
   def check_pstate(turbo:)
     # Override in subclasses
   end
+
+  def keep_sudo_alive
+    @sudo_keepalive ||= Thread.new { sudo_keepalive_loop }
+  end
+
+  def sudo_keepalive_loop
+    loop do
+      sleep 50 # comfortably under sudo's default timestamp_timeout (15 min)
+      break unless system("sudo", "-n", "-v", out: File::NULL, err: File::NULL)
+    end
+  end
+
+  def sudo_restore(manual_hint, shell_cmd)
+    return if system("sudo", "-n", "sh", "-c", shell_cmd, err: File::NULL)
+
+    warn "\nCould not restore CPU setting automatically (sudo credentials expired)."
+    warn "Run this manually:\n  #{manual_hint}"
+  end
 end
 
 # Intel CPU configuration
@@ -67,7 +85,9 @@ class IntelCPUConfig < CPUConfig
   def disable_turbo_boost
     # sudo requires the flag '-S' in order to take input from stdin
     BenchmarkRunner.check_call("sudo -S sh -c 'echo #{TURBO_DISABLED_VALUE} > #{NO_TURBO_PATH}'")
-    at_exit { BenchmarkRunner.check_call("sudo -S sh -c 'echo 0 > #{NO_TURBO_PATH}'", quiet: true) }
+    keep_sudo_alive
+    restore = "sudo sh -c 'echo 0 > #{NO_TURBO_PATH}'"
+    at_exit { sudo_restore(restore, "echo 0 > #{NO_TURBO_PATH}") }
   end
 
   def maximize_frequency
@@ -114,7 +134,9 @@ class AMDCPUConfig < CPUConfig
   def disable_turbo_boost
     # sudo requires the flag '-S' in order to take input from stdin
     BenchmarkRunner.check_call("sudo -S sh -c 'echo #{TURBO_DISABLED_VALUE} > #{BOOST_PATH}'")
-    at_exit { BenchmarkRunner.check_call("sudo -S sh -c 'echo #{TURBO_ENABLED_VALUE} > #{BOOST_PATH}'", quiet: true) }
+    keep_sudo_alive
+    restore = "sudo sh -c 'echo #{TURBO_ENABLED_VALUE} > #{BOOST_PATH}'"
+    at_exit { sudo_restore(restore, "echo #{TURBO_ENABLED_VALUE} > #{BOOST_PATH}") }
   end
 
   def maximize_frequency

test/cpu_config_test.rb

@@ -121,6 +121,7 @@
       at_exit_block = nil
       exit_called = false
       read_count = 0
+      cpu_config = nil
 
       File.stub :exist?, ->(path) { path.include?('intel_pstate') } do
         cpu_config = IntelCPUConfig.new
@@ -140,7 +141,9 @@
                 end
               } do
                 capture_io do
-                  cpu_config.configure_for_benchmarking(turbo: false)
+                  cpu_config.stub :keep_sudo_alive, -> {} do
+                    cpu_config.configure_for_benchmarking(turbo: false)
+                  end
                 end
                 assert_operator call_count, :>, 0, "Should call check_call to configure Intel CPU"
                 assert at_exit_called, "Should register at_exit handler to restore CPU settings"
@@ -152,15 +155,14 @@
         end
       end
 
-      # Verify at_exit block restores Intel turbo settings
-      cleanup_commands = []
-      BenchmarkRunner.stub :check_call, ->(cmd, **opts) { cleanup_commands << { cmd: cmd, opts: opts } } do
+      # Verify at_exit block restores Intel turbo settings non-interactively.
+      # `sudo -n` is what prevents the silent hang when credentials have lapsed.
+      restore_args = nil
+      cpu_config.stub :system, ->(*args, **_opts) { restore_args = args; true } do
         at_exit_block.call
       end
 
-      assert_equal 1, cleanup_commands.length, "at_exit block should call check_call once"
-      assert_equal "sudo -S sh -c 'echo 0 > /sys/devices/system/cpu/intel_pstate/no_turbo'", cleanup_commands[0][:cmd]
-      assert_equal({ quiet: true }, cleanup_commands[0][:opts])
+      assert_equal ["sudo", "-n", "sh", "-c", "echo 0 > /sys/devices/system/cpu/intel_pstate/no_turbo"], restore_args
     end
 
     it 'exits when Intel turbo is not disabled and turbo flag is false' do
@@ -261,6 +263,7 @@
       at_exit_block = nil
       exit_called = false
       read_count = 0
+      cpu_config = nil
 
       File.stub :exist?, ->(path) { path.include?('cpufreq/boost') } do
         cpu_config = AMDCPUConfig.new
@@ -278,7 +281,9 @@
               } do
                 Dir.stub :glob, ->(pattern) { ['/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor'] } do
                   capture_io do
-                    cpu_config.configure_for_benchmarking(turbo: false)
+                    cpu_config.stub :keep_sudo_alive, -> {} do
+                      cpu_config.configure_for_benchmarking(turbo: false)
+                    end
                   end
                   assert_operator call_count, :>, 0, "Should call check_call to configure AMD CPU"
                   assert at_exit_called, "Should register at_exit handler to restore CPU settings"
@@ -291,15 +296,13 @@
         end
       end
 
-      # Verify at_exit block restores AMD boost settings
-      cleanup_commands = []
-      BenchmarkRunner.stub :check_call, ->(cmd, **opts) { cleanup_commands << { cmd: cmd, opts: opts } } do
+      # Verify at_exit block restores AMD boost settings non-interactively.
+      restore_args = nil
+      cpu_config.stub :system, ->(*args, **_opts) { restore_args = args; true } do
         at_exit_block.call
       end
 
-      assert_equal 1, cleanup_commands.length, "at_exit block should call check_call once"
-      assert_equal "sudo -S sh -c 'echo 1 > /sys/devices/system/cpu/cpufreq/boost'", cleanup_commands[0][:cmd]
-      assert_equal({ quiet: true }, cleanup_commands[0][:opts])
+      assert_equal ["sudo", "-n", "sh", "-c", "echo 1 > /sys/devices/system/cpu/cpufreq/boost"], restore_args
     end
 
     it 'exits when AMD boost is not disabled and turbo flag is false' do
@@ -363,3 +366,59 @@
     end
   end
 end
+
+describe 'sudo credential handling' do
+  # The helpers under test live on the base CPUConfig; any concrete subclass
+  # exercises them. These guard against the silent at_exit hang where a lapsed
+  # sudo timestamp left the turbo-restore command blocking on an invisible
+  # password prompt (stderr was suppressed).
+  def config
+    IntelCPUConfig.new
+  end
+
+  describe '#sudo_restore' do
+    it 'restores non-interactively with sudo -n and stays silent on success' do
+      cfg = config
+      captured = nil
+      fake_system = ->(*args, **_opts) { captured = args; true }
+
+      _out, err = capture_io do
+        cfg.stub :system, fake_system do
+          cfg.send(:sudo_restore, "sudo sh -c 'echo 0 > /no_turbo'", "echo 0 > /no_turbo")
+        end
+      end
+
+      assert_equal ["sudo", "-n", "sh", "-c", "echo 0 > /no_turbo"], captured
+      assert_empty err
+    end
+
+    it 'prints the manual command instead of hanging when credentials lapsed' do
+      cfg = config
+
+      _out, err = capture_io do
+        cfg.stub :system, false do
+          cfg.send(:sudo_restore, "sudo sh -c 'echo 0 > /no_turbo'", "echo 0 > /no_turbo")
+        end
+      end
+
+      assert_match(/credentials expired/, err)
+      assert_match(%r{sudo sh -c 'echo 0 > /no_turbo'}, err)
+    end
+  end
+
+  describe '#keep_sudo_alive' do
+    it 'starts at most one keepalive thread and memoizes it' do
+      cfg = config
+      started = 0
+      fake_thread = Object.new
+
+      Thread.stub :new, ->(*_args, &_blk) { started += 1; fake_thread } do
+        cfg.send(:keep_sudo_alive)
+        cfg.send(:keep_sudo_alive)
+      end
+
+      assert_equal 1, started
+      assert_same fake_thread, cfg.instance_variable_get(:@sudo_keepalive)
+    end
+  end
+end