mirror of
https://github.com/MariaDB/server.git
synced 2025-01-20 22:12:30 +01:00
27b9989d31
The InnoDB adaptive hash index is sometimes degrading the performance of InnoDB, and it is sometimes disabled to get more consistent performance. We should have a compile-time option to disable the adaptive hash index. Let us introduce two options: OPTION(WITH_INNODB_AHI "Include innodb_adaptive_hash_index" ON) OPTION(WITH_INNODB_ROOT_GUESS "Cache index root block descriptors" ON) where WITH_INNODB_AHI always implies WITH_INNODB_ROOT_GUESS. As part of this change, the misleadingly named function trx_search_latch_release_if_reserved(trx) will be replaced with the macro trx_assert_no_search_latch(trx) that will be empty unless BTR_CUR_HASH_ADAPT is defined (cmake -DWITH_INNODB_AHI=ON). We will also remove the unused column INFORMATION_SCHEMA.INNODB_TRX.TRX_ADAPTIVE_HASH_TIMEOUT. In MariaDB Server 10.1, it used to reflect the value of trx_t::search_latch_timeout which could be adjusted during row_search_for_mysql(). In 10.2, there is no such field. Other than the removal of the unused column TRX_ADAPTIVE_HASH_TIMEOUT, this is an almost non-functional change to the server when using the default build options. Some tests are adjusted so that they will work with both -DWITH_INNODB_AHI=ON and -DWITH_INNODB_AHI=OFF. The test innodb.innodb_monitor has been renamed to innodb.monitor in order to track MySQL 5.7, and the duplicate tests sys_vars.innodb_monitor_* are removed.
244 lines
7 KiB
Text
244 lines
7 KiB
Text
/*****************************************************************************
|
|
|
|
Copyright (c) 1994, 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 the Free Software
|
|
Foundation; version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful, but WITHOUT
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along with
|
|
this program; if not, write to the Free Software Foundation, Inc.,
|
|
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA
|
|
|
|
*****************************************************************************/
|
|
|
|
/********************************************************************//**
|
|
@file include/ha0ha.ic
|
|
The hash table with external chains
|
|
|
|
Created 8/18/1994 Heikki Tuuri
|
|
*************************************************************************/
|
|
|
|
#ifdef BTR_CUR_HASH_ADAPT
|
|
#include "ut0rnd.h"
|
|
#include "mem0mem.h"
|
|
#include "btr0types.h"
|
|
|
|
/******************************************************************//**
|
|
Gets a hash node data.
|
|
@return pointer to the data */
|
|
UNIV_INLINE
|
|
const rec_t*
|
|
ha_node_get_data(
|
|
/*=============*/
|
|
const ha_node_t* node) /*!< in: hash chain node */
|
|
{
|
|
return(node->data);
|
|
}
|
|
|
|
/******************************************************************//**
|
|
Sets hash node data. */
|
|
UNIV_INLINE
|
|
void
|
|
ha_node_set_data_func(
|
|
/*==================*/
|
|
ha_node_t* node, /*!< in: hash chain node */
|
|
#if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
|
|
buf_block_t* block, /*!< in: buffer block containing the data */
|
|
#endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
|
|
const rec_t* data) /*!< in: pointer to the data */
|
|
{
|
|
#if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
|
|
node->block = block;
|
|
#endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
|
|
node->data = data;
|
|
}
|
|
|
|
#if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
|
|
/** Sets hash node data.
|
|
@param n in: hash chain node
|
|
@param b in: buffer block containing the data
|
|
@param d in: pointer to the data */
|
|
# define ha_node_set_data(n,b,d) ha_node_set_data_func(n,b,d)
|
|
#else /* UNIV_AHI_DEBUG || UNIV_DEBUG */
|
|
/** Sets hash node data.
|
|
@param n in: hash chain node
|
|
@param b in: buffer block containing the data
|
|
@param d in: pointer to the data */
|
|
# define ha_node_set_data(n,b,d) ha_node_set_data_func(n,d)
|
|
#endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
|
|
|
|
/******************************************************************//**
|
|
Gets the next node in a hash chain.
|
|
@return next node, NULL if none */
|
|
UNIV_INLINE
|
|
ha_node_t*
|
|
ha_chain_get_next(
|
|
/*==============*/
|
|
const ha_node_t* node) /*!< in: hash chain node */
|
|
{
|
|
return(node->next);
|
|
}
|
|
|
|
/******************************************************************//**
|
|
Gets the first node in a hash chain.
|
|
@return first node, NULL if none */
|
|
UNIV_INLINE
|
|
ha_node_t*
|
|
ha_chain_get_first(
|
|
/*===============*/
|
|
hash_table_t* table, /*!< in: hash table */
|
|
ulint fold) /*!< in: fold value determining the chain */
|
|
{
|
|
return((ha_node_t*)
|
|
hash_get_nth_cell(table, hash_calc_hash(fold, table))->node);
|
|
}
|
|
|
|
#ifdef UNIV_DEBUG
|
|
/********************************************************************//**
|
|
Assert that the synchronization object in a hash operation involving
|
|
possible change in the hash table is held.
|
|
Note that in case of mutexes we assert that mutex is owned while in case
|
|
of rw-locks we assert that it is held in exclusive mode. */
|
|
UNIV_INLINE
|
|
void
|
|
hash_assert_can_modify(
|
|
/*===================*/
|
|
hash_table_t* table, /*!< in: hash table */
|
|
ulint fold) /*!< in: fold value */
|
|
{
|
|
if (table->type == HASH_TABLE_SYNC_MUTEX) {
|
|
ut_ad(mutex_own(hash_get_mutex(table, fold)));
|
|
} else if (table->type == HASH_TABLE_SYNC_RW_LOCK) {
|
|
# ifdef UNIV_DEBUG
|
|
rw_lock_t* lock = hash_get_lock(table, fold);
|
|
ut_ad(rw_lock_own(lock, RW_LOCK_X));
|
|
# endif
|
|
} else {
|
|
ut_ad(table->type == HASH_TABLE_SYNC_NONE);
|
|
}
|
|
}
|
|
|
|
/********************************************************************//**
|
|
Assert that the synchronization object in a hash search operation is held.
|
|
Note that in case of mutexes we assert that mutex is owned while in case
|
|
of rw-locks we assert that it is held either in x-mode or s-mode. */
|
|
UNIV_INLINE
|
|
void
|
|
hash_assert_can_search(
|
|
/*===================*/
|
|
hash_table_t* table, /*!< in: hash table */
|
|
ulint fold) /*!< in: fold value */
|
|
{
|
|
if (table->type == HASH_TABLE_SYNC_MUTEX) {
|
|
ut_ad(mutex_own(hash_get_mutex(table, fold)));
|
|
} else if (table->type == HASH_TABLE_SYNC_RW_LOCK) {
|
|
# ifdef UNIV_DEBUG
|
|
rw_lock_t* lock = hash_get_lock(table, fold);
|
|
ut_ad(rw_lock_own(lock, RW_LOCK_X)
|
|
|| rw_lock_own(lock, RW_LOCK_S));
|
|
# endif
|
|
} else {
|
|
ut_ad(table->type == HASH_TABLE_SYNC_NONE);
|
|
}
|
|
}
|
|
#endif /* UNIV_DEBUG */
|
|
|
|
/*************************************************************//**
|
|
Looks for an element in a hash table.
|
|
@return pointer to the data of the first hash table node in chain
|
|
having the fold number, NULL if not found */
|
|
UNIV_INLINE
|
|
const rec_t*
|
|
ha_search_and_get_data(
|
|
/*===================*/
|
|
hash_table_t* table, /*!< in: hash table */
|
|
ulint fold) /*!< in: folded value of the searched data */
|
|
{
|
|
hash_assert_can_search(table, fold);
|
|
ut_ad(btr_search_enabled);
|
|
|
|
for (const ha_node_t* node = ha_chain_get_first(table, fold);
|
|
node != NULL;
|
|
node = ha_chain_get_next(node)) {
|
|
|
|
if (node->fold == fold) {
|
|
|
|
return(node->data);
|
|
}
|
|
}
|
|
|
|
return(NULL);
|
|
}
|
|
|
|
/*********************************************************//**
|
|
Looks for an element when we know the pointer to the data.
|
|
@return pointer to the hash table node, NULL if not found in the table */
|
|
UNIV_INLINE
|
|
ha_node_t*
|
|
ha_search_with_data(
|
|
/*================*/
|
|
hash_table_t* table, /*!< in: hash table */
|
|
ulint fold, /*!< in: folded value of the searched data */
|
|
const rec_t* data) /*!< in: pointer to the data */
|
|
{
|
|
ha_node_t* node;
|
|
|
|
hash_assert_can_search(table, fold);
|
|
|
|
ut_ad(btr_search_enabled);
|
|
|
|
node = ha_chain_get_first(table, fold);
|
|
|
|
while (node) {
|
|
if (node->data == data) {
|
|
|
|
return(node);
|
|
}
|
|
|
|
node = ha_chain_get_next(node);
|
|
}
|
|
|
|
return(NULL);
|
|
}
|
|
|
|
/***********************************************************//**
|
|
Deletes a hash node. */
|
|
void
|
|
ha_delete_hash_node(
|
|
/*================*/
|
|
hash_table_t* table, /*!< in: hash table */
|
|
ha_node_t* del_node); /*!< in: node to be deleted */
|
|
|
|
/*********************************************************//**
|
|
Looks for an element when we know the pointer to the data, and deletes
|
|
it from the hash table, if found.
|
|
@return TRUE if found */
|
|
UNIV_INLINE
|
|
ibool
|
|
ha_search_and_delete_if_found(
|
|
/*==========================*/
|
|
hash_table_t* table, /*!< in: hash table */
|
|
ulint fold, /*!< in: folded value of the searched data */
|
|
const rec_t* data) /*!< in: pointer to the data */
|
|
{
|
|
ha_node_t* node;
|
|
|
|
hash_assert_can_modify(table, fold);
|
|
ut_ad(btr_search_enabled);
|
|
|
|
node = ha_search_with_data(table, fold, data);
|
|
|
|
if (node) {
|
|
ha_delete_hash_node(table, node);
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
return(FALSE);
|
|
}
|
|
#endif /* BTR_CUR_HASH_ADAPT */
|