fix deprecation warning: migrate rb_thread_blocking_region to rb_thread_call_without_gvl

Author: tadd

ext/mysql2/client.c

@@ -57,7 +57,7 @@ static VALUE rb_hash_dup(VALUE other) {
 
 /*
  * used to pass all arguments to mysql_real_connect while inside
- * rb_thread_blocking_region
+ * rb_thread_call_without_gvl
  */
 struct nogvl_connect_args {
   MYSQL *mysql;
@@ -72,7 +72,7 @@ struct nogvl_connect_args {
 
 /*
  * used to pass all arguments to mysql_send_query while inside
- * rb_thread_blocking_region
+ * rb_thread_call_without_gvl
  */
 struct nogvl_send_query_args {
   MYSQL *mysql;
@@ -84,7 +84,7 @@ struct nogvl_send_query_args {
 
 /*
  * used to pass all arguments to mysql_select_db while inside
- * rb_thread_blocking_region
+ * rb_thread_call_without_gvl
  */
 struct nogvl_select_db_args {
   MYSQL *mysql;
@@ -144,15 +144,15 @@ static VALUE rb_raise_mysql2_error(mysql_client_wrapper *wrapper) {
   return Qnil;
 }
 
-static VALUE nogvl_init(void *ptr) {
+static void *nogvl_init(void *ptr) {
   MYSQL *client;
 
   /* may initialize embedded server and read /etc/services off disk */
   client = mysql_init((MYSQL *)ptr);
-  return client ? Qtrue : Qfalse;
+  return (void*)(client ? Qtrue : Qfalse);
 }
 
-static VALUE nogvl_connect(void *ptr) {
+static void *nogvl_connect(void *ptr) {
   struct nogvl_connect_args *args = ptr;
   MYSQL *client;
 
@@ -161,10 +161,10 @@ static VALUE nogvl_connect(void *ptr) {
                               args->db, args->port, args->unix_socket,
                               args->client_flag);
 
-  return client ? Qtrue : Qfalse;
+  return (void *)(client ? Qtrue : Qfalse);
 }
 
-static VALUE nogvl_close(void *ptr) {
+static void *nogvl_close(void *ptr) {
   mysql_client_wrapper *wrapper;
 #ifndef _WIN32
   int flags;
@@ -191,7 +191,7 @@ static VALUE nogvl_close(void *ptr) {
     mysql_close(wrapper->client);
   }
 
-  return Qnil;
+  return NULL;
 }
 
 static void rb_mysql_client_free(void *ptr) {
@@ -293,11 +293,11 @@ static VALUE rb_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE po
   args.mysql = wrapper->client;
   args.client_flag = NUM2ULONG(flags);
 
-  rv = rb_thread_blocking_region(nogvl_connect, &args, RUBY_UBF_IO, 0);
+  rv = (VALUE) rb_thread_call_without_gvl(nogvl_connect, &args, RUBY_UBF_IO, 0);
   if (rv == Qfalse) {
     while (rv == Qfalse && errno == EINTR && !mysql_errno(wrapper->client)) {
       errno = 0;
-      rv = rb_thread_blocking_region(nogvl_connect, &args, RUBY_UBF_IO, 0);
+      rv = (VALUE) rb_thread_call_without_gvl(nogvl_connect, &args, RUBY_UBF_IO, 0);
     }
     if (rv == Qfalse)
       return rb_raise_mysql2_error(wrapper);
@@ -317,7 +317,7 @@ static VALUE rb_mysql_client_close(VALUE self) {
   GET_CLIENT(self);
 
   if (wrapper->connected) {
-    rb_thread_blocking_region(nogvl_close, wrapper, RUBY_UBF_IO, 0);
+    rb_thread_call_without_gvl(nogvl_close, wrapper, RUBY_UBF_IO, 0);
   }
 
   return Qnil;
@@ -328,19 +328,19 @@ static VALUE rb_mysql_client_close(VALUE self) {
  * enough to fit in a socket buffer, but sometimes large UPDATE and
  * INSERTs will cause the process to block
  */
-static VALUE nogvl_send_query(void *ptr) {
+static void *nogvl_send_query(void *ptr) {
   struct nogvl_send_query_args *args = ptr;
   int rv;
 
   rv = mysql_send_query(args->mysql, args->sql_ptr, args->sql_len);
 
-  return rv == 0 ? Qtrue : Qfalse;
+  return (void*)(rv == 0 ? Qtrue : Qfalse);
 }
 
 static VALUE do_send_query(void *args) {
   struct nogvl_send_query_args *query_args = args;
   mysql_client_wrapper *wrapper = query_args->wrapper;
-  if (rb_thread_blocking_region(nogvl_send_query, args, RUBY_UBF_IO, 0) == Qfalse) {
+  if ((VALUE)rb_thread_call_without_gvl(nogvl_send_query, args, RUBY_UBF_IO, 0) == Qfalse) {
     /* an error occurred, we're not active anymore */
     MARK_CONN_INACTIVE(self);
     return rb_raise_mysql2_error(wrapper);
@@ -353,14 +353,14 @@ static VALUE do_send_query(void *args) {
  * response can overflow the socket buffers and cause us to eventually
  * block while calling mysql_read_query_result
  */
-static VALUE nogvl_read_query_result(void *ptr) {
+static void *nogvl_read_query_result(void *ptr) {
   MYSQL * client = ptr;
   my_bool res = mysql_read_query_result(client);
 
-  return res == 0 ? Qtrue : Qfalse;
+  return (void *)(res == 0 ? Qtrue : Qfalse);
 }
 
-static VALUE nogvl_do_result(void *ptr, char use_result) {
+static void *nogvl_do_result(void *ptr, char use_result) {
   mysql_client_wrapper *wrapper;
   MYSQL_RES *result;
 
@@ -375,15 +375,15 @@ static VALUE nogvl_do_result(void *ptr, char use_result) {
      ready for another command to be issued */
   wrapper->active_thread = Qnil;
 
-  return (VALUE)result;
+  return result;
 }
 
 /* mysql_store_result may (unlikely) read rows off the socket */
-static VALUE nogvl_store_result(void *ptr) {
+static void *nogvl_store_result(void *ptr) {
   return nogvl_do_result(ptr, 0);
 }
 
-static VALUE nogvl_use_result(void *ptr) {
+static void *nogvl_use_result(void *ptr) {
   return nogvl_do_result(ptr, 1);
 }
 
@@ -403,17 +403,17 @@ static VALUE rb_mysql_client_async_result(VALUE self) {
     return Qnil;
 
   REQUIRE_CONNECTED(wrapper);
-  if (rb_thread_blocking_region(nogvl_read_query_result, wrapper->client, RUBY_UBF_IO, 0) == Qfalse) {
+  if ((VALUE)rb_thread_call_without_gvl(nogvl_read_query_result, wrapper->client, RUBY_UBF_IO, 0) == Qfalse) {
     /* an error occurred, mark this connection inactive */
     MARK_CONN_INACTIVE(self);
     return rb_raise_mysql2_error(wrapper);
   }
 
   is_streaming = rb_hash_aref(rb_iv_get(self, "@current_query_options"), sym_stream);
   if(is_streaming == Qtrue) {
-    result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_use_result, wrapper, RUBY_UBF_IO, 0);
+    result = (MYSQL_RES *)rb_thread_call_without_gvl(nogvl_use_result, wrapper, RUBY_UBF_IO, 0);
   } else {
-    result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
+    result = (MYSQL_RES *)rb_thread_call_without_gvl(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
   }
 
   if (result == NULL) {
@@ -512,7 +512,7 @@ static VALUE finish_and_mark_inactive(void *args) {
     /* if we got here, the result hasn't been read off the wire yet
        so lets do that and then throw it away because we have no way
        of getting it back up to the caller from here */
-    result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
+    result = (MYSQL_RES *)rb_thread_call_without_gvl(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
     mysql_free_result(result);
 
     wrapper->active_thread = Qnil;
@@ -542,7 +542,7 @@ static VALUE rb_mysql_client_abandon_results(VALUE self) {
       rb_raise_mysql2_error(wrapper);
     }
 
-    result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
+    result = (MYSQL_RES *)rb_thread_call_without_gvl(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
 
     if (result != NULL) {
       mysql_free_result(result);
@@ -866,13 +866,13 @@ static VALUE rb_mysql_client_thread_id(VALUE self) {
   return ULL2NUM(retVal);
 }
 
-static VALUE nogvl_select_db(void *ptr) {
+static void *nogvl_select_db(void *ptr) {
   struct nogvl_select_db_args *args = ptr;
 
   if (mysql_select_db(args->mysql, args->db) == 0)
-    return Qtrue;
+    return (void *)Qtrue;
   else
-    return Qfalse;
+    return (void *)Qfalse;
 }
 
 /* call-seq:
@@ -891,16 +891,16 @@ static VALUE rb_mysql_client_select_db(VALUE self, VALUE db)
   args.mysql = wrapper->client;
   args.db = StringValuePtr(db);
 
-  if (rb_thread_blocking_region(nogvl_select_db, &args, RUBY_UBF_IO, 0) == Qfalse)
+  if (rb_thread_call_without_gvl(nogvl_select_db, &args, RUBY_UBF_IO, 0) == Qfalse)
     rb_raise_mysql2_error(wrapper);
 
   return db;
 }
 
-static VALUE nogvl_ping(void *ptr) {
+static void *nogvl_ping(void *ptr) {
   MYSQL *client = ptr;
 
-  return mysql_ping(client) == 0 ? Qtrue : Qfalse;
+  return (void *)(mysql_ping(client) == 0 ? Qtrue : Qfalse);
 }
 
 /* call-seq:
@@ -917,7 +917,7 @@ static VALUE rb_mysql_client_ping(VALUE self) {
   if (!wrapper->connected) {
     return Qfalse;
   } else {
-    return rb_thread_blocking_region(nogvl_ping, wrapper->client, RUBY_UBF_IO, 0);
+    return (VALUE)rb_thread_call_without_gvl(nogvl_ping, wrapper->client, RUBY_UBF_IO, 0);
   }
 }
 
@@ -969,7 +969,7 @@ static VALUE rb_mysql_client_store_result(VALUE self)
   VALUE current;
   GET_CLIENT(self);
 
-  result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
+  result = (MYSQL_RES *)rb_thread_call_without_gvl(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
 
   if (result == NULL) {
     if (mysql_errno(wrapper->client) != 0) {
@@ -1101,7 +1101,7 @@ static VALUE set_secure_auth(VALUE self, VALUE value) {
 static VALUE initialize_ext(VALUE self) {
   GET_CLIENT(self);
 
-  if (rb_thread_blocking_region(nogvl_init, wrapper->client, RUBY_UBF_IO, 0) == Qfalse) {
+  if ((VALUE)rb_thread_call_without_gvl(nogvl_init, wrapper->client, RUBY_UBF_IO, 0) == Qfalse) {
     /* TODO: warning - not enough memory? */
     return rb_raise_mysql2_error(wrapper);
   }

ext/mysql2/client.h

@@ -1,24 +1,30 @@
 #ifndef MYSQL2_CLIENT_H
 #define MYSQL2_CLIENT_H
 
+#ifndef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+
+/* emulate rb_thread_call_without_gvl with rb_thread_blocking_region */
+#define rb_thread_call_without_gvl(func, data1, ubf, data2) \
+  rb_thread_blocking_region((rb_blocking_function_t *)func, data1, ubf, data2)
+
+#else /* ! HAVE_RB_THREAD_BLOCKING_REGION */
 /*
- * partial emulation of the 1.9 rb_thread_blocking_region under 1.8,
+ * partial emulation of the 2.0 rb_thread_call_without_gvl under 1.8,
  * this is enough for dealing with blocking I/O functions in the
  * presence of threads.
  */
-#ifndef HAVE_RB_THREAD_BLOCKING_REGION
 
 #include <rubysig.h>
 #define RUBY_UBF_IO ((rb_unblock_function_t *)-1)
 typedef void rb_unblock_function_t(void *);
-typedef VALUE rb_blocking_function_t(void *);
-static VALUE
-rb_thread_blocking_region(
-  rb_blocking_function_t *func, void *data1,
+static void *
+rb_thread_call_without_gvl(
+  void *(*func), void *data1,
   RB_MYSQL_UNUSED rb_unblock_function_t *ubf,
   RB_MYSQL_UNUSED void *data2)
 {
-  VALUE rv;
+  void *rv;
 
   TRAP_BEG;
   rv = func(data1);
@@ -28,6 +34,7 @@ rb_thread_blocking_region(
 }
 
 #endif /* ! HAVE_RB_THREAD_BLOCKING_REGION */
+#endif /* ! HAVE_RB_THREAD_CALL_WITHOUT_GVL */
 
 void init_mysql2_client();
 

ext/mysql2/extconf.rb

@@ -5,6 +5,9 @@ def asplode lib
   abort "-----\n#{lib} is missing.  please check your installation of mysql and try again.\n-----"
 end
 
+# 2.0-only
+have_header('ruby/thread.h') && have_func('rb_thread_call_without_gvl', 'ruby/thread.h')
+
 # 1.9-only
 have_func('rb_thread_blocking_region')
 have_func('rb_wait_for_single_fd')

ext/mysql2/mysql2_ext.h

@@ -29,6 +29,9 @@ typedef unsigned int    uint;
 #ifdef HAVE_RUBY_ENCODING_H
 #include <ruby/encoding.h>
 #endif
+#ifdef HAVE_RUBY_THREAD_H
+#include <ruby/thread.h>
+#endif
 
 #if defined(__GNUC__) && (__GNUC__ >= 3)
 #define RB_MYSQL_UNUSED __attribute__ ((unused))

ext/mysql2/result.c

@@ -99,10 +99,10 @@ static void rb_mysql_result_free(void *ptr) {
  * reliable way for us to tell this so we'll always release the GVL
  * to be safe
  */
-static VALUE nogvl_fetch_row(void *ptr) {
+static void *nogvl_fetch_row(void *ptr) {
   MYSQL_RES *result = ptr;
 
-  return (VALUE)mysql_fetch_row(result);
+  return mysql_fetch_row(result);
 }
 
 static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, short int symbolize_keys) {
@@ -203,7 +203,7 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
 #endif
 
   ptr = wrapper->result;
-  row = (MYSQL_ROW)rb_thread_blocking_region(nogvl_fetch_row, ptr, RUBY_UBF_IO, 0);
+  row = (MYSQL_ROW)rb_thread_call_without_gvl(nogvl_fetch_row, ptr, RUBY_UBF_IO, 0);
   if (row == NULL) {
     return Qnil;
   }