Reassemble society from the rubble

Author: chillenzer

CMakeLists.txt

@@ -39,6 +39,12 @@ set_target_properties(${PROJECT_NAME} PROPERTIES CXX_STANDARD 20)
 if(alpaka_ACC_GPU_CUDA_ENABLE)
   add_controlled("Gallatin")
 
+  if (TARGET gallatin::gallatin)
+    set(mallocMC_HAS_Gallatin_AVAILABLE YES)
+  else()
+    set(mallocMC_HAS_Gallatin_AVAILABLE NO)
+  endif()
+
   # Gallatin needs some fairly recent compute capability from CUDA.
   # CMake defaults to taking the oldest supported by the device
   # (https://cmake.org/cmake/help/latest/variable/CMAKE_CUDA_ARCHITECTURES.html)
@@ -56,9 +62,13 @@ if(alpaka_ACC_GPU_CUDA_ENABLE)
         "If the architecture set is too old, this can lead to compilation errors with Gallatin. "
         "If Gallatin is needed, please set CMAKE_CUDA_ARCHITECTURES to the correct value >= 70."
       )
+    set(mallocMC_HAS_Gallatin_AVAILABLE NO)
   endif()
 
-  target_link_libraries(${PROJECT_NAME} INTERFACE gallatin)
+  if (mallocMC_HAS_Gallatin_AVAILABLE)
+    target_link_libraries(${PROJECT_NAME} INTERFACE gallatin)
+    target_compile_definitions(${PROJECT_NAME} INTERFACE mallocMC_HAS_Gallatin_AVAILABLE)
+  endif()
 endif()
 
 # being a cross-platform target, we enforce standards conformance on MSVC

examples/getAvailableSlots/source/main.cpp

@@ -136,14 +136,17 @@ auto main(int /*argc*/, char* /*argv*/[]) -> int
     example03<FlatterScatter<FlatterScatterHeapConfig>, mallocMC::ReservePoolPolicies::AlpakaBuf<Acc>>();
     example03<Scatter<FlatterScatterHeapConfig>, mallocMC::ReservePoolPolicies::AlpakaBuf<Acc>>();
 #ifdef ALPAKA_ACC_GPU_CUDA_ENABLED
+#    ifdef mallocMC_HAS_Gallatin_AVAILABLE
     example03<
         mallocMC::CreationPolicies::GallatinCuda<>,
         mallocMC::ReservePoolPolicies::Noop,
         mallocMC::AlignmentPolicies::Noop>();
     // GallatinCuda already uses cudaSetLimits and we're not allowed to call it a second time.
     example03<OldMalloc, mallocMC::ReservePoolPolicies::Noop>();
+#    else
     // This should normally be:
-    //    example01<OldMalloc, mallocMC::ReservePoolPolicies::CudaSetLimits>();
+    example01<OldMalloc, mallocMC::ReservePoolPolicies::CudaSetLimits>();
+#    endif
 #else
     example03<OldMalloc, mallocMC::ReservePoolPolicies::Noop>();
 #endif

examples/vectorAdd/source/main.cpp

@@ -229,15 +229,19 @@ auto main(int /*argc*/, char* /*argv*/[]) -> int
 {
     example01<FlatterScatter<FlatterScatterHeapConfig>, mallocMC::ReservePoolPolicies::AlpakaBuf<Acc>>();
     example01<Scatter<FlatterScatterHeapConfig>, mallocMC::ReservePoolPolicies::AlpakaBuf<Acc>>();
+
 #ifdef ALPAKA_ACC_GPU_CUDA_ENABLED
+#    ifdef mallocMC_HAS_Gallatin_AVAILABLE
     example01<
         mallocMC::CreationPolicies::GallatinCuda<>,
         mallocMC::ReservePoolPolicies::Noop,
         mallocMC::AlignmentPolicies::Noop>();
     // GallatinCuda already uses cudaSetLimits and we're not allowed to call it a second time.
     example01<OldMalloc, mallocMC::ReservePoolPolicies::Noop>();
+#    else
     // This should normally be:
-    //    example01<OldMalloc, mallocMC::ReservePoolPolicies::CudaSetLimits>();
+    example01<OldMalloc, mallocMC::ReservePoolPolicies::CudaSetLimits>();
+#    endif
 #else
     example01<OldMalloc, mallocMC::ReservePoolPolicies::Noop>();
 #endif

include/mallocMC/creationPolicies/GallatinCuda.hpp

@@ -30,7 +30,7 @@
 
 #include <alpaka/alpaka.hpp>
 
-#ifdef ALPAKA_ACC_GPU_CUDA_ENABLED
+#ifdef mallocMC_HAS_Gallatin_AVAILABLE
 #    include <gallatin/allocators/gallatin.cuh>
 #else
 
@@ -45,6 +45,23 @@ namespace gallatin::allocators
         {
             return nullptr;
         }
+
+        template<typename... T>
+        auto malloc(T... /*unused*/) -> void*
+        {
+            // This always triggers but it depends on the template parameter, so it's only instantiated if we actually
+            // use it.
+            static_assert(sizeof...(T) < 0, "Attempt to use malloc of unavailable gallatin prototype.");
+            return nullptr;
+        }
+
+        template<typename... T>
+        auto free(T... /*unused*/)
+        {
+            // This always triggers but it depends on the template parameter, so it's only instantiated if we actually
+            // use it.
+            static_assert(sizeof...(T) < 0, "Attempt to use free of unavailable gallatin prototype.");
+        }
     };
 } // namespace gallatin::allocators
 
@@ -89,7 +106,7 @@ namespace mallocMC
             static constexpr auto providesAvailableSlots = false;
 
             template<typename AlpakaAcc>
-            ALPAKA_FN_ACC auto create(AlpakaAcc const& acc, uint32_t bytes) const -> void*
+            ALPAKA_FN_ACC auto create(AlpakaAcc const& /*acc*/, uint32_t bytes) const -> void*
             {
                 return heap->malloc(static_cast<size_t>(bytes));
             }
@@ -107,7 +124,7 @@ namespace mallocMC
 
             template<typename AlpakaAcc, typename AlpakaDevice, typename AlpakaQueue, typename T_DeviceAllocator>
             static void initHeap(
-                AlpakaDevice& dev,
+                AlpakaDevice& /*dev*/,
                 AlpakaQueue& queue,
                 T_DeviceAllocator* devAllocator,
                 void*,

include/mallocMC/reservePoolPolicies/CudaSetLimits.hpp

@@ -59,7 +59,7 @@ namespace mallocMC
         struct CudaSetLimits
         {
             template<typename AlpakaDev>
-            auto setMemPool(AlpakaDev const& dev, size_t memsize) -> void*
+            auto setMemPool(AlpakaDev const& /*dev*/, size_t memsize) -> void*
             {
                 cudaDeviceSetLimit(cudaLimitMallocHeapSize, memsize);
                 return nullptr;

test/unit/source/Allocator.cpp

@@ -51,7 +51,7 @@ TEST_CASE("Allocator")
         auto queue = alpaka::Queue<Acc, alpaka::Blocking>{dev};
 
         mallocMC::Allocator<
-            Acc,
+            alpaka::AccToTag<Acc>,
             mallocMC::CreationPolicies::FlatterScatter<>,
             mallocMC::DistributionPolicies::Noop,
             mallocMC::OOMPolicies::ReturnNull,