How to build NVidia binaries using CMake's new HIP language?

krasznaa · October 5, 2021, 9:40am

I’ve updated my code recently to make use of the “HIP language”, introduced in 3.21.

After some initial success on a host with an AMD card, I was now trying to build some code on a host that has an NVidia card. And had to realise that I don’t know how to do that. What environment/cache variable can one use to tell the build that it should use HIP_PLATFORM=nvidia? Unfortunately looking through the CMake source code I didn’t find any hint about this.

Cheers,
Attila

zackgalbreath · October 7, 2021, 3:52pm

I believe you’re correct, this isn’t working properly yet. I’ll let you know when we have a MR up so you can try it out if you’re interested.

krasznaa · October 7, 2021, 4:20pm

Sounds good! Yes, please let me know, I’ll give it a spin.

wme7 · April 12, 2023, 7:07am

Hello @zackgalbreath and @krasznaa, any progress on this topic?

I’m experiencing the same problem with a test library that I built on a AMD platform and then try to move it on NVIDIA platform.

I’m using CMake 3.26 at the moment, but perhaps there, is by now, a proper path to address hip compilations on NVIDIA platforms.

krasznaa · April 13, 2023, 11:57am

Hi Manuel,

Since in our code we don’t use HIP all too seriously (there’s just some basic infrastructure for using it, but no actual “algorithmic code”), I lost track of this. (Our build still uses my hand-written implementation for this.)

I would still be very keen on switching to a centrally managed implementation. So if there’s any update around this, I would also be very interested in knowing about it…

Cheers,
Attila

wme7 · April 26, 2023, 1:15pm

Hi Attila,

After scratching my head with this problem for the last week. I managed to archive a working solution

In this example, I demonstrate the only work around I was able to obtain in order to produce a truly cross-platform sample library using HIP/CUDA and CMake in a clean/simply manner.

I would appreciate any feedback/critic on this approach

kind regards,
Manuel

krasznaa · September 11, 2023, 2:02pm

Hi Manuel,

Sorry for never replying to this. Don’t have a good excuse, I just forgot.

That example is fine for what it’s doing, but it’s not really what this thread is about. One can use the runtime API of HIP fairly easily from CMake. Even without support being in CMake directly, one can use the code coming with ROCm.

https://rocm.docs.amd.com/en/latest/understand/cmake_packages.html#consuming-the-hip-api-in-c-code

Very similar to what you do in that example…

But what I’m after is building “device code” for an NVIDIA or AMD backend from the same HIP code. Currently I do this in a very fragile way in our code, with:

github.com

acts-project/vecmem/blob/main/cmake/hip/CMakeDetermineHIPCompiler.cmake#L106-L135


      
          # Decide how to do the build for the AMD (hcc) and NVidia (nvcc) backends.
          set( CMAKE_HIP_FLAGS_INIT "${CMAKE_INCLUDE_SYSTEM_FLAG_HIP}${HIP_INCLUDE_DIR}" )
          if( ( "${CMAKE_HIP_PLATFORM}" STREQUAL "hcc" ) OR
              ( "${CMAKE_HIP_PLATFORM}" STREQUAL "amd" ) )
             if( CMAKE_HIP_VERSION VERSION_LESS "3.7" )
                set( CMAKE_HIP_COMPILE_SOURCE_TYPE_FLAG "-x c++" )
             else()
                set( CMAKE_HIP_COMPILE_SOURCE_TYPE_FLAG "" )
             endif()
             set( CMAKE_HIP_IMPLICIT_LINK_LIBRARIES "${HIP_amdhip64_LIBRARY}" )
             set( CMAKE_HIP_COMPILE_OPTIONS_PIC "${CMAKE_CXX_COMPILE_OPTIONS_PIC}" )
             set( CMAKE_HIP_FLAGS_DEBUG_INIT "${CMAKE_CXX_FLAGS_DEBUG_INIT}" )
             set( CMAKE_HIP_FLAGS_RELEASE_INIT "${CMAKE_CXX_FLAGS_RELEASE_INIT}" )
             set( CMAKE_HIP_FLAGS_RELWITHDEBINFO_INIT
                "${CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT}" )
          elseif( ( "${CMAKE_HIP_PLATFORM}" STREQUAL "nvcc" ) OR
                  ( "${CMAKE_HIP_PLATFORM}" STREQUAL "nvidia" ) )
             set( CMAKE_HIP_COMPILE_SOURCE_TYPE_FLAG "-x cu" )
             find_package( CUDAToolkit QUIET REQUIRED )
             set( CMAKE_HIP_IMPLICIT_LINK_LIBRARIES "${CUDA_cudart_LIBRARY}" )

This file has been truncated. show original

But ideally I’d prefer CMake to provide a global CMAKE_HIP_PLATFORM global cache variable, and a target specific HIP_PLATFORM property, which could be used to control what backend any piece of HIP code would be compiled/linked for. And that would need some further development from somebody. Not sure exactly who…

Cheers,
Attila

wme7 · February 3, 2025, 10:05am

Thx @krasznaa for your sharing, I truly find your CMakeLists insightful !

Is my time to apologize because I just noticed your response until today.
(… and reactivated my forum account)

It is true, my goal is not just using HIP to build NVidia binaries, but to have a single code that can build AMD or NVidia binaries with CMake reliably. But, I wish my code to only support CUDA on NVidia and HIP on AMD platform, strictly.

Just as an update, I’m coming back to explore HIP for the second time, and I can see a lot of progress on HIP 6.2.4 although the support for HIP on NVidia still limited. However, this time I found an easier time by controlling the language and linkage properties of the sources. To the point of being able to generate NVidia binaries from HIP reliably.

Moreover, we can now specify a CMAKE_HIP_PLATFORM finally (like for a CUDA build). Here I leave an update of my old snippets to reflect what I have learned so far.