cleanup: PSI key is *always* the first argument

44 files changed, 210 insertions, 237 deletions

diff --git a/sql/ha_partition.cc b/sql/ha_partition.cc
index ce5038097f0..f30ef6a9688 100644
--- a/sql/ha_partition.cc
+++ b/sql/ha_partition.cc
@@ -3289,10 +3289,10 @@ bool ha_partition::populate_partition_name_hash()
     DBUG_RETURN(false);
   }
   tot_names= m_is_sub_partitioned ? m_tot_parts + num_parts : num_parts;
-  if (my_hash_init(&part_share->partition_name_hash,
-                   system_charset_info, tot_names, 0, 0,
-                   (my_hash_get_key) get_part_name,
-                   my_free, HASH_UNIQUE, key_memory_Partition_share))
+  if (my_hash_init(key_memory_Partition_share,
+                   &part_share->partition_name_hash, system_charset_info,
+                   tot_names, 0, 0, (my_hash_get_key) get_part_name, my_free,
+                   HASH_UNIQUE))
   {
     unlock_shared_ha_data();
     DBUG_RETURN(TRUE);
diff --git a/sql/hash_filo.h b/sql/hash_filo.h
index 864e91594b2..ac84e5ccb7b 100644
--- a/sql/hash_filo.h
+++ b/sql/hash_filo.h
@@ -94,8 +94,8 @@ public:
     first_link= NULL;
     last_link= NULL;
     (void) my_hash_free(&cache);
-    (void) my_hash_init(&cache,hash_charset,m_size,key_offset, 
-                     key_length, get_key, free_element, 0, m_psi_key);
+    (void) my_hash_init(m_psi_key, &cache,hash_charset,m_size,key_offset,
+                        key_length, get_key, free_element, 0);
     if (!locked)
       mysql_mutex_unlock(&lock);
   }
diff --git a/sql/item_create.cc b/sql/item_create.cc
index e437b3fc724..edf44fc3cd3 100644
--- a/sql/item_create.cc
+++ b/sql/item_create.cc
@@ -5617,14 +5617,9 @@ int item_create_init()
 #ifdef HAVE_SPATIAL
   count+= native_func_registry_array_geom.count();
 #endif
-  if (my_hash_init(& native_functions_hash,
-                   system_charset_info,
-                   (ulong) count,
-                   0,
-                   0,
-                   (my_hash_get_key) get_native_fct_hash_key,
-                   NULL,                          /* Nothing to free */
-                   MYF(0), key_memory_native_functions))
+  if (my_hash_init(key_memory_native_functions, & native_functions_hash,
+                   system_charset_info, (ulong) count, 0, 0, (my_hash_get_key)
+                   get_native_fct_hash_key, NULL, MYF(0)))
     DBUG_RETURN(1);
 
   if (native_func_registry_array.append_to_hash(&native_functions_hash))
diff --git a/sql/item_func.cc b/sql/item_func.cc
index fe89938260c..57ef5d6adb9 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -4019,9 +4019,9 @@ longlong Item_func_get_lock::val_int()
   DBUG_PRINT("enter", ("lock: %.*s", res->length(), res->ptr()));
   /* HASH entries are of type User_level_lock. */
   if (! my_hash_inited(&thd->ull_hash) &&
-        my_hash_init(&thd->ull_hash, &my_charset_bin,
-                     16 /* small hash */, 0, 0, ull_get_key, NULL, 0,
-                     key_memory_User_level_lock))
+        my_hash_init(key_memory_User_level_lock, &thd->ull_hash,
+                     &my_charset_bin, 16 /* small hash */, 0, 0, ull_get_key,
+                     NULL, 0))
   {
     DBUG_RETURN(0);
   }
diff --git a/sql/log.cc b/sql/log.cc
index b0254850176..174adc4d145 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -9564,8 +9564,8 @@ int TC_LOG_MMAP::recover()
     goto err1;
   }
 
-  if (my_hash_init(&xids, &my_charset_bin, tc_log_page_size/3, 0,
-                   sizeof(my_xid), 0, 0, MYF(0), PSI_INSTRUMENT_ME))
+  if (my_hash_init(PSI_INSTRUMENT_ME, &xids, &my_charset_bin,
+                   tc_log_page_size/3, 0, sizeof(my_xid), 0, 0, MYF(0)))
     goto err1;
 
   for ( ; p < end_p ; p++)
@@ -10078,9 +10078,8 @@ int TC_LOG_BINLOG::recover(LOG_INFO *linfo, const char *last_log_name,
 #endif
 
   if (! fdle->is_valid() ||
-      (do_xa && my_hash_init(&xids, &my_charset_bin, TC_LOG_PAGE_SIZE/3, 0,
-                             sizeof(my_xid), 0, 0, MYF(0),
-                             key_memory_binlog_recover_exec)))
+      (do_xa && my_hash_init(key_memory_binlog_recover_exec, &xids, &my_charset_bin, TC_LOG_PAGE_SIZE/3, 0,
+                             sizeof(my_xid), 0, 0, MYF(0))))
     goto err1;
 
   if (do_xa)
