Fix packaging (#51)

* Fix packaging

- Bump version to 0.3.0
- Set CMAKE_INSTALL_DEFAULT_COMPONENT at high level
- Fix HOMEPAGE_URL
- Update install components
- Install tests directory
- Create two separate packages: core and tests
- Auto-generate deps based on shared libs (DEB and RPM)
- Auto-generate list of shared libs provided by package (DEB and RPM)
- cleanup cmake/rocprofiler_register_utilities.cmake

* Enable sanitizer jobs

* Update cmake/rocprofiler_register_memcheck.cmake

- set env for LD_PRELOAD

* Update tests for sanitizer jobs

* Remove loading librocprofiler64.so

- this library does not have rocprofiler_set_api_table symbol

* Link to static fmt library

.github/workflows/continuous-integration.yml

@@ -40,18 +40,18 @@ jobs:
             compiler: 'clang-10'
             ci-args: ''
             ci-tag: ''
-        #   - runner: 'ubuntu-latest'
+          - runner: 'ubuntu-latest'
-        #     compiler: 'gcc-12'
+            compiler: 'gcc-12'
-        #     ci-args: '--memcheck ThreadSanitizer'
+            ci-args: '--memcheck ThreadSanitizer'
-        #     ci-tag: '-thread-sanitizer'
+            ci-tag: '-thread-sanitizer'
-        #   - runner: 'ubuntu-latest'
+          - runner: 'ubuntu-latest'
-        #     compiler: 'gcc-12'
+            compiler: 'gcc-12'
-        #     ci-args: '--memcheck AddressSanitizer'
+            ci-args: '--memcheck AddressSanitizer'
-        #     ci-tag: '-address-sanitizer'
+            ci-tag: '-address-sanitizer'
-        #   - runner: 'ubuntu-latest'
+          - runner: 'ubuntu-latest'
-        #     compiler: 'gcc-12'
+            compiler: 'gcc-12'
-        #     ci-args: '--memcheck LeakSanitizer'
+            ci-args: '--memcheck LeakSanitizer'
-        #     ci-tag: '-leak-sanitizer'
+            ci-tag: '-leak-sanitizer'
         #   - runner: 'ubuntu-latest'
         #     compiler: 'gcc-12'
         #     ci-args: '--memcheck UndefinedBehaviorSanitizer'

CMakeLists.txt

@@ -29,7 +29,11 @@ project(
     LANGUAGES C CXX
     VERSION ${ROCPROFILER_REGISTER_VERSION}
     DESCRIPTION "Registration library for rocprofiler"
-    HOMEPAGE_URL "https://github.com/ROCm-Developer-Tools/rocprofiler-register-internal")
+    HOMEPAGE_URL "https://github.com/ROCm/rocprofiler-register-internal")
+
+set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME core)
+# configure the version file so that if it changes, cmake automatically re-runs
+configure_file(${PROJECT_SOURCE_DIR}/VERSION ${PROJECT_BINARY_DIR}/VERSION COPYONLY)
 
 # needed for modulefile and setup-env.sh
 string(REPLACE "-" "_" PROJECT_NAME_UNDERSCORED "${PROJECT_NAME}")

VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

cmake/rocprofiler_register_build_settings.cmake

@@ -63,10 +63,16 @@ target_link_libraries(rocprofiler-register-build-flags INTERFACE rocprofiler-reg
 # ----------------------------------------------------------------------------------------#
 # set the compiler flags
 #
+
+set(_WARN_STACK_USAGE)
+if(NOT ROCPROFILER_REGISTER_ENABLE_CLANG_TIDY)
+    set(_WARN_STACK_USAGE "-Wstack-usage=8192") # 2 KB
+endif()
+
 rocprofiler_register_target_compile_options(
     rocprofiler-register-build-flags
     INTERFACE "-W" "-Wall" "-Wno-unknown-pragmas" "-fstack-protector-strong"
-              "-Wstack-protector")
+              "-Wstack-protector" ${_WARN_STACK_USAGE})
 
 # ----------------------------------------------------------------------------------------#
 # debug-safe optimizations
@@ -84,14 +90,6 @@ rocprofiler_register_target_compile_options(
     LANGUAGES C CXX
     INTERFACE "-Werror" "-Wdouble-promotion" "-Wshadow" "-Wextra")
 
-if(NOT ROCPROFILER_REGISTER_ENABLE_CLANG_TIDY)
-    rocprofiler_register_target_compile_options(
-        rocprofiler-register-developer-flags
-        LANGUAGES C CXX
-        INTERFACE "-Wstack-usage=524288" # 512 KB
-        )
-endif()
-
 if(ROCPROFILER_REGISTER_BUILD_DEVELOPER)
     target_link_libraries(rocprofiler-register-build-flags
                           INTERFACE rocprofiler-register::developer-flags)

cmake/rocprofiler_register_config_install.cmake

@@ -3,13 +3,17 @@ include_guard(GLOBAL)
 
 include(CMakePackageConfigHelpers)
 
-set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME config)
-
 install(
     EXPORT rocprofiler-register-library-targets
     FILE rocprofiler-register-library-targets.cmake
     NAMESPACE rocprofiler-register::
-    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/cmake/rocprofiler-register)
+    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/cmake/rocprofiler-register
+    COMPONENT core)
+
+install(
+    DIRECTORY ${PROJECT_SOURCE_DIR}/tests
+    DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}
+    COMPONENT tests)
 
 configure_file(
     ${PROJECT_SOURCE_DIR}/cmake/Templates/setup-env.sh.in
@@ -23,13 +27,13 @@ configure_file(
 install(
     FILES ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/setup-env.sh
     DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}
-    COMPONENT setup)
+    COMPONENT core)
 
 install(
     FILES
         ${PROJECT_BINARY_DIR}/${CMAKE_INSTALL_DATAROOTDIR}/modulefiles/${PROJECT_NAME}/${PROJECT_VERSION}
     DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/modulefiles/${PROJECT_NAME}
-    COMPONENT setup)
+    COMPONENT core)
 
 # ------------------------------------------------------------------------------#
 # install tree

