cool.io 1.2.0 → 1.2.1

data/.travis.yml

@@ -1,4 +1,11 @@
+language: ruby
+
 rvm:
-  - 1.8.7
-  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
   - rbx
+
+matrix:
+  allow_failures:
+    - rvm: rbx

data/CHANGES.md

@@ -1,9 +1,16 @@
+1.2.1
+-----
+
+* Release the GIL when libev polls (#24)
+* Add Listener#listen method to change backlog size
+
 1.2.0
 -----
 
 * Support Windows environment via cross compilation
 * Include iobuffer library
 * Update to libev 4.15
+* Remove Ruby 1.8 support
 
 1.1.0
 -----

data/Gemfile

@@ -1,4 +1,4 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in cool.io.gemspec
 gemspec

data/ext/cool.io/loop.c

@@ -205,23 +205,12 @@ static VALUE Coolio_Loop_run_once(VALUE self)
   return nevents;
 }
 
-/* Ruby 1.9 supports blocking system calls through rb_thread_blocking_region() */
 #ifdef HAVE_RB_THREAD_BLOCKING_REGION
 #define HAVE_EV_LOOP_ONESHOT
-static VALUE Coolio_Loop_ev_loop_oneshot_blocking(void *ptr) 
-{
-  /* The libev loop has now escaped through the Global VM Lock unscathed! */
-  struct Coolio_Loop *loop_data = (struct Coolio_Loop *)ptr;
-
-  RUN_LOOP(loop_data, EVLOOP_ONESHOT);
-  
-  return Qnil;
-}
 
 static void Coolio_Loop_ev_loop_oneshot(struct Coolio_Loop *loop_data)
 {
-  /* Use Ruby 1.9's rb_thread_blocking_region call to make a blocking system call */
-  rb_thread_blocking_region(Coolio_Loop_ev_loop_oneshot_blocking, loop_data, RUBY_UBF_IO, 0);
+  RUN_LOOP(loop_data, EVLOOP_ONESHOT);
 }
 #endif
 

data/ext/libev/ev.c

@@ -37,6 +37,10 @@
  * either the BSD or the GPL.
  */
 
+/* ########## COOLIO PATCHERY HO! ########## */
+#include "ruby.h"
+/* ######################################## */
+
 /* this big block deduces configuration from config.h */
 #ifndef EV_STANDALONE
 # ifdef EV_CONFIG_H
@@ -3237,9 +3241,27 @@ time_update (EV_P_ ev_tstamp max_block)
     }
 }
 
