adding tracker handler
Change-Id: Iea47c25b3c9b6e1eadf097c34323727181975cca
Этот коммит содержится в:
Evgeny
+103
-79
@@ -30,9 +30,11 @@ SOFTWARE.
|
||||
#include <hsa.h>
|
||||
#include <hsa_ext_amd.h>
|
||||
|
||||
#include <atomic>
|
||||
#include <list>
|
||||
#include <mutex>
|
||||
|
||||
#include "util/hsa_rsrc_factory.h"
|
||||
#include "inc/rocprofiler.h"
|
||||
#include "util/exception.h"
|
||||
#include "util/logger.h"
|
||||
@@ -41,12 +43,13 @@ namespace rocprofiler {
|
||||
|
||||
class Tracker {
|
||||
public:
|
||||
typedef uint64_t timestamp_t;
|
||||
typedef long double freq_t;
|
||||
typedef std::mutex mutex_t;
|
||||
typedef util::HsaRsrcFactory::timestamp_t timestamp_t;
|
||||
typedef rocprofiler_dispatch_record_t record_t;
|
||||
struct entry_t;
|
||||
typedef std::list<entry_t*> sig_list_t;
|
||||
typedef sig_list_t::iterator sig_list_it_t;
|
||||
|
||||
struct entry_t {
|
||||
Tracker* tracker;
|
||||
sig_list_t::iterator it;
|
||||
@@ -54,75 +57,59 @@ class Tracker {
|
||||
hsa_signal_t orig;
|
||||
hsa_signal_t signal;
|
||||
record_t* record;
|
||||
std::atomic<void*> handler;
|
||||
void* arg;
|
||||
bool context_active;
|
||||
};
|
||||
|
||||
Tracker(uint64_t timeout = UINT64_MAX) : timeout_(timeout), outstanding(0) {
|
||||
timestamp_t timestamp_hz = 0;
|
||||
hsa_status_t status = hsa_system_get_info(HSA_SYSTEM_INFO_TIMESTAMP_FREQUENCY, ×tamp_hz);
|
||||
if (status != HSA_STATUS_SUCCESS) EXC_ABORT(status, "hsa_system_get_info(HSA_SYSTEM_INFO_TIMESTAMP_FREQUENCY)");
|
||||
timestamp_factor_ = (freq_t)1000000000 / (freq_t)timestamp_hz;
|
||||
}
|
||||
Tracker() :
|
||||
outstanding_(0),
|
||||
hsa_rsrc_(&(util::HsaRsrcFactory::Instance()))
|
||||
{}
|
||||
|
||||
~Tracker() {
|
||||
mutex_.lock();
|
||||
for (entry_t* entry : sig_list_) {
|
||||
assert(entry != NULL);
|
||||
while (1) {
|
||||
const hsa_signal_value_t signal_value = hsa_signal_wait_scacquire(
|
||||
entry->signal,
|
||||
HSA_SIGNAL_CONDITION_LT,
|
||||
1,
|
||||
timeout_,
|
||||
HSA_WAIT_STATE_BLOCKED);
|
||||
if (signal_value < 1) break;
|
||||
else WARN_LOGGING("tracker timeout");
|
||||
}
|
||||
Del(entry);
|
||||
auto it = sig_list_.begin();
|
||||
auto end = sig_list_.end();
|
||||
while (it != end) {
|
||||
auto cur = it++;
|
||||
hsa_rsrc_->SignalWait((*cur)->signal);
|
||||
Erase(cur);
|
||||
}
|
||||
mutex_.unlock();
|
||||
}
|
||||
|
||||
// Add tracker entry
|
||||
entry_t* Add(const hsa_agent_t& agent, const hsa_signal_t& orig) {
|
||||
entry_t* Alloc(const hsa_agent_t& agent, const hsa_signal_t& orig) {
|
||||
hsa_status_t status = HSA_STATUS_ERROR;
|
||||
|
||||
// Creating a new tracker entry
|
||||
entry_t* entry = new entry_t{};
|
||||
assert(entry);
|
||||
entry->tracker = this;
|
||||
entry->agent = agent;
|
||||
entry->orig = orig;
|
||||
|
||||
// Creating a record with the dispatch timestamps
|
||||
record_t* record = new record_t{};
|
||||
assert(record);
|
||||
record->dispatch = hsa_rsrc_->TimestampNs();
|
||||
entry->record = record;
|
||||
|
||||
// Creating a proxy signal
|
||||
status = hsa_signal_create(1, 0, NULL, &(entry->signal));
|
||||
if (status != HSA_STATUS_SUCCESS) EXC_RAISING(status, "hsa_signal_create");
|
||||
status = hsa_amd_signal_async_handler(entry->signal, HSA_SIGNAL_CONDITION_LT, 1, Handler, entry);
|
||||
if (status != HSA_STATUS_SUCCESS) EXC_RAISING(status, "hsa_amd_signal_async_handler");
|
||||
|
||||
// Adding antry to the list
|
||||
mutex_.lock();
|
||||
entry->it = sig_list_.insert(sig_list_.begin(), entry);
|
||||
mutex_.unlock();
|
||||
|
||||
entry->agent = agent;
|
||||
entry->orig = orig;
|
||||
status = hsa_signal_create(1, 0, NULL, &(entry->signal));
|
||||
if (status != HSA_STATUS_SUCCESS) EXC_RAISING(status, "hsa_signal_create");
|
||||
|
||||
record_t* record = new record_t{};
|
||||
assert(record);
|
||||
entry->record = record;
|
||||
|
||||
timestamp_t dispatch_timestamp = 0;
|
||||
status = hsa_system_get_info(HSA_SYSTEM_INFO_TIMESTAMP, &dispatch_timestamp);
|
||||
if (status != HSA_STATUS_SUCCESS) EXC_RAISING(status, "hsa_system_get_info(HSA_SYSTEM_INFO_TIMESTAMP)");
|
||||
|
||||
record->dispatch = timestamp2ns(dispatch_timestamp);
|
||||
|
||||
status = hsa_amd_signal_async_handler(entry->signal, HSA_SIGNAL_CONDITION_LT, 1, Handler, entry);
|
||||
if (status != HSA_STATUS_SUCCESS) EXC_RAISING(status, "hsa_amd_signal_async_handler");
|
||||
|
||||
if (trace_on_) {
|
||||
mutex_.lock();
|
||||
entry->tracker->outstanding++;
|
||||
fprintf(stdout, "Tracker::Add: entry %p, record %p, outst %lu\n", entry, entry->record, entry->tracker->outstanding);
|
||||
fflush(stdout);
|
||||
mutex_.unlock();
|
||||
}
|
||||
|
||||
return entry;
|
||||
}
|
||||
|
||||
private:
|
||||
// Delete tracker entry
|
||||
void Del(entry_t* entry) {
|
||||
void Delete(entry_t* entry) {
|
||||
hsa_signal_destroy(entry->signal);
|
||||
mutex_.lock();
|
||||
sig_list_.erase(entry->it);
|
||||
@@ -130,31 +117,53 @@ class Tracker {
|
||||
delete entry;
|
||||
}
|
||||
|
||||
// Handler for packet completion
|
||||
static bool Handler(hsa_signal_value_t value, void* arg) {
|
||||
entry_t* entry = reinterpret_cast<entry_t*>(arg);
|
||||
// Enable tracker entry
|
||||
void Enable(entry_t* entry, void* handler, void* arg) {
|
||||
// Set entry handler and release the entry
|
||||
entry->arg = arg;
|
||||
entry->handler.store(handler, std::memory_order_release);
|
||||
|
||||
// Debug trace
|
||||
if (trace_on_) {
|
||||
auto outstanding = outstanding_.fetch_add(1);
|
||||
fprintf(stdout, "Tracker::Add: entry %p, record %p, outst %lu\n", entry, entry->record, outstanding);
|
||||
fflush(stdout);
|
||||
}
|
||||
}
|
||||
|
||||
void Enable(entry_t* entry, hsa_amd_signal_handler handler, void* arg) {
|
||||
entry->context_active = true;
|
||||
Enable(entry, reinterpret_cast<void*>(handler), arg);
|
||||
}
|
||||
void Enable(entry_t* entry, rocprofiler_handler_t handler, void* arg) {
|
||||
Enable(entry, reinterpret_cast<void*>(handler), arg);
|
||||
}
|
||||
|
||||
private:
|
||||
// Delete an entry by iterator
|
||||
void Erase(const sig_list_it_t& it) { Delete(*it); }
|
||||
|
||||
// Entry completion
|
||||
void Complete(entry_t* entry) {
|
||||
record_t* record = entry->record;
|
||||
|
||||
// Debug trace
|
||||
if (trace_on_) {
|
||||
mutex_.lock();
|
||||
entry->tracker->outstanding--;
|
||||
fprintf(stdout, "Tracker::Handler: entry %p, record %p, outst %lu\n", entry, entry->record, entry->tracker->outstanding);
|
||||
auto outstanding = outstanding_.fetch_sub(1);
|
||||
fprintf(stdout, "Tracker::Handler: entry %p, record %p, outst %lu\n", entry, entry->record, outstanding);
|
||||
fflush(stdout);
|
||||
mutex_.unlock();
|
||||
}
|
||||
|
||||
timestamp_t complete_timestamp = 0;
|
||||
// Query begin/end and complete timestamps
|
||||
hsa_amd_profiling_dispatch_time_t dispatch_time{};
|
||||
|
||||
hsa_status_t status = hsa_system_get_info(HSA_SYSTEM_INFO_TIMESTAMP, &complete_timestamp);
|
||||
if (status != HSA_STATUS_SUCCESS) EXC_RAISING(status, "hsa_system_get_info(HSA_SYSTEM_INFO_TIMESTAMP)");
|
||||
status = hsa_amd_profiling_get_dispatch_time(entry->agent, entry->signal, &dispatch_time);
|
||||
hsa_status_t status = hsa_amd_profiling_get_dispatch_time(entry->agent, entry->signal, &dispatch_time);
|
||||
if (status != HSA_STATUS_SUCCESS) EXC_RAISING(status, "hsa_amd_profiling_get_dispatch_time");
|
||||
|
||||
record->complete = entry->tracker->timestamp2ns(complete_timestamp);
|
||||
record->begin = entry->tracker->timestamp2ns(dispatch_time.start);
|
||||
record->end = entry->tracker->timestamp2ns(dispatch_time.end);
|
||||
record->begin = hsa_rsrc_->SysclockToNs(dispatch_time.start);
|
||||
record->end = hsa_rsrc_->SysclockToNs(dispatch_time.end);
|
||||
record->complete = hsa_rsrc_->TimestampNs();
|
||||
|
||||
// Original intercepted signal completion
|
||||
hsa_signal_t orig = entry->orig;
|
||||
if (orig.handle) {
|
||||
amd_signal_t* orig_signal_ptr = reinterpret_cast<amd_signal_t*>(orig.handle);
|
||||
@@ -165,26 +174,41 @@ class Tracker {
|
||||
const hsa_signal_value_t value = hsa_signal_load_relaxed(orig);
|
||||
hsa_signal_store_screlease(orig, value - 1);
|
||||
}
|
||||
entry->tracker->Del(entry);
|
||||
}
|
||||
|
||||
// Handler for packet completion
|
||||
static bool Handler(hsa_signal_value_t, void* arg) {
|
||||
// Acquire entry
|
||||
entry_t* entry = reinterpret_cast<entry_t*>(arg);
|
||||
volatile std::atomic<void*>* ptr = &entry->handler;
|
||||
while (ptr->load(std::memory_order_acquire) == NULL) sched_yield();
|
||||
|
||||
// Complete entry
|
||||
entry->tracker->Complete(entry);
|
||||
|
||||
// Call entry handler
|
||||
void* handler = static_cast<void*>(entry->handler);
|
||||
if (entry->context_active) {
|
||||
reinterpret_cast<hsa_amd_signal_handler>(handler)(0, entry->arg);
|
||||
} else {
|
||||
rocprofiler_group_t group{};
|
||||
reinterpret_cast<rocprofiler_handler_t>(handler)(group, entry->arg);
|
||||
}
|
||||
|
||||
// Delete tracker entry
|
||||
entry->tracker->Delete(entry);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
inline timestamp_t timestamp2ns(const timestamp_t& timestamp) const {
|
||||
const freq_t timestamp_ns = (freq_t)timestamp * timestamp_factor_;
|
||||
return (timestamp_t)timestamp_ns;
|
||||
}
|
||||
|
||||
// Timestamp frequency factor
|
||||
freq_t timestamp_factor_;
|
||||
// Timeout for wait on destruction
|
||||
timestamp_t timeout_;
|
||||
// Tracked signals list
|
||||
sig_list_t sig_list_;
|
||||
// Inter-thread synchronization
|
||||
static mutex_t mutex_;
|
||||
mutex_t mutex_;
|
||||
// Outstanding dispatches
|
||||
uint64_t outstanding;
|
||||
std::atomic<uint64_t> outstanding_;
|
||||
// HSA resources factory
|
||||
util::HsaRsrcFactory* hsa_rsrc_;
|
||||
// Enable tracing
|
||||
static const bool trace_on_ = false;
|
||||
};
|
||||
|
||||
Ссылка в новой задаче
Block a user