cmake/rocprofiler_register_config_packaging.cmake

@@ -29,12 +29,91 @@ set(ROCPROFILER_REGISTER_PACKAGE_FILE_NAME
     )
 rocprofiler_register_add_feature(ROCPROFILER_REGISTER_PACKAGE_FILE_NAME "CPack filename")
 
+get_cmake_property(ROCPROFILER_REGISTER_PACKAGING_COMPONENTS COMPONENTS)
+
+rocprofiler_register_add_feature(ROCPROFILER_REGISTER_PACKAGING_COMPONENTS
+                                 "Packaging components")
+list(REMOVE_ITEM ROCPROFILER_REGISTER_PACKAGING_COMPONENTS "Development" "Unspecified"
+     "external")
+list(LENGTH ROCPROFILER_REGISTER_PACKAGING_COMPONENTS
+     NUM_ROCPROFILER_REGISTER_PACKAGING_COMPONENTS)
+
+# the packages we will generate
+set(ROCPROFILER_REGISTER_COMPONENT_GROUPS "core" "tests")
+
+set(COMPONENT_GROUP_core_COMPONENTS "core" "Development" "Unspecified" "external")
+set(COMPONENT_GROUP_tests_COMPONENTS "tests")
+
+# variables for each component group. Note: eventually we will probably want to separate
+# the core to just be the runtime libraries, development to be the headers and cmake
+# files, the samples to just be the samples, and tools just be the tool files but right
+# now we are just combining core, development, samples, and tools into one package
+set(COMPONENT_NAME_core "")
+set(COMPONENT_NAME_tests "tests")
+
+set(COMPONENT_SEP_core "")
+set(COMPONENT_SEP_tests "-")
+
+set(COMPONENT_DEP_core "")
+set(COMPONENT_DEP_tests "${PROJECT_NAME}")
+
+set(COMPONENT_DESC_core "rocprofiler-register libraries and headers")
+set(COMPONENT_DESC_tests "rocprofiler-register tests")
+
+if(NOT NUM_ROCPROFILER_REGISTER_PACKAGING_COMPONENTS EQUAL 2)
+    message(
+        FATAL_ERROR
+            "Error new install component needs COMPONENT_NAME_* and COMPONENT_SEP_* entries. Expected 2, found ${NUM_ROCPROFILER_REGISTER_PACKAGING_COMPONENTS}: ${ROCPROFILER_REGISTER_PACKAGING_COMPONENTS}"
+        )
+endif()
+
+if(ROCM_DEP_ROCMCORE OR ROCPROFILER_REGISTER_DEP_ROCMCORE)
+    set(CPACK_DEBIAN_PACKAGE_DEPENDS "rocm-core")
+    set(CPACK_RPM_PACKAGE_REQUIRES "rocm-core")
+else()
+    set(CPACK_DEBIAN_PACKAGE_DEPENDS "")
+    set(CPACK_RPM_PACKAGE_REQUIRES "")
+endif()
+
+foreach(COMPONENT_GROUP ${ROCPROFILER_REGISTER_COMPONENT_GROUPS})
+    set(_SEP "${COMPONENT_SEP_${COMPONENT_GROUP}}")
+    set(_DEP "${COMPONENT_DEP_${COMPONENT_GROUP}}")
+    set(_NAME "${COMPONENT_NAME_${COMPONENT_GROUP}}")
+    set(_DESC "${COMPONENT_DESC_${COMPONENT_GROUP}}")
+
+    cpack_add_component_group(
+        ${COMPONENT_GROUP}
+        DISPLAY_NAME "${_NAME}"
+        DESCRIPTION "${_DESC}")
+
+    if(ROCM_DEP_ROCMCORE OR ROCPROFILER_REGISTER_DEP_ROCMCORE)
+        list(INSERT _DEP 0 "rocm-core")
+    endif()
+
+    string(TOUPPER "${COMPONENT_GROUP}" UCOMPONENT)
+    set(CPACK_DEBIAN_${UCOMPONENT}_PACKAGE_NAME "${PROJECT_NAME}${_SEP}${_NAME}")
+    set(CPACK_DEBIAN_${UCOMPONENT}_PACKAGE_DEPENDS "${_DEP}")
+    set(CPACK_RPM_${UCOMPONENT}_PACKAGE_NAME "${PROJECT_NAME}${_SEP}${_NAME}")
+    set(CPACK_RPM_${UCOMPONENT}_PACKAGE_REQUIRES "${_DEP}")
+
+    foreach(COMPONENT ${COMPONENT_GROUP_${COMPONENT_GROUP}_COMPONENTS})
+        cpack_add_component(${COMPONENT} REQUIRED GROUP "${COMPONENT_GROUP}")
+    endforeach()
+endforeach()
+
 # -------------------------------------------------------------------------------------- #
 #
 # Debian package specific variables
 #
 # -------------------------------------------------------------------------------------- #
 
+set(CPACK_DEBIAN_PACKAGE_EPOCH 0)
+set(CPACK_DEB_COMPONENT_INSTALL ON)
+set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON) # auto-generate deps based on shared libs
+set(CPACK_DEBIAN_PACKAGE_GENERATE_SHLIBS ON) # generate list of shared libs provided by
+                                             # package
+set(CPACK_DEBIAN_TESTS_PACKAGE_SHLIBDEPS OFF) # disable for tests package
+set(CPACK_DEBIAN_TESTS_PACKAGE_GENERATE_SHLIBS OFF) # disable for tests package
 set(CPACK_DEBIAN_PACKAGE_HOMEPAGE "${PROJECT_HOMEPAGE_URL}")
 set(CPACK_DEBIAN_PACKAGE_RELEASE
     "${ROCPROFILER_REGISTER_CPACK_SYSTEM_NAME}${ROCPROFILER_REGISTER_CPACK_PACKAGE_SUFFIX}"
@@ -71,6 +150,12 @@ if(DEFINED CPACK_PACKAGING_INSTALL_PREFIX)
     set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION "${CPACK_PACKAGING_INSTALL_PREFIX}")
 endif()
 
