SWDEV-403068 & SWDEV-403069: Memory Leaks fix for tracer
Change-Id: I57ce10ae616dda9529d22d4cee15556864760d6c
This commit is contained in:
Ammar ELWazir
committad av
Ammar Elwazir
Ammar Elwazir
förälder
2c34a6c166
incheckning
3ac57e167e
@@ -224,6 +224,7 @@ Rocprofiler for ROCm 5.7 added support for counter collection (PMC) and advanced
|
||||
- On Navi3x, counter collection requires the GPU to be in a stable power state. See README.md for instructions. HIP RT in ATT not yet supported.
|
||||
### Changed
|
||||
- ATT analysis will not run by default. For ATT to have the same behaviour as 5.5, use --plugin att <as.s> --mode network
|
||||
- Kernel Names are now removed from HIP API records, users of the API can get the kernel names from the corresponding HIP Dispatch OPS using the correlation ID, this change was done to optimize and to manage the data copied.
|
||||
### Optimized
|
||||
- ATT json filesizes
|
||||
- Now profiler autocorrects user input errors for pmc and throws exception for wrong input with this message:"Bad input metric. usage --> pmc: [counter1] [counter2]"
|
||||
|
||||
@@ -194,7 +194,7 @@ THE SOFTWARE.
|
||||
#if !defined(ROCPROFILER)
|
||||
#if defined(ROCPROFILER_EXPORTS)
|
||||
#define ROCPROFILER_API ROCPROFILER_EXPORT
|
||||
#else /* !defined (ROCPROFILER_EXPORTS) */
|
||||
#else /* !defined (ROCPROFILER_EXPORTS) */
|
||||
#define ROCPROFILER_API ROCPROFILER_IMPORT
|
||||
#endif /* !defined (ROCPROFILER_EXPORTS) */
|
||||
#endif /* !defined (ROCPROFILER) */
|
||||
@@ -1293,295 +1293,40 @@ typedef struct {
|
||||
* Tracer API Calls Data Handler
|
||||
*/
|
||||
typedef struct {
|
||||
/**
|
||||
* Data Handler Identifier
|
||||
*/
|
||||
const void* handle;
|
||||
/**
|
||||
* API Data Size
|
||||
*/
|
||||
size_t size;
|
||||
} rocprofiler_tracer_api_data_handle_t;
|
||||
|
||||
/** \defgroup roctx_tracer_api_data_group Tracer ROCTX API Data
|
||||
* \ingroup tracing_api_group
|
||||
* @{
|
||||
*/
|
||||
union {
|
||||
const struct hip_api_data_s* hip;
|
||||
const struct hsa_api_data_s* hsa;
|
||||
const struct roctx_api_data_s* roctx;
|
||||
};
|
||||
} rocprofiler_tracer_api_data_t;
|
||||
|
||||
/**
|
||||
* ROCTX Tracer Data Information Kinds
|
||||
*/
|
||||
typedef enum {
|
||||
/**
|
||||
* ROCTX Tracer Data kind that can be used to return ROCTX message
|
||||
*/
|
||||
ROCPROFILER_ROCTX_MESSAGE = 0,
|
||||
/**
|
||||
* ROCTX Tracer Data kind that can be used to return ROCTX id
|
||||
*/
|
||||
ROCPROFILER_ROCTX_ID = 1
|
||||
} rocprofiler_tracer_roctx_api_data_info_t;
|
||||
|
||||
/**
|
||||
* Query Tracer API Call Data Information size to allow the user to allocate
|
||||
* the right size for the information data requested, the information will be
|
||||
* collected using
|
||||
* ::rocprofiler_tracer_api_data_id_t by using
|
||||
* ::rocprofiler_query_tracer_api_data_info and the user need to identify one
|
||||
* type of information available in
|
||||
* ::rocprofiler_query_tracer_api_data_info
|
||||
* @brief Get Tracer API Function Name
|
||||
*
|
||||
* \param[in] session_id Session id where this data was collected
|
||||
* \param[in] kind The tyoe of information needed
|
||||
* \param[in] api_data_id API Data ID
|
||||
* \param[in] operation_id API Operation ID
|
||||
* \param[out] data_size API Data Information size
|
||||
* \retval ::ROCPROFILER_STATUS_SUCCESS, if the information was found
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_NOT_INITIALIZED, if rocprofiler_initialize
|
||||
* wasn't called before or if rocprofiler_finalize is called
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_NOT_FOUND \n if the api data
|
||||
* was not found in the saved api data
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_INFORMATION_MISSING \n if the
|
||||
* api data was found in the saved data but the required information is
|
||||
* missing
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_INCORRECT_DOMAIN \n if the user sent a handle
|
||||
* that is not related to the requested domain
|
||||
*/
|
||||
ROCPROFILER_API rocprofiler_status_t rocprofiler_query_roctx_tracer_api_data_info_size(
|
||||
rocprofiler_session_id_t session_id, rocprofiler_tracer_roctx_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id, size_t* data_size) ROCPROFILER_VERSION_9_0;
|
||||
|
||||
/**
|
||||
* Query API Data Information using an allocated data pointer by the user,
|
||||
* user can get the size of the data using
|
||||
* ::rocprofiler_query_tracer_api_data_info_length, the user can get the data
|
||||
* using ::rocprofiler_tracer_api_data_id_t and the user need to identify one
|
||||
* type of information available in ::rocprofiler_tracer_api_data_info_t
|
||||
* Return NULL if the name is not found for given domain and operation_id.
|
||||
*
|
||||
* \param[in] session_id Session id where this data was collected
|
||||
* \param[in] kind Information kind requested by the user
|
||||
* \param[in] api_data_id API Data ID
|
||||
* \param[in] operation_id API Operation ID
|
||||
* \param[out] data API Data Data
|
||||
* \retval ::ROCPROFILER_STATUS_SUCCESS, if the information was found
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_NOT_INITIALIZED, if rocprofiler_initialize
|
||||
* wasn't called before or if rocprofiler_finalize is called
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_NOT_FOUND \n if the api data
|
||||
* was not found in the saved api data
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_INFORMATION_MISSING \n if the
|
||||
* api data was found in the saved data but the required information is
|
||||
* missing
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_INCORRECT_DOMAIN \n if the user sent a handle
|
||||
* that is not related to the requested domain
|
||||
*/
|
||||
ROCPROFILER_API rocprofiler_status_t rocprofiler_query_roctx_tracer_api_data_info(
|
||||
rocprofiler_session_id_t session_id, rocprofiler_tracer_roctx_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id, char** data) ROCPROFILER_VERSION_9_0;
|
||||
|
||||
/** @} */
|
||||
|
||||
/** \defgroup hsa_tracer_api_data_group Tracer HSA API Data
|
||||
* \ingroup tracing_api_group
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* hsa Tracer Data Information Kinds
|
||||
*/
|
||||
typedef enum {
|
||||
/**
|
||||
* HSA Tracer Data kind that can be used to return to a pointer to all the
|
||||
* API Call Data
|
||||
*/
|
||||
ROCPROFILER_HSA_FUNCTION_NAME = 0,
|
||||
/**
|
||||
* HSA API Data in string format.
|
||||
*/
|
||||
ROCPROFILER_HSA_API_DATA_STR = 1,
|
||||
/**
|
||||
* HSA Activity Name
|
||||
*/
|
||||
ROCPROFILER_HSA_ACTIVITY_NAME = 2,
|
||||
/**
|
||||
* HSA Data
|
||||
* User has to reinterpret_cast to hsa_api_data_t*
|
||||
*/
|
||||
ROCPROFILER_HSA_API_DATA = 3
|
||||
} rocprofiler_tracer_hsa_api_data_info_t;
|
||||
|
||||
/**
|
||||
* Query Tracer API Call Data Information size to allow the user to allocate
|
||||
* the right size for the information data requested, the information will be
|
||||
* collected using
|
||||
* ::rocprofiler_tracer_api_data_id_t by using
|
||||
* ::rocprofiler_query_tracer_api_data_info and the user need to identify one
|
||||
* type of information available in
|
||||
* ::rocprofiler_query_tracer_api_data_info
|
||||
* Note: The returned string is NULL terminated.
|
||||
*
|
||||
* \param[in] session_id Session id where this data was collected
|
||||
* \param[in] kind The tyoe of information needed
|
||||
* \param[in] api_data_id API Data ID
|
||||
* \param[in] operation_id API Operation ID
|
||||
* \param[out] data_size API Data Information size
|
||||
* \retval ::ROCPROFILER_STATUS_SUCCESS, if the information was found
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_NOT_INITIALIZED, if rocprofiler_initialize
|
||||
* wasn't called before or if rocprofiler_finalize is called
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_NOT_FOUND \n if the api data
|
||||
* was not found in the saved api data
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_INFORMATION_MISSING \n if the
|
||||
* api data was found in the saved data but the required information is
|
||||
* missing
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_INCORRECT_DOMAIN \n if the user sent a handle
|
||||
* that is not related to the requested domain
|
||||
* @param[in] domain
|
||||
* @param[in] operation_id
|
||||
* @param[out] name
|
||||
* @return ::rocprofiler_status_t
|
||||
*/
|
||||
ROCPROFILER_API rocprofiler_status_t rocprofiler_query_hsa_tracer_api_data_info_size(
|
||||
rocprofiler_session_id_t session_id, rocprofiler_tracer_hsa_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id, size_t* data_size) ROCPROFILER_VERSION_9_0;
|
||||
ROCPROFILER_API rocprofiler_status_t rocprofiler_query_tracer_operation_name(
|
||||
rocprofiler_tracer_activity_domain_t domain, rocprofiler_tracer_operation_id_t operation_id,
|
||||
const char** name);
|
||||
|
||||
/**
|
||||
* Query API Data Information using an allocated data pointer by the user,
|
||||
* user can get the size of the data using
|
||||
* ::rocprofiler_query_tracer_api_data_info_length, the user can get the data
|
||||
* using ::rocprofiler_tracer_api_data_id_t and the user need to identify one
|
||||
* type of information available in ::rocprofiler_tracer_api_data_info_t
|
||||
* @brief Get Tracer API Operation ID
|
||||
*
|
||||
* \param[in] session_id Session id where this data was collected
|
||||
* \param[in] kind Information kind requested by the user
|
||||
* \param[in] api_data_id API Data ID
|
||||
* \param[in] operation_id API Operation ID
|
||||
* \param[out] data API Data Data
|
||||
* \retval ::ROCPROFILER_STATUS_SUCCESS, if the information was found
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_NOT_INITIALIZED, if rocprofiler_initialize
|
||||
* wasn't called before or if rocprofiler_finalize is called
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_NOT_FOUND \n if the api data
|
||||
* was not found in the saved api data
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_INFORMATION_MISSING \n if the
|
||||
* api data was found in the saved data but the required information is
|
||||
* missing
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_INCORRECT_DOMAIN \n if the user sent a handle
|
||||
* that is not related to the requested domain
|
||||
* @param [in] domain
|
||||
* @param [in] name
|
||||
* @param [out] operation_id
|
||||
* @return ::rocprofiler_status_t
|
||||
*/
|
||||
ROCPROFILER_API rocprofiler_status_t rocprofiler_query_hsa_tracer_api_data_info(
|
||||
rocprofiler_session_id_t session_id, rocprofiler_tracer_hsa_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id, char** data) ROCPROFILER_VERSION_9_0;
|
||||
|
||||
/** @} */
|
||||
|
||||
/** \defgroup hip_tracer_api_data_group Tracer HIP API Data
|
||||
* \ingroup tracing_api_group
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* hip Tracer Data Information Kinds
|
||||
*/
|
||||
typedef enum {
|
||||
// TODO(aelwazir): Get the data from hip_api_data_t
|
||||
/**
|
||||
* hip Tracer Data kind that can be used to return to a pointer to all the
|
||||
* API Call Data
|
||||
*/
|
||||
ROCPROFILER_HIP_FUNCTION_NAME = 0,
|
||||
/**
|
||||
* Only available for HIP Functions that lead to kernel launch to get the
|
||||
* kernel name
|
||||
*/
|
||||
ROCPROFILER_HIP_KERNEL_NAME = 1,
|
||||
/**
|
||||
* Only available to hip calls that has memory copy operation with source
|
||||
* available
|
||||
*/
|
||||
ROCPROFILER_HIP_MEM_COPY_SRC = 2,
|
||||
/**
|
||||
* Only available to hip calls that has memory copy operation with
|
||||
* destination available
|
||||
*/
|
||||
ROCPROFILER_HIP_MEM_COPY_DST = 3,
|
||||
/**
|
||||
* Only available to hip calls that has memory copy operation with data size
|
||||
* available
|
||||
*/
|
||||
ROCPROFILER_HIP_MEM_COPY_SIZE = 4,
|
||||
/**
|
||||
* Reporting the whole API data as one string
|
||||
*/
|
||||
ROCPROFILER_HIP_API_DATA_STR = 5,
|
||||
/**
|
||||
* HIP Activity Name
|
||||
*/
|
||||
ROCPROFILER_HIP_ACTIVITY_NAME = 6,
|
||||
/**
|
||||
* Stream ID
|
||||
*/
|
||||
ROCPROFILER_HIP_STREAM_ID = 7,
|
||||
/**
|
||||
* HIP API Data
|
||||
* User has to reinterpret_cast to hip_api_data_t*
|
||||
*/
|
||||
ROCPROFILER_HIP_API_DATA = 8
|
||||
} rocprofiler_tracer_hip_api_data_info_t;
|
||||
|
||||
/**
|
||||
* Query Tracer API Call Data Information size to allow the user to allocate
|
||||
* the right size for the information data requested, the information will be
|
||||
* collected using
|
||||
* ::rocprofiler_tracer_api_data_id_t by using
|
||||
* ::rocprofiler_query_tracer_api_data_info and the user need to identify one
|
||||
* type of information available in
|
||||
* ::rocprofiler_query_tracer_api_data_info
|
||||
*
|
||||
* \param[in] session_id Session id where this data was collected
|
||||
* \param[in] kind The tyoe of information needed
|
||||
* \param[in] api_data_id API Data ID
|
||||
* \param[out] data_size API Data Information size
|
||||
* \retval ::ROCPROFILER_STATUS_SUCCESS, if the information was found
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_NOT_INITIALIZED, if rocprofiler_initialize
|
||||
* wasn't called before or if rocprofiler_finalize is called
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_NOT_FOUND \n if the api data
|
||||
* was not found in the saved api data
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_INFORMATION_MISSING \n if the
|
||||
* api data was found in the saved data but the required information is
|
||||
* missing
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_INCORRECT_DOMAIN \n if the user sent a handle
|
||||
* that is not related to the requested domain
|
||||
*/
|
||||
ROCPROFILER_API rocprofiler_status_t rocprofiler_query_hip_tracer_api_data_info_size(
|
||||
rocprofiler_session_id_t session_id, rocprofiler_tracer_hip_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id, size_t* data_size) ROCPROFILER_VERSION_9_0;
|
||||
|
||||
/**
|
||||
* Query API Data Information using an allocated data pointer by the user,
|
||||
* user can get the size of the data using
|
||||
* ::rocprofiler_query_tracer_api_data_info_length, the user can get the data
|
||||
* using ::rocprofiler_tracer_api_data_id_t and the user need to identify one
|
||||
* type of information available in ::rocprofiler_tracer_api_data_info_t
|
||||
*
|
||||
* \param[in] session_id Session id where this data was collected
|
||||
* \param[in] kind Information kind requested by the user
|
||||
* \param[in] api_data_id API Data ID
|
||||
* \param[out] data API Data Data
|
||||
* \retval ::ROCPROFILER_STATUS_SUCCESS, if the information was found
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_NOT_INITIALIZED, if rocprofiler_initialize
|
||||
* wasn't called before or if rocprofiler_finalize is called
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_NOT_FOUND \n if the api data
|
||||
* was not found in the saved api data
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_INFORMATION_MISSING \n if the
|
||||
* api data was found in the saved data but the required information is
|
||||
* missing
|
||||
* \retval ::ROCPROFILER_STATUS_ERROR_INCORRECT_DOMAIN \n if the user sent a handle
|
||||
* that is not related to the requested domain
|
||||
*/
|
||||
ROCPROFILER_API rocprofiler_status_t rocprofiler_query_hip_tracer_api_data_info(
|
||||
rocprofiler_session_id_t session_id, rocprofiler_tracer_hip_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id, char** data) ROCPROFILER_VERSION_9_0;
|
||||
|
||||
/** @} */
|
||||
ROCPROFILER_API rocprofiler_status_t
|
||||
rocprofiler_tracer_operation_id(rocprofiler_tracer_activity_domain_t domain, const char* name,
|
||||
rocprofiler_tracer_operation_id_t* operation_id);
|
||||
|
||||
/**
|
||||
* Tracing external ID
|
||||
@@ -1619,7 +1364,7 @@ typedef struct {
|
||||
*/
|
||||
rocprofiler_record_header_t header;
|
||||
/**
|
||||
* Tracing external ID
|
||||
* Tracing external ID, and ROCTX ID if domain is ::ACTIVITY_DOMAIN_ROCTX
|
||||
*/
|
||||
rocprofiler_tracer_external_id_t external_id;
|
||||
/**
|
||||
@@ -1631,12 +1376,9 @@ typedef struct {
|
||||
*/
|
||||
rocprofiler_tracer_operation_id_t operation_id;
|
||||
/**
|
||||
* API Data Handler to be used by
|
||||
* ::rocprofiler_query_roctx_tracer_api_data_info or
|
||||
* ::rocprofiler_query_hsa_tracer_api_data_info or
|
||||
* ::rocprofiler_query_hip_tracer_api_data_info depending on the domain type
|
||||
* API Data
|
||||
*/
|
||||
rocprofiler_tracer_api_data_handle_t api_data_handle;
|
||||
rocprofiler_tracer_api_data_t api_data;
|
||||
/**
|
||||
* Activity correlation ID
|
||||
*/
|
||||
|
||||
+22
-92
@@ -159,9 +159,7 @@ class file_plugin_t {
|
||||
}
|
||||
|
||||
public:
|
||||
file_plugin_t() {
|
||||
valid_ = true;
|
||||
}
|
||||
file_plugin_t() { valid_ = true; }
|
||||
|
||||
std::mutex writing_lock;
|
||||
|
||||
@@ -196,95 +194,27 @@ class file_plugin_t {
|
||||
std::lock_guard<std::mutex> lock(writing_lock);
|
||||
if (tracer_record.timestamps.end.value <= 0 && tracer_record.domain != ACTIVITY_DOMAIN_ROCTX)
|
||||
return;
|
||||
std::string function_name;
|
||||
std::string kernel_name;
|
||||
std::string roctx_message;
|
||||
uint64_t roctx_id;
|
||||
if ((tracer_record.operation_id.id == 0 && tracer_record.domain == ACTIVITY_DOMAIN_HIP_OPS)) {
|
||||
if (tracer_record.name) {
|
||||
kernel_name = rocprofiler::cxx_demangle(tracer_record.name);
|
||||
std::string key = "\"";
|
||||
std::size_t found = kernel_name.rfind(key);
|
||||
while (found != std::string::npos) {
|
||||
kernel_name.replace(found, key.length(), "'");
|
||||
found = kernel_name.rfind(key, found - 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
size_t function_name_size = 0;
|
||||
char* function_name_c = nullptr;
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_HSA_API) {
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info_size(
|
||||
rocprofiler_session_id_t{0}, ROCPROFILER_HSA_FUNCTION_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &function_name_size));
|
||||
function_name_c = new char[function_name_size];
|
||||
if (function_name_size > 1) {
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info(
|
||||
rocprofiler_session_id_t{0}, ROCPROFILER_HSA_FUNCTION_NAME,
|
||||
tracer_record.api_data_handle, tracer_record.operation_id, &function_name_c));
|
||||
if (function_name_c) function_name = std::string(function_name_c);
|
||||
}
|
||||
}
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_HIP_API) {
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
|
||||
rocprofiler_session_id_t{0}, ROCPROFILER_HIP_FUNCTION_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &function_name_size));
|
||||
if (function_name_size > 1) {
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HIP_FUNCTION_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &function_name_c));
|
||||
if (function_name_c) function_name = std::string(function_name_c);
|
||||
}
|
||||
if (tracer_record.name) {
|
||||
kernel_name = rocprofiler::cxx_demangle(std::string(tracer_record.name));
|
||||
std::string key = "\"";
|
||||
std::size_t found = kernel_name.rfind(key);
|
||||
while (found != std::string::npos) {
|
||||
kernel_name.replace(found, key.length(), "'");
|
||||
found = kernel_name.rfind(key, found - 1);
|
||||
}
|
||||
// TODO: Change how this API returns a string.
|
||||
}
|
||||
}
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX) {
|
||||
if (tracer_record.name) roctx_message = rocprofiler::cxx_demangle(tracer_record.name);
|
||||
roctx_id = tracer_record.operation_id.id;
|
||||
}
|
||||
char* activity_name = nullptr;
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_HIP_OPS) {
|
||||
if (tracer_record.api_data_handle.handle) {
|
||||
kernel_name = rocprofiler::cxx_demangle(
|
||||
const_cast<char*>(reinterpret_cast<const char*>(tracer_record.api_data_handle.handle)));
|
||||
}
|
||||
size_t activity_name_size = 0;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_HIP_ACTIVITY_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &activity_name_size));
|
||||
if (activity_name_size > 1) {
|
||||
activity_name = nullptr;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HIP_ACTIVITY_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &activity_name));
|
||||
}
|
||||
}
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_HSA_OPS) {
|
||||
size_t activity_name_size = 0;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_HSA_ACTIVITY_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &activity_name_size));
|
||||
if (activity_name_size > 1) {
|
||||
activity_name = nullptr;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HSA_ACTIVITY_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &activity_name));
|
||||
}
|
||||
const char* operation_name_c = nullptr;
|
||||
// ROCTX domain Operation ID doesn't have a name
|
||||
// It depends on the user input of the roctx functions.
|
||||
// ROCTX message is the tracer_record.name
|
||||
if (tracer_record.domain != ACTIVITY_DOMAIN_ROCTX) {
|
||||
CHECK_ROCPROFILER(rocprofiler_query_tracer_operation_name(
|
||||
tracer_record.domain, tracer_record.operation_id, &operation_name_c));
|
||||
}
|
||||
|
||||
output_file_t* output_file = get_output_file(output_type_t::TRACER, tracer_record.domain);
|
||||
*output_file << "Domain(" << GetDomainName(tracer_record.domain) << "), ";
|
||||
if (function_name.size() > 1) *output_file << "Function(" << function_name << "), ";
|
||||
if (activity_name) *output_file << "Operation_Name(" << activity_name << "), ";
|
||||
if (kernel_name.size() > 1) *output_file << "Kernel_Name(" << kernel_name.c_str() << "), ";
|
||||
if (operation_name_c)
|
||||
*output_file << ((tracer_record.domain == ACTIVITY_DOMAIN_HIP_API ||
|
||||
tracer_record.domain == ACTIVITY_DOMAIN_HSA_API)
|
||||
? "Function("
|
||||
: "Operation_Name(")
|
||||
<< operation_name_c << "), ";
|
||||
if (tracer_record.name && tracer_record.domain != ACTIVITY_DOMAIN_ROCTX)
|
||||
*output_file << "Kernel_Name("
|
||||
<< rocprofiler::truncate_name(rocprofiler::cxx_demangle(tracer_record.name))
|
||||
<< "), ";
|
||||
if (tracer_record.domain != ACTIVITY_DOMAIN_ROCTX) {
|
||||
*output_file << "Start_Timestamp(" << tracer_record.timestamps.begin.value << "), "
|
||||
<< "End_Timestamp(" << tracer_record.timestamps.end.value << "), "
|
||||
@@ -292,10 +222,10 @@ class file_plugin_t {
|
||||
} else {
|
||||
*output_file << "Timestamp(" << tracer_record.timestamps.begin.value << "), ";
|
||||
}
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX && roctx_id >= 0)
|
||||
*output_file << "ROCTX_ID(" << roctx_id << "), ";
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX && roctx_message.size() > 1)
|
||||
*output_file << "ROCTX_Message(" << roctx_message << ")";
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX && tracer_record.external_id.id >= 0)
|
||||
*output_file << "ROCTX_ID(" << tracer_record.external_id.id << "), ";
|
||||
if (tracer_record.name && tracer_record.domain == ACTIVITY_DOMAIN_ROCTX)
|
||||
*output_file << "ROCTX_Message(" << tracer_record.name << ")";
|
||||
*output_file << std::endl;
|
||||
}
|
||||
|
||||
|
||||
+10
-66
@@ -136,7 +136,7 @@ class RocTxEventRecord final : public TracerEventRecord<barectf_roctx_ctx> {
|
||||
explicit RocTxEventRecord(const rocprofiler_record_tracer_t& record,
|
||||
const rocprofiler_session_id_t session_id)
|
||||
: TracerEventRecord<barectf_roctx_ctx>{record, GetRecordBeginClockVal(record)},
|
||||
id_{record.operation_id.id} {
|
||||
id_{record.external_id.id} {
|
||||
msg_ = record.name ? record.name : "";
|
||||
}
|
||||
|
||||
@@ -156,37 +156,13 @@ class HsaApiEventRecord : public TracerEventRecord<barectf_hsa_api_ctx> {
|
||||
const rocprofiler_session_id_t session_id,
|
||||
const std::uint64_t clock_val)
|
||||
: TracerEventRecord<barectf_hsa_api_ctx>{record, clock_val},
|
||||
api_data_{QueryApiData(record, session_id)} {}
|
||||
api_data_{*(record.api_data.hsa)} {}
|
||||
explicit HsaApiEventRecord(const rocprofiler_record_tracer_t& record,
|
||||
const std::uint64_t clock_val, hsa_api_data_t& api_data)
|
||||
: TracerEventRecord<barectf_hsa_api_ctx>{record, clock_val}, api_data_(api_data) {}
|
||||
const hsa_api_data_t& GetApiData() const noexcept { return api_data_; }
|
||||
|
||||
private:
|
||||
// Queries and returns the API data of the record `record` and session
|
||||
// ID `session_id`.
|
||||
static const hsa_api_data_t& QueryApiData(const rocprofiler_record_tracer_t& record,
|
||||
const rocprofiler_session_id_t session_id) {
|
||||
// Query size first (only for assertions).
|
||||
[[maybe_unused]] std::size_t size = 0;
|
||||
[[maybe_unused]] auto ret = rocprofiler_query_hsa_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_HSA_API_DATA, record.api_data_handle, record.operation_id, &size);
|
||||
|
||||
assert(ret == ROCPROFILER_STATUS_SUCCESS && "Query HSA API data size");
|
||||
assert(size > 0);
|
||||
|
||||
// Query data (borrowed from the record).
|
||||
char* data = nullptr;
|
||||
ret = rocprofiler_query_hsa_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HSA_API_DATA, record.api_data_handle, record.operation_id, &data);
|
||||
|
||||
assert(ret == ROCPROFILER_STATUS_SUCCESS && "Query HSA API data");
|
||||
assert(data);
|
||||
|
||||
// Reinterpret as an HSA API data pointer.
|
||||
return *reinterpret_cast<const hsa_api_data_t*>(data);
|
||||
}
|
||||
|
||||
hsa_api_data_t api_data_;
|
||||
};
|
||||
|
||||
@@ -228,7 +204,7 @@ class HipApiEventRecord : public TracerEventRecord<barectf_hip_api_ctx> {
|
||||
const rocprofiler_session_id_t session_id,
|
||||
const std::uint64_t clock_val)
|
||||
: TracerEventRecord<barectf_hip_api_ctx>{record, clock_val},
|
||||
api_data_{QueryApiData(record, session_id)},
|
||||
api_data_{*(record.api_data.hip)},
|
||||
kernel_name_{nullptr} {}
|
||||
explicit HipApiEventRecord(const rocprofiler_record_tracer_t& record,
|
||||
const std::uint64_t clock_val, hip_api_data_t& api_data,
|
||||
@@ -240,30 +216,6 @@ class HipApiEventRecord : public TracerEventRecord<barectf_hip_api_ctx> {
|
||||
const std::string& GetKernelName() const noexcept { return kernel_name_; }
|
||||
|
||||
private:
|
||||
// Queries and returns the API data of the record `record` and session
|
||||
// ID `session_id`.
|
||||
static const hip_api_data_t& QueryApiData(const rocprofiler_record_tracer_t& record,
|
||||
const rocprofiler_session_id_t session_id) {
|
||||
// Query size first (only for assertions).
|
||||
[[maybe_unused]] std::size_t size = 0;
|
||||
[[maybe_unused]] auto ret = rocprofiler_query_hip_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_HIP_API_DATA, record.api_data_handle, record.operation_id, &size);
|
||||
|
||||
assert(ret == ROCPROFILER_STATUS_SUCCESS && "Query HIP API data size");
|
||||
assert(size > 0);
|
||||
|
||||
// Query data (borrowed from the record).
|
||||
char* data = nullptr;
|
||||
|
||||
ret = rocprofiler_query_hip_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HIP_API_DATA, record.api_data_handle, record.operation_id, &data);
|
||||
assert(ret == ROCPROFILER_STATUS_SUCCESS && "Query HIP API data");
|
||||
assert(data);
|
||||
|
||||
// Reinterpret as an HIP API data pointer.
|
||||
return *reinterpret_cast<const hip_api_data_t*>(data);
|
||||
}
|
||||
|
||||
hip_api_data_t api_data_;
|
||||
std::string kernel_name_;
|
||||
};
|
||||
@@ -370,15 +322,9 @@ class HipOpEventRecordBegin final : public ApiOpEventRecord {
|
||||
//
|
||||
// Returns an empty string if not available.
|
||||
static std::string QueryKernelName(const rocprofiler_record_tracer_t& record) {
|
||||
if (record.operation_id.id == 0) {
|
||||
if (const auto api_handle = record.api_data_handle.handle) {
|
||||
const auto str = reinterpret_cast<const char*>(api_handle);
|
||||
|
||||
if (std::strlen(str) > 1) {
|
||||
// Return demangled version.
|
||||
return rocprofiler::cxx_demangle(str);
|
||||
}
|
||||
}
|
||||
if (record.name) {
|
||||
// Return demangled version.
|
||||
return rocprofiler::cxx_demangle(record.name);
|
||||
}
|
||||
|
||||
return {};
|
||||
@@ -640,14 +586,13 @@ void Plugin::HandleTracerRecord(const rocprofiler_record_tracer_t& record,
|
||||
break;
|
||||
case ACTIVITY_DOMAIN_HSA_API: {
|
||||
/*If data is nullptr then the call is asynchromous*/
|
||||
if (record.api_data_handle.handle == nullptr) {
|
||||
if (record.api_data.hsa == nullptr) {
|
||||
hsa_api_tracer_.AddEventRecord(
|
||||
std::make_shared<const HsaApiEventRecordBegin>(record, session_id));
|
||||
hsa_api_tracer_.AddEventRecord(
|
||||
std::make_shared<const HsaApiEventRecordEnd>(record, session_id));
|
||||
} else {
|
||||
hsa_api_data_t hsa_api_data =
|
||||
*reinterpret_cast<const hsa_api_data_t*>(record.api_data_handle.handle);
|
||||
hsa_api_data_t hsa_api_data = *(record.api_data.hsa);
|
||||
hsa_api_tracer_.AddEventRecord(
|
||||
std::make_shared<const HsaApiEventRecordBegin>(record, hsa_api_data));
|
||||
hsa_api_tracer_.AddEventRecord(
|
||||
@@ -657,15 +602,14 @@ void Plugin::HandleTracerRecord(const rocprofiler_record_tracer_t& record,
|
||||
}
|
||||
case ACTIVITY_DOMAIN_HIP_API: {
|
||||
/*If data is nullptr then the call is asynchromous*/
|
||||
if (record.api_data_handle.handle == nullptr) {
|
||||
if (record.api_data.hip == nullptr) {
|
||||
hip_api_tracer_.AddEventRecord(
|
||||
std::make_shared<const HipApiEventRecordBegin>(record, session_id));
|
||||
hip_api_tracer_.AddEventRecord(
|
||||
std::make_shared<const HipApiEventRecordEnd>(record, session_id));
|
||||
} else {
|
||||
std::string kernel_name;
|
||||
hip_api_data_t hip_api_data =
|
||||
*reinterpret_cast<const hip_api_data_t*>(record.api_data_handle.handle);
|
||||
hip_api_data_t hip_api_data = *(record.api_data.hip);
|
||||
if (record.name != nullptr)
|
||||
kernel_name = rocprofiler::cxx_demangle(std::string(record.name));
|
||||
else
|
||||
|
||||
+19
-90
@@ -118,7 +118,7 @@ class file_plugin_t {
|
||||
bPrintToStdout = true;
|
||||
return;
|
||||
}
|
||||
if (output_dir == nullptr) output_dir = "./";
|
||||
if (output_dir == nullptr) output_dir = ".";
|
||||
|
||||
fs::path output_prefix(output_dir);
|
||||
if (!fs::is_directory(fs::status(output_prefix))) {
|
||||
@@ -216,7 +216,7 @@ class file_plugin_t {
|
||||
case ACTIVITY_DOMAIN_HIP_API: {
|
||||
if (hip_api_header_written_.load(std::memory_order_relaxed)) return;
|
||||
output_file = get_output_file(output_type_t::TRACER, ACTIVITY_DOMAIN_HIP_API);
|
||||
*output_file << "Domain,Function,Kernel_Name,Start_Timestamp,End_Timestamp,Correlation_ID"
|
||||
*output_file << "Record_ID,Domain,Function,Start_Timestamp,End_Timestamp,Correlation_ID"
|
||||
<< std::endl;
|
||||
*output_file << std::endl;
|
||||
hip_api_header_written_.exchange(true, std::memory_order_release);
|
||||
@@ -313,106 +313,35 @@ class file_plugin_t {
|
||||
if (tracer_record.timestamps.end.value <= 0 && tracer_record.domain != ACTIVITY_DOMAIN_ROCTX)
|
||||
return;
|
||||
WriteHeader(output_type_t::TRACER, tracer_record.domain);
|
||||
std::string function_name;
|
||||
std::string kernel_name;
|
||||
std::string roctx_message;
|
||||
uint64_t roctx_id;
|
||||
if ((tracer_record.operation_id.id == 0 && tracer_record.domain == ACTIVITY_DOMAIN_HIP_OPS)) {
|
||||
if (tracer_record.name) {
|
||||
kernel_name = rocprofiler::cxx_demangle(tracer_record.name);
|
||||
std::string key = "\"";
|
||||
std::size_t found = kernel_name.rfind(key);
|
||||
while (found != std::string::npos) {
|
||||
kernel_name.replace(found, key.length(), "'");
|
||||
found = kernel_name.rfind(key, found - 1);
|
||||
}
|
||||
}
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX && tracer_record.name) {
|
||||
roctx_message = tracer_record.name;
|
||||
}
|
||||
size_t function_name_size = 0;
|
||||
char* function_name_c = nullptr;
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_HSA_API) {
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info_size(
|
||||
rocprofiler_session_id_t{0}, ROCPROFILER_HSA_FUNCTION_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &function_name_size));
|
||||
if (function_name_size > 1) {
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info(
|
||||
rocprofiler_session_id_t{0}, ROCPROFILER_HSA_FUNCTION_NAME,
|
||||
tracer_record.api_data_handle, tracer_record.operation_id, &function_name_c));
|
||||
if (function_name_c) function_name = std::string(function_name_c);
|
||||
}
|
||||
|
||||
const char* operation_name_c = nullptr;
|
||||
// ROCTX domain Operation ID doesn't have a name
|
||||
// It depends on the user input of the roctx functions.
|
||||
// ROCTX message is the tracer_record.name
|
||||
if (tracer_record.domain != ACTIVITY_DOMAIN_ROCTX) {
|
||||
CHECK_ROCPROFILER(rocprofiler_query_tracer_operation_name(
|
||||
tracer_record.domain, tracer_record.operation_id, &operation_name_c));
|
||||
}
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_HIP_API) {
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
|
||||
rocprofiler_session_id_t{0}, ROCPROFILER_HIP_FUNCTION_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &function_name_size));
|
||||
if (function_name_size > 1) {
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HIP_FUNCTION_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &function_name_c));
|
||||
if (function_name_c) function_name = std::string(function_name_c);
|
||||
}
|
||||
if (tracer_record.name) {
|
||||
kernel_name = rocprofiler::cxx_demangle(std::string(tracer_record.name));
|
||||
std::string key = "\"";
|
||||
std::size_t found = kernel_name.rfind(key);
|
||||
while (found != std::string::npos) {
|
||||
kernel_name.replace(found, key.length(), "'");
|
||||
found = kernel_name.rfind(key, found - 1);
|
||||
}
|
||||
// TODO: Change how this API returns a string.
|
||||
}
|
||||
}
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX) {
|
||||
if (tracer_record.name) roctx_message = rocprofiler::cxx_demangle(tracer_record.name);
|
||||
roctx_id = tracer_record.operation_id.id;
|
||||
}
|
||||
char* activity_name = nullptr;
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_HIP_OPS) {
|
||||
if (tracer_record.api_data_handle.handle) {
|
||||
kernel_name = rocprofiler::cxx_demangle(
|
||||
const_cast<char*>(reinterpret_cast<const char*>(tracer_record.api_data_handle.handle)));
|
||||
}
|
||||
size_t activity_name_size = 0;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_HIP_ACTIVITY_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &activity_name_size));
|
||||
if (activity_name_size > 1) {
|
||||
activity_name = nullptr;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HIP_ACTIVITY_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &activity_name));
|
||||
}
|
||||
}
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_HSA_OPS) {
|
||||
size_t activity_name_size = 0;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_HSA_ACTIVITY_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &activity_name_size));
|
||||
if (activity_name_size > 1) {
|
||||
activity_name = nullptr;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HSA_ACTIVITY_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &activity_name));
|
||||
}
|
||||
}
|
||||
// return;
|
||||
output_file_t* output_file = get_output_file(output_type_t::TRACER, tracer_record.domain);
|
||||
*output_file << GetDomainName(tracer_record.domain);
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX && roctx_id >= 0)
|
||||
*output_file << "," << roctx_id;
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX && tracer_record.external_id.id >= 0)
|
||||
*output_file << "," << tracer_record.external_id.id;
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX) {
|
||||
if (roctx_message.size() > 1)
|
||||
*output_file << ",\"" << roctx_message << "\"";
|
||||
else
|
||||
*output_file << ",";
|
||||
}
|
||||
if (function_name.size() > 1) *output_file << ",\"" << function_name << "\"";
|
||||
if (activity_name) *output_file << ",\"" << activity_name << "\"";
|
||||
if (kernel_name.size() > 1)
|
||||
*output_file << ",\"" << kernel_name.c_str() << "\"";
|
||||
else if (tracer_record.domain == ACTIVITY_DOMAIN_HIP_API ||
|
||||
tracer_record.domain == ACTIVITY_DOMAIN_HIP_OPS)
|
||||
if (operation_name_c) *output_file << ",\"" << operation_name_c << "\"";
|
||||
if (tracer_record.name && tracer_record.domain != ACTIVITY_DOMAIN_ROCTX) {
|
||||
*output_file << ",\"" << rocprofiler::cxx_demangle(tracer_record.name) << "\"";
|
||||
} else if (tracer_record.domain == ACTIVITY_DOMAIN_HIP_OPS) {
|
||||
*output_file << ",";
|
||||
}
|
||||
if (tracer_record.domain != ACTIVITY_DOMAIN_ROCTX) {
|
||||
*output_file << "," << tracer_record.timestamps.begin.value << ","
|
||||
<< tracer_record.timestamps.end.value;
|
||||
|
||||
+40
-158
@@ -34,6 +34,7 @@
|
||||
#include <string>
|
||||
#include <functional>
|
||||
#include <iostream>
|
||||
#include <string_view>
|
||||
|
||||
#include <cxxabi.h>
|
||||
#include <fcntl.h>
|
||||
@@ -346,8 +347,15 @@ class perfetto_plugin_t {
|
||||
std::lock_guard<std::mutex> lock(writing_lock);
|
||||
if (!tracing_session_) rocprofiler::warning("Tracing session is deleted!\n");
|
||||
std::string kernel_name;
|
||||
const char* function_name;
|
||||
char* activity_name;
|
||||
const char* operation_name_c = nullptr;
|
||||
// ROCTX domain Operation ID doesn't have a name
|
||||
// It depends on the user input of the roctx functions.
|
||||
// ROCTX message is the tracer_record.name
|
||||
if (tracer_record.domain != ACTIVITY_DOMAIN_ROCTX) {
|
||||
CHECK_ROCPROFILER(rocprofiler_query_tracer_operation_name(
|
||||
tracer_record.domain, tracer_record.operation_id, &operation_name_c));
|
||||
if (!operation_name_c) operation_name_c = "Unknown Operation";
|
||||
}
|
||||
std::string roctx_message;
|
||||
uint64_t roctx_id = 0;
|
||||
uint64_t thread_id = tracer_record.thread_id.value;
|
||||
@@ -447,7 +455,7 @@ class perfetto_plugin_t {
|
||||
}
|
||||
}
|
||||
auto& roctx_track = roctx_track_it->second;
|
||||
roctx_id = tracer_record.operation_id.id;
|
||||
roctx_id = tracer_record.external_id.id;
|
||||
roctx_message = tracer_record.name ? tracer_record.name : "";
|
||||
if (tracer_record.operation_id.id == 1) {
|
||||
perfetto::StaticString roctx_message_pft(
|
||||
@@ -486,27 +494,14 @@ class perfetto_plugin_t {
|
||||
}
|
||||
}
|
||||
auto& hsa_track = hsa_track_it->second;
|
||||
size_t function_name_size;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info_size(
|
||||
rocprofiler_session_id_t{0}, ROCPROFILER_HSA_FUNCTION_NAME,
|
||||
tracer_record.api_data_handle, tracer_record.operation_id, &function_name_size));
|
||||
if (function_name_size > 1) {
|
||||
char* function_name_str = new char[function_name_size];
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info(
|
||||
rocprofiler_session_id_t{0}, ROCPROFILER_HSA_FUNCTION_NAME,
|
||||
tracer_record.api_data_handle, tracer_record.operation_id, &function_name_str));
|
||||
function_name = function_name_str;
|
||||
} else {
|
||||
function_name = "Unknown";
|
||||
}
|
||||
if (tracer_record.phase == ROCPROFILER_PHASE_ENTER)
|
||||
TRACE_EVENT_BEGIN("HSA_API", perfetto::StaticString(function_name), hsa_track,
|
||||
TRACE_EVENT_BEGIN("HSA_API", perfetto::StaticString(operation_name_c), hsa_track,
|
||||
tracer_record.timestamps.begin.value,
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
if (tracer_record.phase == ROCPROFILER_PHASE_EXIT)
|
||||
TRACE_EVENT_END("HSA_API", hsa_track, tracer_record.timestamps.end.value);
|
||||
if (tracer_record.phase == ROCPROFILER_PHASE_NONE) {
|
||||
TRACE_EVENT_BEGIN("HSA_API", perfetto::StaticString(function_name), hsa_track,
|
||||
TRACE_EVENT_BEGIN("HSA_API", perfetto::StaticString(operation_name_c), hsa_track,
|
||||
tracer_record.timestamps.begin.value,
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
TRACE_EVENT_END("HSA_API", hsa_track, tracer_record.timestamps.end.value);
|
||||
@@ -538,43 +533,16 @@ class perfetto_plugin_t {
|
||||
}
|
||||
}
|
||||
auto& hip_track = hip_track_it->second;
|
||||
size_t function_name_size;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
|
||||
rocprofiler_session_id_t{0}, ROCPROFILER_HIP_FUNCTION_NAME,
|
||||
tracer_record.api_data_handle, tracer_record.operation_id, &function_name_size));
|
||||
if (function_name_size > 1) {
|
||||
char* function_name_str = new char[function_name_size];
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
|
||||
rocprofiler_session_id_t{0}, ROCPROFILER_HIP_FUNCTION_NAME,
|
||||
tracer_record.api_data_handle, tracer_record.operation_id, &function_name_str));
|
||||
function_name = function_name_str;
|
||||
} else {
|
||||
function_name = "Unknown";
|
||||
}
|
||||
if (tracer_record.phase == ROCPROFILER_PHASE_ENTER) {
|
||||
if (kernel_name.size() > 0) {
|
||||
TRACE_EVENT_BEGIN("HIP_API", perfetto::StaticString(function_name), hip_track,
|
||||
tracer_record.timestamps.begin.value, "Kernel Name", kernel_name,
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
} else {
|
||||
TRACE_EVENT_BEGIN("HIP_API", perfetto::StaticString(function_name), hip_track,
|
||||
tracer_record.timestamps.begin.value,
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
}
|
||||
}
|
||||
if (tracer_record.phase == ROCPROFILER_PHASE_EXIT) {
|
||||
if (tracer_record.phase == ROCPROFILER_PHASE_ENTER)
|
||||
TRACE_EVENT_BEGIN("HIP_API", perfetto::StaticString(operation_name_c), hip_track,
|
||||
tracer_record.timestamps.begin.value,
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
if (tracer_record.phase == ROCPROFILER_PHASE_EXIT)
|
||||
TRACE_EVENT_END("HIP_API", hip_track, tracer_record.timestamps.end.value);
|
||||
}
|
||||
if (tracer_record.phase == ROCPROFILER_PHASE_NONE) {
|
||||
if (kernel_name.size() > 0) {
|
||||
TRACE_EVENT_BEGIN("HIP_API", perfetto::StaticString(function_name), hip_track,
|
||||
tracer_record.timestamps.begin.value, "Kernel Name", kernel_name,
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
} else {
|
||||
TRACE_EVENT_BEGIN("HIP_API", perfetto::StaticString(function_name), hip_track,
|
||||
tracer_record.timestamps.begin.value,
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
}
|
||||
TRACE_EVENT_BEGIN("HIP_API", perfetto::StaticString(operation_name_c), hip_track,
|
||||
tracer_record.timestamps.begin.value,
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
TRACE_EVENT_END("HIP_API", hip_track, tracer_record.timestamps.end.value);
|
||||
}
|
||||
break;
|
||||
@@ -584,36 +552,9 @@ class perfetto_plugin_t {
|
||||
break;
|
||||
}
|
||||
case ACTIVITY_DOMAIN_HIP_OPS: {
|
||||
// TODO(aelwazir): Stream ID is removed from the API processing.
|
||||
// Waiting for better implementation to get the stream id.
|
||||
// uint64_t stream_id = 0;
|
||||
// std::unordered_map<int, perfetto::Track>::iterator stream_track_it;
|
||||
// {
|
||||
// std::lock_guard<std::mutex> lock(stream_tracks_lock_);
|
||||
// uint64_t stream_track_id = (stream_id + STREAM_CONSTANT) *
|
||||
// (tracer_record.agent_id.handle + 2) * (machine_id_ + 2);
|
||||
// stream_track_it = stream_tracks_.find(stream_track_id);
|
||||
// if (stream_track_it == stream_tracks_.end()) {
|
||||
// /* Create a new perfetto::Track */
|
||||
// stream_track_it =
|
||||
// stream_tracks_.emplace(stream_track_id, perfetto::Track(stream_track_id,
|
||||
// gpu_track))
|
||||
// .first;
|
||||
|
||||
// auto stream_desc = stream_track_it->second.Serialize();
|
||||
// std::string stream_str = rocprofiler::string_printf("Stream %d", stream_id);
|
||||
// stream_desc.set_name(stream_str);
|
||||
// perfetto::TrackEvent::SetTrackDescriptor(stream_track_it->second, stream_desc);
|
||||
// track_ids_used_.emplace_back(stream_track_id);
|
||||
// }
|
||||
// }
|
||||
// auto& stream_track = stream_track_it->second;
|
||||
rocprofiler_timestamp_t timestamp;
|
||||
rocprofiler_get_timestamp(×tamp);
|
||||
std::string::size_type pos = std::string::npos;
|
||||
if (tracer_record.api_data_handle.handle && tracer_record.api_data_handle.size > 1) {
|
||||
kernel_name = rocprofiler::cxx_demangle(
|
||||
strdup(reinterpret_cast<const char*>(tracer_record.api_data_handle.handle)));
|
||||
if (tracer_record.name) {
|
||||
kernel_name = rocprofiler::cxx_demangle(tracer_record.name);
|
||||
TRACE_EVENT_BEGIN(
|
||||
"HIP_OPS",
|
||||
perfetto::StaticString(strdup(rocprofiler::truncate_name(kernel_name).c_str())),
|
||||
@@ -621,94 +562,35 @@ class perfetto_plugin_t {
|
||||
tracer_record.agent_id.handle, "Process ID", GetPid(), "Kernel Name", kernel_name,
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
} else {
|
||||
size_t activity_name_size = 0;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_HIP_ACTIVITY_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &activity_name_size));
|
||||
if (activity_name_size > 1) {
|
||||
activity_name = nullptr;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HIP_ACTIVITY_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &activity_name));
|
||||
} else {
|
||||
activity_name = const_cast<char*>(std::string("N/A").c_str());
|
||||
}
|
||||
pos = std::string(activity_name).find("Copy");
|
||||
if (tracer_record.phase == ROCPROFILER_PHASE_NONE) {
|
||||
if (std::string::npos == pos)
|
||||
TRACE_EVENT_BEGIN("HIP_OPS", perfetto::StaticString(activity_name), gpu_track,
|
||||
tracer_record.timestamps.begin.value, "Process ID", GetPid(),
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
else
|
||||
TRACE_EVENT_BEGIN("MEM_COPIES", perfetto::StaticString(activity_name),
|
||||
mem_copies_track, tracer_record.timestamps.begin.value,
|
||||
"Process ID", GetPid(),
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
} else if (tracer_record.phase == ROCPROFILER_PHASE_ENTER) {
|
||||
if (std::string::npos == pos)
|
||||
TRACE_EVENT_BEGIN("HIP_OPS", perfetto::StaticString(activity_name), gpu_track,
|
||||
timestamp.value, "Process ID", GetPid(),
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
else
|
||||
TRACE_EVENT_BEGIN("MEM_COPIES", perfetto::StaticString(activity_name),
|
||||
mem_copies_track, timestamp.value, "Process ID", GetPid(),
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
}
|
||||
}
|
||||
if (tracer_record.phase == ROCPROFILER_PHASE_NONE) {
|
||||
// MEM Copies are not correlated to GPUs, so they need a special track
|
||||
pos = operation_name_c ? std::string_view(operation_name_c).find("Copy")
|
||||
: std::string::npos;
|
||||
|
||||
if (std::string::npos == pos)
|
||||
TRACE_EVENT_END("HIP_OPS", gpu_track, tracer_record.timestamps.end.value);
|
||||
TRACE_EVENT_BEGIN("HIP_OPS", perfetto::StaticString(operation_name_c), gpu_track,
|
||||
tracer_record.timestamps.begin.value, "Process ID", GetPid(),
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
else
|
||||
TRACE_EVENT_END("MEM_COPIES", mem_copies_track, tracer_record.timestamps.end.value);
|
||||
} else if (tracer_record.phase == ROCPROFILER_PHASE_EXIT) {
|
||||
if (std::string::npos == pos)
|
||||
TRACE_EVENT_END("HIP_OPS", gpu_track, timestamp.value);
|
||||
else
|
||||
TRACE_EVENT_END("MEM_COPIES", mem_copies_track, timestamp.value);
|
||||
TRACE_EVENT_BEGIN("MEM_COPIES", perfetto::StaticString(operation_name_c),
|
||||
mem_copies_track, tracer_record.timestamps.begin.value, "Process ID",
|
||||
GetPid(),
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
}
|
||||
if (std::string::npos == pos)
|
||||
TRACE_EVENT_END("HIP_OPS", gpu_track, tracer_record.timestamps.end.value);
|
||||
else
|
||||
TRACE_EVENT_END("MEM_COPIES", mem_copies_track, tracer_record.timestamps.end.value);
|
||||
break;
|
||||
}
|
||||
case ACTIVITY_DOMAIN_HSA_OPS: {
|
||||
// std::pair<int, uint64_t> gpu_queue_id =
|
||||
// std::make_pair(tracer_record.agent_id.handle, tracer_record.queue_id.handle);
|
||||
// std::unordered_map<int, perfetto::Track>::iterator queue_track_it;
|
||||
// {
|
||||
// std::lock_guard<std::mutex> lock(queue_tracks_lock_);
|
||||
// uint64_t queue_track_id = (tracer_record.queue_id.handle + 2) *
|
||||
// (tracer_record.agent_id.handle + 2) * (machine_id_ + 2);
|
||||
// queue_track_it = queue_tracks_.find(queue_track_id);
|
||||
// if (queue_track_it == queue_tracks_.end()) {
|
||||
// /* Create a new perfetto::Track */
|
||||
// queue_track_it =
|
||||
// queue_tracks_.emplace(queue_track_id, perfetto::Track(queue_track_id, gpu_track))
|
||||
// .first;
|
||||
|
||||
// auto queue_desc = queue_track_it->second.Serialize();
|
||||
// std::string queue_str = rocprofiler::string_printf("Queue %ld", gpu_queue_id.second);
|
||||
// queue_desc.set_name(queue_str);
|
||||
// perfetto::TrackEvent::SetTrackDescriptor(queue_track_it->second, queue_desc);
|
||||
// }
|
||||
// track_ids_used_.emplace_back(queue_track_id);
|
||||
// }
|
||||
// auto& queue_track = queue_track_it->second;
|
||||
size_t activity_name_size = 0;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_HSA_ACTIVITY_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &activity_name_size));
|
||||
if (activity_name_size > 1) {
|
||||
activity_name = nullptr;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HSA_ACTIVITY_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &activity_name));
|
||||
}
|
||||
TRACE_EVENT_BEGIN("MEM_COPIES", perfetto::StaticString(activity_name), mem_copies_track,
|
||||
TRACE_EVENT_BEGIN("MEM_COPIES", perfetto::StaticString(operation_name_c), mem_copies_track,
|
||||
tracer_record.timestamps.begin.value, "Process ID", GetPid(),
|
||||
perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
|
||||
TRACE_EVENT_END("MEM_COPIES", mem_copies_track, tracer_record.timestamps.end.value);
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
rocprofiler::warning("ignored record for domain %d", tracer_record.domain);
|
||||
rocprofiler::warning("Ignored record for domain %d", tracer_record.domain);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
+13
-81
@@ -44,7 +44,7 @@
|
||||
#define CHECK_ROCPROFILER(call) \
|
||||
do { \
|
||||
if ((call) != ROCPROFILER_STATUS_SUCCESS) \
|
||||
rocprofiler::fatal("Error: ROCProfiler API Call Error!"); \
|
||||
rocprofiler::fatal("Error: ROCProfiler API Call Error!"); \
|
||||
} while (false)
|
||||
|
||||
// Device (Kernel) functions, it must be void
|
||||
@@ -107,82 +107,13 @@ void FlushTracerRecord(rocprofiler_record_tracer_t tracer_record,
|
||||
rocprofiler_session_id_t session_id,
|
||||
rocprofiler_buffer_id_t buffer_id = rocprofiler_buffer_id_t{0}) {
|
||||
std::lock_guard<std::mutex> lock(writing_lock);
|
||||
std::string kernel_name;
|
||||
std::string function_name;
|
||||
std::string roctx_message;
|
||||
uint64_t roctx_id = 0;
|
||||
if ((tracer_record.operation_id.id == 0 && tracer_record.domain == ACTIVITY_DOMAIN_HIP_OPS)) {
|
||||
if (tracer_record.api_data_handle.handle &&
|
||||
strlen(reinterpret_cast<const char*>(tracer_record.api_data_handle.handle)) > 1)
|
||||
kernel_name = rocprofiler::cxx_demangle(
|
||||
reinterpret_cast<const char*>(tracer_record.api_data_handle.handle));
|
||||
}
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_HSA_API) {
|
||||
size_t function_name_size = 0;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_HSA_FUNCTION_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &function_name_size));
|
||||
if (function_name_size > 1) {
|
||||
char* function_name_c = (char*)malloc(function_name_size);
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HSA_FUNCTION_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &function_name_c));
|
||||
if (function_name_c) function_name = std::string(function_name_c);
|
||||
}
|
||||
}
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_HIP_API) {
|
||||
size_t function_name_size = 0;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_HIP_FUNCTION_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &function_name_size));
|
||||
if (function_name_size > 1) {
|
||||
char* function_name_c = (char*)malloc(function_name_size);
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HIP_FUNCTION_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &function_name_c));
|
||||
if (function_name_c) function_name = std::string(function_name_c);
|
||||
}
|
||||
size_t kernel_name_size = 0;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_HIP_KERNEL_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &kernel_name_size));
|
||||
if (kernel_name_size > 1) {
|
||||
char* kernel_name_str = (char*)malloc(kernel_name_size * sizeof(char));
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HIP_KERNEL_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &kernel_name_str));
|
||||
if (kernel_name_str) kernel_name = rocprofiler::cxx_demangle(std::string(kernel_name_str));
|
||||
}
|
||||
}
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX) {
|
||||
size_t roctx_message_size = 0;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_ROCTX_MESSAGE, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &roctx_message_size));
|
||||
if (roctx_message_size > 1) {
|
||||
[[maybe_unused]] char* roctx_message_str =
|
||||
static_cast<char*>(malloc(roctx_message_size * sizeof(char)));
|
||||
CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_ROCTX_MESSAGE, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &roctx_message_str));
|
||||
if (roctx_message_str)
|
||||
roctx_message = rocprofiler::cxx_demangle(std::string(strdup(roctx_message_str)));
|
||||
}
|
||||
size_t roctx_id_size = 0;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_ROCTX_ID, tracer_record.api_data_handle, tracer_record.operation_id,
|
||||
&roctx_id_size));
|
||||
if (roctx_id_size > 1) {
|
||||
[[maybe_unused]] char* roctx_id_str =
|
||||
static_cast<char*>(malloc(roctx_id_size * sizeof(char)));
|
||||
CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_ROCTX_ID, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &roctx_id_str));
|
||||
if (roctx_id_str) {
|
||||
roctx_id = std::stoll(std::string(strdup(roctx_id_str)));
|
||||
free(roctx_id_str);
|
||||
}
|
||||
}
|
||||
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_HSA_API || ACTIVITY_DOMAIN_HIP_API) {
|
||||
const char* function_name_c = nullptr;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_tracer_operation_name(
|
||||
tracer_record.domain, tracer_record.operation_id, &function_name_c));
|
||||
function_name = function_name_c ? function_name_c : "";
|
||||
}
|
||||
|
||||
output_file << "Record [" << tracer_record.header.id.handle << "], Domain("
|
||||
@@ -200,12 +131,13 @@ void FlushTracerRecord(rocprofiler_record_tracer_t tracer_record,
|
||||
<< tracer_record.timestamps.end.value;
|
||||
}
|
||||
output_file << "), Correlation ID(" << tracer_record.correlation_id.value << ")";
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX && roctx_id >= 0)
|
||||
output_file << ", ROCTX ID(" << roctx_id << ")";
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX && roctx_message.size() > 1)
|
||||
output_file << ", ROCTX Message(" << roctx_message << ")";
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX && tracer_record.operation_id.id >= 0)
|
||||
output_file << ", ROCTX ID(" << tracer_record.operation_id.id << ")";
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX && tracer_record.name)
|
||||
output_file << ", ROCTX Message(" << tracer_record.name << ")";
|
||||
if (function_name.size() > 1) output_file << ", Function(" << function_name << ")";
|
||||
if (kernel_name.size() > 1) output_file << ", Kernel Name(" << kernel_name.c_str() << ")";
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_HIP_OPS && tracer_record.name)
|
||||
output_file << ", Kernel Name(" << rocprofiler::cxx_demangle(tracer_record.name) << ")";
|
||||
output_file << std::endl;
|
||||
}
|
||||
|
||||
|
||||
+2
-2
@@ -383,7 +383,7 @@ class API_DescrParser:
|
||||
def gen_arg_struct(self, n, name, call, struct):
|
||||
content = ''
|
||||
if n == -1:
|
||||
content += 'struct hsa_api_data_t {\n'
|
||||
content += 'typedef struct hsa_api_data_s {\n'
|
||||
content += ' uint64_t correlation_id;\n'
|
||||
content += ' uint32_t phase;\n'
|
||||
content += ' union {\n'
|
||||
@@ -402,7 +402,7 @@ class API_DescrParser:
|
||||
else:
|
||||
content += ' } args;\n'
|
||||
content += ' uint64_t *phase_data;\n'
|
||||
content += '};\n'
|
||||
content += '} hsa_api_data_t;\n'
|
||||
return content
|
||||
|
||||
# generate API callbacks
|
||||
|
||||
+2
-6
@@ -17,12 +17,8 @@ global: OnLoad;
|
||||
rocprofiler_query_kernel_info;
|
||||
rocprofiler_query_counter_info_size;
|
||||
rocprofiler_query_counter_info;
|
||||
rocprofiler_query_roctx_tracer_api_data_info_size;
|
||||
rocprofiler_query_roctx_tracer_api_data_info;
|
||||
rocprofiler_query_hsa_tracer_api_data_info_size;
|
||||
rocprofiler_query_hsa_tracer_api_data_info;
|
||||
rocprofiler_query_hip_tracer_api_data_info_size;
|
||||
rocprofiler_query_hip_tracer_api_data_info;
|
||||
rocprofiler_query_tracer_operation_name;
|
||||
rocprofiler_tracer_operation_id;
|
||||
rocprofiler_flush_data;
|
||||
rocprofiler_next_record;
|
||||
rocprofiler_create_session;
|
||||
|
||||
+17
-197
@@ -1,10 +1,13 @@
|
||||
#include <atomic>
|
||||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
|
||||
#include "rocprofiler.h"
|
||||
|
||||
#include "core/session/tracer/tracer.h"
|
||||
#include "src/core/hsa/hsa_support.h"
|
||||
#include "src/api/rocprofiler_singleton.h"
|
||||
#include "src/utils/helper.h"
|
||||
#include "rocprofiler.h"
|
||||
|
||||
// TODO(aelwazir): change that to adapt with our own Exception
|
||||
// What about outside exceptions and callbacks exceptions!!
|
||||
@@ -255,205 +258,22 @@ ROCPROFILER_API rocprofiler_status_t rocprofiler_query_counter_info(
|
||||
API_METHOD_SUFFIX
|
||||
}
|
||||
|
||||
ROCPROFILER_API rocprofiler_status_t rocprofiler_query_roctx_tracer_api_data_info_size(
|
||||
rocprofiler_session_id_t session_id, rocprofiler_tracer_roctx_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id, size_t* data_size) {
|
||||
API_INIT_CHECKER
|
||||
// TODO(aelwazir): To be implemented
|
||||
// if (!rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindROCTxApiData(api_data_id)) {
|
||||
// if (rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindHSAApiData(api_data_id) ||
|
||||
// rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindHIPApiData(api_data_id)) {
|
||||
// throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_INCORRECT_DOMAIN);
|
||||
// } else {
|
||||
// throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_NOT_FOUND);
|
||||
// }
|
||||
// }
|
||||
*data_size = rocprofiler::GetROCProfilerSingleton()
|
||||
->GetSession(session_id)
|
||||
->GetTracer()
|
||||
->GetROCTxApiDataInfoSize(kind, api_data_id, operation_id);
|
||||
// if (*data_size <= 0)
|
||||
// throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_INFORMATION_MISSING);
|
||||
API_METHOD_SUFFIX
|
||||
ROCPROFILER_API rocprofiler_status_t rocprofiler_query_tracer_operation_name(
|
||||
rocprofiler_tracer_activity_domain_t domain, rocprofiler_tracer_operation_id_t operation_id,
|
||||
const char** name) {
|
||||
*name = rocprofiler::tracer::GetApiCallOperationName(domain, operation_id);
|
||||
return ROCPROFILER_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
ROCPROFILER_API rocprofiler_status_t rocprofiler_query_roctx_tracer_api_data_info(
|
||||
rocprofiler_session_id_t session_id, rocprofiler_tracer_roctx_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id, char** data) {
|
||||
ROCPROFILER_API rocprofiler_status_t
|
||||
rocprofiler_query_tracer_operation_id(rocprofiler_tracer_activity_domain_t domain, const char* name,
|
||||
rocprofiler_tracer_operation_id_t* operation_id) {
|
||||
API_INIT_CHECKER
|
||||
// TODO(aelwazir): To be implemented
|
||||
// if (!rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindROCTxApiData(api_data_id)) {
|
||||
// if (rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindHSAApiData(api_data_id) ||
|
||||
// rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindHIPApiData(api_data_id)) {
|
||||
// throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_INCORRECT_DOMAIN);
|
||||
// } else {
|
||||
// throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_NOT_FOUND);
|
||||
// }
|
||||
// }
|
||||
if (!(*data = rocprofiler::GetROCProfilerSingleton()
|
||||
->GetSession(session_id)
|
||||
->GetTracer()
|
||||
->GetROCTxApiDataInfo(kind, api_data_id, operation_id)))
|
||||
throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_INFORMATION_MISSING);
|
||||
API_METHOD_SUFFIX
|
||||
}
|
||||
|
||||
ROCPROFILER_API rocprofiler_status_t rocprofiler_query_hsa_tracer_api_data_info_size(
|
||||
rocprofiler_session_id_t session_id, rocprofiler_tracer_hsa_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id, size_t* data_size) {
|
||||
API_INIT_CHECKER
|
||||
// TODO(aelwazir): To be implemented
|
||||
// if (!rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindHSAApiData(api_data_id)) {
|
||||
// if (rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindROCTxApiData(api_data_id) ||
|
||||
// rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindHIPApiData(api_data_id)) {
|
||||
// throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_INCORRECT_DOMAIN);
|
||||
// } else {
|
||||
// throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_NOT_FOUND);
|
||||
// }
|
||||
// }
|
||||
*data_size =
|
||||
((kind == ROCPROFILER_HSA_FUNCTION_NAME)
|
||||
? rocprofiler::tracer::GetApiCallFunctionNameSize(ACTIVITY_DOMAIN_HSA_API, operation_id)
|
||||
: rocprofiler::GetROCProfilerSingleton()
|
||||
->GetSession(session_id)
|
||||
->GetTracer()
|
||||
->GetHSAApiDataInfoSize(kind, api_data_id, operation_id));
|
||||
if (*data_size <= 0)
|
||||
throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_INFORMATION_MISSING);
|
||||
API_METHOD_SUFFIX
|
||||
}
|
||||
|
||||
ROCPROFILER_API rocprofiler_status_t rocprofiler_query_hsa_tracer_api_data_info(
|
||||
rocprofiler_session_id_t session_id, rocprofiler_tracer_hsa_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id, char** data) {
|
||||
API_INIT_CHECKER
|
||||
// TODO(aelwazir): To be implemented
|
||||
// if (!rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindHSAApiData(api_data_id)) {
|
||||
// if (rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindROCTxApiData(api_data_id) ||
|
||||
// rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindHIPApiData(api_data_id)) {
|
||||
// throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_INCORRECT_DOMAIN);
|
||||
// } else {
|
||||
// throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_NOT_FOUND);
|
||||
// }
|
||||
// }
|
||||
*data = (kind == ROCPROFILER_HSA_FUNCTION_NAME)
|
||||
? rocprofiler::tracer::GetApiCallFunctionName(ACTIVITY_DOMAIN_HSA_API, operation_id)
|
||||
: rocprofiler::GetROCProfilerSingleton()
|
||||
->GetSession(session_id)
|
||||
->GetTracer()
|
||||
->GetHSAApiDataInfo(kind, api_data_id, operation_id);
|
||||
if (*data == nullptr)
|
||||
throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_INFORMATION_MISSING);
|
||||
API_METHOD_SUFFIX
|
||||
}
|
||||
|
||||
ROCPROFILER_API rocprofiler_status_t rocprofiler_query_hip_tracer_api_data_info_size(
|
||||
rocprofiler_session_id_t session_id, rocprofiler_tracer_hip_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id, size_t* data_size) {
|
||||
API_INIT_CHECKER
|
||||
// TODO(aelwazir): To be implemented
|
||||
// if (!rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindHIPApiData(api_data_id)) {
|
||||
// if (rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindHSAApiData(api_data_id) ||
|
||||
// rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindROCTxApiData(api_data_id)) {
|
||||
// throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_INCORRECT_DOMAIN);
|
||||
// } else {
|
||||
// throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_NOT_FOUND);
|
||||
// }
|
||||
// }
|
||||
*data_size = (kind == ROCPROFILER_HIP_FUNCTION_NAME)
|
||||
? rocprofiler::tracer::GetApiCallFunctionNameSize(ACTIVITY_DOMAIN_HIP_API, operation_id)
|
||||
: rocprofiler::GetROCProfilerSingleton()
|
||||
->GetSession(session_id)
|
||||
->GetTracer()
|
||||
->GetHIPApiDataInfoSize(kind, api_data_id, operation_id);
|
||||
// if (*data_size <= 0)
|
||||
// throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_INFORMATION_MISSING);
|
||||
API_METHOD_SUFFIX
|
||||
}
|
||||
|
||||
ROCPROFILER_API rocprofiler_status_t rocprofiler_query_hip_tracer_api_data_info(
|
||||
rocprofiler_session_id_t session_id, rocprofiler_tracer_hip_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id, char** data) {
|
||||
API_INIT_CHECKER
|
||||
// TODO(aelwazir): To be implemented
|
||||
// if (!rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindHIPApiData(api_data_id)) {
|
||||
// if (rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindHSAApiData(api_data_id) ||
|
||||
// rocprofiler::GetROCProfilerSingleton()
|
||||
// ->GetSession(session_id)
|
||||
// ->GetTracer()
|
||||
// ->FindROCTxApiData(api_data_id)) {
|
||||
// throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_INCORRECT_DOMAIN);
|
||||
// } else {
|
||||
// throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_NOT_FOUND);
|
||||
// }
|
||||
// }
|
||||
// if (!(
|
||||
*data = (kind == ROCPROFILER_HIP_FUNCTION_NAME)
|
||||
? rocprofiler::tracer::GetApiCallFunctionName(ACTIVITY_DOMAIN_HIP_API, operation_id)
|
||||
: rocprofiler::GetROCProfilerSingleton()
|
||||
->GetSession(session_id)
|
||||
->GetTracer()
|
||||
->GetHIPApiDataInfo(kind, api_data_id, operation_id);
|
||||
// ))
|
||||
// throw
|
||||
// rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_TRACER_API_DATA_INFORMATION_MISSING);
|
||||
if (operation_id == nullptr)
|
||||
throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_INVALID_ARGUMENTS);
|
||||
if (!rocprofiler::tracer::GetApiCallOperationID(domain, name, operation_id))
|
||||
throw rocprofiler::Exception(ROCPROFILER_STATUS_ERROR_INVALID_OPERATION_ID);
|
||||
return ROCPROFILER_STATUS_SUCCESS;
|
||||
API_METHOD_SUFFIX
|
||||
}
|
||||
|
||||
|
||||
@@ -401,7 +401,7 @@ int TracerCallback(activity_domain_t domain, uint32_t operation_id, void* data)
|
||||
rocprofiler_record.domain = domain;
|
||||
rocprofiler_record.external_id = rocprofiler_tracer_external_id_t{};
|
||||
rocprofiler_record.operation_id = rocprofiler_tracer_operation_id_t{record->kind};
|
||||
rocprofiler_record.api_data_handle = rocprofiler_tracer_api_data_handle_t{};
|
||||
rocprofiler_record.api_data = rocprofiler_tracer_api_data_t{};
|
||||
rocprofiler_record.correlation_id =
|
||||
rocprofiler_tracer_activity_correlation_id_t{record->correlation_id};
|
||||
rocprofiler_record.timestamps = rocprofiler_record_header_timestamp_t{
|
||||
@@ -411,21 +411,14 @@ int TracerCallback(activity_domain_t domain, uint32_t operation_id, void* data)
|
||||
rocprofiler_record.thread_id = rocprofiler_thread_id_t{GetTid()};
|
||||
rocprofiler_record.phase = ROCPROFILER_PHASE_NONE;
|
||||
if (operation_id == HIP_OP_ID_DISPATCH && record->kernel_name != nullptr) {
|
||||
rocprofiler_record.api_data_handle.handle = strdup(record->kernel_name);
|
||||
void* initial_handle = const_cast<void*>(rocprofiler_record.api_data_handle.handle);
|
||||
rocprofiler_record.api_data_handle.size = (strlen(record->kernel_name) + 1);
|
||||
rocprofiler_record.name = record->kernel_name;
|
||||
size_t kernel_name_size = (strlen(record->kernel_name) + 1);
|
||||
rocprofiler::GetROCProfilerSingleton()
|
||||
->GetSession((*pool)->session_id)
|
||||
->GetBuffer((*pool)->buffer_id)
|
||||
->AddRecord(rocprofiler_record, rocprofiler_record.api_data_handle.handle,
|
||||
rocprofiler_record.api_data_handle.size,
|
||||
[initial_handle](auto& rocprofiler_record, const void* data) {
|
||||
if (rocprofiler_record.api_data_handle.handle == initial_handle &&
|
||||
data != initial_handle) {
|
||||
free(initial_handle);
|
||||
}
|
||||
rocprofiler_record.api_data_handle.handle =
|
||||
static_cast<const char*>(data);
|
||||
->AddRecord(rocprofiler_record, rocprofiler_record.name, kernel_name_size,
|
||||
[](auto& rocprofiler_record, const void* data) {
|
||||
rocprofiler_record.name = static_cast<const char*>(data);
|
||||
});
|
||||
} else {
|
||||
rocprofiler::GetROCProfilerSingleton()
|
||||
@@ -469,7 +462,7 @@ int TracerCallback(activity_domain_t domain, uint32_t operation_id, void* data)
|
||||
rocprofiler_record.domain = domain;
|
||||
rocprofiler_record.external_id = rocprofiler_tracer_external_id_t{0};
|
||||
rocprofiler_record.operation_id = rocprofiler_tracer_operation_id_t{record->op};
|
||||
rocprofiler_record.api_data_handle = rocprofiler_tracer_api_data_handle_t{};
|
||||
rocprofiler_record.api_data = rocprofiler_tracer_api_data_t{};
|
||||
rocprofiler_record.correlation_id =
|
||||
rocprofiler_tracer_activity_correlation_id_t{record->correlation_id};
|
||||
rocprofiler_record.timestamps = rocprofiler_record_header_timestamp_t{
|
||||
@@ -479,22 +472,15 @@ int TracerCallback(activity_domain_t domain, uint32_t operation_id, void* data)
|
||||
rocprofiler_record.thread_id = rocprofiler_thread_id_t{GetTid()};
|
||||
rocprofiler_record.phase = ROCPROFILER_PHASE_NONE;
|
||||
if (record->kernel_name != nullptr && record->op == HSA_OP_ID_DISPATCH) {
|
||||
rocprofiler_record.api_data_handle.handle = strdup(record->kernel_name);
|
||||
void* initial_handle = const_cast<void*>(rocprofiler_record.api_data_handle.handle);
|
||||
rocprofiler_record.api_data_handle.size = strlen(record->kernel_name) + 1;
|
||||
size_t kernel_name_size = strlen(record->kernel_name) + 1;
|
||||
rocprofiler::GetROCProfilerSingleton()
|
||||
->GetSession((*pool)->session_id)
|
||||
->GetBuffer((*pool)->buffer_id)
|
||||
->AddRecord(rocprofiler_record, rocprofiler_record.api_data_handle.handle,
|
||||
rocprofiler_record.api_data_handle.size,
|
||||
[initial_handle](auto& rocprofiler_record, const void* data) {
|
||||
if (rocprofiler_record.api_data_handle.handle == initial_handle &&
|
||||
data != initial_handle) {
|
||||
free(initial_handle);
|
||||
}
|
||||
rocprofiler_record.api_data_handle.handle =
|
||||
static_cast<const char*>(data);
|
||||
});
|
||||
->AddRecord(
|
||||
rocprofiler_record, record->kernel_name, kernel_name_size,
|
||||
[](auto& rocprofiler_record, const void* data) {
|
||||
rocprofiler_record.name = static_cast<const char*>(data);
|
||||
});
|
||||
} else {
|
||||
rocprofiler::GetROCProfilerSingleton()
|
||||
->GetSession((*pool)->session_id)
|
||||
|
||||
@@ -7,10 +7,12 @@
|
||||
#include <atomic>
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <cstring>
|
||||
#include <map>
|
||||
#include <mutex>
|
||||
#include <utility>
|
||||
|
||||
#include "core/session/tracer/src/roctracer.h"
|
||||
#include "src/api/rocprofiler_singleton.h"
|
||||
#include "src/utils/helper.h"
|
||||
#include "src/core/hsa/hsa_support.h"
|
||||
@@ -19,21 +21,18 @@
|
||||
namespace rocprofiler {
|
||||
namespace tracer {
|
||||
|
||||
char* GetApiCallFunctionName(rocprofiler_tracer_activity_domain_t domain,
|
||||
rocprofiler_tracer_operation_id_t operation_id) {
|
||||
return const_cast<char*>(roctracer_op_string(domain, operation_id.id));
|
||||
const char* GetApiCallOperationName(rocprofiler_tracer_activity_domain_t domain,
|
||||
rocprofiler_tracer_operation_id_t operation_id) {
|
||||
return roctracer_op_string(domain, operation_id.id);
|
||||
}
|
||||
|
||||
size_t GetApiCallFunctionNameSize(rocprofiler_tracer_activity_domain_t domain,
|
||||
rocprofiler_tracer_operation_id_t operation_id) {
|
||||
return std::string(const_cast<char*>(roctracer_op_string(domain, operation_id.id))).size();
|
||||
bool GetApiCallOperationID(rocprofiler_tracer_activity_domain_t domain, const char* name,
|
||||
rocprofiler_tracer_operation_id_t* operation_id) {
|
||||
assert(name != nullptr && operation_id != nullptr);
|
||||
roctracer_op_code(domain, name, &(operation_id->id), nullptr);
|
||||
return true;
|
||||
}
|
||||
|
||||
std::mutex stream_ids_map_lock;
|
||||
std::map<uint64_t, std::pair<uint64_t, uint64_t>> stream_ids;
|
||||
std::map<uint64_t, uint64_t> used_stream_ids;
|
||||
std::atomic<uint64_t> stream_count{1};
|
||||
|
||||
uint32_t GetPid() {
|
||||
static uint32_t pid = syscall(__NR_getpid);
|
||||
return pid;
|
||||
@@ -110,199 +109,28 @@ Tracer::~Tracer() {
|
||||
std::lock_guard<std::mutex> lock(tracer_lock_);
|
||||
|
||||
is_active_.exchange(false, std::memory_order_release);
|
||||
// tracer_lock_.unlock();
|
||||
}
|
||||
|
||||
std::mutex& Tracer::GetTracerLock() { return tracer_lock_; }
|
||||
|
||||
// TODO(aelwazir): To be implemented from here
|
||||
bool Tracer::FindROCTxApiData(rocprofiler_tracer_api_data_handle_t api_data_handler) {
|
||||
// std::lock_guard<std::mutex> lock(tracer_lock_);
|
||||
return true;
|
||||
}
|
||||
bool Tracer::FindHSAApiData(rocprofiler_tracer_api_data_handle_t api_data_handler) {
|
||||
// std::lock_guard<std::mutex> lock(tracer_lock_);
|
||||
return true;
|
||||
}
|
||||
bool Tracer::FindHIPApiData(rocprofiler_tracer_api_data_handle_t api_data_handler) {
|
||||
// std::lock_guard<std::mutex> lock(tracer_lock_);
|
||||
return true;
|
||||
}
|
||||
|
||||
size_t Tracer::GetROCTxApiDataInfoSize(rocprofiler_tracer_roctx_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id) {
|
||||
const roctx_api_data_t* roctx_data =
|
||||
reinterpret_cast<const roctx_api_data_t*>(api_data_id.handle);
|
||||
switch (kind) {
|
||||
case ROCPROFILER_ROCTX_MESSAGE: {
|
||||
if (roctx_data && roctx_data->args.message)
|
||||
return strlen(reinterpret_cast<const roctx_api_data_t*>(api_data_id.handle)->args.message) +
|
||||
1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
case ROCPROFILER_ROCTX_ID: {
|
||||
if (roctx_data && roctx_data->args.id >= 0)
|
||||
return std::to_string(roctx_data->args.id).size() + 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
default:
|
||||
warning("ROCTX API Data Not Supported!");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
size_t Tracer::GetHSAApiDataInfoSize(rocprofiler_tracer_hsa_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id) {
|
||||
switch (kind) {
|
||||
case ROCPROFILER_HSA_FUNCTION_NAME: {
|
||||
return strlen(roctracer_op_string(ACTIVITY_DOMAIN_HSA_API, operation_id.id)) + 1;
|
||||
}
|
||||
case ROCPROFILER_HSA_ACTIVITY_NAME: {
|
||||
return strlen(roctracer_op_string(ACTIVITY_DOMAIN_HSA_OPS, operation_id.id)) + 1;
|
||||
}
|
||||
case ROCPROFILER_HSA_API_DATA: {
|
||||
return api_data_id.size;
|
||||
}
|
||||
default:
|
||||
warning("HSA API Data Not Supported!");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
size_t Tracer::GetHIPApiDataInfoSize(rocprofiler_tracer_hip_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id) {
|
||||
switch (kind) {
|
||||
case ROCPROFILER_HIP_KERNEL_NAME: {
|
||||
hip_api_data_t* hip_data =
|
||||
const_cast<hip_api_data_t*>(reinterpret_cast<const hip_api_data_t*>(api_data_id.handle));
|
||||
if (api_data_id.handle && hip_data) {
|
||||
auto kernel_name = GetHipKernelName(operation_id.id, hip_data);
|
||||
if (kernel_name) return kernel_name->size() + 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
case ROCPROFILER_HIP_FUNCTION_NAME: {
|
||||
return strlen(roctracer_op_string(ACTIVITY_DOMAIN_HIP_API, operation_id.id)) + 1;
|
||||
}
|
||||
case ROCPROFILER_HIP_ACTIVITY_NAME: {
|
||||
return strlen(roctracer_op_string(ACTIVITY_DOMAIN_HIP_OPS, operation_id.id)) + 1;
|
||||
}
|
||||
case ROCPROFILER_HIP_STREAM_ID: {
|
||||
// std::lock_guard<std::mutex> lock(stream_ids_map_lock);
|
||||
// if (!stream_ids.empty() && stream_ids.find(operation_id.id) != stream_ids.end())
|
||||
// return std::to_string(stream_ids.at(operation_id.id).second).size() + 1;
|
||||
// else
|
||||
// return 0;
|
||||
warning("Stream ID is not supported!");
|
||||
}
|
||||
case ROCPROFILER_HIP_API_DATA: {
|
||||
return api_data_id.size;
|
||||
}
|
||||
default:
|
||||
warning("HIP API Data Not Supported!");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
char* Tracer::GetROCTxApiDataInfo(rocprofiler_tracer_roctx_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id) {
|
||||
switch (kind) {
|
||||
case ROCPROFILER_ROCTX_MESSAGE: {
|
||||
return const_cast<char*>(
|
||||
reinterpret_cast<const roctx_api_data_t*>(api_data_id.handle)->args.message);
|
||||
}
|
||||
case ROCPROFILER_ROCTX_ID: {
|
||||
const roctx_api_data_t* roctx_data =
|
||||
reinterpret_cast<const roctx_api_data_t*>(api_data_id.handle);
|
||||
if (roctx_data && roctx_data->args.id >= 0)
|
||||
return strdup(std::to_string(roctx_data->args.id).c_str());
|
||||
else
|
||||
return nullptr;
|
||||
}
|
||||
default:
|
||||
warning("HSA API Data Not Supported!");
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
char* Tracer::GetHSAApiDataInfo(rocprofiler_tracer_hsa_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id) {
|
||||
switch (kind) {
|
||||
case ROCPROFILER_HSA_FUNCTION_NAME: {
|
||||
return const_cast<char*>(roctracer_op_string(ACTIVITY_DOMAIN_HSA_API, operation_id.id));
|
||||
}
|
||||
case ROCPROFILER_HSA_ACTIVITY_NAME: {
|
||||
return const_cast<char*>(roctracer_op_string(ACTIVITY_DOMAIN_HSA_OPS, operation_id.id));
|
||||
}
|
||||
case ROCPROFILER_HSA_API_DATA: {
|
||||
return const_cast<char*>(reinterpret_cast<const char*>(api_data_id.handle));
|
||||
}
|
||||
default:
|
||||
warning("HSA API Data Not Supported!");
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
char* Tracer::GetHIPApiDataInfo(rocprofiler_tracer_hip_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id) {
|
||||
switch (kind) {
|
||||
case ROCPROFILER_HIP_KERNEL_NAME: {
|
||||
std::optional<std::string> kernel_name = GetHipKernelName(
|
||||
operation_id.id,
|
||||
const_cast<hip_api_data_t*>(reinterpret_cast<const hip_api_data_t*>(api_data_id.handle)));
|
||||
|
||||
if (kernel_name && kernel_name->find(" ") == std::string::npos) {
|
||||
return strdup(kernel_name->c_str());
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
case ROCPROFILER_HIP_FUNCTION_NAME: {
|
||||
return const_cast<char*>(roctracer_op_string(ACTIVITY_DOMAIN_HIP_API, operation_id.id));
|
||||
}
|
||||
case ROCPROFILER_HIP_ACTIVITY_NAME: {
|
||||
return const_cast<char*>(roctracer_op_string(ACTIVITY_DOMAIN_HIP_OPS, operation_id.id));
|
||||
}
|
||||
case ROCPROFILER_HIP_STREAM_ID: {
|
||||
// std::lock_guard<std::mutex> lock(stream_ids_map_lock);
|
||||
// if (!stream_ids.empty() && stream_ids.find(operation_id.id) != stream_ids.end())
|
||||
// return strdup(
|
||||
// const_cast<char*>(std::to_string(stream_ids.at(operation_id.id).second).c_str()));
|
||||
// else
|
||||
// return nullptr;
|
||||
warning("Stream ID is not supported!");
|
||||
}
|
||||
case ROCPROFILER_HIP_API_DATA: {
|
||||
return const_cast<char*>(reinterpret_cast<const char*>(api_data_id.handle));
|
||||
}
|
||||
default:
|
||||
warning("HIP API Data Not Supported!");
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// TODO(aelwazir): Till here
|
||||
|
||||
void api_callback(activity_domain_t domain, uint32_t cid, const void* callback_data, void* args) {
|
||||
api_callback_data_t* args_data = reinterpret_cast<api_callback_data_t*>(args);
|
||||
rocprofiler_tracer_api_data_t api_data{};
|
||||
if (args_data && rocprofiler::GetROCProfilerSingleton() &&
|
||||
rocprofiler::GetROCProfilerSingleton()->GetSession(args_data->session_id) &&
|
||||
rocprofiler::GetROCProfilerSingleton()->GetSession(args_data->session_id)->GetTracer()) {
|
||||
switch (domain) {
|
||||
case ACTIVITY_DOMAIN_ROCTX: {
|
||||
const roctx_api_data_t* data = reinterpret_cast<const roctx_api_data_t*>(callback_data);
|
||||
api_data.roctx = data;
|
||||
args_data->user_sync_callback(
|
||||
rocprofiler_record_tracer_t{
|
||||
rocprofiler_record_header_t{
|
||||
ROCPROFILER_TRACER_RECORD,
|
||||
rocprofiler_record_id_t{rocprofiler::GetROCProfilerSingleton()->GetUniqueRecordId()}},
|
||||
rocprofiler_tracer_external_id_t{0}, ACTIVITY_DOMAIN_ROCTX,
|
||||
rocprofiler_tracer_operation_id_t{cid},
|
||||
rocprofiler_tracer_api_data_handle_t{callback_data, sizeof(*data)},
|
||||
rocprofiler_record_id_t{
|
||||
rocprofiler::GetROCProfilerSingleton()->GetUniqueRecordId()}},
|
||||
rocprofiler_tracer_external_id_t{data ? data->args.id : 0}, ACTIVITY_DOMAIN_ROCTX,
|
||||
rocprofiler_tracer_operation_id_t{cid}, api_data,
|
||||
rocprofiler_tracer_activity_correlation_id_t{0},
|
||||
rocprofiler_record_header_timestamp_t{roctracer::hsa_support::timestamp_ns(),
|
||||
rocprofiler_timestamp_t{0}},
|
||||
@@ -313,15 +141,16 @@ void api_callback(activity_domain_t domain, uint32_t cid, const void* callback_d
|
||||
case ACTIVITY_DOMAIN_HSA_API: {
|
||||
hsa_api_data_t* data =
|
||||
const_cast<hsa_api_data_t*>(reinterpret_cast<const hsa_api_data_t*>(callback_data));
|
||||
api_data.hsa = data;
|
||||
if (data->phase == ACTIVITY_API_PHASE_ENTER) {
|
||||
args_data->user_sync_callback(
|
||||
rocprofiler_record_tracer_t{
|
||||
rocprofiler_record_header_t{
|
||||
ROCPROFILER_TRACER_RECORD,
|
||||
rocprofiler_record_id_t{rocprofiler::GetROCProfilerSingleton()->GetUniqueRecordId()}},
|
||||
rocprofiler_record_id_t{
|
||||
rocprofiler::GetROCProfilerSingleton()->GetUniqueRecordId()}},
|
||||
rocprofiler_tracer_external_id_t{0}, ACTIVITY_DOMAIN_HSA_API,
|
||||
rocprofiler_tracer_operation_id_t{cid},
|
||||
rocprofiler_tracer_api_data_handle_t{callback_data, sizeof(*data)},
|
||||
rocprofiler_tracer_operation_id_t{cid}, api_data,
|
||||
rocprofiler_tracer_activity_correlation_id_t{data->correlation_id},
|
||||
rocprofiler_record_header_timestamp_t{rocprofiler_timestamp_t{0},
|
||||
rocprofiler_timestamp_t{0}},
|
||||
@@ -332,10 +161,10 @@ void api_callback(activity_domain_t domain, uint32_t cid, const void* callback_d
|
||||
rocprofiler_record_tracer_t{
|
||||
rocprofiler_record_header_t{
|
||||
ROCPROFILER_TRACER_RECORD,
|
||||
rocprofiler_record_id_t{rocprofiler::GetROCProfilerSingleton()->GetUniqueRecordId()}},
|
||||
rocprofiler_record_id_t{
|
||||
rocprofiler::GetROCProfilerSingleton()->GetUniqueRecordId()}},
|
||||
rocprofiler_tracer_external_id_t{0}, ACTIVITY_DOMAIN_HSA_API,
|
||||
rocprofiler_tracer_operation_id_t{cid},
|
||||
rocprofiler_tracer_api_data_handle_t{callback_data, sizeof(*data)},
|
||||
rocprofiler_tracer_operation_id_t{cid}, api_data,
|
||||
rocprofiler_tracer_activity_correlation_id_t{data->correlation_id},
|
||||
rocprofiler_record_header_timestamp_t{rocprofiler_timestamp_t{0},
|
||||
rocprofiler_timestamp_t{0}},
|
||||
@@ -347,52 +176,30 @@ void api_callback(activity_domain_t domain, uint32_t cid, const void* callback_d
|
||||
case ACTIVITY_DOMAIN_HIP_API: {
|
||||
hip_api_data_t* data =
|
||||
const_cast<hip_api_data_t*>(reinterpret_cast<const hip_api_data_t*>(callback_data));
|
||||
api_data.hip = data;
|
||||
if (data->phase == ACTIVITY_API_PHASE_ENTER) {
|
||||
args_data->user_sync_callback(
|
||||
rocprofiler_record_tracer_t{
|
||||
rocprofiler_record_header_t{
|
||||
ROCPROFILER_TRACER_RECORD,
|
||||
rocprofiler_record_id_t{rocprofiler::GetROCProfilerSingleton()->GetUniqueRecordId()}},
|
||||
rocprofiler_record_id_t{
|
||||
rocprofiler::GetROCProfilerSingleton()->GetUniqueRecordId()}},
|
||||
rocprofiler_tracer_external_id_t{0}, ACTIVITY_DOMAIN_HIP_API,
|
||||
rocprofiler_tracer_operation_id_t{cid},
|
||||
rocprofiler_tracer_api_data_handle_t{callback_data, sizeof(*data)},
|
||||
rocprofiler_tracer_operation_id_t{cid}, api_data,
|
||||
rocprofiler_tracer_activity_correlation_id_t{data->correlation_id},
|
||||
rocprofiler_record_header_timestamp_t{rocprofiler_timestamp_t{0},
|
||||
rocprofiler_timestamp_t{0}},
|
||||
0, 0, GetTid(), ROCPROFILER_PHASE_ENTER},
|
||||
args_data->session_id);
|
||||
} else {
|
||||
// TODO(aelwazir): STREAM ID GET need to be removed
|
||||
// hipApiArgsInit((hip_api_id_t)cid, data);
|
||||
// std::string hip_api_data_string = hipApiString((hip_api_id_t)cid, data);
|
||||
// std::string start_str = "stream=";
|
||||
// int start = hip_api_data_string.find(start_str);
|
||||
// uint64_t stream_id = 0;
|
||||
// if (start >= 0) {
|
||||
// int end = hip_api_data_string.find(",", start);
|
||||
// std::string stream_id_str = hip_api_data_string.substr(start + start_str.length(),
|
||||
// end); std::stringstream ss; ss << std::hex << stream_id_str; ss >> stream_id;
|
||||
// }
|
||||
// {
|
||||
// std::lock_guard<std::mutex> lock(stream_ids_map_lock);
|
||||
// if (used_stream_ids.find(stream_id) == used_stream_ids.end()) {
|
||||
// uint64_t stream_generated_id = stream_count.fetch_add(1,
|
||||
// std::memory_order_release); used_stream_ids.emplace(stream_id,
|
||||
// stream_generated_id); stream_ids.emplace(data->correlation_id,
|
||||
// std::make_pair(stream_id, stream_generated_id));
|
||||
// } else {
|
||||
// stream_ids.emplace(data->correlation_id,
|
||||
// std::make_pair(stream_id, used_stream_ids.at(stream_id)));
|
||||
// }
|
||||
// }
|
||||
args_data->user_sync_callback(
|
||||
rocprofiler_record_tracer_t{
|
||||
rocprofiler_record_header_t{
|
||||
ROCPROFILER_TRACER_RECORD,
|
||||
rocprofiler_record_id_t{rocprofiler::GetROCProfilerSingleton()->GetUniqueRecordId()}},
|
||||
rocprofiler_record_id_t{
|
||||
rocprofiler::GetROCProfilerSingleton()->GetUniqueRecordId()}},
|
||||
rocprofiler_tracer_external_id_t{0}, ACTIVITY_DOMAIN_HIP_API,
|
||||
rocprofiler_tracer_operation_id_t{cid},
|
||||
rocprofiler_tracer_api_data_handle_t{callback_data, sizeof(*data)},
|
||||
rocprofiler_tracer_operation_id_t{cid}, api_data,
|
||||
rocprofiler_tracer_activity_correlation_id_t{data->correlation_id},
|
||||
rocprofiler_record_header_timestamp_t{rocprofiler_timestamp_t{0},
|
||||
rocprofiler_timestamp_t{0}},
|
||||
|
||||
@@ -40,11 +40,11 @@ typedef struct {
|
||||
namespace rocprofiler {
|
||||
namespace tracer {
|
||||
|
||||
char* GetApiCallFunctionName(rocprofiler_tracer_activity_domain_t domain,
|
||||
rocprofiler_tracer_operation_id_t operation_id);
|
||||
const char* GetApiCallOperationName(rocprofiler_tracer_activity_domain_t domain,
|
||||
rocprofiler_tracer_operation_id_t operation_id);
|
||||
|
||||
size_t GetApiCallFunctionNameSize(rocprofiler_tracer_activity_domain_t domain,
|
||||
rocprofiler_tracer_operation_id_t operation_id);
|
||||
bool GetApiCallOperationID(rocprofiler_tracer_activity_domain_t domain, const char* name,
|
||||
rocprofiler_tracer_operation_id_t* operation_id);
|
||||
|
||||
class Tracer {
|
||||
public:
|
||||
@@ -54,34 +54,6 @@ class Tracer {
|
||||
std::vector<rocprofiler_tracer_activity_domain_t> domains);
|
||||
~Tracer();
|
||||
|
||||
rocprofiler_tracer_api_data_handle_t AddROCTxApiData(std::string api_data);
|
||||
rocprofiler_tracer_api_data_handle_t AddHSAApiData(hsa_api_data_t api_data);
|
||||
rocprofiler_tracer_api_data_handle_t AddHIPApiData(hip_api_data_t api_data);
|
||||
|
||||
bool FindROCTxApiData(rocprofiler_tracer_api_data_handle_t api_data_handler);
|
||||
bool FindHSAApiData(rocprofiler_tracer_api_data_handle_t api_data_handler);
|
||||
bool FindHIPApiData(rocprofiler_tracer_api_data_handle_t api_data_handler);
|
||||
|
||||
size_t GetROCTxApiDataInfoSize(rocprofiler_tracer_roctx_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id);
|
||||
size_t GetHSAApiDataInfoSize(rocprofiler_tracer_hsa_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id);
|
||||
size_t GetHIPApiDataInfoSize(rocprofiler_tracer_hip_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id);
|
||||
|
||||
char* GetROCTxApiDataInfo(rocprofiler_tracer_roctx_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id);
|
||||
char* GetHSAApiDataInfo(rocprofiler_tracer_hsa_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id);
|
||||
char* GetHIPApiDataInfo(rocprofiler_tracer_hip_api_data_info_t kind,
|
||||
rocprofiler_tracer_api_data_handle_t api_data_id,
|
||||
rocprofiler_tracer_operation_id_t operation_id);
|
||||
|
||||
void InitRoctracer(
|
||||
const std::map<rocprofiler_tracer_activity_domain_t, is_filtered_domain_t>& domains,
|
||||
const std::vector<std::string>& api_filter_data_vector);
|
||||
|
||||
+22
-67
@@ -23,6 +23,7 @@
|
||||
#include <fcntl.h>
|
||||
#include <hsa/hsa.h>
|
||||
#include <hsa/hsa_ext_amd.h>
|
||||
#include "core/session/tracer/src/roctracer.h"
|
||||
#include "hsa_prof_str.h"
|
||||
#include <hip/hip_runtime.h>
|
||||
#include <hip/amd_detail/hip_prof_str.h>
|
||||
@@ -110,7 +111,8 @@ class rocprofiler_plugin_t {
|
||||
if (auto* initialize = reinterpret_cast<decltype(rocprofiler_plugin_initialize)*>(
|
||||
dlsym(plugin_handle_, "rocprofiler_plugin_initialize"));
|
||||
initialize != nullptr)
|
||||
valid_ = initialize(ROCPROFILER_VERSION_MAJOR, ROCPROFILER_VERSION_MINOR, &counter_names) == 0;
|
||||
valid_ =
|
||||
initialize(ROCPROFILER_VERSION_MAJOR, ROCPROFILER_VERSION_MINOR, &counter_names) == 0;
|
||||
}
|
||||
|
||||
~rocprofiler_plugin_t() {
|
||||
@@ -149,9 +151,8 @@ struct hsa_api_trace_entry_t {
|
||||
: valid(rocprofiler::TRACE_ENTRY_INIT) {
|
||||
record = tracer_record;
|
||||
api_data = *data;
|
||||
record.api_data_handle.handle = &api_data;
|
||||
record.api_data.hsa = &api_data;
|
||||
}
|
||||
~hsa_api_trace_entry_t() {}
|
||||
};
|
||||
|
||||
struct roctx_trace_entry_t {
|
||||
@@ -162,7 +163,6 @@ struct roctx_trace_entry_t {
|
||||
: valid(rocprofiler::TRACE_ENTRY_INIT) {
|
||||
record = tracer_record;
|
||||
record.name = roctx_message_str ? strdup(roctx_message_str) : nullptr;
|
||||
record.api_data_handle.handle = record.name;
|
||||
}
|
||||
~roctx_trace_entry_t() {
|
||||
if (record.name != nullptr) free(const_cast<char*>(record.name));
|
||||
@@ -172,23 +172,15 @@ struct roctx_trace_entry_t {
|
||||
struct hip_api_trace_entry_t {
|
||||
std::atomic<uint32_t> valid;
|
||||
rocprofiler_record_tracer_t record;
|
||||
|
||||
union {
|
||||
hip_api_data_t api_data;
|
||||
};
|
||||
|
||||
hip_api_trace_entry_t(rocprofiler_record_tracer_t tracer_record, const char* kernel_name_str,
|
||||
const hip_api_data_t* data)
|
||||
hip_api_trace_entry_t(rocprofiler_record_tracer_t tracer_record, const hip_api_data_t* data)
|
||||
: valid(rocprofiler::TRACE_ENTRY_INIT) {
|
||||
record = tracer_record;
|
||||
|
||||
api_data = *data;
|
||||
record.api_data_handle.handle = &api_data;
|
||||
record.name = kernel_name_str ? strdup(kernel_name_str) : nullptr;
|
||||
free(const_cast<char*>(kernel_name_str));
|
||||
}
|
||||
~hip_api_trace_entry_t() {
|
||||
if (record.name != nullptr) free(const_cast<char*>(record.name));
|
||||
record.api_data.hip = &api_data;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -367,7 +359,7 @@ void plugins_load() {
|
||||
if (Dl_info dl_info; dladdr((void*)plugins_load, &dl_info) != 0) {
|
||||
const char* plugin_name = getenv("ROCPROFILER_PLUGIN_LIB");
|
||||
if (plugin_name == nullptr) {
|
||||
if(getenv("OUTPUT_PATH"))
|
||||
if (getenv("OUTPUT_PATH"))
|
||||
plugin_name = "libfile_plugin.so";
|
||||
else
|
||||
plugin_name = "libcli_plugin.so";
|
||||
@@ -377,92 +369,55 @@ void plugins_load() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* A callback function for synchronous trace records.
|
||||
* This function queries the api infoemation and populates the
|
||||
* This function queries the api information and populates the
|
||||
* api_trace buffer and adds it to the trace buffer.
|
||||
*/
|
||||
void sync_api_trace_callback(rocprofiler_record_tracer_t tracer_record,
|
||||
rocprofiler_session_id_t session_id) {
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_HIP_API) {
|
||||
size_t kernel_name_size = 0;
|
||||
char* kernel_name_c = nullptr;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_HIP_KERNEL_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &kernel_name_size));
|
||||
if (kernel_name_size > 1) {
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HIP_KERNEL_NAME, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &kernel_name_c));
|
||||
}
|
||||
char* data = nullptr;
|
||||
size_t size = 0;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_HIP_API_DATA, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &size));
|
||||
if (size > 0)
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HIP_API_DATA, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &data));
|
||||
hip_api_data_t* hip_api_data = reinterpret_cast<hip_api_data_t*>(data);
|
||||
if (tracer_record.phase == ROCPROFILER_PHASE_ENTER) {
|
||||
rocprofiler_timestamp_t timestamp;
|
||||
CHECK_ROCPROFILER(rocprofiler_get_timestamp(×tamp));
|
||||
*hip_api_data->phase_data = timestamp.value;
|
||||
*(const_cast<hip_api_data_t*>(tracer_record.api_data.hip)->phase_data) = timestamp.value;
|
||||
tracer_record.timestamps = rocprofiler_record_header_timestamp_t{.begin = timestamp};
|
||||
} else {
|
||||
rocprofiler_timestamp_t timestamp;
|
||||
CHECK_ROCPROFILER(rocprofiler_get_timestamp(×tamp));
|
||||
tracer_record.timestamps = rocprofiler_record_header_timestamp_t{
|
||||
.begin = rocprofiler_timestamp_t{*hip_api_data->phase_data}, .end = timestamp};
|
||||
.begin = rocprofiler_timestamp_t{*tracer_record.api_data.hip->phase_data},
|
||||
.end = timestamp};
|
||||
}
|
||||
hip_api_trace_entry_t& entry = hip_api_buffer.Emplace(
|
||||
tracer_record, (const char*)kernel_name_c ? strdup(kernel_name_c) : nullptr, hip_api_data);
|
||||
hip_api_trace_entry_t& entry =
|
||||
hip_api_buffer.Emplace(tracer_record, tracer_record.api_data.hip);
|
||||
entry.valid.store(rocprofiler::TRACE_ENTRY_COMPLETE, std::memory_order_release);
|
||||
free(kernel_name_c);
|
||||
}
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_HSA_API) {
|
||||
char* data = nullptr;
|
||||
size_t size = 0;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_HSA_API_DATA, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &size));
|
||||
CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_HSA_API_DATA, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &data));
|
||||
hsa_api_data_t* hsa_api_data = reinterpret_cast<hsa_api_data_t*>(data);
|
||||
if (tracer_record.phase == ROCPROFILER_PHASE_ENTER) {
|
||||
rocprofiler_timestamp_t timestamp;
|
||||
CHECK_ROCPROFILER(rocprofiler_get_timestamp(×tamp));
|
||||
*hsa_api_data->phase_data = timestamp.value;
|
||||
*(const_cast<hsa_api_data_t*>(tracer_record.api_data.hsa)->phase_data) = timestamp.value;
|
||||
tracer_record.timestamps = rocprofiler_record_header_timestamp_t{.begin = timestamp};
|
||||
} else {
|
||||
rocprofiler_timestamp_t timestamp;
|
||||
CHECK_ROCPROFILER(rocprofiler_get_timestamp(×tamp));
|
||||
tracer_record.timestamps = rocprofiler_record_header_timestamp_t{
|
||||
.begin = rocprofiler_timestamp_t{*hsa_api_data->phase_data}, .end = timestamp};
|
||||
.begin = rocprofiler_timestamp_t{*(tracer_record.api_data.hsa->phase_data)},
|
||||
.end = timestamp};
|
||||
}
|
||||
hsa_api_trace_entry_t& entry = hsa_api_buffer.Emplace(tracer_record, hsa_api_data);
|
||||
hsa_api_trace_entry_t& entry =
|
||||
hsa_api_buffer.Emplace(tracer_record, tracer_record.api_data.hsa);
|
||||
entry.valid.store(rocprofiler::TRACE_ENTRY_COMPLETE, std::memory_order_release);
|
||||
}
|
||||
if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX) {
|
||||
size_t roctx_message_size = 0;
|
||||
char* roctx_message_str = nullptr;
|
||||
CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info_size(
|
||||
session_id, ROCPROFILER_ROCTX_MESSAGE, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &roctx_message_size));
|
||||
if (roctx_message_size > 1) {
|
||||
roctx_message_str = (char*)malloc(roctx_message_size * sizeof(char));
|
||||
CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info(
|
||||
session_id, ROCPROFILER_ROCTX_MESSAGE, tracer_record.api_data_handle,
|
||||
tracer_record.operation_id, &roctx_message_str));
|
||||
if (roctx_message_str)
|
||||
roctx_message_str ? std::string(strdup(roctx_message_str)).c_str() : nullptr;
|
||||
}
|
||||
rocprofiler_timestamp_t timestamp;
|
||||
CHECK_ROCPROFILER(rocprofiler_get_timestamp(×tamp));
|
||||
tracer_record.timestamps = rocprofiler_record_header_timestamp_t{.begin = timestamp};
|
||||
roctx_trace_entry_t& entry = roctx_trace_buffer.Emplace(tracer_record, roctx_message_str);
|
||||
tracer_record.operation_id.id = tracer_record.api_data.roctx->args.id;
|
||||
roctx_trace_entry_t& entry =
|
||||
roctx_trace_buffer.Emplace(tracer_record, tracer_record.api_data.roctx->args.message);
|
||||
entry.valid.store(rocprofiler::TRACE_ENTRY_COMPLETE, std::memory_order_release);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,7 +5,7 @@ Domain(HIP_API_DOMAIN), Function(hipMalloc), Start_Timestamp(611510516183599), E
|
||||
Domain(HIP_API_DOMAIN), Function(hipMemcpy), Start_Timestamp(611510516192225), End_Timestamp(611510784335292), Correlation_ID(4)
|
||||
Domain(HIP_API_DOMAIN), Function(__hipPushCallConfiguration), Start_Timestamp(611510784338909), End_Timestamp(611510784341915), Correlation_ID(5)
|
||||
Domain(HIP_API_DOMAIN), Function(__hipPopCallConfiguration), Start_Timestamp(611510784343228), End_Timestamp(611510784343538), Correlation_ID(6)
|
||||
Domain(HIP_API_DOMAIN), Function(hipLaunchKernel), Kernel_Name(helloworld(char*, char*)), Start_Timestamp(611510784351053), End_Timestamp(611510784872311), Correlation_ID(7)
|
||||
Domain(HIP_API_DOMAIN), Function(hipLaunchKernel), Start_Timestamp(611510784351053), End_Timestamp(611510784872311), Correlation_ID(7)
|
||||
Domain(HIP_API_DOMAIN), Function(hipMemcpy), Start_Timestamp(611510784873914), End_Timestamp(611510784891167), Correlation_ID(8)
|
||||
Domain(HIP_API_DOMAIN), Function(hipFree), Start_Timestamp(611510784893482), End_Timestamp(611510784902690), Correlation_ID(9)
|
||||
Domain(HIP_API_DOMAIN), Function(hipFree), Start_Timestamp(611510784904944), End_Timestamp(611510784907128), Correlation_ID(10)
|
||||
|
||||
@@ -1,5 +1,4 @@
|
||||
Enabling API Tracing
|
||||
CPU is "AMD Eng Sample: 100-000000248-08_35/21_N"
|
||||
CPU is "AMD"
|
||||
GPU1 is "gfx90a"
|
||||
GPU2 is "gfx90a"
|
||||
Copying 4096 bytes from gpu1 memory to system memory...
|
||||
@@ -8,73 +7,73 @@ Copying 4096 bytes from system memory to gpu1 memory...
|
||||
Success!
|
||||
Copying 4096 bytes from gpu1 memory to gpu2 memory...
|
||||
Success!
|
||||
Domain(HSA_OPS_DOMAIN), Operation_Name(COPY), Start_Timestamp(911155715185019), End_Timestamp(911155715192699), Correlation_ID(33)
|
||||
Domain(HSA_OPS_DOMAIN), Operation_Name(COPY), Start_Timestamp(911155716884614), End_Timestamp(911155716890854), Correlation_ID(42)
|
||||
Domain(HSA_OPS_DOMAIN), Operation_Name(COPY), Start_Timestamp(911155716896614), End_Timestamp(911155716899654), Correlation_ID(44)
|
||||
Domain(HSA_OPS_DOMAIN), Operation_Name(COPY), Start_Timestamp(911155716901334), End_Timestamp(911155716905334), Correlation_ID(47)
|
||||
Domain(HSA_OPS_DOMAIN), Operation_Name(COPY), Start_Timestamp(911155721788162), End_Timestamp(911155722047524), Correlation_ID(54)
|
||||
Domain(HSA_OPS_DOMAIN), Operation_Name(COPY), Start_Timestamp(911155723248205), End_Timestamp(911155723254125), Correlation_ID(60)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(911155708889278), End_Timestamp(911155708889849), Correlation_ID(2)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(911155708893556), End_Timestamp(911155708893977), Correlation_ID(4)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(911155708894197), End_Timestamp(911155708894418), Correlation_ID(5)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(911155708894678), End_Timestamp(911155708894858), Correlation_ID(6)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agent_iterate_memory_pools), Start_Timestamp(911155708891833), End_Timestamp(911155708895039), Correlation_ID(3)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_iterate_agents), Start_Timestamp(911155708883967), End_Timestamp(911155708895219), Correlation_ID(1)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(911155708895610), End_Timestamp(911155708895770), Correlation_ID(8)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(911155708896061), End_Timestamp(911155708896221), Correlation_ID(9)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(911155708896391), End_Timestamp(911155708904237), Correlation_ID(10)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(911155708904477), End_Timestamp(911155708904617), Correlation_ID(11)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(911155708904818), End_Timestamp(911155708905048), Correlation_ID(12)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(911155708905529), End_Timestamp(911155708905699), Correlation_ID(14)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(911155708905850), End_Timestamp(911155708906000), Correlation_ID(15)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(911155708906170), End_Timestamp(911155708906321), Correlation_ID(16)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agent_iterate_memory_pools), Start_Timestamp(911155708905249), End_Timestamp(911155708906471), Correlation_ID(13)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(911155708906661), End_Timestamp(911155708906802), Correlation_ID(17)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(911155708907182), End_Timestamp(911155708907313), Correlation_ID(19)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(911155708909106), End_Timestamp(911155708909266), Correlation_ID(20)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agent_memory_pool_get_info), Start_Timestamp(911155708910368), End_Timestamp(911155708910679), Correlation_ID(21)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(911155708910859), End_Timestamp(911155708911040), Correlation_ID(22)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agent_iterate_memory_pools), Start_Timestamp(911155708906982), End_Timestamp(911155708911210), Correlation_ID(18)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_iterate_agents), Start_Timestamp(911155708895420), End_Timestamp(911155708911431), Correlation_ID(7)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_allocate), Start_Timestamp(911155708912463), End_Timestamp(911155708989391), Correlation_ID(23)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_allocate), Start_Timestamp(911155708989852), End_Timestamp(911155709008508), Correlation_ID(24)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_allocate), Start_Timestamp(911155709008859), End_Timestamp(911155709029178), Correlation_ID(25)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(911155709029539), End_Timestamp(911155709029920), Correlation_ID(26)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(911155709032164), End_Timestamp(911155709034739), Correlation_ID(27)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(911155709035210), End_Timestamp(911155709035500), Correlation_ID(28)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(911155709037394), End_Timestamp(911155709039288), Correlation_ID(29)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(911155709039528), End_Timestamp(911155714027071), Correlation_ID(30)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agents_allow_access), Start_Timestamp(911155714029005), End_Timestamp(911155714035708), Correlation_ID(31)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_create), Start_Timestamp(911155714038313), End_Timestamp(911155714039796), Correlation_ID(32)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy), Start_Timestamp(911155714040688), End_Timestamp(911155715169851), Correlation_ID(33)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_copy_engine_status), Start_Timestamp(911155715171454), End_Timestamp(911155716794372), Correlation_ID(34)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy_on_engine), Start_Timestamp(911155716795764), End_Timestamp(911155716802908), Correlation_ID(35)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_wait_relaxed), Start_Timestamp(911155716804121), End_Timestamp(911155716805724), Correlation_ID(36)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(911155716808770), End_Timestamp(911155716852254), Correlation_ID(37)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(911155716852564), End_Timestamp(911155716863766), Correlation_ID(38)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(911155716864036), End_Timestamp(911155716874747), Correlation_ID(39)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agents_allow_access), Start_Timestamp(911155716875048), End_Timestamp(911155716876681), Correlation_ID(40)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_create), Start_Timestamp(911155716876981), End_Timestamp(911155716877563), Correlation_ID(41)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy), Start_Timestamp(911155716877863), End_Timestamp(911155716880819), Correlation_ID(42)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_copy_engine_status), Start_Timestamp(911155716881119), End_Timestamp(911155716881550), Correlation_ID(43)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy_on_engine), Start_Timestamp(911155716881831), End_Timestamp(911155716883975), Correlation_ID(44)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_wait_relaxed), Start_Timestamp(911155716884256), End_Timestamp(911155716893944), Correlation_ID(45)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_store_screlease), Start_Timestamp(911155716894856), End_Timestamp(911155716895056), Correlation_ID(46)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy), Start_Timestamp(911155716895227), End_Timestamp(911155716898293), Correlation_ID(47)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_wait_relaxed), Start_Timestamp(911155716898593), End_Timestamp(911155716901459), Correlation_ID(48)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(911155716902751), End_Timestamp(911155716915937), Correlation_ID(49)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(911155716916187), End_Timestamp(911155721747629), Correlation_ID(50)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(911155721748621), End_Timestamp(911155721769541), Correlation_ID(51)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agents_allow_access), Start_Timestamp(911155721769922), End_Timestamp(911155721775212), Correlation_ID(52)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_create), Start_Timestamp(911155721775703), End_Timestamp(911155721776415), Correlation_ID(53)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy), Start_Timestamp(911155721778338), End_Timestamp(911155721783318), Correlation_ID(54)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_copy_engine_status), Start_Timestamp(911155721783719), End_Timestamp(911155721784390), Correlation_ID(55)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy_on_engine), Start_Timestamp(911155721784751), End_Timestamp(911155721787346), Correlation_ID(56)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_wait_relaxed), Start_Timestamp(911155721787727), End_Timestamp(911155722145178), Correlation_ID(57)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agents_allow_access), Start_Timestamp(911155722145669), End_Timestamp(911155722160888), Correlation_ID(58)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_store_screlease), Start_Timestamp(911155722161319), End_Timestamp(911155722161539), Correlation_ID(59)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy), Start_Timestamp(911155722161890), End_Timestamp(911155723231608), Correlation_ID(60)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_wait_relaxed), Start_Timestamp(911155723232310), End_Timestamp(911155723309238), Correlation_ID(61)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_free), Start_Timestamp(911155723311563), End_Timestamp(911155723335479), Correlation_ID(62)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_free), Start_Timestamp(911155723337383), End_Timestamp(911155723338415), Correlation_ID(63)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_free), Start_Timestamp(911155723338685), End_Timestamp(911155723339256), Correlation_ID(64)
|
||||
Domain(HSA_OPS_DOMAIN), Operation_Name(COPY), Start_Timestamp(947405228918635), End_Timestamp(947405228926155), Correlation_ID(33)
|
||||
Domain(HSA_OPS_DOMAIN), Operation_Name(COPY), Start_Timestamp(947405230713265), End_Timestamp(947405230719345), Correlation_ID(42)
|
||||
Domain(HSA_OPS_DOMAIN), Operation_Name(COPY), Start_Timestamp(947405230724945), End_Timestamp(947405230727825), Correlation_ID(44)
|
||||
Domain(HSA_OPS_DOMAIN), Operation_Name(COPY), Start_Timestamp(947405230730945), End_Timestamp(947405230734465), Correlation_ID(47)
|
||||
Domain(HSA_OPS_DOMAIN), Operation_Name(COPY), Start_Timestamp(947405235880788), End_Timestamp(947405236138548), Correlation_ID(54)
|
||||
Domain(HSA_OPS_DOMAIN), Operation_Name(COPY), Start_Timestamp(947405237403974), End_Timestamp(947405237410534), Correlation_ID(60)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(947405222622485), End_Timestamp(947405222623327), Correlation_ID(2)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(947405222627214), End_Timestamp(947405222627505), Correlation_ID(4)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(947405222627685), End_Timestamp(947405222627816), Correlation_ID(5)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(947405222627986), End_Timestamp(947405222628126), Correlation_ID(6)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agent_iterate_memory_pools), Start_Timestamp(947405222625812), End_Timestamp(947405222628287), Correlation_ID(3)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_iterate_agents), Start_Timestamp(947405222616434), End_Timestamp(947405222628467), Correlation_ID(1)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(947405222628818), End_Timestamp(947405222628958), Correlation_ID(8)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(947405222629138), End_Timestamp(947405222629278), Correlation_ID(9)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(947405222629439), End_Timestamp(947405222629559), Correlation_ID(10)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(947405222632154), End_Timestamp(947405222632274), Correlation_ID(11)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(947405222632455), End_Timestamp(947405222632695), Correlation_ID(12)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(947405222633126), End_Timestamp(947405222633256), Correlation_ID(14)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(947405222633406), End_Timestamp(947405222633537), Correlation_ID(15)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(947405222633687), End_Timestamp(947405222633817), Correlation_ID(16)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agent_iterate_memory_pools), Start_Timestamp(947405222632865), End_Timestamp(947405222633957), Correlation_ID(13)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(947405222634128), End_Timestamp(947405222634248), Correlation_ID(17)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(947405222634599), End_Timestamp(947405222634719), Correlation_ID(19)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(947405222634889), End_Timestamp(947405222645690), Correlation_ID(20)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agent_memory_pool_get_info), Start_Timestamp(947405222646772), End_Timestamp(947405222647043), Correlation_ID(21)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_get_info), Start_Timestamp(947405222647213), End_Timestamp(947405222647333), Correlation_ID(22)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agent_iterate_memory_pools), Start_Timestamp(947405222634418), End_Timestamp(947405222647494), Correlation_ID(18)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_iterate_agents), Start_Timestamp(947405222628647), End_Timestamp(947405222647684), Correlation_ID(7)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_allocate), Start_Timestamp(947405222648646), End_Timestamp(947405222712790), Correlation_ID(23)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_allocate), Start_Timestamp(947405222713111), End_Timestamp(947405222731125), Correlation_ID(24)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_allocate), Start_Timestamp(947405222731346), End_Timestamp(947405222752467), Correlation_ID(25)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(947405222752767), End_Timestamp(947405222753098), Correlation_ID(26)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(947405222759510), End_Timestamp(947405222760342), Correlation_ID(27)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_agent_get_info), Start_Timestamp(947405222761624), End_Timestamp(947405222763137), Correlation_ID(28)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(947405222766283), End_Timestamp(947405222767937), Correlation_ID(29)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(947405222768147), End_Timestamp(947405227893581), Correlation_ID(30)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agents_allow_access), Start_Timestamp(947405227895204), End_Timestamp(947405227900514), Correlation_ID(31)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_create), Start_Timestamp(947405227902448), End_Timestamp(947405227903730), Correlation_ID(32)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy), Start_Timestamp(947405227904722), End_Timestamp(947405228901650), Correlation_ID(33)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_copy_engine_status), Start_Timestamp(947405228903053), End_Timestamp(947405230619884), Correlation_ID(34)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy_on_engine), Start_Timestamp(947405230621827), End_Timestamp(947405230627649), Correlation_ID(35)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_wait_relaxed), Start_Timestamp(947405230628641), End_Timestamp(947405230629091), Correlation_ID(36)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(947405230636997), End_Timestamp(947405230678006), Correlation_ID(37)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(947405230680090), End_Timestamp(947405230690851), Correlation_ID(38)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(947405230691021), End_Timestamp(947405230701772), Correlation_ID(39)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agents_allow_access), Start_Timestamp(947405230701992), End_Timestamp(947405230703816), Correlation_ID(40)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_create), Start_Timestamp(947405230704107), End_Timestamp(947405230704708), Correlation_ID(41)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy), Start_Timestamp(947405230704938), End_Timestamp(947405230708856), Correlation_ID(42)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_copy_engine_status), Start_Timestamp(947405230709086), End_Timestamp(947405230709577), Correlation_ID(43)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy_on_engine), Start_Timestamp(947405230709757), End_Timestamp(947405230714276), Correlation_ID(44)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_wait_relaxed), Start_Timestamp(947405230714487), End_Timestamp(947405230722863), Correlation_ID(45)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_store_screlease), Start_Timestamp(947405230723714), End_Timestamp(947405230723885), Correlation_ID(46)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy), Start_Timestamp(947405230724957), End_Timestamp(947405230727752), Correlation_ID(47)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_wait_relaxed), Start_Timestamp(947405230727923), End_Timestamp(947405230729656), Correlation_ID(48)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(947405230733614), End_Timestamp(947405230748873), Correlation_ID(49)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(947405230749023), End_Timestamp(947405235846182), Correlation_ID(50)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_fill), Start_Timestamp(947405235846984), End_Timestamp(947405235865760), Correlation_ID(51)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agents_allow_access), Start_Timestamp(947405235866000), End_Timestamp(947405235870780), Correlation_ID(52)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_create), Start_Timestamp(947405235871030), End_Timestamp(947405235871681), Correlation_ID(53)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy), Start_Timestamp(947405235871912), End_Timestamp(947405235876320), Correlation_ID(54)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_copy_engine_status), Start_Timestamp(947405235876531), End_Timestamp(947405235877172), Correlation_ID(55)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy_on_engine), Start_Timestamp(947405235878985), End_Timestamp(947405235882142), Correlation_ID(56)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_wait_relaxed), Start_Timestamp(947405235882392), End_Timestamp(947405236233702), Correlation_ID(57)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_agents_allow_access), Start_Timestamp(947405236234092), End_Timestamp(947405236248921), Correlation_ID(58)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_store_screlease), Start_Timestamp(947405236249181), End_Timestamp(947405236249362), Correlation_ID(59)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_async_copy), Start_Timestamp(947405236249582), End_Timestamp(947405237388625), Correlation_ID(60)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_signal_wait_relaxed), Start_Timestamp(947405237389357), End_Timestamp(947405237849477), Correlation_ID(61)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_free), Start_Timestamp(947405237856380), End_Timestamp(947405237884084), Correlation_ID(62)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_free), Start_Timestamp(947405237884374), End_Timestamp(947405237885446), Correlation_ID(63)
|
||||
Domain(HSA_API_DOMAIN), Function(hsa_amd_memory_pool_free), Start_Timestamp(947405237885657), End_Timestamp(947405237886228), Correlation_ID(64)
|
||||
@@ -191,7 +191,7 @@ TEST_F(HelloWorldTest, WhenRunningTracerWithAppThenKernelInfoMatchWithGoldenOutp
|
||||
|
||||
// Test:2 Compares order of kernel-names in golden output against current
|
||||
// tracer output
|
||||
TEST_F(HelloWorldTest, WhenRunningTracerWithAppThenFunctionNamessMatchWithGoldenOutput) {
|
||||
TEST_F(HelloWorldTest, WhenRunningTracerWithAppThenFunctionNamesMatchWithGoldenOutput) {
|
||||
// kernel info in current tracer run
|
||||
std::vector<tracer_kernel_info_t> current_kernel_info;
|
||||
GetKernelInfoForRunningApplication(¤t_kernel_info);
|
||||
|
||||
Referens i nytt ärende
Block a user