AI/rocm-systems
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Generalized updates (#174)

Browse Source 
- include/rocprofiler/agent.h
  - move rocprofiler_dim3_t
- include/rocprofiler/buffer_tracing.h
  - size fields
  - update kernel dispatch record
- include/rocprofiler/callback_tracing.h
  - remove rocprofiler_callback_tracing_code_object_unload_data_t
  - remove rocprofiler_callback_tracing_code_object_register_host_kernel_symbol_data_t
- include/rocprofiler/fwd.h
  - added ROCPROFILER_STATUS_ERROR_CONTEXT_CONFLICT
  - remove ROCPROFILER_CALLBACK_TRACING_CODE_OBJECT_UNLOAD
  - remove ROCPROFILER_CALLBACK_TRACING_CODE_OBJECT_DEVICE_KERNEL_SYMBOL_UNREGISTER
  - add rocprofiler_kernel_id_t typedef
  - add rocprofiler_dim3_t (moved from agent.h)
- lib/common/synchronized.hpp
  - rlock/wlock return decltype(auto)
  - separate prototype from definition
- lib/common/utility.{hpp,cpp}
  - timestamp functions replicating HSA implementation(s)
  - init_public_api_struct for setting size field and ensuring certain type traits
  - simplified static_cleanup_wrapper
  - separate prototype from definition in active_capacity_gate
- lib/rocprofiler/agent.cpp
  - tweak get_rocprofiler_agent impl
- lib/rocprofiler/buffer.cpp
  - fix buffer message log level
- lib/rocprofiler/context.cpp
  - use new paradigm for getting active contexts
- lib/rocprofiler/internal_threading.hpp
  - update to simplified static_cleanup_wrapper implementation
- lib/rocprofiler/registration.cpp
  - fix deactivating contexts
- lib/rocprofiler/rocprofiler.cpp
  - status string for context conflict
- lib/rocprofiler/context/context.*
  - correlation_id struct
  - new get_active_contexts paradigm
- lib/rocprofiler/counters/core.*
  - rocprofiler_packet union
  - tweak start/stop context to accept pointer instead of handle
- lib/rocprofiler/counters/dimensions.cpp
  - update to new get_rocp_agent() return type
- lib/rocprofiler/hsa/hsa.*
  - update to new get_active_contexts paradigm
  - update to new correlation id implementation
  - guard against hsa.def.cpp direct compilation
- lib/rocprofiler/hsa/queue_controller.*
  - update to change in get_rocp_agent return type
  - consistent aliases
  - lookup function for getting queue pointer from hsa queue id
- lib/rocprofiler/hsa/queue.*
  - rocprofiler_packet
  - extend queue_info_session_t
- lib/rocprofiler/tests/registration.cpp
  - improve diagnostic on perf check for rocprofiler_lib.callback_registration_lambda_with_result
This commit is contained in:
Jonathan R. Madsen
2023-11-06 21:59:31 -06:00
committed by GitHub
parent 63775f241a
commit 55f2dabbb3
26 changed files with 828 additions and 325 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/lib/rocprofiler/context/context.cpp
+146 -28
View File
@@ -20,10 +20,13 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#include <rocprofiler/buffer_tracing.h>
#include <rocprofiler/fwd.h>
#include <rocprofiler/rocprofiler.h>
#include "lib/common/container/stable_vector.hpp"
#include "lib/common/synchronized.hpp"
#include "lib/common/utility.hpp"
#include "lib/rocprofiler/buffer.hpp"
#include "lib/rocprofiler/context/context.hpp"
#include "lib/rocprofiler/counters/core.hpp"
@@ -33,6 +36,7 @@
#include <unistd.h>
#include <atomic>
#include <cstddef>
#include <deque>
#include <memory>
#include <mutex>
#include <optional>
@@ -43,6 +47,8 @@ namespace context
{
namespace
{
using reserve_size_t = common::container::reserve_size;
auto&
get_contexts_mutex()
{
@@ -58,26 +64,16 @@ get_client_index()
static auto _v = invalid_client_idx;
return _v;
}
} // namespace
uint64_t
correlation_tracing_service::get_unique_internal_id()
auto&
get_num_active_contexts()
{
static auto _v = std::atomic<uint64_t>{};
return _v++;
}
using reserve_size_t = common::container::reserve_size;
unique_context_vec_t&
get_registered_contexts()
{
static auto _v = unique_context_vec_t{reserve_size_t{unique_context_vec_t::chunk_size}};
static auto _v = std::atomic<int64_t>{0};
return _v;
}
active_context_vec_t&
get_active_contexts()
get_active_contexts_impl()
{
static auto* _v = new active_context_vec_t{reserve_size_t{active_context_vec_t::chunk_size}};
static auto _once = std::once_flag{};
@@ -90,6 +86,97 @@ get_active_contexts()
return *_v;
}
auto&
get_correlation_id_map()
{
static auto _v = common::Synchronized<std::vector<std::unique_ptr<correlation_id>>>{};
return _v;
}
auto*&
get_latest_correlation_id_impl()
{
static thread_local correlation_id* _v = nullptr;
return _v;
}
uint64_t
get_unique_internal_id()
{
static auto _v = std::atomic<uint64_t>{};
return ++_v;
}
} // namespace
correlation_id*
correlation_tracing_service::construct(uint32_t _init_ref_count)
{
auto _internal_id = get_unique_internal_id();
auto& corr_id_map = get_correlation_id_map();
auto& ret = corr_id_map.wlock([](auto& data) -> auto& { return data.emplace_back(); });
ret = std::make_unique<correlation_id>(_init_ref_count, common::get_tid(), _internal_id);
get_latest_correlation_id_impl() = ret.get();
return ret.get();
}
correlation_id*
get_latest_correlation_id()
{
return get_latest_correlation_id_impl();
}
void
pop_latest_correlation_id(const correlation_id* val)
{
if(get_latest_correlation_id_impl() == val) get_latest_correlation_id_impl() = nullptr;
}
unique_context_vec_t&
get_registered_contexts()
{
static auto _v = unique_context_vec_t{reserve_size_t{unique_context_vec_t::chunk_size}};
return _v;
}
std::vector<const context*>&
get_active_contexts(std::vector<const context*>& data, context_filter_t filter)
{
data.clear();
auto num_ctx = get_num_active_contexts().load(std::memory_order_acquire);
if(num_ctx <= 0) return data;
data.reserve(num_ctx);
for(auto& itr : get_active_contexts_impl())
{
const auto* ctx = itr.load(std::memory_order_acquire);
if(ctx)
{
if(!filter || (filter && filter(ctx))) data.emplace_back(ctx);
}
if(static_cast<int64_t>(data.size()) == num_ctx)
{
// if the number of active contexts changed, restart
if(num_ctx != get_num_active_contexts().load(std::memory_order_relaxed))
{
data.clear();
return get_active_contexts(data, filter);
}
break;
}
}
return data;
}
std::vector<const context*>
get_active_contexts(context_filter_t filter)
{
auto data = std::vector<const context*>{};
get_active_contexts(data, filter);
return data;
}
// set the client index needs to be called before allocate_context()
void
push_client(uint32_t value)
@@ -173,15 +260,30 @@ start_context(rocprofiler_context_id_t context_id)
return ROCPROFILER_STATUS_ERROR_CONTEXT_INVALID;
}
auto current_contexts = std::vector<const context*>{};
for(const auto* itr : get_active_contexts(current_contexts))
{
if(cfg->context_idx == itr->context_idx)
{
return ROCPROFILER_STATUS_SUCCESS;
}
else if(cfg->counter_collection && itr->counter_collection)
{
// conflicting context
return ROCPROFILER_STATUS_ERROR_CONTEXT_CONFLICT;
}
}
uint64_t rocp_tot_contexts = get_registered_contexts().size();
auto idx = rocp_tot_contexts;
auto& active_contexts = get_active_contexts_impl();
{
// hold a lock here so prevent multiple threads from finding the same nullptr slot
// hold a lock here to prevent multiple threads from finding the same nullptr slot
auto _lk = std::unique_lock<std::mutex>{get_contexts_mutex()};
// try to find a nullptr slot first
for(size_t i = 0; i < get_active_contexts().size(); ++i)
for(size_t i = 0; i < active_contexts.size(); ++i)
{
const auto* itr = get_active_contexts().at(i).load(std::memory_order_relaxed);
const auto* itr = active_contexts.at(i).load(std::memory_order_relaxed);
if(itr == nullptr)
{
idx = i;
@@ -195,19 +297,25 @@ start_context(rocprofiler_context_id_t context_id)
// if no nullptr slot was found, then create one while lock is held
if(idx == rocp_tot_contexts)
{
idx = get_active_contexts().size();
get_active_contexts().emplace_back();
idx = active_contexts.size();
active_contexts.emplace_back();
}
get_num_active_contexts().fetch_add(1, std::memory_order_release);
}
// atomic swap the pointer into the "active" array used internally
const context* _expected = nullptr;
bool success = get_active_contexts().at(idx).compare_exchange_strong(
bool success = active_contexts.at(idx).compare_exchange_strong(
_expected, get_registered_contexts().at(context_id.handle).get());
if(!success) return ROCPROFILER_STATUS_ERROR_CONTEXT_NOT_STARTED;
if(!success)
{
get_num_active_contexts().fetch_sub(1, std::memory_order_release);
return ROCPROFILER_STATUS_ERROR_CONTEXT_NOT_STARTED;
}
rocprofiler::counters::start_context(context_id);
if(cfg->counter_collection) rocprofiler::counters::start_context(cfg);
return ROCPROFILER_STATUS_SUCCESS;
}
@@ -215,17 +323,27 @@ start_context(rocprofiler_context_id_t context_id)
rocprofiler_status_t
stop_context(rocprofiler_context_id_t idx)
{
// hold a lock here to prevent other thread from changing the active contexts array
auto _lk = std::unique_lock<std::mutex>{get_contexts_mutex()};
// atomically assign the context pointer to NULL so that it is skipped in future
// callbacks
for(auto& itr : get_active_contexts())
for(auto& itr : get_active_contexts_impl())
{
const auto* _expected = itr.load(std::memory_order_relaxed);
const context* _expected = itr.load(std::memory_order_acquire);
if(_expected && _expected->context_idx == idx.handle)
{
bool success = itr.compare_exchange_strong(_expected, nullptr);
rocprofiler::counters::stop_context(idx);
if(success) return ROCPROFILER_STATUS_SUCCESS;
if(success)
{
auto nactive = get_num_active_contexts().load(std::memory_order_acquire);
if(nactive > 0) get_num_active_contexts().fetch_sub(1, std::memory_order_release);
if(_expected->counter_collection)
rocprofiler::counters::stop_context(const_cast<context*>(_expected));
return ROCPROFILER_STATUS_SUCCESS;
}
}
}
@@ -235,10 +353,10 @@ stop_context(rocprofiler_context_id_t idx)
void
deactivate_client_contexts(rocprofiler_client_id_t client_id)
{
for(auto& itr : get_active_contexts())
for(auto& itr : get_active_contexts_impl())
{
const auto* itr_v = itr.load();
if(itr_v->client_idx == client_id.handle)
if(itr_v && itr_v->client_idx == client_id.handle)
{
itr.store(nullptr);
}