+set(CPACK_RPM_PACKAGE_EPOCH 0)
+set(CPACK_RPM_COMPONENT_INSTALL ON)
+set(CPACK_RPM_PACKAGE_AUTOREQ ON) # auto-generate deps based on shared libs
+set(CPACK_RPM_PACKAGE_AUTOPROV ON) # generate list of shared libs provided by package
+set(CPACK_RPM_TESTS_PACKAGE_AUTOREQ OFF) # disable for tests package
+set(CPACK_RPM_TESTS_PACKAGE_AUTOPROV OFF) # disable for tests package
 set(CPACK_RPM_PACKAGE_RELEASE
     "${ROCPROFILER_REGISTER_CPACK_SYSTEM_NAME}${ROCPROFILER_REGISTER_CPACK_PACKAGE_SUFFIX}"
     )

cmake/rocprofiler_register_memcheck.cmake

@@ -19,11 +19,47 @@ function(rocprofiler_register_add_memcheck_flags _TYPE _LIB)
     target_compile_options(
         rocprofiler-register-memcheck
         INTERFACE $<BUILD_INTERFACE:-g3 -Og -fno-omit-frame-pointer
-                  -fno-optimize-sibling-calls -fno-inline-functions -fsanitize=${_TYPE}>
+                  -fno-optimize-sibling-calls -fno-inline-functions -fsanitize=${_TYPE}>)
-                  -static-lib${_LIB})
+    target_link_options(rocprofiler-register-memcheck INTERFACE
-    target_link_options(
+                        $<BUILD_INTERFACE:-fsanitize=${_TYPE}>)
-        rocprofiler-register-memcheck INTERFACE $<BUILD_INTERFACE:-fsanitize=${_TYPE}
+endfunction()
-        -static-lib${_LIB} -Wl,--no-undefined>)
+
+function(rocprofiler_register_set_memcheck_env _TYPE _LIB_BASE)
+    set(_LIBS ${_LIB_BASE})
+
+    foreach(
+        _N
+        8
+        7
+        6
+        5
+        4
+        3
+        2
+        1
+        0)
+        list(
+            APPEND _LIBS
+            ${CMAKE_SHARED_LIBRARY_PREFIX}${_LIB_BASE}${CMAKE_SHARED_LIBRARY_SUFFIX}.${_N}
+            )
+    endforeach()
+
+    foreach(_LIB ${_LIBS})
+        if(NOT ${_TYPE}_LIBRARY)
+            find_library(${_TYPE}_LIBRARY NAMES ${_LIB} ${ARGN})
+        endif()
+    endforeach()
+
+    target_link_libraries(rocprofiler-register-memcheck INTERFACE ${_LIB_BASE})
+
+    if(${_TYPE}_LIBRARY)
+        set(ROCPROFILER_REGISTER_MEMCHECK_PRELOAD_LIBRARY
+            "${${_TYPE}_LIBRARY}"
+            CACHE INTERNAL "LD_PRELOAD library for tests " FORCE)
+        set(ROCPROFILER_REGISTER_MEMCHECK_PRELOAD_ENV
+            "LD_PRELOAD=${ROCPROFILER_REGISTER_MEMCHECK_PRELOAD_LIBRARY}"
+            CACHE INTERNAL "LD_PRELOAD env variable for tests " FORCE)
+    endif()
 endfunction()
 
 # always unset so that it doesn't preload if memcheck disabled
@@ -31,10 +67,14 @@ unset(ROCPROFILER_REGISTER_MEMCHECK_PRELOAD_ENV CACHE)
 
 if(ROCPROFILER_REGISTER_MEMCHECK STREQUAL "AddressSanitizer")
     rocprofiler_register_add_memcheck_flags("address" "asan")
+    rocprofiler_register_set_memcheck_env("${ROCPROFILER_REGISTER_MEMCHECK}" "asan")
 elseif(ROCPROFILER_REGISTER_MEMCHECK STREQUAL "LeakSanitizer")
     rocprofiler_register_add_memcheck_flags("leak" "lsan")
+    rocprofiler_register_set_memcheck_env("${ROCPROFILER_REGISTER_MEMCHECK}" "lsan")
 elseif(ROCPROFILER_REGISTER_MEMCHECK STREQUAL "ThreadSanitizer")
     rocprofiler_register_add_memcheck_flags("thread" "tsan")
+    rocprofiler_register_set_memcheck_env("${ROCPROFILER_REGISTER_MEMCHECK}" "tsan")
 elseif(ROCPROFILER_REGISTER_MEMCHECK STREQUAL "UndefinedBehaviorSanitizer")
     rocprofiler_register_add_memcheck_flags("undefined" "ubsan")
+    rocprofiler_register_set_memcheck_env("${ROCPROFILER_REGISTER_MEMCHECK}" "ubsan")
 endif()

cmake/rocprofiler_register_utilities.cmake

@@ -551,80 +551,8 @@ function(ROCPROFILER_REGISTER_PRINT_FEATURES)
 endfunction()
 
 # ----------------------------------------------------------------------------------------#
-# this function is provided to easily select which files use alternative compiler:
+# function watch_for_change() Print the value of variable if it changed
 #
