Bug#20333037: MOVE CURRENT MUTEX/COND FROM THREAD LOCAL STORAGE TO THD

Move current_mutex, current_cond and mutex fields from TLS to THD.

This reduces thread local storage usage and is a step towards
removing the requirement of calling my_thread_init() and
my_thread_end().

Author: jhauglid

include/my_sys.h

@@ -220,8 +220,25 @@ extern void (*local_message_hook)(enum loglevel ll,
 extern uint my_file_limit;
 extern ulong my_thread_stack_size;
 
-extern void (*proc_info_hook)(void *, const PSI_stage_info *, PSI_stage_info *,
-                              const char *, const char *, const unsigned int);
+/*
+  Hooks for reporting execution stage information. The server implementation
+  of these will also set THD::current_cond/current_mutex.
+  By having hooks, we avoid direct dependencies on server code.
+*/
+extern void (*enter_cond_hook)(void *opaque_thd,
+                               mysql_cond_t *cond,
+                               mysql_mutex_t *mutex,
+                               const PSI_stage_info *stage,
+                               PSI_stage_info *old_stage,
+                               const char *src_function,
+                               const char *src_file,
+                               int src_line);
+
+extern void (*exit_cond_hook)(void *opaque_thd,
+                              const PSI_stage_info *stage,
+                              const char *src_function,
+                              const char *src_file,
+                              int src_line);
 
 /* charsets */
 #define MY_ALL_CHARSETS_SIZE 2048

include/my_thread_local.h

@@ -79,9 +79,6 @@ struct st_my_thread_var
   int thr_winerr;
 #endif
   mysql_cond_t suspend;
-  mysql_mutex_t mutex;
-  mysql_mutex_t * volatile current_mutex;
-  mysql_cond_t * volatile current_cond;
   my_thread_id id;
   int volatile abort;
   struct st_my_thread_var *next,**prev;

mysys/my_init.c

@@ -444,7 +444,7 @@ PSI_stage_info stage_waiting_for_table_level_lock=
 
 PSI_mutex_key key_BITMAP_mutex, key_IO_CACHE_append_buffer_lock,
   key_IO_CACHE_SHARE_mutex, key_KEY_CACHE_cache_lock,
-  key_my_thread_var_mutex, key_THR_LOCK_charset, key_THR_LOCK_heap,
+  key_THR_LOCK_charset, key_THR_LOCK_heap,
   key_THR_LOCK_lock, key_THR_LOCK_malloc,
   key_THR_LOCK_mutex, key_THR_LOCK_myisam, key_THR_LOCK_net,
   key_THR_LOCK_open, key_THR_LOCK_threads,
@@ -456,7 +456,6 @@ static PSI_mutex_info all_mysys_mutexes[]=
   { &key_IO_CACHE_append_buffer_lock, "IO_CACHE::append_buffer_lock", 0},
   { &key_IO_CACHE_SHARE_mutex, "IO_CACHE::SHARE_mutex", 0},
   { &key_KEY_CACHE_cache_lock, "KEY_CACHE::cache_lock", 0},
-  { &key_my_thread_var_mutex, "my_thread_var::mutex", 0},
   { &key_THR_LOCK_charset, "THR_LOCK_charset", PSI_FLAG_GLOBAL},
   { &key_THR_LOCK_heap, "THR_LOCK_heap", PSI_FLAG_GLOBAL},
   { &key_THR_LOCK_lock, "THR_LOCK_lock", PSI_FLAG_GLOBAL},

mysys/my_static.c

@@ -1,4 +1,4 @@
-/* Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -89,19 +89,34 @@ void (*fatal_error_handler_hook)(uint error, const char *str, myf MyFlags)=
 void (*local_message_hook)(enum loglevel ll, const char *format, va_list args)=
   my_message_local_stderr;
 
-static void proc_info_dummy(void *a __attribute__((unused)),
+static void enter_cond_dummy(void *a __attribute__((unused)),
+                             mysql_cond_t *b __attribute__((unused)),
+                             mysql_mutex_t *c __attribute__((unused)),
+                             const PSI_stage_info *d __attribute__((unused)),
+                             PSI_stage_info *e __attribute__((unused)),
+                             const char *f __attribute__((unused)),
+                             const char *g __attribute__((unused)),
+                             int h __attribute__((unused)))
+{ };
+
+static void exid_cond_dummy(void *a __attribute__((unused)),
                             const PSI_stage_info *b __attribute__((unused)),
-                            PSI_stage_info *c __attribute__((unused)),
+                            const char *c __attribute__((unused)),
                             const char *d __attribute__((unused)),
-                            const char *e __attribute__((unused)),
-                            const unsigned int f __attribute__((unused)))
-{
-  return;
-}
-
-/* this is to be able to call set_thd_proc_info from the C code */
-void (*proc_info_hook)(void *, const PSI_stage_info *, PSI_stage_info *,
-                       const char *, const char *, const unsigned int)= proc_info_dummy;
+                            int e __attribute__((unused)))
+{ };
+
+/*
+  Initialize these hooks to dummy implementations. The real server
+  implementations will be set during server startup by
+  init_server_components().
+*/
+void (*enter_cond_hook)(void *, mysql_cond_t *, mysql_mutex_t *,
+                        const PSI_stage_info *, PSI_stage_info *,
+                        const char *, const char *, int)= enter_cond_dummy;
+
+void (*exit_cond_hook)(void *, const PSI_stage_info *,
+                       const char *, const char *, int)= exid_cond_dummy;
 
 #if defined(ENABLED_DEBUG_SYNC)
 /**

mysys/my_thr_init.c

@@ -94,9 +94,6 @@ void my_thread_global_reinit()
   tmp= mysys_thread_var();
   DBUG_ASSERT(tmp);
 
-  mysql_mutex_destroy(&tmp->mutex);
-  mysql_mutex_init(key_my_thread_var_mutex, &tmp->mutex, MY_MUTEX_INIT_FAST);
-
   mysql_cond_destroy(&tmp->suspend);
   mysql_cond_init(key_my_thread_var_suspend, &tmp->suspend);
 }
@@ -257,7 +254,6 @@ my_bool my_thread_init()
   if (!(tmp= (struct st_my_thread_var *) calloc(1, sizeof(*tmp))))
     return TRUE;
 
-  mysql_mutex_init(key_my_thread_var_mutex, &tmp->mutex, MY_MUTEX_INIT_FAST);
   mysql_cond_init(key_my_thread_var_suspend, &tmp->suspend);
 
   tmp->stack_ends_here= (char*)&tmp +
@@ -306,7 +302,6 @@ void my_thread_end()
     }
 #endif
     mysql_cond_destroy(&tmp->suspend);
-    mysql_mutex_destroy(&tmp->mutex);
     free(tmp);
 
     /*

mysys/mysys_priv.h

@@ -28,7 +28,7 @@ C_MODE_START
 
 extern PSI_mutex_key key_BITMAP_mutex, key_IO_CACHE_append_buffer_lock,
   key_IO_CACHE_SHARE_mutex, key_KEY_CACHE_cache_lock,
-  key_my_thread_var_mutex, key_THR_LOCK_charset, key_THR_LOCK_heap,
+  key_THR_LOCK_charset, key_THR_LOCK_heap,
   key_THR_LOCK_lock, key_THR_LOCK_malloc,
   key_THR_LOCK_mutex, key_THR_LOCK_myisam, key_THR_LOCK_net,
   key_THR_LOCK_open, key_THR_LOCK_threads,

mysys/thr_lock.c

@@ -356,7 +356,6 @@ wait_for_lock(struct st_lock_list *wait, THR_LOCK_DATA *data,
               my_bool in_wait_list, ulong lock_wait_timeout,
               struct st_my_thread_var *thread_var)
 {
-  mysql_cond_t *cond= &thread_var->suspend;
   struct timespec wait_timeout;
   enum enum_thr_lock_result result= THR_LOCK_ABORTED;
   PSI_stage_info old_stage;
@@ -394,13 +393,11 @@ wait_for_lock(struct st_lock_list *wait, THR_LOCK_DATA *data,
   locks_waited++;
 
   /* Set up control struct to allow others to abort locks */
