mjit.c: add :wait option to RubyVM::MJIT.pause

and wait until JIT queue is flushed when wait option is not passed or
`wait: true` is passed.

vm.c: ditto

test/ruby/test_rubyvm_mjit.rb: added test for pause/resume

test/lib/jit_support.rb: allow retrying MJIT on JITSupport level
test/ruby/test_jit.rb: ditto

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@64250 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

mjit.c

@@ -1782,8 +1782,19 @@ stop_worker(void)
 
 /* Stop JIT-compiling methods but compiled code is kept available. */
 VALUE
-mjit_pause(void)
+mjit_pause(int argc, VALUE *argv, VALUE recv)
 {
+    VALUE options = Qnil;
+    VALUE wait = Qtrue;
+    rb_scan_args(argc, argv, "0:", &options);
+
+    if (!NIL_P(options)) {
+        static ID keyword_ids[1];
+        if (!keyword_ids[0])
+            keyword_ids[0] = rb_intern("wait");
+        rb_get_kwargs(options, keyword_ids, 0, 1, &wait);
+    }
+
     if (!mjit_enabled) {
         rb_raise(rb_eRuntimeError, "MJIT is not enabled");
     }
@@ -1791,6 +1802,20 @@ mjit_pause(void)
         return Qfalse;
     }
 
+    /* Flush all queued units with `wait: true` (default) */
+    if (RTEST(wait)) {
+        struct timeval tv;
+        tv.tv_sec = 0;
+        tv.tv_usec = 1000;
+
+        while (unit_queue.length > 0) {
+            CRITICAL_SECTION_START(3, "in mjit_pause for a worker wakeup");
+            rb_native_cond_broadcast(&mjit_worker_wakeup);
+            CRITICAL_SECTION_FINISH(3, "in mjit_pause for a worker wakeup");
+            rb_thread_wait_for(tv);
+        }
+    }
+
     stop_worker();
     return Qtrue;
 }

test/lib/jit_support.rb

@@ -14,7 +14,7 @@ module JITSupport
 
     # Very pessimistic check. With this check, we can't ensure JIT is working.
     begin
-      _, err = JITSupport.eval_with_jit('proc {}.call', verbose: 1, min_calls: 1, timeout: 10)
+      _, err = JITSupport.eval_with_jit_without_retry('proc {}.call', verbose: 1, min_calls: 1, timeout: 10)
     rescue Timeout::Error
       $stderr.puts "TestJIT: #jit_supported? check timed out"
       false
@@ -28,11 +28,25 @@ module JITSupport
   end
 
   module_function
-  def eval_with_jit(env = nil, script, verbose: 0, min_calls: 5, save_temps: false, max_cache: 1000, timeout: JIT_TIMEOUT)
+  # Run Ruby script with --jit-wait (Synchronous JIT compilation).
+  # Returns [stdout, stderr]
+  def eval_with_jit(env = nil, script, **opts)
+    stdout, stderr = nil, nil
+    # retry 3 times while cc1 error happens.
+    3.times do |i|
+      stdout, stderr, status = eval_with_jit_without_retry(env, script, **opts)
+      assert_equal(true, status.success?, "Failed to run script with JIT:\n#{code_block(script)}\nstdout:\n#{code_block(stdout)}\nstderr:\n#{code_block(stderr)}")
+      break unless retried_stderr?(stderr)
+    end
+    [stdout, stderr]
+  end
+
+  def eval_with_jit_without_retry(env = nil, script, verbose: 0, min_calls: 5, save_temps: false, max_cache: 1000, wait: true, timeout: JIT_TIMEOUT)
     args = [
-      '--disable-gems', '--jit-wait', "--jit-verbose=#{verbose}",
+      '--disable-gems', "--jit-verbose=#{verbose}",
       "--jit-min-calls=#{min_calls}", "--jit-max-cache=#{max_cache}",
     ]
+    args << '--jit-wait' if wait
     args << '--jit-save-temps' if save_temps
     args << '-e' << script
     base_env = { 'MJIT_SEARCH_BUILD_DIR' => 'true' } # workaround to skip requiring `make install` for `make test-all`
@@ -58,4 +72,14 @@ module JITSupport
       stderr
     end
   end
