GPA 4.1 Updates

Author: PLohrmannAMD

BUILD.md

@@ -1,20 +1,17 @@
 # GPUPerfAPI Build Instructions
 ---
 ## Table of Contents
-* [Cloning & Updating Dependent Repositories](#cloningupdating-dependent-repositories)
 * [Windows Build Information](#windows-build-information)
 * [Linux Build Information](#linux-build-information)
 * [PublicCounterCompiler Tool](#publiccountercompiler-tool)
 
-## Cloning & Updating Dependent Repositories
-GPUPerfAPI no longer uses git submodules to reference dependent repositories. Instead, you need to follow these instructions in
-order to clone and update any dependent repositories.
-
 #### Prerequisites
-  * Python 3.x, which can be installed from https://www.python.org/.
-  * CMake 3.19 and newer.
-    * For Windows, this can be downloaded from https://cmake.org/download/.
-    * For Linux, this can be installed using:
+  * Python 3.6 or newer which can be installed from https://www.python.org/.
+  * Vulkan SDK (optional)
+  * CMake 3.25 and newer which can be installed from https://cmake.org/download/ or your package manager.
+    * On Windows, this can also be installed using:
+      * `winget install cmake`
+    * On Linux, this can also be installed using:
       * `sudo apt-get install cmake`
   * To build the documentation:
     * Install Sphinx:
@@ -24,75 +21,100 @@ order to clone and update any dependent repositories.
     * Install spelling checker (optional)
       * `pip install pyenchant`
       * `pip install sphinxcontrib-spelling`
-    * **Note:** Be sure to add Python scripts to PATH in order to build documentation from prebuild scripts.
-
-#### Instructions
- * Simply execute the [pre_build.py](build/pre_build.py) Python script located in the GPA directory:
-   * `python build/pre_build.py`
- * This script will clone any dependent repositories that are not present on the system. If any of the dependent repositories are already
-present on the system, this script will instead do a "git pull" on those repositories to ensure that they are up to date. Please re-run
-this script everytime you pull new changes from GPA repository.
- * **Note:** For GPA 3.3 and newer, if you are updating an existing clone of the GPA repo from a GPA release prior to 3.3, you will first need to delete the Common/Lib/Ext/GoogleTest directory. Starting with GPA 3.3, GPA is now using a fork of the official GoogleTest repo. Failure to remove this directory will lead to Git errors when running [pre_build.py](build/pre_build.py) or [fetch_dependencies.py](scripts/fetch_dependencies.py).
- * **Note:** For GPA 3.11 and newer, the Common/ directory has been removed, and the external/Lib/Ext/GoogleTest will first need to be deleted instead.
- * This script will also download and execute the Vulkan SDK installer.
-   * On Windows, running the installer may require elevation. If you've previously installed the required Vulkan version, fetch_dependencies.py will simply copy the files from the default installation location into the correct place into the GPUPerfAPI directory tree.
-   * fetch_dependencies.py is set up to install the version of the Vulkan SDK which was used during development. If you want to use a newer version of the SDK, the following file will need to be updated:
-     * [fetch_dependencies.py](scripts/fetch_dependencies.py)
-   * By default the build will expect the Vulkan SDK to be found in a directory pointed to by the `VULKAN_SDK` environment variable. This environment variable is automatically set by the Windows SDK installer, but you may need to set it manually after running the Linux SDK installer. The Linux SDK includes a script called `setup-env.sh` to aid in setting this environment variable:
-     * `source ~/VulkanSDK/1.0.68.0/setup-env.sh` (adjust PATH as necessary)
- * This script also executes CMake to generate all required files to build GPA.
- * If you want to generate all CMake build files without trying to clone/pull dependent repos, you can add "--nofetch" to the [pre_build.py](build/pre_build.py) command line.
- * Additional switches that can be used with the [pre_build.py](build/pre_build.py) script:
-   * `--vs=[2015,2017,2019,2022]`: Specify the Visual Studio version for which to generate projects. Default is 2022.
-    * `--config=[debug,release]`: Specify the config for which to generate makefiles. Default is both. A specific config can only be specified on Linux. On Windows, both configs are always supported by the generated VS solution and project files.
-   * `--platform=[x86,x64]`: Specify the platform for which to generate build files. Default is both.
-   * `--clean`: Deletes CMakeBuild directory and regenerates all build files from scratch
-   * `--skipdx11`: Does not generate build files for DX11 version of GPA (Windows only)
-   * `--skipdx12`: Does not generate build files for DX12 version of GPA (Windows only)
-   * `--skipvulkan`: Does not generate build files for Vulkan version of GPA
-   * `--skipopengl`: Does not generate build files for OpenGL version of GPA
-   * `--skipopencl`: Does not generate build files for OpenCL version of GPA
-   * `--skiptests`: Does not generate build files for unit tests
-   * `--skipdocs`: Does not generate build files for documentation
-   * `--skipexamples`: Does not generate build files for GPA examples
-   * `--cmakecmd="CMD"`: Override the "cmake" command with "CMD"
+    * **Note:** Be sure to add Python scripts to PATH in order to build documentation from pre_build scripts.
 
 ## Windows Build Information
+The Windows projects each include a .rc file that embeds the VERSIONINFO resource into the final binary.
 
 ##### Prerequisites
- * Microsoft Visual Studio 2022
+ * Microsoft Visual Studio 2022 (17.13.5)
  * Within the Visual Studio Installer, the following workloads: 
    * Desktop development with C++
  * Within the Visual Studio Installer, the following individual components:
    * Windows 11 SDK (10.0.22621.0)
    * MSVC v143 - VS 2022 C++ x64/x86 build tools (latest)
    * C++ CMake tools for Windows
-   * C++ Clang Compiler for Windows (15.0.1)
-   * .NET Framework 4.6.2-4.8.1 SDKs and targeting packs
+   * C++ Clang Compiler for Windows (19.1.1)
+   * .NET SDK
+   * .NET 8.0 Runtime (Long Term Support)
    * C# and Visual Basic
    * C# and Visual Basic Roslyn compilers
 
-##### Build Instructions
- * Load build\win\vs2022_x64\GPUPerfAPI-x64.sln into Visual Studio to build the 64-bit version of GPA.
- * Load build\win\vs2022_x86\GPUPerfAPI-x86.sln into Visual Studio to build the 32-bit version of GPA.
- * After a successful build, the GPUPerfAPI binaries can be found in `gpu_performance_api\build\output\(configuration)` (e.g. gpu_performance_api\build\output\debug_x64).
-
-#### Additional Information
- * The Windows projects each include a .rc file that embeds the VERSIONINFO resource into the final binary. Internally within AMD, a Jenkins build system will dynamically update.
-   the build number. The version and build numbers can be manually updated by modifying the [gpa_version.h](source/gpu_perf_api_common/gpa_version.h) file.
-
 ## Linux Build Information
 
 ##### Prerequisites
  * Install the Mesa common development package:
    * `sudo apt-get install mesa-common-dev`
 
-##### Build Instructions
- * Execute "make" in the build/linux/make_debug_x64 to build the 64-bit debug version of GPA.
- * Execute "make" in the build/linux/make_release_x64 to build the 64-bit release version of GPA.
- * After a successful build, the GPUPerfAPI binaries can be found in `gpu_performance_api/build/output/$(Configuration)` (e.g. gpu_performance_api/build/output/debug_x64).
+#### Instructions (pre_build.py)
+
+GPA utilizes a python script pre_build.py to help users configure/setup the CMake build.
+```sh
+python build/pre_build.py --help
+```
+
+Additional switches that can be used with the pre_build.py script:
+--vs=[2022]: Specify the Visual Studio version for which to generate projects. Default is 2022.
+--config=[debug,release]: Specify the config for which to generate makefiles. Default is both. A specific config can only be specified on Linux. On Windows, both configs are always supported by the generated VS solution and project files.
+--clean: Delete cmake-generated directories created by this script
+--skipdx11: Does not generate build files for DX11 version of GPA (Windows only)
+--skipdx12: Does not generate build files for DX12 version of GPA (Windows only)
+--skipvulkan: Does not generate build files for Vulkan version of GPA
+--skipopengl: Does not generate build files for OpenGL version of GPA
+--skiptests: Does not generate build files for unit tests
+--skipdocs: Does not generate build files for documentation
+--skipexamples: Does not generate build files for GPA examples
+--cmakecmd="CMD": Override the "cmake" command with "CMD"
+
+By default the project will not build the generated CMake project (Although you can with `--build`).
+
+On Windows
+
+* Load build\win\vs2022_x64\GPUPerfAPI-x64.sln into Visual Studio to build the 64-bit version of GPA.
+* After a successful build, the GPUPerfAPI binaries can be found in gpu_performance_api\build\output\(configuration) (e.g. gpu_performance_api\build\output\debug_x64).
+
+You can use CMake to open the solution from the command line:
+```sh
+cmake --open build/win/vs2022_x64/
+```
+
+On Linux
+
+* Execute `make` in the build/linux/make_debug_x64 to build the 64-bit debug version of GPA.
+* Execute `make` in the build/linux/make_release_x64 to build the 64-bit release version of GPA.
+* After a successful build, the GPUPerfAPI binaries can be found in gpu_performance_api/build/output/$(Configuration) (e.g. gpu_performance_api/build/output/debug_x64).
+
+#### Instructions (CMake)
+
+You can also use CMake directly:
+
+On Windows
+
+Assuming you use `Visual Studio` which is the default `generator` on Windows
+
+```sh
+cmake -S . -B build/win/
+cmake --build build/win/ --config Debug
+```
+
+On Linux
+
+Assuming you use `Unix Makefiles` which is the default `generator` on Windows
+
+```sh
+cmake -S . -B build/linux -D CMAKE_BUILD_TYPE=Debug
+cmake --build build/linux
+```
+
+NOTES:
+- You may want to configure with `-Dskipdocs=ON` if you don't want to add python scripts to your PATH.
+- You may want to configure with `-Dskipcsharp=ON` if you don't want to download C# development tools.
+- CMake 3.30+ brings drastic performance improvements to FetchContent highly recommended for developers.
 
 ## PublicCounterCompiler Tool
+
+NOTE: The PublicCounterCompiler Tool requires using the `Visual Studio` generator due to `C#` usage!
+
 The PublicCounterCompiler Tool is a C# utility that will generate C++ code to define the public (or derived) counters.
 It takes as input text files contained in the [public_counter_compiler_input_files](source/public_counter_compiler_input_files) directory and
 outputs files in the [gpu_perf_api_counter_generator](source/auto_generated/gpu_perf_api_counter_generator), [gpu_perf_api_unit_tests](source/auto_generated/gpu_perf_api_unit_tests)

CMakeLists.txt

@@ -1,43 +1,88 @@
 ## Copyright (c) 2018-2025 Advanced Micro Devices, Inc. All rights reserved.
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.25)
+set(GPA_CMAKE_MODULES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/build/cmake_modules)
 
-set(DEPTH "./")
-
-message(STATUS "Generating project files for GPA....")
-set(GPA_CMAKE_MODULES_DIR   ${CMAKE_CURRENT_SOURCE_DIR}/build/cmake_modules)
-
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS OFF)
+set(GPA_MAJOR_VERSION 4)
+set(GPA_MINOR_VERSION 1)
+set(GPA_UPDATE_VERSION 0)
 
 if(NOT DEFINED build)
     set(GPA_BUILD_NUMBER 0)
 else()
     set(GPA_BUILD_NUMBER ${build})
 endif()
+set(ProjectSuffix "-x64")
+project(GPUPerfAPI${ProjectSuffix} VERSION ${GPA_MAJOR_VERSION}.${GPA_MINOR_VERSION}.${GPA_UPDATE_VERSION}.${GPA_BUILD_NUMBER} LANGUAGES C CXX)
 
-include(${GPA_CMAKE_MODULES_DIR}/gpa_version.cmake)
 include(${GPA_CMAKE_MODULES_DIR}/defs.cmake)
 include(${GPA_CMAKE_MODULES_DIR}/build_flags.cmake)
+include(${GPA_CMAKE_MODULES_DIR}/utils.cmake)
+include(${GPA_CMAKE_MODULES_DIR}/common.cmake)
+include(${GPA_CMAKE_MODULES_DIR}/fetch_dependencies.cmake)
 
-if (WIN32)
-    if (${build-32bit})
-        set(PlatformSuffix "-x86")
-    else()
-        set(PlatformSuffix "-x64")
-    endif()
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+if(NOT ${skiptests} AND NOT TARGET gtest)
+    enable_testing()
+    block()
+        set(CMAKE_FOLDER "Tests")
+        set(BUILD_GMOCK OFF)
+        set(INSTALL_GTEST OFF)
+        add_subdirectory(external/googletest EXCLUDE_FROM_ALL SYSTEM)
+        if (MSVC)
+            target_compile_options(gtest PRIVATE
+                "$<$<CONFIG:RELEASE>:/MT>"
+                "$<$<CONFIG:DEBUG>:/MTd>"
+            )
+        endif()
+    endblock()
 endif()
 
+add_subdirectory(external/adl)
+add_subdirectory(external/tsingleton)
+add_subdirectory(external/adl_util)
+add_subdirectory(external/dynamic_library_module)
+
+if(NOT ${skipdocs})
+    add_subdirectory(documentation/sphinx)
+endif()
+
+add_subdirectory(source)
+
 
-set(GPA_ALL_OPEN_SOURCE ON)
+set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
+set(CPACK_COMPONENTS_GROUPING IGNORE)
 
-if(${BUILD_ANDROID})
-    include (${GPA_CMAKE_MODULES_DIR}/android.cmake)
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/gpu_performance_api" DESTINATION ${GPA_INSTALL_INCLUDEDIR} COMPONENT GPUPerfAPI)
+install(FILES LICENSE.txt NOTICES.txt DESTINATION ${GPA_INSTALL_PREFIX} COMPONENT GPUPerfAPI)
+
+# Create the archive's suffix (ie: <GPUPerfAPI>[-Android|-Linux]-<version>.[zip|tgz])
+set(ARCHIVE_SUFFIX "")
+if (LINUX)
+    set(ARCHIVE_SUFFIX "${ARCHIVE_SUFFIX}-Linux")
+elseif (ANDROID)
+    set(ARCHIVE_SUFFIX "${ARCHIVE_SUFFIX}-Android")
+endif()
+set(ARCHIVE_SUFFIX "${ARCHIVE_SUFFIX}-${PROJECT_VERSION}")
+if (GPA_PACKAGE_SUFFIX)
+    set(ARCHIVE_SUFFIX "${ARCHIVE_SUFFIX}-${GPA_PACKAGE_SUFFIX}")
+endif()
+set(CPACK_PACKAGE_VENDOR "AMD")
+if (WIN32)
+    set(CPACK_GENERATOR "ZIP")
+else()
+    set(CPACK_GENERATOR "TGZ")
+    # By default CMake uses .tar.gz
+    set(CPACK_ARCHIVE_FILE_EXTENSION "tgz")
 endif()
+set(CPACK_PACKAGE_DIRECTORY ${GPA_OUTPUT_DIR})
+set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY OFF)
 
-## Define the GPA solution name
-project(GPUPerfAPI${PlatformSuffix} VERSION ${GPA_MAJOR_VERSION}.${GPA_MINOR_VERSION} LANGUAGES C CXX)
+set(CPACK_ARCHIVE_GPUPERFAPI_FILE_NAME "GPUPerfAPI${ARCHIVE_SUFFIX}")
 
-include(${GPA_CMAKE_MODULES_DIR}/targets.cmake)
+include(CPack)
 
-message(STATUS "Finished generating project files for GPA.")
+cpack_add_component(GPUPerfAPI)

CMakeSettings.json

@@ -1,4 +1,4 @@
-Copyright (c) 2016-2024 Advanced Micro Devices, Inc. All rights reserved.
+Copyright (c) 2016-2025 Advanced Micro Devices, Inc. All rights reserved.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

LICENSE.txt

@@ -80,7 +80,7 @@ License Text
 This program is freely distributable without licensing fees  and is provided without guarantee or warrantee expressed or  implied. This program is -not- in the public domain.
 
 
-google-googletest v1.8 (Apache-2.0)
+google-googletest v1.16 (Apache-2.0)
 Copyright 2009 Neal Norwitz All Rights Reserved.
 Portions Copyright 2009 Google Inc. All Rights Reserved.
 Apache License
@@ -121,7 +121,7 @@ Unless required by applicable law or agreed to in writing, software distributed
 See the License for the specific language governing permissions and limitations under the License.
 
 
-google-googletest v1.8.1 (BSD-3-Clause)
+google-googletest v1.16.0 (BSD-3-Clause)
 Copyright 2008, Google Inc.
 All rights reserved.
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: