Release C extension mutex when waiting for fds.

PullRequest: truffleruby/746

Author: aardvark179

lib/truffle/truffle/cext.rb

@@ -1037,7 +1037,7 @@ def rb_path_to_class(path)
   def rb_proc_new(function, value)
     Proc.new do |*args|
       Truffle::CExt.rb_tr_unwrap(
-        Truffle.invoke_primitive(:interop_call_c_with_mutex, function, args.map! { |arg| Truffle::CExt.rb_tr_wrap(arg) }))
+        Truffle.invoke_primitive(:call_with_c_mutex, function, args.map! { |arg| Truffle::CExt.rb_tr_wrap(arg) }))
     end
   end
 
@@ -1092,11 +1092,11 @@ def rb_jump_tag(pos)
   end
 
   def rb_yield(value)
-    Truffle.invoke_primitive(:interop_call_c_with_mutex, rb_block_proc, [value])
+    Truffle.invoke_primitive(:call_with_c_mutex, rb_block_proc, [value])
   end
 
   def rb_yield_splat(values)
-    Truffle.invoke_primitive(:interop_call_c_with_mutex, rb_block_proc, values)
+    Truffle.invoke_primitive(:call_with_c_mutex, rb_block_proc, values)
   end
 
   def rb_ivar_lookup(object, name, default_value)
@@ -1248,7 +1248,7 @@ def rb_enumeratorize(obj, meth, args)
 
   def rb_enumeratorize_with_size(obj, meth, args, size_fn)
     return rb_enumeratorize(obj, meth, args) if size_fn.nil?
-    enum = obj.to_enum(meth, *args) { rb_tr_unwrap(Truffle.invoke_primitive(:interop_call_c_with_mutex, size_fn, [rb_tr_wrap(obj), rb_tr_wrap(args), rb_tr_wrap(enum)])) }
+    enum = obj.to_enum(meth, *args) { rb_tr_unwrap(Truffle.invoke_primitive(:call_with_c_mutex, size_fn, [rb_tr_wrap(obj), rb_tr_wrap(args), rb_tr_wrap(enum)])) }
     enum
   end
 
@@ -1258,7 +1258,7 @@ def rb_eval_string(str)
 
   def rb_define_alloc_func(ruby_class, function)
     ruby_class.singleton_class.send(:define_method, :__allocate__) do
-      Truffle::CExt.rb_tr_unwrap(Truffle.invoke_primitive(:interop_call_c_with_mutex, function, [Truffle::CExt.rb_tr_wrap(self)]))
+      Truffle::CExt.rb_tr_unwrap(Truffle.invoke_primitive(:call_with_c_mutex, function, [Truffle::CExt.rb_tr_wrap(self)]))
     end
     class << ruby_class
       private :__allocate__
@@ -1376,7 +1376,7 @@ def rb_mutex_sleep(mutex, timeout)
 
   def rb_mutex_synchronize(mutex, func, arg)
     mutex.synchronize do
-      rb_tr_unwrap(Truffle.invoke_primitive(:interop_call_c_with_mutex, func, [rb_tr_wrap(arg)]))
+      rb_tr_unwrap(Truffle.invoke_primitive(:call_with_c_mutex, func, [rb_tr_wrap(arg)]))
     end
   end
 
@@ -1438,23 +1438,23 @@ def rb_data_typed_object_wrap(ruby_class, data, data_type, mark, free, size)
   def data_finalizer(free, data_holder)
     raise unless free.respond_to?(:call)
     proc {
-      Truffle.invoke_primitive(:interop_call_c_with_mutex, free, [data_holder.data]) unless data_holder.data.nil?
+      Truffle.invoke_primitive(:call_with_c_mutex, free, [data_holder.data]) unless data_holder.data.nil?
     }
   end
 
   def data_marker(mark, data_holder)
     raise unless mark.respond_to?(:call)
     proc { |obj|
       create_mark_list
-      Truffle.invoke_primitive(:interop_call_c_with_mutex, mark, [data_holder.data]) unless data_holder.data.nil?
+      Truffle.invoke_primitive(:call_with_c_mutex, mark, [data_holder.data]) unless data_holder.data.nil?
       set_mark_list_on_object(obj)
     }
   end
 
   def data_sizer(sizer, data_holder)
     raise unless sizer.respond_to?(:call)
     proc {
-      Truffle.invoke_primitive(:interop_call_c_with_mutex, sizer, [data_holder.data])
+      Truffle.invoke_primitive(:call_with_c_mutex, sizer, [data_holder.data])
     }
   end
 
@@ -1488,51 +1488,51 @@ def send_splatted(object, method, args)
 
   def rb_block_call(object, method, args, func, data)
     object.__send__(method, *args) do |*block_args|
-      rb_tr_unwrap(Truffle.invoke_primitive(:interop_call_c_with_mutex, func, [rb_tr_wrap(block_args.first), data, block_args.size, RARRAY_PTR(block_args), nil]))
+      rb_tr_unwrap(Truffle.invoke_primitive(:call_with_c_mutex, func, [rb_tr_wrap(block_args.first), data, block_args.size, RARRAY_PTR(block_args), nil]))
     end
   end
 
   def rb_ensure(b_proc, data1, e_proc, data2)
     begin