diff --git a/sql/log_event_client.cc b/sql/log_event_client.cc
index 83a7eaf06b0..6ee5587943d 100644
--- a/sql/log_event_client.cc
+++ b/sql/log_event_client.cc
@@ -1104,7 +1104,7 @@ void Rows_log_event::change_to_flashback_event(PRINT_EVENT_INFO *print_event_inf
   if (((get_general_type_code() == WRITE_ROWS_EVENT) && (m_rows_buf==m_rows_end)))
     goto end;
 
-  (void) my_init_dynamic_array(&rows_arr, PSI_NOT_INSTRUMENTED, sizeof(LEX_STRING), 8, 8, MYF(0));
+  (void) my_init_dynamic_array(PSI_NOT_INSTRUMENTED, &rows_arr, sizeof(LEX_STRING), 8, 8, MYF(0));
 
   for (uchar *value= m_rows_buf; value < m_rows_end; )
   {
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 42eb97fefbe..0f54f29e8f6 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -6395,7 +6395,7 @@ int handle_early_options()
   my_getopt_skip_unknown= TRUE;
 
   /* prepare all_early_options array */
-  my_init_dynamic_array(&all_early_options, PSI_NOT_INSTRUMENTED,
+  my_init_dynamic_array(PSI_NOT_INSTRUMENTED, &all_early_options,
                         sizeof(my_option), 100, 25, MYF(0));
   add_many_options(&all_early_options, pfs_early_options,
                   array_elements(pfs_early_options));
@@ -8570,7 +8570,7 @@ static int get_options(int *argc_ptr, char ***argv_ptr)
   my_getopt_error_reporter= option_error_reporter;
 
   /* prepare all_options array */
-  my_init_dynamic_array(&all_options, PSI_INSTRUMENT_ME, sizeof(my_option),
+  my_init_dynamic_array(PSI_INSTRUMENT_ME, &all_options, sizeof(my_option),
                         array_elements(my_long_options) + sys_var_elements(),
                         array_elements(my_long_options)/4, MYF(0));
   add_many_options(&all_options, my_long_options, array_elements(my_long_options));
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index e3672d2c47f..5822aaa8250 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -1276,7 +1276,7 @@ QUICK_RANGE_SELECT::QUICK_RANGE_SELECT(THD *thd, TABLE *table, uint key_nr,
   file= head->file;
   record= head->record[0];
 
-  my_init_dynamic_array2(&ranges, PSI_INSTRUMENT_ME, sizeof(QUICK_RANGE*),
+  my_init_dynamic_array2(PSI_INSTRUMENT_ME, &ranges, sizeof(QUICK_RANGE*),
                          thd->alloc(sizeof(QUICK_RANGE*) * 16), 16, 16,
                          MYF(MY_THREAD_SPECIFIC));
 
@@ -14507,8 +14507,9 @@ int QUICK_GROUP_MIN_MAX_SELECT::init()
 
   if (min_max_arg_part)
   {
-    if (my_init_dynamic_array(&min_max_ranges, PSI_INSTRUMENT_ME,
-                              sizeof(QUICK_RANGE*), 16, 16, MYF(MY_THREAD_SPECIFIC)))
+    if (my_init_dynamic_array(PSI_INSTRUMENT_ME, &min_max_ranges,
+                              sizeof(QUICK_RANGE*), 16, 16,
+                              MYF(MY_THREAD_SPECIFIC)))
       return 1;
 
     if (have_min)
diff --git a/sql/opt_split.cc b/sql/opt_split.cc
index 8fe3749c2df..b27a0d757cb 100644
--- a/sql/opt_split.cc
+++ b/sql/opt_split.cc
@@ -742,7 +742,7 @@ void JOIN::add_keyuses_for_splitting()
   save_query_plan(save_qep);
 
   if (!keyuse.buffer &&
-       my_init_dynamic_array(&keyuse, PSI_INSTRUMENT_ME, sizeof(KEYUSE),
+       my_init_dynamic_array(PSI_INSTRUMENT_ME, &keyuse, sizeof(KEYUSE),
                              20, 64, MYF(MY_THREAD_SPECIFIC)))
     goto err;
 
diff --git a/sql/partition_info.cc b/sql/partition_info.cc
index 5a0e7426713..1af3153ca87 100644
--- a/sql/partition_info.cc
+++ b/sql/partition_info.cc
@@ -733,9 +733,8 @@ char *partition_info::find_duplicate_name()
   max_names= num_parts;
   if (is_sub_partitioned())
     max_names+= num_parts * num_subparts;
-  if (my_hash_init(&partition_names, system_charset_info, max_names, 0, 0,
-                   (my_hash_get_key) get_part_name_from_elem, 0, HASH_UNIQUE,
-                   PSI_INSTRUMENT_ME))
+  if (my_hash_init(PSI_INSTRUMENT_ME, &partition_names, system_charset_info, max_names, 0, 0,
+                   (my_hash_get_key) get_part_name_from_elem, 0, HASH_UNIQUE))
   {
     DBUG_ASSERT(0);
     curr_name= (const uchar*) "Internal failure";
diff --git a/sql/rpl_filter.cc b/sql/rpl_filter.cc
index d9dc7e499ea..635a0f4e2d6 100644
--- a/sql/rpl_filter.cc
+++ b/sql/rpl_filter.cc
@@ -573,8 +573,9 @@ void free_table_ent(void* a)
 void 
 Rpl_filter::init_table_rule_hash(HASH* h, bool* h_inited)
 {
-  my_hash_init(h, system_charset_info,TABLE_RULE_HASH_SIZE,0,0,
-	    get_table_key, free_table_ent, 0, key_memory_TABLE_RULE_ENT);
+  my_hash_init(key_memory_TABLE_RULE_ENT, h,
+               system_charset_info,TABLE_RULE_HASH_SIZE,0,0, get_table_key,
+               free_table_ent, 0);
   *h_inited = 1;
 }
 
@@ -582,7 +583,7 @@ Rpl_filter::init_table_rule_hash(HASH* h, bool* h_inited)
 void 
 Rpl_filter::init_table_rule_array(DYNAMIC_ARRAY* a, bool* a_inited)
 {
-  my_init_dynamic_array(a, key_memory_TABLE_RULE_ENT, sizeof(TABLE_RULE_ENT*),
+  my_init_dynamic_array(key_memory_TABLE_RULE_ENT, a, sizeof(TABLE_RULE_ENT*),
                         TABLE_RULE_ARR_SIZE, TABLE_RULE_ARR_SIZE, MYF(0));
   *a_inited = 1;
 }
diff --git a/sql/rpl_gtid.cc b/sql/rpl_gtid.cc
index e9c1dc8c5d7..bc87441d183 100644
--- a/sql/rpl_gtid.cc
+++ b/sql/rpl_gtid.cc
@@ -248,10 +248,9 @@ rpl_slave_state::rpl_slave_state()
 {
   mysql_mutex_init(key_LOCK_slave_state, &LOCK_slave_state,
                    MY_MUTEX_INIT_SLOW);
-  my_hash_init(&hash, &my_charset_bin, 32, offsetof(element, domain_id),
-               sizeof(uint32), NULL, rpl_slave_state_free_element, HASH_UNIQUE,
-               PSI_INSTRUMENT_ME);
-  my_init_dynamic_array(&gtid_sort_array, PSI_INSTRUMENT_ME, sizeof(rpl_gtid),
+  my_hash_init(PSI_INSTRUMENT_ME, &hash, &my_charset_bin, 32, offsetof(element, domain_id),
+               sizeof(uint32), NULL, rpl_slave_state_free_element, HASH_UNIQUE);
+  my_init_dynamic_array(PSI_INSTRUMENT_ME, &gtid_sort_array, sizeof(rpl_gtid),
                         8, 8, MYF(0));
 }
 
@@ -1114,8 +1113,9 @@ rpl_slave_state::iterate(int (*cb)(rpl_gtid *, void *), void *data,
   int res= 1;
   bool locked= false;
 
-  my_hash_init(&gtid_hash, &my_charset_bin, 32, offsetof(rpl_gtid, domain_id),
-               sizeof(uint32), NULL, NULL, HASH_UNIQUE, PSI_INSTRUMENT_ME);
+  my_hash_init(PSI_INSTRUMENT_ME, &gtid_hash, &my_charset_bin, 32,
+               offsetof(rpl_gtid, domain_id), sizeof(uint32), NULL, NULL,
+               HASH_UNIQUE);
   for (i= 0; i < num_extra; ++i)
     if (extra_gtids[i].server_id == global_system_variables.server_id &&
         my_hash_insert(&gtid_hash, (uchar *)(&extra_gtids[i])))
@@ -1487,9 +1487,9 @@ rpl_slave_state::alloc_gtid_pos_table(LEX_CSTRING *table_name, void *hton,
 
 void rpl_binlog_state::init()
 {
-  my_hash_init(&hash, &my_charset_bin, 32, offsetof(element, domain_id),
-               sizeof(uint32), NULL, my_free, HASH_UNIQUE, PSI_INSTRUMENT_ME);
-  my_init_dynamic_array(&gtid_sort_array, PSI_INSTRUMENT_ME, sizeof(rpl_gtid), 8, 8, MYF(0));
+  my_hash_init(PSI_INSTRUMENT_ME, &hash, &my_charset_bin, 32, offsetof(element, domain_id),
+               sizeof(uint32), NULL, my_free, HASH_UNIQUE);
+  my_init_dynamic_array(PSI_INSTRUMENT_ME, &gtid_sort_array, sizeof(rpl_gtid), 8, 8, MYF(0));
   mysql_mutex_init(key_LOCK_binlog_state, &LOCK_binlog_state,
                    MY_MUTEX_INIT_SLOW);
   initialized= 1;
@@ -1714,9 +1714,9 @@ rpl_binlog_state::alloc_element_nolock(const rpl_gtid *gtid)
   if (elem && lookup_gtid)
   {
     elem->domain_id= gtid->domain_id;
-    my_hash_init(&elem->hash, &my_charset_bin, 32,
+    my_hash_init(PSI_INSTRUMENT_ME, &elem->hash, &my_charset_bin, 32,
                  offsetof(rpl_gtid, server_id), sizeof(uint32), NULL, my_free,
-                 HASH_UNIQUE, PSI_INSTRUMENT_ME);
+                 HASH_UNIQUE);
     elem->last_gtid= lookup_gtid;
     elem->seq_no_counter= gtid->seq_no;
     memcpy(lookup_gtid, gtid, sizeof(*lookup_gtid));
@@ -1795,9 +1795,9 @@ rpl_binlog_state::bump_seq_no_if_needed(uint32 domain_id, uint64 seq_no)
   }
 
   elem->domain_id= domain_id;
-  my_hash_init(&elem->hash, &my_charset_bin, 32,
+  my_hash_init(PSI_INSTRUMENT_ME, &elem->hash, &my_charset_bin, 32,
                offsetof(rpl_gtid, server_id), sizeof(uint32), NULL, my_free,
-               HASH_UNIQUE, PSI_INSTRUMENT_ME);
+               HASH_UNIQUE);
   elem->last_gtid= NULL;
   elem->seq_no_counter= seq_no;
   if (0 == my_hash_insert(&hash, (const uchar *)elem))
@@ -2126,7 +2126,7 @@ rpl_binlog_state::drop_domain(DYNAMIC_ARRAY *ids,
 
   DBUG_ENTER("rpl_binlog_state::drop_domain");
 
-  my_init_dynamic_array2(&domain_unique, PSI_INSTRUMENT_ME,
+  my_init_dynamic_array2(PSI_INSTRUMENT_ME, &domain_unique,
                          sizeof(element*), domain_unique_buffer,
                          sizeof(domain_unique_buffer) / sizeof(element*), 4, 0);
 
@@ -2251,10 +2251,10 @@ end:
 
 slave_connection_state::slave_connection_state()
 {
-  my_hash_init(&hash, &my_charset_bin, 32,
+  my_hash_init(PSI_INSTRUMENT_ME, &hash, &my_charset_bin, 32,
                offsetof(entry, gtid) + offsetof(rpl_gtid, domain_id),
-               sizeof(uint32), NULL, my_free, HASH_UNIQUE, PSI_INSTRUMENT_ME);
-  my_init_dynamic_array(&gtid_sort_array, PSI_INSTRUMENT_ME, sizeof(rpl_gtid), 8, 8, MYF(0));
+               sizeof(uint32), NULL, my_free, HASH_UNIQUE);
+  my_init_dynamic_array(PSI_INSTRUMENT_ME, &gtid_sort_array, sizeof(rpl_gtid), 8, 8, MYF(0));
 }
 
 
@@ -2877,9 +2877,9 @@ free_hash_element(void *p)
 void
 gtid_waiting::init()
 {
-  my_hash_init(&hash, &my_charset_bin, 32,
+  my_hash_init(PSI_INSTRUMENT_ME, &hash, &my_charset_bin, 32,
                offsetof(hash_element, domain_id), sizeof(uint32), NULL,
-               free_hash_element, HASH_UNIQUE, PSI_INSTRUMENT_ME);
+               free_hash_element, HASH_UNIQUE);
   mysql_mutex_init(key_LOCK_gtid_waiting, &LOCK_gtid_waiting, 0);
 }
 
diff --git a/sql/rpl_mi.cc b/sql/rpl_mi.cc
index fcbd988509d..0649a8f05e8 100644
--- a/sql/rpl_mi.cc
+++ b/sql/rpl_mi.cc
@@ -77,7 +77,7 @@ Master_info::Master_info(LEX_CSTRING *connection_name_arg,
 
   parallel_mode= rpl_filter->get_parallel_mode();
 
-  my_init_dynamic_array(&ignore_server_ids, PSI_INSTRUMENT_ME,
+  my_init_dynamic_array(PSI_INSTRUMENT_ME, &ignore_server_ids,
                         sizeof(global_system_variables.server_id), 16, 16,
                         MYF(0));
   bzero((char*) &file, sizeof(file));
@@ -1099,11 +1099,10 @@ bool Master_info_index::init_all_master_info()
   }
 
   /* Initialize Master_info Hash Table */
-  if (my_hash_init(&master_info_hash, system_charset_info, 
+  if (my_hash_init(PSI_INSTRUMENT_ME, &master_info_hash, system_charset_info, 
                    MAX_REPLICATION_THREAD, 0, 0, 
                    (my_hash_get_key) get_key_master_info, 
-                   (my_hash_free_key)free_key_master_info, HASH_UNIQUE,
-                   PSI_INSTRUMENT_ME))
+                   (my_hash_free_key)free_key_master_info, HASH_UNIQUE))
   {                                                      
     sql_print_error("Initializing Master_info hash table failed");
     DBUG_RETURN(1);
@@ -1743,8 +1742,8 @@ Domain_id_filter::Domain_id_filter() : m_filter(false)
 {
   for (int i= DO_DOMAIN_IDS; i <= IGNORE_DOMAIN_IDS; i ++)
   {
-    my_init_dynamic_array(&m_domain_ids[i], PSI_INSTRUMENT_ME,
-                          sizeof(ulong), 16, 16, MYF(0));
+    my_init_dynamic_array(PSI_INSTRUMENT_ME, &m_domain_ids[i], sizeof(ulong),
+                          16, 16, MYF(0));
   }
 }
 
diff --git a/sql/rpl_parallel.cc b/sql/rpl_parallel.cc
index cbdc5a548be..f875ab2b4a4 100644
--- a/sql/rpl_parallel.cc
+++ b/sql/rpl_parallel.cc
@@ -2199,9 +2199,9 @@ free_rpl_parallel_entry(void *element)
 rpl_parallel::rpl_parallel() :
   current(NULL), sql_thread_stopping(false)
 {
-  my_hash_init(&domain_hash, &my_charset_bin, 32,
+  my_hash_init(PSI_INSTRUMENT_ME, &domain_hash, &my_charset_bin, 32,
                offsetof(rpl_parallel_entry, domain_id), sizeof(uint32),
-               NULL, free_rpl_parallel_entry, HASH_UNIQUE, PSI_INSTRUMENT_ME);
+               NULL, free_rpl_parallel_entry, HASH_UNIQUE);
 }
 
 
diff --git a/sql/rpl_rli.cc b/sql/rpl_rli.cc
index 08cc05f082e..01093d9a6da 100644
--- a/sql/rpl_rli.cc
+++ b/sql/rpl_rli.cc
@@ -1834,10 +1834,10 @@ rpl_load_gtid_slave_state(THD *thd)
 
   cb_data.table_list= NULL;
   cb_data.default_entry= NULL;
-  my_hash_init(&hash, &my_charset_bin, 32,
+  my_hash_init(PSI_INSTRUMENT_ME, &hash, &my_charset_bin, 32,
                offsetof(gtid_pos_element, gtid) + offsetof(rpl_gtid, domain_id),
-               sizeof(uint32), NULL, my_free, HASH_UNIQUE, PSI_INSTRUMENT_ME);
-  if ((err= my_init_dynamic_array(&array, PSI_INSTRUMENT_ME,
+               sizeof(uint32), NULL, my_free, HASH_UNIQUE);
+  if ((err= my_init_dynamic_array(PSI_INSTRUMENT_ME, &array,
                                   sizeof(gtid_pos_element), 0, 0, MYF(0))))
     goto end;
   array_inited= true;
diff --git a/sql/rpl_tblmap.cc b/sql/rpl_tblmap.cc
index db0c11473d1..a230b9f6f29 100644
--- a/sql/rpl_tblmap.cc
+++ b/sql/rpl_tblmap.cc
@@ -48,9 +48,9 @@ table_mapping::table_mapping()
     Note that below we don't test if my_hash_init() succeeded. This
     constructor is called at startup only.
   */
-  (void) my_hash_init(&m_table_ids,&my_charset_bin,TABLE_ID_HASH_SIZE,
+  (void) my_hash_init(psi_key, &m_table_ids,&my_charset_bin,TABLE_ID_HASH_SIZE,
                       offsetof(entry,table_id),sizeof(ulonglong),
-                      0,0,0, psi_key);
+                      0,0,0);
   /* We don't preallocate any block, this is consistent with m_free=0 above */
   init_alloc_root(psi_key, &m_mem_root, TABLE_ID_HASH_SIZE*sizeof(entry), 0, MYF(0));
   DBUG_VOID_RETURN;
diff --git a/sql/rpl_utility_server.cc b/sql/rpl_utility_server.cc
index 00d4888bbe3..8110b142e74 100644
--- a/sql/rpl_utility_server.cc
+++ b/sql/rpl_utility_server.cc
@@ -1123,7 +1123,7 @@ err:
 
 Deferred_log_events::Deferred_log_events(Relay_log_info *rli) : last_added(NULL)
 {
-  my_init_dynamic_array(&array, PSI_INSTRUMENT_ME, sizeof(Log_event *), 32, 16, MYF(0));
+  my_init_dynamic_array(PSI_INSTRUMENT_ME, &array, sizeof(Log_event *), 32, 16, MYF(0));
 }
 
 Deferred_log_events::~Deferred_log_events()
diff --git a/sql/session_tracker.h b/sql/session_tracker.h
index 422ec98944a..7db1feb1b1a 100644
--- a/sql/session_tracker.h
+++ b/sql/session_tracker.h
@@ -142,10 +142,9 @@ class Session_sysvars_tracker: public State_tracker
     bool track_all;
     void init()
     {
-      my_hash_init(&m_registered_sysvars, &my_charset_bin, 0, 0, 0,
-                   (my_hash_get_key) sysvars_get_key, my_free, HASH_UNIQUE |
-                   (mysqld_server_initialized ?  HASH_THREAD_SPECIFIC : 0),
-                   PSI_INSTRUMENT_ME);
+      my_hash_init(PSI_INSTRUMENT_ME, &m_registered_sysvars, &my_charset_bin,
+                   0, 0, 0, (my_hash_get_key) sysvars_get_key, my_free,
+                   HASH_UNIQUE | (mysqld_server_initialized ?  HASH_THREAD_SPECIFIC : 0));
     }
     void free_hash()
     {
diff --git a/sql/set_var.cc b/sql/set_var.cc
index c195312a096..df52d42f54a 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -65,9 +65,8 @@ int sys_var_init()
   /* Must be already initialized. */
   DBUG_ASSERT(system_charset_info != NULL);
 
-  if (my_hash_init(&system_variable_hash, system_charset_info, 700, 0,
-                   0, (my_hash_get_key) get_sys_var_length, 0, HASH_UNIQUE,
-                   PSI_INSTRUMENT_ME))
+  if (my_hash_init(PSI_INSTRUMENT_ME, &system_variable_hash, system_charset_info, 700, 0,
+                   0, (my_hash_get_key) get_sys_var_length, 0, HASH_UNIQUE))
     goto error;
 
   if (mysql_add_sys_var_chain(all_sys_vars.first))
diff --git a/sql/sp.cc b/sql/sp.cc
index 5ea7a0ab4ba..584ec0b520b 100644
--- a/sql/sp.cc
+++ b/sql/sp.cc
@@ -2301,9 +2301,9 @@ bool sp_add_used_routine(Query_tables_list *prelocking_ctx, Query_arena *arena,
                          const Sp_handler *handler,
                          TABLE_LIST *belong_to_view)
 {
-  my_hash_init_opt(&prelocking_ctx->sroutines, system_charset_info,
+  my_hash_init_opt(PSI_INSTRUMENT_ME, &prelocking_ctx->sroutines, system_charset_info,
                    Query_tables_list::START_SROUTINES_HASH_SIZE,
-                   0, 0, sp_sroutine_key, 0, 0, PSI_INSTRUMENT_ME);
+                   0, 0, sp_sroutine_key, 0, 0);
 
   if (!my_hash_search(&prelocking_ctx->sroutines, key->ptr(), key->length()))
   {
diff --git a/sql/sp_cache.cc b/sql/sp_cache.cc
index 04172d56166..a8659cc121f 100644
--- a/sql/sp_cache.cc
+++ b/sql/sp_cache.cc
@@ -302,9 +302,8 @@ sp_cache::~sp_cache()
 void
 sp_cache::init()
 {
-  my_hash_init(&m_hashtable, system_charset_info, 0, 0, 0,
-               hash_get_key_for_sp_head, hash_free_sp_head, 0,
-               key_memory_sp_cache);
+  my_hash_init(key_memory_sp_cache, &m_hashtable, system_charset_info, 0, 0, 0,
+               hash_get_key_for_sp_head, hash_free_sp_head, 0);
 }
 
 
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index 6853d392a8c..9b378cc66f7 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -580,12 +580,12 @@ sp_head::sp_head(MEM_ROOT *mem_root_arg, sp_package *parent,
   m_backpatch_goto.empty();
   m_cont_backpatch.empty();
   m_lex.empty();
-  my_init_dynamic_array(&m_instr, key_memory_sp_head_main_root,
+  my_init_dynamic_array(key_memory_sp_head_main_root, &m_instr,
                         sizeof(sp_instr *), 16, 8, MYF(0));
-  my_hash_init(&m_sptabs, system_charset_info, 0, 0, 0, sp_table_key, 0, 0,
-               key_memory_sp_head_main_root);
-  my_hash_init(&m_sroutines, system_charset_info, 0, 0, 0, sp_sroutine_key,
-               0, 0, key_memory_sp_head_main_root);
+  my_hash_init(key_memory_sp_head_main_root, &m_sptabs, system_charset_info, 0,
+               0, 0, sp_table_key, 0, 0);
+  my_hash_init(key_memory_sp_head_main_root, &m_sroutines, system_charset_info,
+               0, 0, 0, sp_sroutine_key, 0, 0);
 
   DBUG_VOID_RETURN;
 }
diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc
index a91d4cfb078..4da88a9e82c 100644
--- a/sql/sql_acl.cc
+++ b/sql/sql_acl.cc
@@ -2461,7 +2461,7 @@ static bool acl_load(THD *thd, const Grant_tables& tables)
     user.sort= get_magic_sort("hu", user.host.hostname, user.user.str);
     user.hostname_length= safe_strlen(user.host.hostname);
 
-    my_init_dynamic_array(&user.role_grants, key_memory_acl_mem,
+    my_init_dynamic_array(key_memory_acl_mem, &user.role_grants,
                           sizeof(ACL_ROLE *), 0, 8, MYF(0));
 
     user.account_locked= user_table.get_account_locked();
@@ -2480,7 +2480,7 @@ static bool acl_load(THD *thd, const Grant_tables& tables)
 
       ACL_ROLE *entry= new (&acl_memroot) ACL_ROLE(&user, &acl_memroot);
       entry->role_grants = user.role_grants;
-      my_init_dynamic_array(&entry->parent_grantee, key_memory_acl_mem,
+      my_init_dynamic_array(key_memory_acl_mem, &entry->parent_grantee,
                             sizeof(ACL_USER_BASE *), 0, 8, MYF(0));
       my_hash_insert(&acl_roles, (uchar *)entry);
 
@@ -2744,16 +2744,16 @@ bool acl_reload(THD *thd)
   old_acl_roles_mappings= acl_roles_mappings;
   old_acl_proxy_users= acl_proxy_users;
   old_acl_dbs= acl_dbs;
-  my_init_dynamic_array(&acl_hosts, key_memory_acl_mem, sizeof(ACL_HOST), 20, 50, MYF(0));
-  my_init_dynamic_array(&acl_users, key_memory_acl_mem, sizeof(ACL_USER), 50, 100, MYF(0));
+  my_init_dynamic_array(key_memory_acl_mem, &acl_hosts, sizeof(ACL_HOST), 20, 50, MYF(0));
+  my_init_dynamic_array(key_memory_acl_mem, &acl_users, sizeof(ACL_USER), 50, 100, MYF(0));
   acl_dbs.init(key_memory_acl_mem, 50, 100);
-  my_init_dynamic_array(&acl_proxy_users, key_memory_acl_mem, sizeof(ACL_PROXY_USER), 50, 100, MYF(0));
-  my_hash_init2(&acl_roles,50, &my_charset_utf8mb3_bin,
+  my_init_dynamic_array(key_memory_acl_mem, &acl_proxy_users, sizeof(ACL_PROXY_USER), 50, 100, MYF(0));
+  my_hash_init2(key_memory_acl_mem, &acl_roles,50, &my_charset_utf8mb3_bin,
                 0, 0, 0, (my_hash_get_key) acl_role_get_key, 0,
-                (void (*)(void *))free_acl_role, 0, key_memory_acl_mem);
-  my_hash_init2(&acl_roles_mappings, 50, &my_charset_utf8mb3_bin, 0, 0, 0,
-                (my_hash_get_key) acl_role_map_get_key, 0, 0, 0,
-                key_memory_acl_mem);
+                (void (*)(void *))free_acl_role, 0);
+  my_hash_init2(key_memory_acl_mem, &acl_roles_mappings, 50,
+                &my_charset_utf8mb3_bin, 0, 0, 0, (my_hash_get_key)
+                acl_role_map_get_key, 0, 0, 0);
   old_mem= acl_memroot;
   delete_dynamic(&acl_wild_hosts);
   my_hash_free(&acl_check_hosts);
@@ -3191,7 +3191,7 @@ ACL_USER::ACL_USER(THD *thd, const LEX_USER &combo,
   sort= get_magic_sort("hu", host.hostname, user.str);
   password_last_changed= thd->query_start();
   password_lifetime= -1;
-  my_init_dynamic_array(&role_grants, PSI_INSTRUMENT_ME, sizeof(ACL_USER *), 0, 8, MYF(0));
+  my_init_dynamic_array(PSI_INSTRUMENT_ME, &role_grants, sizeof(ACL_USER *), 0, 8, MYF(0));
 }
 
 
@@ -3276,9 +3276,9 @@ static void acl_insert_role(const char *rolename, privilege_t privileges)
 
   mysql_mutex_assert_owner(&acl_cache->lock);
   entry= new (&acl_memroot) ACL_ROLE(rolename, privileges, &acl_memroot);
-  my_init_dynamic_array(&entry->parent_grantee, key_memory_acl_mem,
+  my_init_dynamic_array(key_memory_acl_mem, &entry->parent_grantee,
                         sizeof(ACL_USER_BASE *), 0, 8, MYF(0));
-  my_init_dynamic_array(&entry->role_grants, key_memory_acl_mem,
+  my_init_dynamic_array(key_memory_acl_mem, &entry->role_grants,
                         sizeof(ACL_ROLE *), 0, 8, MYF(0));
 
   my_hash_insert(&acl_roles, (uchar *)entry);
@@ -3451,12 +3451,12 @@ exit:
 static void init_check_host(void)
 {
   DBUG_ENTER("init_check_host");
-  (void) my_init_dynamic_array(&acl_wild_hosts, key_memory_acl_mem,
+  (void) my_init_dynamic_array(key_memory_acl_mem, &acl_wild_hosts,
                                sizeof(struct acl_host_and_ip),
                                acl_users.elements, 1, MYF(0));
-  (void) my_hash_init(&acl_check_hosts,system_charset_info, acl_users.elements,
-                      0, 0, (my_hash_get_key) check_get_key, 0, 0,
-                      key_memory_acl_mem);
+  (void) my_hash_init(key_memory_acl_mem, &acl_check_hosts,system_charset_info,
+                      acl_users.elements, 0, 0,
+                      (my_hash_get_key) check_get_key, 0, 0);
   if (!allow_all_hosts)
   {
     for (uint i=0 ; i < acl_users.elements ; i++)
@@ -5101,9 +5101,8 @@ public:
   bool ok() { return privs != NO_ACL || cols != NO_ACL; }
   void init_hash()
   {
-    my_hash_init2(&hash_columns, 4, system_charset_info, 0, 0, 0,
-                  (my_hash_get_key) get_key_column, 0, 0, 0,
-                  key_memory_acl_memex);
+    my_hash_init2(key_memory_acl_memex, &hash_columns, 4, system_charset_info,
+                  0, 0, 0, (my_hash_get_key) get_key_column, 0, 0, 0);
   }
 };
 
@@ -5369,8 +5368,7 @@ column_hash_search(GRANT_TABLE *t, const char *cname, size_t length)
 {
   if (!my_hash_inited(&t->hash_columns))
     return (GRANT_COLUMN*) 0;
-  return (GRANT_COLUMN*) my_hash_search(&t->hash_columns,
-                                        (uchar*) cname, length);
+  return (GRANT_COLUMN*)my_hash_search(&t->hash_columns, (uchar*)cname, length);
 }
 
 
@@ -7652,22 +7650,21 @@ static bool grant_load(THD *thd,
 
   Sql_mode_instant_remove sms(thd, MODE_PAD_CHAR_TO_FULL_LENGTH);
 
-  (void) my_hash_init(&column_priv_hash, &my_charset_utf8mb3_bin,
-                      0,0,0, (my_hash_get_key) get_grant_table,
-                      (my_hash_free_key) free_grant_table, 0,
-                      key_memory_acl_memex);
-  (void) my_hash_init(&proc_priv_hash, &my_charset_utf8mb3_bin,
-                      0,0,0, (my_hash_get_key) get_grant_table, 0,0,
-                      key_memory_acl_memex);
-  (void) my_hash_init(&func_priv_hash, &my_charset_utf8mb3_bin,
-                      0,0,0, (my_hash_get_key) get_grant_table, 0,0,
-                      key_memory_acl_memex);
-  (void) my_hash_init(&package_spec_priv_hash, &my_charset_utf8mb3_bin,
-                      0,0,0, (my_hash_get_key) get_grant_table, 0,0,
-                      key_memory_acl_memex);
-  (void) my_hash_init(&package_body_priv_hash, &my_charset_utf8mb3_bin,
-                      0,0,0, (my_hash_get_key) get_grant_table, 0,0,
-                      key_memory_acl_memex);
+  (void) my_hash_init(key_memory_acl_memex, &column_priv_hash,
+                      &my_charset_utf8mb3_bin, 0,0,0, (my_hash_get_key)
+                      get_grant_table, (my_hash_free_key) free_grant_table, 0);
+  (void) my_hash_init(key_memory_acl_memex, &proc_priv_hash,
+                      &my_charset_utf8mb3_bin, 0,0,0, (my_hash_get_key)
+                      get_grant_table, 0,0);
+  (void) my_hash_init(key_memory_acl_memex, &func_priv_hash,
+                      &my_charset_utf8mb3_bin, 0,0,0, (my_hash_get_key)
+                      get_grant_table, 0,0);
+  (void) my_hash_init(key_memory_acl_memex, &package_spec_priv_hash,
+                      &my_charset_utf8mb3_bin, 0,0,0, (my_hash_get_key)
+                      get_grant_table, 0,0);
+  (void) my_hash_init(key_memory_acl_memex, &package_body_priv_hash,
+                      &my_charset_utf8mb3_bin, 0,0,0, (my_hash_get_key)
+                      get_grant_table, 0,0);
   init_sql_alloc(key_memory_acl_mem, &grant_memroot, ACL_ALLOC_BLOCK_SIZE, 0, MYF(0));
 
   t_table= tables_priv.table();
diff --git a/sql/sql_array.h b/sql/sql_array.h
index e0f2485e297..b6de1b18d78 100644
--- a/sql/sql_array.h
+++ b/sql/sql_array.h
@@ -122,13 +122,13 @@ public:
   Dynamic_array(MEM_ROOT *root, uint prealloc=16, uint increment=16)
   {
     void *init_buffer= alloc_root(root, sizeof(Elem) * prealloc);
-    init_dynamic_array2(&array, root->m_psi_key, sizeof(Elem), init_buffer,
+    init_dynamic_array2(root->m_psi_key, &array, sizeof(Elem), init_buffer,
                            prealloc, increment, MYF(0));
   }
 
   void init(PSI_memory_key psi_key, uint prealloc=16, uint increment=16)
   {
-    init_dynamic_array2(&array, psi_key, sizeof(Elem), 0, prealloc, increment, MYF(0));
+    init_dynamic_array2(psi_key, &array, sizeof(Elem), 0, prealloc, increment, MYF(0));
   }
 
   /**
diff --git a/sql/sql_audit.cc b/sql/sql_audit.cc
index 2fd92725194..3e9379ebe33 100644
--- a/sql/sql_audit.cc
+++ b/sql/sql_audit.cc
@@ -88,7 +88,7 @@ static my_bool acquire_plugins(THD *thd, plugin_ref plugin, void *arg)
   if (unlikely(!thd->audit_class_plugins.buffer))
   {
     /* specify some reasonable initialization defaults */
-    my_init_dynamic_array(&thd->audit_class_plugins, PSI_INSTRUMENT_ME,
+    my_init_dynamic_array(PSI_INSTRUMENT_ME, &thd->audit_class_plugins,
                           sizeof(plugin_ref), 16, 16, MYF(0));
   }
   
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 7fbd4fb3af1..4f0cf9babf4 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -571,7 +571,7 @@ bool flush_tables(THD *thd, flush_tables_type flag)
                                       MYF(MY_WME | MY_THREAD_SPECIFIC))))
     DBUG_RETURN(1);
 
-  my_init_dynamic_array(&collect_arg.shares, PSI_INSTRUMENT_ME,
+  my_init_dynamic_array(PSI_INSTRUMENT_ME, &collect_arg.shares,
                         sizeof(TABLE_SHARE*), 100, 100, MYF(0));
   collect_arg.flush_type= flag;
   if (tdc_iterate(thd, (my_hash_walk_action) tc_collect_used_shares,
diff --git a/sql/sql_cache.cc b/sql/sql_cache.cc
index 858a97b66be..00681ba8e2a 100644
--- a/sql/sql_cache.cc
+++ b/sql/sql_cache.cc
@@ -2727,8 +2727,8 @@ size_t Query_cache::init_cache()
 
   DUMP(this);
 
-  (void) my_hash_init(&queries, &my_charset_bin, def_query_hash_size, 0, 0,
-                      query_cache_query_get_key, 0, 0, key_memory_Query_cache);
+  (void) my_hash_init(key_memory_Query_cache, &queries, &my_charset_bin,
+                      def_query_hash_size, 0,0, query_cache_query_get_key,0,0);
 #ifndef FN_NO_CASE_SENSE
   /*
     If lower_case_table_names!=0 then db and table names are already 
@@ -2738,8 +2738,8 @@ size_t Query_cache::init_cache()
     lower_case_table_names == 0 then we should distinguish my_table
     and MY_TABLE cases and so again can use binary collation.
   */
-  (void) my_hash_init(&tables, &my_charset_bin, def_table_hash_size, 0, 0,
-                      query_cache_table_get_key, 0, 0, key_memory_Query_cache);
+  (void) my_hash_init(key_memory_Query_cache, &tables, &my_charset_bin,
+                      def_table_hash_size, 0,0, query_cache_table_get_key, 0,0);
 #else
   /*
     On windows, OS/2, MacOS X with HFS+ or any other case insensitive
@@ -2749,11 +2749,9 @@ size_t Query_cache::init_cache()
     file system) and so should use case insensitive collation for
     comparison.
   */
-  (void) my_hash_init(&tables,
-                      lower_case_table_names ? &my_charset_bin :
-                      files_charset_info,
-                      def_table_hash_size, 0, 0,query_cache_table_get_key,
-                      0, 0, PSI_INSTRUMENT_ME);
+  (void) my_hash_init(PSI_INSTRUMENT_ME, &tables, lower_case_table_names ?
+                      &my_charset_bin : files_charset_info,
+                      def_table_hash_size, 0,0, query_cache_table_get_key, 0,0);
 #endif
 
   queries_in_cache = 0;
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 8ea71b7bd8e..0325ef5cc9c 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -845,14 +845,13 @@ THD::THD(my_thread_id id, bool is_wsrep_applier)
   profiling.set_thd(this);
 #endif
   user_connect=(USER_CONN *)0;
-  my_hash_init(&user_vars, system_charset_info, USER_VARS_HASH_SIZE, 0, 0,
-               (my_hash_get_key) get_var_key,
-               (my_hash_free_key) free_user_var, HASH_THREAD_SPECIFIC,
-               key_memory_user_var_entry);
-  my_hash_init(&sequences, system_charset_info, SEQUENCES_HASH_SIZE, 0, 0,
-               (my_hash_get_key) get_sequence_last_key,
-               (my_hash_free_key) free_sequence_last, HASH_THREAD_SPECIFIC,
-               PSI_INSTRUMENT_ME);
+  my_hash_init(key_memory_user_var_entry, &user_vars, system_charset_info,
+               USER_VARS_HASH_SIZE, 0, 0, (my_hash_get_key) get_var_key,
+               (my_hash_free_key) free_user_var, HASH_THREAD_SPECIFIC);
+  my_hash_init(PSI_INSTRUMENT_ME, &sequences, system_charset_info,
+               SEQUENCES_HASH_SIZE, 0, 0, (my_hash_get_key)
+               get_sequence_last_key, (my_hash_free_key) free_sequence_last,
+               HASH_THREAD_SPECIFIC);
 
   sp_proc_cache= NULL;
   sp_func_cache= NULL;
@@ -861,7 +860,7 @@ THD::THD(my_thread_id id, bool is_wsrep_applier)
 
   /* For user vars replication*/
   if (opt_bin_log)
-    my_init_dynamic_array(&user_var_events, key_memory_user_var_entry,
+    my_init_dynamic_array(key_memory_user_var_entry, &user_var_events,
 			  sizeof(BINLOG_USER_VAR_EVENT *), 16, 16, MYF(0));
   else
     bzero((char*) &user_var_events, sizeof(user_var_events));
@@ -1443,14 +1442,13 @@ void THD::change_user(void)
 
   init();
   stmt_map.reset();
-  my_hash_init(&user_vars, system_charset_info, USER_VARS_HASH_SIZE, 0, 0,
-               (my_hash_get_key) get_var_key,
-               (my_hash_free_key) free_user_var, HASH_THREAD_SPECIFIC,
-               key_memory_user_var_entry);
-  my_hash_init(&sequences, system_charset_info, SEQUENCES_HASH_SIZE, 0, 0,
-               (my_hash_get_key) get_sequence_last_key,
-               (my_hash_free_key) free_sequence_last, HASH_THREAD_SPECIFIC,
-               key_memory_user_var_entry);
+  my_hash_init(key_memory_user_var_entry, &user_vars, system_charset_info,
+               USER_VARS_HASH_SIZE, 0, 0, (my_hash_get_key) get_var_key,
+               (my_hash_free_key) free_user_var, HASH_THREAD_SPECIFIC);
+  my_hash_init(key_memory_user_var_entry, &sequences, system_charset_info,
+               SEQUENCES_HASH_SIZE, 0, 0, (my_hash_get_key)
+               get_sequence_last_key, (my_hash_free_key) free_sequence_last,
+               HASH_THREAD_SPECIFIC);
   sp_cache_clear(&sp_proc_cache);
   sp_cache_clear(&sp_func_cache);
   sp_cache_clear(&sp_package_spec_cache);
@@ -3929,13 +3927,12 @@ Statement_map::Statement_map() :
     START_STMT_HASH_SIZE = 16,
     START_NAME_HASH_SIZE = 16
   };
-  my_hash_init(&st_hash, &my_charset_bin, START_STMT_HASH_SIZE, 0, 0,
-               get_statement_id_as_hash_key,
-               delete_statement_as_hash_key, MYF(0),
-               key_memory_prepared_statement_map);
-  my_hash_init(&names_hash, system_charset_info, START_NAME_HASH_SIZE, 0, 0,
+  my_hash_init(key_memory_prepared_statement_map, &st_hash, &my_charset_bin,
+               START_STMT_HASH_SIZE, 0, 0, get_statement_id_as_hash_key,
+               delete_statement_as_hash_key, MYF(0));
+  my_hash_init(key_memory_prepared_statement_map, &names_hash, system_charset_info, START_NAME_HASH_SIZE, 0, 0,
                (my_hash_get_key) get_stmt_name_hash_key,
-               NULL, MYF(0), key_memory_prepared_statement_map);
+               NULL, MYF(0));
 }
 
 
diff --git a/sql/sql_connect.cc b/sql/sql_connect.cc
index c02e595717d..d095697eb09 100644
--- a/sql/sql_connect.cc
+++ b/sql/sql_connect.cc
@@ -322,9 +322,9 @@ extern "C" void free_user(struct user_conn *uc)
 void init_max_user_conn(void)
 {
 #ifndef NO_EMBEDDED_ACCESS_CHECKS
-  my_hash_init(&hash_user_connections, system_charset_info, max_connections,
-               0, 0, (my_hash_get_key) get_key_conn,
-               (my_hash_free_key) free_user, 0, key_memory_user_conn);
+  my_hash_init(key_memory_user_conn, &hash_user_connections,
+               system_charset_info, max_connections, 0, 0, (my_hash_get_key)
+               get_key_conn, (my_hash_free_key) free_user, 0);
 #endif
 }
 
@@ -483,16 +483,16 @@ void init_user_stats(USER_STATS *user_stats,
 
 void init_global_user_stats(void)
 {
-  my_hash_init(&global_user_stats, system_charset_info, max_connections,
+  my_hash_init(PSI_INSTRUMENT_ME, &global_user_stats, system_charset_info, max_connections,
                0, 0, (my_hash_get_key) get_key_user_stats,
-               (my_hash_free_key) free_user_stats, 0, PSI_INSTRUMENT_ME);
+               (my_hash_free_key) free_user_stats, 0);
 }
 
 void init_global_client_stats(void)
 {
-  my_hash_init(&global_client_stats, system_charset_info, max_connections,
+  my_hash_init(PSI_INSTRUMENT_ME, &global_client_stats, system_charset_info, max_connections,
                0, 0, (my_hash_get_key) get_key_user_stats,
-               (my_hash_free_key) free_user_stats, 0, PSI_INSTRUMENT_ME);
+               (my_hash_free_key) free_user_stats, 0);
 }
 
 extern "C" uchar *get_key_table_stats(TABLE_STATS *table_stats, size_t *length,
@@ -509,9 +509,9 @@ extern "C" void free_table_stats(TABLE_STATS* table_stats)
 
 void init_global_table_stats(void)
 {
-  my_hash_init(&global_table_stats, system_charset_info, max_connections,
-               0, 0, (my_hash_get_key) get_key_table_stats,
-               (my_hash_free_key) free_table_stats, 0, PSI_INSTRUMENT_ME);
+  my_hash_init(PSI_INSTRUMENT_ME, &global_table_stats, system_charset_info,
+               max_connections, 0, 0, (my_hash_get_key) get_key_table_stats,
+               (my_hash_free_key) free_table_stats, 0);
 }
 
 extern "C" uchar *get_key_index_stats(INDEX_STATS *index_stats, size_t *length,
@@ -528,9 +528,9 @@ extern "C" void free_index_stats(INDEX_STATS* index_stats)
 
 void init_global_index_stats(void)
 {
-  my_hash_init(&global_index_stats, system_charset_info, max_connections,
-               0, 0, (my_hash_get_key) get_key_index_stats,
-               (my_hash_free_key) free_index_stats, 0, PSI_INSTRUMENT_ME);
+  my_hash_init(PSI_INSTRUMENT_ME, &global_index_stats, system_charset_info,
+               max_connections, 0, 0, (my_hash_get_key) get_key_index_stats,
+               (my_hash_free_key) free_index_stats, 0);
 }
 
 
diff --git a/sql/sql_db.cc b/sql/sql_db.cc
index 2698b29d787..3ad7bea5661 100644
--- a/sql/sql_db.cc
+++ b/sql/sql_db.cc
@@ -186,9 +186,9 @@ bool my_dboptions_cache_init(void)
   if (!dboptions_init)
   {
     dboptions_init= 1;
-    error= my_hash_init(&dboptions, table_alias_charset,
-                        32, 0, 0, (my_hash_get_key) dboptions_get_key,
-                        free_dbopt, 0, key_memory_dboptions_hash);
+    error= my_hash_init(key_memory_dboptions_hash, &dboptions,
+                        table_alias_charset, 32, 0, 0, (my_hash_get_key)
+                        dboptions_get_key, free_dbopt, 0);
   }
   return error;
 }
@@ -218,9 +218,8 @@ void my_dbopt_cleanup(void)
 {
   mysql_rwlock_wrlock(&LOCK_dboptions);
   my_hash_free(&dboptions);
-  my_hash_init(&dboptions, table_alias_charset,
-               32, 0, 0, (my_hash_get_key) dboptions_get_key,
-               free_dbopt, 0, key_memory_dboptions_hash);
+  my_hash_init(key_memory_dboptions_hash, &dboptions, table_alias_charset, 32,
+               0, 0, (my_hash_get_key) dboptions_get_key, free_dbopt, 0);
   mysql_rwlock_unlock(&LOCK_dboptions);
 }
 
diff --git a/sql/sql_handler.cc b/sql/sql_handler.cc
index 1427d3a17b6..d7adc35c5c9 100644
--- a/sql/sql_handler.cc
+++ b/sql/sql_handler.cc
@@ -289,11 +289,11 @@ bool mysql_ha_open(THD *thd, TABLE_LIST *tables, SQL_HANDLER *reopen)
     /*
       HASH entries are of type SQL_HANDLER
     */
-    if (my_hash_init(&thd->handler_tables_hash, &my_charset_latin1,
-                     HANDLER_TABLES_HASH_SIZE, 0, 0,
-                     (my_hash_get_key) mysql_ha_hash_get_key,
-                     (my_hash_free_key) mysql_ha_hash_free, 0,
-                     key_memory_THD_handler_tables_hash))
+    if (my_hash_init(key_memory_THD_handler_tables_hash,
+                     &thd->handler_tables_hash, &my_charset_latin1,
+                     HANDLER_TABLES_HASH_SIZE, 0, 0, (my_hash_get_key)
+                     mysql_ha_hash_get_key, (my_hash_free_key)
+                     mysql_ha_hash_free, 0))
     {
       DBUG_PRINT("exit",("ERROR"));
       DBUG_RETURN(TRUE);
diff --git a/sql/sql_hset.h b/sql/sql_hset.h
index 6af6e1df371..b3d8165f6f6 100644
--- a/sql/sql_hset.h
+++ b/sql/sql_hset.h
@@ -43,8 +43,8 @@ public:
            size_t key_offset, size_t key_length, my_hash_get_key get_key,
            void (*free_element)(void*), uint flags)
   {
-    my_hash_init(&m_hash, charset, default_array_elements, key_offset,
-                 key_length, get_key, free_element, flags, psi_key);
+    my_hash_init(psi_key, &m_hash, charset, default_array_elements, key_offset,
+                 key_length, get_key, free_element, flags);
   }
   /**
     Destroy the hash by freeing the buckets table. Does
@@ -65,8 +65,8 @@ public:
   */
   bool insert(T *value)
   {
-    my_hash_init_opt(&m_hash, m_hash.charset, START_SIZE, 0, 0,
-                     m_hash.get_key, 0, HASH_UNIQUE, m_hash.array.m_psi_key);
+    my_hash_init_opt(m_hash.array.m_psi_key, &m_hash, m_hash.charset,
+                     START_SIZE, 0, 0, m_hash.get_key, 0, HASH_UNIQUE);
     return my_hash_insert(&m_hash, reinterpret_cast<const uchar*>(value));
   }
   bool remove(T *value)
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
index 0420e449ed0..da255c2701d 100644
--- a/sql/sql_lex.cc
+++ b/sql/sql_lex.cc
@@ -3826,13 +3826,12 @@ LEX::LEX()
     default_used(0), is_lex_started(0), limit_rows_examined_cnt(ULONGLONG_MAX)
 {
 
-  init_dynamic_array2(&plugins, PSI_INSTRUMENT_ME,
-                      sizeof(plugin_ref), plugins_static_buffer,
-                      INITIAL_LEX_PLUGIN_LIST_SIZE,
+  init_dynamic_array2(PSI_INSTRUMENT_ME, &plugins, sizeof(plugin_ref),
+                      plugins_static_buffer, INITIAL_LEX_PLUGIN_LIST_SIZE,
                       INITIAL_LEX_PLUGIN_LIST_SIZE, 0);
   reset_query_tables_list(TRUE);
   mi.init();
-  init_dynamic_array2(&delete_gtid_domain, PSI_INSTRUMENT_ME, sizeof(uint32),
+  init_dynamic_array2(PSI_INSTRUMENT_ME, &delete_gtid_domain, sizeof(uint32),
                       gtid_domain_static_buffer,
                       initial_gtid_domain_buffer_size,
                       initial_gtid_domain_buffer_size, 0);
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index f5611cb6cb0..b2f0272a7d2 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -510,11 +510,11 @@ struct LEX_MASTER_INFO
   void init()
   {
     bzero(this, sizeof(*this));
-    my_init_dynamic_array(&repl_ignore_server_ids, PSI_INSTRUMENT_ME,
+    my_init_dynamic_array(PSI_INSTRUMENT_ME, &repl_ignore_server_ids,
                           sizeof(::server_id), 0, 16, MYF(0));
-    my_init_dynamic_array(&repl_do_domain_ids, PSI_INSTRUMENT_ME,
+    my_init_dynamic_array(PSI_INSTRUMENT_ME, &repl_do_domain_ids,
                           sizeof(ulong), 0, 16, MYF(0));
-    my_init_dynamic_array(&repl_ignore_domain_ids, PSI_INSTRUMENT_ME,
+    my_init_dynamic_array(PSI_INSTRUMENT_ME, &repl_ignore_domain_ids,
                           sizeof(ulong), 0, 16, MYF(0));
     sql_delay= -1;
   }
diff --git a/sql/sql_plugin.cc b/sql/sql_plugin.cc
index 1555755bb36..478fd4b4335 100644
--- a/sql/sql_plugin.cc
+++ b/sql/sql_plugin.cc
@@ -1608,26 +1608,24 @@ int plugin_init(int *argc, char **argv, int flags)
   init_alloc_root(key_memory_plugin_mem_root, &plugin_vars_mem_root, 4096, 4096, MYF(0));
   init_alloc_root(PSI_NOT_INSTRUMENTED, &tmp_root, 4096, 4096, MYF(0));
 
-  if (my_hash_init(&bookmark_hash, &my_charset_bin, 32, 0, 0,
-                   get_bookmark_hash_key, NULL, HASH_UNIQUE,
-                   key_memory_plugin_bookmark))
+  if (my_hash_init(key_memory_plugin_bookmark, &bookmark_hash, &my_charset_bin, 32, 0, 0,
+                   get_bookmark_hash_key, NULL, HASH_UNIQUE))
       goto err;
 
   /*
     The 80 is from 2016-04-27 when we had 71 default plugins
     Big enough to avoid many mallocs even in future
   */
-  if (my_init_dynamic_array(&plugin_dl_array, key_memory_mysql_plugin_dl,
+  if (my_init_dynamic_array(key_memory_mysql_plugin_dl, &plugin_dl_array,
                             sizeof(struct st_plugin_dl *), 16, 16, MYF(0)) ||
-      my_init_dynamic_array(&plugin_array, key_memory_mysql_plugin,
+      my_init_dynamic_array(key_memory_mysql_plugin, &plugin_array,
                             sizeof(struct st_plugin_int *), 80, 32, MYF(0)))
     goto err;
 
   for (i= 0; i < MYSQL_MAX_PLUGIN_TYPE_NUM; i++)
   {
-    if (my_hash_init(&plugin_hash[i], system_charset_info, 32, 0, 0,
-                     get_plugin_hash_key, NULL, HASH_UNIQUE,
-                     key_memory_plugin_mem_root))
+    if (my_hash_init(key_memory_plugin_mem_root, &plugin_hash[i], system_charset_info, 32, 0, 0,
+                     get_plugin_hash_key, NULL, HASH_UNIQUE))
       goto err;
   }
 
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index c9f40d33b90..397b5b988b2 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -6769,7 +6769,7 @@ update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,
   /* set a barrier for the array of SARGABLE_PARAM */
   (*sargables)[0].field= 0; 
 
-  if (my_init_dynamic_array2(keyuse, thd->mem_root->m_psi_key, sizeof(KEYUSE),
+  if (my_init_dynamic_array2(thd->mem_root->m_psi_key, keyuse, sizeof(KEYUSE),
                              thd->alloc(sizeof(KEYUSE) * 20), 20, 64,
                              MYF(MY_THREAD_SPECIFIC)))
     DBUG_RETURN(TRUE);
@@ -24043,9 +24043,9 @@ static int remove_dup_with_hash_index(THD *thd, TABLE *table,
   for (ptr= first_field, field_length=field_lengths ; *ptr ; ptr++)
     (*field_length++)= (*ptr)->sort_length();
 
-  if (my_hash_init(&hash, &my_charset_bin, (uint) file->stats.records, 0,
-                   key_length, (my_hash_get_key) 0, 0, 0,
-                   key_memory_hash_index_key_buffer))
+  if (my_hash_init(key_memory_hash_index_key_buffer, &hash, &my_charset_bin,
+                   (uint) file->stats.records, 0, key_length,
+                   (my_hash_get_key) 0, 0, 0))
   {
     my_free(key_buffer);
     DBUG_RETURN(1);
@@ -27856,7 +27856,7 @@ JOIN::reoptimize(Item *added_where, table_map join_tables,
     reset_query_plan();
 
   if (!keyuse.buffer &&
-      my_init_dynamic_array(&keyuse, thd->mem_root->m_psi_key, sizeof(KEYUSE),
+      my_init_dynamic_array(thd->mem_root->m_psi_key, &keyuse, sizeof(KEYUSE),
                             20, 64, MYF(MY_THREAD_SPECIFIC)))
   {
     delete_dynamic(&added_keyuse);
diff --git a/sql/sql_servers.cc b/sql/sql_servers.cc
index 654e2ee7aac..1d12e95bbbb 100644
--- a/sql/sql_servers.cc
+++ b/sql/sql_servers.cc
@@ -158,9 +158,8 @@ bool servers_init(bool dont_read_servers_table)
     DBUG_RETURN(TRUE);
 
   /* initialise our servers cache */
-  if (my_hash_init(&servers_cache, system_charset_info, 32, 0, 0,
-                   (my_hash_get_key) servers_cache_get_key, 0, 0,
-                   key_memory_servers))
+  if (my_hash_init(key_memory_servers, &servers_cache, system_charset_info, 32, 0, 0,
+                   (my_hash_get_key) servers_cache_get_key, 0, 0))
   {
     return_val= TRUE; /* we failed, out of memory? */
     goto end;
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 0efa91293b2..bbb7dae7250 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -571,7 +571,7 @@ static bool skip_ignored_dir_check= TRUE;
 bool
 ignore_db_dirs_init()
 {
-  return my_init_dynamic_array(&ignore_db_dirs_array, key_memory_ignored_db,
+  return my_init_dynamic_array(key_memory_ignored_db, &ignore_db_dirs_array,
                                sizeof(LEX_STRING *), 0, 0, MYF(0));
 }
 
@@ -749,12 +749,10 @@ ignore_db_dirs_process_additions()
 
   skip_ignored_dir_check= TRUE;
 
-  if (my_hash_init(&ignore_db_dirs_hash, 
-                   lower_case_table_names ?
-                     character_set_filesystem : &my_charset_bin,
-                   0, 0, 0, db_dirs_hash_get_key,
-                   dispose_db_dir,
-                   HASH_UNIQUE, key_memory_ignored_db))
+  if (my_hash_init(key_memory_ignored_db, &ignore_db_dirs_hash,
+                   lower_case_table_names ?  character_set_filesystem :
+                   &my_charset_bin, 0, 0, 0, db_dirs_hash_get_key,
+                   dispose_db_dir, HASH_UNIQUE))
     return true;
 
   /* len starts from 1 because of the terminating zero. */
@@ -3365,7 +3363,7 @@ int add_status_vars(SHOW_VAR *list)
   if (status_vars_inited)
     mysql_rwlock_wrlock(&LOCK_all_status_vars);
   if (!all_status_vars.buffer && // array is not allocated yet - do it now
-      my_init_dynamic_array(&all_status_vars, PSI_INSTRUMENT_ME,
+      my_init_dynamic_array(PSI_INSTRUMENT_ME, &all_status_vars,
                             sizeof(SHOW_VAR), 250, 50, MYF(0)))
   {
     res= 1;
diff --git a/sql/sql_test.cc b/sql/sql_test.cc
index c14f15908b1..ffd42599527 100644
--- a/sql/sql_test.cc
+++ b/sql/sql_test.cc
@@ -466,10 +466,9 @@ static void display_table_locks(void)
   void *saved_base;
   DYNAMIC_ARRAY saved_table_locks;
 
-  (void) my_init_dynamic_array(&saved_table_locks,
-                               key_memory_locked_thread_list,
-                               sizeof(TABLE_LOCK_INFO), tc_records() + 20, 50,
-                               MYF(0));
+  (void) my_init_dynamic_array(key_memory_locked_thread_list,
+                               &saved_table_locks, sizeof(TABLE_LOCK_INFO),
+                               tc_records() + 20, 50, MYF(0));
   mysql_mutex_lock(&THR_LOCK_lock);
   for (list= thr_lock_thread_list; list; list= list_rest(list))
   {
diff --git a/sql/sql_udf.cc b/sql/sql_udf.cc
index 38328c91db3..4da85de7852 100644
--- a/sql/sql_udf.cc
+++ b/sql/sql_udf.cc
@@ -167,8 +167,8 @@ void udf_init()
   init_sql_alloc(key_memory_udf_mem, &mem, UDF_ALLOC_BLOCK_SIZE, 0, MYF(0));
   THD *new_thd = new THD(0);
   if (!new_thd ||
-      my_hash_init(&udf_hash,system_charset_info,32,0,0,get_hash_key, NULL, 0,
-                   key_memory_udf_mem))
+      my_hash_init(key_memory_udf_mem,
+                   &udf_hash,system_charset_info,32,0,0,get_hash_key, NULL, 0))
   {
     sql_print_error("Can't allocate memory for udf structures");
     my_hash_free(&udf_hash);
diff --git a/sql/table.cc b/sql/table.cc
index cfd2358cd20..8c4c562647a 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -2198,10 +2198,9 @@ int TABLE_SHARE::init_from_binary_frm_image(THD *thd, bool write,
 
   use_hash= share->fields >= MAX_FIELDS_BEFORE_HASH;
   if (use_hash)
-    use_hash= !my_hash_init(&share->name_hash, system_charset_info,
-                            share->fields, 0, 0,
-                            (my_hash_get_key) get_field_name, 0, 0,
-                            PSI_INSTRUMENT_ME);
+    use_hash= !my_hash_init(PSI_INSTRUMENT_ME, &share->name_hash,
+                            system_charset_info, share->fields, 0, 0,
+                            (my_hash_get_key) get_field_name, 0, 0);
 
   if (share->mysql_version >= 50700 && share->mysql_version < 100000 &&
       vcol_screen_length)
diff --git a/sql/table_cache.cc b/sql/table_cache.cc
index 5578bd59966..d8786f72244 100644
--- a/sql/table_cache.cc
+++ b/sql/table_cache.cc
@@ -1258,8 +1258,9 @@ int tdc_iterate(THD *thd, my_hash_walk_action action, void *argument,
   if (no_dups)
   {
     init_alloc_root(PSI_INSTRUMENT_ME, &no_dups_argument.root, 4096, 4096, MYF(alloc_flags));
-    my_hash_init(&no_dups_argument.hash, &my_charset_bin, tdc_records(), 0, 0,
-                 eliminate_duplicates_get_key, 0, hash_flags, PSI_INSTRUMENT_ME);
+    my_hash_init(PSI_INSTRUMENT_ME, &no_dups_argument.hash, &my_charset_bin,
+                 tdc_records(), 0, 0, eliminate_duplicates_get_key, 0,
+                 hash_flags);
     no_dups_argument.action= action;
     no_dups_argument.argument= argument;
     action= (my_hash_walk_action) eliminate_duplicates;
diff --git a/sql/tztime.cc b/sql/tztime.cc
index a38bb2b0fc8..72db37fde9c 100644
--- a/sql/tztime.cc
+++ b/sql/tztime.cc
@@ -1625,16 +1625,14 @@ my_tz_init(THD *org_thd, const char *default_tzname, my_bool bootstrap)
   thd->store_globals();
 
   /* Init all memory structures that require explicit destruction */
-  if (my_hash_init(&tz_names, &my_charset_latin1, 20,
-                   0, 0, (my_hash_get_key) my_tz_names_get_key, 0, 0,
-                   key_memory_tz_storage))
+  if (my_hash_init(key_memory_tz_storage, &tz_names, &my_charset_latin1, 20, 0,
+                   0, (my_hash_get_key) my_tz_names_get_key, 0, 0))
   {
     sql_print_error("Fatal error: OOM while initializing time zones");
     goto end;
   }
-  if (my_hash_init(&offset_tzs, &my_charset_latin1, 26, 0, 0,
-                   (my_hash_get_key)my_offset_tzs_get_key, 0, 0,
-                   key_memory_tz_storage))
+  if (my_hash_init(key_memory_tz_storage, &offset_tzs, &my_charset_latin1, 26,
+                   0, 0, (my_hash_get_key)my_offset_tzs_get_key, 0, 0))
   {
     sql_print_error("Fatal error: OOM while initializing time zones");
     my_hash_free(&tz_names);
diff --git a/sql/uniques.cc b/sql/uniques.cc
index 6b486e48444..4e327a4cc09 100644
--- a/sql/uniques.cc
+++ b/sql/uniques.cc
@@ -93,7 +93,7 @@ Unique::Unique(qsort_cmp2 comp_func, void * comp_func_fixed_arg,
   init_tree(&tree, (max_in_memory_size / 16), 0, size, comp_func,
             NULL, comp_func_fixed_arg, MYF(MY_THREAD_SPECIFIC));
   /* If the following fail's the next add will also fail */
-  my_init_dynamic_array(&file_ptrs, PSI_INSTRUMENT_ME, sizeof(Merge_chunk), 16,
+  my_init_dynamic_array(PSI_INSTRUMENT_ME, &file_ptrs, sizeof(Merge_chunk), 16,
                         16, MYF(MY_THREAD_SPECIFIC));
   /*
     If you change the following, change it in get_max_elements function, too.