-# GLOBAL      --> all files TARGET      --> all files in a target SOURCE      --> specific
-# source files DIRECTORY   --> all files in directory PROJECT     --> all files/targets in
-# a project/subproject
-#
-function(rocprofiler_register_custom_compilation)
-    cmake_parse_arguments(COMP "GLOBAL;PROJECT" "COMPILER" "DIRECTORY;TARGET;SOURCE"
-                          ${ARGN})
-
-    # find rocprofiler-register-launch-compiler
-    find_program(
-        ROCPROFILER_REGISTER_COMPILE_LAUNCHER
-        NAMES rocprofiler-register-launch-compiler
-        HINTS ${PROJECT_SOURCE_DIR} ${CMAKE_SOURCE_DIR}
-        PATHS ${PROJECT_SOURCE_DIR} ${CMAKE_SOURCE_DIR}
-        PATH_SUFFIXES scripts bin)
-
-    if(NOT COMP_COMPILER)
-        message(
-            FATAL_ERROR
-                "rocprofiler_register_custom_compilation not provided COMPILER argument")
-    endif()
-
-    if(NOT ROCPROFILER_REGISTER_COMPILE_LAUNCHER)
-        message(
-            FATAL_ERROR
-                "rocprofiler-register could not find 'rocprofiler-register-launch-compiler'. Please set '-DROCPROFILER_REGISTER_COMPILE_LAUNCHER=/path/to/launcher'"
-            )
-    endif()
-
-    if(COMP_GLOBAL)
-        # if global, don't bother setting others
-        set_property(
-            GLOBAL
-            PROPERTY
-                RULE_LAUNCH_COMPILE
-                "${ROCPROFILER_REGISTER_COMPILE_LAUNCHER} ${COMP_COMPILER} ${CMAKE_CXX_COMPILER}"
-            )
-        set_property(
-            GLOBAL
-            PROPERTY
-                RULE_LAUNCH_LINK
-                "${ROCPROFILER_REGISTER_COMPILE_LAUNCHER} ${COMP_COMPILER} ${CMAKE_CXX_COMPILER}"
-            )
-    else()
-        foreach(_TYPE PROJECT DIRECTORY TARGET SOURCE)
-            # make project/subproject scoping easy, e.g.
-            # rocprofiler_register_custom_compilation(PROJECT) after project(...)
-            if("${_TYPE}" STREQUAL "PROJECT" AND COMP_${_TYPE})
-                list(APPEND COMP_DIRECTORY ${PROJECT_SOURCE_DIR})
-                unset(COMP_${_TYPE})
-            endif()
-            # set the properties if defined
-            if(COMP_${_TYPE})
-                foreach(_VAL ${COMP_${_TYPE}})
-                    set_property(
-                        ${_TYPE} ${_VAL}
-                        PROPERTY
-                            RULE_LAUNCH_COMPILE
-                            "${ROCPROFILER_REGISTER_COMPILE_LAUNCHER} ${COMP_COMPILER} ${CMAKE_CXX_COMPILER}"
-                        )
-                    set_property(
-                        ${_TYPE} ${_VAL}
-                        PROPERTY
-                            RULE_LAUNCH_LINK
-                            "${ROCPROFILER_REGISTER_COMPILE_LAUNCHER} ${COMP_COMPILER} ${CMAKE_CXX_COMPILER}"
-                        )
-                endforeach()
-            endif()
-        endforeach()
-    endif()
-endfunction()
-
 function(ROCPROFILER_REGISTER_WATCH_FOR_CHANGE _var)
     list(LENGTH ARGN _NUM_EXTRA_ARGS)
     if(_NUM_EXTRA_ARGS EQUAL 1)
@@ -667,171 +595,6 @@ function(ROCPROFILER_REGISTER_WATCH_FOR_CHANGE _var)
         CACHE INTERNAL "Last value of ${_var}" FORCE)
 endfunction()
 