-      rb_tr_unwrap(Truffle.invoke_primitive(:interop_call_c_with_mutex, b_proc, [data1]))
+      rb_tr_unwrap(Truffle.invoke_primitive(:call_with_c_mutex, b_proc, [data1]))
     ensure
-      rb_tr_unwrap(Truffle.invoke_primitive(:interop_call_c_with_mutex, e_proc, [data2]))
+      rb_tr_unwrap(Truffle.invoke_primitive(:call_with_c_mutex, e_proc, [data2]))
     end
   end
 
   def rb_rescue(b_proc, data1, r_proc, data2)
     begin
-      Truffle.invoke_primitive(:interop_call_c_with_mutex, b_proc, [data1])
+      Truffle.invoke_primitive(:call_with_c_mutex, b_proc, [data1])
     rescue StandardError => e
-      Truffle.invoke_primitive(:interop_call_c_with_mutex, r_proc, [data2, rb_tr_wrap(e)])
+      Truffle.invoke_primitive(:call_with_c_mutex, r_proc, [data2, rb_tr_wrap(e)])
     end
   end
 
   def rb_rescue2(b_proc, data1, r_proc, data2, rescued)
     begin
-      Truffle.invoke_primitive(:interop_call_c_with_mutex, b_proc, [data1])
+      Truffle.invoke_primitive(:call_with_c_mutex, b_proc, [data1])
     rescue *rescued => e
-      Truffle.invoke_primitive(:interop_call_c_with_mutex, r_proc, [data2, rb_tr_wrap(e)])
+      Truffle.invoke_primitive(:call_with_c_mutex, r_proc, [data2, rb_tr_wrap(e)])
     end
   end
 
   def rb_exec_recursive(func, obj, arg)
     result = nil
 
     recursive = Thread.detect_recursion(obj) do
-      result = rb_tr_unwrap(Truffle.invoke_primitive(:interop_call_c_with_mutex, func, [rb_tr_wrap(obj), rb_tr_wrap(arg), 0]))
+      result = rb_tr_unwrap(Truffle.invoke_primitive(:call_with_c_mutex, func, [rb_tr_wrap(obj), rb_tr_wrap(arg), 0]))
     end
 
     if recursive
-      rb_tr_unwrap(Truffle.invoke_primitive(:interop_call_c_with_mutex, func, [rb_tr_wrap(obj), rb_tr_wrap(arg), 1]))
+      rb_tr_unwrap(Truffle.invoke_primitive(:call_with_c_mutex, func, [rb_tr_wrap(obj), rb_tr_wrap(arg), 1]))
     else
       result
     end
   end
 
   def rb_catch_obj(tag, func, data)
     catch tag do |caught|
-      rb_tr_unwrap(Truffle.invoke_primitive(:interop_call_c_with_mutex, func, [rb_tr_wrap(caught), rb_tr_wrap(data), rb_tr_wrap(nil)]))
+      rb_tr_unwrap(Truffle.invoke_primitive(:call_with_c_mutex, func, [rb_tr_wrap(caught), rb_tr_wrap(data), rb_tr_wrap(nil)]))
     end
   end
 
@@ -1602,12 +1602,12 @@ def rb_time_interval_acceptable(time_val)
 
   def rb_thread_create(fn, args)
     Thread.new do
-      Truffle.invoke_primitive(:interop_call_c_with_mutex, fn, [args])
+      Truffle.invoke_primitive(:call_with_c_mutex, fn, [args])
     end
   end
 
   def rb_thread_call_with_gvl(function, data)
-    Truffle.invoke_primitive(:interop_call_c_with_mutex, function, [data])
+    Truffle.invoke_primitive(:call_with_c_mutex, function, [data])
   end
 
   def rb_thread_call_without_gvl(function, data1, unblock, data2)
@@ -1618,7 +1618,7 @@ def rb_thread_call_without_gvl(function, data1, unblock, data2)
     end
 
     runner = -> {
-      Truffle.invoke_primitive(:interop_call_c_without_mutex, function, [data1])
+      Truffle.invoke_primitive(:call_without_c_mutex, function, [data1])
     }
 
     Thread.current.unblock unblocker, runner
@@ -1632,22 +1632,22 @@ def rb_iterate(iteration, iterated_object, callback, callback_arg)
       end
     else
       call_with_thread_locally_stored_block iteration, iterated_object do |block_arg|
-        rb_tr_unwrap Truffle.invoke_primitive(:interop_call_c_with_mutex, callback, [rb_tr_wrap(block_arg), rb_tr_wrap(callback_arg), rb_tr_wrap(nil)])
+        rb_tr_unwrap Truffle.invoke_primitive(:call_with_c_mutex, callback, [rb_tr_wrap(block_arg), rb_tr_wrap(callback_arg), rb_tr_wrap(nil)])
       end
     end
   end
 
   def rb_thread_wait_fd(fd)
     io = IO.for_fd(fd)
     io.autoclose = false
