[RP007] Changes dict_sys->mutex to rw_lock for innodb_purge_threads scaling performance

Comparing user threads DML CPU scale performance, innodb_purge_threads seems not to scale enough. dict_sys->mutex around dd_table_open_on_id() causes contention among purge_threads, and the History list length might growing huge. Changes dict_sys->mutex to dict_sys->lock and base operation is changed to x-lock. Only for just only HASH_SEARCH of dict_sys->table_id_hash, uses s-lock to minimize contention.

Author: buildup-db

MYSQL_VERSION

@@ -3,4 +3,4 @@ MYSQL_VERSION_MINOR=0
 MYSQL_VERSION_PATCH=42
 MYSQL_VERSION_EXTRA=
 MYSQL_VERSION_STABILITY="LTS"
-MYSQL_RP_REVISION="-RP006"
+MYSQL_RP_REVISION="-RP007"

storage/innobase/clone/clone0api.cc

@@ -2763,17 +2763,19 @@ static int clone_init_tablespaces(THD *thd) {
 
  /* Acquire dict mutex to prevent race against concurrent DML trying to
  load the space. */
- IB_mutex_guard sys_mutex(&dict_sys->mutex, UT_LOCATION_HERE);
+ dict_sys_mutex_enter();
 
  /* Re-check if space exists after acquiring dict sys mutex. Concurrent
  DML could have already loaded the space. Space name is already adjusted
  in previous call. */
  if (fil_space_exists_in_mem(space_id, space_name, false, false)) {
+ dict_sys_mutex_exit();
  continue;
  }
 
  auto err = fil_ibd_open(false, FIL_TYPE_TABLESPACE, space_id, space_flags,
  space_name, filename.c_str(), false, false);
+ dict_sys_mutex_exit();
 
  if (err != DB_SUCCESS) {
  ib::error(ER_IB_CLONE_INTERNAL)

storage/innobase/dict/dict0crea.cc

@@ -1,6 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1996, 2025, Oracle and/or its affiliates.
+Copyright (c) 2025, buildup-db.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License, version 2.0, as published by the
@@ -648,9 +649,11 @@ void dict_table_assign_new_id(dict_table_t *table) {
 @param[in] space_discarded true if space is discarded
 @param[in] in_flags space flags to use when space_discarded is true
 @param[in] is_create true when creating SDI index
+@param[in] has_x_lock false when holding s-lock of dict_sys
 @return in-memory index structure for tablespace dictionary or NULL */
 dict_index_t *dict_sdi_create_idx_in_mem(space_id_t space, bool space_discarded,
- uint32_t in_flags, bool is_create) {
+ uint32_t in_flags, bool is_create,
+ bool has_x_lock) {
  uint32_t flags = space_discarded ? in_flags : fil_space_get_flags(space);
 
  /* This means the tablespace is evicted from cache */
@@ -660,7 +663,11 @@ dict_index_t *dict_sdi_create_idx_in_mem(space_id_t space, bool space_discarded,
 
  ut_ad(fsp_flags_is_valid(flags));
 
- dict_sys_mutex_exit();
+ if (has_x_lock) {
+ dict_sys_mutex_exit();
+ } else {
+ dict_sys_s_unlock();
+ }
 
  rec_format_t rec_format;
 

storage/innobase/dict/dict0dd.cc

@@ -1,6 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2017, 2025, Oracle and/or its affiliates.
+Copyright (c) 2025, buildup-db.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License, version 2.0, as published by the
@@ -399,7 +400,7 @@ int dd_table_open_on_dd_obj(THD *thd, dd::cache::Dictionary_client *client,
 
  ut_ad(table_id != dd::INVALID_OBJECT_ID);
 
- dict_sys_mutex_enter();
+ dict_sys_s_lock();
 
  HASH_SEARCH(id_hash, dict_sys->table_id_hash, hash_value, dict_table_t *,
  table, ut_ad(table->cached), table->id == table_id);
@@ -408,7 +409,7 @@ int dd_table_open_on_dd_obj(THD *thd, dd::cache::Dictionary_client *client,
  table->acquire();
  }
 
- dict_sys_mutex_exit();
+ dict_sys_s_unlock();
 
  if (table != nullptr) {
  return 0;
@@ -697,17 +698,19 @@ hold Shared MDL lock on it.
 table_id was found) mdl=NULL if we are resurrecting table IX locks in recovery
 @param[in] dict_locked dict_sys mutex is held
 @param[in] check_corruption check if the table is corrupted or not.
+@param[in] for_modification if false, dict_locked means s-lock.
 @return table
 @retval NULL if the table does not exist or cannot be opened */
 dict_table_t *dd_table_open_on_id(table_id_t table_id, THD *thd,
  MDL_ticket **mdl, bool dict_locked,
- bool check_corruption) {
+ bool check_corruption,
+ bool for_modification) {
  dict_table_t *ib_table;
  const auto hash_value = ut::hash_uint64(table_id);
  char full_name[MAX_FULL_NAME_LEN + 1];
 
  if (!dict_locked) {
- dict_sys_mutex_enter();
+ dict_sys_s_lock();
  }
 
  HASH_SEARCH(id_hash, dict_sys->table_id_hash, hash_value, dict_table_t *,
@@ -721,12 +724,12 @@ dict_table_t *dd_table_open_on_id(table_id_t table_id, THD *thd,
  space_id_t space_id = dict_sdi_get_space_id(table_id);
 
  /* Create in-memory table object for SDI table */
- dict_index_t *sdi_index =
- dict_sdi_create_idx_in_mem(space_id, false, 0, false);
+ dict_index_t *sdi_index = dict_sdi_create_idx_in_mem(
+ space_id, false, 0, false, dict_locked && for_modification);
 
  if (sdi_index == nullptr) {
  if (!dict_locked) {
- dict_sys_mutex_exit();
+ dict_sys_s_unlock();
  }
  return nullptr;
  }
@@ -737,15 +740,24 @@ dict_table_t *dd_table_open_on_id(table_id_t table_id, THD *thd,
  ib_table->acquire();
 
  if (!dict_locked) {
+ /* dict_sdi_create_idx_in_mem() re-obtains with x-lock. */
  dict_sys_mutex_exit();
  }
  } else {
- dict_sys_mutex_exit();
+ if (dict_locked && for_modification) {
+ dict_sys_mutex_exit();
+ } else {
+ dict_sys_s_unlock();
+ }
 
  ib_table = dd_table_open_on_id_low(thd, mdl, table_id);
 
  if (dict_locked) {
- dict_sys_mutex_enter();
+ if (for_modification) {
+ dict_sys_mutex_enter();
+ } else {
+ dict_sys_s_lock();
+ }
  }
  }
 #else /* !UNIV_HOTBACKUP */
@@ -762,7 +774,7 @@ dict_table_t *dd_table_open_on_id(table_id_t table_id, THD *thd,
  }
 
  if (!dict_locked) {
- dict_sys_mutex_exit();
+ dict_sys_s_unlock();
  }
  } else {
  for (;;) {
@@ -778,12 +790,20 @@ dict_table_t *dd_table_open_on_id(table_id_t table_id, THD *thd,
 
  ut_ad(!ib_table->is_temporary());
 
- dict_sys_mutex_exit();
+ if (dict_locked && for_modification) {
+ dict_sys_mutex_exit();
+ } else {
+ dict_sys_s_unlock();
+ }
 
 #ifndef UNIV_HOTBACKUP
  if (db_str.empty() || tbl_str.empty()) {
  if (dict_locked) {
- dict_sys_mutex_enter();
+ if (for_modification) {
+ dict_sys_mutex_enter();
+ } else {
+ dict_sys_s_lock();
+ }
  }
  return nullptr;
  }
@@ -797,7 +817,11 @@ dict_table_t *dd_table_open_on_id(table_id_t table_id, THD *thd,
 #endif /* !UNIV_HOTBACKUP */
 
  /* Re-lookup the table after acquiring MDL. */
- dict_sys_mutex_enter();
+ if (dict_locked && for_modification) {
+ dict_sys_mutex_enter();
+ } else {
+ dict_sys_s_lock();
+ }
 
  HASH_SEARCH(id_hash, dict_sys->table_id_hash, hash_value, dict_table_t *,
  ib_table, ut_ad(ib_table->cached), ib_table->id == table_id);
@@ -832,7 +856,11 @@ dict_table_t *dd_table_open_on_id(table_id_t table_id, THD *thd,
  }
  }
 
- dict_sys_mutex_exit();
+ if (dict_locked && for_modification) {
+ dict_sys_mutex_exit();
+ } else {
+ dict_sys_s_unlock();
+ }
  break;
  }
 
@@ -857,11 +885,16 @@ dict_table_t *dd_table_open_on_id(table_id_t table_id, THD *thd,
 #endif /* !UNIV_HOTBACKUP */
 
  if (dict_locked) {
- dict_sys_mutex_enter();
+ if (for_modification) {
+ dict_sys_mutex_enter();
+ } else {
+ dict_sys_s_lock();
+ }
  }
  }
 
- ut_ad(dict_locked == dict_sys_mutex_own());
+ ut_ad(dict_locked ==
+ (for_modification ? dict_sys_mutex_own() : dict_sys_s_lock_own()));
 
  return ib_table;
 }

storage/innobase/dict/dict0dict.cc

@@ -2,6 +2,7 @@
 
 Copyright (c) 1996, 2025, Oracle and/or its affiliates.
 Copyright (c) 2012, Facebook Inc.
+Copyright (c) 2025, buildup-db.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License, version 2.0, as published by the
@@ -499,19 +500,18 @@ void dict_table_close(dict_table_t *table, bool dict_locked, bool try_drop) {
 #ifdef UNIV_DEBUG
  if (!table->is_intrinsic()) {
  /* This is now only for validation in debug mode */
+ /* Cannot execute the validation when s-locked */
  if (!dict_locked) {
  dict_sys_mutex_enter();
- }
 
- ut_ad(dict_lru_validate());
+  ut_ad(dict_lru_validate());
 
- if (table->can_be_evicted) {
- ut_ad(dict_lru_find_table(table));
- } else {
- ut_ad(dict_non_lru_find_table(table));
- }
+  if (table->can_be_evicted) {
+  ut_ad(dict_lru_find_table(table));
+  } else {
+  ut_ad(dict_non_lru_find_table(table));
+  }
 
- if (!dict_locked) {
  dict_sys_mutex_exit();
  }
  }
@@ -1016,7 +1016,7 @@ void dict_init(void) {
  UT_LIST_INIT(dict_sys->table_LRU);
  UT_LIST_INIT(dict_sys->table_non_LRU);
 
- mutex_create(LATCH_ID_DICT_SYS, &dict_sys->mutex);
+ rw_lock_create(dict_sys_mutex_key, &dict_sys->lock, LATCH_ID_DICT_SYS);
 
  dict_sys->table_hash = ut::new_<hash_table_t>(
  buf_pool_get_curr_size() / (DICT_POOL_PER_TABLE_HASH * UNIV_WORD_SIZE));
@@ -2777,7 +2777,7 @@ void dict_index_remove_from_cache(dict_table_t *table, /*!< in/out: table */
 
 std::vector<table_id_t> dict_get_all_table_ids() {
  std::vector<table_id_t> ids;
- mutex_enter(&dict_sys->mutex);
+ rw_lock_s_lock(&dict_sys->lock, UT_LOCATION_HERE);
  ids.reserve(dict_sys->table_LRU.get_length() +
  dict_sys->table_non_LRU.get_length());
  for (dict_table_t *table : dict_sys->table_LRU) {
@@ -2786,7 +2786,7 @@ std::vector<table_id_t> dict_get_all_table_ids() {
  for (dict_table_t *table : dict_sys->table_non_LRU) {
  ids.push_back(table->id);
  }
- mutex_exit(&dict_sys->mutex);
+ rw_lock_s_unlock(&dict_sys->lock);
  return ids;
 }
 

storage/innobase/handler/handler0alter.cc

@@ -10949,10 +10949,10 @@ int ha_innopart::exchange_partition_low(uint part_id, dd::Table *part_table,
  dict_table_t *swap;
  const auto hash_value = ut::hash_uint64(table_id);
 
- dict_sys_mutex_enter();
+ dict_sys_s_lock();
  HASH_SEARCH(id_hash, dict_sys->table_id_hash, hash_value, dict_table_t *,
  swap, ut_ad(swap->cached), swap->id == table_id);
- dict_sys_mutex_exit();
+ dict_sys_s_unlock();
  ut_ad(swap != nullptr);
  ut_ad(swap->n_ref_count == 1);
 

storage/innobase/include/dict0crea.h

@@ -1,6 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1996, 2025, Oracle and/or its affiliates.
+Copyright (c) 2025, buildup-db.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License, version 2.0, as published by the
@@ -139,9 +140,11 @@ struct tab_node_t {
 @param[in] space_discarded true if space is discarded
 @param[in] in_flags space flags to use when space_discarded is true
 @param[in] is_create true when creating SDI index
+@param[in] has_x_lock false when holding s-lock of dict_sys
 @return in-memory index structure for tablespace dictionary or NULL */
 dict_index_t *dict_sdi_create_idx_in_mem(space_id_t space, bool space_discarded,
- uint32_t in_flags, bool is_create);
+ uint32_t in_flags, bool is_create,
+ bool has_x_lock = true);
 
 /* Index create node struct */
 

storage/innobase/include/dict0dd.h

@@ -1,6 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2015, 2025, Oracle and/or its affiliates.
+Copyright (c) 2025, buildup-db.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License, version 2.0, as published by the
@@ -1163,11 +1164,13 @@ hold Shared MDL lock on it.
 table_id was found) mdl=NULL if we are resurrecting table IX locks in recovery
 @param[in] dict_locked dict_sys mutex is held
 @param[in] check_corruption check if the table is corrupted or not.
+@param[in] for_modification if false, dict_locked means s-lock.
 @return table
 @retval NULL if the table does not exist or cannot be opened */
 dict_table_t *dd_table_open_on_id(table_id_t table_id, THD *thd,
  MDL_ticket **mdl, bool dict_locked,
- bool check_corruption);
+ bool check_corruption,
+ bool for_modification = true);
 
 /** Close an internal InnoDB table handle.
 @param[in,out] table InnoDB table handle