-function(ROCPROFILER_REGISTER_DIRECTORY)
-    cmake_parse_arguments(F "MKDIR;FAIL;FORCE" "PREFIX;OUTPUT_VARIABLE;WORKING_DIRECTORY"
-                          "PATHS" ${ARGN})
-
-    if(F_PREFIX AND NOT IS_ABSOLUTE "${F_PREFIX}")
-        if(F_WORKING_DIRECTORY)
-            rocprofiler_register_message(
-                STATUS
-                "PREFIX was specified as a relative path, using working directory + prefix :: '${F_WORKING_DIRECTORY}/${F_PREFIX}'..."
-                )
-            set(F_PREFIX ${F_WORKING_DIRECTORY}/${F_PREFIX})
-        else()
-            rocprofiler_register_message(
-                FATAL_ERROR
-                "PREFIX was specified but it is not an absolute path: ${F_PREFIX}")
-        endif()
-    endif()
-
-    if(NOT F_WORKING_DIRECTORY)
-        set(F_WORKING_DIRECTORY ${PROJECT_BINARY_DIR})
-    endif()
-
-    foreach(_PATH ${F_PREFIX} ${F_PATHS})
-        if(F_PREFIX AND NOT "${_PATH}" STREQUAL "${F_PREFIX}")
-            # if path is relative, set to prefix + path
-            if(NOT IS_ABSOLUTE "${_PATH}")
-                set(_PATH ${F_PREFIX}/${_PATH})
-            endif()
-            list(APPEND _OUTPUT_VAR ${_PATH})
-        elseif(NOT F_PREFIX)
-            list(APPEND _OUTPUT_VAR ${_PATH})
-        endif()
-
-        if(NOT EXISTS "${_PATH}" AND F_FAIL)
-            rocprofiler_register_message(FATAL_ERROR
-                                         "Directory '${_PATH}' does not exist")
-        elseif(NOT IS_DIRECTORY "${_PATH}" AND F_FAIL)
-            rocprofiler_register_message(FATAL_ERROR
-                                         "'${_PATH}' exists but is not a directory")
-        elseif(NOT EXISTS "${_PATH}" AND F_MKDIR)
-            execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory ${_PATH}
-                            WORKING_DIRECTORY ${F_WORKING_DIRECTORY})
-        elseif(
-            EXISTS "${_PATH}"
-            AND NOT IS_DIRECTORY "${_PATH}"
-            AND F_MKDIR)
-            if(F_FORCE)
-                execute_process(COMMAND ${CMAKE_COMMAND} -E rm ${_PATH}
-                                WORKING_DIRECTORY ${F_WORKING_DIRECTORY})
-            endif()
-            execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory ${_PATH}
-                            WORKING_DIRECTORY ${F_WORKING_DIRECTORY})
-        endif()
-    endforeach()
-
-    if(F_OUTPUT_VARIABLE)
-        set(${F_OUTPUT_VARIABLE}
-            "${_OUTPUT_VAR}"
-            PARENT_SCOPE)
-    endif()
-endfunction()
-
-function(ROCPROFILER_REGISTER_CHECK_PYTHON_DIRS_AND_VERSIONS)
-    cmake_parse_arguments(F "FAIL;UNSET" "RESULT_VARIABLE;OUTPUT_VARIABLE" "" ${ARGN})
-
-    list(LENGTH ROCPROFILER_REGISTER_PYTHON_VERSIONS _NUM_PYTHON_VERSIONS)
-    list(LENGTH ROCPROFILER_REGISTER_PYTHON_ROOT_DIRS _NUM_PYTHON_ROOT_DIRS)
-
-    if(NOT _NUM_PYTHON_VERSIONS EQUAL _NUM_PYTHON_ROOT_DIRS)
-        set(_RET 1)
-    else()
-        set(_RET 0)
-        if(F_OUTPUT_VARIABLE)
-            set(${F_OUTPUT_VARIABLE}
-                ${_NUM_PYTHON_VERSIONS}
-                PARENT_SCOPE)
-        endif()
-    endif()
-
-    if(F_RESULT_VARIABLE)
-        set(${F_RESULT_VARIABLE}
-            ${_RET}
-            PARENT_SCOPE)
-    endif()
-
-    if(NOT ${_RET} EQUAL 0)
-        if(F_FAIL)
-            rocprofiler_register_message(
-                WARNING
-                "Error! Number of python versions  : ${_NUM_PYTHON_VERSIONS}. VERSIONS :: ${ROCPROFILER_REGISTER_PYTHON_VERSIONS}"
-                )
-            rocprofiler_register_message(
-                WARNING
-                "Error! Number of python root directories : ${_NUM_PYTHON_ROOT_DIRS}. ROOT DIRS :: ${ROCPROFILER_REGISTER_PYTHON_ROOT_DIRS}"
-                )
-            rocprofiler_register_message(
-                FATAL_ERROR
-                "Error! Number of python versions != number of python root directories")
-        elseif(F_UNSET)
-            unset(ROCPROFILER_REGISTER_PYTHON_VERSIONS CACHE)
-            unset(ROCPROFILER_REGISTER_PYTHON_ROOT_DIRS CACHE)
-            if(F_OUTPUT_VARIABLE)
-                set(${F_OUTPUT_VARIABLE} 0)
-            endif()
-        endif()
-    endif()
-endfunction()
-
-# ----------------------------------------------------------------------------
-# Console scripts
-#
-function(ROCPROFILER_REGISTER_PYTHON_CONSOLE_SCRIPT SCRIPT_NAME SCRIPT_SUBMODULE)
-    set(options)
-    set(args VERSION ROOT_DIR)
-    set(kwargs)
-    cmake_parse_arguments(ARG "${options}" "${args}" "${kwargs}" ${ARGN})
-
-    if(ARG_VERSION AND ARG_ROOT_DIR)
-        set(Python3_ROOT_DIR "${ARG_ROOT_DIR}")
-        find_package(Python3 ${ARG_VERSION} EXACT QUIET MODULE COMPONENTS Interpreter)
-        set(PYTHON_EXECUTABLE "${Python3_EXECUTABLE}")
-        configure_file(${PROJECT_SOURCE_DIR}/cmake/Templates/console-script.in
-                       ${PROJECT_BINARY_DIR}/bin/${SCRIPT_NAME}-${ARG_VERSION} @ONLY)
-
-        if(CMAKE_INSTALL_PYTHONDIR)
-            install(
-                PROGRAMS ${PROJECT_BINARY_DIR}/bin/${SCRIPT_NAME}-${ARG_VERSION}
-                DESTINATION ${CMAKE_INSTALL_BINDIR}
-                COMPONENT python
-                OPTIONAL)
-        endif()
-
-        if(ROCPROFILER_REGISTER_BUILD_TESTING OR ROCPROFILER_REGISTER_BUILD_PYTHON)
-            add_test(
-                NAME ${SCRIPT_NAME}-console-script-test-${ARG_VERSION}
-                COMMAND ${PROJECT_BINARY_DIR}/bin/${SCRIPT_NAME}-${ARG_VERSION} --help
-                WORKING_DIRECTORY ${PROJECT_BINARY_DIR})
-            set_tests_properties(
-                ${SCRIPT_NAME}-console-script-test-${ARG_VERSION}
-                PROPERTIES LABELS "python;python-${ARG_VERSION};console-script")
-            add_test(
-                NAME ${SCRIPT_NAME}-generic-console-script-test-${ARG_VERSION}
-                COMMAND ${PROJECT_BINARY_DIR}/bin/${SCRIPT_NAME} --help
-                WORKING_DIRECTORY ${PROJECT_BINARY_DIR})
-            set_tests_properties(
-                ${SCRIPT_NAME}-generic-console-script-test-${ARG_VERSION}
-                PROPERTIES ENVIRONMENT "PYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}" LABELS
-                           "python;python-${ARG_VERSION};console-script")
-        endif()
-    else()
-        set(PYTHON_EXECUTABLE "python3")
-
-        configure_file(${PROJECT_SOURCE_DIR}/cmake/Templates/console-script.in
-                       ${PROJECT_BINARY_DIR}/bin/${SCRIPT_NAME} @ONLY)
-
-        if(CMAKE_INSTALL_PYTHONDIR)
-            install(
-                PROGRAMS ${PROJECT_BINARY_DIR}/bin/${SCRIPT_NAME}
-                DESTINATION ${CMAKE_INSTALL_BINDIR}
-                COMPONENT python
-                OPTIONAL)
-        endif()
-    endif()
-endfunction()
-
 function(ROCPROFILER_REGISTER_FIND_STATIC_LIBRARY)
     set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX})
     find_library(${ARGN})
