vedithal-amd
aa5dfb98f9
* Fix rocprofiler-sdk metrics definition
* Use TCC_EA0_RDREQ_128B instead of TCC_BUBBLE counter for L2 cache to
HBM counters and metrics
* Update MI350 counter definitions
* FETCH_SIZE
* BANDWIDTH_EA
* Update MI350 metrics definitions
* System Speed of Light, L2-Fabric Read BW
* Roofline Plot Points, AI (Arithmetic Intensity) HBM
* Roofline Performance Rates, HBM Bandwidth
* Remove redundant definition for gfx950 and fix BANDWIDTH_EA definition
Test HBM bandwidth metric for memcopy workload
* Add memcopy.cpp workload
* Add metric validation test suite to validate HBM Bandwidth metric for
memcopy workload
* Move gpu_soc() to test_utils.py for better re-usability
* Update TUI analysis config
* Fix hbm bandwidth formula for mi350 in calc_ai_profile
Co-authored-by: Alysa Liu <Alysa.Liu@amd.com>
888 baris
28 KiB
CMake
888 baris
28 KiB
CMake
cmake_minimum_required(VERSION 3.21 FATAL_ERROR)
|
|
|
|
# Set cmake_prefix_path for searching, ROCM_PATH if avail otherwise default to general rocm install path
|
|
set(CMAKE_PREFIX_PATH $ENV{ROCM_PATH} "/opt/rocm/")
|
|
message(STATUS "ROCM_PATH: $ENV{ROCM_PATH}")
|
|
|
|
if(
|
|
CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR
|
|
AND CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR
|
|
)
|
|
set(MSG "")
|
|
message(STATUS "Warning! Building from the source directory is not recommended")
|
|
message(STATUS "If unintended, please remove 'CMakeCache.txt' and 'CMakeFiles'")
|
|
message(STATUS "and build from a separate directory")
|
|
message(FATAL_ERROR "In-source build")
|
|
endif()
|
|
|
|
# System info
|
|
cmake_host_system_information(RESULT LOCALHOST QUERY FQDN)
|
|
message(STATUS "Hostname: ${LOCALHOST}")
|
|
|
|
# Versioning info derived from file
|
|
file(READ "${CMAKE_CURRENT_SOURCE_DIR}/VERSION" FULL_VERSION_STRING LIMIT_COUNT 1)
|
|
string(REGEX REPLACE "(\n|\r)" "" FULL_VERSION_STRING "${FULL_VERSION_STRING}")
|
|
set(ROCPROFCOMPUTE_FULL_VERSION "${FULL_VERSION_STRING}")
|
|
string(
|
|
REGEX REPLACE
|
|
"([0-9]+)\.([0-9]+)\.([0-9]+)(.*)"
|
|
"\\1.\\2.\\3"
|
|
ROCPROFCOMPUTE_VERSION
|
|
"${FULL_VERSION_STRING}"
|
|
)
|
|
|
|
# string(REGEX REPLACE "(${ROCPROFCOMPUTE_VERSION})(.*)" "\\2"
|
|
# ROCPROFCOMPUTE_VERSION_TWEAK
|
|
# "${FULL_VERSION_STRING}")
|
|
# string(REGEX REPLACE "^\\." "" ROCPROFCOMPUTE_VERSION_TWEAK
|
|
# "${ROCPROFCOMPUTE_VERSION_TWEAK}")
|
|
|
|
project(
|
|
rocprofiler-compute
|
|
VERSION ${ROCPROFCOMPUTE_VERSION}
|
|
LANGUAGES CXX
|
|
DESCRIPTION
|
|
"A kernel-level profiling tool for machine learning/HPC workloads running on AMD MI GPUs"
|
|
HOMEPAGE_URL
|
|
"https://github.com/ROCm/rocm-systems/tree/develop/projects/rocprofiler-compute"
|
|
)
|
|
|
|
set(PACKAGE_NAME "rocprofiler-compute")
|
|
set(PACKAGE_NAME_UNDERSCORE "rocprofiler_compute")
|
|
set(EXECUTABLE_NAME "rocprof-compute")
|
|
|
|
include(ExternalProject)
|
|
include(GNUInstallDirs)
|
|
include(utils.cmake)
|
|
|
|
set(BUILD_ENABLE_LINTIAN_OVERRIDES ON CACHE BOOL "Enable/Disable Lintian Overrides")
|
|
set(BUILD_DEBIAN_PKGING_FLAG
|
|
ON
|
|
CACHE BOOL
|
|
"Internal Status Flag to indicate Debian Packaging Build"
|
|
)
|
|
set(COMP_TYPE "main")
|
|
|
|
# version control info
|
|
execute_process(
|
|
COMMAND git log --pretty=format:%h -n 1
|
|
OUTPUT_VARIABLE ROCPROFCOMPUTE_GIT_REV
|
|
OUTPUT_STRIP_TRAILING_WHITESPACE
|
|
)
|
|
message(STATUS "Git revision: ${ROCPROFCOMPUTE_GIT_REV}")
|
|
configure_file(
|
|
${PROJECT_SOURCE_DIR}/cmake/VERSION.sha.in
|
|
${PROJECT_SOURCE_DIR}/VERSION.sha
|
|
@ONLY
|
|
)
|
|
|
|
set(CMAKE_BUILD_TYPE "Release")
|
|
if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
|
|
set(CMAKE_INSTALL_PREFIX "/opt/rocm" CACHE PATH "default install path" FORCE)
|
|
endif()
|
|
message(STATUS "Installation path: ${CMAKE_INSTALL_PREFIX}")
|
|
|
|
option(CHECK_PYTHON_DEPS "Verify necessary python dependencies" ON)
|
|
if(CHECK_PYTHON_DEPS)
|
|
# Python 3 is required
|
|
message(STATUS "Detecting Python interpreter...")
|
|
find_package(Python3 3.9 COMPONENTS Interpreter REQUIRED)
|
|
|
|
# Allow user-provided python search path
|
|
if(DEFINED PYTHON_DEPS)
|
|
set(ENV{PYTHONPATH} "${PYTHON_DEPS}")
|
|
message(STATUS "Optional PYTHON_DEPS provided:")
|
|
list(APPEND CMAKE_MESSAGE_INDENT " ")
|
|
message(STATUS "including ${PYTHON_DEPS} in search path")
|
|
list(POP_BACK CMAKE_MESSAGE_INDENT)
|
|
endif()
|
|
|
|
# Check required Python packages
|
|
file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/requirements.txt" pythonDeps)
|
|
|
|
message(STATUS "Checking for required Python package dependencies...")
|
|
set_property(GLOBAL PROPERTY pythonDepsFlag "groovy")
|
|
|
|
function(checkPythonPackage [package])
|
|
# mapping for non-default package names
|
|
set(PACKAGE ${ARGV0})
|
|
if(${ARGV0} STREQUAL "pyyaml")
|
|
set(PACKAGE "yaml")
|
|
endif()
|
|
execute_process(
|
|
COMMAND ${Python3_EXECUTABLE} -c "import ${PACKAGE}"
|
|
OUTPUT_QUIET
|
|
ERROR_QUIET
|
|
RESULT_VARIABLE EXIT_CODE
|
|
)
|
|
if(${EXIT_CODE} EQUAL 0)
|
|
message(STATUS "${ARGV0} = yes")
|
|
else()
|
|
message(STATUS "${ARGV0} = missing")
|
|
set_property(GLOBAL PROPERTY pythonDepsFlag "missing")
|
|
endif()
|
|
endfunction()
|
|
|
|
list(APPEND CMAKE_MESSAGE_INDENT " ")
|
|
foreach(package IN LISTS pythonDeps)
|
|
# Filter out any version requirements from requirements.txt
|
|
string(REGEX REPLACE "[><=].*" "" package "${package}")
|
|
string(REPLACE "-" "_" package "${package}")
|
|
checkpythonpackage(${package})
|
|
endforeach()
|
|
list(POP_BACK CMAKE_MESSAGE_INDENT)
|
|
|
|
get_property(pythonDepsInstalled GLOBAL PROPERTY pythonDepsFlag)
|
|
if(${pythonDepsInstalled} STREQUAL "groovy")
|
|
message(STATUS "OK: Python dependencies available in current environment.")
|
|
else()
|
|
message(
|
|
FATAL_ERROR
|
|
"\nNecessary Python package dependencies not found. Please install required dependencies "
|
|
"above using your favorite package manager. If using pip, consider running:\n"
|
|
"python3 -m pip install -r requirements.txt\n"
|
|
"at the top-level of this repository. If preparing a shared installation for "
|
|
"multiple users, consider adding the -t <target-dir> option to install necessary dependencies "
|
|
"into a shared directory, e.g.\n"
|
|
"python3 -m pip install -t <shared-install-path> -r requirements.txt\n"
|
|
"Note that the -DPYTHON_DEPS=<shared-install-path> can be used to provide an "
|
|
"additional search path to cmake for python packages."
|
|
)
|
|
endif()
|
|
endif()
|
|
|
|
# ----------------------
|
|
# Portable Python command for tests
|
|
# ----------------------
|
|
# For build-time checks, use ${Python3_EXECUTABLE} (absolute path from find_package)
|
|
# For runtime tests (add_test), use portable command that resolves from PATH
|
|
# This allows tests to work when build/install folders are moved to different machines
|
|
set(PYTHON_TEST_COMMAND
|
|
"python3"
|
|
CACHE STRING
|
|
"Python command for running tests (portable)"
|
|
)
|
|
message(STATUS "Python test command: ${PYTHON_TEST_COMMAND}")
|
|
|
|
# ----------------------
|
|
# modulefile creation
|
|
# ----------------------
|
|
|
|
set(MOD_INSTALL_PATH
|
|
"${CMAKE_INSTALL_DATADIR}/${PROJECT_NAME}/modulefiles/${PROJECT_NAME}"
|
|
CACHE STRING
|
|
"Install path for modulefile"
|
|
)
|
|
message(STATUS "Modulefile install path: ${MOD_INSTALL_PATH}")
|
|
|
|
set(moduleFileTemplate "rocprofcompute.lua.in")
|
|
|
|
configure_file(
|
|
${PROJECT_SOURCE_DIR}/cmake/${moduleFileTemplate}
|
|
${PROJECT_BINARY_DIR}/${MOD_INSTALL_PATH}/${ROCPROFCOMPUTE_FULL_VERSION}.lua
|
|
@ONLY
|
|
)
|
|
|
|
# Thera mods
|
|
if(LOCALHOST MATCHES "TheraS01|.*\.thera\.amd\.com|thera-hn")
|
|
list(APPEND CMAKE_MESSAGE_INDENT " ")
|
|
message(STATUS "Using thera-specific modulefile modification")
|
|
file(READ ${PROJECT_SOURCE_DIR}/cmake/modfile.thera.mod mod_additions)
|
|
file(
|
|
APPEND
|
|
${PROJECT_BINARY_DIR}/${MOD_INSTALL_PATH}/${ROCPROFCOMPUTE_FULL_VERSION}.lua
|
|
${mod_additions}
|
|
)
|
|
list(POP_BACK CMAKE_MESSAGE_INDENT)
|
|
endif()
|
|
|
|
# Setup testing collateral
|
|
|
|
option(ENABLE_TESTS "Enable compilation of testing collateral" OFF)
|
|
set(CMAKE_HIP_FLAGS_RELEASE "-O2")
|
|
if(${ENABLE_TESTS})
|
|
enable_language("C" "HIP")
|
|
add_subdirectory(tests)
|
|
endif()
|
|
message(STATUS "Enable tests compilation: ${ENABLE_TESTS}")
|
|
|
|
enable_testing()
|
|
include(CTest)
|
|
|
|
option(ENABLE_COVERAGE "Enable code coverage" OFF)
|
|
set(COV_OPTION "")
|
|
if(${ENABLE_COVERAGE})
|
|
set(COV_OPTION
|
|
"--cov=src"
|
|
"--cov-append"
|
|
"--cov-report=term-missing"
|
|
"--cov-report=lcov:tests/coverage.info"
|
|
)
|
|
|
|
set(CTEST_COVERAGE_COMMAND "python3")
|
|
set(CTEST_COVERAGE_EXTRA_FLAGS
|
|
"-m"
|
|
"coverage"
|
|
"xml"
|
|
"-o"
|
|
"${CMAKE_BINARY_DIR}/coverage.xml"
|
|
)
|
|
endif()
|
|
message(STATUS "Code coverage: ${ENABLE_COVERAGE}")
|
|
|
|
# CPU threads available for testing
|
|
set(PYTEST_NUMPROCS
|
|
"1"
|
|
CACHE STRING
|
|
"Number of parallel threads to use with CPU-oriented tests"
|
|
)
|
|
message(STATUS "Pytest CPU threadcount: ${PYTEST_NUMPROCS}")
|
|
|
|
# 2 CPU threads available for testing(test-analyze-commands)
|
|
set(PYTEST_NUMPROCS_ANALYSIS
|
|
"4"
|
|
CACHE STRING
|
|
"Number of parallel threads to use with CPU-oriented tests"
|
|
)
|
|
message(STATUS "Pytest CPU threadcount: ${PYTEST_NUMPROCS_ANALYSIS}")
|
|
|
|
# ---------------------------
|
|
# add tests
|
|
# ---------------------------
|
|
|
|
option(
|
|
TEST_FROM_INSTALL
|
|
"Test from install directory rather than from source directory"
|
|
OFF
|
|
)
|
|
if(TEST_FROM_INSTALL)
|
|
set(WORKING_DIR_OPTION "")
|
|
else()
|
|
set(WORKING_DIR_OPTION WORKING_DIRECTORY ${PROJECT_SOURCE_DIR})
|
|
endif()
|
|
|
|
# ---------------------------
|
|
# profile mode tests
|
|
# ---------------------------
|
|
|
|
add_test(
|
|
NAME test_profile_kernel_execution
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -m kernel_execution
|
|
--junitxml=tests/test_profile_kernel_execution.xml ${COV_OPTION}
|
|
tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_profile_dispatch
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -m dispatch
|
|
--junitxml=tests/test_profile_dispatch.xml ${COV_OPTION}
|
|
tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_profile_mem
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -m mem --junitxml=tests/test_profile_mem.xml
|
|
${COV_OPTION} tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_profile_join
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -m join --junitxml=tests/test_profile_join.xml
|
|
${COV_OPTION} tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_profile_sort
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -m sort --junitxml=tests/test_profile_sort.xml
|
|
${COV_OPTION} tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_profile_misc
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -m misc --junitxml=tests/test_profile_misc.xml
|
|
${COV_OPTION} tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_profile_path
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -m path --junitxml=tests/test_profile_path.xml
|
|
${COV_OPTION} tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_profile_roofline_1
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -m roofline_1
|
|
--junitxml=tests/test_profile_roofline_1.xml ${COV_OPTION}
|
|
tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_profile_roofline_2
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -m roofline_2
|
|
--junitxml=tests/test_profile_roofline_2.xml ${COV_OPTION}
|
|
tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_profile_section
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -m section
|
|
--junitxml=tests/test_profile_section.xml ${COV_OPTION}
|
|
tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_profile_pc_sampling
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -s -m pc_sampling
|
|
--junitxml=tests/test_profile_pc_sampling.xml ${COV_OPTION}
|
|
tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_profile_sets_func
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -m sets_func
|
|
--junitxml=tests/test_profile_sets_func.xml ${COV_OPTION}
|
|
tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_profile_live_attach_detach
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -s -m live_attach_detach
|
|
--junitxml=tests/test_profile_live_attach_detach.xml ${COV_OPTION}
|
|
tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_profile_iteration_multiplexing_1
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -s -m iteration_multiplexing_1
|
|
--junitxml=tests/test_profile_iteration_multiplexing_1.xml ${COV_OPTION}
|
|
tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_profile_iteration_multiplexing_2
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -s -m iteration_multiplexing_2
|
|
--junitxml=tests/test_profile_iteration_multiplexing_2.xml ${COV_OPTION}
|
|
tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_profile_iteration_multiplexing_stochastic
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -s -m iteration_multiplexing_stochastic
|
|
--junitxml=tests/test_profile_iteration_multiplexing_stochastic.xml ${COV_OPTION}
|
|
tests/test_profile_general.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_metric_validation
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest --junitxml=tests/test_metric_validation.xml
|
|
${COV_OPTION} tests/test_metric_validation.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
set_tests_properties(
|
|
test_profile_kernel_execution
|
|
test_profile_dispatch
|
|
test_profile_mem
|
|
test_profile_join
|
|
test_profile_sort
|
|
test_profile_misc
|
|
test_profile_path
|
|
test_profile_roofline_1
|
|
test_profile_roofline_2
|
|
test_profile_section
|
|
test_profile_pc_sampling
|
|
test_profile_sets_func
|
|
test_profile_live_attach_detach
|
|
test_profile_iteration_multiplexing_1
|
|
test_profile_iteration_multiplexing_2
|
|
test_profile_iteration_multiplexing_stochastic
|
|
PROPERTIES LABELS "profile" RESOURCE_GROUPS gpus:1 TIMEOUT 1800
|
|
)
|
|
|
|
# ---------------------------
|
|
# analysis command tests
|
|
# ---------------------------
|
|
|
|
add_test(
|
|
NAME test_analyze_commands
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -n ${PYTEST_NUMPROCS_ANALYSIS} --verbose
|
|
--junitxml=tests/test_analyze_commands.xml ${COV_OPTION}
|
|
tests/test_analyze_commands.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
# ---------------------------
|
|
# analyze workloads tests
|
|
# ---------------------------
|
|
|
|
add_test(
|
|
NAME test_analyze_workloads
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -n ${PYTEST_NUMPROCS}
|
|
--junitxml=tests/test_analyze_workloads.xml ${COV_OPTION}
|
|
tests/test_analyze_workloads.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
# ---------------------------
|
|
# TCP counter tests
|
|
# ---------------------------
|
|
|
|
add_test(
|
|
NAME test_L1_cache_counters
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -m L1_cache
|
|
--junitxml=tests/test_L1_cache_counters.xml ${COV_OPTION}
|
|
tests/test_TCP_counters.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
# ---------------------------
|
|
# Spec tests
|
|
# ---------------------------
|
|
|
|
add_test(
|
|
NAME test_num_xcds_spec_class
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -m num_xcds_spec_class
|
|
--junitxml=tests/test_num_xcds_spec_class.xml ${COV_OPTION}
|
|
tests/test_gpu_specs.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
add_test(
|
|
NAME test_num_xcds_cli_output
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest -m num_xcds_cli_output
|
|
--junitxml=tests/test_num_xcds_cli_output.xml ${COV_OPTION}
|
|
tests/test_gpu_specs.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
# ---------------------------
|
|
# Utils tests
|
|
# ---------------------------
|
|
|
|
add_test(
|
|
NAME test_utils
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest --junitxml=tests/test_utils.xml ${COV_OPTION}
|
|
tests/test_utils.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
# -----------------------------------
|
|
# Autogenerated configuration tests
|
|
# -----------------------------------
|
|
|
|
add_test(
|
|
NAME test_autogen_config
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m pytest --junitxml=tests/test_autogen_config.xml
|
|
${COV_OPTION} tests/test_autogen_config.py ${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
# -----------------------------------
|
|
# Generate coverage tests
|
|
# -----------------------------------
|
|
|
|
if(${ENABLE_COVERAGE})
|
|
set(ALL_TEST_NAMES
|
|
test_profile_kernel_execution
|
|
test_profile_dispatch
|
|
test_profile_mem
|
|
test_profile_join
|
|
test_profile_sort
|
|
test_profile_misc
|
|
test_profile_path
|
|
test_profile_roofline_1
|
|
test_profile_roofline_2
|
|
test_profile_section
|
|
test_profile_sets_func
|
|
test_analyze_commands
|
|
test_analyze_workloads
|
|
test_L1_cache_counters
|
|
test_num_xcds_spec_class
|
|
test_num_xcds_cli_output
|
|
test_utils
|
|
test_autogen_config
|
|
)
|
|
|
|
string(REPLACE ";" ";" ALL_TESTS_STRING "${ALL_TEST_NAMES}")
|
|
|
|
add_test(
|
|
NAME generate_coverage_report
|
|
COMMAND
|
|
${PYTHON_TEST_COMMAND} -m coverage xml -o ${CMAKE_BINARY_DIR}/coverage.xml
|
|
${WORKING_DIR_OPTION}
|
|
)
|
|
|
|
set_tests_properties(
|
|
generate_coverage_report
|
|
PROPERTIES
|
|
DEPENDS "${ALL_TESTS_STRING}"
|
|
LABELS "coverage"
|
|
ENVIRONMENT "COVERAGE_FILE=${PROJECT_SOURCE_DIR}/.coverage"
|
|
TIMEOUT 600
|
|
)
|
|
endif()
|
|
|
|
# -------------------
|
|
# Setup tool library
|
|
# -------------------
|
|
add_subdirectory(src/lib)
|
|
|
|
# ---------
|
|
# Install
|
|
# ---------
|
|
|
|
# top-level rocprofiler-compute utility
|
|
install(
|
|
PROGRAMS src/${EXECUTABLE_NAME}
|
|
DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}
|
|
COMPONENT main
|
|
)
|
|
# python dependency requirements
|
|
install(
|
|
FILES requirements.txt
|
|
DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}
|
|
COMPONENT main
|
|
)
|
|
# support files and version info
|
|
install(
|
|
FILES
|
|
src/argparser.py
|
|
src/config.py
|
|
src/rocprof_compute_base.py
|
|
src/roofline.py
|
|
VERSION VERSION.sha
|
|
DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}
|
|
COMPONENT main
|
|
)
|
|
# src/hip (local hip python wrapper)
|
|
install(
|
|
DIRECTORY src/hip
|
|
DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}
|
|
COMPONENT main
|
|
PATTERN "__pycache__" EXCLUDE
|
|
)
|
|
# src/rocprof_compute_analyze
|
|
install(
|
|
DIRECTORY src/rocprof_compute_analyze
|
|
DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}
|
|
COMPONENT main
|
|
PATTERN src/rocprof_compute_analyze/tests EXCLUDE
|
|
PATTERN "__pycache__" EXCLUDE
|
|
)
|
|
# src/utils
|
|
install(
|
|
DIRECTORY src/utils
|
|
DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}
|
|
COMPONENT main
|
|
PATTERN "rooflines*" EXCLUDE
|
|
PATTERN "__pycache__" EXCLUDE
|
|
)
|
|
# src/utils/rooflines
|
|
file(GLOB rooflinebins src/utils/rooflines/roofline-*)
|
|
install(PROGRAMS ${rooflinebins} DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT main)
|
|
# src/rocprof_compute_soc
|
|
install(
|
|
DIRECTORY src/rocprof_compute_soc
|
|
DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}
|
|
COMPONENT main
|
|
PATTERN "__pycache__" EXCLUDE
|
|
)
|
|
# src/rocprof_compute_profile
|
|
install(
|
|
DIRECTORY src/rocprof_compute_profile
|
|
DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}
|
|
COMPONENT main
|
|
PATTERN "__pycache__" EXCLUDE
|
|
)
|
|
# src/rocprof_compute_tui
|
|
install(
|
|
DIRECTORY src/rocprof_compute_tui
|
|
DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}
|
|
COMPONENT main
|
|
PATTERN "__pycache__" EXCLUDE
|
|
)
|
|
# tools/config_management
|
|
install(
|
|
DIRECTORY tools/config_management
|
|
DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}
|
|
COMPONENT main
|
|
PATTERN "__pycache__" EXCLUDE
|
|
)
|
|
# samples
|
|
install(
|
|
DIRECTORY sample
|
|
DESTINATION ${CMAKE_INSTALL_DATADIR}/${PROJECT_NAME}
|
|
COMPONENT main
|
|
FILES_MATCHING
|
|
PATTERN "*.hip"
|
|
PATTERN "*.h"
|
|
PATTERN "*.cpp"
|
|
PATTERN "workloads" EXCLUDE
|
|
)
|
|
# modulefile
|
|
install(
|
|
FILES ${PROJECT_BINARY_DIR}/${MOD_INSTALL_PATH}/${ROCPROFCOMPUTE_FULL_VERSION}.lua
|
|
DESTINATION ${MOD_INSTALL_PATH}
|
|
COMPONENT main
|
|
)
|
|
|
|
# install librocprofiler-compute-tool.so
|
|
install(
|
|
TARGETS rocprofiler-compute-tool
|
|
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/rocprofiler-compute COMPONENT main
|
|
)
|
|
|
|
# top-level symlink for bin/rocprof-compute
|
|
install(
|
|
CODE
|
|
"execute_process(
|
|
COMMAND bash -c \"set -e
|
|
cd \$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}
|
|
mkdir -p ${CMAKE_INSTALL_BINDIR}
|
|
ln -sf ../${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}/${EXECUTABLE_NAME} ${CMAKE_INSTALL_BINDIR}/${EXECUTABLE_NAME}
|
|
\")"
|
|
COMPONENT main
|
|
)
|
|
|
|
# License header update(s)
|
|
add_custom_target(
|
|
license
|
|
COMMAND
|
|
${PROJECT_SOURCE_DIR}/tools/update_license.py --source ${PROJECT_SOURCE_DIR}/src
|
|
--license ${PROJECT_SOURCE_DIR}/LICENSE.md --extension '.py'
|
|
COMMAND
|
|
${PROJECT_SOURCE_DIR}/tools/update_license.py --source ${PROJECT_SOURCE_DIR}
|
|
--license ${PROJECT_SOURCE_DIR}/LICENSE.md --file
|
|
"src/${PACKAGE_NAME},cmake/Dockerfile,cmake/rocm_install.sh,docker/docker-entrypoint.sh,src/rocprof_compute_analyze/convertor/mongodb/convert"
|
|
)
|
|
|
|
set(STANDALONEBINARY_EXTRACT_DIR
|
|
"/tmp"
|
|
CACHE PATH
|
|
"Absolute path to where the standalone binary will extract its contents"
|
|
)
|
|
|
|
# Standalone binary creation
|
|
add_custom_target(
|
|
standalonebinary
|
|
# Change working directory to src
|
|
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
|
|
# Install nuitka
|
|
COMMAND ${Python3_EXECUTABLE} -m pip install nuitka==2.6
|
|
# Install patchelf
|
|
COMMAND ${Python3_EXECUTABLE} -m pip install patchelf
|
|
# Check nuitka
|
|
COMMAND ${Python3_EXECUTABLE} -m pip list | grep -i nuitka > /dev/null 2>&1
|
|
# Check patchelf
|
|
COMMAND ${Python3_EXECUTABLE} -m pip list | grep -i patchelf > /dev/null 2>&1
|
|
# Create VERSION.sha file
|
|
COMMAND git rev-parse HEAD > VERSION.sha
|
|
# Build standalone binary
|
|
# NOTE: --no-deployment-flag=self-execution is used to avoid self-execution
|
|
# and fork bombs as explained in
|
|
# https://nuitka.net/user-documentation/common-issue-solutions.html#fork-bombs-self-execution
|
|
COMMAND
|
|
${Python3_EXECUTABLE} -m nuitka --mode=onefile --no-deployment-flag=self-execution
|
|
--product-name=${STANDALONEBINARY_EXTRACT_DIR}
|
|
--onefile-tempdir-spec=/{PRODUCT}/rocprof_compute_standalonebinary_{PID}
|
|
--include-data-files=${PROJECT_SOURCE_DIR}/VERSION*=./ --enable-plugin=no-qt
|
|
--include-data-files=src/lib/rocprofiler_compute_tool.cpp=lib/rocprofiler_compute_tool.cpp
|
|
--include-data-files=src/lib/helper.cpp=lib/helper.cpp
|
|
--include-data-files=src/lib/helper.hpp=lib/helper.hpp --include-package=dash_svg
|
|
--include-package-data=dash_svg --include-package=dash_bootstrap_components
|
|
--include-package-data=dash_bootstrap_components --include-package=plotly
|
|
--include-package-data=plotly --include-package=rocprof_compute_analyze
|
|
--include-package-data=rocprof_compute_analyze
|
|
--include-package=rocprof_compute_profile
|
|
--include-package-data=rocprof_compute_profile
|
|
--include-package=rocprof_compute_tui --include-package-data=rocprof_compute_tui
|
|
--include-package=rocprof_compute_soc --include-package-data=rocprof_compute_soc
|
|
--include-package=utils --include-package-data=utils --include-package=hip
|
|
--include-package-data=hip src/rocprof-compute
|
|
# Remove library rpath from executable
|
|
COMMAND patchelf --remove-rpath rocprof-compute.bin
|
|
# Move to build directory
|
|
COMMAND mv rocprof-compute.bin ${CMAKE_BINARY_DIR}
|
|
)
|
|
|
|
install(
|
|
FILES ${PROJECT_SOURCE_DIR}/LICENSE.md
|
|
DESTINATION ${CMAKE_INSTALL_DOCDIR}
|
|
COMPONENT main
|
|
)
|
|
|
|
# TEST collateral
|
|
option(INSTALL_TESTS "Build test suite" OFF)
|
|
if(INSTALL_TESTS)
|
|
install(
|
|
DIRECTORY tests
|
|
DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}
|
|
COMPONENT tests
|
|
FILES_MATCHING
|
|
PATTERN "*.py"
|
|
PATTERN "__pycache__" EXCLUDE
|
|
)
|
|
install(
|
|
DIRECTORY tests/workloads
|
|
DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}/tests
|
|
COMPONENT tests
|
|
PATTERN "__pycache__" EXCLUDE
|
|
)
|
|
install(
|
|
PROGRAMS
|
|
tests/vcopy
|
|
tests/vmem
|
|
tests/vrandom_access
|
|
tests/vsequential_access
|
|
tests/occupancy
|
|
tests/hip_dynamic_shared
|
|
tests/laplace_eqn
|
|
tests/mat_mul_max
|
|
tests/rocflop
|
|
tests/memcopy
|
|
DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}/tests
|
|
COMPONENT tests
|
|
)
|
|
install(
|
|
FILES requirements-test.txt
|
|
DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}
|
|
COMPONENT tests
|
|
)
|
|
install(
|
|
FILES ${CMAKE_CURRENT_BINARY_DIR}/CTestTestfile.cmake
|
|
COMPONENT tests
|
|
DESTINATION ${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME}
|
|
)
|
|
endif()
|
|
message(STATUS "Install tests: ${INSTALL_TESTS}")
|
|
|
|
# ----------
|
|
# Packaging
|
|
# ----------
|
|
|
|
set(PKG_MAINTAINER_NM "rocprofiler compute support")
|
|
set(PKG_MAINTAINER_EMAIL "dl.omnitools@amd.com")
|
|
message(STATUS "Packaging config...")
|
|
set(CPACK_GENERATOR "DEB" "RPM" CACHE STRING "")
|
|
set(CPACK_PACKAGE_NAME "${PROJECT_NAME}" CACHE STRING "")
|
|
set(CPACK_PACKAGE_CONTACT
|
|
"https://github.com/ROCm/rocm-systems/tree/develop/projects/rocprofiler-compute"
|
|
)
|
|
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY
|
|
"ROCm Compute Profiler: tool for GPU performance profiling"
|
|
)
|
|
set(CPACK_RPM_PACKAGE_DESCRIPTION
|
|
"ROCm Compute Profiler is a performance analysis tool for profiling
|
|
machine learning/HPC workloads running on AMD GPUs."
|
|
)
|
|
set(CPACK_PACKAGE_VENDOR "Advanced Micro Devices, Inc.")
|
|
|
|
# Package versioning
|
|
set(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
|
|
set(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})
|
|
set(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})
|
|
set(CPACK_PACKAGE_VERSION
|
|
"${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}"
|
|
)
|
|
|
|
# RPM package specific variables
|
|
set(CPACK_RPM_PACKAGE_LICENSE "MIT")
|
|
set(CPACK_RPM_COMPONENT_INSTALL ON)
|
|
set(CPACK_RPM_PACKAGE_RELEASE_DIST ON)
|
|
set(CPACK_RPM_FILE_NAME "RPM-DEFAULT")
|
|
set(CPACK_RPM_SPEC_MORE_DEFINE "%undefine __brp_mangle_shebangs")
|
|
|
|
if(DEFINED CPACK_PACKAGING_INSTALL_PREFIX)
|
|
set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION "${CPACK_PACKAGING_INSTALL_PREFIX}")
|
|
endif()
|
|
|
|
# Debian package specific variables
|
|
set(CPACK_DEBIAN_PACKAGE_LICENSE "MIT")
|
|
set(CPACK_DEB_COMPONENT_INSTALL ON)
|
|
set(CPACK_DEBIAN_FILE_NAME "DEB-DEFAULT")
|
|
|
|
# Dependencies
|
|
set(PACKAGE_REQUIRES "rocprofiler" CACHE STRING "Package dependencies")
|
|
set(CPACK_RPM_PACKAGE_REQUIRES ${PACKAGE_REQUIRES})
|
|
set(CPACK_DEBIAN_PACKAGE_DEPENDS ${PACKAGE_REQUIRES})
|
|
|
|
# Handle the project rebranding from omniperf to rocprofiler-compute
|
|
set(OMNIPERF_PACKAGE_NAME "omniperf")
|
|
set(CPACK_RPM_PACKAGE_PROVIDES ${OMNIPERF_PACKAGE_NAME})
|
|
set(CPACK_RPM_PACKAGE_OBSOLETES "${OMNIPERF_PACKAGE_NAME} < 3.0.0")
|
|
set(CPACK_RPM_PACKAGE_CONFLICTS ${OMNIPERF_PACKAGE_NAME})
|
|
|
|
set(CPACK_DEBIAN_PACKAGE_PROVIDES ${OMNIPERF_PACKAGE_NAME})
|
|
set(CPACK_DEBIAN_PACKAGE_REPLACES ${OMNIPERF_PACKAGE_NAME})
|
|
set(CPACK_DEBIAN_PACKAGE_BREAKS ${OMNIPERF_PACKAGE_NAME})
|
|
|
|
# Disable automatic dependency generation
|
|
set(CPACK_RPM_PACKAGE_AUTOREQPROV OFF)
|
|
set(CPACK_RPM_PACKAGE_AUTOREQ OFF)
|
|
set(CPACK_RPM_PACKAGE_AUTOPROV OFF)
|
|
|
|
if(INSTALL_TESTS)
|
|
set(CPACK_RPM_TESTS_PACKAGE_REQUIRES ${CPACK_PACKAGE_NAME})
|
|
set(CPACK_DEBIAN_TESTS_PACKAGE_DEPENDS ${CPACK_PACKAGE_NAME})
|
|
endif()
|
|
|
|
# ----- Check for packaging override -----
|
|
if(DEFINED ENV{ROCM_LIBPATCH_VERSION})
|
|
set(CPACK_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION}.$ENV{ROCM_LIBPATCH_VERSION}")
|
|
endif()
|
|
|
|
if(DEFINED ENV{CPACK_RPM_PACKAGE_RELEASE})
|
|
set(CPACK_RPM_PACKAGE_RELEASE $ENV{CPACK_RPM_PACKAGE_RELEASE})
|
|
else()
|
|
set(CPACK_RPM_PACKAGE_RELEASE "local")
|
|
endif()
|
|
|
|
if(DEFINED ENV{CPACK_DEBIAN_PACKAGE_RELEASE})
|
|
set(CPACK_DEBIAN_PACKAGE_RELEASE $ENV{CPACK_DEBIAN_PACKAGE_RELEASE})
|
|
else()
|
|
set(CPACK_DEBIAN_PACKAGE_RELEASE "local")
|
|
endif()
|
|
|
|
# Log package info
|
|
message(STATUS " Package Name: ${CPACK_PACKAGE_NAME}")
|
|
message(STATUS " Package Version: ${CPACK_PACKAGE_VERSION}")
|
|
message(STATUS " RPM Package Release: ${CPACK_RPM_PACKAGE_RELEASE}")
|
|
message(STATUS " Debian Package Release: ${CPACK_DEBIAN_PACKAGE_RELEASE}")
|
|
message(STATUS " Packaging Install Prefix: ${CPACK_PACKAGING_INSTALL_PREFIX}")
|
|
message(STATUS " Install Tests: ${INSTALL_TESTS}")
|
|
message(STATUS " Package Dependencies: ${PACKAGE_REQUIRES}")
|
|
message(STATUS " CPack Generator: ${CPACK_GENERATOR}")
|
|
|
|
# Source tarball
|
|
set(CPACK_SOURCE_GENERATOR "TGZ")
|
|
set(CPACK_SOURCE_PACKAGE_FILE_NAME ${CMAKE_PROJECT_NAME}-${FULL_VERSION_STRING})
|
|
set(CPACK_SOURCE_IGNORE_FILES
|
|
".*~$"
|
|
\.git/
|
|
\.github
|
|
\.gitmodules
|
|
\.gitignore
|
|
/tests
|
|
/build
|
|
)
|
|
|
|
configure_pkg( ${PACKAGE_NAME} ${COMP_TYPE} ${CPACK_PACKAGE_VERSION} ${PKG_MAINTAINER_NM} ${PKG_MAINTAINER_EMAIL})
|
|
|
|
include(CPack)
|