MDEV-22871: Clean up hash_table_t

HASH_TABLE_SYNC_MUTEX was kind-of used for the adaptive hash index,
even though that hash table is already protected by btr_search_latches[].

HASH_TABLE_SYNC_RWLOCK was only being used for buf_pool.page_hash.
It is cleaner to decouple that synchronization from hash_table_t,
and move it to the actual user.

buf_pool_t::page_hash_latches[]: Synchronization for buf_pool.page_hash.

LATCH_ID_HASH_TABLE_MUTEX: Remove.

hash_table_t::sync_obj, hash_table_t::n_sync_obj: Remove.

hash_table_t::type, hash_table_sync_t: Remove.

HASH_ASSERT_OWN(), hash_get_mutex(), hash_get_nth_mutex(): Remove.

ib_recreate(): Merge to the only caller, buf_pool_resize_hash().

ib_create(): Merge to the callers.

ha_clear(): Merge to the only caller buf_pool_t::close().

buf_pool_t::create(): Merge the ib_create() and
hash_create_sync_obj() invocations.

ha_insert_for_fold_func(): Clarify an assertion.

buf_pool_t::page_hash_lock(): Simplify the logic.

hash_assert_can_search(), hash_assert_can_modify(): Remove.
These predicates were only being invoked for the adaptive hash index,
while they only are effective for buf_pool.page_hash.

HASH_DELETE_AND_COMPACT(): Merge to ha_delete_hash_node().

hash_get_sync_obj_index(): Remove.

hash_table_t::heaps[], hash_get_nth_heap(): Remove. It was actually unused!

hash_get_heap(): Remove. It was only used in ha_delete_hash_node(),
where we always use hash_table_t::heap.

hash_table_t::calc_hash(): Replaces hash_calc_hash().

Author: dr-m

storage/innobase/btr/btr0sea.cc