@@ -842,100 +605,4 @@ function(ROCPROFILER_REGISTER_FIND_SHARED_LIBRARY)
     find_library(${ARGN})
 endfunction()
 
-function(ROCPROFILER_REGISTER_BUILDTREE_TPL _TPL_TARGET _NEW_NAME _BUILD_TREE_DIR)
-    get_target_property(_TPL_VERSION ${_TPL_TARGET} VERSION)
-    get_target_property(_TPL_SOVERSION ${_TPL_TARGET} SOVERSION)
-    get_target_property(_TPL_NAME ${_TPL_TARGET} OUTPUT_NAME)
-    set(_TPL_PREFIX ${CMAKE_SHARED_LIBRARY_PREFIX})
-    set(_TPL_SUFFIX ${CMAKE_SHARED_LIBRARY_SUFFIX})
-
-    foreach(_TAIL ${_TPL_SUFFIX} ${_TPL_SUFFIX}.${_TPL_SOVERSION}
-                  ${_TPL_SUFFIX}.${_TPL_VERSION})
-        set(_INP ${_TPL_PREFIX}${_TPL_NAME}${_TAIL})
-        set(_OUT ${_TPL_PREFIX}${_NEW_NAME}${_TAIL})
-    endforeach()
-
-    string(REPLACE " " "-" _TAIL "${ARGN}")
-
-    # build tree symbolic links
-    add_custom_target(
-        ${_NEW_NAME}-build-tree-library${_TAIL} ALL
-        ${CMAKE_COMMAND} -E create_symlink $<TARGET_FILE:${_TPL_TARGET}>
-        ${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}.${_TPL_VERSION}
-        COMMAND
-            ${CMAKE_COMMAND} -E create_symlink
-            ${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}.${_TPL_VERSION}
-            ${_BUILD_TREE_DIR}/${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}.${_TPL_SOVERSION}
-        COMMAND
-            ${CMAKE_COMMAND} -E create_symlink
-            ${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}.${_TPL_SOVERSION}
-            ${_BUILD_TREE_DIR}/${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}
-        WORKING_DIRECTORY ${_BUILD_TREE_DIR}
-        DEPENDS ${_TPL_TARGET}
-        COMMENT "Creating ${_NEW_NAME} from ${_TPL_TARGET}...")
-endfunction()
-
-function(ROCPROFILER_REGISTER_INSTALL_TPL _TPL_TARGET _NEW_NAME _BUILD_TREE_DIR
-         _COMPONENT)
-    get_target_property(_TPL_VERSION ${_TPL_TARGET} VERSION)
-    get_target_property(_TPL_SOVERSION ${_TPL_TARGET} SOVERSION)
-    get_target_property(_TPL_NAME ${_TPL_TARGET} OUTPUT_NAME)
-    set(_TPL_PREFIX ${CMAKE_SHARED_LIBRARY_PREFIX})
-    set(_TPL_SUFFIX ${CMAKE_SHARED_LIBRARY_SUFFIX})
-
-    foreach(_TAIL ${_TPL_SUFFIX} ${_TPL_SUFFIX}.${_TPL_SOVERSION}
-                  ${_TPL_SUFFIX}.${_TPL_VERSION})
-        set(_INP ${_TPL_PREFIX}${_TPL_NAME}${_TAIL})
-        set(_OUT ${_TPL_PREFIX}${_NEW_NAME}${_TAIL})
-    endforeach()
-
-    # build tree symbolic links
-    rocprofiler_register_buildtree_tpl("${_TPL_TARGET}" "${_NEW_NAME}"
-                                       "${_BUILD_TREE_DIR}" ${ARGN})
-
-    install(
-        FILES $<TARGET_FILE:${_TPL_TARGET}>
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        COMPONENT ${_COMPONENT}
-        RENAME ${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}.${_TPL_VERSION})
-
-    install(
-        FILES
-            ${_BUILD_TREE_DIR}/${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}.${_TPL_SOVERSION}
-            ${_BUILD_TREE_DIR}/${_TPL_PREFIX}${_NEW_NAME}${_TPL_SUFFIX}
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        COMPONENT ${_COMPONENT})
-
-endfunction()
-
-function(COMPUTE_POW2_CEIL _OUTPUT _VALUE)
-    find_package(Python3 COMPONENTS Interpreter)
-
-    if(Python3_FOUND)
-        execute_process(
-            COMMAND
-                ${Python3_EXECUTABLE} -c
-                "VALUE = ${_VALUE}; ispow2 = lambda x: x if (x and (not(x & (x - 1)))) else None; v = list(filter(ispow2, [x for x in range(VALUE, VALUE**2)])); print(v[0])"
-            RESULT_VARIABLE _POW2_RET
-            OUTPUT_VARIABLE _POW2_OUT
-            ERROR_VARIABLE _POW2_ERR
-            OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-        if(_POW2_RET EQUAL 0)
-            set(${_OUTPUT}
-                ${_POW2_OUT}
-                PARENT_SCOPE)
-        else()
-            set(${_OUTPUT}
-                "-1"
-                PARENT_SCOPE)
-        endif()
-    else()
-        set(${_OUTPUT}
-            "-1"
-            PARENT_SCOPE)
-    endif()
-
-endfunction()
-
 cmake_policy(POP)

external/CMakeLists.txt

@@ -1,4 +1,7 @@
 set(BUILD_TESTING OFF)
+set(BUILD_SHARED_LIBS OFF)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME external)
 
 if(ROCPROFILER_REGISTER_BUILD_GLOG)
     # checkout submodule if not already checked out or clone repo if no .gitmodules file
