Skip to content

M
MariaDB
Commit dd77f072 authored by Vladislav Vaintroub's avatar Vladislav Vaintroub
Browse files
Options

MDEV-22841 ut_new_get_key_by_file is unnecessarily expensive 

Change how lookup for the "auto" PSI_memory_keys is done.
Lookup for filename hashes (integers), instead of C strings

Generate these hashes at the compile time with constexpr,
rather than at runtime.
parent 17a7bafe
Hide whitespace changes
Inline Side-by-side
Showing with 309 additions and 187 deletions
storage/innobase/include/ut0new.h
View file @ dd77f072
......@@ -178,13 +178,13 @@ ut_new_boot();
#ifdef UNIV_PFS_MEMORY
/** Retrieve a memory key (registered with PFS), given a portion of the file
name of the caller.
@param[in] file portion of the filename - basename without an extension
@return registered memory key or PSI_NOT_INSTRUMENTED if not found */
PSI_memory_key
ut_new_get_key_by_file(
const char* file);
/**
Retrieve a memory key (registered with PFS),
given filename hash of the caller
@param[in] filename_hash - FILENAME_HASH value of the caller
@return registered memory key or PSI_NOT_INSTRUMENTED */
PSI_memory_key ut_new_get_key_by_file(uint32_t filename_hash);
#endif /* UNIV_PFS_MEMORY */
......@@ -293,7 +293,7 @@ class ut_allocator {
)
{
#ifdef UNIV_PFS_MEMORY
const PSI_memory_key other_key = other.get_mem_key(NULL);
const PSI_memory_key other_key = other.get_mem_key(0);
m_key = (other_key != mem_key_std)
? other_key
......@@ -315,7 +315,7 @@ class ut_allocator {
#endif /* UNIV_PFS_MEMORY */
}
pointer allocate(size_type n) { return allocate(n, NULL, NULL); }
pointer allocate(size_type n) { return allocate(n, NULL, 0); }
/** Allocate a chunk of memory that can hold 'n_elements' objects of
type 'T' and trace the allocation.
......@@ -333,9 +333,9 @@ class ut_allocator {
allocate(
size_type n_elements,
const_pointer,
const char*
uint32_t
#ifdef UNIV_PFS_MEMORY
file /*!< file name of the caller */
filename_hash /* filename hash of the caller */
#endif
,
bool set_to_zero = false,
......@@ -397,7 +397,7 @@ class ut_allocator {
#ifdef UNIV_PFS_MEMORY
ut_new_pfx_t* pfx = static_cast<ut_new_pfx_t*>(ptr);
allocate_trace(total_bytes, file, pfx);
allocate_trace(total_bytes, filename_hash, pfx);
return(reinterpret_cast<pointer>(pfx + 1));
#else
......@@ -479,7 +479,7 @@ class ut_allocator {
reallocate(
void* ptr,
size_type n_elements,
const char* file)
uint32_t filename_hash)
{
if (n_elements == 0) {
deallocate(static_cast<pointer>(ptr));
......@@ -487,7 +487,7 @@ class ut_allocator {
}
if (ptr == NULL) {
return(allocate(n_elements, NULL, file, false, false));
return(allocate(n_elements, NULL, filename_hash, false, false));
}
if (n_elements > max_size()) {
......@@ -530,7 +530,7 @@ class ut_allocator {
deallocate_trace(pfx_new);
/* pfx_new is set here to describe the new block. */
allocate_trace(total_bytes, file, pfx_new);
allocate_trace(total_bytes, filename_hash, pfx_new);
return(reinterpret_cast<pointer>(pfx_new + 1));
}
......@@ -546,9 +546,10 @@ class ut_allocator {
pointer
new_array(
size_type n_elements,
const char* file)
uint32_t filename_hash
)
{
T* p = allocate(n_elements, NULL, file, false, false);
T* p = allocate(n_elements, NULL, filename_hash, false, false);
if (p == NULL) {
return(NULL);
......@@ -634,7 +635,7 @@ class ut_allocator {
if (pfx != NULL) {
#ifdef UNIV_PFS_MEMORY
allocate_trace(n_bytes, NULL, pfx);
allocate_trace(n_bytes, 0, pfx);
#endif /* UNIV_PFS_MEMORY */
pfx->m_size = n_bytes;
}
......@@ -687,25 +688,16 @@ class ut_allocator {
@return performance schema key */
PSI_memory_key
get_mem_key(
const char* file) const
uint32_t filename_hash) const
{
if (m_key != PSI_NOT_INSTRUMENTED) {
return(m_key);
}
if (file == NULL) {
if (filename_hash == 0) {
return(mem_key_std);
}
/* e.g. "btr0cur", derived from "/path/to/btr0cur.cc" */
char keyname[FILENAME_MAX];
const size_t len = ut_basename_noext(file, keyname,
sizeof(keyname));
/* If sizeof(keyname) was not enough then the output would
be truncated, assert that this did not happen. */
ut_a(len < sizeof(keyname));
const PSI_memory_key key = ut_new_get_key_by_file(keyname);
const PSI_memory_key key = ut_new_get_key_by_file(filename_hash);
if (key != PSI_NOT_INSTRUMENTED) {
return(key);
......@@ -747,16 +739,16 @@ class ut_allocator {
corresponds to "file", that will be used (see ut_new_boot())
4. Otherwise, the name associated with mem_key_other will be used.
@param[in] size number of bytes that were allocated
@param[in] file file name of the caller or NULL if unknown
@param[in] filename_hash FILENAME_HASH of the caller
@param[out] pfx placeholder to store the info which will be
needed when freeing the memory */
void
allocate_trace(
size_t size,
const char* file,
const uint32_t filename_hash,
ut_new_pfx_t* pfx)
{
const PSI_memory_key key = get_mem_key(file);
const PSI_memory_key key = get_mem_key(filename_hash);
pfx->m_key = PSI_MEMORY_CALL(memory_alloc)(key, size, & pfx->m_owner);
pfx->m_size = size;
......@@ -806,6 +798,41 @@ operator!=(
#ifdef UNIV_PFS_MEMORY
/*
constexpr trickery ahead.
Retrieve the FILENAME_HASH = djb2(basename_noext(__FILE__)) at the compile time.
We use the number rather than __FILE__ because integers is better to deal with
(hashing, searching) that C style strings.
*/
static constexpr const char * basename_helper(const char* s, const char * last_slash)
{
return
*s == '\0' ? last_slash :
*s == '/' || *s == '\\' ? basename_helper(s + 1, s + 1) :
basename_helper(s + 1, last_slash);
}
static constexpr const char* ut_basename(const char *filename)
{
return basename_helper(filename, filename);
}
/** Compute djb2 hash for a string. Stop at '.' , or '\0' */
constexpr uint32_t ut_filename_hash(const char* s, uint32_t h = 5381)
{
return *s == 0 || *s == '.' ? h :
ut_filename_hash(s + 1, 33 * h + (uint8_t)*s);
}
/* Force constexpr to be evaluated at compile time.*/
#define FORCE_CONSTEXPR(expr)[&]() \
{ static constexpr auto x = (expr); return x; }()
#define FILENAME_HASH FORCE_CONSTEXPR(ut_filename_hash(ut_basename(__FILE__)))
/** Allocate, trace the allocation and construct an object.
Use this macro instead of 'new' within InnoDB.
For example: instead of
......@@ -823,7 +850,7 @@ pointer must be passed to UT_DELETE() when no longer needed.
object if the passed in pointer is NULL, e.g. if allocate() has
failed to allocate memory and has returned NULL. */ \
::new(ut_allocator<byte>(key).allocate( \
sizeof expr, NULL, __FILE__, false, false)) expr
sizeof expr, NULL, FILENAME_HASH, false, false)) expr
/** Allocate, trace the allocation and construct an object.
Use this macro instead of 'new' within InnoDB and instead of UT_NEW()
......@@ -871,7 +898,7 @@ The returned pointer must be passed to UT_DELETE_ARRAY().
@param[in] key performance schema memory tracing key
@return pointer to the first allocated object or NULL */
#define UT_NEW_ARRAY(type, n_elements, key) \
ut_allocator<type>(key).new_array(n_elements, __FILE__)
ut_allocator<type>(key).new_array(n_elements, FILENAME_HASH)
/** Allocate and account 'n_elements' objects of type 'type'.
Use this macro to allocate memory within InnoDB instead of 'new[]' and
......@@ -902,7 +929,7 @@ ut_delete_array(
#define ut_malloc(n_bytes, key) static_cast<void*>( \
ut_allocator<byte>(key).allocate( \
n_bytes, NULL, __FILE__, false, false))
n_bytes, NULL, FILENAME_HASH, false, false))
#define ut_malloc_dontdump(n_bytes, key) static_cast<void*>( \
ut_allocator<byte>(key).allocate_large( \
......@@ -910,23 +937,23 @@ ut_delete_array(
#define ut_zalloc(n_bytes, key) static_cast<void*>( \
ut_allocator<byte>(key).allocate( \
n_bytes, NULL, __FILE__, true, false))
n_bytes, NULL, FILENAME_HASH, true, false))
#define ut_malloc_nokey(n_bytes) static_cast<void*>( \
ut_allocator<byte>(PSI_NOT_INSTRUMENTED).allocate( \
n_bytes, NULL, __FILE__, false, false))
n_bytes, NULL, FILENAME_HASH, false, false))
#define ut_zalloc_nokey(n_bytes) static_cast<void*>( \
ut_allocator<byte>(PSI_NOT_INSTRUMENTED).allocate( \
n_bytes, NULL, __FILE__, true, false))
n_bytes, NULL, FILENAME_HASH, true, false))
#define ut_zalloc_nokey_nofatal(n_bytes) static_cast<void*>( \
ut_allocator<byte, false>(PSI_NOT_INSTRUMENTED).allocate( \
n_bytes, NULL, __FILE__, true, false))
n_bytes, NULL, FILENAME_HASH, true, false))
#define ut_realloc(ptr, n_bytes) static_cast<void*>( \
ut_allocator<byte>(PSI_NOT_INSTRUMENTED).reallocate( \
ptr, n_bytes, __FILE__))
ptr, n_bytes, FILENAME_HASH))
#define ut_free(ptr) ut_allocator<byte>(PSI_NOT_INSTRUMENTED).deallocate( \
reinterpret_cast<byte*>(ptr))
......
storage/innobase/ut/ut0new.cc
View file @ dd77f072
......@@ -25,7 +25,7 @@ Created May 26, 2014 Vasil Dimov
*******************************************************/
#include "univ.i"
#include <algorithm>
/** Maximum number of retries to allocate memory. */
const size_t alloc_max_retries = 60;
......@@ -44,6 +44,175 @@ PSI_memory_key mem_key_row_merge_sort;
PSI_memory_key mem_key_std;
#ifdef UNIV_PFS_MEMORY
static const char* auto_event_names[] =
{
"btr0btr",
"btr0bulk",
"btr0cur",
"btr0defragment",
"btr0pcur",
"btr0sea",
"btr0types",
"buf0buddy",
"buf0buf",
"buf0checksum",
"buf0dblwr",
"buf0dump",
"buf0flu",
"buf0lru",
"buf0rea",
"buf0types",
"data0data",
"data0type",
"data0types",
"db0err",
"dict0boot",
"dict0crea",
"dict0defrag_bg",
"dict0dict",
"dict0load",
"dict0mem",
"dict0pagecompress",
"dict0priv",
"dict0stats",
"dict0stats_bg",
"dict0types",
"dyn0buf",
"dyn0types",
"eval0eval",
"eval0proc",
"fil0crypt",
"fil0fil",
"fil0pagecompress",
"fsp0file",
"fsp0fsp",
"fsp0space",
"fsp0sysspace",
"fsp0types",
"fts0ast",
"fts0blex",
"fts0config",
"fts0fts",
"fts0opt",
"fts0pars",
"fts0plugin",
"fts0priv",
"fts0que",
"fts0sql",
"fts0tlex",
"fts0tokenize",
"fts0types",
"fts0vlc",
"fut0fut",
"fut0lst",
"gis0geo",
"gis0rtree",
"gis0sea",
"gis0type",
"ha0ha",
"ha0storage",
"ha_innodb",
"ha_prototypes",
"handler0alter",
"hash0hash",
"i_s",
"ib0mutex",
"ibuf0ibuf",
"ibuf0types",
"lexyy",
"lock0iter",
"lock0lock",
"lock0prdt",
"lock0priv",
"lock0types",
"lock0wait",
"log0crypt",
"log0log",
"log0recv",
"log0sync",
"log0types",
"mach0data",
"mem0mem",
"mtr0log",
"mtr0mtr",
"mtr0types",
"os0api",
"os0event",
"os0file",
"os0proc",
"os0thread",
"page0cur",
"page0page",
"page0types",
"page0zip",
"pars0grm",
"pars0lex",
"pars0opt",
"pars0pars",
"pars0sym",
"pars0types",
"que0que",
"que0types",
"read0read",
"read0types",
"rem0cmp",
"rem0rec",
"rem0types",
"row0ext",
"row0ftsort",
"row0import",
"row0ins",
"row0log",
"row0merge",
"row0mysql",
"row0purge",
"row0quiesce",
"row0row",
"row0sel",
"row0types",
"row0uins",
"row0umod",
"row0undo",
"row0upd",
"row0vers",
"srv0conc",
"srv0mon",
"srv0srv",
"srv0start",
"sync0arr",
"sync0debug",
"sync0policy",
"sync0rw",
"sync0sync",
"sync0types",
"trx0i_s",
"trx0purge",
"trx0rec",
"trx0roll",
"trx0rseg",
"trx0sys",
"trx0trx",
"trx0types",
"trx0undo",
"trx0xa",
"ut0byte",
"ut0counter",
"ut0crc32",
"ut0dbg",
"ut0list",
"ut0lst",
"ut0mem",
"ut0mutex",
"ut0new",
"ut0pool",
"ut0rbt",
"ut0rnd",
"ut0sort",
"ut0stage",
"ut0ut",
"ut0vec",
"ut0wqueue"
};
/** Auxiliary array of performance schema 'PSI_memory_info'.
Each allocation appears in
......@@ -59,163 +228,89 @@ the list below:
Keep this list alphabetically sorted. */
static PSI_memory_info pfs_info[] = {
#ifdef BTR_CUR_HASH_ADAPT
{&mem_key_ahi, "adaptive hash index", 0},
{&mem_key_ahi, "adaptive hash index", 0},
#endif /* BTR_CUR_HASH_ADAPT */
{&mem_key_buf_buf_pool, "buf_buf_pool", 0},
{&mem_key_dict_stats_bg_recalc_pool_t, "dict_stats_bg_recalc_pool_t", 0},
{&mem_key_dict_stats_index_map_t, "dict_stats_index_map_t", 0},
{&mem_key_dict_stats_n_diff_on_level, "dict_stats_n_diff_on_level", 0},
{&mem_key_other, "other", 0},
{&mem_key_row_log_buf, "row_log_buf", 0},
{&mem_key_row_merge_sort, "row_merge_sort", 0},
{&mem_key_std, "std", 0},
{&mem_key_buf_buf_pool, "buf_buf_pool", 0},
{&mem_key_dict_stats_bg_recalc_pool_t, "dict_stats_bg_recalc_pool_t", 0},
{&mem_key_dict_stats_index_map_t, "dict_stats_index_map_t", 0},
{&mem_key_dict_stats_n_diff_on_level, "dict_stats_n_diff_on_level", 0},
{&mem_key_other, "other", 0},
{&mem_key_row_log_buf, "row_log_buf", 0},
{&mem_key_row_merge_sort, "row_merge_sort", 0},
{&mem_key_std, "std", 0},
};
/** Map used for default performance schema keys, based on file name of the
caller. The key is the file name of the caller and the value is a pointer
to a PSI_memory_key variable to be passed to performance schema methods.
We use ut_strcmp_functor because by default std::map will compare the pointers
themselves (cont char*) and not do strcmp(). */
typedef std::map<const char*, PSI_memory_key*, ut_strcmp_functor>
mem_keys_auto_t;
/** Map of filename/pfskey, used for tracing allocations that have not
provided a manually created pfs key. This map is only ever modified (bulk
insert) at startup in a single-threaded environment by ut_new_boot().
Later it is only read (only std::map::find() is called) from multithreaded
environment, thus it is not protected by any latch. */
static mem_keys_auto_t mem_keys_auto;
#endif /* UNIV_PFS_MEMORY */
static const int NKEYS = static_cast<int>UT_ARR_SIZE(auto_event_names);
std::pair<uint32_t, PSI_memory_key> search_array[NKEYS];
/** Setup the internal objects needed for UT_NEW() to operate.
This must be called before the first call to UT_NEW(). */
void
ut_new_boot()
void ut_new_boot()
{
#ifdef UNIV_PFS_MEMORY
static const char* auto_event_names[] = {
/* Keep this list alphabetically sorted. */
"btr0btr",
"btr0bulk",
"btr0cur",
"btr0pcur",
"btr0sea",
"buf0buf",
"buf0dblwr",
"buf0dump",
"buf0flu",
"buf0lru",
"dict0dict",
"dict0mem",
"dict0stats",
"dict0stats_bg",
"eval0eval",
"fil0fil",
"fsp0file",
"fsp0space",
"fsp0sysspace",
"fts0ast",
"fts0config",
"fts0fts",
"fts0opt",
"fts0pars",
"fts0que",
"fts0sql",
"gis0sea",
"ha0ha",
"ha_innodb",
"handler0alter",
"hash0hash",
"i_s",
"ibuf0ibuf",
"lexyy",
"lock0lock",
"log0log",
"log0recv",
"mem0mem",
"os0event",
"os0file",
"page0cur",
"page0zip",
"pars0lex",
"read0read",
"rem0rec",
"row0ftsort",
"row0import",
"row0log",
"row0merge",
"row0mysql",
"row0sel",
"srv0conc",
"srv0srv",
"srv0start",
"sync0arr",
"sync0debug",
"sync0rw",
"sync0types",
"trx0i_s",
"trx0purge",
"trx0roll",
"trx0rseg",
"trx0sys",
"trx0trx",
"trx0undo",
"ut0list",
"ut0mem",
"ut0mutex",
"ut0pool",
"ut0rbt",
"ut0wqueue",
};
static const size_t n_auto = UT_ARR_SIZE(auto_event_names);
static PSI_memory_key auto_event_keys[n_auto];
static PSI_memory_info pfs_info_auto[n_auto];
for (size_t i = 0; i < n_auto; i++) {
const std::pair<mem_keys_auto_t::iterator, bool> ret
MY_ATTRIBUTE((unused))
= mem_keys_auto.insert(
mem_keys_auto_t::value_type(auto_event_names[i],
&auto_event_keys[i]));
/* ret.second is true if new element has been inserted */
ut_a(ret.second);
/* e.g. "btr0btr" */
pfs_info_auto[i].m_name = auto_event_names[i];
/* a pointer to the pfs key */
pfs_info_auto[i].m_key = &auto_event_keys[i];
pfs_info_auto[i].m_flags = 0;
}
PSI_MEMORY_CALL(register_memory)("innodb", pfs_info, static_cast<int>(
UT_ARR_SIZE(pfs_info)));
PSI_MEMORY_CALL(register_memory)("innodb", pfs_info_auto,
static_cast<int>(n_auto));
#endif /* UNIV_PFS_MEMORY */
PSI_MEMORY_CALL(register_memory)("innodb", pfs_info, UT_ARR_SIZE(pfs_info));
static PSI_memory_key auto_event_keys[NKEYS];
static PSI_memory_info pfs_info_auto[NKEYS];
for (int i= 0; i < NKEYS; i++)
{
pfs_info_auto[i]= {&auto_event_keys[i], auto_event_names[i], 0};
}
PSI_MEMORY_CALL(register_memory)("innodb", pfs_info_auto,NKEYS);
if (auto_event_keys[0] == PSI_NOT_INSTRUMENTED)
return; // PSI is off
for (int i= 0; i < NKEYS; i++)
{
search_array[i]= {ut_filename_hash(auto_event_names[i]), auto_event_keys[i]};
}
std::sort(search_array, std::end(search_array));
#ifdef UNIV_DEBUG
/* assumption that hash value is not 0 in ut0new.h, get_mem_key() */
ut_ad(search_array[0].first);
/* Check for hash duplicates */
for(int i= 0; i < NKEYS-1; i++)
{
if (search_array[i].first == search_array[i + 1].first)
{
// This can only happen if autoevent_names was updated
// previously, or the hash function changed
ib::fatal() << __FILE__ "Duplicates found in filename hashes";
}
}
#endif
}
#ifdef UNIV_PFS_MEMORY
/** Retrieve a memory key (registered with PFS), corresponding to source file hash.
/** Retrieve a memory key (registered with PFS), given a portion of the file
name of the caller.
@param[in] file portion of the filename - basename without an extension
@return registered memory key or PSI_NOT_INSTRUMENTED if not found */
PSI_memory_key
ut_new_get_key_by_file(
const char* file)
@param[in] filename_hash - hash value (computed at compile time) of a ut_filename_hash
for a one of the auto_event_names.
@return registered memory key or PSI_NOT_INSTRUMENTED
*/
PSI_memory_key ut_new_get_key_by_file(uint32_t filename_hash)
{
mem_keys_auto_t::const_iterator el = mem_keys_auto.find(file);
if(search_array[0].second == PSI_NOT_INSTRUMENTED)
{
// PSI is off.
return PSI_NOT_INSTRUMENTED;
}
std::pair<uint32, PSI_memory_key> e{ filename_hash, 0 };
auto result= std::lower_bound(search_array, std::end(search_array), e);
if (result != std::end(search_array) && result->first == filename_hash)
return result->second;
if (el != mem_keys_auto.end()) {
return(*(el->second));
}
#ifdef UNIV_DEBUG
ib::fatal() << __FILE__ " ut_new_get_key_by_file : hash not found";
#endif
return(PSI_NOT_INSTRUMENTED);
return PSI_NOT_INSTRUMENTED;
}
#endif /* UNIV_PFS_MEMORY */
#else /* UNIV_PFS_MEMORY */
void ut_new_boot(){}
#endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7