-    IO.select([io])
+    Truffle.invoke_primitive(:call_without_c_mutex, IO.method(:select), [[io]])
     nil
   end
 
   def rb_thread_fd_writable(fd)
     io = IO.for_fd(fd)
     io.autoclose = false
-    _r, w, _e = IO.select(nil, [io])
+    _r, w, _e = Truffle.invoke_primitive(:call_without_c_mutex, IO.method(:select), [nil, [io]])
     w.size
   end
 
@@ -1666,7 +1666,7 @@ def rb_wait_for_single_fd(fd, events, tv_secs, tv_usecs)
     if tv_secs > 0 || tv_usecs > 0
       timeout = tv_secs + tv_usecs/1.0e6
     end
-    r, w, e = IO.select(read, write, error, *timeout)
+    r, w, e = Truffle.invoke_primitive(:call_without_c_mutex, IO.method(:select), [read, write, error, *timeout])
     if r.nil? # timeout
       0
     else
@@ -1738,11 +1738,11 @@ def rb_define_hooked_variable(name, gvar, getter, setter)
     id = name.to_sym
 
     getter_proc = -> {
-      rb_tr_unwrap Truffle.invoke_primitive(:interop_call_c_with_mutex, getter, [rb_tr_wrap(id), gvar, rb_tr_wrap(nil)])
+      rb_tr_unwrap Truffle.invoke_primitive(:call_with_c_mutex, getter, [rb_tr_wrap(id), gvar, rb_tr_wrap(nil)])
     }
 
     setter_proc = -> value {
-      Truffle.invoke_primitive(:interop_call_c_with_mutex, setter, [rb_tr_wrap(value), rb_tr_wrap(id), gvar, rb_tr_wrap(nil)])
+      Truffle.invoke_primitive(:call_with_c_mutex, setter, [rb_tr_wrap(value), rb_tr_wrap(id), gvar, rb_tr_wrap(nil)])
     }
 
     Truffle::KernelOperations.define_hooked_variable id, getter_proc, setter_proc

lib/truffle/truffle/cext_ruby.rb

@@ -36,9 +36,9 @@ def rb_define_method(mod, name, function, argc)
         # here so that the `rb_block_*` functions will be able to find
         # it by walking the stack.
         if block
-          Truffle::CExt.rb_tr_unwrap(Truffle.invoke_primitive(:interop_call_c_with_mutex, function, args, &block))
+          Truffle::CExt.rb_tr_unwrap(Truffle.invoke_primitive(:call_with_c_mutex, function, args, &block))
         else
-          Truffle::CExt.rb_tr_unwrap(Truffle.invoke_primitive(:interop_call_c_with_mutex, function, args))
+          Truffle::CExt.rb_tr_unwrap(Truffle.invoke_primitive(:call_with_c_mutex, function, args))
         end
       ensure
         Truffle::CExt.pop_preserving_frame
@@ -51,7 +51,7 @@ def rb_define_method(mod, name, function, argc)
   private
 
   def rb_iterate_call_block(callback, block_arg, callback_arg, &block)
-    rb_tr_unwrap(Truffle.invoke_primitive(:interop_call_c_with_mutex, callback, [rb_tr_wrap(block_arg), rb_tr_wrap(callback_arg)]))
+    rb_tr_unwrap(Truffle.invoke_primitive(:call_with_c_mutex, callback, [rb_tr_wrap(block_arg), rb_tr_wrap(callback_arg)]))
   end
 
   def call_with_thread_locally_stored_block(function, *args, &block)
@@ -61,7 +61,7 @@ def call_with_thread_locally_stored_block(function, *args, &block)
     previous_block = Thread.current[:__C_BLOCK__]
     begin
       Thread.current[:__C_BLOCK__] = block
-      rb_tr_unwrap(Truffle.invoke_primitive(:interop_call_c_with_mutex, function, args.map! { |arg| Truffle::CExt.rb_tr_wrap(arg) }, &block))
+      rb_tr_unwrap(Truffle.invoke_primitive(:call_with_c_mutex, function, args.map! { |arg| Truffle::CExt.rb_tr_wrap(arg) }, &block))
     ensure
       Thread.current[:__C_BLOCK__] = previous_block
     end

src/main/java/org/truffleruby/cext/CExtNodes.java

@@ -114,7 +114,7 @@
 public class CExtNodes {
 
     @ImportStatic(Message.class)
-    @Primitive(name = "interop_call_c_with_mutex")
+    @Primitive(name = "call_with_c_mutex")
     public abstract static class CallCWithMutexNode extends PrimitiveArrayArgumentsNode {
 
         @Specialization
@@ -157,7 +157,7 @@ private Object execute(TruffleObject receiver, Object[] args, Node executeNode,
     }
 
     @ImportStatic(Message.class)
-    @Primitive(name = "interop_call_c_without_mutex")
+    @Primitive(name = "call_without_c_mutex")
     public abstract static class CallCWithoutMutexNode extends PrimitiveArrayArgumentsNode {
 
         @Specialization