Issue #4538 has been updated by Charles Nutter.


Understood. I read through a bit more code and saw that Ruby uses pthread signalling and RUBY_VM_CHECK_INTS after blocking regions to interrupt blocking operations.

I wonder, though, if depending on this behavior is leading Ruby more and more down the GVL path. The designers of the JVM's core IO libraries, for example, were unable to reconcile concurrent native threads with interruptible IO, due to the impossibility of knowing what state all IO-related data structures are in when the thread is interrupted. As a result, IO channels performing blocking operations are explicitly closed when the thread they block is interrupted.

In JRuby, we simulate interruptible IO by using select as much as possible, and blocking operations against unselectable IO channels are not interruptible. Some of the overhead of select is mitigated by JVM implementers usually using the fastest-possible mechanism to implement it (kqueue, epoll).

It seems that your change (and others like it) makes Ruby even more dependent on kernel-level blocking IO operations always being safely interruptible, and depending on those interruptions to only occur at the exact boundaries defined by the GVL. A future concurrent-threaded Ruby (or other impls that may become concurrent-threaded) may want to consider this, no? And are there any cross-platform concerns from eliminating select in these cases?

I also wonder if there's a race condition here; is it not possible that the interrupt of a thread would fire immediately after the GVL has been released but before the blocking IO operation has fired? Perhaps I'm birdwalking too deep into the vagaries of MRI's IO logic.
----------------------------------------
Feature #4538: [PATCH (cleanup)] avoid unnecessary select() calls before doing I/O
http://redmine.ruby-lang.org/issues/4538

Author: Eric Wong
Status: Open
Priority: Low
Assignee: 
Category: core
Target version: 1.9.x


Please look at http://redmine.ruby-lang.org/issues/4535 before
this one.  That one actually fixes a bug I noticed while working
on this patch.

Ruby 1.9 no longer depends on multiplexed non-blocking I/O
to do its threading and defaults to blocking file descriptors.

As a result, there is no need to check the fd for read/writability when
there is an error check for rb_io_wait_(read|writ)able after the
blocking function.

I also believe the code in io_binwrite() to:
    avoid context switch between "a" and "\n" in STDERR.puts "a".
    [ruby-dev:25080]
...has always been broken under 1.9 with native threads.

Nothing new is broken with test-all and test-rubyspec



-- 
http://redmine.ruby-lang.org