@@ -11,7 +14,8 @@ if(ROCPROFILER_REGISTER_BUILD_GLOG)
 
     # May want to use GFLAGS in the future
     set(WITH_GFLAGS OFF)
-    set(BUILD_SHARED_LIBS OFF)
+    set(WITH_GTEST OFF)
+    set(WITH_UNWIND OFF)
     add_subdirectory(glog EXCLUDE_FROM_ALL)
 else()
     find_package(glog REQUIRED)

samples/CMakeLists.txt

@@ -3,4 +3,6 @@
 #
 project(rocprofiler-register-samples LANGUAGES C CXX)
 
+set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME sample)
+
 add_subdirectory(library-implementation)

source/include/rocprofiler-register/CMakeLists.txt

@@ -9,5 +9,7 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/version.h.in
 set(ROCPROFILER_REGISTER_INCLUDE_FILES ${CMAKE_CURRENT_SOURCE_DIR}/rocprofiler-register.h
                                        ${CMAKE_CURRENT_BINARY_DIR}/version.h)
 
-install(FILES ${ROCPROFILER_REGISTER_INCLUDE_FILES}
+install(
-        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/rocprofiler-register)
+    FILES ${ROCPROFILER_REGISTER_INCLUDE_FILES}
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/rocprofiler-register
+    COMPONENT core)

source/lib/rocprofiler-register/CMakeLists.txt

@@ -20,7 +20,7 @@ target_include_directories(
 target_link_libraries(
     rocprofiler-register
     PUBLIC rocprofiler-register::headers
-    PRIVATE fmt::fmt-header-only glog::glog rocprofiler-register::build-flags
+    PRIVATE fmt::fmt glog::glog rocprofiler-register::build-flags
             rocprofiler-register::memcheck rocprofiler-register::stdcxxfs
             rocprofiler-register::dl)
 

source/lib/rocprofiler-register/rocprofiler_register.cpp

@@ -253,13 +253,9 @@ rocp_reg_scan_for_tools()
         std::tie(rocprofiler_lib_handle, rocprofiler_lib_config_fn) =
             rocp_load_rocprofiler_lib(_rocp_reg_lib);
 
-        if(!rocprofiler_lib_config_fn)
-            std::tie(rocprofiler_lib_handle, rocprofiler_lib_config_fn) =
-                rocp_load_rocprofiler_lib("librocprofiler64.so");
-
         LOG_IF(FATAL, !rocprofiler_lib_config_fn)
             << rocprofiler_lib_register_entrypoint << " not found. Tried to dlopen "
-            << _rocp_reg_lib << " and librocprofiler64.so";
+            << _rocp_reg_lib;
     }
     else if(_found_tool && rocprofiler_set_api_table)
     {

tests/CMakeLists.txt

@@ -1,6 +1,7 @@
 cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 
 project(rocprofiler-register-tests LANGUAGES C CXX)
+set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME tests)
 
 include(CMakeParseArguments)
 include(GNUInstallDirs)
@@ -155,27 +156,40 @@ function(rocp_register_test_executable _NAME)
                        ${ARGN})
     endfunction()
 
-    rocp_register_add_test(${_NAME} ${_NAME} "" "${RRTE_CORE_PASS_REGEX}"
+    rocp_register_add_test(
-                           "${RRTE_CORE_FAIL_REGEX}")
+        ${_NAME} ${_NAME} "${ROCPROFILER_REGISTER_MEMCHECK_PRELOAD_ENV}"
-
+        "${RRTE_CORE_PASS_REGEX}" "${RRTE_CORE_FAIL_REGEX}")
-    rocp_register_add_test(${_NAME}-preload ${_NAME} "LD_PRELOAD=libgeneric-tool.so"
-                           "${RRTE_PRELOAD_PASS_REGEX}" "${RRTE_PRELOAD_FAIL_REGEX}")
-
-    rocp_register_add_test(${_NAME}-env ${_NAME} "ROCP_TOOL_LIBRARIES=libgeneric-tool.so"
-                           "${RRTE_PRELOAD_PASS_REGEX}" "${RRTE_PRELOAD_FAIL_REGEX}")
-
-    rocp_register_add_test(${_NAME}-wrap ${_NAME} "ROCP_REG_TEST_WRAP=1"
-                           "${RRTE_WRAP_PASS_REGEX}" "${RRTE_WRAP_FAIL_REGEX}")
 
     rocp_register_add_test(
-        ${_NAME}-preload-wrap ${_NAME}
+        ${_NAME}-preload ${_NAME}
-        "LD_PRELOAD=libgeneric-tool.so;ROCP_REG_TEST_WRAP=1"
+        "LD_PRELOAD=${ROCPROFILER_REGISTER_MEMCHECK_PRELOAD_LIBRARY}:libgeneric-tool.so"
-        "${RRTE_PRELOAD_WRAP_PASS_REGEX}" "${RRTE_PRELOAD_WRAP_FAIL_REGEX}")
+        "${RRTE_PRELOAD_PASS_REGEX}" "${RRTE_PRELOAD_FAIL_REGEX}")
 
     rocp_register_add_test(
-        ${_NAME}-env-wrap ${_NAME}
+        ${_NAME}-env
-        "ROCP_TOOL_LIBRARIES=libgeneric-tool.so;ROCP_REG_TEST_WRAP=1"
+        ${_NAME}
-        "${RRTE_PRELOAD_WRAP_PASS_REGEX}" "${RRTE_PRELOAD_WRAP_FAIL_REGEX}")
+        "ROCP_TOOL_LIBRARIES=libgeneric-tool.so;${ROCPROFILER_REGISTER_MEMCHECK_PRELOAD_ENV}"
+        "${RRTE_PRELOAD_PASS_REGEX}"
+        "${RRTE_PRELOAD_FAIL_REGEX}")
+
+    rocp_register_add_test(
+        ${_NAME}-wrap ${_NAME}
+        "ROCP_REG_TEST_WRAP=1;${ROCPROFILER_REGISTER_MEMCHECK_PRELOAD_ENV}"
+        "${RRTE_WRAP_PASS_REGEX}" "${RRTE_WRAP_FAIL_REGEX}")
+
+    rocp_register_add_test(
+        ${_NAME}-preload-wrap
+        ${_NAME}
+        "LD_PRELOAD=${ROCPROFILER_REGISTER_MEMCHECK_PRELOAD_LIBRARY}:libgeneric-tool.so;ROCP_REG_TEST_WRAP=1"
+        "${RRTE_PRELOAD_WRAP_PASS_REGEX}"
+        "${RRTE_PRELOAD_WRAP_FAIL_REGEX}")
+
+    rocp_register_add_test(
+        ${_NAME}-env-wrap
+        ${_NAME}
+        "ROCP_TOOL_LIBRARIES=libgeneric-tool.so;ROCP_REG_TEST_WRAP=1;${ROCPROFILER_REGISTER_MEMCHECK_PRELOAD_ENV}"
+        "${RRTE_PRELOAD_WRAP_PASS_REGEX}"
+        "${RRTE_PRELOAD_WRAP_FAIL_REGEX}")
 
 endfunction()
 
