1: #include <petsc/private/cupminterface.hpp>
  2: #include <petsc/private/petscadvancedmacros.h>

  4: // This file serves simply to store the definitions of all the static variables that we
  5: // DON'T have access to. Ones defined in PETSc-defined enum classes don't seem to have to
  6: // need this declaration...

  8: namespace Petsc
  9: {

 11: namespace device
 12: {

 14: namespace cupm
 15: {

 17: namespace impl
 18: {

 20: #define PETSC_CUPM_STATIC_VARIABLE_DEFN_EMPTY(...) static_assert(true, "")

 22: #define PETSC_CUPM_STATIC_VARIABLE_DEFN(theirs, DEVICE, ours) const decltype(theirs) InterfaceImpl<DeviceType::DEVICE>::ours

 24: #define PETSC_CUPM_STATIC_VARIABLE_DEFN_CLASS(type_name, DEVICE, ours) const typename InterfaceImpl<DeviceType::DEVICE>::type_name InterfaceImpl<DeviceType::DEVICE>::ours

 26: #define PETSC_CUPM_STATIC_VARIABLE_DEFN_EXACT(type_name, DEVICE, ours) const type_name InterfaceImpl<DeviceType::DEVICE>::ours

 28: // in case either one or the other don't agree on a name, you can specify all three here:
 29: //
 30: // PETSC_CUPM_DEFINE_STATIC_VARIABLE_EXACT(cudaSuccess, hipAllGood, cupmSuccess) ->
 31: // const decltype(cudaSuccess) Interface::cupmSuccess;
 32: // const decltype(hipAllGood)  Interface::cupmSuccess;
 33: #define PETSC_CUPM_DEFINE_STATIC_VARIABLE_EXACT(cuoriginal, hiporiginal, ours) \
 34:   PetscIfPetscDefined(HAVE_CUDA, PETSC_CUPM_STATIC_VARIABLE_DEFN, PETSC_CUPM_STATIC_VARIABLE_DEFN_EMPTY)(cuoriginal, CUDA, ours); \
 35:   PetscIfPetscDefined(HAVE_HIP, PETSC_CUPM_STATIC_VARIABLE_DEFN, PETSC_CUPM_STATIC_VARIABLE_DEFN_EMPTY)(hiporiginal, HIP, ours)

 37: // define the static variable in terms of the class typename
 38: #define PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME(type_name, ours) \
 39:   PetscIfPetscDefined(HAVE_CUDA, PETSC_CUPM_STATIC_VARIABLE_DEFN_CLASS, PETSC_CUPM_STATIC_VARIABLE_DEFN_EMPTY)(type_name, CUDA, ours); \
 40:   PetscIfPetscDefined(HAVE_HIP, PETSC_CUPM_STATIC_VARIABLE_DEFN_CLASS, PETSC_CUPM_STATIC_VARIABLE_DEFN_EMPTY)(type_name, HIP, ours)

 42: #define PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_EXACT_TYPENAME(type_name, ours) \
 43:   PetscIfPetscDefined(HAVE_CUDA, PETSC_CUPM_STATIC_VARIABLE_DEFN_EXACT, PETSC_CUPM_STATIC_VARIABLE_DEFN_EMPTY)(type_name, CUDA, ours); \
 44:   PetscIfPetscDefined(HAVE_HIP, PETSC_CUPM_STATIC_VARIABLE_DEFN_EXACT, PETSC_CUPM_STATIC_VARIABLE_DEFN_EMPTY)(type_name, HIP, ours)

 46: // if both CUDA and HIP agree on the same naming scheme, i.e., cudaSuccess and hipSuccess:
 47: //
 48: // PETSC_CUPM_DEFINE_STATIC_VARIABLE_MATCHING_SCHEME(Success) ->
 49: // const decltype(cudaSuccess) Interface::cupmSuccess;
 50: // const decltype(hipSuccess)  Interface::cupmSuccess;
 51: #define PETSC_CUPM_DEFINE_STATIC_VARIABLE_MATCHING_SCHEME(suffix) PETSC_CUPM_DEFINE_STATIC_VARIABLE_EXACT(PetscConcat(cuda, suffix), PetscConcat(hip, suffix), PetscConcat(cupm, suffix))

 53: // error codes
 54: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME(cupmError_t, cupmSuccess);
 55: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME(cupmError_t, cupmErrorNotReady);
 56: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME(cupmError_t, cupmErrorSetOnActiveProcess);
 57: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME(cupmError_t, cupmErrorNoDevice);
 58: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME(cupmError_t, cupmErrorDeviceAlreadyInUse);
 59: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME(cupmError_t, cupmErrorStubLibrary);

 61: // enums
 62: PETSC_CUPM_DEFINE_STATIC_VARIABLE_MATCHING_SCHEME(StreamDefault);
 63: PETSC_CUPM_DEFINE_STATIC_VARIABLE_MATCHING_SCHEME(StreamNonBlocking);
 64: PETSC_CUPM_DEFINE_STATIC_VARIABLE_MATCHING_SCHEME(DeviceMapHost);

 66: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME(cupmMemcpyKind_t, cupmMemcpyHostToDevice);
 67: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME(cupmMemcpyKind_t, cupmMemcpyDeviceToHost);
 68: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME(cupmMemcpyKind_t, cupmMemcpyDeviceToDevice);
 69: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME(cupmMemcpyKind_t, cupmMemcpyHostToHost);
 70: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME(cupmMemcpyKind_t, cupmMemcpyDefault);

 72: PETSC_CUPM_DEFINE_STATIC_VARIABLE_MATCHING_SCHEME(MemoryTypeHost);
 73: PETSC_CUPM_DEFINE_STATIC_VARIABLE_MATCHING_SCHEME(MemoryTypeDevice);
 74: // A vile, vile, hack. Would use PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME() with
 75: // cupmMemoryType_t however MSVC chokes on this with:
 76: //
 77: // \src\sys\objects\device\impls\cupm\cupminterface.cxx(69): error C2371: 'cupmMemoryTypeHost':
 78: // redefinition; different basic types
 79: // \include\petsc/private/cupminterface.hpp(314): note: see declaration of 'cupmMemoryTypeHost'
 80: // \src\sys\objects\device\impls\cupm\cupminterface.cxx(70): error C2371:
 81: // 'cupmMemoryTypeDevice': redefinition; different basic types
 82: // \include\petsc/private/cupminterface.hpp(315): note: see declaration of 'cupmMemoryTypeDevice'
 83: // \src\sys\objects\device\impls\cupm\cupminterface.cxx(71): error C2371:
 84: // 'cupmMemoryTypeManaged': redefinition; different basic types
 85: // \include\petsc/private/cupminterface.hpp(316): note: see declaration of
 86: // 'cupmMemoryTypeManaged'
 87: //
 88: // the only way to get it to compile is to use
 89: // PETSC_CUPM_DEFINE_STATIC_VARIABLE_MATCHING_SCHEME() but since cupmMemoryTypeManaged is
 90: // secretly hipMemoryTypeUnified that doesn't work unless we fudge it with preprocessor
 91: #define hipMemoryTypeManaged hipMemoryTypeUnified
 92: PETSC_CUPM_DEFINE_STATIC_VARIABLE_MATCHING_SCHEME(MemoryTypeManaged);

 94: PETSC_CUPM_DEFINE_STATIC_VARIABLE_MATCHING_SCHEME(EventDisableTiming);
 95: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_EXACT_TYPENAME(int, cupmHostAllocDefault);
 96: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_EXACT_TYPENAME(int, cupmHostAllocWriteCombined);

 98: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME(cupmMemPoolAttr, cupmMemPoolAttrReleaseThreshold);
 99: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME(cupmDeviceAttr_t, cupmDevAttrClockRate);
100: PETSC_CUPM_DEFINE_STATIC_VARIABLE_VIA_CLASS_TYPENAME(cupmDeviceAttr_t, cupmDevAttrMemoryClockRate);

102: #if PetscDefined(HAVE_CUDA)
103: template struct Interface<DeviceType::CUDA>;
104: #endif

106: #if PetscDefined(HAVE_HIP)
107: template struct Interface<DeviceType::HIP>;
108: #endif

110: } // namespace impl

112: } // namespace cupm

114: } // namespace device

116: } // namespace Petsc