From 48ff39f531a0f4d9270e221570176b54518f0c23 Mon Sep 17 00:00:00 2001 From: nileshnegi Date: Fri, 22 May 2026 21:56:08 -0500 Subject: [PATCH 1/7] Embed git branch and commit hash in version string Print git branch and short commit hash alongside the existing version number whenever any TransferBench command is run, e.g.: TransferBench v1.67.00 (users/nileshnegi/add-version:6f5ea52) ... Both build paths are covered: - Makefile: shell-captures branch/commit via `git rev-parse` and passes them as -D string macros; uses -C so it works from any invocation directory; falls back to "unknown" when git is unavailable. - CMake: uses execute_process (same pattern as CollectBench) to capture branch/commit at configure time, wires them via target_compile_definitions, and emits a STATUS message during configure. Source: #ifndef guards in DisplayVersion() provide a safe fallback if the macros are somehow absent. Co-authored-by: Claude --- CMakeLists.txt | 34 ++++++++++++++++++++++++++++++++++ Makefile | 5 +++++ src/client/Client.cpp | 8 +++++++- 3 files changed, 46 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 0646b67..ecfbe3e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -140,6 +140,35 @@ message(STATUS "TransferBench version: ${VERSION_STRING}") project(TransferBench VERSION ${VERSION_STRING} LANGUAGES CXX) +# Git metadata (branch + short commit hash; graceful fallback if git is unavailable) +find_package(Git QUIET) +if(Git_FOUND) + execute_process( + COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref HEAD + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + OUTPUT_VARIABLE TB_GIT_BRANCH + OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET + RESULT_VARIABLE _tb_git_branch_result + ) + if(NOT _tb_git_branch_result EQUAL 0 OR TB_GIT_BRANCH STREQUAL "") + set(TB_GIT_BRANCH "unknown") + endif() + execute_process( + COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + OUTPUT_VARIABLE TB_GIT_COMMIT + OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET + RESULT_VARIABLE _tb_git_commit_result + ) + if(NOT _tb_git_commit_result EQUAL 0 OR TB_GIT_COMMIT STREQUAL "") + set(TB_GIT_COMMIT "unknown") + endif() +else() + set(TB_GIT_BRANCH "unknown") + set(TB_GIT_COMMIT "unknown") +endif() +message(STATUS "TransferBench ${VERSION_STRING} (${TB_GIT_BRANCH}:${TB_GIT_COMMIT})") + if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) message(STATUS "Setting build type to 'Release' as none was specified.") set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build." FORCE) @@ -497,6 +526,11 @@ if(POD_COMM_FOUND) target_compile_definitions(TransferBench PRIVATE POD_COMM_ENABLED) endif() +target_compile_definitions(TransferBench PRIVATE + TB_GIT_BRANCH="${TB_GIT_BRANCH}" + TB_GIT_COMMIT="${TB_GIT_COMMIT}" +) + check_cxx_compiler_flag(-parallel-jobs=12 HAVE_PARALLEL_JOBS) if(HAVE_PARALLEL_JOBS) message(STATUS "Enabling parallel compile jobs: -parallel-jobs=12") diff --git a/Makefile b/Makefile index 2f240b1..dadb4d3 100644 --- a/Makefile +++ b/Makefile @@ -297,6 +297,11 @@ ifeq ($(filter clean,$(MAKECMDGOALS)),) endif endif +# Git metadata (branch + short commit hash; graceful fallback if git is unavailable) +TB_GIT_BRANCH := $(shell git -C $(dir $(abspath $(firstword $(MAKEFILE_LIST)))) rev-parse --abbrev-ref HEAD 2>/dev/null || echo unknown) +TB_GIT_COMMIT := $(shell git -C $(dir $(abspath $(firstword $(MAKEFILE_LIST)))) rev-parse --short HEAD 2>/dev/null || echo unknown) +COMMON_FLAGS += -DTB_GIT_BRANCH='"$(TB_GIT_BRANCH)"' -DTB_GIT_COMMIT='"$(TB_GIT_COMMIT)"' + .PHONY : all clean all: TransferBench diff --git a/src/client/Client.cpp b/src/client/Client.cpp index 8ab5319..3074f3b 100644 --- a/src/client/Client.cpp +++ b/src/client/Client.cpp @@ -253,7 +253,13 @@ void DisplayVersion() case COMM_MPI: multiNodeMode = " (Multi-node via MPI)"; break; } - Print("TransferBench v%s.%s%s%s\n", VERSION, CLIENT_VERSION, support.c_str(), multiNodeMode.c_str()); +#ifndef TB_GIT_BRANCH +#define TB_GIT_BRANCH "unknown" +#endif +#ifndef TB_GIT_COMMIT +#define TB_GIT_COMMIT "unknown" +#endif + Print("TransferBench v%s.%s (%s:%s)%s%s\n", VERSION, CLIENT_VERSION, TB_GIT_BRANCH, TB_GIT_COMMIT, support.c_str(), multiNodeMode.c_str()); Print("=============================================================================================================\n"); } From 3a32b9c71a8b04918aa8cd822dd7dcecc9c61a44 Mon Sep 17 00:00:00 2001 From: nileshnegi Date: Fri, 22 May 2026 22:20:37 -0500 Subject: [PATCH 2/7] Add GIT_VERSION file fallback for packaged/tarball builds When TransferBench is distributed as a source tarball without the .git directory, git rev-parse fails and the version string would show "unknown:unknown". This adds a GIT_VERSION file (line 1: branch, line 2: commit) that both build paths read as a middle fallback: git rev-parse > GIT_VERSION > "unknown" The file is committed with placeholder "unknown" values. Packaging scripts should overwrite it with the real branch/hash before creating a tarball: printf '%s\n%s\n' "$(git rev-parse --abbrev-ref HEAD)" \ "$(git rev-parse --short HEAD)" > GIT_VERSION CMake: uses file(STRINGS ...) after the git block fails. Makefile: uses sed -n '1p'/'2p' in the same shell || chain. Co-authored-by: Claude --- CMakeLists.txt | 18 ++++++++++-------- GIT_VERSION | 2 ++ Makefile | 8 +++++--- 3 files changed, 17 insertions(+), 11 deletions(-) create mode 100644 GIT_VERSION diff --git a/CMakeLists.txt b/CMakeLists.txt index ecfbe3e..c72e88b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -140,7 +140,8 @@ message(STATUS "TransferBench version: ${VERSION_STRING}") project(TransferBench VERSION ${VERSION_STRING} LANGUAGES CXX) -# Git metadata (branch + short commit hash; graceful fallback if git is unavailable) +# Git metadata: branch + short commit hash +# Priority: git rev-parse > GIT_VERSION file (populated by packaging scripts) > "unknown" find_package(Git QUIET) if(Git_FOUND) execute_process( @@ -150,9 +151,6 @@ if(Git_FOUND) OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET RESULT_VARIABLE _tb_git_branch_result ) - if(NOT _tb_git_branch_result EQUAL 0 OR TB_GIT_BRANCH STREQUAL "") - set(TB_GIT_BRANCH "unknown") - endif() execute_process( COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} @@ -160,12 +158,16 @@ if(Git_FOUND) OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET RESULT_VARIABLE _tb_git_commit_result ) - if(NOT _tb_git_commit_result EQUAL 0 OR TB_GIT_COMMIT STREQUAL "") +endif() +if(NOT TB_GIT_BRANCH OR TB_GIT_BRANCH STREQUAL "") + if(EXISTS "${CMAKE_SOURCE_DIR}/GIT_VERSION") + file(STRINGS "${CMAKE_SOURCE_DIR}/GIT_VERSION" _tb_version_lines LIMIT_COUNT 2) + list(GET _tb_version_lines 0 TB_GIT_BRANCH) + list(GET _tb_version_lines 1 TB_GIT_COMMIT) + else() + set(TB_GIT_BRANCH "unknown") set(TB_GIT_COMMIT "unknown") endif() -else() - set(TB_GIT_BRANCH "unknown") - set(TB_GIT_COMMIT "unknown") endif() message(STATUS "TransferBench ${VERSION_STRING} (${TB_GIT_BRANCH}:${TB_GIT_COMMIT})") diff --git a/GIT_VERSION b/GIT_VERSION new file mode 100644 index 0000000..6abfba0 --- /dev/null +++ b/GIT_VERSION @@ -0,0 +1,2 @@ +unknown +unknown diff --git a/Makefile b/Makefile index dadb4d3..eeeef67 100644 --- a/Makefile +++ b/Makefile @@ -297,9 +297,11 @@ ifeq ($(filter clean,$(MAKECMDGOALS)),) endif endif -# Git metadata (branch + short commit hash; graceful fallback if git is unavailable) -TB_GIT_BRANCH := $(shell git -C $(dir $(abspath $(firstword $(MAKEFILE_LIST)))) rev-parse --abbrev-ref HEAD 2>/dev/null || echo unknown) -TB_GIT_COMMIT := $(shell git -C $(dir $(abspath $(firstword $(MAKEFILE_LIST)))) rev-parse --short HEAD 2>/dev/null || echo unknown) +# Git metadata (branch + short commit hash) +# Priority: git rev-parse > GIT_VERSION file (populated by packaging scripts) > "unknown" +_TB_DIR := $(dir $(abspath $(firstword $(MAKEFILE_LIST)))) +TB_GIT_BRANCH := $(shell git -C "$(_TB_DIR)" rev-parse --abbrev-ref HEAD 2>/dev/null || sed -n '1p' "$(_TB_DIR)GIT_VERSION" 2>/dev/null || echo unknown) +TB_GIT_COMMIT := $(shell git -C "$(_TB_DIR)" rev-parse --short HEAD 2>/dev/null || sed -n '2p' "$(_TB_DIR)GIT_VERSION" 2>/dev/null || echo unknown) COMMON_FLAGS += -DTB_GIT_BRANCH='"$(TB_GIT_BRANCH)"' -DTB_GIT_COMMIT='"$(TB_GIT_COMMIT)"' .PHONY : all clean From c0da2bc3cef52d38a497fa11eb7107cdd6aa75f2 Mon Sep 17 00:00:00 2001 From: nileshnegi Date: Fri, 22 May 2026 22:24:37 -0500 Subject: [PATCH 3/7] Automate GIT_VERSION stamping via CPACK_PRE_BUILD_SCRIPTS Previously the packaging workflow doc said to manually overwrite GIT_VERSION before creating a tarball. This automates it via CMake. At configure time, configure_file() stamps branch and commit into cmake/WriteGitVersion.cmake.in -> build/WriteGitVersion.cmake (values are baked in as string literals, no git dependency at package time). CPack then runs that script via CPACK_PRE_BUILD_SCRIPTS before collecting source files, so GIT_VERSION in the tarball always carries the real values captured at configure time. No manual steps required of the packager. Requires CMake >= 3.20 for CPACK_PRE_BUILD_SCRIPTS; silently skipped on older CMake (GIT_VERSION fallback still works, will just show "unknown"). Co-authored-by: Claude --- CMakeLists.txt | 18 ++++++++++++++++++ cmake/WriteGitVersion.cmake.in | 4 ++++ 2 files changed, 22 insertions(+) create mode 100644 cmake/WriteGitVersion.cmake.in diff --git a/CMakeLists.txt b/CMakeLists.txt index c72e88b..de16ce4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -671,6 +671,15 @@ if(BUILD_RELOCATABLE_PACKAGE) set(CPACK_ARCHIVE_FILE_NAME "${_tb_archive_name}") set(CPACK_PACKAGE_FILE_NAME "${_tb_archive_name}") + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.20") + configure_file( + cmake/WriteGitVersion.cmake.in + ${CMAKE_BINARY_DIR}/WriteGitVersion.cmake + @ONLY + ) + set(CPACK_PRE_BUILD_SCRIPTS "${CMAKE_BINARY_DIR}/WriteGitVersion.cmake") + endif() + set(CPACK_GENERATOR "DEB;RPM;TGZ") include(CPack) else() @@ -686,6 +695,15 @@ else() set(PACKAGE_NAME TB) set(LIBRARY_NAME TransferBench) + if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.20") + configure_file( + cmake/WriteGitVersion.cmake.in + ${CMAKE_BINARY_DIR}/WriteGitVersion.cmake + @ONLY + ) + set(CPACK_PRE_BUILD_SCRIPTS "${CMAKE_BINARY_DIR}/WriteGitVersion.cmake") + endif() + rocm_create_package( NAME ${LIBRARY_NAME} DESCRIPTION "TransferBench package" diff --git a/cmake/WriteGitVersion.cmake.in b/cmake/WriteGitVersion.cmake.in new file mode 100644 index 0000000..84e1207 --- /dev/null +++ b/cmake/WriteGitVersion.cmake.in @@ -0,0 +1,4 @@ +# Generated by CMakeLists.txt at configure time — do not edit. +# CPack runs this via CPACK_PRE_BUILD_SCRIPTS before creating the package, +# so source tarballs built without .git still carry the correct version info. +file(WRITE "@CMAKE_SOURCE_DIR@/GIT_VERSION" "@TB_GIT_BRANCH@\n@TB_GIT_COMMIT@\n") From 1e5ebb572c7882559f11ba76437b1c3bedac5bbb Mon Sep 17 00:00:00 2001 From: nileshnegi Date: Fri, 22 May 2026 23:21:25 -0500 Subject: [PATCH 4/7] [version] Stamp GIT_VERSION at configure time for CMake < 3.20 CPACK_PRE_BUILD_SCRIPTS requires CMake 3.20+. On older CMake the packaging block silently skipped stamping, leaving GIT_VERSION as "unknown" in any distributed source tarball. Fix: when CMake < 3.20 and git is available, write GIT_VERSION directly during configure while the branch/hash values are already in scope. The guard on NOT "unknown" ensures a tarball build (no git) never overwrites a correctly-stamped file with "unknown" values. For CMake >= 3.20 the CPACK_PRE_BUILD_SCRIPTS path is unchanged and stamps the file right before CPack collects source files. Co-authored-by: Claude --- CMakeLists.txt | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index de16ce4..57f40a9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -171,6 +171,14 @@ if(NOT TB_GIT_BRANCH OR TB_GIT_BRANCH STREQUAL "") endif() message(STATUS "TransferBench ${VERSION_STRING} (${TB_GIT_BRANCH}:${TB_GIT_COMMIT})") +# CMake < 3.20 has no CPACK_PRE_BUILD_SCRIPTS hook, so stamp GIT_VERSION now +# while git values are in scope. Only writes when git is present — avoids +# overwriting a correctly-stamped file in a tarball build where git is absent. +# For >= 3.20 this is done just before CPack runs; see the packaging block below. +if(CMAKE_VERSION VERSION_LESS "3.20" AND NOT TB_GIT_BRANCH STREQUAL "unknown") + file(WRITE "${CMAKE_SOURCE_DIR}/GIT_VERSION" "${TB_GIT_BRANCH}\n${TB_GIT_COMMIT}\n") +endif() + if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) message(STATUS "Setting build type to 'Release' as none was specified.") set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build." FORCE) From 8184d7f01c073570fc26f9b137bcc68d38bfcac4 Mon Sep 17 00:00:00 2001 From: nileshnegi Date: Fri, 22 May 2026 23:46:26 -0500 Subject: [PATCH 5/7] [version] Address Copilot review comments on git metadata MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three real issues fixed: Makefile: git shell calls outside clean guard Move the git metadata block inside ifeq($(filter clean,...)) so $(shell git rev-parse ...) is not invoked on every `make clean`. CMakeLists: duplicate find_package and inconsistent variable name The second find_package(Git QUIET) was redundant — git was already found at line 113 with GIT_FOUND/GIT_EXECUTABLE in scope. Remove the duplicate call and change if(Git_FOUND) to if(GIT_FOUND) for consistency with the rest of the file. CMakeLists: list(GET) crash on malformed GIT_VERSION list(GET) with an out-of-range index is a hard CMake error. Add a list(LENGTH) guard so a truncated or empty GIT_VERSION falls back to "unknown" rather than aborting configure. Also extend the fallback trigger to check TB_GIT_COMMIT as well as TB_GIT_BRANCH, so a commit hash that fails independently does not get baked in as an empty string. Co-authored-by: Claude --- CMakeLists.txt | 19 ++++++++++++++----- Makefile | 2 +- 2 files changed, 15 insertions(+), 6 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 57f40a9..de665a6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -142,8 +142,7 @@ project(TransferBench VERSION ${VERSION_STRING} LANGUAGES CXX) # Git metadata: branch + short commit hash # Priority: git rev-parse > GIT_VERSION file (populated by packaging scripts) > "unknown" -find_package(Git QUIET) -if(Git_FOUND) +if(GIT_FOUND) execute_process( COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref HEAD WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} @@ -159,11 +158,21 @@ if(Git_FOUND) RESULT_VARIABLE _tb_git_commit_result ) endif() -if(NOT TB_GIT_BRANCH OR TB_GIT_BRANCH STREQUAL "") +if(NOT TB_GIT_BRANCH OR TB_GIT_BRANCH STREQUAL "" OR + NOT TB_GIT_COMMIT OR TB_GIT_COMMIT STREQUAL "") if(EXISTS "${CMAKE_SOURCE_DIR}/GIT_VERSION") file(STRINGS "${CMAKE_SOURCE_DIR}/GIT_VERSION" _tb_version_lines LIMIT_COUNT 2) - list(GET _tb_version_lines 0 TB_GIT_BRANCH) - list(GET _tb_version_lines 1 TB_GIT_COMMIT) + list(LENGTH _tb_version_lines _tb_version_line_count) + if(_tb_version_line_count GREATER 0) + list(GET _tb_version_lines 0 TB_GIT_BRANCH) + else() + set(TB_GIT_BRANCH "unknown") + endif() + if(_tb_version_line_count GREATER 1) + list(GET _tb_version_lines 1 TB_GIT_COMMIT) + else() + set(TB_GIT_COMMIT "unknown") + endif() else() set(TB_GIT_BRANCH "unknown") set(TB_GIT_COMMIT "unknown") diff --git a/Makefile b/Makefile index eeeef67..db40ed2 100644 --- a/Makefile +++ b/Makefile @@ -295,7 +295,6 @@ ifeq ($(filter clean,$(MAKECMDGOALS)),) endif endif endif -endif # Git metadata (branch + short commit hash) # Priority: git rev-parse > GIT_VERSION file (populated by packaging scripts) > "unknown" @@ -303,6 +302,7 @@ _TB_DIR := $(dir $(abspath $(firstword $(MAKEFILE_LIST)))) TB_GIT_BRANCH := $(shell git -C "$(_TB_DIR)" rev-parse --abbrev-ref HEAD 2>/dev/null || sed -n '1p' "$(_TB_DIR)GIT_VERSION" 2>/dev/null || echo unknown) TB_GIT_COMMIT := $(shell git -C "$(_TB_DIR)" rev-parse --short HEAD 2>/dev/null || sed -n '2p' "$(_TB_DIR)GIT_VERSION" 2>/dev/null || echo unknown) COMMON_FLAGS += -DTB_GIT_BRANCH='"$(TB_GIT_BRANCH)"' -DTB_GIT_COMMIT='"$(TB_GIT_COMMIT)"' +endif .PHONY : all clean From 00195b27ab96028cf0e8a32c00261f151ba50c17 Mon Sep 17 00:00:00 2001 From: nileshnegi Date: Fri, 22 May 2026 23:51:18 -0500 Subject: [PATCH 6/7] [version] Restrict GIT_VERSION write to packaging configure paths The CMake < 3.20 fallback previously wrote GIT_VERSION into the source tree on every cmake invocation, dirtying the worktree even for normal non-packaging builds. Move the file(WRITE) into both packaging branches as an elseif on the existing >= 3.20 CPACK_PRE_BUILD_SCRIPTS block. GIT_VERSION is now only stamped when cmake is explicitly configured for packaging (BUILD_RELOCATABLE_PACKAGE or rocm_create_package paths), matching the intent of the >= 3.20 path. Co-authored-by: Claude --- CMakeLists.txt | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index de665a6..f584b07 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -180,13 +180,6 @@ if(NOT TB_GIT_BRANCH OR TB_GIT_BRANCH STREQUAL "" OR endif() message(STATUS "TransferBench ${VERSION_STRING} (${TB_GIT_BRANCH}:${TB_GIT_COMMIT})") -# CMake < 3.20 has no CPACK_PRE_BUILD_SCRIPTS hook, so stamp GIT_VERSION now -# while git values are in scope. Only writes when git is present — avoids -# overwriting a correctly-stamped file in a tarball build where git is absent. -# For >= 3.20 this is done just before CPack runs; see the packaging block below. -if(CMAKE_VERSION VERSION_LESS "3.20" AND NOT TB_GIT_BRANCH STREQUAL "unknown") - file(WRITE "${CMAKE_SOURCE_DIR}/GIT_VERSION" "${TB_GIT_BRANCH}\n${TB_GIT_COMMIT}\n") -endif() if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) message(STATUS "Setting build type to 'Release' as none was specified.") @@ -695,6 +688,8 @@ if(BUILD_RELOCATABLE_PACKAGE) @ONLY ) set(CPACK_PRE_BUILD_SCRIPTS "${CMAKE_BINARY_DIR}/WriteGitVersion.cmake") + elseif(NOT TB_GIT_BRANCH STREQUAL "unknown") + file(WRITE "${CMAKE_SOURCE_DIR}/GIT_VERSION" "${TB_GIT_BRANCH}\n${TB_GIT_COMMIT}\n") endif() set(CPACK_GENERATOR "DEB;RPM;TGZ") @@ -719,6 +714,8 @@ else() @ONLY ) set(CPACK_PRE_BUILD_SCRIPTS "${CMAKE_BINARY_DIR}/WriteGitVersion.cmake") + elseif(NOT TB_GIT_BRANCH STREQUAL "unknown") + file(WRITE "${CMAKE_SOURCE_DIR}/GIT_VERSION" "${TB_GIT_BRANCH}\n${TB_GIT_COMMIT}\n") endif() rocm_create_package( From b10a3a6ba42cf4e4382a305af3ad821b1f8258fb Mon Sep 17 00:00:00 2001 From: nileshnegi Date: Sat, 23 May 2026 00:16:16 -0500 Subject: [PATCH 7/7] [version] Use CMAKE_CURRENT_SOURCE_DIR consistently in git metadata block The version-patch block above already uses CMAKE_CURRENT_SOURCE_DIR for git operations; align the git metadata block and packaging writes to match. No behavior change for standalone builds; correct hygiene. Co-authored-by: Claude --- CMakeLists.txt | 12 ++++++------ cmake/WriteGitVersion.cmake.in | 2 +- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f584b07..73f961b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -145,14 +145,14 @@ project(TransferBench VERSION ${VERSION_STRING} LANGUAGES CXX) if(GIT_FOUND) execute_process( COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref HEAD - WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} OUTPUT_VARIABLE TB_GIT_BRANCH OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET RESULT_VARIABLE _tb_git_branch_result ) execute_process( COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD - WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} OUTPUT_VARIABLE TB_GIT_COMMIT OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET RESULT_VARIABLE _tb_git_commit_result @@ -160,8 +160,8 @@ if(GIT_FOUND) endif() if(NOT TB_GIT_BRANCH OR TB_GIT_BRANCH STREQUAL "" OR NOT TB_GIT_COMMIT OR TB_GIT_COMMIT STREQUAL "") - if(EXISTS "${CMAKE_SOURCE_DIR}/GIT_VERSION") - file(STRINGS "${CMAKE_SOURCE_DIR}/GIT_VERSION" _tb_version_lines LIMIT_COUNT 2) + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/GIT_VERSION") + file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/GIT_VERSION" _tb_version_lines LIMIT_COUNT 2) list(LENGTH _tb_version_lines _tb_version_line_count) if(_tb_version_line_count GREATER 0) list(GET _tb_version_lines 0 TB_GIT_BRANCH) @@ -689,7 +689,7 @@ if(BUILD_RELOCATABLE_PACKAGE) ) set(CPACK_PRE_BUILD_SCRIPTS "${CMAKE_BINARY_DIR}/WriteGitVersion.cmake") elseif(NOT TB_GIT_BRANCH STREQUAL "unknown") - file(WRITE "${CMAKE_SOURCE_DIR}/GIT_VERSION" "${TB_GIT_BRANCH}\n${TB_GIT_COMMIT}\n") + file(WRITE "${CMAKE_CURRENT_SOURCE_DIR}/GIT_VERSION" "${TB_GIT_BRANCH}\n${TB_GIT_COMMIT}\n") endif() set(CPACK_GENERATOR "DEB;RPM;TGZ") @@ -715,7 +715,7 @@ else() ) set(CPACK_PRE_BUILD_SCRIPTS "${CMAKE_BINARY_DIR}/WriteGitVersion.cmake") elseif(NOT TB_GIT_BRANCH STREQUAL "unknown") - file(WRITE "${CMAKE_SOURCE_DIR}/GIT_VERSION" "${TB_GIT_BRANCH}\n${TB_GIT_COMMIT}\n") + file(WRITE "${CMAKE_CURRENT_SOURCE_DIR}/GIT_VERSION" "${TB_GIT_BRANCH}\n${TB_GIT_COMMIT}\n") endif() rocm_create_package( diff --git a/cmake/WriteGitVersion.cmake.in b/cmake/WriteGitVersion.cmake.in index 84e1207..84acd58 100644 --- a/cmake/WriteGitVersion.cmake.in +++ b/cmake/WriteGitVersion.cmake.in @@ -1,4 +1,4 @@ # Generated by CMakeLists.txt at configure time — do not edit. # CPack runs this via CPACK_PRE_BUILD_SCRIPTS before creating the package, # so source tarballs built without .git still carry the correct version info. -file(WRITE "@CMAKE_SOURCE_DIR@/GIT_VERSION" "@TB_GIT_BRANCH@\n@TB_GIT_COMMIT@\n") +file(WRITE "@CMAKE_CURRENT_SOURCE_DIR@/GIT_VERSION" "@TB_GIT_BRANCH@\n@TB_GIT_COMMIT@\n")