Pull from Github

Squashed commit of the following: commit f029195705a15700380c6f832ba5d15d46fd6de7 Author: Jonathan R. Madsen <jrmadsen@users.noreply.github.com> Date: Thu Jul 13 14:38:56 2023 -0500 Formatting workflows for source (clang-format) and cmake (cmake-format) (#4) * Add .cmake-format.yaml file * Add formatting workflow * provide base input for creating PR * Update scheme for extracting branch name - disable running formatting on push to amd-staging branch * patch .cmake-format.yaml for find_package signature - apparently cmake-format doesn't format the full signature of find_package * run formatting (clang-format v11) (#7) Co-authored-by: jrmadsen <jrmadsen@users.noreply.github.com> * run cmake formatting (cmake-format) (#6) Co-authored-by: jrmadsen <jrmadsen@users.noreply.github.com> --------- Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> commit bc4d135fdd8a1a9e51235f18a5d575fd2b3735e6 Author: Ammar ELWazir <aelwazir@amd.com> Date: Thu Jul 13 12:55:17 2023 -0500 Removing Build cache for potential issues with auto-generated header files (#5) Change-Id: I9e2319f4335e2f88585ffa6fac2bd88a1c952e6e commit ce86dea6a311d44d880fa684eb78f3329295e2a4 Author: Jonathan R. Madsen <jrmadsen@users.noreply.github.com> Date: Thu Jul 13 11:08:58 2023 -0500 Fix decltype(<hsa-function>) function pointer usage (#3) - the following is done in several places: decltype(hsa_memory_allocate)* hsa_memory_allocate - above can cause compiler errors - replace decltype(<hsa-function>) with decltype(::<hsa-function>) - this ensures that the type within the decltype is recognized as the global scope HSA function, not the variable - in many places, the variable has a "_fn" suffix to prevent this issue but added '::' anyway for consistency commit ac49fdd92a72e9c99394253a02da413a6c2e3b3a Merge: a07946a 03a0855 Author: Ammar ELWazir <aelwazir@amd.com> Date: Wed Jul 12 11:36:24 2023 -0500 Merge pull request #2 from ROCm-Developer-Tools/gerrit-amd-staging Pull from gerrit commit 03a085588cffe863e8f466de67be1cfb205b675a Merge: e88cad2 a07946a Author: Ammar ELWazir <aelwazir@amd.com> Date: Wed Jul 12 10:57:30 2023 -0500 Merge branch 'amd-staging' into gerrit-amd-staging commit a07946a5cd4c670c83c27ad1a076a9d4567ce6d7 Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Wed Jul 12 15:46:04 2023 +0000 Enabling Cached Builds commit 525e494a7f13941077a8fd4ad6840904db4d27d4 Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Wed Jul 12 04:53:54 2023 +0000 Updating missed GPU Targets commit 42c75862f628c9bee7cfb7dc04dff2619430efbc Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Wed Jul 12 04:43:02 2023 +0000 Adding V1 Testing commit 9d72fd4aee85e4b0c12e717060d2730fa5b73be1 Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Wed Jul 12 03:34:31 2023 +0000 Fixing Artifacts directory path commit f4000cc558b3b2e4676f7994f7ce8c8e6f94518e Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Wed Jul 12 03:27:26 2023 +0000 Fixing CMake for test build job commit 2ce8115d4c33948c3c8f957f545a95a04e1d6cd2 Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Wed Jul 12 03:16:18 2023 +0000 Fixing Ubuntu CMake for ubuntu test build commit 6d0ed439191be900748d0c025157f9d689a73ec7 Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Wed Jul 12 01:28:41 2023 +0000 Removing Navi21 commit e349a7642e5ae5eb03ab9fcd0a0f74f09f78cab5 Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Wed Jul 12 01:14:14 2023 +0000 Removing Navi21 commit fefd02fe68d2a4bca7ec2e381960ad004ee9fc5b Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Wed Jul 12 00:42:48 2023 +0000 Fixing CMake Job commit 2ea46abf7bf92643efa8c549fa70346ffbd79d65 Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Wed Jul 12 00:35:13 2023 +0000 Fixing CMake Job commit d99d681ed1999c5fcf291dc678b11a77205fb0f3 Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Wed Jul 12 00:32:13 2023 +0000 Fixing Pull Latest Dockers and CMake Jobs commit dfc4498072d13b4a1df3a63047d34c682c3d9a29 Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Tue Jul 11 23:54:21 2023 +0000 Fixing CMake job commit 919efe04de707f7c702031be15c3e2c5f8442cbb Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Tue Jul 11 23:52:13 2023 +0000 Adding Pull Last dockers job commit be1b1256e8b0e05308e8f7e7e69bee3acca55281 Author: Ammar ELWazir <aelwazir@amd.com> Date: Tue Jul 11 18:25:40 2023 -0500 Update cmake.yml commit 212299fa4355ae6ec18f9aaacbb79c51ea6c6f97 Author: Ammar ELWazir <aelwazir@amd.com> Date: Tue Jul 11 18:23:35 2023 -0500 Update cmake.yml commit 7c2c1327086a61466cc6cac39f70865c051a8bc7 Author: Ammar ELWazir <aelwazir@amd.com> Date: Tue Jul 11 18:18:53 2023 -0500 Update cmake.yml commit 191b5ce007e612e814c1d7a3afb4ad398f3852e1 Author: Ammar ELWazir <aelwazir@amd.com> Date: Tue Jul 11 16:03:22 2023 -0500 Update cmake.yml commit 8824113d95f3e13c7ce4d0af8e0d9d8f522a6c4a Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Tue Jul 11 16:28:09 2023 +0000 Fixing Pull from Gerrit job name Change-Id: I9e7ed9a27a13ca49d62c93bdadb30f0057e4d385 commit cc3d5e4b02ffb439e8cc2b3efa53527c376f9982 Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Tue Jul 11 16:21:43 2023 +0000 Adding Staging sync job Change-Id: I0551f43878b0678ce4b3e74e27d62357cf95ad95 commit b9be2eee71380a2e6dd34d520e92d0c4209277a0 Author: Ammar ELWazir <Ammar.ELWazir@amd.com> Date: Tue Jul 11 15:57:11 2023 +0000 Fixing build.sh Change-Id: Ia987b0244f0875370d5fe69907b3f5e9cea914de commit 9eee33a95a1abd656a7ac5ca10a9f245e9825431 Author: Ammar ELWazir <aelwazir@amd.com> Date: Mon Jul 10 21:39:46 2023 -0500 Update cmake.yml commit 7093b85a78497140e8b52632ca2a002bdaeacd62 Author: Ammar ELWazir <aelwazir@amd.com> Date: Mon Jul 10 21:33:29 2023 -0500 Update cmake.yml commit f54697172c72a67740f9fdfa0c217b6ea6931576 Author: Ammar ELWazir <aelwazir@amd.com> Date: Mon Jul 10 21:01:26 2023 -0500 Update cmake.yml commit 1b6620e16f8940386b0f4f04e69e2410d21c0e26 Author: Ammar ELWazir <aelwazir@amd.com> Date: Mon Jul 10 20:21:02 2023 -0500 Update cmake.yml commit a94bec740c6b42c4b79c87bca20fa87b99bf060d Author: Ammar ELWazir <aelwazir@amd.com> Date: Mon Jul 10 19:46:35 2023 -0500 Update cmake.yml commit 85d6b29d4375a69d575c18ece8542c50f2ddfcc3 Author: Ammar ELWazir <aelwazir@amd.com> Date: Mon Jul 10 19:34:39 2023 -0500 Update cmake.yml commit 8c004887cf1435f1a6214c3d2455299a8a27bd4c Author: Ammar ELWazir <aelwazir@amd.com> Date: Mon Jul 10 19:31:17 2023 -0500 Update cmake.yml commit a14a9168e17d9348a53c6e9c9a47ba1edb4c4509 Author: Ammar ELWazir <aelwazir@amd.com> Date: Mon Jul 10 19:25:46 2023 -0500 Update cmake.yml commit 000f2f40b84e6a2f7d4becdbf5aed01436ca4c83 Author: Ammar ELWazir <aelwazir@amd.com> Date: Mon Jul 10 19:08:18 2023 -0500 Update cmake.yml commit a28a53d56731cad848fa9133d1c4dbaa8fc7afa7 Author: Ammar ELWazir <aelwazir@amd.com> Date: Mon Jul 10 19:03:39 2023 -0500 Update cmake.yml commit a6a2db01027f0b01fdfbb5997ddb772c7f51b649 Author: Ammar ELWazir <aelwazir@amd.com> Date: Mon Jul 10 18:21:53 2023 -0500 Update cmake.yml commit 118ef2a88b2d44e3207c31c343da3e5e5ec6f176 Author: Ammar ELWazir <aelwazir@amd.com> Date: Mon Jul 10 17:55:57 2023 -0500 Update cmake.yml commit 03c4c232396440cd0be6d2dd7baf4ceea1c2589d Author: Ammar ELWazir <aelwazir@amd.com> Date: Mon Jul 10 17:48:49 2023 -0500 Create cmake.yml Change-Id: I77992f15694e77cbae49c56f9ff02f4f9079235d
2023-07-13 20:54:30 -04:00
1 parent 019ddfe68e
commit d4a33cf33a
@@ -20,14 +20,14 @@
 # THE SOFTWARE.
 ################################################################################
 cmake_minimum_required(VERSION 3.16.0)
-set ( EXE_NAME "rocprof-ctrl" )
+set(EXE_NAME "rocprof-ctrl")

-if ( NOT DEFINED TEST_DIR )
-  set ( TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR} )
-  project ( ${EXE_NAME} C CXX )
-  ## Set build environment
-  include ( env )
-endif ()
+if(NOT DEFINED TEST_DIR)
+    set(TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+    project(${EXE_NAME} C CXX)
+    # Set build environment
+    include(env)
+endif()

 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
@@ -35,164 +35,198 @@ find_package(Threads REQUIRED)
 add_definitions(-DAMD_INTERNAL_BUILD=1)

 find_package(Threads REQUIRED)
-find_package(hsa-runtime64 REQUIRED CONFIG HINTS ${CMAKE_INSTALL_PREFIX} PATHS ${ROCM_PATH})
-get_property(HSA_RUNTIME_INCLUDE_DIRECTORIES TARGET hsa-runtime64::hsa-runtime64 PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
-find_file(HSA_H hsa.h
-  PATHS ${HSA_RUNTIME_INCLUDE_DIRECTORIES}
-  PATH_SUFFIXES hsa
-  NO_DEFAULT_PATH
-  REQUIRED)
+find_package(
+    hsa-runtime64 REQUIRED CONFIG
+    HINTS ${CMAKE_INSTALL_PREFIX}
+    PATHS ${ROCM_PATH})
+get_property(
+    HSA_RUNTIME_INCLUDE_DIRECTORIES
+    TARGET hsa-runtime64::hsa-runtime64
+    PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
+find_file(
+    HSA_H hsa.h
+    PATHS ${HSA_RUNTIME_INCLUDE_DIRECTORIES}
+    PATH_SUFFIXES hsa
+    NO_DEFAULT_PATH REQUIRED)
 get_filename_component(HSA_RUNTIME_INC_PATH ${HSA_H} DIRECTORY)
 include_directories(${HSA_RUNTIME_INC_PATH})

-## C test
-add_executable ( "c_test" ${TEST_DIR}/app/c_test.c )
-target_include_directories ( "c_test" PRIVATE ${ROOT_DIR} ${PROJECT_SOURCE_DIR}/include $<TARGET_PROPERTY:hsa-runtime64::hsa-runtime64,INTERFACE_INCLUDE_DIRECTORIES> )
-install(TARGETS "c_test" DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1/test COMPONENT tests)
+# C test
+add_executable("c_test" ${TEST_DIR}/app/c_test.c)
+target_include_directories(
+    "c_test"
+    PRIVATE ${ROOT_DIR} ${PROJECT_SOURCE_DIR}/include
+            $<TARGET_PROPERTY:hsa-runtime64::hsa-runtime64,INTERFACE_INCLUDE_DIRECTORIES>)
+install(
+    TARGETS "c_test"
+    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1/test
+    COMPONENT tests)

-## Util sources
-file( GLOB UTIL_SRC "${TEST_DIR}/util/*.cpp" )
+# Util sources
+file(GLOB UTIL_SRC "${TEST_DIR}/util/*.cpp")

-## Standalone test sources
-set ( ST_EXE_NAME "standalone_test" )
-set ( ST_TST_SRC
-  ${TEST_DIR}/app/standalone_test.cpp
-  ${TEST_DIR}/ctrl/test_hsa.cpp
-)
+# Standalone test sources
+set(ST_EXE_NAME "standalone_test")
+set(ST_TST_SRC ${TEST_DIR}/app/standalone_test.cpp ${TEST_DIR}/ctrl/test_hsa.cpp)

-## Standalone intercept test sources
-set ( STIN_EXE_NAME "stand_intercept_test" )
-set ( STIN_TST_SRC
-  ${TEST_DIR}/app/stand_intercept_test.cpp
-  ${TEST_DIR}/ctrl/test_hsa.cpp
-)
+# Standalone intercept test sources
+set(STIN_EXE_NAME "stand_intercept_test")
+set(STIN_TST_SRC ${TEST_DIR}/app/stand_intercept_test.cpp ${TEST_DIR}/ctrl/test_hsa.cpp)

-## Intercept test sources
-set ( IN_EXE_NAME "intercept_test" )
-set ( IN_TST_SRC
-  ${TEST_DIR}/app/intercept_test.cpp
-  ${TEST_DIR}/ctrl/test_hsa.cpp
-)
+# Intercept test sources
+set(IN_EXE_NAME "intercept_test")
+set(IN_TST_SRC ${TEST_DIR}/app/intercept_test.cpp ${TEST_DIR}/ctrl/test_hsa.cpp)

-## Test control sources
-set ( CTRL_SRC
-  ${TEST_DIR}/app/test.cpp
-  ${TEST_DIR}/ctrl/test_hsa.cpp
-)
+# Test control sources
+set(CTRL_SRC ${TEST_DIR}/app/test.cpp ${TEST_DIR}/ctrl/test_hsa.cpp)

-## Dummy kernel
-set ( DUMMY_NAME dummy_kernel )
-## Test kernel
-set ( TEST_NAME simple_convolution )
-set ( KERN_SRC ${TEST_DIR}/${TEST_NAME}/${TEST_NAME}.cpp )
+# Dummy kernel
+set(DUMMY_NAME dummy_kernel)
+# Test kernel
+set(TEST_NAME simple_convolution)
+set(KERN_SRC ${TEST_DIR}/${TEST_NAME}/${TEST_NAME}.cpp)

-## Building test kernels
-# add_custom_target( mytest
-#   COMMAND sh -xc "${TEST_DIR}/../bin/build_kernel.sh ${TEST_DIR}/${DUMMY_NAME}/${DUMMY_NAME} ${PROJECT_BINARY_DIR} '${ROCM_ROOT_DIR}' '${GPU_TARGETS}'"
-#   COMMAND sh -xc "${TEST_DIR}/../bin/build_kernel.sh ${TEST_DIR}/${TEST_NAME}/${TEST_NAME} ${PROJECT_BINARY_DIR} '${ROCM_ROOT_DIR}' '${GPU_TARGETS}'"
-# )
+# Building test kernels add_custom_target( mytest COMMAND sh -xc
+# "${TEST_DIR}/../bin/build_kernel.sh ${TEST_DIR}/${DUMMY_NAME}/${DUMMY_NAME}
+# ${PROJECT_BINARY_DIR} '${ROCM_ROOT_DIR}' '${GPU_TARGETS}'" COMMAND sh -xc
+# "${TEST_DIR}/../bin/build_kernel.sh ${TEST_DIR}/${TEST_NAME}/${TEST_NAME}
+# ${PROJECT_BINARY_DIR} '${ROCM_ROOT_DIR}' '${GPU_TARGETS}'" )

-find_package(Clang REQUIRED CONFIG
-             PATHS ${ROCM_ROOT_DIR}
-             PATH_SUFFIXES "llvm/lib/cmake/clang")
+find_package(
+    Clang REQUIRED CONFIG
+    PATHS ${ROCM_ROOT_DIR}
+    PATH_SUFFIXES "llvm/lib/cmake/clang")

-## Build the hsa (standalone) simple_convolution test
+# Build the hsa (standalone) simple_convolution test
 function(generate_hsaco TARGET_ID INPUT_FILE OUTPUT_FILE)
-  separate_arguments(CLANG_ARG_LIST UNIX_COMMAND
-    "-O2 -x cl -Xclang -finclude-default-header -cl-denorms-are-zero -cl-std=CL2.0 --hip-device-lib-path=${ROCM_ROOT_DIR}/amdgcn/bitcode
-    -Wl,--build-id=sha1 -target amdgcn-amd-amdhsa -mcpu=${TARGET_ID} -mcode-object-version=4 -o ${OUTPUT_FILE} ${INPUT_FILE}")
-  add_custom_command(OUTPUT ${PROJECT_BINARY_DIR}/${OUTPUT_FILE}
-    COMMAND clang ${CLANG_ARG_LIST}
-    WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
-    DEPENDS ${INPUT_FILE} clang
-    COMMENT "Building ${OUTPUT_FILE}..."
-    VERBATIM)
-  install(FILES ${PROJECT_BINARY_DIR}/${OUTPUT_FILE} DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1 COMPONENT tests)
-  set(HSACO_TARGET_LIST ${HSACO_TARGET_LIST} ${PROJECT_BINARY_DIR}/${OUTPUT_FILE} PARENT_SCOPE)
+    separate_arguments(
+        CLANG_ARG_LIST
+        UNIX_COMMAND
+        "-O2 -x cl -Xclang -finclude-default-header -cl-denorms-are-zero -cl-std=CL2.0 --hip-device-lib-path=${ROCM_ROOT_DIR}/amdgcn/bitcode
+    -Wl,--build-id=sha1 -target amdgcn-amd-amdhsa -mcpu=${TARGET_ID} -mcode-object-version=4 -o ${OUTPUT_FILE} ${INPUT_FILE}"
+        )
+    add_custom_command(
+        OUTPUT ${PROJECT_BINARY_DIR}/${OUTPUT_FILE}
+        COMMAND clang ${CLANG_ARG_LIST}
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${INPUT_FILE} clang
+        COMMENT "Building ${OUTPUT_FILE}..."
+        VERBATIM)
+    install(
+        FILES ${PROJECT_BINARY_DIR}/${OUTPUT_FILE}
+        DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1
+        COMPONENT tests)
+    set(HSACO_TARGET_LIST
+        ${HSACO_TARGET_LIST} ${PROJECT_BINARY_DIR}/${OUTPUT_FILE}
+        PARENT_SCOPE)
 endfunction(generate_hsaco)

 separate_arguments(GPU_TARGETS)
 list(LENGTH GPU_TARGETS list_count)
-if (${list_count} LESS_EQUAL 1)
-  string(REPLACE " " ";" GPU_LIST ${GPU_TARGETS})
-  string(REPLACE "," ";" GPU_LIST ${GPU_TARGETS})
+if(${list_count} LESS_EQUAL 1)
+    string(REPLACE " " ";" GPU_LIST ${GPU_TARGETS})
+    string(REPLACE "," ";" GPU_LIST ${GPU_TARGETS})
 else()
-  set(GPU_LIST ${GPU_TARGETS})
+    set(GPU_LIST ${GPU_TARGETS})
 endif()
 foreach(target_id ${GPU_LIST})
-  ## generate kernel bitcodes
-  generate_hsaco(${target_id} ${TEST_DIR}/${TEST_NAME}/${TEST_NAME}.cl ${target_id}_SimpleConvolution.hsaco)
-  generate_hsaco(${target_id} ${TEST_DIR}/${DUMMY_NAME}/${DUMMY_NAME}.cl ${target_id}_DummyKernel.hsaco)
+    # generate kernel bitcodes
+    generate_hsaco(${target_id} ${TEST_DIR}/${TEST_NAME}/${TEST_NAME}.cl
+                   ${target_id}_SimpleConvolution.hsaco)
+    generate_hsaco(${target_id} ${TEST_DIR}/${DUMMY_NAME}/${DUMMY_NAME}.cl
+                   ${target_id}_DummyKernel.hsaco)
 endforeach(target_id)
 add_custom_target(test DEPENDS ${HSACO_TARGET_LIST})
 add_custom_target(mytest DEPENDS ${HSACO_TARGET_LIST})
-add_custom_command(TARGET mytest POST_BUILD
-  DEPENDS mytest
-  COMMAND $<$<CONFIG:release>:${CPACK_STRIP_EXECUTABLE}>
-  ARGS ${HSACO_TARGET_LIST})
+add_custom_command(
+    TARGET mytest
+    POST_BUILD DEPENDS mytest
+    COMMAND $<$<CONFIG:release>:${CPACK_STRIP_EXECUTABLE}> ARGS ${HSACO_TARGET_LIST})

-## Building standalone test executable
-add_executable ( ${ST_EXE_NAME} ${ST_TST_SRC} ${UTIL_SRC} ${KERN_SRC} )
-target_include_directories ( ${ST_EXE_NAME} PRIVATE ${TEST_DIR} ${ROOT_DIR} ${PROJECT_SOURCE_DIR}/include )
-target_link_libraries ( ${ST_EXE_NAME} ${ROCPROFILER_TARGET} hsa-runtime64::hsa-runtime64 hsakmt::hsakmt Threads::Threads stdc++fs dl )
-install(TARGETS ${ST_EXE_NAME} DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1/test COMPONENT tests)
+# Building standalone test executable
+add_executable(${ST_EXE_NAME} ${ST_TST_SRC} ${UTIL_SRC} ${KERN_SRC})
+target_include_directories(${ST_EXE_NAME} PRIVATE ${TEST_DIR} ${ROOT_DIR}
+                                                  ${PROJECT_SOURCE_DIR}/include)
+target_link_libraries(${ST_EXE_NAME} ${ROCPROFILER_TARGET} hsa-runtime64::hsa-runtime64
+                      hsakmt::hsakmt Threads::Threads stdc++fs dl)
+install(
+    TARGETS ${ST_EXE_NAME}
+    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1/test
+    COMPONENT tests)

-## Building standalone intercept test executable
-add_executable ( ${STIN_EXE_NAME} ${STIN_TST_SRC} ${UTIL_SRC} ${KERN_SRC} )
-target_include_directories ( ${STIN_EXE_NAME} PRIVATE ${TEST_DIR} ${ROOT_DIR} ${PROJECT_SOURCE_DIR}/include )
-target_link_libraries ( ${STIN_EXE_NAME} ${ROCPROFILER_TARGET} hsa-runtime64::hsa-runtime64 hsakmt::hsakmt Threads::Threads stdc++fs dl )
-install(TARGETS ${STIN_EXE_NAME} DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1/test COMPONENT tests)
+# Building standalone intercept test executable
+add_executable(${STIN_EXE_NAME} ${STIN_TST_SRC} ${UTIL_SRC} ${KERN_SRC})
+target_include_directories(${STIN_EXE_NAME} PRIVATE ${TEST_DIR} ${ROOT_DIR}
+                                                    ${PROJECT_SOURCE_DIR}/include)
+target_link_libraries(${STIN_EXE_NAME} ${ROCPROFILER_TARGET} hsa-runtime64::hsa-runtime64
+                      hsakmt::hsakmt Threads::Threads stdc++fs dl)
+install(
+    TARGETS ${STIN_EXE_NAME}
+    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1/test
+    COMPONENT tests)

-## Building intercept test executable
-add_library ( ${IN_EXE_NAME} SHARED ${IN_TST_SRC} ${UTIL_SRC} ${KERN_SRC} )
-target_include_directories ( ${IN_EXE_NAME} PRIVATE ${TEST_DIR} ${ROOT_DIR} ${PROJECT_SOURCE_DIR}/include )
-target_link_libraries ( ${IN_EXE_NAME} ${ROCPROFILER_TARGET} hsa-runtime64::hsa-runtime64 hsakmt::hsakmt Threads::Threads stdc++fs dl )
-install(TARGETS ${IN_EXE_NAME} DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1/test COMPONENT tests)
+# Building intercept test executable
+add_library(${IN_EXE_NAME} SHARED ${IN_TST_SRC} ${UTIL_SRC} ${KERN_SRC})
+target_include_directories(${IN_EXE_NAME} PRIVATE ${TEST_DIR} ${ROOT_DIR}
+                                                  ${PROJECT_SOURCE_DIR}/include)
+target_link_libraries(${IN_EXE_NAME} ${ROCPROFILER_TARGET} hsa-runtime64::hsa-runtime64
+                      hsakmt::hsakmt Threads::Threads stdc++fs dl)
+install(
+    TARGETS ${IN_EXE_NAME}
+    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1/test
+    COMPONENT tests)

-## Building ctrl test executable
-add_executable ( ${EXE_NAME} ${CTRL_SRC} ${UTIL_SRC} ${KERN_SRC} )
-target_include_directories ( ${EXE_NAME} PRIVATE ${TEST_DIR} ${ROOT_DIR} ${PROJECT_SOURCE_DIR}/include )
-target_link_libraries ( ${EXE_NAME} hsa-runtime64::hsa-runtime64 hsakmt::hsakmt Threads::Threads stdc++fs dl )
-execute_process ( COMMAND sh -xc "cp ${TEST_DIR}/run.sh ${PROJECT_BINARY_DIR}" )
-execute_process ( COMMAND sh -xc "cp ${TEST_DIR}/tool/*.xml ${PROJECT_BINARY_DIR}" )
-execute_process ( COMMAND sh -xc "mkdir -p ${PROJECT_BINARY_DIR}/RESULTS" )
-## TODO(aelwazir): Should be replaced by the current location in the main CMakeLists.txt
-install(TARGETS ${EXE_NAME} DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1/test COMPONENT tests)
+# Building ctrl test executable
+add_executable(${EXE_NAME} ${CTRL_SRC} ${UTIL_SRC} ${KERN_SRC})
+target_include_directories(${EXE_NAME} PRIVATE ${TEST_DIR} ${ROOT_DIR}
+                                               ${PROJECT_SOURCE_DIR}/include)
+target_link_libraries(${EXE_NAME} hsa-runtime64::hsa-runtime64 hsakmt::hsakmt
+                      Threads::Threads stdc++fs dl)
+execute_process(COMMAND sh -xc "cp ${TEST_DIR}/run.sh ${PROJECT_BINARY_DIR}")
+execute_process(COMMAND sh -xc "cp ${TEST_DIR}/tool/*.xml ${PROJECT_BINARY_DIR}")
+execute_process(COMMAND sh -xc "mkdir -p ${PROJECT_BINARY_DIR}/RESULTS")
+# TODO(aelwazir): Should be replaced by the current location in the main CMakeLists.txt
+install(
+    TARGETS ${EXE_NAME}
+    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1/test
+    COMPONENT tests)

-## Build test library
-set ( TEST_LIB "rocprof-tool" )
-set ( TEST_LIB_SRC ${TEST_DIR}/tool/tool.cpp ${UTIL_SRC} )
-add_library ( ${TEST_LIB} SHARED ${TEST_LIB_SRC} )
-target_include_directories ( ${TEST_LIB} PRIVATE ${TEST_DIR} ${ROOT_DIR} ${PROJECT_SOURCE_DIR}/include )
-target_link_libraries ( ${TEST_LIB} ${ROCPROFILER_TARGET} hsa-runtime64::hsa-runtime64 Threads::Threads atomic dl )
-## TODO(aelwazir): Should be replaced by the current location in the main CMakeLists.txt
-install(TARGETS ${TEST_LIB} DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1/test COMPONENT tests)
+# Build test library
+set(TEST_LIB "rocprof-tool")
+set(TEST_LIB_SRC ${TEST_DIR}/tool/tool.cpp ${UTIL_SRC})
+add_library(${TEST_LIB} SHARED ${TEST_LIB_SRC})
+target_include_directories(${TEST_LIB} PRIVATE ${TEST_DIR} ${ROOT_DIR}
+                                               ${PROJECT_SOURCE_DIR}/include)
+target_link_libraries(${TEST_LIB} ${ROCPROFILER_TARGET} hsa-runtime64::hsa-runtime64
+                      Threads::Threads atomic dl)
+# TODO(aelwazir): Should be replaced by the current location in the main CMakeLists.txt
+install(
+    TARGETS ${TEST_LIB}
+    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1/test
+    COMPONENT tests)

-## Build memory test bench
-add_custom_target( mbench
-  COMMAND sh -xc "cp -r ${TEST_DIR}/memory_validation ${PROJECT_BINARY_DIR}/test/."
-  COMMAND make -C "${PROJECT_BINARY_DIR}/test/memory_validation"
-)
+# Build memory test bench
+add_custom_target(
+    mbench
+    COMMAND sh -xc "cp -r ${TEST_DIR}/memory_validation ${PROJECT_BINARY_DIR}/test/."
+    COMMAND make -C "${PROJECT_BINARY_DIR}/test/memory_validation")

-## Copy OCL test
-execute_process ( COMMAND sh -xc "cp -r ${TEST_DIR}/ocl ${PROJECT_BINARY_DIR}/test/." )
-install(DIRECTORY ${TEST_DIR}/ocl DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1/test COMPONENT tests)
+# Copy OCL test
+execute_process(COMMAND sh -xc "cp -r ${TEST_DIR}/ocl ${PROJECT_BINARY_DIR}/test/.")
+install(
+    DIRECTORY ${TEST_DIR}/ocl
+    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1/test
+    COMPONENT tests)

 file(GLOB TEST_XML_FILES ${CMAKE_CURRENT_SOURCE_DIR}/tool/*.xml)
 install(
-  FILES ${TEST_XML_FILES}
-  DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1
-  COMPONENT tests)
+    FILES ${TEST_XML_FILES}
+    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1
+    COMPONENT tests)

 install(
-  FILES ${PROJECT_BINARY_DIR}/run.sh
-  DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1
-  PERMISSIONS
-    OWNER_READ
-    OWNER_WRITE
-    OWNER_EXECUTE
-    GROUP_READ
-    GROUP_EXECUTE
-    WORLD_READ
-    WORLD_EXECUTE
-  COMPONENT tests)
+    FILES ${PROJECT_BINARY_DIR}/run.sh
+    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/tests-v1
+    PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ
+                WORLD_EXECUTE
+    COMPONENT tests)
@@ -42,8 +42,8 @@ pthread_mutex_t mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
 // Tool is unloaded
 volatile bool is_loaded = false;
 // Profiling features
-//rocprofiler_feature_t* features = NULL;
-//unsigned feature_count = 0;
+// rocprofiler_feature_t* features = NULL;
+// unsigned feature_count = 0;

 // Error handler
 void fatal(const std::string msg) {
@@ -83,7 +83,8 @@ struct handler_arg_t {
 };

 // Dump stored context entry
-void dump_context_entry(context_entry_t* entry, rocprofiler_feature_t* features, unsigned feature_count) {
+void dump_context_entry(context_entry_t* entry, rocprofiler_feature_t* features,
+                        unsigned feature_count) {
  volatile std::atomic<bool>* valid = reinterpret_cast<std::atomic<bool>*>(&entry->valid);
  while (valid->load() == false) sched_yield();

@@ -92,16 +93,11 @@ void dump_context_entry(context_entry_t* entry, rocprofiler_feature_t* features,

  fflush(stdout);
  fprintf(stdout, "kernel symbol(0x%lx) name(\"%s\") tid(%u) queue-id(%u) gpu-id(%u) ",
-    entry->data.kernel_object,
-    kernel_name.c_str(),
-    entry->data.thread_id,
-    entry->data.queue_id,
-    HsaRsrcFactory::Instance().GetAgentInfo(entry->agent)->dev_index);
-  if (record) fprintf(stdout, "time(%lu,%lu,%lu,%lu)",
-    record->dispatch,
-    record->begin,
-    record->end,
-    record->complete);
+          entry->data.kernel_object, kernel_name.c_str(), entry->data.thread_id,
+          entry->data.queue_id, HsaRsrcFactory::Instance().GetAgentInfo(entry->agent)->dev_index);
+  if (record)
+    fprintf(stdout, "time(%lu,%lu,%lu,%lu)", record->dispatch, record->begin, record->end,
+            record->complete);
  fprintf(stdout, "\n");
  fflush(stdout);

@@ -125,8 +121,8 @@ void dump_context_entry(context_entry_t* entry, rocprofiler_feature_t* features,
        fprintf(stdout, "= (%lu)\n", p->data.result_int64);
        break;
      case ROCPROFILER_DATA_KIND_DOUBLE:
-	fprintf(stdout, "= (%lf)\n", p->data.result_double);
-	break;
+        fprintf(stdout, "= (%lf)\n", p->data.result_double);
+        break;
      default:
        fprintf(stderr, "Undefined data kind(%u)\n", p->data.kind);
        abort();
@@ -205,8 +201,8 @@ hsa_status_t dispatch_callback(const rocprofiler_callback_data_t* callback_data,
  rocprofiler_properties_t properties{};
  properties.handler = context_handler1;
  properties.handler_arg = (void*)entry;
-  status = rocprofiler_open(agent, features, feature_count,
-                            &context, 0 /*ROCPROFILER_MODE_SINGLEGROUP*/, &properties);
+  status = rocprofiler_open(agent, features, feature_count, &context,
+                            0 /*ROCPROFILER_MODE_SINGLEGROUP*/, &properties);
  check_status(status);
 #endif
  // Get group[0]
@@ -242,12 +238,12 @@ unsigned metrics_input(rocprofiler_feature_t** ret) {
  features[4].name = "SQ_INSTS_VALU";
  features[5].kind = ROCPROFILER_FEATURE_KIND_METRIC;
  features[5].name = "VALUInsts";
-//  features[6].kind = ROCPROFILER_FEATURE_KIND_METRIC;
-//  features[6].name = "TCC_HIT_sum";
-//  features[7].kind = ROCPROFILER_FEATURE_KIND_METRIC;
-//  features[7].name = "TCC_MISS_sum";
-//  features[8].kind = ROCPROFILER_FEATURE_KIND_METRIC;
-//  features[8].name = "WRITE_SIZE";
+  //  features[6].kind = ROCPROFILER_FEATURE_KIND_METRIC;
+  //  features[6].name = "TCC_HIT_sum";
+  //  features[7].kind = ROCPROFILER_FEATURE_KIND_METRIC;
+  //  features[7].name = "TCC_MISS_sum";
+  //  features[8].kind = ROCPROFILER_FEATURE_KIND_METRIC;
+  //  features[8].name = "WRITE_SIZE";

  *ret = features;
  return feature_count;
@@ -275,7 +271,7 @@ void initialize() {

  // Adding dispatch observer
  callbacks_arg_t* callbacks_arg = new callbacks_arg_t{};
-  callbacks_arg->pools = new rocprofiler_pool_t* [gpu_count];
+  callbacks_arg->pools = new rocprofiler_pool_t*[gpu_count];
  for (unsigned gpu_id = 0; gpu_id < gpu_count; gpu_id++) {
    // Getting GPU device info
    const AgentInfo* agent_info = NULL;
@@ -286,8 +282,8 @@ void initialize() {

    // Open profiling pool
    rocprofiler_pool_t* pool = NULL;
-    hsa_status_t status = rocprofiler_pool_open(agent_info->dev_id, features, feature_count,
-                                                &pool, 0/*ROCPROFILER_MODE_SINGLEGROUP*/, &properties);
+    hsa_status_t status = rocprofiler_pool_open(agent_info->dev_id, features, feature_count, &pool,
+                                                0 /*ROCPROFILER_MODE_SINGLEGROUP*/, &properties);
    check_status(status);
    callbacks_arg->pools[gpu_id] = pool;
  }
@@ -310,8 +306,7 @@ void cleanup() {
 }

 // Tool constructor
-extern "C" PUBLIC_API void OnLoadToolProp(rocprofiler_settings_t* settings)
-{
+extern "C" PUBLIC_API void OnLoadToolProp(rocprofiler_settings_t* settings) {
  if (pthread_mutex_lock(&mutex) != 0) {
    perror("pthread_mutex_lock");
    abort();
@@ -348,7 +343,8 @@ extern "C" PUBLIC_API void OnUnloadTool() {
 }

 extern "C" CONSTRUCTOR_API void constructor() {
-  printf("INTT constructor\n"); fflush(stdout);
+  printf("INTT constructor\n");
+  fflush(stdout);
 }

 extern "C" DESTRUCTOR_API void destructor() {
@@ -73,13 +73,12 @@ void dump_context_entry(context_entry_t* entry) {
  const rocprofiler_dispatch_record_t* record = entry->data.record;

  fflush(stdout);
-  fprintf(stdout, "kernel-object(0x%lx) name(\"%s\")", entry->data.kernel_object, kernel_name.c_str());
-  if (record) fprintf(stdout, ", gpu-id(%u), time(%lu,%lu,%lu,%lu)",
-    HsaRsrcFactory::Instance().GetAgentInfo(entry->agent)->dev_index,
-    record->dispatch,
-    record->begin,
-    record->end,
-    record->complete);
+  fprintf(stdout, "kernel-object(0x%lx) name(\"%s\")", entry->data.kernel_object,
+          kernel_name.c_str());
+  if (record)
+    fprintf(stdout, ", gpu-id(%u), time(%lu,%lu,%lu,%lu)",
+            HsaRsrcFactory::Instance().GetAgentInfo(entry->agent)->dev_index, record->dispatch,
+            record->begin, record->end, record->complete);
  fprintf(stdout, "\n");
  fflush(stdout);

@@ -115,8 +114,8 @@ bool context_handler(rocprofiler_group_t group, void* arg) {
 }

 // Kernel disoatch callback
-hsa_status_t dispatch_callback(const rocprofiler_callback_data_t* callback_data, void* /*user_data*/,
-                               rocprofiler_group_t* group) {
+hsa_status_t dispatch_callback(const rocprofiler_callback_data_t* callback_data,
+                               void* /*user_data*/, rocprofiler_group_t* group) {
  // HSA status
  hsa_status_t status = HSA_STATUS_ERROR;

@@ -132,8 +131,8 @@ hsa_status_t dispatch_callback(const rocprofiler_callback_data_t* callback_data,
  properties.handler_arg = (void*)entry;

  // Open profiling context
-  status = rocprofiler_open(callback_data->agent, NULL, 0,
-                            &context, 0 /*ROCPROFILER_MODE_SINGLEGROUP*/, &properties);
+  status = rocprofiler_open(callback_data->agent, NULL, 0, &context,
+                            0 /*ROCPROFILER_MODE_SINGLEGROUP*/, &properties);
  check_status(status);

  // Get group[0]
@@ -178,8 +177,10 @@ int main() {

  for (unsigned ind = 0; ind < kiter; ++ind) {
    printf("Iteration %u:\n", ind);
-    if ((ind & 1) == 0) rocprofiler_start_queue_callbacks();
-    else rocprofiler_stop_queue_callbacks();
+    if ((ind & 1) == 0)
+      rocprofiler_start_queue_callbacks();
+    else
+      rocprofiler_stop_queue_callbacks();
    ret_val = RunKernel<DummyKernel, TestAql>(0, NULL, agent_info, queue, diter);
    if (ret_val) ret_val = RunKernel<SimpleConvolution, TestAql>(0, NULL, agent_info, queue, diter);
  }
@@ -51,7 +51,8 @@ void print_sys_time(clockid_t clock_id, rocprofiler_time_id_t time_id) {
  HsaTimer::timestamp_t timestamp1 = timestamp;
  HsaTimer::timestamp_t value_ns1 = value_ns;

-  printf("time-id(%d) ts_ns(%lu) orig_ns(%lu) time_ns(%lu) err_ns(%lu)\n", (int)time_id, timestamp, tm_val_ns, value_ns, error_ns);
+  printf("time-id(%d) ts_ns(%lu) orig_ns(%lu) time_ns(%lu) err_ns(%lu)\n", (int)time_id, timestamp,
+         tm_val_ns, value_ns, error_ns);

  sleep(1);

@@ -66,51 +67,53 @@ void print_sys_time(clockid_t clock_id, rocprofiler_time_id_t time_id) {
  HsaTimer::timestamp_t timestamp2 = timestamp;
  HsaTimer::timestamp_t value_ns2 = value_ns;

-  printf("time-id(%d) ts_ns(%lu) orig_ns(%lu) time_ns(%lu) err_ns(%lu)\n", (int)time_id, timestamp, tm_val_ns, value_ns, error_ns);
+  printf("time-id(%d) ts_ns(%lu) orig_ns(%lu) time_ns(%lu) err_ns(%lu)\n", (int)time_id, timestamp,
+         tm_val_ns, value_ns, error_ns);
  printf("ts-diff(%lu) tm-diff(%lu)\n", timestamp2 - timestamp1, value_ns2 - value_ns1);
 }

 // print profiler features
 void print_features(rocprofiler_feature_t* feature, uint32_t feature_count) {
-    for (rocprofiler_feature_t* p = feature; p < feature + feature_count; ++p) {
-      std::cout << (p - feature) << ": " << p->name;
-      switch (p->data.kind) {
-        case ROCPROFILER_DATA_KIND_INT64:
-          std::cout << std::dec << " result64 (" << p->data.result_int64 << ")" << std::endl;
-          break;
-        case ROCPROFILER_DATA_KIND_DOUBLE:
-          std::cout << " result64 (" << p->data.result_double << ")" << std::endl;
-          break;
-        case ROCPROFILER_DATA_KIND_BYTES: {
-          const char* ptr = reinterpret_cast<const char*>(p->data.result_bytes.ptr);
-          uint64_t size = 0;
-          for (unsigned i = 0; i < p->data.result_bytes.instance_count; ++i) {
-            size = *reinterpret_cast<const uint64_t*>(ptr);
-            const char* data = ptr + sizeof(size);
-            std::cout << std::endl;
-            std::cout << std::hex << "  data (" << (void*)data << ")" << std::endl;
-            std::cout << std::dec << "  size (" << size << ")" << std::endl;
-            ptr = data + size;
-          }
-          break;
+  for (rocprofiler_feature_t* p = feature; p < feature + feature_count; ++p) {
+    std::cout << (p - feature) << ": " << p->name;
+    switch (p->data.kind) {
+      case ROCPROFILER_DATA_KIND_INT64:
+        std::cout << std::dec << " result64 (" << p->data.result_int64 << ")" << std::endl;
+        break;
+      case ROCPROFILER_DATA_KIND_DOUBLE:
+        std::cout << " result64 (" << p->data.result_double << ")" << std::endl;
+        break;
+      case ROCPROFILER_DATA_KIND_BYTES: {
+        const char* ptr = reinterpret_cast<const char*>(p->data.result_bytes.ptr);
+        uint64_t size = 0;
+        for (unsigned i = 0; i < p->data.result_bytes.instance_count; ++i) {
+          size = *reinterpret_cast<const uint64_t*>(ptr);
+          const char* data = ptr + sizeof(size);
+          std::cout << std::endl;
+          std::cout << std::hex << "  data (" << (void*)data << ")" << std::endl;
+          std::cout << std::dec << "  size (" << size << ")" << std::endl;
+          ptr = data + size;
        }
-        default:
-          std::cout << "result kind (" << p->data.kind << ")" << std::endl;
-          TEST_ASSERT(false);
+        break;
      }
+      default:
+        std::cout << "result kind (" << p->data.kind << ")" << std::endl;
+        TEST_ASSERT(false);
    }
+  }
 }

-void read_features(uint32_t n, rocprofiler_t* context, rocprofiler_feature_t* feature, const unsigned feature_count) {
-    std::cout << "read features" << std::endl;
-    hsa_status_t status = rocprofiler_read(context, n);
-    TEST_STATUS(status == HSA_STATUS_SUCCESS);
-    std::cout << "read issue" << std::endl;
-    status = rocprofiler_get_data(context, n);
-    TEST_STATUS(status == HSA_STATUS_SUCCESS);
-    status = rocprofiler_get_metrics(context);
-    TEST_STATUS(status == HSA_STATUS_SUCCESS);
-    print_features(feature, feature_count);
+void read_features(uint32_t n, rocprofiler_t* context, rocprofiler_feature_t* feature,
+                   const unsigned feature_count) {
+  std::cout << "read features" << std::endl;
+  hsa_status_t status = rocprofiler_read(context, n);
+  TEST_STATUS(status == HSA_STATUS_SUCCESS);
+  std::cout << "read issue" << std::endl;
+  status = rocprofiler_get_data(context, n);
+  TEST_STATUS(status == HSA_STATUS_SUCCESS);
+  status = rocprofiler_get_metrics(context);
+  TEST_STATUS(status == HSA_STATUS_SUCCESS);
+  print_features(feature, feature_count);
 }

 int main() {
@@ -174,7 +177,8 @@ int main() {
  const unsigned queue_count = 16;
  hsa_queue_t* queue[queue_count];
  for (unsigned queue_ind = 0; queue_ind < queue_count; ++queue_ind) {
-    if (HsaRsrcFactory::Instance().CreateQueue(agent_info, 128, &queue[queue_ind]) == false) abort();
+    if (HsaRsrcFactory::Instance().CreateQueue(agent_info, 128, &queue[queue_ind]) == false)
+      abort();
  }
  hsa_queue_t* prof_queue = queue[0];

@@ -198,7 +202,7 @@ int main() {
 #if 1
    const unsigned queue_ind = ind % queue_count;
    hsa_queue_t* prof_queue = queue[queue_ind];
-    //ret_val = RunKernel<DummyKernel, TestAql>(0, NULL, NULL, prof_queue);
+    // ret_val = RunKernel<DummyKernel, TestAql>(0, NULL, NULL, prof_queue);
    ret_val = RunKernel<SimpleConvolution, TestAql>(0, NULL, NULL, prof_queue);
    std::cout << "run kernel, queue " << queue_ind << std::endl;
 #else
@@ -26,7 +26,9 @@ THE SOFTWARE.
 #include "ctrl/test_hsa.h"
 #include "util/test_assert.h"

-template <class Kernel, class Test> bool RunKernel(int argc = 0, char* argv[] = NULL, const AgentInfo* agent_info = NULL, hsa_queue_t* queue = NULL, int count = 1) {
+template <class Kernel, class Test>
+bool RunKernel(int argc = 0, char* argv[] = NULL, const AgentInfo* agent_info = NULL,
+               hsa_queue_t* queue = NULL, int count = 1) {
  bool ret_val = false;

  if (getenv("ROC_TEST_TRACE") == NULL) std::clog.rdbuf(NULL);
@@ -70,7 +70,8 @@ bool TestHsa::Initialize(int /*arg_cnt*/, char** /*arg_list*/) {
      return false;
    }
  }
-  std::clog << "> Using agent[" << agent_info_->dev_index << "] : " << agent_info_->name << std::endl;
+  std::clog << "> Using agent[" << agent_info_->dev_index << "] : " << agent_info_->name
+            << std::endl;

  // Create an instance of Aql Queue
  if (hsa_queue_ == NULL) {
@@ -88,8 +89,8 @@ bool TestHsa::Initialize(int /*arg_cnt*/, char** /*arg_list*/) {
  // Obtain the code object file name
  std::string agentName(agent_info_->name);
  Dl_info dl_info;
-    if (dladdr(reinterpret_cast<const void*>(TestHsa::HsaShutdown), &dl_info) != 0)
-      brig_path_obj_.append(fs::path(dl_info.dli_fname).remove_filename().remove_filename());
+  if (dladdr(reinterpret_cast<const void*>(TestHsa::HsaShutdown), &dl_info) != 0)
+    brig_path_obj_.append(fs::path(dl_info.dli_fname).remove_filename().remove_filename());
  brig_path_obj_.append(agentName);
  brig_path_obj_.append("_" + name_ + ".hsaco");

@@ -219,7 +220,8 @@ bool TestHsa::Run() {
  // Submit AQL packet to the queue
  const uint64_t que_idx = hsa_rsrc_->Submit(hsa_queue_, &aql);

-  std::clog << "> Waiting on kernel dispatch signal, que_idx=" << que_idx << std::endl << std::flush;
+  std::clog << "> Waiting on kernel dispatch signal, que_idx=" << que_idx << std::endl
+            << std::flush;

  // Wait on the dispatch signal until the kernel is finished.
  // Update wait condition to HSA_WAIT_STATE_ACTIVE for Polling
@@ -35,10 +35,7 @@ class DummyKernel : public TestKernel {
  enum { KERNARG_BUF_ID, LOCAL_BUF_ID };

  // Constructor
-  DummyKernel() :
-    width_(64),
-    height_(64)
-  {
+  DummyKernel() : width_(64), height_(64) {
    SetInDescr(KERNARG_BUF_ID, KERNARG_DES_ID, 0);
    SetOutDescr(LOCAL_BUF_ID, LOCAL_DES_ID, 0);
  }
@@ -59,7 +56,9 @@ class DummyKernel : public TestKernel {
  // Reference CPU implementation
  bool ReferenceImplementation(uint32_t* output, const uint32_t* input, const float* mask,
                               const uint32_t width, const uint32_t height,
-                               const uint32_t maskWidth, const uint32_t maskHeight) { return true; }
+                               const uint32_t maskWidth, const uint32_t maskHeight) {
+    return true;
+  }

  // Width of the Input array
  const uint32_t width_;
@@ -783,7 +783,7 @@ void set_kernel_properties(const rocprofiler_callback_data_t* callback_data,
 // Kernel disoatch callback
 hsa_status_t dispatch_callback(const rocprofiler_callback_data_t* callback_data, void* user_data,
                               rocprofiler_group_t* group) {
-  if(!allow_profiling) return HSA_STATUS_SUCCESS;
+  if (!allow_profiling) return HSA_STATUS_SUCCESS;
  // TODO: return success, make atomic flag
  // Passed tool data
  callbacks_data_t* tool_data = reinterpret_cast<callbacks_data_t*>(user_data);
@@ -81,13 +81,15 @@ static hsa_status_t FindGlobalPool(hsa_amd_memory_pool_t pool, void* data, bool
    return HSA_STATUS_ERROR_INVALID_ARGUMENT;
  }

-  err = HsaRsrcFactory::HsaApi()->hsa_amd_memory_pool_get_info(pool, HSA_AMD_MEMORY_POOL_INFO_SEGMENT, &segment);
+  err = HsaRsrcFactory::HsaApi()->hsa_amd_memory_pool_get_info(
+      pool, HSA_AMD_MEMORY_POOL_INFO_SEGMENT, &segment);
  CHECK_STATUS("hsa_amd_memory_pool_get_info", err);
  if (HSA_AMD_SEGMENT_GLOBAL != segment) {
    return HSA_STATUS_SUCCESS;
  }

-  err = HsaRsrcFactory::HsaApi()->hsa_amd_memory_pool_get_info(pool, HSA_AMD_MEMORY_POOL_INFO_GLOBAL_FLAGS, &flag);
+  err = HsaRsrcFactory::HsaApi()->hsa_amd_memory_pool_get_info(
+      pool, HSA_AMD_MEMORY_POOL_INFO_GLOBAL_FLAGS, &flag);
  CHECK_STATUS("hsa_amd_memory_pool_get_info", err);

  uint32_t karg_st = flag & HSA_AMD_MEMORY_POOL_GLOBAL_FLAG_KERNARG_INIT;
@@ -140,19 +142,22 @@ HsaRsrcFactory::HsaRsrcFactory(bool initialize_hsa) : initialize_hsa_(initialize
 #ifdef ROCP_LD_AQLPROFILE
  status = LoadAqlProfileLib(&aqlprofile_api_);
 #else
-  status = hsa_api_.hsa_system_get_major_extension_table(HSA_EXTENSION_AMD_AQLPROFILE, hsa_ven_amd_aqlprofile_VERSION_MAJOR, sizeof(aqlprofile_api_), &aqlprofile_api_);
+  status = hsa_api_.hsa_system_get_major_extension_table(HSA_EXTENSION_AMD_AQLPROFILE,
+                                                         hsa_ven_amd_aqlprofile_VERSION_MAJOR,
+                                                         sizeof(aqlprofile_api_), &aqlprofile_api_);
 #endif
  CHECK_STATUS("aqlprofile API table load failed", status);

  // Get Loader API table
  loader_api_ = {0};
-  status = hsa_api_.hsa_system_get_major_extension_table(HSA_EXTENSION_AMD_LOADER, 1, sizeof(loader_api_), &loader_api_);
+  status = hsa_api_.hsa_system_get_major_extension_table(HSA_EXTENSION_AMD_LOADER, 1,
+                                                         sizeof(loader_api_), &loader_api_);
  CHECK_STATUS("loader API table query failed", status);

  // Instantiate HSA timer
  timer_ = new HsaTimer(&hsa_api_);
  CHECK_STATUS("HSA timer allocation failed",
-    (timer_ == NULL) ? HSA_STATUS_ERROR : HSA_STATUS_SUCCESS);
+               (timer_ == NULL) ? HSA_STATUS_ERROR : HSA_STATUS_SUCCESS);

  // Time correlation
  const uint32_t corr_iters = 1000;
@@ -161,7 +166,8 @@ HsaRsrcFactory::HsaRsrcFactory(bool initialize_hsa) : initialize_hsa_(initialize
  }

  // System timeout
-  timeout_ = (timeout_ns_ == HsaTimer::TIMESTAMP_MAX) ? timeout_ns_ : timer_->ns_to_sysclock(timeout_ns_);
+  timeout_ =
+      (timeout_ns_ == HsaTimer::TIMESTAMP_MAX) ? timeout_ns_ : timer_->ns_to_sysclock(timeout_ns_);
 }

 // Destructor of the class
@@ -187,9 +193,12 @@ void HsaRsrcFactory::InitHsaApiTable(HsaApiTable* table) {

      hsa_api_.hsa_queue_create = table->core_->hsa_queue_create_fn;
      hsa_api_.hsa_queue_destroy = table->core_->hsa_queue_destroy_fn;
-      hsa_api_.hsa_queue_load_read_index_relaxed = table->core_->hsa_queue_load_read_index_relaxed_fn;
-      hsa_api_.hsa_queue_load_write_index_relaxed = table->core_->hsa_queue_load_write_index_relaxed_fn;
-      hsa_api_.hsa_queue_add_write_index_scacq_screl = table->core_->hsa_queue_add_write_index_scacq_screl_fn;
+      hsa_api_.hsa_queue_load_read_index_relaxed =
+          table->core_->hsa_queue_load_read_index_relaxed_fn;
+      hsa_api_.hsa_queue_load_write_index_relaxed =
+          table->core_->hsa_queue_load_write_index_relaxed_fn;
+      hsa_api_.hsa_queue_add_write_index_scacq_screl =
+          table->core_->hsa_queue_add_write_index_scacq_screl_fn;

      hsa_api_.hsa_signal_create = table->core_->hsa_signal_create_fn;
      hsa_api_.hsa_signal_destroy = table->core_->hsa_signal_destroy_fn;
@@ -198,9 +207,11 @@ void HsaRsrcFactory::InitHsaApiTable(HsaApiTable* table) {
      hsa_api_.hsa_signal_wait_scacquire = table->core_->hsa_signal_wait_scacquire_fn;
      hsa_api_.hsa_signal_store_screlease = table->core_->hsa_signal_store_screlease_fn;

-      hsa_api_.hsa_code_object_reader_create_from_file = table->core_->hsa_code_object_reader_create_from_file_fn;
+      hsa_api_.hsa_code_object_reader_create_from_file =
+          table->core_->hsa_code_object_reader_create_from_file_fn;
      hsa_api_.hsa_executable_create_alt = table->core_->hsa_executable_create_alt_fn;
-      hsa_api_.hsa_executable_load_agent_code_object = table->core_->hsa_executable_load_agent_code_object_fn;
+      hsa_api_.hsa_executable_load_agent_code_object =
+          table->core_->hsa_executable_load_agent_code_object_fn;
      hsa_api_.hsa_executable_freeze = table->core_->hsa_executable_freeze_fn;
      hsa_api_.hsa_executable_destroy = table->core_->hsa_executable_destroy_fn;
      hsa_api_.hsa_executable_get_symbol = table->core_->hsa_executable_get_symbol_fn;
@@ -208,18 +219,23 @@ void HsaRsrcFactory::InitHsaApiTable(HsaApiTable* table) {
      hsa_api_.hsa_executable_iterate_symbols = table->core_->hsa_executable_iterate_symbols_fn;

      hsa_api_.hsa_system_get_info = table->core_->hsa_system_get_info_fn;
-      hsa_api_.hsa_system_get_major_extension_table = table->core_->hsa_system_get_major_extension_table_fn;
+      hsa_api_.hsa_system_get_major_extension_table =
+          table->core_->hsa_system_get_major_extension_table_fn;

-      hsa_api_.hsa_amd_agent_iterate_memory_pools = table->amd_ext_->hsa_amd_agent_iterate_memory_pools_fn;
+      hsa_api_.hsa_amd_agent_iterate_memory_pools =
+          table->amd_ext_->hsa_amd_agent_iterate_memory_pools_fn;
      hsa_api_.hsa_amd_memory_pool_get_info = table->amd_ext_->hsa_amd_memory_pool_get_info_fn;
      hsa_api_.hsa_amd_memory_pool_allocate = table->amd_ext_->hsa_amd_memory_pool_allocate_fn;
      hsa_api_.hsa_amd_agents_allow_access = table->amd_ext_->hsa_amd_agents_allow_access_fn;
      hsa_api_.hsa_amd_memory_async_copy = table->amd_ext_->hsa_amd_memory_async_copy_fn;

      hsa_api_.hsa_amd_signal_async_handler = table->amd_ext_->hsa_amd_signal_async_handler_fn;
-      hsa_api_.hsa_amd_profiling_set_profiler_enabled = table->amd_ext_->hsa_amd_profiling_set_profiler_enabled_fn;
-      hsa_api_.hsa_amd_profiling_get_async_copy_time = table->amd_ext_->hsa_amd_profiling_get_async_copy_time_fn;
-      hsa_api_.hsa_amd_profiling_get_dispatch_time = table->amd_ext_->hsa_amd_profiling_get_dispatch_time_fn;
+      hsa_api_.hsa_amd_profiling_set_profiler_enabled =
+          table->amd_ext_->hsa_amd_profiling_set_profiler_enabled_fn;
+      hsa_api_.hsa_amd_profiling_get_async_copy_time =
+          table->amd_ext_->hsa_amd_profiling_get_async_copy_time_fn;
+      hsa_api_.hsa_amd_profiling_get_dispatch_time =
+          table->amd_ext_->hsa_amd_profiling_get_dispatch_time_fn;
    } else {
      hsa_api_.hsa_init = hsa_init;
      hsa_api_.hsa_shut_down = hsa_shut_down;
@@ -315,10 +331,13 @@ const AgentInfo* HsaRsrcFactory::AddAgentInfo(const hsa_agent_t agent) {
    agent_info->dev_type = HSA_DEVICE_TYPE_CPU;
    agent_info->dev_index = cpu_list_.size();

-    status = hsa_api_.hsa_amd_agent_iterate_memory_pools(agent, FindStandardPool, &agent_info->cpu_pool);
+    status =
+        hsa_api_.hsa_amd_agent_iterate_memory_pools(agent, FindStandardPool, &agent_info->cpu_pool);
    if ((status == HSA_STATUS_INFO_BREAK) && (cpu_pool_ == NULL)) cpu_pool_ = &agent_info->cpu_pool;
-    status = hsa_api_.hsa_amd_agent_iterate_memory_pools(agent, FindKernArgPool, &agent_info->kern_arg_pool);
-    if ((status == HSA_STATUS_INFO_BREAK) && (kern_arg_pool_ == NULL)) kern_arg_pool_ = &agent_info->kern_arg_pool;
+    status = hsa_api_.hsa_amd_agent_iterate_memory_pools(agent, FindKernArgPool,
+                                                         &agent_info->kern_arg_pool);
+    if ((status == HSA_STATUS_INFO_BREAK) && (kern_arg_pool_ == NULL))
+      kern_arg_pool_ = &agent_info->kern_arg_pool;
    agent_info->gpu_pool = {};

    cpu_list_.push_back(agent_info);
@@ -330,36 +349,40 @@ const AgentInfo* HsaRsrcFactory::AddAgentInfo(const hsa_agent_t agent) {
    agent_info->dev_id = agent;
    agent_info->dev_type = HSA_DEVICE_TYPE_GPU;
    hsa_api_.hsa_agent_get_info(agent, HSA_AGENT_INFO_NAME, agent_info->name);
-    const int gfxip_label_len = std::min (strlen(agent_info->name) - 2, sizeof (agent_info->gfxip) - 1);
+    const int gfxip_label_len =
+        std::min(strlen(agent_info->name) - 2, sizeof(agent_info->gfxip) - 1);
    memcpy(agent_info->gfxip, agent_info->name, gfxip_label_len);
    agent_info->gfxip[gfxip_label_len] = '\0';
    hsa_api_.hsa_agent_get_info(agent, HSA_AGENT_INFO_WAVEFRONT_SIZE, &agent_info->max_wave_size);
    hsa_api_.hsa_agent_get_info(agent, HSA_AGENT_INFO_QUEUE_MAX_SIZE, &agent_info->max_queue_size);
    hsa_api_.hsa_agent_get_info(agent, HSA_AGENT_INFO_PROFILE, &agent_info->profile);
    agent_info->is_apu = (agent_info->profile == HSA_PROFILE_FULL) ? true : false;
-    hsa_api_.hsa_agent_get_info(agent, static_cast<hsa_agent_info_t>(HSA_AMD_AGENT_INFO_COMPUTE_UNIT_COUNT),
-                       &agent_info->cu_num);
-    hsa_api_.hsa_agent_get_info(agent, static_cast<hsa_agent_info_t>(HSA_AMD_AGENT_INFO_MAX_WAVES_PER_CU),
-                       &agent_info->waves_per_cu);
-    hsa_api_.hsa_agent_get_info(agent, static_cast<hsa_agent_info_t>(HSA_AMD_AGENT_INFO_NUM_SIMDS_PER_CU),
-                       &agent_info->simds_per_cu);
-    hsa_api_.hsa_agent_get_info(agent, static_cast<hsa_agent_info_t>(HSA_AMD_AGENT_INFO_NUM_SHADER_ENGINES),
-                       &agent_info->se_num);
+    hsa_api_.hsa_agent_get_info(
+        agent, static_cast<hsa_agent_info_t>(HSA_AMD_AGENT_INFO_COMPUTE_UNIT_COUNT),
+        &agent_info->cu_num);
    hsa_api_.hsa_agent_get_info(agent,
-                       static_cast<hsa_agent_info_t>(HSA_AMD_AGENT_INFO_NUM_SHADER_ARRAYS_PER_SE),
-                       &agent_info->shader_arrays_per_se);
+                                static_cast<hsa_agent_info_t>(HSA_AMD_AGENT_INFO_MAX_WAVES_PER_CU),
+                                &agent_info->waves_per_cu);
+    hsa_api_.hsa_agent_get_info(agent,
+                                static_cast<hsa_agent_info_t>(HSA_AMD_AGENT_INFO_NUM_SIMDS_PER_CU),
+                                &agent_info->simds_per_cu);
+    hsa_api_.hsa_agent_get_info(
+        agent, static_cast<hsa_agent_info_t>(HSA_AMD_AGENT_INFO_NUM_SHADER_ENGINES),
+        &agent_info->se_num);
+    hsa_api_.hsa_agent_get_info(
+        agent, static_cast<hsa_agent_info_t>(HSA_AMD_AGENT_INFO_NUM_SHADER_ARRAYS_PER_SE),
+        &agent_info->shader_arrays_per_se);

    agent_info->cpu_pool = {};
    agent_info->kern_arg_pool = {};
-    status = hsa_api_.hsa_amd_agent_iterate_memory_pools(agent, FindStandardPool, &agent_info->gpu_pool);
+    status =
+        hsa_api_.hsa_amd_agent_iterate_memory_pools(agent, FindStandardPool, &agent_info->gpu_pool);
    CHECK_ITER_STATUS("hsa_amd_agent_iterate_memory_pools(gpu pool)", status);

    // Set GPU index
    uint32_t driver_node_id;
    status = hsa_api_.hsa_agent_get_info(
-            agent,
-            static_cast<hsa_agent_info_t>(HSA_AMD_AGENT_INFO_DRIVER_NODE_ID),
-            &driver_node_id);
+        agent, static_cast<hsa_agent_info_t>(HSA_AMD_AGENT_INFO_DRIVER_NODE_ID), &driver_node_id);
    CHECK_STATUS("hsa_agent_get_info(gpu hsa_driver_node_id)", status);
    agent_info->dev_index = driver_node_id;
    gpu_list_.push_back(agent_info);
@@ -449,7 +472,7 @@ bool HsaRsrcFactory::CreateQueue(const AgentInfo* agent_info, uint32_t num_pkts,
                                 hsa_queue_t** queue) {
  hsa_status_t status;
  status = hsa_api_.hsa_queue_create(agent_info->dev_id, num_pkts, HSA_QUEUE_TYPE_MULTI, NULL, NULL,
-                            UINT32_MAX, UINT32_MAX, queue);
+                                     UINT32_MAX, UINT32_MAX, queue);
  return (status == HSA_STATUS_SUCCESS);
 }

@@ -472,7 +495,8 @@ uint8_t* HsaRsrcFactory::AllocateLocalMemory(const AgentInfo* agent_info, size_t
  hsa_status_t status = HSA_STATUS_ERROR;
  uint8_t* buffer = NULL;
  size = (size + MEM_PAGE_MASK) & ~MEM_PAGE_MASK;
-  status = hsa_api_.hsa_amd_memory_pool_allocate(agent_info->gpu_pool, size, 0, reinterpret_cast<void**>(&buffer));
+  status = hsa_api_.hsa_amd_memory_pool_allocate(agent_info->gpu_pool, size, 0,
+                                                 reinterpret_cast<void**>(&buffer));
  uint8_t* ptr = (status == HSA_STATUS_SUCCESS) ? buffer : NULL;
  return ptr;
 }
@@ -487,7 +511,8 @@ uint8_t* HsaRsrcFactory::AllocateKernArgMemory(const AgentInfo* agent_info, size
  uint8_t* buffer = NULL;
  if (!cpu_agents_.empty()) {
    size = (size + MEM_PAGE_MASK) & ~MEM_PAGE_MASK;
-    status = hsa_api_.hsa_amd_memory_pool_allocate(*kern_arg_pool_, size, 0, reinterpret_cast<void**>(&buffer));
+    status = hsa_api_.hsa_amd_memory_pool_allocate(*kern_arg_pool_, size, 0,
+                                                   reinterpret_cast<void**>(&buffer));
    // Both the CPU and GPU can access the kernel arguments
    if (status == HSA_STATUS_SUCCESS) {
      hsa_agent_t ag_list[1] = {agent_info->dev_id};
@@ -507,7 +532,8 @@ uint8_t* HsaRsrcFactory::AllocateSysMemory(const AgentInfo* agent_info, size_t s
  uint8_t* buffer = NULL;
  size = (size + MEM_PAGE_MASK) & ~MEM_PAGE_MASK;
  if (!cpu_agents_.empty()) {
-    status = hsa_api_.hsa_amd_memory_pool_allocate(*cpu_pool_, size, 0, reinterpret_cast<void**>(&buffer));
+    status = hsa_api_.hsa_amd_memory_pool_allocate(*cpu_pool_, size, 0,
+                                                   reinterpret_cast<void**>(&buffer));
    // Both the CPU and GPU can access the memory
    if (status == HSA_STATUS_SUCCESS) {
      hsa_agent_t ag_list[1] = {agent_info->dev_id};
@@ -532,16 +558,18 @@ uint8_t* HsaRsrcFactory::AllocateCmdMemory(const AgentInfo* agent_info, size_t s
 }

 // Wait signal
-hsa_signal_value_t HsaRsrcFactory::SignalWait(const hsa_signal_t& signal, const hsa_signal_value_t& signal_value) const {
+hsa_signal_value_t HsaRsrcFactory::SignalWait(const hsa_signal_t& signal,
+                                              const hsa_signal_value_t& signal_value) const {
  const hsa_signal_value_t exp_value = signal_value - 1;
  hsa_signal_value_t ret_value = signal_value;
  while (1) {
-    ret_value =
-      hsa_api_.hsa_signal_wait_scacquire(signal, HSA_SIGNAL_CONDITION_LT, signal_value, timeout_, HSA_WAIT_STATE_BLOCKED);
+    ret_value = hsa_api_.hsa_signal_wait_scacquire(signal, HSA_SIGNAL_CONDITION_LT, signal_value,
+                                                   timeout_, HSA_WAIT_STATE_BLOCKED);
    if (ret_value == exp_value) break;
    if (ret_value != signal_value) {
      std::cerr << "Error: HsaRsrcFactory::SignalWait: signal_value(" << signal_value
-                << "), ret_value(" << ret_value << ")" << std::endl << std::flush;
+                << "), ret_value(" << ret_value << ")" << std::endl
+                << std::flush;
      abort();
    }
  }
@@ -549,7 +577,8 @@ hsa_signal_value_t HsaRsrcFactory::SignalWait(const hsa_signal_t& signal, const
 }

 // Wait signal with signal value restore
-void HsaRsrcFactory::SignalWaitRestore(const hsa_signal_t& signal, const hsa_signal_value_t& signal_value) const {
+void HsaRsrcFactory::SignalWaitRestore(const hsa_signal_t& signal,
+                                       const hsa_signal_value_t& signal_value) const {
  SignalWait(signal, signal_value);
  hsa_api_.hsa_signal_store_relaxed(const_cast<hsa_signal_t&>(signal), signal_value);
 }
@@ -613,13 +642,13 @@ bool HsaRsrcFactory::LoadAndFinalize(const AgentInfo* agent_info, const char* br
  }

  // Create executable.
-  status = hsa_api_.hsa_executable_create_alt(HSA_PROFILE_FULL, HSA_DEFAULT_FLOAT_ROUNDING_MODE_DEFAULT,
-                                     NULL, executable);
+  status = hsa_api_.hsa_executable_create_alt(
+      HSA_PROFILE_FULL, HSA_DEFAULT_FLOAT_ROUNDING_MODE_DEFAULT, NULL, executable);
  CHECK_STATUS("Error in creating executable object", status);

  // Load code object.
-  status = hsa_api_.hsa_executable_load_agent_code_object(*executable, agent_info->dev_id, code_obj_rdr,
-                                                 NULL, NULL);
+  status = hsa_api_.hsa_executable_load_agent_code_object(*executable, agent_info->dev_id,
+                                                          code_obj_rdr, NULL, NULL);
  CHECK_STATUS("Error in loading executable object", status);

  // Freeze executable.
@@ -629,7 +658,7 @@ bool HsaRsrcFactory::LoadAndFinalize(const AgentInfo* agent_info, const char* br
  // Get symbol handle.
  hsa_executable_symbol_t kernelSymbol;
  status = hsa_api_.hsa_executable_get_symbol(*executable, NULL, kernel_name, agent_info->dev_id, 0,
-                                     &kernelSymbol);
+                                              &kernelSymbol);
  CHECK_STATUS("Error in looking up kernel symbol", status);

  close(file_handle);
@@ -668,7 +697,8 @@ void* HsaRsrcFactory::GetReadPointer(hsa_queue_t* queue) {
  const uint32_t slot_size_b = CMD_SLOT_SIZE_B;
  const uint64_t read_idx = hsa_api_.hsa_queue_load_read_index_relaxed(queue);
  const uint32_t slot_idx = (uint32_t)(read_idx % queue->size);
-  void* queue_slot = reinterpret_cast<void*>((uintptr_t)(queue->base_address) + (slot_idx * slot_size_b));
+  void* queue_slot =
+      reinterpret_cast<void*>((uintptr_t)(queue->base_address) + (slot_idx * slot_size_b));
  return queue_slot;
 }

@@ -682,7 +712,8 @@ uint64_t HsaRsrcFactory::Submit(hsa_queue_t* queue, const void* packet) {
  }

  const uint32_t slot_idx = (uint32_t)(write_idx % queue->size);
-  uint32_t* queue_slot = reinterpret_cast<uint32_t*>((uintptr_t)(queue->base_address) + (slot_idx * slot_size_b));
+  uint32_t* queue_slot =
+      reinterpret_cast<uint32_t*>((uintptr_t)(queue->base_address) + (slot_idx * slot_size_b));
  const uint32_t* slot_data = reinterpret_cast<const uint32_t*>(packet);

  // Copy buffered commands into the queue slot.
@@ -716,24 +747,29 @@ uint64_t HsaRsrcFactory::Submit(hsa_queue_t* queue, const void* packet, size_t s
  return write_idx;
 }

-hsa_status_t HsaRsrcFactory::executable_symbols_cb(hsa_executable_t exec, hsa_executable_symbol_t symbol, void *arg) {
+hsa_status_t HsaRsrcFactory::executable_symbols_cb(hsa_executable_t exec,
+                                                   hsa_executable_symbol_t symbol, void* arg) {
  hsa_symbol_kind_t value = (hsa_symbol_kind_t)0;
-  hsa_status_t status = hsa_api_.hsa_executable_symbol_get_info(symbol, HSA_EXECUTABLE_SYMBOL_INFO_TYPE, &value);
+  hsa_status_t status =
+      hsa_api_.hsa_executable_symbol_get_info(symbol, HSA_EXECUTABLE_SYMBOL_INFO_TYPE, &value);
  CHECK_STATUS("Error in getting symbol info", status);

  if (value == HSA_SYMBOL_KIND_KERNEL) {
    uint64_t addr = 0;
-    status = hsa_api_.hsa_executable_symbol_get_info(symbol, HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_OBJECT, &addr);
+    status = hsa_api_.hsa_executable_symbol_get_info(
+        symbol, HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_OBJECT, &addr);
    CHECK_STATUS("Error in getting kernel object", status);

    const int to_free = reinterpret_cast<long>(arg);
    const char* name = NULL;
    if (to_free == 0) {
      uint32_t len = 0;
-      status = hsa_api_.hsa_executable_symbol_get_info(symbol, HSA_EXECUTABLE_SYMBOL_INFO_NAME_LENGTH, &len);
+      status = hsa_api_.hsa_executable_symbol_get_info(
+          symbol, HSA_EXECUTABLE_SYMBOL_INFO_NAME_LENGTH, &len);
      CHECK_STATUS("Error in getting name len", status);
      char sym_name[len + 1];
-      status = hsa_api_.hsa_executable_symbol_get_info(symbol, HSA_EXECUTABLE_SYMBOL_INFO_NAME, sym_name);
+      status = hsa_api_.hsa_executable_symbol_get_info(symbol, HSA_EXECUTABLE_SYMBOL_INFO_NAME,
+                                                       sym_name);
      CHECK_STATUS("Error in getting kernel name", status);
      sym_name[len] = 0;
      name = cpp_demangle(sym_name);
@@ -745,10 +781,12 @@ hsa_status_t HsaRsrcFactory::executable_symbols_cb(hsa_executable_t exec, hsa_ex
  return HSA_STATUS_SUCCESS;
 }

-hsa_status_t HsaRsrcFactory::hsa_executable_freeze_interceptor(hsa_executable_t executable, const char *options) {
+hsa_status_t HsaRsrcFactory::hsa_executable_freeze_interceptor(hsa_executable_t executable,
+                                                               const char* options) {
  std::lock_guard<mutex_t> lck(mutex_);
  if (symbols_map_ == NULL) symbols_map_ = new symbols_map_t;
-  hsa_status_t status = hsa_api_.hsa_executable_iterate_symbols(executable, executable_symbols_cb, (void*)0);
+  hsa_status_t status =
+      hsa_api_.hsa_executable_iterate_symbols(executable, executable_symbols_cb, (void*)0);
  CHECK_STATUS("Error in iterating executable symbols", status);
  return hsa_api_.hsa_executable_freeze(executable, options);
 }
@@ -756,7 +794,8 @@ hsa_status_t HsaRsrcFactory::hsa_executable_freeze_interceptor(hsa_executable_t
 hsa_status_t HsaRsrcFactory::hsa_executable_destroy_interceptor(hsa_executable_t executable) {
  std::lock_guard<mutex_t> lck(mutex_);
  if (symbols_map_ != NULL) {
-    hsa_status_t status = hsa_api_.hsa_executable_iterate_symbols(executable, executable_symbols_cb, (void*)1);
+    hsa_status_t status =
+        hsa_api_.hsa_executable_iterate_symbols(executable, executable_symbols_cb, (void*)1);
    CHECK_STATUS("Error in iterating executable symbols", status);
  }
  return hsa_api_.hsa_executable_destroy(executable);
@@ -48,69 +48,71 @@ POSSIBILITY OF SUCH DAMAGE.
 #define HSA_QUEUE_ALIGN_BYTES 64
 #define HSA_PACKET_ALIGN_BYTES 64

-#define CHECK_STATUS(msg, status) do {                                                             \
-  if ((status) != HSA_STATUS_SUCCESS) {                                                            \
-    const char* emsg = 0;                                                                          \
-    hsa_status_string(status, &emsg);                                                              \
-    printf("%s: %s\n", msg, emsg ? emsg : "<unknown error>");                                      \
-    abort();                                                                                       \
-  }                                                                                                \
-} while (0)
+#define CHECK_STATUS(msg, status)                                                                  \
+  do {                                                                                             \
+    if ((status) != HSA_STATUS_SUCCESS) {                                                          \
+      const char* emsg = 0;                                                                        \
+      hsa_status_string(status, &emsg);                                                            \
+      printf("%s: %s\n", msg, emsg ? emsg : "<unknown error>");                                    \
+      abort();                                                                                     \
+    }                                                                                              \
+  } while (0)

-#define CHECK_ITER_STATUS(msg, status) do {                                                        \
-  if ((status) != HSA_STATUS_INFO_BREAK) {                                                         \
-    const char* emsg = 0;                                                                          \
-    hsa_status_string(status, &emsg);                                                              \
-    printf("%s: %s\n", msg, emsg ? emsg : "<unknown error>");                                      \
-    abort();                                                                                       \
-  }                                                                                                \
-} while (0)
+#define CHECK_ITER_STATUS(msg, status)                                                             \
+  do {                                                                                             \
+    if ((status) != HSA_STATUS_INFO_BREAK) {                                                       \
+      const char* emsg = 0;                                                                        \
+      hsa_status_string(status, &emsg);                                                            \
+      printf("%s: %s\n", msg, emsg ? emsg : "<unknown error>");                                    \
+      abort();                                                                                     \
+    }                                                                                              \
+  } while (0)

 static const size_t MEM_PAGE_BYTES = 0x1000;
 static const size_t MEM_PAGE_MASK = MEM_PAGE_BYTES - 1;
 typedef decltype(hsa_agent_t::handle) hsa_agent_handle_t;

 struct hsa_pfn_t {
-  decltype(hsa_init)* hsa_init;
-  decltype(hsa_shut_down)* hsa_shut_down;
-  decltype(hsa_agent_get_info)* hsa_agent_get_info;
-  decltype(hsa_iterate_agents)* hsa_iterate_agents;
+  decltype(::hsa_init)* hsa_init;
+  decltype(::hsa_shut_down)* hsa_shut_down;
+  decltype(::hsa_agent_get_info)* hsa_agent_get_info;
+  decltype(::hsa_iterate_agents)* hsa_iterate_agents;

-  decltype(hsa_queue_create)* hsa_queue_create;
-  decltype(hsa_queue_destroy)* hsa_queue_destroy;
-  decltype(hsa_queue_load_read_index_relaxed)* hsa_queue_load_read_index_relaxed;
-  decltype(hsa_queue_load_write_index_relaxed)* hsa_queue_load_write_index_relaxed;
-  decltype(hsa_queue_add_write_index_scacq_screl)* hsa_queue_add_write_index_scacq_screl;
+  decltype(::hsa_queue_create)* hsa_queue_create;
+  decltype(::hsa_queue_destroy)* hsa_queue_destroy;
+  decltype(::hsa_queue_load_read_index_relaxed)* hsa_queue_load_read_index_relaxed;
+  decltype(::hsa_queue_load_write_index_relaxed)* hsa_queue_load_write_index_relaxed;
+  decltype(::hsa_queue_add_write_index_scacq_screl)* hsa_queue_add_write_index_scacq_screl;

-  decltype(hsa_signal_create)* hsa_signal_create;
-  decltype(hsa_signal_destroy)* hsa_signal_destroy;
-  decltype(hsa_signal_load_relaxed)* hsa_signal_load_relaxed;
-  decltype(hsa_signal_store_relaxed)* hsa_signal_store_relaxed;
-  decltype(hsa_signal_wait_scacquire)* hsa_signal_wait_scacquire;
-  decltype(hsa_signal_store_screlease)* hsa_signal_store_screlease;
+  decltype(::hsa_signal_create)* hsa_signal_create;
+  decltype(::hsa_signal_destroy)* hsa_signal_destroy;
+  decltype(::hsa_signal_load_relaxed)* hsa_signal_load_relaxed;
+  decltype(::hsa_signal_store_relaxed)* hsa_signal_store_relaxed;
+  decltype(::hsa_signal_wait_scacquire)* hsa_signal_wait_scacquire;
+  decltype(::hsa_signal_store_screlease)* hsa_signal_store_screlease;

-  decltype(hsa_code_object_reader_create_from_file)* hsa_code_object_reader_create_from_file;
-  decltype(hsa_executable_create_alt)* hsa_executable_create_alt;
-  decltype(hsa_executable_load_agent_code_object)* hsa_executable_load_agent_code_object;
-  decltype(hsa_executable_freeze)* hsa_executable_freeze;
-  decltype(hsa_executable_destroy)* hsa_executable_destroy;
-  decltype(hsa_executable_get_symbol)* hsa_executable_get_symbol;
-  decltype(hsa_executable_symbol_get_info)* hsa_executable_symbol_get_info;
-  decltype(hsa_executable_iterate_symbols)* hsa_executable_iterate_symbols;
+  decltype(::hsa_code_object_reader_create_from_file)* hsa_code_object_reader_create_from_file;
+  decltype(::hsa_executable_create_alt)* hsa_executable_create_alt;
+  decltype(::hsa_executable_load_agent_code_object)* hsa_executable_load_agent_code_object;
+  decltype(::hsa_executable_freeze)* hsa_executable_freeze;
+  decltype(::hsa_executable_destroy)* hsa_executable_destroy;
+  decltype(::hsa_executable_get_symbol)* hsa_executable_get_symbol;
+  decltype(::hsa_executable_symbol_get_info)* hsa_executable_symbol_get_info;
+  decltype(::hsa_executable_iterate_symbols)* hsa_executable_iterate_symbols;

-  decltype(hsa_system_get_info)* hsa_system_get_info;
-  decltype(hsa_system_get_major_extension_table)* hsa_system_get_major_extension_table;
+  decltype(::hsa_system_get_info)* hsa_system_get_info;
+  decltype(::hsa_system_get_major_extension_table)* hsa_system_get_major_extension_table;

-  decltype(hsa_amd_agent_iterate_memory_pools)* hsa_amd_agent_iterate_memory_pools;
-  decltype(hsa_amd_memory_pool_get_info)* hsa_amd_memory_pool_get_info;
-  decltype(hsa_amd_memory_pool_allocate)* hsa_amd_memory_pool_allocate;
-  decltype(hsa_amd_agents_allow_access)* hsa_amd_agents_allow_access;
-  decltype(hsa_amd_memory_async_copy)* hsa_amd_memory_async_copy;
+  decltype(::hsa_amd_agent_iterate_memory_pools)* hsa_amd_agent_iterate_memory_pools;
+  decltype(::hsa_amd_memory_pool_get_info)* hsa_amd_memory_pool_get_info;
+  decltype(::hsa_amd_memory_pool_allocate)* hsa_amd_memory_pool_allocate;
+  decltype(::hsa_amd_agents_allow_access)* hsa_amd_agents_allow_access;
+  decltype(::hsa_amd_memory_async_copy)* hsa_amd_memory_async_copy;

-  decltype(hsa_amd_signal_async_handler)* hsa_amd_signal_async_handler;
-  decltype(hsa_amd_profiling_set_profiler_enabled)* hsa_amd_profiling_set_profiler_enabled;
-  decltype(hsa_amd_profiling_get_async_copy_time)* hsa_amd_profiling_get_async_copy_time;
-  decltype(hsa_amd_profiling_get_dispatch_time)* hsa_amd_profiling_get_dispatch_time;
+  decltype(::hsa_amd_signal_async_handler)* hsa_amd_signal_async_handler;
+  decltype(::hsa_amd_profiling_set_profiler_enabled)* hsa_amd_profiling_set_profiler_enabled;
+  decltype(::hsa_amd_profiling_get_async_copy_time)* hsa_amd_profiling_get_async_copy_time;
+  decltype(::hsa_amd_profiling_get_dispatch_time)* hsa_amd_profiling_get_dispatch_time;
 };

 // Encapsulates information about a Hsa Agent such as its
@@ -185,7 +187,8 @@ class HsaTimer {

  HsaTimer(const hsa_pfn_t* hsa_api) : hsa_api_(hsa_api) {
    timestamp_t sysclock_hz = 0;
-    hsa_status_t status = hsa_api_->hsa_system_get_info(HSA_SYSTEM_INFO_TIMESTAMP_FREQUENCY, &sysclock_hz);
+    hsa_status_t status =
+        hsa_api_->hsa_system_get_info(HSA_SYSTEM_INFO_TIMESTAMP_FREQUENCY, &sysclock_hz);
    CHECK_STATUS("hsa_system_get_info(HSA_SYSTEM_INFO_TIMESTAMP_FREQUENCY)", status);
    sysclock_factor_ = (freq_t)1000000000 / (freq_t)sysclock_hz;
  }
@@ -220,8 +223,8 @@ class HsaTimer {

  // Return pair of correlated values of profiling timestamp and time with
  // correlation error for a given time ID and number of iterations
-  void correlated_pair_ns(time_id_t time_id, uint32_t iters,
-                          timestamp_t* timestamp_v, timestamp_t* time_v, timestamp_t* error_v) {
+  void correlated_pair_ns(time_id_t time_id, uint32_t iters, timestamp_t* timestamp_v,
+                          timestamp_t* time_v, timestamp_t* error_v) {
    clockid_t clock_id = 0;
    switch (time_id) {
      case TIME_ID_CLOCK_REALTIME:
@@ -376,7 +379,8 @@ class HsaRsrcFactory {
  uint8_t* AllocateCmdMemory(const AgentInfo* agent_info, size_t size);

  // Wait signal
-  hsa_signal_value_t SignalWait(const hsa_signal_t& signal, const hsa_signal_value_t& signal_value) const;
+  hsa_signal_value_t SignalWait(const hsa_signal_t& signal,
+                                const hsa_signal_value_t& signal_value) const;

  // Wait signal with signal value restore
  void SignalWaitRestore(const hsa_signal_t& signal, const hsa_signal_value_t& signal_value) const;
@@ -444,7 +448,7 @@ class HsaRsrcFactory {
    }

    std::atomic<uint64_t>* atomic_ptr =
-      reinterpret_cast<std::atomic<uint64_t>*>(&(it->second.refs_count));
+        reinterpret_cast<std::atomic<uint64_t>*>(&(it->second.refs_count));
    atomic_ptr->fetch_add(1, std::memory_order_relaxed);

    return it;
@@ -452,7 +456,7 @@ class HsaRsrcFactory {

  static inline void ReleaseKernelNameRef(const symbols_map_it_t& it) {
    std::atomic<uint64_t>* atomic_ptr =
-      reinterpret_cast<std::atomic<uint64_t>*>(&(it->second.refs_count));
+        reinterpret_cast<std::atomic<uint64_t>*>(&(it->second.refs_count));
    atomic_ptr->fetch_sub(1, std::memory_order_relaxed);
  }

@@ -465,7 +469,7 @@ class HsaRsrcFactory {
    auto it = symbols_map_->find(addr);
    if (it != symbols_map_->end()) {
      while (1) {
-        while(it->second.refs_count != 0) sched_yield();
+        while (it->second.refs_count != 0) sched_yield();
        mutex_.lock();
        if (it->second.refs_count == 0) break;
        mutex_.unlock();
@@ -477,14 +481,16 @@ class HsaRsrcFactory {
      if (free == 1) {
        symbols_map_->erase(it);
      } else {
-        fprintf(stderr, "HsaRsrcFactory::SetKernelNameRef: to set kernel addr (0x%lx) conflict\n", addr);
+        fprintf(stderr, "HsaRsrcFactory::SetKernelNameRef: to set kernel addr (0x%lx) conflict\n",
+                addr);
        abort();
      }
    } else {
      if (free == 0) {
        symbols_map_->insert({addr, symbols_map_data_t{name, 0}});
      } else {
-        fprintf(stderr, "HsaRsrcFactory::SetKernelNameRef: to free kernel addr (0x%lx) not found\n", addr);
+        fprintf(stderr, "HsaRsrcFactory::SetKernelNameRef: to free kernel addr (0x%lx) not found\n",
+                addr);
        abort();
      }
    }
@@ -504,7 +510,9 @@ class HsaRsrcFactory {
  const hsa_ven_amd_loader_1_00_pfn_t* LoaderApi() const { return &loader_api_; }

  // Methods for system-clock/ns conversion and timestamp in 'ns'
-  timestamp_t SysclockToNs(const timestamp_t& sysclock) const { return timer_->sysclock_to_ns(sysclock); }
+  timestamp_t SysclockToNs(const timestamp_t& sysclock) const {
+    return timer_->sysclock_to_ns(sysclock);
+  }
  timestamp_t NsToSysclock(const timestamp_t& time) const { return timer_->ns_to_sysclock(time); }
  timestamp_t TimestampNs() const { return timer_->timestamp_ns(); }

@@ -578,9 +586,11 @@ class HsaRsrcFactory {

  static symbols_map_t* symbols_map_;
  static bool executable_tracking_on_;
-  static hsa_status_t hsa_executable_freeze_interceptor(hsa_executable_t executable, const char *options);
+  static hsa_status_t hsa_executable_freeze_interceptor(hsa_executable_t executable,
+                                                        const char* options);
  static hsa_status_t hsa_executable_destroy_interceptor(hsa_executable_t executable);
-  static hsa_status_t executable_symbols_cb(hsa_executable_t exec, hsa_executable_symbol_t symbol, void *data);
+  static hsa_status_t executable_symbols_cb(hsa_executable_t exec, hsa_executable_symbol_t symbol,
+                                            void* data);

  // HSA runtime API table
  static hsa_pfn_t hsa_api_;
@@ -604,8 +614,8 @@ class HsaRsrcFactory {
  timestamp_t time_error_[HsaTimer::TIME_ID_NUMBER];

  // CPU/kern-arg memory pools
-  hsa_amd_memory_pool_t *cpu_pool_;
-  hsa_amd_memory_pool_t *kern_arg_pool_;
+  hsa_amd_memory_pool_t* cpu_pool_;
+  hsa_amd_memory_pool_t* kern_arg_pool_;
 };


@@ -214,7 +214,8 @@ class Xml {
      buf[size - 1] = '\0';

      if (strncmp(buf, "#include \"", 10) == 0) {
-        for (ind = 0; (ind < size) && (buf[ind] != '\n'); ++ind) {}
+        for (ind = 0; (ind < size) && (buf[ind] != '\n'); ++ind) {
+        }
        if (ind == size) {
          fprintf(stderr, "XML PreProcess failed, line size limit %zu\n", kBufSize);
          error = true;
@@ -224,7 +225,8 @@ class Xml {
        size = ind;
        lseek(fd_, pos + ind + 1, SEEK_SET);

-        for (ind = 10; (ind < size) && (buf[ind] != '"'); ++ind) {}
+        for (ind = 10; (ind < size) && (buf[ind] != '"'); ++ind) {
+        }
        if (ind == size) {
          error = true;
          break;