bzr commit into mysql-6.0-perf branch (marc.alff:2707)

[Marc Alff]

#At file:///home/malff/BZR-TREE/mysql-6.0-perf/

 2707 Marc Alff	2008-10-16
      Instrumentation for mysys, continued
modified:
  mysys/my_init.c

=== modified file 'mysys/my_init.c'
--- a/mysys/my_init.c	2008-10-14 17:30:16 +0000
+++ b/mysys/my_init.c	2008-10-16 17:01:38 +0000
@@ -551,6 +551,12 @@ static void netware_init()
 
 #ifdef HAVE_PSI_INTERFACE
 
+#if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
+PSI_mutex_key key_LOCK_localtime_r;
+#endif
+#ifndef HAVE_GETHOSTBYNAME_R
+PSI_mutex_key key_LOCK_gethostbyname_r;
+#endif
 PSI_mutex_key key_KEY_CACHE_cache_lock;
 PSI_mutex_key key_IO_CACHE_append_buffer_lock;
 PSI_mutex_key key_IO_CACHE_SHARE_mutex;
@@ -574,75 +580,106 @@ PSI_mutex_key key_THR_LOCK_heap;
 PSI_mutex_key key_THR_LOCK_threads;
 PSI_mutex_key key_my_thread_var_mutex;
 
+static PSI_mutex_info all_mysys_mutexes[]=
+{
 #if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
-PSI_mutex_key key_LOCK_localtime_r;
+  { & key_LOCK_localtime_r,
+    "LOCK_localtime_r", PSI_FLAG_GLOBAL},
 #endif
 #ifndef HAVE_GETHOSTBYNAME_R
-PSI_mutex_key key_LOCK_gethostbyname_r;
+  { & key_LOCK_gethostbyname_r,
+    "LOCK_gethostbyname_r", PSI_FLAG_GLOBAL},
 #endif
+  { & key_KEY_CACHE_cache_lock,
+    "KEY_CACHE::cache_lock", PSI_FLAG_GLOBAL},
+  { & key_IO_CACHE_append_buffer_lock,
+    "IO_CACHE::append_buffer_lock", PSI_FLAG_GLOBAL},
+  { & key_IO_CACHE_SHARE_mutex,
+    "IO_CACHE::SHARE_mutex", PSI_FLAG_GLOBAL},
+  { & key_TMPDIR_mutex,
+    "TMPDIR_mutex", PSI_FLAG_GLOBAL},
+  { & key_LOCK_uuid_generator,
+    "LOCK_uuid_generator", PSI_FLAG_GLOBAL},
+  { & key_BITMAP_mutex,
+    "BITMAP_mutex", PSI_FLAG_GLOBAL},
+  { & key_LOCK_alarm,
+    "LOCK_alarm", PSI_FLAG_GLOBAL},
+  { & key_THD_LOCK_mutex,
+    "THD_LOCK_mutex", PSI_FLAG_GLOBAL},
+  { & key_THR_LOCK_malloc,
+    "THR_LOCK_malloc", PSI_FLAG_GLOBAL},
+  { & key_THR_LOCK_open,
+    "THR_LOCK_open", PSI_FLAG_GLOBAL},
+  { & key_THR_LOCK_keycache,
+    "THR_LOCK_keycache", PSI_FLAG_GLOBAL},
+  { & key_THR_LOCK_lock,
+    "THR_LOCK_lock", PSI_FLAG_GLOBAL},
+  { & key_THR_LOCK_isam,
+    "THR_LOCK_isam", PSI_FLAG_GLOBAL},
+  { & key_THR_LOCK_net,
+    "THR_LOCK_net", PSI_FLAG_GLOBAL},
+  { & key_THR_LOCK_charset,
+    "THR_LOCK_charset", PSI_FLAG_GLOBAL},
+  { & key_THR_LOCK_time,
+    "THR_LOCK_time", PSI_FLAG_GLOBAL},
+  { & key_THR_LOCK_isam,
+    "THR_LOCK_isam", PSI_FLAG_GLOBAL},
+  { & key_THR_LOCK_myisam,
+    "THR_LOCK_myisam", PSI_FLAG_GLOBAL},
+  { & key_THR_LOCK_myisam_log,
+    "THR_LOCK_myisam_log", PSI_FLAG_GLOBAL},
+  { & key_THR_LOCK_heap,
+    "THR_LOCK_heap", PSI_FLAG_GLOBAL},
+  { & key_THR_LOCK_threads,
+    "THR_LOCK_threads", PSI_FLAG_GLOBAL},
+  { & key_my_thread_var_mutex,
+    "my_thread_var::mutex", PSI_FLAG_GLOBAL}
+};
 
 PSI_rwlock_key key_SAFE_HASH_mutex;
 
+static PSI_rwlock_info all_mysys_rwlocks[]=
+{
+  { & key_SAFE_HASH_mutex,
+    "SAFE_HASH_mutex", PSI_FLAG_GLOBAL}
+};
+
 PSI_cond_key key_IO_CACHE_SHARE_cond;
 PSI_cond_key key_IO_CACHE_SHARE_cond_writer;
 PSI_cond_key key_COND_alarm;
 PSI_cond_key key_THR_COND_threads;
 PSI_cond_key key_my_thread_var_suspend;
 
