Change Primitive.thread_run_blocking_nfi_system_call to take an interop isExecutable object

* That way we avoid the overhead of the block, and profiling reports the
  properly named method, and not "block (2 levels) in POSIX.attach_function_eagerly".
* Let Ruby code do the loop for more flexibility and to simplify.

Author: eregon

lib/truffle/truffle/ffi_backend/function.rb

@@ -82,14 +82,9 @@ def call(*args, &block)
       end
 
       if blocking
-        result = Primitive.thread_run_blocking_nfi_system_call -> {
-          r = @function.call(*args)
-          if Integer === r and r == -1 and Errno.errno == Errno::EINTR::Errno
-            Truffle::UNDEFINED # retry
-          else
-            r
-          end
-        }
+        begin
+          result = Primitive.thread_run_blocking_nfi_system_call(@function, args)
+        end while Integer === result and result == -1 and Errno.errno == Errno::EINTR::Errno
       else
         result = @function.call(*args)
       end

src/main/java/org/truffleruby/core/thread/ThreadNodes.java

@@ -59,6 +59,7 @@
 import org.truffleruby.core.InterruptMode;
 import org.truffleruby.core.VMPrimitiveNodes.VMRaiseExceptionNode;
 import org.truffleruby.core.array.ArrayGuards;
+import org.truffleruby.core.array.ArrayToObjectArrayNode;
 import org.truffleruby.core.array.RubyArray;
 import org.truffleruby.core.array.library.ArrayStoreLibrary;
 import org.truffleruby.core.basicobject.RubyBasicObject;
@@ -104,7 +105,6 @@
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.object.Shape;
 import com.oracle.truffle.api.profiles.BranchProfile;
-import com.oracle.truffle.api.profiles.LoopConditionProfile;
 import com.oracle.truffle.api.source.SourceSection;
 
 @CoreModule(value = "Thread", isClass = true)
@@ -833,36 +833,30 @@ protected RubyBasicObject getFiberLocals(RubyThread thread) {
 
     /** Similar to {@link ThreadManager#runUntilResult(Node, ThreadManager.BlockingAction)} but purposed for blocking
      * native calls. If the {@link SafepointManager} needs to interrupt the thread, it will send a SIGVTALRM to abort
-     * the blocking syscall and the action will return NotProvided if the syscall fails with errno=EINTR, meaning it was
-     * interrupted. */
+     * the blocking syscall and the syscall will return -1 with errno=EINTR, meaning it was interrupted. */
     @Primitive(name = "thread_run_blocking_nfi_system_call")
     public static abstract class ThreadRunBlockingSystemCallNode extends PrimitiveArrayArgumentsNode {
 
         @Specialization
-        protected Object runBlockingSystemCall(RubyProc block,
-                @Cached("createCountingProfile()") LoopConditionProfile loopProfile,
-                @Cached YieldNode yieldNode) {
+        protected Object runBlockingSystemCall(Object executable, RubyArray argsArray,
+                @Cached GetCurrentRubyThreadNode getCurrentRubyThreadNode,
+                @CachedLibrary(limit = "1") InteropLibrary receivers,
+                @Cached ArrayToObjectArrayNode arrayToObjectArrayNode,
+                @Cached TranslateInteropExceptionNode translateInteropExceptionNode) {
+            final Object[] args = arrayToObjectArrayNode.executeToObjectArray(argsArray);
+            final RubyThread thread = getCurrentRubyThreadNode.execute();
+
             final ThreadManager threadManager = getContext().getThreadManager();
             final UnblockingAction unblockingAction = threadManager.getNativeCallUnblockingAction();
-            final RubyThread thread = threadManager.getCurrentThread();
             final UnblockingActionHolder actionHolder = threadManager.getActionHolder(Thread.currentThread());
 
             final UnblockingAction oldAction = actionHolder.changeTo(unblockingAction);
+            final ThreadStatus status = thread.status;
+            thread.status = ThreadStatus.SLEEP;
             try {
-                Object result;
-                do {
-                    final ThreadStatus status = thread.status;
-                    thread.status = ThreadStatus.SLEEP;
-
-                    try {
-                        result = yieldNode.executeDispatch(block);
-                    } finally {
-                        thread.status = status;
-                    }
-                } while (loopProfile.profile(result == NotProvided.INSTANCE));
-
-                return result;
+                return InteropNodes.execute(executable, args, receivers, translateInteropExceptionNode);
             } finally {
+                thread.status = status;
                 actionHolder.restore(oldAction);
             }
         }

src/main/ruby/truffleruby/core/posix.rb

@@ -139,14 +139,9 @@ def self.attach_function_eagerly(native_name, argument_types, return_type,
         end
 
         if blocking
-          result = Primitive.thread_run_blocking_nfi_system_call -> {
-            r = bound_func.call(*args)
-            if Integer === r and r == -1 and Errno.errno == EINTR
-              undefined # retry
-            else
-              r
-            end
-          }
+          begin
+            result = Primitive.thread_run_blocking_nfi_system_call(bound_func, args)
+          end while Integer === result and result == -1 and Errno.errno == EINTR
         else
           result = bound_func.call(*args)
         end
@@ -316,6 +311,7 @@ def self.unsetenv(name)
     attach_function :dup3, [:int, :int, :int], :int
   end
 
+  SELECT = method(:truffleposix_select)
 
   def self.with_array_of_ints(ints)
     if ints.empty?
@@ -514,5 +510,4 @@ class << self
       end
     end
   end
-
 end

src/main/ruby/truffleruby/core/truffle/io_operations.rb

@@ -145,12 +145,12 @@ def self.select(readables, readable_ios, writables, writable_ios, errorables, er
         to_fds(errorable_ios, errorables_pointer)
 
         begin
-          primitive_result = Primitive.thread_run_blocking_nfi_system_call -> do
-            Truffle::POSIX.truffleposix_select(readables.size, readables_pointer,
-                                               writables.size, writables_pointer,
-                                               errorables.size, errorables_pointer,
-                                               remaining_timeout)
-          end
+          primitive_result = Primitive.thread_run_blocking_nfi_system_call(Truffle::POSIX::SELECT, [
+              readables.size, readables_pointer,
+              writables.size, writables_pointer,
+              errorables.size, errorables_pointer,
+              remaining_timeout
+          ])
 
           result =
             if primitive_result < 0