@@ -458,7 +472,7 @@ set_tests_properties(
     test-secure-invalid-hsa-runtime
     PROPERTIES
         ENVIRONMENT
-        "LD_LIBRARY_PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/invalid:${CMAKE_LIBRARY_OUTPUT_DIRECTORY};ROCPROFILER_REGISTER_SECURE=1"
+        "LD_LIBRARY_PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/invalid:${CMAKE_LIBRARY_OUTPUT_DIRECTORY};ROCPROFILER_REGISTER_SECURE=1;${ROCPROFILER_REGISTER_MEMCHECK_PRELOAD_ENV}"
         LABELS
         "secure"
         WILL_FAIL
@@ -473,7 +487,7 @@ set_tests_properties(
     test-insecure-invalid-hsa-runtime
     PROPERTIES
         ENVIRONMENT
-        "LD_LIBRARY_PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/invalid:${CMAKE_LIBRARY_OUTPUT_DIRECTORY};ROCPROFILER_REGISTER_SECURE=0"
+        "LD_LIBRARY_PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/invalid:${CMAKE_LIBRARY_OUTPUT_DIRECTORY};ROCPROFILER_REGISTER_SECURE=0;${ROCPROFILER_REGISTER_MEMCHECK_PRELOAD_ENV}"
         LABELS
         "insecure")
 
@@ -492,7 +506,7 @@ set_tests_properties(
     test-force-rocprofiler-dlopen
     PROPERTIES
         ENVIRONMENT
-        "LD_LIBRARY_PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY};ROCPROFILER_REGISTER_FORCE_LOAD=1;ROCPROFILER_REGISTER_SECURE=yes;ROCPROFILER_REGISTER_VERBOSE=3"
+        "LD_LIBRARY_PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY};ROCPROFILER_REGISTER_FORCE_LOAD=1;ROCPROFILER_REGISTER_SECURE=yes;ROCPROFILER_REGISTER_VERBOSE=3;${ROCPROFILER_REGISTER_MEMCHECK_PRELOAD_ENV}"
         LABELS
         "dlopen;secure")
 
@@ -505,7 +519,7 @@ set_tests_properties(
     test-rocprofiler-register-library-base-path
     PROPERTIES
         ENVIRONMENT
-        "LD_LIBRARY_PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY};ROCPROFILER_REGISTER_LIBRARY=librocprofiler-sdk.so.0;ROCPROFILER_REGISTER_SECURE=yes;ROCPROFILER_REGISTER_VERBOSE=3;ROCPROFILER_REGISTER_MONOCHROME=true"
+        "LD_LIBRARY_PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY};ROCPROFILER_REGISTER_LIBRARY=librocprofiler-sdk.so.0;ROCPROFILER_REGISTER_SECURE=yes;ROCPROFILER_REGISTER_VERBOSE=3;ROCPROFILER_REGISTER_MONOCHROME=true;${ROCPROFILER_REGISTER_MEMCHECK_PRELOAD_ENV}"
         LABELS
         "dlopen;secure")
 
@@ -518,6 +532,6 @@ set_tests_properties(
     test-rocprofiler-register-library-absolute-path
     PROPERTIES
         ENVIRONMENT
-        "LD_LIBRARY_PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY};ROCPROFILER_REGISTER_LIBRARY=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/librocprofiler-sdk.so.0;ROCPROFILER_REGISTER_SECURE=yes;ROCPROFILER_REGISTER_VERBOSE=3;ROCPROFILER_REGISTER_MONOCHROME=true"
+        "LD_LIBRARY_PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY};ROCPROFILER_REGISTER_LIBRARY=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/librocprofiler-sdk.so.0;ROCPROFILER_REGISTER_SECURE=yes;ROCPROFILER_REGISTER_VERBOSE=3;ROCPROFILER_REGISTER_MONOCHROME=true;${ROCPROFILER_REGISTER_MEMCHECK_PRELOAD_ENV}"
         LABELS
         "dlopen;secure")