Avoid re-polling for events when printing error

Dynamically printing error output to the configured stderr stream
may trigger additional thread interrupt polls, wiping out any
thread interrupt currently being reported or propagated. This
patch avoids such polls by writing directly to the underlying IO
without using Ruby logic if and only if it is the original (boot)
stderr stream.

This also removes a second poll that happens when exiting the
blocking task for a raise, a side effect of using afterBlockingCall
to set the new status. The status update happens again after this
point, and the poll is spurious.

Fixes jruby#8479

core/src/main/java/org/jruby/Ruby.java

@@ -172,10 +172,15 @@
 import java.io.InputStream;
 import java.io.PrintStream;
 import java.io.PrintWriter;
+import java.io.Writer;
 import java.lang.invoke.MethodHandle;
 import java.lang.ref.WeakReference;
 import java.net.BindException;
+import java.nio.ByteBuffer;
+import java.nio.channels.Channels;
+import java.nio.channels.WritableByteChannel;
 import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.nio.charset.UnsupportedCharsetException;
 import java.security.SecureRandom;
 import java.util.ArrayList;
@@ -2848,6 +2853,25 @@ WarnCallback getRegexpWarnings() {
         return regexpWarnings;
     }
 
+    public IRubyObject getStderr() {
+        return getGlobalVariables().get("$stderr");
+    }
+
+    /**
+     * Return the original stderr with which this runtime was initialized.
+     *
+     * Used for fast-path comparisons when printing error info directly to stderr.
+     *
+     * @return the original stderr with which this runtime was initialized
+     */
+    public IRubyObject getOriginalStderr() {
+        return originalStderr;
+    }
+
+    void setOriginalStderr(IRubyObject stderr) {
+        this.originalStderr = stderr;
+    }
+
     public PrintStream getErrorStream() {
         // FIXME: We can't guarantee this will always be a RubyIO...so the old code here is not safe
         /*java.io.OutputStream os = ((RubyIO) getGlobalVariables().getService("$stderr")).getOutStream();
@@ -2916,36 +2940,41 @@ private static boolean isJavaPackageOrJavaClassProxyType(final RubyModule type)
         return type instanceof JavaPackage || ClassUtils.isJavaClassProxyType(type);
     }
 
-    /** Prints an error with backtrace to the error stream.
+    /**
+     * Prints a Ruby exception with backtrace to the configured stderr stream.
      *
      * MRI: eval.c - error_print()
      *
      */
     public void printError(final RubyException ex) {
         if (ex == null) return;
 
-        PrintStream errorStream = getErrorStream();
-        String backtrace = config.getTraceType().printBacktrace(ex, (errorStream == System.err) && getPosix().isatty(FileDescriptor.err));
-        try {
-            errorStream.print(backtrace);
-        } catch (Exception e) {
-            System.err.print(backtrace);
-        }
+        boolean formatted =
+                getStderr() == getOriginalStderr() &&
+                        getErr() == System.err &&
+                        getPosix().isatty(FileDescriptor.err);
+
+        String backtrace = config.getTraceType().printBacktrace(ex, formatted);
+        printErrorString(backtrace);
     }
 
+    /**
+     * Prints an exception to System.err.
+     *
+     * @param ex
+     */
     public void printError(final Throwable ex) {
         if (ex instanceof RaiseException) {
             printError(((RaiseException) ex).getException());
             return;
         }
 
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
-        PrintStream errorStream = getErrorStream();
 
         ex.printStackTrace(new PrintStream(baos));
 
         try {
-            errorStream.write(baos.toByteArray());
+            printErrorString(baos.toByteArray());
         } catch (Exception e) {
             try {
                 System.err.write(baos.toByteArray());
@@ -2956,6 +2985,50 @@ public void printError(final Throwable ex) {
         }
     }
 
+    /**
+     * Prints a string directly to the stderr channel, if default, or via dynamic dispatch otherwise.
+     *
+     * @param msg the string to print
+     */
+    public void printErrorString(String msg) {
+        IRubyObject stderr = getStderr();
+
+        WritableByteChannel writeChannel;
+        if (stderr == getOriginalStderr() &&
+                (writeChannel = ((RubyIO) stderr).getOpenFile().fd().chWrite) != null) {
+            Writer writer = Channels.newWriter(writeChannel, "UTF-8");
+            try {
+                writer.write(msg);
+                writer.flush();
+            } catch (IOException ioe) {
+                // ignore as in CRuby
+            }
+        } else {
+            getErrorStream().print(msg);
+        }
+    }
+
+    /**
+     * Prints a string directly to the stderr channel, if default, or via dynamic dispatch otherwise.
+     *
+     * @param msg the string to print
+     */
+    public void printErrorString(byte[] msg) {
+        IRubyObject stderr = getGlobalVariables().get("$stderr");
+
+        try {
+            WritableByteChannel writeChannel;
+            if (stderr == getOriginalStderr() &&
+                    (writeChannel = ((RubyIO) stderr).getOpenFile().fd().chWrite) != null) {
+                    writeChannel.write(ByteBuffer.wrap(msg));
+            } else {
+                getErrorStream().write(msg);
+            }
+        } catch (IOException ioe) {
+            // ignore as in CRuby
+        }
+    }
+
     static final String ROOT_FRAME_NAME = "(root)";
     static long yarpTime = 0;
     static boolean loaded = false;
@@ -5724,6 +5797,8 @@ public void warn(String message) {
     private final EnumMap<DefinedMessage, RubyString> definedMessages = new EnumMap<>(DefinedMessage.class);
     private final EnumMap<RubyThread.Status, RubyString> threadStatuses = new EnumMap<>(RubyThread.Status.class);
 
+    private IRubyObject originalStderr;
+
     public interface ObjectSpacer {
         void addToObjectSpace(Ruby runtime, boolean useObjectSpace, IRubyObject object);
     }

core/src/main/java/org/jruby/RubyGlobal.java

@@ -311,6 +311,8 @@ public static void initSTDIO(Ruby runtime, GlobalVariables globals) {
             runtime.defineGlobalConstant("STDIN", stdin);
             runtime.defineGlobalConstant("STDOUT", stdout);
             runtime.defineGlobalConstant("STDERR", stderr);
+
+            runtime.setOriginalStderr(stderr);
         } else {
             ((RubyIO) runtime.getObject().getConstant("STDIN")).getOpenFile().setFD(stdin.getOpenFile().fd());
             ((RubyIO) runtime.getObject().getConstant("STDOUT")).getOpenFile().setFD(stdout.getOpenFile().fd());

core/src/main/java/org/jruby/RubyThread.java

@@ -34,13 +34,17 @@
 package org.jruby;
 
 import java.io.IOException;
+import java.io.Writer;
 import java.lang.management.ManagementFactory;
 import java.lang.ref.WeakReference;
 import java.nio.ByteBuffer;
 import java.nio.channels.Channel;
+import java.nio.channels.Channels;
 import java.nio.channels.SelectableChannel;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.Selector;
+import java.nio.channels.WritableByteChannel;
+import java.nio.charset.StandardCharsets;
 import java.util.Iterator;
 import java.util.Objects;
 import java.util.Queue;
@@ -275,7 +279,6 @@ private void executeInterrupts(ThreadContext context, boolean blockingTiming) {
                         ((RubyFixnum) err).getLongValue() == 2)) {
                     toKill();
                 } else {
-                    afterBlockingCall();
                     if (getStatus() == Status.SLEEP) {
                         exitSleep();
                     }
@@ -2071,7 +2074,9 @@ public void exceptionRaised(RaiseException exception) {
     protected void printReportExceptionWarning() {
         Ruby runtime = getRuntime();
         String name = threadImpl.getReportName();
-        runtime.getErrorStream().println("warning: thread \"" + name + "\" terminated with exception (report_on_exception is true):");
+        String warning = "warning: thread \"" + name + "\" terminated with exception (report_on_exception is true):";
+
+        runtime.printErrorString(warning);
     }
 
     /**