-  thread_var->current_mutex= &data->lock->mutex;
-  thread_var->current_cond=  cond;
-  data->cond= cond;
+  data->cond= &thread_var->suspend;
 
-  proc_info_hook(NULL, &stage_waiting_for_table_level_lock,
-                 &old_stage,
-                 __func__, __FILE__, __LINE__);
+  enter_cond_hook(NULL, data->cond, &data->lock->mutex,
+                  &stage_waiting_for_table_level_lock, &old_stage,
+                  __func__, __FILE__, __LINE__);
 
   /*
     Since before_lock_wait potentially can create more threads to
@@ -418,7 +415,7 @@ wait_for_lock(struct st_lock_list *wait, THR_LOCK_DATA *data,
   set_timespec(&wait_timeout, lock_wait_timeout);
   while (!thread_var->abort || in_wait_list)
   {
-    int rc= mysql_cond_timedwait(cond, &data->lock->mutex, &wait_timeout);
+    int rc= mysql_cond_timedwait(data->cond, &data->lock->mutex, &wait_timeout);
     /*
       We must break the wait if one of the following occurs:
       - the connection has been aborted (!thread_var->abort),
@@ -481,13 +478,7 @@ wait_for_lock(struct st_lock_list *wait, THR_LOCK_DATA *data,
   }
   mysql_mutex_unlock(&data->lock->mutex);
 
-  /* The following must be done after unlock of lock->mutex */
-  mysql_mutex_lock(&thread_var->mutex);
-  thread_var->current_mutex= 0;
-  thread_var->current_cond=  0;
-  mysql_mutex_unlock(&thread_var->mutex);
-
-  proc_info_hook(NULL, &old_stage, NULL, __func__, __FILE__, __LINE__);
+  exit_cond_hook(NULL, &old_stage, __func__, __FILE__, __LINE__);
 
   DBUG_RETURN(result);
 }