+static PSI_cond_info all_mysys_conds[]=
+{
+  { & key_IO_CACHE_SHARE_cond,
+    "IO_CACHE_SHARE::cond", PSI_FLAG_GLOBAL},
+  { & key_IO_CACHE_SHARE_cond_writer,
+    "IO_CACHE_SHARE::cond_writer", PSI_FLAG_GLOBAL},
+  { & key_COND_alarm,
+    "COND_alarm", PSI_FLAG_GLOBAL},
+  { & key_THR_COND_threads,
+    "THR_COND_threads", PSI_FLAG_GLOBAL},
+  { & key_my_thread_var_suspend,
+    "my_thread_var::suspend", PSI_FLAG_GLOBAL}
+};
 
 void my_init_mysys_psi_keys()
 {
-  PSI_mutex_key (*reg_mutex)(const char* name, int global);
-  PSI_rwlock_key (*reg_rwlock)(const char* name, int global);
-  PSI_cond_key (*reg_cond)(const char* name, int global);
-  int global= 1;
+  const char* category= "mysys";
+  int count;
 
   if (PSI_server == NULL)
     return;
 
-  reg_mutex= PSI_server->register_mutex;
-  reg_rwlock= PSI_server->register_rwlock;
-  reg_cond= PSI_server->register_cond;
-
-  /* ALL mysys MUTEXES */
-  key_KEY_CACHE_cache_lock= (*reg_mutex)("KEY_CACHE::cache_lock", global);
-  key_IO_CACHE_append_buffer_lock= (*reg_mutex)("IO_CACHE::append_buffer_lock", global);
-  key_IO_CACHE_SHARE_mutex= (*reg_mutex)("IO_CACHE_SHARE::mutex", global);
-  key_TMPDIR_mutex= (*reg_mutex)("TMPDIR::mutex", global);
-  key_LOCK_uuid_generator= (*reg_mutex)("LOCK_uuid_generator", global);
-  key_BITMAP_mutex= (*reg_mutex)("BITMAP::mutex", global);
-  key_LOCK_alarm= (*reg_mutex)("LOCK_alarm", global);
-  key_THD_LOCK_mutex= (*reg_mutex)("THD_LOCK_mutex", global);
-  key_THR_LOCK_malloc= (*reg_mutex)("THR_LOCK_malloc", global);
-  key_THR_LOCK_open= (*reg_mutex)("THR_LOCK_open", global);
-  key_THR_LOCK_keycache= (*reg_mutex)("THR_LOCK_keycache", global);
-  key_THR_LOCK_lock= (*reg_mutex)("THR_LOCK_lock", global);
-  key_THR_LOCK_isam= (*reg_mutex)("THR_LOCK_isam", global);
-  key_THR_LOCK_net= (*reg_mutex)("THR_LOCK_net", global);
-  key_THR_LOCK_charset= (*reg_mutex)("THR_LOCK_charset", global);
-  key_THR_LOCK_time= (*reg_mutex)("THR_LOCK_time", global);
-  key_THR_LOCK_isam= (*reg_mutex)("THR_LOCK_isam", global);
-  key_THR_LOCK_myisam= (*reg_mutex)("THR_LOCK_myisam", global);
-  key_THR_LOCK_myisam_log= (*reg_mutex)("THR_LOCK_myisam_log", global);
-  key_THR_LOCK_heap= (*reg_mutex)("THR_LOCK_heap", global);
-  key_THR_LOCK_threads= (*reg_mutex)("THR_LOCK_threads", global);
-  key_my_thread_var_mutex= (*reg_mutex)("my_thread_var::mutex", global);
-#if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
-  key_LOCK_localtime_r= (*reg_mutex)("LOCK_localtime_r", global);
-#endif
-#ifndef HAVE_GETHOSTBYNAME_R
-  key_LOCK_gethostbyname_r= (*reg_mutex)("LOCK_gethostbyname_r", global);
-#endif
+  count= sizeof(all_mysys_mutexes)/sizeof(all_mysys_mutexes[0]);
+  PSI_server->register_mutex(category, all_mysys_mutexes, count);
 
-  /* ALL mysys RWLOCK */
-  key_SAFE_HASH_mutex= (*reg_rwlock)("SAFE_HASH::mutex", global);
+  count= sizeof(all_mysys_rwlocks)/sizeof(all_mysys_rwlocks[0]);
+  PSI_server->register_rwlock(category, all_mysys_rwlocks, count);
 
-  /* ALL mysys COND */
-  key_IO_CACHE_SHARE_cond= (*reg_cond)("IO_CACHE_SHARE::cond", global);
-  key_IO_CACHE_SHARE_cond_writer= (*reg_cond)("IO_CACHE_SHARE::cond_writer", global);
-  key_COND_alarm= (*reg_cond)("COND_alarm", global);
-  key_THR_COND_threads= (*reg_cond)("THR_COND_threads", global);
-  key_my_thread_var_suspend= (*reg_cond)("my_thread_var::suspend", global);
+  count= sizeof(all_mysys_conds)/sizeof(all_mysys_conds[0]);
+  PSI_server->register_cond(category, all_mysys_conds, count);
 }
 #endif