+/* ########## COOLIO PATCHERY HO! ########## */
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+static
+VALUE ev_backend_poll(void **args)
+{
+  struct ev_loop *loop = (struct ev_loop *)args[0];
+  ev_tstamp waittime = *(ev_tstamp *)args[1];
+  backend_poll (EV_A_ waittime);
+}
+#endif
+/* ######################################## */
+
 int
 ev_run (EV_P_ int flags)
 {
+/* ########## COOLIO PATCHERY HO! ########## */
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+    void *poll_args[2];
+#endif
+/* ######################################## */
+
 #if EV_FEATURE_API
   ++loop_depth;
 #endif
@@ -3357,7 +3379,53 @@ ev_run (EV_P_ int flags)
         ++loop_count;
 #endif
         assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */
+
+/*
+########################## COOLIO PATCHERY HO! ##########################
+
+The original patch file is made by Tony Arcieri.
+https://github.com/celluloid/nio4r/blob/680143345726c5a64bb22376ca8fc3c6857019ae/ext/libev/ruby_gil.patch.
+
+According to the grandwizards of Ruby, locking and unlocking of the global
+interpreter lock are apparently too powerful a concept for a mere mortal to
+wield (although redefining what + and - do to numbers is totally cool).
+And so it came to pass that the only acceptable way to release the global
+interpreter lock is through a convoluted callback system that thakes a
+function pointer. While the grandwizard of libev foresaw this sort of scenario,
+he too attempted to place an API with callbacks on it, one that runs before
+the system call, and one that runs immediately after.
+
+And so it came to pass that trying to wrap everything up in callbacks created
+two incompatible APIs, Ruby's which releases the global interpreter lock and
+reacquires it when the callback returns, and libev's, which wants two
+callbacks, one which runs before the polling operation starts, and one which
+runs after it finishes.
+
+These two systems are incompatible as they both want to use callbacks to
+solve the same problem, however libev wants to use before/after callbacks,
+and Ruby wants to use an "around" callback. This presents a significant
+problem as these two patterns of callbacks are diametrical opposites of each
+other and thus cannot be composed.
+
+And thus we are left with no choice but to patch the internals of libev in
+order to release a mutex at just the precise moment.
+
+Let this be a lesson to the all: CALLBACKS FUCKING BLOW
+
+#######################################################################
+*/
+
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+        poll_args[0] = (void *)loop;
+        poll_args[1] = (void *)&waittime;
+        rb_thread_blocking_region(ev_backend_poll, (void *)&poll_args, RUBY_UBF_IO, 0);
+#else
         backend_poll (EV_A_ waittime);
+#endif
+/*
+############################# END PATCHERY ############################
+*/
+
         assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */
 
         pipe_write_wanted = 0; /* just an optimisation, no fence needed */

data/ext/libev/ruby_gil.patch

@@ -0,0 +1,97 @@
+diff --git a/ext/libev/ev.c b/ext/libev/ev.c
+index e5bd5ab..10f6ff2 100644
+--- a/ext/libev/ev.c
++++ b/ext/libev/ev.c
+@@ -37,6 +37,10 @@
+  * either the BSD or the GPL.
+  */
+ 
++/* ########## COOLIO PATCHERY HO! ########## */
++#include "ruby.h"
++/* ######################################## */
++
+ /* this big block deduces configuration from config.h */
+ #ifndef EV_STANDALONE
+ # ifdef EV_CONFIG_H
+@@ -3237,9 +3241,27 @@ time_update (EV_P_ ev_tstamp max_block)
+     }
+ }
+ 
++/* ########## COOLIO PATCHERY HO! ########## */
++#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
++static
++VALUE ev_backend_poll(void **args)
++{
++  struct ev_loop *loop = (struct ev_loop *)args[0];
++  ev_tstamp waittime = *(ev_tstamp *)args[1];
++  backend_poll (EV_A_ waittime);
++}
++#endif
++/* ######################################## */
++
+ int
+ ev_run (EV_P_ int flags)
+ {
++/* ########## COOLIO PATCHERY HO! ########## */
++#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
++    void *poll_args[2];
++#endif
++/* ######################################## */
++
+ #if EV_FEATURE_API
+   ++loop_depth;
+ #endif
+@@ -3357,7 +3379,53 @@ ev_run (EV_P_ int flags)
+         ++loop_count;
+ #endif
+         assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */
++
++/*
++########################## COOLIO PATCHERY HO! ##########################
++
++The original patch file is made by Tony Arcieri.
++https://github.com/celluloid/nio4r/blob/680143345726c5a64bb22376ca8fc3c6857019ae/ext/libev/ruby_gil.patch.
++
++According to the grandwizards of Ruby, locking and unlocking of the global
++interpreter lock are apparently too powerful a concept for a mere mortal to
++wield (although redefining what + and - do to numbers is totally cool).
++And so it came to pass that the only acceptable way to release the global
++interpreter lock is through a convoluted callback system that thakes a
++function pointer. While the grandwizard of libev foresaw this sort of scenario,
++he too attempted to place an API with callbacks on it, one that runs before
++the system call, and one that runs immediately after.
++
++And so it came to pass that trying to wrap everything up in callbacks created
++two incompatible APIs, Ruby's which releases the global interpreter lock and
++reacquires it when the callback returns, and libev's, which wants two
++callbacks, one which runs before the polling operation starts, and one which
++runs after it finishes.
++
++These two systems are incompatible as they both want to use callbacks to
++solve the same problem, however libev wants to use before/after callbacks,
++and Ruby wants to use an "around" callback. This presents a significant
++problem as these two patterns of callbacks are diametrical opposites of each
++other and thus cannot be composed.
++
++And thus we are left with no choice but to patch the internals of libev in
++order to release a mutex at just the precise moment.
++
++Let this be a lesson to the all: CALLBACKS FUCKING BLOW
++
++#######################################################################
++*/
++
++#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
++        poll_args[0] = (void *)loop;
++        poll_args[1] = (void *)&waittime;
++        rb_thread_blocking_region(ev_backend_poll, (void *)&poll_args, RUBY_UBF_IO, 0);
++#else
+         backend_poll (EV_A_ waittime);
++#endif
++/*
++############################# END PATCHERY ############################
++*/
++
+         assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */
+ 
+         pipe_write_wanted = 0; /* just an optimisation, no fence needed */

data/lib/cool.io/listener.rb

@@ -21,6 +21,10 @@ module Coolio
       @listen_socket.fileno
     end
 
+    def listen(backlog)
+      @listen_socket.listen(backlog)
+    end
+
     # Close the listener
     def close
       detach if attached?
@@ -53,9 +57,9 @@ module Coolio
     end
   end
 
-  class TCPListener < Listener
-    DEFAULT_BACKLOG = 1024
+  DEFAULT_BACKLOG = 1024
 
+  class TCPListener < Listener
     # Create a new Coolio::TCPListener on the specified address and port.
     # Accepts the following options:
     #
@@ -87,7 +91,9 @@ module Coolio
     # Optionally, it can also take anyn existing UNIXServer object
     # and create a Coolio::UNIXListener out of it.
     def initialize(*args)
-      super(::UNIXServer === args.first ? args.first : ::UNIXServer.new(*args))
+      s = ::UNIXServer === args.first ? args.first : ::UNIXServer.new(*args)
+      s.instance_eval { listen(DEFAULT_BACKLOG) }
+      super(s)
     end
   end
 end

data/lib/cool.io/server.rb

@@ -56,7 +56,7 @@ module Coolio
         raise ArgumentError, "port must be an integer" if nil == port
         ::TCPServer.new(host, port)
       end
-      listen_socket.instance_eval { listen(1024) } # Change listen backlog to 1024
+      listen_socket.instance_eval { listen(DEFAULT_BACKLOG) } # Change listen backlog to 1024
       super(listen_socket, klass, *args, &block)
     end
   end
@@ -68,6 +68,7 @@ module Coolio
   class UNIXServer < Server
     def initialize(path, klass = UNIXSocket, *args, &block)
       s = ::UNIXServer === path ? path : ::UNIXServer.new(path)
+      s.instance_eval { listen(DEFAULT_BACKLOG) }
       super(s, klass, *args, &block)
     end
   end

data/lib/cool.io/version.rb

@@ -1,5 +1,5 @@
 module Coolio
-  VERSION = "1.2.0"
+  VERSION = "1.2.1"
   
   def self.version; VERSION; end
 end

data/spec/unix_server_spec.rb

@@ -11,13 +11,15 @@ describe Cool.io::UNIXServer, :env => :win do
 
   it "creates a new Cool.io::UNIXServer" do
     listener = Cool.io::UNIXListener.new(@tmp.path)
+    listener.listen(24)
     File.socket?(@tmp.path).should == true
   end
 
   it "builds off an existing ::UNIXServer" do
     unix_server = ::UNIXServer.new(@tmp.path)
     File.socket?(@tmp.path).should == true
-    listener = Cool.io::UNIXServer.new(unix_server)
+    listener = Cool.io::UNIXServer.new(unix_server, Coolio::UNIXSocket)
+    listener.listen(24)
     File.socket?(@tmp.path).should == true
     listener.fileno.should == unix_server.fileno
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cool.io
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-27 00:00:00.000000000 Z
+date: 2014-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -124,6 +124,7 @@ files:
 - ext/libev/ev_vars.h
 - ext/libev/ev_win32.c
 - ext/libev/ev_wrap.h
+- ext/libev/ruby_gil.patch
 - ext/libev/test_libev_win32.c
 - lib/.gitignore
 - lib/cool.io.rb
@@ -164,7 +165,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3111666693494633054
+      hash: 2606014626052723115
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -173,7 +174,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3111666693494633054
+      hash: 2606014626052723115
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23