@@ -1385,7 +1376,6 @@ static void *test_thread(void *arg)
   struct st_my_thread_var my_thread_var;
   memset(&my_thread_var, 0, sizeof(my_thread_var));
   my_thread_var.id= param + 1; /* Main thread uses value 0. */
-  mysql_mutex_init(0, &my_thread_var.mutex, MY_MUTEX_INIT_FAST);
   mysql_cond_init(0, &my_thread_var.suspend);
 
   printf("Thread T@%u (%d) started\n", my_thread_var.id, param);

plugin/semisync/semisync_master.cc

@@ -1,5 +1,5 @@
 /* Copyright (C) 2007 Google Inc.
-   Copyright (c) 2008, 2014, Oracle and/or its affiliates. All rights reserved.
+   Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -854,8 +854,7 @@ int ReplSemiSyncMaster::commitTrx(const char* trx_wait_binlog_name,
     else
       rpl_semi_sync_master_no_transactions++;
 
-    /* The lock held will be released by thd_exit_cond, so no need to
-       call unlock() here */
+    unlock();
     THD_EXIT_COND(NULL, & old_stage);
   }
 

sql/binlog.cc

@@ -7068,6 +7068,7 @@ int MYSQL_BIN_LOG::wait_for_update_relay_log(THD* thd, const struct timespec *ti
   else
     ret= mysql_cond_timedwait(&update_cond, &LOCK_log,
                               const_cast<struct timespec *>(timeout));
+  mysql_mutex_unlock(&LOCK_log);
   thd->EXIT_COND(&old_stage);
 
   DBUG_RETURN(ret);

sql/debug_sync.cc

@@ -1,4 +1,4 @@
-/* Copyright (c) 2009, 2014, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2009, 2015, Oracle and/or its affiliates. All rights reserved.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -238,20 +238,21 @@
   #endif
   while (!thd->killed && !end_of_wait_condition)
     mysql_cond_wait(&condition_variable, &mutex);
+  mysql_mutex_unlock(&mutex);
   thd->exit_cond(old_message);
 
   Here some explanations:
 
   thd->enter_cond() is used to register the condition variable and the
-  mutex in thd->mysys_var. This is done to allow the thread to be
-  interrupted (killed) from its sleep. Another thread can find the
-  condition variable to signal and mutex to use for synchronization in
-  this thread's THD::mysys_var.
+  mutex in THD::current_cond/current_mutex. This is done to allow the
+  thread to be interrupted (killed) from its sleep. Another thread can
+  find the condition variable to signal and mutex to use for synchronization
+  in this thread's THD.
 
   thd->enter_cond() requires the mutex to be acquired in advance.
 
-  thd->exit_cond() unregisters the condition variable and mutex and
-  releases the mutex.
+  thd->exit_cond() unregisters the condition variable and mutex. Requires
+  the mutex to be released in advance.
 
   If you want to have a Debug Sync point with the wait, please place it
   behind enter_cond(). Only then you can safely decide, if the wait will
@@ -280,6 +281,7 @@
       [DEBUG_SYNC(thd, "sync_point_name");]
       mysql_cond_wait(&condition_variable, &mutex);
     }
+    mysql_mutex_unlock(&mutex);
     thd->exit_cond(old_message);
   }
 
@@ -291,7 +293,7 @@
   condition variable. It would just set THD::killed. But if we would not
   test it again, we would go asleep though we are killed. If the killing
   thread would kill us when we are after the second test, but still
-  before sleeping, we hold the mutex, which is registered in mysys_var.
+  before sleeping, we hold the mutex, which is registered in THD.
   The killing thread would try to acquire the mutex before signaling
   the condition variable. Since the mutex is only released implicitly in
   mysql_cond_wait(), the signaling happens at the right place. We
@@ -1903,19 +1905,13 @@ static void debug_sync_execute(THD *thd, st_debug_sync_action *action)
         mutex and cond. This would prohibit the use of DEBUG_SYNC
         between other places of enter_cond() and exit_cond().
 
-        We need to check for existence of thd->mysys_var to also make
-        it possible to use DEBUG_SYNC framework in scheduler when this
-        variable has been set to NULL.
+        Note that we cannot lock LOCK_current_cond here. See comment
+        in THD::enter_cond().
       */
-      if (thd->mysys_var)
-      {
-        old_mutex= thd->mysys_var->current_mutex;
-        old_cond= thd->mysys_var->current_cond;
-        thd->mysys_var->current_mutex= &debug_sync_global.ds_mutex;
-        thd->mysys_var->current_cond= &debug_sync_global.ds_cond;
-      }
-      else
-        old_mutex= NULL;
+      old_mutex= thd->current_mutex;
+      old_cond= thd->current_cond;
+      thd->current_mutex= &debug_sync_global.ds_mutex;
+      thd->current_cond= &debug_sync_global.ds_cond;
 
       set_timespec(&abstime, action->timeout);
       DBUG_EXECUTE("debug_sync_exec", {
@@ -1974,11 +1970,11 @@ static void debug_sync_execute(THD *thd, st_debug_sync_action *action)
       mysql_mutex_unlock(&debug_sync_global.ds_mutex);
       if (old_mutex)
       {
-        mysql_mutex_lock(&thd->mysys_var->mutex);
-        thd->mysys_var->current_mutex= old_mutex;
-        thd->mysys_var->current_cond= old_cond;
+        mysql_mutex_lock(&thd->LOCK_current_cond);
+        thd->current_mutex= old_mutex;
+        thd->current_cond= old_cond;
+        mysql_mutex_unlock(&thd->LOCK_current_cond);
         debug_sync_thd_proc_info(thd, old_proc_info);
-        mysql_mutex_unlock(&thd->mysys_var->mutex);
       }
       else
         debug_sync_thd_proc_info(thd, old_proc_info);