@@ -387,9 +387,13 @@ void btr_search_enable(bool resize)
 		ut_malloc(sizeof(hash_table_t*) * btr_ahi_parts, mem_key_ahi));
 	for (ulint i = 0; i < btr_ahi_parts; ++i) {
 		btr_search_sys->hash_tables[i] =
-			ib_create((hash_size / btr_ahi_parts),
-				  LATCH_ID_HASH_TABLE_MUTEX,
-				  0, MEM_HEAP_FOR_BTR_SEARCH);
+			hash_create(hash_size / btr_ahi_parts);
+		btr_search_sys->hash_tables[i]->heap = mem_heap_create_typed(
+			std::min<ulong>(4096,
+					MEM_MAX_ALLOC_IN_BUF / 2
+					- MEM_BLOCK_HEADER_SIZE
+					- MEM_SPACE_NEEDED(0)),
+			MEM_HEAP_FOR_BTR_SEARCH);
 #if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
                 btr_search_sys->hash_tables[i]->adaptive = TRUE;
 #endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */

storage/innobase/buf/buf0buf.cc

@@ -1523,11 +1523,10 @@ bool buf_pool_t::create()
   ut_a(srv_n_page_hash_locks != 0);
   ut_a(srv_n_page_hash_locks <= MAX_PAGE_HASH_LOCKS);
 
-  page_hash= ib_create(2 * curr_size,
-                         LATCH_ID_HASH_TABLE_RW_LOCK,
-                         srv_n_page_hash_locks, MEM_HEAP_FOR_PAGE_HASH);
-
-  ut_ad(!page_hash_old);
+  page_hash= hash_create(2 * curr_size);
+  for (auto i= srv_n_page_hash_locks; i--; )
+    rw_lock_create(hash_table_locks_key, &page_hash_latches[i],
+                   SYNC_BUF_PAGE_HASH);
   zip_hash= hash_create(2 * curr_size);
   last_printout_time= time(NULL);
 
@@ -1605,7 +1604,8 @@ void buf_pool_t::close()
 
   ut_free(chunks);
   chunks= nullptr;
-  ha_clear(page_hash);
+  for (auto i= srv_n_page_hash_locks; i--; )
+    rw_lock_free(&page_hash_latches[i]);
   hash_table_free(page_hash);
   hash_table_free(zip_hash);
 
@@ -1924,78 +1924,44 @@ inline bool buf_pool_t::withdraw_blocks()
 /** resize page_hash and zip_hash */
 static void buf_pool_resize_hash()
 {
-	hash_table_t*	new_hash_table;
-
-	ut_ad(buf_pool.page_hash_old == NULL);
-
-	/* recreate page_hash */
-	new_hash_table = ib_recreate(
-		buf_pool.page_hash, 2 * buf_pool.curr_size);
-
-	for (ulint i = 0; i < hash_get_n_cells(buf_pool.page_hash); i++) {
-		buf_page_t*	bpage;
-
-		bpage = static_cast<buf_page_t*>(
-			HASH_GET_FIRST(
-				buf_pool.page_hash, i));
-
-		while (bpage) {
-			buf_page_t*	prev_bpage = bpage;
-			ulint		fold;
-
-			ut_ad(bpage->in_page_hash);
-			bpage = static_cast<buf_page_t*>(
-				HASH_GET_NEXT(
-					hash, prev_bpage));
-
-			fold = prev_bpage->id().fold();
-
-			HASH_DELETE(buf_page_t, hash,
-				buf_pool.page_hash, fold,
-				prev_bpage);
-
-			HASH_INSERT(buf_page_t, hash,
-				new_hash_table, fold,
-				prev_bpage);
-		}
-	}
-
-	buf_pool.page_hash_old = buf_pool.page_hash;
-	buf_pool.page_hash = new_hash_table;
-
-	/* recreate zip_hash */
-	new_hash_table = hash_create(2 * buf_pool.curr_size);
-
-	for (ulint i = 0; i < hash_get_n_cells(buf_pool.zip_hash); i++) {
-		buf_page_t*	bpage;
-
-		bpage = static_cast<buf_page_t*>(
-			HASH_GET_FIRST(buf_pool.zip_hash, i));
+  hash_table_t *new_hash_table= hash_create(2 * buf_pool.curr_size);
 
-		while (bpage) {
-			buf_page_t*	prev_bpage = bpage;
-			ulint		fold;
-
-			bpage = static_cast<buf_page_t*>(
-				HASH_GET_NEXT(
-					hash, prev_bpage));
+  for (ulint i= 0; i < hash_get_n_cells(buf_pool.page_hash); i++)
+  {
+    while (buf_page_t *bpage= static_cast<buf_page_t*>
+           (HASH_GET_FIRST(buf_pool.page_hash, i)))
+    {
+      buf_page_t *prev_bpage= bpage;
+      ut_ad(bpage->in_page_hash);
+      bpage= static_cast<buf_page_t*>(HASH_GET_NEXT(hash, prev_bpage));
+      const ulint fold= prev_bpage->id().fold();
+      HASH_DELETE(buf_page_t, hash, buf_pool.page_hash, fold, prev_bpage);
+      HASH_INSERT(buf_page_t, hash, new_hash_table, fold, prev_bpage);
+    }
+  }
 
-			fold = BUF_POOL_ZIP_FOLD(
-				reinterpret_cast<buf_block_t*>(
-					prev_bpage));
+  std::swap(buf_pool.page_hash->array, new_hash_table->array);
+  buf_pool.page_hash->n_cells= new_hash_table->n_cells;
+  hash_table_free(new_hash_table);
 
-			HASH_DELETE(buf_page_t, hash,
-				buf_pool.zip_hash, fold,
-				prev_bpage);
+  /* recreate zip_hash */
+  new_hash_table= hash_create(2 * buf_pool.curr_size);
 
-			HASH_INSERT(buf_page_t, hash,
-				new_hash_table, fold,
-				prev_bpage);
-		}
-	}
+  for (ulint i= 0; i < hash_get_n_cells(buf_pool.zip_hash); i++)
+  {
+    while (buf_page_t *bpage= static_cast<buf_page_t*>
+           (HASH_GET_FIRST(buf_pool.zip_hash, i)))
+    {
+      buf_page_t *prev_bpage= bpage;
+      bpage= static_cast<buf_page_t*>(HASH_GET_NEXT(hash, prev_bpage));
+      const ulint fold= BUF_POOL_ZIP_FOLD_BPAGE(prev_bpage);
+      HASH_DELETE(buf_page_t, hash, buf_pool.zip_hash, fold, prev_bpage);
+      HASH_INSERT(buf_page_t, hash, new_hash_table, fold, prev_bpage);
+    }
+  }
 
-	hash_table_free(buf_pool.zip_hash);
-	buf_pool.zip_hash = new_hash_table;
+  hash_table_free(buf_pool.zip_hash);
+  buf_pool.zip_hash= new_hash_table;
 }
 
 
@@ -2162,8 +2128,10 @@ inline void buf_pool_t::resize()
 	/* Indicate critical path */
 	resizing.store(true, std::memory_order_relaxed);
 
-	mutex_enter(&mutex);
-	page_hash_lock_all();
+  mutex_enter(&mutex);
+  for (auto i= srv_n_page_hash_locks; i--; )
+    rw_lock_x_lock(&page_hash_latches[i]);
+
 	chunk_t::map_reg = UT_NEW_NOKEY(chunk_t::map());
 
 	/* add/delete chunks */
@@ -2312,13 +2280,9 @@ inline void buf_pool_t::resize()
 		ib::info() << "hash tables were resized";
 	}
 
-	page_hash_unlock_all();
-	mutex_exit(&mutex);
-
-	if (page_hash_old != NULL) {
-		hash_table_free(page_hash_old);
-		page_hash_old = NULL;
-	}
+  mutex_exit(&mutex);
+  for (auto i= srv_n_page_hash_locks; i--; )
+    rw_lock_x_unlock(&page_hash_latches[i]);
 
 	UT_DELETE(chunk_map_old);