126#include <type_traits>
127#include <unordered_map>
128#include <unordered_set>
242#ifdef UNIV_PFS_MEMORY
451#if defined(__GNUG__) && (__GNUG__ == 5)
461 return (index == b_len || (a[index] == b[index] &&
471 return ((
file[index] ==
'\0' ||
file[index] ==
'.')
500#define UT_NEW_THIS_FILE_PSI_KEY ut_new_get_key_by_file(MY_BASENAME)
511 for (
size_t i = 0; i < b_len; ++i) {
523 for (
size_t i = 0;; ++i) {
524 if (
file[i] ==
'\0' ||
file[i] ==
'.') {
536 for (
size_t i = 0; i <
n_auto; ++i) {
538 return static_cast<int>(i);
560#define UT_NEW_THIS_FILE_PSI_INDEX \
561 (force_constexpr<ut_new_get_key_by_file(MY_BASENAME)>::value)
563#define UT_NEW_THIS_FILE_PSI_KEY \
564 (UT_NEW_THIS_FILE_PSI_INDEX == -1 \
565 ? ut::make_psi_memory_key(PSI_NOT_INSTRUMENTED) \
566 : ut::make_psi_memory_key(auto_event_keys[UT_NEW_THIS_FILE_PSI_INDEX]))
572#define UT_NEW_THIS_FILE_PSI_KEY ut::make_psi_memory_key(PSI_NOT_INSTRUMENTED)
578#ifdef HAVE_PSI_MEMORY_INTERFACE
598 return malloc_impl::alloc<false>(size,
key());
616inline void *
malloc(std::size_t size)
noexcept {
634 return malloc_impl::alloc<true>(size,
key());
652inline void *
zalloc(std::size_t size)
noexcept {
675 std::size_t size)
noexcept {
702inline void *
realloc(
void *ptr, std::size_t size)
noexcept {
716inline void free(
void *ptr)
noexcept {
749template <
typename T,
typename... Args>
754 new (
mem) T(std::forward<Args>(args)...);
759 return static_cast<T *
>(
mem);
792template <
typename T,
typename... Args>
793inline T *
new_(Args &&... args) {
795 std::forward<Args>(args)...);
872template <
typename T,
typename... Args>
876 auto mem = malloc_impl::alloc<false>(
sizeof(T) *
sizeof...(args),
key());
882 detail::construct<T>(
mem,
sizeof(T) * idx++, std::forward<Args>(args)));
884 for (
size_t offset = (idx - 1) *
sizeof(T); offset != 0;
885 offset -=
sizeof(T)) {
886 reinterpret_cast<T *
>(
reinterpret_cast<std::uintptr_t
>(
mem) + offset -
893 return static_cast<T *
>(
mem);
957template <
typename T,
typename... Args>
960 std::forward<Args>(args)...);
1025template <
typename T>
1029 auto mem = malloc_impl::alloc<false>(
sizeof(T) *
count(),
key());
1034 for (; offset <
sizeof(T) *
count(); offset +=
sizeof(T)) {
1035 new (
reinterpret_cast<uint8_t *
>(
mem) + offset) T{};
1038 for (; offset != 0; offset -=
sizeof(T)) {
1039 reinterpret_cast<T *
>(
reinterpret_cast<std::uintptr_t
>(
mem) + offset -
1046 return static_cast<T *
>(
mem);
1092template <
typename T>
1107template <
typename T>
1112 const auto data_len = malloc_impl::datalen(ptr);
1113 for (
size_t offset = 0; offset < data_len; offset +=
sizeof(T)) {
1114 reinterpret_cast<T *
>(
reinterpret_cast<std::uintptr_t
>(ptr) + offset)->~T();
1148 std::size_t size)
noexcept {
1151 return page_alloc_impl::alloc(size,
key());
1197 return page_alloc_impl::datalen(ptr);
1211 return page_alloc_impl::low_level_info(ptr);
1247 std::size_t size)
noexcept {
1250 return large_page_alloc_impl::alloc(size,
key());
1295 return large_page_alloc_impl::datalen(ptr);
1309 return large_page_alloc_impl::low_level_info(ptr);
1357 void *large_page_mem =
nullptr;
1358 if (large_pages_enabled) {
1456 if (!ptr)
return false;
1462 ut_a(large_page_alloc_impl::page_type(ptr) ==
1484 std::size_t alignment)
noexcept {
1487 return aligned_alloc_impl::alloc<false>(size, alignment,
key());
1526 std::size_t alignment)
noexcept {
1529 return aligned_alloc_impl::alloc<true>(size, alignment,
key());
1592template <
typename T,
typename... Args>
1598 new (
mem) T(std::forward<Args>(args)...);
1603 return static_cast<T *
>(
mem);
1633template <
typename T,
typename... Args>
1636 alignment, std::forward<Args>(args)...);
1648template <
typename T>
1713template <
typename T,
typename... Args>
1722 detail::construct<T>(
mem,
sizeof(T) * idx++, std::forward<Args>(args)));
1724 for (
size_t offset = (idx - 1) *
sizeof(T); offset != 0;
1725 offset -=
sizeof(T)) {
1726 reinterpret_cast<T *
>(
reinterpret_cast<std::uintptr_t
>(
mem) + offset -
1733 return static_cast<T *
>(
mem);
1777template <
typename T>
1785 for (; offset <
sizeof(T) *
count(); offset +=
sizeof(T)) {
1786 new (
reinterpret_cast<uint8_t *
>(
mem) + offset) T{};
1789 for (; offset != 0; offset -=
sizeof(T)) {
1790 reinterpret_cast<T *
>(
reinterpret_cast<std::uintptr_t
>(
mem) + offset -
1797 return static_cast<T *
>(
mem);
1836template <
typename T,
typename... Args>
1839 alignment, std::forward<Args>(args)...);
1878template <
typename T>
1893template <
typename T>
1897 const auto data_len = aligned_alloc_impl::datalen(ptr);
1898 for (
size_t offset = 0; offset < data_len; offset +=
sizeof(T)) {
1899 reinterpret_cast<T *
>(
reinterpret_cast<std::uintptr_t
>(ptr) + offset)->~T();
1921template <
typename T,
size_t Alignment>
1943 template <
typename... Args>
1960 template <
typename... Args>
1964 ut::aligned_new_withkey<T>(
key,
Alignment, std::forward<Args>(args)...);
1979 operator T *()
const {
2015template <
typename T,
size_t Alignment>
2055 template <
typename... Args>
2058 ptr = ut::aligned_new_arr<T>(
Alignment, std::forward<Args>(args)...);
2093 template <
typename... Args>
2097 std::forward<Args>(args)...);
2112 operator T *()
const {
2119template <
typename T>
2123 template <
typename U>
2129template <
typename T>
2133 template <
typename U>
2177template <
typename T,
typename Allocator_base = std::conditional_t<
2190 static_assert(
alignof(T) <=
alignof(std::max_align_t),
2191 "ut::allocator does not support over-aligned types. Use "
2192 "ut::aligned_* API to handle such types.");
2212 template <
typename U>
2214 : Allocator_base(other) {}
2221 template <
typename U>
2232 return !(*
this == other);
2240 const size_type s_max = std::numeric_limits<size_type>::max();
2259 throw std::bad_array_new_length();
2262 auto ptr = Allocator_base::allocate_impl(n_elements *
sizeof(T));
2265 throw std::bad_alloc();
2268 return static_cast<pointer>(ptr);
2284template <
typename T>
2289template <
typename T, std::
size_t N>
2294template <
typename T, std::
size_t N>
2297template <
typename T>
2302template <
typename T>
2307template <
typename T>
2312template <
typename T>
2334template <
typename T,
typename Deleter = detail::Deleter<T>,
typename... Args>
2335std::enable_if_t<!std::is_array<T>::value, std::unique_ptr<T, Deleter>>
2337 return std::unique_ptr<T, Deleter>(ut::new_<T>(std::forward<Args>(args)...));
2353template <
typename T,
typename Deleter = detail::Deleter<T>,
typename... Args>
2354std::enable_if_t<!std::is_array<T>::value, std::unique_ptr<T, Deleter>>
2356 return std::unique_ptr<T, Deleter>(
2357 ut::new_withkey<T>(
key, std::forward<Args>(args)...));
2375template <
typename T,
2376 typename Deleter = detail::Array_deleter<std::remove_extent_t<T>>>
2377std::enable_if_t<detail::is_unbounded_array_v<T>, std::unique_ptr<T, Deleter>>
2379 return std::unique_ptr<T, Deleter>(
2395template <
typename T,
2396 typename Deleter = detail::Array_deleter<std::remove_extent_t<T>>>
2397std::enable_if_t<detail::is_unbounded_array_v<T>, std::unique_ptr<T, Deleter>>
2399 return std::unique_ptr<T, Deleter>(
2408template <
typename T,
typename... Args>
2409std::enable_if_t<detail::is_bounded_array_v<T>>
make_unique(Args &&...) =
2418template <
typename T,
typename... Args>
2431template <
typename T>
2433 !std::is_array<T>::value, std::unique_ptr<T, detail::Deleter<T>>,
2435 detail::is_unbounded_array_v<T>,
2436 std::unique_ptr<T, detail::Array_deleter<std::remove_extent_t<T>>>,
2455template <
typename T,
typename Deleter = detail::Aligned_deleter<T>,
2457std::enable_if_t<!std::is_array<T>::value, std::unique_ptr<T, Deleter>>
2459 return std::unique_ptr<T, Deleter>(
2460 ut::aligned_new<T>(alignment, std::forward<Args>(args)...));
2478template <
typename T,
typename Deleter = detail::Aligned_deleter<T>,
2480std::enable_if_t<!std::is_array<T>::value, std::unique_ptr<T, Deleter>>
2482 return std::unique_ptr<T, Deleter>(
2483 ut::aligned_new_withkey<T>(
key, alignment, std::forward<Args>(args)...));
2504template <
typename T,
typename Deleter = detail::Aligned_array_deleter<
2505 std::remove_extent_t<T>>>
2506std::enable_if_t<detail::is_unbounded_array_v<T>, std::unique_ptr<T, Deleter>>
2508 return std::unique_ptr<T, Deleter>(
2528template <
typename T,
typename Deleter = detail::Aligned_array_deleter<
2529 std::remove_extent_t<T>>>
2530std::enable_if_t<detail::is_unbounded_array_v<T>, std::unique_ptr<T, Deleter>>
2532 return std::unique_ptr<T, Deleter>(
2542template <
typename T,
typename... Args>
2544 Args &&...) =
delete;
2552template <
typename T,
typename... Args>
2565template <
typename T>
2567 !std::is_array<T>::value, std::unique_ptr<T, detail::Aligned_deleter<T>>,
2568 std::conditional_t<detail::is_unbounded_array_v<T>,
2570 std::remove_extent_t<T>>>,
2588template <
typename T,
typename Deleter = detail::Deleter<T>,
typename... Args>
2589std::enable_if_t<!std::is_array<T>::value, std::shared_ptr<T>>
make_shared(
2591 return std::shared_ptr<T>(ut::new_<T>(std::forward<Args>(args)...),
2608template <
typename T,
typename Deleter = detail::Deleter<T>,
typename... Args>
2609std::enable_if_t<!std::is_array<T>::value, std::shared_ptr<T>>
make_shared(
2611 return std::shared_ptr<T>(
2612 ut::new_withkey<T>(
key, std::forward<Args>(args)...),
Deleter{});
2631template <
typename T,
2632 typename Deleter = detail::Array_deleter<std::remove_extent_t<T>>>
2633std::enable_if_t<detail::is_unbounded_array_v<T>, std::shared_ptr<T>>
2635 return std::shared_ptr<T>(
2654template <
typename T,
2655 typename Deleter = detail::Array_deleter<std::remove_extent_t<T>>>
2656std::enable_if_t<detail::is_unbounded_array_v<T>, std::shared_ptr<T>>
2658 return std::shared_ptr<T>(
2678template <
typename T,
2679 typename Deleter = detail::Array_deleter<std::remove_extent_t<T>>>
2680std::enable_if_t<detail::is_bounded_array_v<T>, std::shared_ptr<T>>
2682 return std::shared_ptr<T>(
ut::new_arr<std::remove_extent_t<T>>(
2683 ut::Count{detail::bounded_array_size_v<T>}),
2700template <
typename T,
2701 typename Deleter = detail::Array_deleter<std::remove_extent_t<T>>>
2702std::enable_if_t<detail::is_bounded_array_v<T>, std::shared_ptr<T>>
make_shared(
2704 return std::shared_ptr<T>(
2726template <
typename T,
typename Deleter = detail::Aligned_deleter<T>,
2728std::enable_if_t<!std::is_array<T>::value, std::shared_ptr<T>>
2730 return std::shared_ptr<T>(
2731 ut::aligned_new<T>(alignment, std::forward<Args>(args)...),
Deleter{});
2749template <
typename T,
typename Deleter = detail::Aligned_deleter<T>,
2751std::enable_if_t<!std::is_array<T>::value, std::shared_ptr<T>>
2753 return std::shared_ptr<T>(
2754 ut::aligned_new_withkey<T>(
key, alignment, std::forward<Args>(args)...),
2776template <
typename T,
typename Deleter = detail::Aligned_array_deleter<
2777 std::remove_extent_t<T>>>
2778std::enable_if_t<detail::is_unbounded_array_v<T>, std::shared_ptr<T>>
2780 return std::shared_ptr<T>(
2801template <
typename T,
typename Deleter = detail::Aligned_array_deleter<
2802 std::remove_extent_t<T>>>
2803std::enable_if_t<detail::is_unbounded_array_v<T>, std::shared_ptr<T>>
2805 return std::shared_ptr<T>(
2828template <
typename T,
typename Deleter = detail::Aligned_array_deleter<
2829 std::remove_extent_t<T>>>
2830std::enable_if_t<detail::is_bounded_array_v<T>, std::shared_ptr<T>>
2832 return std::shared_ptr<T>(
2834 alignment,
ut::Count{detail::bounded_array_size_v<T>}),
2853template <
typename T,
typename Deleter = detail::Aligned_array_deleter<
2854 std::remove_extent_t<T>>>
2855std::enable_if_t<detail::is_bounded_array_v<T>, std::shared_ptr<T>>
2857 return std::shared_ptr<T>(
2859 key, alignment,
ut::Count{detail::bounded_array_size_v<T>}),
2872template <
typename T>
2873using vector = std::vector<T, ut::allocator<T>>;
2876template <
typename T>
2877using list = std::list<T, ut::allocator<T>>;
2880template <
typename Key,
typename Compare = std::less<Key>>
2881using set = std::set<Key, Compare, ut::allocator<Key>>;
2883template <
typename Key>
2885 std::unordered_set<Key, std::hash<Key>, std::equal_to<Key>,
2889template <
typename Key,
typename Value,
typename Compare = std::less<Key>>
2891 std::map<Key, Value, Compare, ut::allocator<std::pair<const Key, Value>>>;
2893template <
typename Key,
typename Value,
typename Hash = std::hash<Key>,
2894 typename Key_equal = std::equal_to<Key>>
Definition: tls_cipher.cc:36
a nullable SQL value.
Definition: sql_value.h:39
Lightweight convenience wrapper which manages a dynamically allocated array of over-aligned types.
Definition: ut0new.h:2016
void dealloc()
Invokes destructors of instances of type T, if applicable.
Definition: ut0new.h:2104
void alloc(Count count)
Allocates sufficiently large memory of dynamic storage duration to fit the array of size number of el...
Definition: ut0new.h:2038
T * ptr
Definition: ut0new.h:2017
void alloc_withkey(PSI_memory_key_t key, Count count)
Allocates sufficiently large memory of dynamic storage duration to fit the array of size number of el...
Definition: ut0new.h:2074
void alloc_withkey(PSI_memory_key_t key, Args &&... args)
Allocates sufficiently large memory of dynamic storage duration to fit the array of size number of el...
Definition: ut0new.h:2094
~aligned_array_pointer()
Destructor.
Definition: ut0new.h:2024
void alloc(Args &&... args)
Allocates sufficiently large memory of dynamic storage duration to fit the array of size number of el...
Definition: ut0new.h:2056
Lightweight convenience wrapper which manages dynamically allocated over-aligned type.
Definition: ut0new.h:1922
~aligned_pointer()
Destructor.
Definition: ut0new.h:1930
void alloc(Args &&... args)
Allocates sufficiently large memory of dynamic storage duration to fit the instance of type T at the ...
Definition: ut0new.h:1944
void alloc_withkey(PSI_memory_key_t key, Args &&... args)
Allocates sufficiently large memory of dynamic storage duration to fit the instance of type T at the ...
Definition: ut0new.h:1961
T * ptr
Definition: ut0new.h:1923
void dealloc()
Invokes the destructor of instance of type T, if applicable.
Definition: ut0new.h:1970
Allocator that allows std::* containers to manage their memory through ut::malloc* and ut::free libra...
Definition: ut0new.h:2180
T & reference
Definition: ut0new.h:2184
void deallocate(pointer ptr, size_type n_elements=0)
Releases the memory allocated through ut::allocator<T>::allocate().
Definition: ut0new.h:2276
const T * const_pointer
Definition: ut0new.h:2183
ptrdiff_t difference_type
Definition: ut0new.h:2188
allocator< T, Allocator_base > & operator=(const allocator< T, Allocator_base > &)=default
allocator< T, Allocator_base > & operator=(allocator< T, Allocator_base > &&)=default
T value_type
Definition: ut0new.h:2186
allocator(const allocator< U, Allocator_base > &other)
Copy-construct a new instance of allocator with type T by using existing instance of allocator constr...
Definition: ut0new.h:2213
pointer allocate(size_type n_elements, const_pointer hint=nullptr)
Allocates chunk of memory that can hold n_elements objects of type T.
Definition: ut0new.h:2256
size_type max_size() const
Return the maximum number of objects that can be allocated by this allocator.
Definition: ut0new.h:2239
const T & const_reference
Definition: ut0new.h:2185
allocator(allocator< T, Allocator_base > &&)=default
bool operator!=(const ut::allocator< T, Allocator_base > &other) const
Non-equality of allocators instantiated with same types T.
Definition: ut0new.h:2231
allocator(PSI_memory_key key=mem_key_std)
Default constructor.
Definition: ut0new.h:2197
allocator(const allocator< T, Allocator_base > &)=default
size_t size_type
Definition: ut0new.h:2187
bool operator==(const ut::allocator< T, Allocator_base > &) const
Equality of allocators instantiated with same types T.
Definition: ut0new.h:2227
T * pointer
Definition: ut0new.h:2182
Implementation bits and pieces of include/ut0new.h.
unsigned int PSI_memory_key
Instrumented memory key.
Definition: psi_memory_bits.h:48
#define realloc(P, A)
Definition: lexyy.cc:916
#define free(A)
Definition: lexyy.cc:915
A macro that gives FILE without the directory name (e.g.
constexpr bool unlikely(bool expr)
Definition: my_compiler.h:57
static int count
Definition: myisam_ftdump.cc:44
Instrumentation helpers for memory allocation.
std::atomic< Type > N
Definition: ut0counter.h:224
std::unordered_map< Key, CHARSET_INFO * > Hash
Definition: collations_internal.cc:547
Definition: ut0tuple.h:56
std::string_view Key
The key type for the hash structure in HashJoinRowBuffer.
Definition: hash_join_buffer.h:107
Definition: authentication.cc:35
Alignment
Enum class describing alignment-requirements.
Definition: lock_free_type.h:38
constexpr bool is_unbounded_array_v< T[]>
Definition: ut0new.h:2285
typename select_alloc_impl< Pfs_memory_instrumentation_on >::type select_alloc_impl_t
Just a small helper type which saves us some keystrokes.
Definition: aligned_alloc.h:690
constexpr size_t bounded_array_size_v< T[N]>
Definition: ut0new.h:2295
constexpr bool is_bounded_array_v
Definition: ut0new.h:2288
constexpr bool is_unbounded_array_v
Definition: ut0new.h:2283
typename select_large_page_alloc_impl< Pfs_memory_instrumentation_on >::type select_large_page_alloc_impl_t
Just a small helper type which saves us some keystrokes.
Definition: large_page_alloc.h:366
typename select_page_alloc_impl< Pfs_memory_instrumentation_on >::type select_page_alloc_impl_t
Just a small helper type which saves us some keystrokes.
Definition: page_alloc.h:427
typename select_malloc_impl< Pfs_memory_instrumentation_on, Array_specialization >::type select_malloc_impl_t
Just a small helper type which saves us some keystrokes.
Definition: alloc.h:428
constexpr size_t bounded_array_size_v
Definition: ut0new.h:2293
constexpr bool is_bounded_array_v< T[N]>
Definition: ut0new.h:2290
This file contains a set of libraries providing overloads for regular dynamic allocation routines whi...
Definition: aligned_alloc.h:47
void * aligned_zalloc_withkey(PSI_memory_key_t key, std::size_t size, std::size_t alignment) noexcept
Dynamically allocates zero-initialized storage of given size and at the address aligned to the reques...
Definition: ut0new.h:1525
std::unordered_map< Key, Value, Hash, Key_equal, ut::allocator< std::pair< const Key, Value > > > unordered_map
Definition: ut0new.h:2897
T * new_arr_withkey(PSI_memory_key_t key, Args &&... args)
Dynamically allocates storage for an array of T's.
Definition: ut0new.h:873
size_t pfs_overhead() noexcept
Returns number of bytes that ut::malloc_*, ut::zalloc_*, ut::realloc_* and ut::new_* variants will be...
Definition: ut0new.h:1124
T * aligned_new_withkey(PSI_memory_key_t key, std::size_t alignment, Args &&... args)
Dynamically allocates storage for an object of type T at address aligned to the requested alignment.
Definition: ut0new.h:1593
void * zalloc_withkey(PSI_memory_key_t key, std::size_t size) noexcept
Dynamically allocates zero-initialized storage of given size.
Definition: ut0new.h:631
void * malloc_withkey(PSI_memory_key_t key, std::size_t size) noexcept
Dynamically allocates storage of given size.
Definition: ut0new.h:595
std::enable_if_t<!std::is_array< T >::value, std::unique_ptr< T, Deleter > > make_unique(Args &&... args)
Dynamically allocates storage for an object of type T.
Definition: ut0new.h:2336
T * aligned_new_arr(std::size_t alignment, Args &&... args)
Dynamically allocates storage for an array of T's at address aligned to the requested alignment.
Definition: ut0new.h:1837
void * aligned_zalloc(std::size_t size, std::size_t alignment) noexcept
Dynamically allocates zero-initialized storage of given size and at the address aligned to the reques...
Definition: ut0new.h:1548
void * malloc_large_page(std::size_t size) noexcept
Dynamically allocates memory backed up by large (huge) pages.
Definition: ut0new.h:1270
std::unordered_set< Key, std::hash< Key >, std::equal_to< Key >, ut::allocator< Key > > unordered_set
Definition: ut0new.h:2886
std::basic_ostringstream< char, std::char_traits< char >, ut::allocator< char > > ostringstream
Specialization of basic_ostringstream which uses ut::allocator.
Definition: ut0new.h:2869
T * new_(Args &&... args)
Dynamically allocates storage for an object of type T.
Definition: ut0new.h:793
allocation_low_level_info page_low_level_info(void *ptr) noexcept
Retrieves the pointer and size of the allocation provided by the OS.
Definition: ut0new.h:1208
std::vector< T, ut::allocator< T > > vector
Specialization of vector which uses allocator.
Definition: ut0new.h:2873
void aligned_delete_arr(T *ptr) noexcept
Releases storage which has been dynamically allocated through any of the aligned_new_arr_*() variants...
Definition: ut0new.h:1894
void delete_(T *ptr) noexcept
Releases storage which has been dynamically allocated through any of the ut::new*() variants.
Definition: ut0new.h:808
std::set< Key, Compare, ut::allocator< Key > > set
Specialization of set which uses ut_allocator.
Definition: ut0new.h:2881
void * malloc_page(std::size_t size) noexcept
Dynamically allocates system page-aligned storage of given size.
Definition: ut0new.h:1174
void * realloc_withkey(PSI_memory_key_t key, void *ptr, std::size_t size) noexcept
Upsizes or downsizes already dynamically allocated storage to the new size.
Definition: ut0new.h:674
T * new_withkey(PSI_memory_key_t key, Args &&... args)
Dynamically allocates storage for an object of type T.
Definition: ut0new.h:750
void delete_arr(T *ptr) noexcept
Releases storage which has been dynamically allocated through any of the ut::new_arr*() variants.
Definition: ut0new.h:1108
allocation_low_level_info large_page_low_level_info(void *ptr) noexcept
Retrieves the pointer and size of the allocation provided by the OS.
Definition: ut0new.h:1306
std::enable_if_t<!std::is_array< T >::value, std::unique_ptr< T, Deleter > > make_unique_aligned(size_t alignment, Args &&... args)
Dynamically allocates storage for an object of type T at address aligned to the requested alignment.
Definition: ut0new.h:2458
T * new_arr(Args &&... args)
Dynamically allocates storage for an array of T's.
Definition: ut0new.h:958
bool free_page(void *ptr) noexcept
Releases storage which has been dynamically allocated through any of the ut::malloc_page*() variants.
Definition: ut0new.h:1224
void * malloc_large_page_withkey(PSI_memory_key_t key, std::size_t size) noexcept
Dynamically allocates memory backed up by large (huge) pages.
Definition: ut0new.h:1246
size_t large_page_allocation_size(void *ptr) noexcept
Retrieves the total amount of bytes that are available for application code to use.
Definition: ut0new.h:1292
std::enable_if_t<!std::is_array< T >::value, std::shared_ptr< T > > make_shared_aligned(size_t alignment, Args &&... args)
Dynamically allocates storage for an object of type T at address aligned to the requested alignment.
Definition: ut0new.h:2729
std::map< Key, Value, Compare, ut::allocator< std::pair< const Key, Value > > > map
Specialization of map which uses ut_allocator.
Definition: ut0new.h:2891
void * malloc(std::size_t size) noexcept
Dynamically allocates storage of given size.
Definition: ut0new.h:616
std::conditional_t< !std::is_array< T >::value, std::unique_ptr< T, detail::Deleter< T > >, std::conditional_t< detail::is_unbounded_array_v< T >, std::unique_ptr< T, detail::Array_deleter< std::remove_extent_t< T > > >, void > > unique_ptr
The following is a common type that is returned by all the ut::make_unique (non-aligned) specializati...
Definition: ut0new.h:2437
T * aligned_new(std::size_t alignment, Args &&... args)
Dynamically allocates storage for an object of type T at address aligned to the requested alignment.
Definition: ut0new.h:1634
std::list< T, ut::allocator< T > > list
Specialization of list which uses ut_allocator.
Definition: ut0new.h:2877
void free(void *ptr) noexcept
Releases storage which has been dynamically allocated through any of the ut::malloc*(),...
Definition: ut0new.h:716
PSI_memory_key_t make_psi_memory_key(PSI_memory_key key)
Convenience helper function to create type-safe representation of PSI_memory_key.
Definition: ut0new.h:189
void * aligned_alloc_withkey(PSI_memory_key_t key, std::size_t size, std::size_t alignment) noexcept
Dynamically allocates storage of given size and at the address aligned to the requested alignment.
Definition: ut0new.h:1483
constexpr bool WITH_PFS_MEMORY
Definition: ut0new.h:579
void aligned_delete(T *ptr) noexcept
Releases storage which has been dynamically allocated through any of the aligned_new_*() variants.
Definition: ut0new.h:1649
void * malloc_page_withkey(PSI_memory_key_t key, std::size_t size) noexcept
Dynamically allocates system page-aligned storage of given size.
Definition: ut0new.h:1147
std::conditional_t< !std::is_array< T >::value, std::unique_ptr< T, detail::Aligned_deleter< T > >, std::conditional_t< detail::is_unbounded_array_v< T >, std::unique_ptr< T, detail::Aligned_array_deleter< std::remove_extent_t< T > > >, void > > unique_ptr_aligned
The following is a common type that is returned by all the ut::make_unique_aligned (non-aligned) spec...
Definition: ut0new.h:2571
void * realloc(void *ptr, std::size_t size) noexcept
Upsizes or downsizes already dynamically allocated storage to the new size.
Definition: ut0new.h:702
std::enable_if_t<!std::is_array< T >::value, std::shared_ptr< T > > make_shared(Args &&... args)
Dynamically allocates storage for an object of type T.
Definition: ut0new.h:2589
size_t page_allocation_size(void *ptr) noexcept
Retrieves the total amount of bytes that are available for application code to use.
Definition: ut0new.h:1194
bool free_large_page(void *ptr) noexcept
Releases storage which has been dynamically allocated through any of the ut::malloc_large_page*() var...
Definition: ut0new.h:1323
T * aligned_new_arr_withkey(PSI_memory_key_t key, std::size_t alignment, Args &&... args)
Dynamically allocates storage for an array of T's at address aligned to the requested alignment.
Definition: ut0new.h:1714
void aligned_free(void *ptr) noexcept
Releases storage which has been dynamically allocated through any of the aligned_alloc_*() or aligned...
Definition: ut0new.h:1562
void * aligned_alloc(std::size_t size, std::size_t alignment) noexcept
Dynamically allocates storage of given size and at the address aligned to the requested alignment.
Definition: ut0new.h:1506
void * zalloc(std::size_t size) noexcept
Dynamically allocates zero-initialized storage of given size.
Definition: ut0new.h:652
The interface to the operating system process control primitives.
bool os_use_large_pages
Whether to use large pages in the buffer pool.
Definition: os0proc.cc:50
The interface to the operating system process and thread control primitives.
Performance schema instrumentation interface.
Performance schema instrumentation interface.
required string key
Definition: replication_asynchronous_connection_failover.proto:59
static MEM_ROOT mem
Definition: sql_servers.cc:99
Memory instrument information.
Definition: psi_memory_bits.h:57
static constexpr int value
Definition: ut0new.h:557
Light-weight and type-safe wrapper which serves a purpose of being able to select proper ut::new_arr*...
Definition: ut0new.h:980
Count(size_t count)
Definition: ut0new.h:981
size_t m_count
Definition: ut0new.h:983
size_t operator()() const
Definition: ut0new.h:982
Light-weight and type-safe wrapper around the PSI_memory_key that eliminates the possibility of intro...
Definition: ut0new.h:177
PSI_memory_key operator()() const
Definition: ut0new.h:179
PSI_memory_key m_key
Definition: ut0new.h:180
PSI_memory_key_t(PSI_memory_key key)
Definition: ut0new.h:178
Can be used to extract pointer and size of the allocation provided by the OS.
Definition: ut0new.h:139
void * base_ptr
A pointer returned by the OS allocator.
Definition: ut0new.h:141
size_t allocation_size
The size of allocation that OS performed.
Definition: ut0new.h:143
Definition: ut0new.h:2222
Small wrapper which utilizes SFINAE to dispatch the call to appropriate aligned allocator implementat...
Definition: aligned_alloc.h:696
Definition: ut0new.h:2313
void operator()(T *ptr)
Definition: ut0new.h:2314
Definition: ut0new.h:2308
void operator()(T *ptr)
Definition: ut0new.h:2309
Small wrapper which utilizes SFINAE to dispatch the call to appropriate allocator implementation.
Definition: alloc.h:434
Definition: ut0new.h:2303
void operator()(T *ptr)
Definition: ut0new.h:2304
Definition: ut0new.h:2298
void operator()(T *ptr)
Definition: ut0new.h:2299
Small wrapper which utilizes SFINAE to dispatch the call to appropriate aligned allocator implementat...
Definition: large_page_alloc.h:372
Small wrapper which utilizes SFINAE to dispatch the call to appropriate aligned allocator implementat...
Definition: page_alloc.h:433
Definition: ut0new.h:2130
void * allocate_impl(size_t n_bytes)
Definition: ut0new.h:2139
const PSI_memory_key m_key
Definition: ut0new.h:2144
PSI_memory_key get_mem_key() const
Definition: ut0new.h:2137
allocator_base_pfs(PSI_memory_key key)
Definition: ut0new.h:2131
allocator_base_pfs(const allocator_base_pfs< U > &other)
Definition: ut0new.h:2134
Definition: ut0new.h:2120
allocator_base(const allocator_base< U > &)
Definition: ut0new.h:2124
void * allocate_impl(size_t n_bytes)
Definition: ut0new.h:2126
allocator_base(PSI_memory_key)
Definition: ut0new.h:2121
Definition: ut0new.h:1330
Version control for database, common definitions, and include files.
#define UT_ARR_SIZE(a)
Definition: univ.i:523
Utilities for byte operations.
Utilities related to CPU cache.
Debug utilities for Innobase.
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:68
#define ut_a(EXPR)
Abort execution if EXPR does not evaluate to nonzero.
Definition: ut0dbg.h:56
PSI_memory_key mem_key_ddl
Definition: ut0new.cc:59
void ut_new_boot_safe()
Setup the internal objects needed for ut::*_withkey() to operate.
Definition: ut0new.cc:136
PSI_memory_key mem_key_redo_log_archive_queue_element
PSI_memory_key mem_key_dict_stats_index_map_t
Definition: ut0new.cc:53
PSI_memory_key mem_key_buf_stat_per_index_t
Definition: ut0new.cc:49
PSI_memory_key mem_key_other
Definition: ut0new.cc:56
PSI_memory_info pfs_info_auto[n_auto]
PSI_memory_key auto_event_keys[n_auto]
constexpr int ut_new_get_key_by_base_file(const char *file, size_t len)
Retrieve a memory key (registered with PFS), given the file name of the caller.
Definition: ut0new.h:535
PSI_memory_key mem_key_fil_space_t
Definition: ut0new.cc:55
constexpr bool ut_string_begins_with(const char *a, const char *b, size_t b_len)
gcc 5 fails to evaluate costexprs at compile time.
Definition: ut0new.h:509
constexpr int ut_new_get_key_by_file(const char *file)
Retrieve a memory key (registered with PFS), given the file name of the caller.
Definition: ut0new.h:548
PSI_memory_key mem_key_ahi
Keys for registering allocations with performance schema.
Definition: ut0new.cc:46
void ut_new_boot()
Setup the internal objects needed for ut::*_withkey() to operate.
Definition: ut0new.cc:117
PSI_memory_key mem_key_partitioning
Definition: ut0new.cc:57
PSI_memory_key mem_key_archive
Definition: ut0new.cc:47
static constexpr const char * auto_event_names[]
List of filenames that allocate memory and are instrumented via PFS.
Definition: ut0new.h:245
PSI_memory_key mem_key_std
Definition: ut0new.cc:60
const size_t alloc_max_retries
Maximum number of retries to allocate memory.
Definition: ut0new.cc:42
PSI_memory_key mem_key_row_log_buf
Definition: ut0new.cc:58
PSI_memory_key mem_key_trx_sys_t_rw_trx_ids
Definition: ut0new.cc:61
static constexpr size_t n_auto
Definition: ut0new.h:446
PSI_memory_key mem_key_buf_buf_pool
Definition: ut0new.cc:48
constexpr size_t ut_len_without_extension(const char *file)
Find the length of the filename without its file extension.
Definition: ut0new.h:522
PSI_memory_key mem_key_undo_spaces
Definition: ut0new.cc:62
PSI_memory_key mem_key_ut_lock_free_hash_t
Definition: ut0new.cc:63
PSI_memory_key mem_key_clone
Memory key for clone.
Definition: ut0new.cc:51
PSI_memory_key mem_key_dict_stats_n_diff_on_level
Definition: ut0new.cc:54
PSI_memory_key mem_key_dict_stats_bg_recalc_pool_t
Definition: ut0new.cc:52
#define PSI_NOT_INSTRUMENTED
Definition: validate_password_imp.cc:41