+
+  def code_block(code)
+    "```\n#{code}\n```\n\n"
+  end
+
+  # We're retrying cc1 not found error on gcc, which should be solved in the future but ignored for now.
+  def retried_stderr?(stderr)
+    RbConfig::CONFIG['CC'].start_with?('gcc') &&
+      stderr.include?("error trying to exec 'cc1': execvp: No such file or directory")
+  end
 end

test/ruby/test_jit.rb

@@ -873,27 +873,4 @@ class TestJIT < Test::Unit::TestCase
     end
     insns
   end
-
-  # Run Ruby script with --jit-wait (Synchronous JIT compilation).
-  # Returns [stdout, stderr]
-  def eval_with_jit(env = nil, script, **opts)
-    stdout, stderr = nil, nil
-    # retry 3 times while cc1 error happens.
-    3.times do |i|
-      stdout, stderr, status = super
-      assert_equal(true, status.success?, "Failed to run script with JIT:\n#{code_block(script)}\nstdout:\n#{code_block(stdout)}\nstderr:\n#{code_block(stderr)}")
-      break unless retried_stderr?(stderr)
-    end
-    [stdout, stderr]
-  end
-
-  # We're retrying cc1 not found error on gcc, which should be solved in the future but ignored for now.
-  def retried_stderr?(stderr)
-    RbConfig::CONFIG['CC'].start_with?('gcc') &&
-      stderr.include?("error trying to exec 'cc1': execvp: No such file or directory")
-  end
-
-  def code_block(code)
-    "```\n#{code}\n```\n\n"
-  end
 end

test/ruby/test_rubyvm_mjit.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+require 'test/unit'
+require_relative '../lib/jit_support'
+
+class TestRubyVMMJIT < Test::Unit::TestCase
+  include JITSupport
+
+  def test_pause
+    out, err = eval_with_jit(<<~'EOS', verbose: 1, min_calls: 1, wait: false)
+      i = 0
+      while i < 5
+        eval("def mjit#{i}; end; mjit#{i}")
+        i += 1
+      end
+      print RubyVM::MJIT.pause
+      print RubyVM::MJIT.pause
+      while i < 10
+        eval("def mjit#{i}; end; mjit#{i}")
+        i += 1
+      end
+      print RubyVM::MJIT.pause # no JIT here
+    EOS
+    assert_equal('truefalsefalse', out)
+    assert_equal(5, err.scan(/#{JITSupport::JIT_SUCCESS_PREFIX}/).size)
+  end
+
+  def test_pause_wait_false
+    out, err = eval_with_jit(<<~'EOS', verbose: 1, min_calls: 1, wait: false)
+      i = 0
+      while i < 10
+        eval("def mjit#{i}; end; mjit#{i}")
+        i += 1
+      end
+      print RubyVM::MJIT.pause(wait: false)
+      print RubyVM::MJIT.pause(wait: false)
+    EOS
+    assert_equal('truefalse', out)
+    assert_equal(true, err.scan(/#{JITSupport::JIT_SUCCESS_PREFIX}/).size < 10)
+  end
+
+  def test_resume
+    out, err = eval_with_jit(<<~'EOS', verbose: 1, min_calls: 1, wait: false)
+      print RubyVM::MJIT.resume
+      print RubyVM::MJIT.pause
+      print RubyVM::MJIT.resume
+      print RubyVM::MJIT.resume
+      print RubyVM::MJIT.pause
+    EOS
+    assert_equal('falsetruetruefalsetrue', out)
+    assert_equal(0, err.scan(/#{JITSupport::JIT_SUCCESS_PREFIX}/).size)
+  end
+end

vm.c

@@ -2770,7 +2770,7 @@ mjit_enabled_p(void)
     return mjit_enabled ? Qtrue : Qfalse;
 }
 
-extern VALUE mjit_pause(void);
+extern VALUE mjit_pause(int argc, VALUE *argv, VALUE recv);
 extern VALUE mjit_resume(void);
 
 extern VALUE *rb_gc_stack_start;
@@ -2861,7 +2861,7 @@ Init_VM(void)
     /* RubyVM::MJIT */
     mjit = rb_define_module_under(rb_cRubyVM, "MJIT");
     rb_define_singleton_method(mjit, "enabled?", mjit_enabled_p, 0);
-    rb_define_singleton_method(mjit, "pause", mjit_pause, 0);
+    rb_define_singleton_method(mjit, "pause", mjit_pause, -1);
     rb_define_singleton_method(mjit, "resume", mjit_resume, 0);
 
     /*