Code object, kernel dispatch, and memory copy tracing (#177)
* Update samples/api_buffered_tracing
- external correlation id
- support ROCPROFILER_BUFFER_TRACING_KERNEL_DISPATCH
* Update lib/rocprofiler/context.cpp
- update alternative get_active_contexts paradigm
* Update lib/rocprofiler/external_correlation.cpp
- inherit correlation id from main thread
* Update lib/rocprofiler/hsa/queue.*
- typedef changes
- rocprofiler_packet union
- modify Queue::queue_info_session_t
- use rocprofiler_packet
- add thread id
- add kernel id
- add correlation id
- out of line definitions
- AsyncSignalHandler function update
- handle kernel dispatch tracing
- Move CreateBarrierPacket and AddVendorSpecificPacket to lambdas
- handle contexts
* Update lib/rocprofiler/hsa/hsa.cpp
- remove unnecessary log function
- use new get_active_contexts paradigm
- use new correlation id updates
* Update AgentCache and kernel dispatch record
- include const rocprofiler_agent_t* in rocprofiler_buffer_tracing_kernel_dispatch_record_t
- AgentCache::get_rocp_agent returns const pointer
* Replace ROCPROFILER_SERVICE_ with ROCPROFILER_
* source formatting
* Code Object Tracing
- include/rocprofiler/callback_tracing.h
- remove rocprofiler_callback_tracing_code_object_unload_data_t
- remove rocprofiler_callback_tracing_code_object_kernel_symbol_register_data_t
- include/rocprofiler/fwd.h
- remove ROCPROFILER_CALLBACK_TRACING_CODE_OBJECT_UNLOAD
- remove ROCPROFILER_CALLBACK_TRACING_CODE_OBJECT_DEVICE_KERNEL_SYMBOL_UNREGISTER
- lib/common/utility.hpp
- assert_public_api_struct_properties()
- init_public_api_struct(...)
- lib/rocprofiler/registration.cpp
- invoke hsa::code_object_init
- lib/rocprofiler/hsa/CMakeLists.txt
- compile code_object code
- lib/rocprofiler/hsa/code_object.{hpp,cpp}
- tracing code object load/unload
- lib/rocprofiler/hsa/queue.cpp
- get_kernel_id
* Update lib/rocprofiler/hsa/hsa.cpp
- fix should_wrap_functor logic (which was not handling callback_tracer + buffered_tracer properly)
* Update lib/rocprofiler/hsa/queue.cpp
- fix rocprofiler_buffer_tracing_kernel_dispatch_record_t construction
* Update samples/api_buffered_tracing/client.cpp
- print kernel names
* Move samples/apps to tests/apps
* Update lib/rocprofiler/hsa/code_object.cpp
- ensure unload callbacks when application is exiting
- support user data in between load/unload callbacks
* Update lib/rocprofiler/hsa/queue.{hpp,cpp}
- store contexts and external correlation ids in queue_info_session
- reduce signal_limiter to 96 to fix hangs
- fix support for kernel tracing and async memory copies
* Add lib/common/scope_destructor.hpp
- similar to static_cleanup_wrapper but different
* Update include/rocprofiler/buffer_tracing.h
- update rocprofiler_buffer_tracing_memory_copy_record_t
- remove operation: user can figure that out from correlation id
- add kernel id
- add rocprofiler agent id
* Update include/rocprofiler/callback_tracing.h
- fix data type of load_delta field in code object
- remove rocp_agent from kernel_symbol_register_data_t (known via code_object_id)
* Add samples/code_object_tracing
- sample demonstrating code object tracing
* Update samples
- minor tweak to print_call_stack
* Update lib/rocprofiler/hsa/code_object.cpp
- flip ordering of unload callbacks for code object unloading and kernel symbol deregistering
* clang-tidy fixes
* Update lib/rocprofiler/hsa/code_object.cpp
- fix heap-use-after-free issue with code object
* Update include/rocprofiler/external_correlation.h
- update documentation to include info about default value of external correlation value
* Use common::container::small_vector for contexts
- small_vector<const context*> is an ideal data structure for array of active contexts
* Update context handling for code object unload
- code object unload is only called for contexts which received the load callback
* Update samples
- improve ROCPROFILER_CALL macro to include status string
- api_buffered_tracing handles ROCPROFILER_STATUS_ERROR_BUFFER_BUSY
* Code object shutdown
- ensure code object callbacks are invoked prior to finalizing
* Update lib/common (memory allocators)
- added lib/common/memory folder with allocators
* Add lib/rocprofiler/allocator.*
- rocprofiler::allocator::static_data_allocator
- special allocator for static data which finalizes before any data gets destroyed
- rocprofiler::allocator::unique_static_ptr_t
- unique_ptr that uses static data deleter (ensure finalize is called)
* Update lib/rocprofiler/buffer.cpp
- flush checks fini status
- use unique_static_ptr_t
* Update lib/rocprofiler/internal_threading.*
- change meaning of thread_pool_t and task_group_t
- improve finalization to prevent data races and heap-use-after-free
* Update lib/rocprofiler/registration.cpp
- use static_data_allocator for client_library vector
* Update lib/rocprofiler/context/context.*
- use allocator::unique_static_ptr_t
* Update lib/rocprofiler/allocator.cpp
- avoid deadlock in deleter<static_data>::operator()
* Update lib/rocprofiler/registration.cpp
- avoid deadlock in rocprofiler::registration::finalize()
* Update lib/rocprofiler/hsa/code_object.cpp
- suppress duplicate reporting of code-object/kernel-symbol load/unload
* Update leak sanitizer suppressions
- __new_exitfn (via stdlib/cxa_atexit.c leaks
[ROCm/rocprofiler-sdk commit: 3082288a25]
This commit is contained in:
Jonathan R. Madsen
committed by
GitHub
GitHub
parent
c57bfb22f8
commit
6108ea7efd
@@ -0,0 +1,7 @@
|
||||
#
|
||||
# add container sources and headers to common library target
|
||||
#
|
||||
set(memory_headers deleter.hpp pool.hpp pool_allocator.hpp stateless_allocator.hpp)
|
||||
set(memory_sources)
|
||||
|
||||
target_sources(rocprofiler-common-library PRIVATE ${memory_sources} ${memory_headers})
|
||||
@@ -0,0 +1,46 @@
|
||||
// Copyright (c) 2023 Advanced Micro Devices, Inc.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in
|
||||
// all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
// THE SOFTWARE.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "lib/common/defines.hpp"
|
||||
|
||||
namespace rocprofiler
|
||||
{
|
||||
namespace common
|
||||
{
|
||||
namespace memory
|
||||
{
|
||||
// this type is a template parameter for allocators to execute a function when the allocator
|
||||
// destroys an object. In the rocprofiler library, this is used to ensure
|
||||
// rocprofiler::registration::finalize is called on the first instance of a data structure being
|
||||
// destroyed after main exits
|
||||
template <typename Tp>
|
||||
struct deleter;
|
||||
|
||||
// default deleter type
|
||||
template <>
|
||||
struct deleter<void>
|
||||
{
|
||||
constexpr void operator()() const {}
|
||||
};
|
||||
} // namespace memory
|
||||
} // namespace common
|
||||
} // namespace rocprofiler
|
||||
@@ -0,0 +1,101 @@
|
||||
// Copyright (c) 2023 Advanced Micro Devices, Inc.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in
|
||||
// all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
// THE SOFTWARE.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "lib/common/defines.hpp"
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <cstdlib>
|
||||
#include <memory>
|
||||
#include <stack>
|
||||
#include <stdexcept>
|
||||
|
||||
namespace rocprofiler
|
||||
{
|
||||
namespace common
|
||||
{
|
||||
namespace memory
|
||||
{
|
||||
template <size_t BlockSize, size_t ReservedBlocks = 0>
|
||||
class pool
|
||||
{
|
||||
public:
|
||||
explicit pool(size_t size)
|
||||
: m_size(size)
|
||||
{
|
||||
for(size_t i = 0; i < ReservedBlocks; i++)
|
||||
{
|
||||
append();
|
||||
}
|
||||
}
|
||||
|
||||
void* allocate()
|
||||
{
|
||||
if(m_addrs.empty())
|
||||
{
|
||||
append();
|
||||
}
|
||||
|
||||
auto* ptr = m_addrs.top();
|
||||
m_addrs.pop();
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void deallocate(void* ptr) { m_addrs.push(ptr); }
|
||||
|
||||
void rebind(size_t size)
|
||||
{
|
||||
if(!(m_addrs.empty() && m_blocks.empty()))
|
||||
{
|
||||
throw std::runtime_error{"cannot call pool::rebind() after alloc"};
|
||||
::abort();
|
||||
}
|
||||
|
||||
m_size = size;
|
||||
}
|
||||
|
||||
private:
|
||||
// Refill the address stack by allocating another block of memory
|
||||
void append()
|
||||
{
|
||||
auto block = std::make_unique<uint8_t[]>(BlockSize);
|
||||
auto total_size = BlockSize % m_size == 0 ? BlockSize : BlockSize - m_size;
|
||||
|
||||
// Divide the block into chunks of m_size bytes, and add their addrs
|
||||
for(size_t i = 0; i < total_size; i += m_size)
|
||||
{
|
||||
m_addrs.push(&block.get()[i]);
|
||||
}
|
||||
|
||||
// Keep the memory of the block alive by adding it to our stack
|
||||
m_blocks.push(std::move(block));
|
||||
}
|
||||
|
||||
private:
|
||||
size_t m_size = {};
|
||||
std::stack<void*> m_addrs = {};
|
||||
std::stack<std::unique_ptr<uint8_t[]>> m_blocks = {};
|
||||
};
|
||||
|
||||
} // namespace memory
|
||||
} // namespace common
|
||||
} // namespace rocprofiler
|
||||
@@ -0,0 +1,174 @@
|
||||
// Copyright (c) 2023 Advanced Micro Devices, Inc.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in
|
||||
// all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
// THE SOFTWARE.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "lib/common/defines.hpp"
|
||||
#include "lib/common/memory/deleter.hpp"
|
||||
#include "lib/common/memory/pool.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstddef>
|
||||
#include <cstdlib>
|
||||
#include <memory>
|
||||
|
||||
namespace rocprofiler
|
||||
{
|
||||
namespace common
|
||||
{
|
||||
namespace memory
|
||||
{
|
||||
// template <typename Tp, size_t Alignment, size_t BlockSize, size_t ReservedBlocks, typename
|
||||
// DeleterT> pool_allocator<Tp, Alignment, BlockSize, ReservedBlocks, DeleterT>::
|
||||
template <typename Tp,
|
||||
size_t Alignment = 64,
|
||||
size_t BlockSize = 4096,
|
||||
size_t ReservedBlocks = 0,
|
||||
typename DeleterT = deleter<void>>
|
||||
class pool_allocator
|
||||
{
|
||||
public:
|
||||
using value_type = Tp;
|
||||
using pointer = Tp*;
|
||||
using const_pointer = const Tp*;
|
||||
using reference = Tp&;
|
||||
using const_reference = const Tp&;
|
||||
using size_type = size_t;
|
||||
using difference_type = ptrdiff_t;
|
||||
using propagate_on_container_move_assignment = std::false_type;
|
||||
using is_always_equal = value_type;
|
||||
|
||||
pool_allocator() = default;
|
||||
|
||||
// Rebind copy constructor
|
||||
template <typename Up>
|
||||
pool_allocator(const pool_allocator<Up>& rhs);
|
||||
|
||||
pool_allocator(const pool_allocator& rhs) = default;
|
||||
pool_allocator(pool_allocator&& rhs) noexcept = default;
|
||||
pool_allocator& operator=(const pool_allocator& rhs) = default;
|
||||
pool_allocator& operator=(pool_allocator&& rhs) noexcept = default;
|
||||
|
||||
value_type* allocate(size_t n);
|
||||
void deallocate(value_type* ptr, size_t n);
|
||||
void construct(value_type* const _p, const value_type& _v) const;
|
||||
void construct(value_type* const _p, value_type&& _v) const;
|
||||
void construct_at(value_type* const _p, const value_type& _v) const;
|
||||
void construct_at(value_type* const _p, value_type&& _v) const;
|
||||
void destroy(value_type* const _p) const;
|
||||
void destroy_at(value_type* const _p) const;
|
||||
|
||||
template <typename Up>
|
||||
struct rebind
|
||||
{
|
||||
using other = pool_allocator<Up, Alignment, BlockSize, ReservedBlocks>;
|
||||
};
|
||||
|
||||
private:
|
||||
using pool_type = pool<BlockSize, ReservedBlocks>;
|
||||
|
||||
std::shared_ptr<pool_type> m_pool = std::make_shared<pool_type>(sizeof(value_type));
|
||||
};
|
||||
|
||||
template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedBlocks, typename DeleterT>
|
||||
template <typename Up>
|
||||
pool_allocator<Tp, AlignV, BlockSz, ReservedBlocks, DeleterT>::pool_allocator(
|
||||
const pool_allocator<Up>& rhs)
|
||||
: m_pool{rhs.m_pool}
|
||||
{
|
||||
m_pool->rebind(sizeof(value_type));
|
||||
}
|
||||
|
||||
template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedBlocks, typename DeleterT>
|
||||
typename pool_allocator<Tp, AlignV, BlockSz, ReservedBlocks, DeleterT>::value_type*
|
||||
pool_allocator<Tp, AlignV, BlockSz, ReservedBlocks, DeleterT>::allocate(size_t n)
|
||||
{
|
||||
if(n > 1)
|
||||
{
|
||||
return static_cast<value_type*>(::aligned_alloc(AlignV, sizeof(value_type) * n));
|
||||
}
|
||||
|
||||
return static_cast<value_type*>(m_pool->allocate());
|
||||
}
|
||||
|
||||
template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedBlocks, typename DeleterT>
|
||||
void
|
||||
pool_allocator<Tp, AlignV, BlockSz, ReservedBlocks, DeleterT>::deallocate(value_type* ptr, size_t n)
|
||||
{
|
||||
DeleterT{}();
|
||||
if(n > 1)
|
||||
{
|
||||
::free(ptr);
|
||||
return;
|
||||
}
|
||||
|
||||
m_pool->deallocate(ptr);
|
||||
}
|
||||
|
||||
template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedV, typename DeleterT>
|
||||
void
|
||||
pool_allocator<Tp, AlignV, BlockSz, ReservedV, DeleterT>::construct(value_type* const _p,
|
||||
const value_type& _v) const
|
||||
{
|
||||
::new((void*) _p) value_type{_v};
|
||||
}
|
||||
|
||||
template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedV, typename DeleterT>
|
||||
void
|
||||
pool_allocator<Tp, AlignV, BlockSz, ReservedV, DeleterT>::construct(value_type* const _p,
|
||||
value_type&& _v) const
|
||||
{
|
||||
::new((void*) _p) value_type{std::move(_v)};
|
||||
}
|
||||
|
||||
template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedV, typename DeleterT>
|
||||
void
|
||||
pool_allocator<Tp, AlignV, BlockSz, ReservedV, DeleterT>::construct_at(value_type* const _p,
|
||||
const value_type& _v) const
|
||||
{
|
||||
::new((void*) _p) value_type{_v};
|
||||
}
|
||||
|
||||
template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedV, typename DeleterT>
|
||||
void
|
||||
pool_allocator<Tp, AlignV, BlockSz, ReservedV, DeleterT>::construct_at(value_type* const _p,
|
||||
value_type&& _v) const
|
||||
{
|
||||
::new((void*) _p) value_type{std::move(_v)};
|
||||
}
|
||||
|
||||
template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedV, typename DeleterT>
|
||||
void
|
||||
pool_allocator<Tp, AlignV, BlockSz, ReservedV, DeleterT>::destroy(value_type* const _p) const
|
||||
{
|
||||
DeleterT{}();
|
||||
_p->~value_type();
|
||||
}
|
||||
|
||||
template <typename Tp, size_t AlignV, size_t BlockSz, size_t ReservedV, typename DeleterT>
|
||||
void
|
||||
pool_allocator<Tp, AlignV, BlockSz, ReservedV, DeleterT>::destroy_at(value_type* const _p) const
|
||||
{
|
||||
DeleterT{}();
|
||||
_p->~value_type();
|
||||
}
|
||||
} // namespace memory
|
||||
} // namespace common
|
||||
} // namespace rocprofiler
|
||||
@@ -0,0 +1,181 @@
|
||||
// Copyright (c) 2023 Advanced Micro Devices, Inc.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in
|
||||
// all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
// THE SOFTWARE.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "lib/common/defines.hpp"
|
||||
#include "lib/common/memory/deleter.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstddef>
|
||||
#include <cstdlib>
|
||||
#include <new>
|
||||
#include <stdexcept>
|
||||
|
||||
namespace rocprofiler
|
||||
{
|
||||
namespace common
|
||||
{
|
||||
namespace memory
|
||||
{
|
||||
template <typename Tp, size_t Alignment = 64, typename DeleterT = deleter<void>>
|
||||
class stateless_allocator
|
||||
{
|
||||
public:
|
||||
using value_type = Tp;
|
||||
using pointer = Tp*;
|
||||
using const_pointer = const Tp*;
|
||||
using reference = Tp&;
|
||||
using const_reference = const Tp&;
|
||||
using size_type = size_t;
|
||||
using difference_type = ptrdiff_t;
|
||||
using propagate_on_container_move_assignment = std::true_type;
|
||||
|
||||
template <typename Up>
|
||||
struct rebind
|
||||
{
|
||||
using other = stateless_allocator<Up, Alignment, DeleterT>;
|
||||
};
|
||||
|
||||
stateless_allocator() = default;
|
||||
stateless_allocator(const stateless_allocator& rhs) = default;
|
||||
stateless_allocator(stateless_allocator&& rhs) noexcept = default;
|
||||
stateless_allocator& operator=(const stateless_allocator& rhs) = default;
|
||||
stateless_allocator& operator=(stateless_allocator&& rhs) noexcept = default;
|
||||
|
||||
template <typename Up>
|
||||
stateless_allocator(const stateless_allocator<Up, Alignment, DeleterT>& rhs);
|
||||
|
||||
static Tp* allocate(size_t n);
|
||||
static void deallocate(Tp* ptr, size_t n);
|
||||
static void construct(value_type* const _p, const value_type& _v);
|
||||
static void construct(value_type* const _p, value_type&& _v);
|
||||
static void construct_at(value_type* const _p, const value_type& _v);
|
||||
static void construct_at(value_type* const _p, value_type&& _v);
|
||||
static void destroy(value_type* const _p);
|
||||
static void destroy_at(value_type* const _p);
|
||||
};
|
||||
|
||||
template <typename Tp, size_t Alignment, typename DeleterT>
|
||||
template <typename Up>
|
||||
stateless_allocator<Tp, Alignment, DeleterT>::stateless_allocator(
|
||||
const stateless_allocator<Up, Alignment, DeleterT>& rhs)
|
||||
{
|
||||
(void) rhs;
|
||||
}
|
||||
|
||||
template <typename Tp, size_t Alignment, typename DeleterT>
|
||||
Tp*
|
||||
stateless_allocator<Tp, Alignment, DeleterT>::allocate(size_t n)
|
||||
{
|
||||
constexpr auto alignment_v = Alignment / sizeof(void*);
|
||||
Tp* ptr = nullptr;
|
||||
|
||||
if constexpr(sizeof(Tp) >= alignment_v && sizeof(Tp) % alignment_v == 0)
|
||||
ptr = static_cast<Tp*>(::aligned_alloc(Alignment / sizeof(void*), sizeof(Tp) * n));
|
||||
else
|
||||
ptr = static_cast<Tp*>(::malloc(sizeof(Tp) * n));
|
||||
|
||||
if(ptr) return ptr;
|
||||
|
||||
throw std::bad_alloc{};
|
||||
}
|
||||
|
||||
template <typename Tp, size_t Alignment, typename DeleterT>
|
||||
void
|
||||
stateless_allocator<Tp, Alignment, DeleterT>::deallocate(Tp* ptr, size_t n)
|
||||
{
|
||||
(void) n;
|
||||
::free(ptr);
|
||||
}
|
||||
|
||||
template <typename Tp, size_t Alignment, typename DeleterT>
|
||||
void
|
||||
stateless_allocator<Tp, Alignment, DeleterT>::construct(value_type* const _p, const value_type& _v)
|
||||
{
|
||||
::new((void*) _p) value_type{_v};
|
||||
}
|
||||
|
||||
template <typename Tp, size_t Alignment, typename DeleterT>
|
||||
void
|
||||
stateless_allocator<Tp, Alignment, DeleterT>::construct(value_type* const _p, value_type&& _v)
|
||||
{
|
||||
::new((void*) _p) value_type{std::move(_v)};
|
||||
}
|
||||
|
||||
template <typename Tp, size_t Alignment, typename DeleterT>
|
||||
void
|
||||
stateless_allocator<Tp, Alignment, DeleterT>::construct_at(value_type* const _p,
|
||||
const value_type& _v)
|
||||
{
|
||||
::new((void*) _p) value_type{_v};
|
||||
}
|
||||
|
||||
template <typename Tp, size_t Alignment, typename DeleterT>
|
||||
void
|
||||
stateless_allocator<Tp, Alignment, DeleterT>::construct_at(value_type* const _p, value_type&& _v)
|
||||
{
|
||||
::new((void*) _p) value_type{std::move(_v)};
|
||||
}
|
||||
|
||||
template <typename Tp, size_t Alignment, typename DeleterT>
|
||||
void
|
||||
stateless_allocator<Tp, Alignment, DeleterT>::destroy(value_type* const _p)
|
||||
{
|
||||
DeleterT{}();
|
||||
_p->~value_type();
|
||||
}
|
||||
|
||||
template <typename Tp, size_t Alignment, typename DeleterT>
|
||||
void
|
||||
stateless_allocator<Tp, Alignment, DeleterT>::destroy_at(value_type* const _p)
|
||||
{
|
||||
DeleterT{}();
|
||||
_p->~value_type();
|
||||
}
|
||||
|
||||
template <typename LhsTp,
|
||||
size_t LhsAlignment,
|
||||
typename LhsDeleterT,
|
||||
typename RhsTp,
|
||||
size_t RhsAlignment,
|
||||
typename RhsDeleterT>
|
||||
constexpr bool
|
||||
operator==(const stateless_allocator<LhsTp, LhsAlignment, LhsDeleterT>&,
|
||||
const stateless_allocator<RhsTp, RhsAlignment, RhsDeleterT>&)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename LhsTp,
|
||||
size_t LhsAlignment,
|
||||
typename LhsDeleterT,
|
||||
typename RhsTp,
|
||||
size_t RhsAlignment,
|
||||
typename RhsDeleterT>
|
||||
constexpr bool
|
||||
operator!=(const stateless_allocator<LhsTp, LhsAlignment, LhsDeleterT>&,
|
||||
const stateless_allocator<RhsTp, RhsAlignment, RhsDeleterT>&)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
} // namespace memory
|
||||
} // namespace common
|
||||
} // namespace rocprofiler
|
||||
Reference in New Issue
Block a user