diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index bcbfbaa4..e8d09821 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -93,7 +93,8 @@ ROOTTEST_ADD_TEST(
 if (ENABLE_ALPAKA_TESTS)
 
   string(TOLOWER "${ALPAKA_BACKEND}" _alpaka_backend)
-  if (NOT _alpaka_backend IN_LIST ALPAKA_BACKEND)
+  set(_alpaka_known_backends cuda cpu hip sycl)
+  if (NOT _alpaka_backend IN_LIST _alpaka_known_backends)
     message(FATAL_ERROR "Unsupported ALPAKA_BACKEND=${ALPAKA_BACKEND}")
   endif()
 
@@ -134,55 +135,78 @@ if (ENABLE_ALPAKA_TESTS)
   )
 
   ##########################################################################
-  # CUDA backend
+  # Backend selection
+  #
+  # The test sources are backend-agnostic (see alpaka/TestAlpakaCommon.h),
+  # only the toolchain, flags and libraries differ per backend.
   ##########################################################################
-  if (_alpaka_backend STREQUAL "cuda")
+  set(ALPAKA_TEST_SOURCES
+    alpaka/TestAlpakaLinear.cxx
+    alpaka/TestAlpakaConv.cxx
+    alpaka/TestAlpakaNormalization.cxx
+    alpaka/TestAlpakaElementwiseUnary.cxx
+    alpaka/TestAlpakaElementwiseBinaryLogic.cxx
+    alpaka/TestAlpakaReduce.cxx
+    alpaka/TestAlpakaShapeIndexing.cxx
+    alpaka/TestAlpakaGNN.cxx
+    alpaka/TestAlpakaPool.cxx
+    alpaka/TestAlpakaLowRank.cxx
+    alpaka/TestAlpakaKernelOnly.cxx
+    alpaka/TestAlpakaNormReduction.cxx
+    alpaka/TestAlpakaSequenceOps.cxx
+  )
 
+  if (_alpaka_backend STREQUAL "cuda")
     message(STATUS "Enabling Alpaka CUDA tests")
-
     enable_language(CUDA)
     find_package(CUDAToolkit REQUIRED)
+    set(ALPAKA_TEST_TARGET TestCustomModelsFromONNXForAlpakaCuda)
+    set_source_files_properties(${ALPAKA_TEST_SOURCES} PROPERTIES LANGUAGE CUDA)
+  elseif (_alpaka_backend STREQUAL "hip")
+    message(STATUS "Enabling Alpaka HIP tests")
+    enable_language(HIP)
+    set(ROCM_BASE "/opt/rocm" CACHE PATH "ROCm installation prefix")
+    set(ALPAKA_TEST_TARGET TestCustomModelsFromONNXForAlpakaHip)
+    set_source_files_properties(${ALPAKA_TEST_SOURCES} PROPERTIES LANGUAGE HIP)
+  elseif (_alpaka_backend STREQUAL "sycl")
+    message(FATAL_ERROR "ALPAKA_BACKEND=sycl is not implemented yet.")
+  elseif (_alpaka_backend STREQUAL "cpu")
+    message(FATAL_ERROR "ALPAKA_BACKEND=cpu is not implemented yet.")
+  endif()
 
-    set(ALPAKA_CUDA_TEST_SOURCES
-      alpaka/TestAlpakaLinear.cxx
-      alpaka/TestAlpakaConv.cxx
-      alpaka/TestAlpakaNormalization.cxx
-      alpaka/TestAlpakaElementwiseUnary.cxx
-      alpaka/TestAlpakaElementwiseBinaryLogic.cxx
-      alpaka/TestAlpakaReduce.cxx
-      alpaka/TestAlpakaShapeIndexing.cxx
-      alpaka/TestAlpakaGNN.cxx
-      alpaka/TestAlpakaPool.cxx
-      alpaka/TestAlpakaLowRank.cxx
-      alpaka/TestAlpakaKernelOnly.cxx
-      alpaka/TestAlpakaNormReduction.cxx
-      alpaka/TestAlpakaSequenceOps.cxx
-    )
+  ROOTTEST_GENERATE_EXECUTABLE(
+    ${ALPAKA_TEST_TARGET}
+    ${ALPAKA_TEST_SOURCES}
+    LIBRARIES SOFIE_core GTest::gtest GTest::gtest_main
+    FIXTURES_REQUIRED sofie-compile-models-onnx-alpaka;sofie-lowrank-emit
+    FIXTURES_SETUP sofie-test-models-onnx-alpaka-build
+  )
 
-    set_source_files_properties(
-      ${ALPAKA_CUDA_TEST_SOURCES}
-      PROPERTIES LANGUAGE CUDA
-    )
+  target_include_directories(
+    ${ALPAKA_TEST_TARGET} PRIVATE
+    ${CMAKE_CURRENT_BINARY_DIR}
+    ${alpaka_SOURCE_DIR}/include
+    ${sofieblas_SOURCE_DIR}/include
+    ${CMAKE_CURRENT_SOURCE_DIR}
+  )
 
-    ROOTTEST_GENERATE_EXECUTABLE(
-      TestCustomModelsFromONNXForAlpakaCuda
-      ${ALPAKA_CUDA_TEST_SOURCES}
-      LIBRARIES SOFIE_core GTest::gtest GTest::gtest_main
-      FIXTURES_REQUIRED sofie-compile-models-onnx-alpaka;sofie-lowrank-emit
-      FIXTURES_SETUP sofie-test-models-onnx-alpaka-build
-    )
+  target_compile_definitions(
+    ${ALPAKA_TEST_TARGET} PRIVATE
+    ALPAKA_HAS_STD_ATOMIC_REF
+  )
+
+  ##########################################################################
+  # Backend-specific flags and libraries
+  ##########################################################################
+  if (_alpaka_backend STREQUAL "cuda")
 
     target_include_directories(
-      TestCustomModelsFromONNXForAlpakaCuda PRIVATE
-      ${CMAKE_CURRENT_BINARY_DIR}
-      ${alpaka_SOURCE_DIR}/include
-      ${sofieblas_SOURCE_DIR}/include
+      ${ALPAKA_TEST_TARGET} PRIVATE
       ${CUDAToolkit_INCLUDE_DIRS}
-      ${CMAKE_CURRENT_SOURCE_DIR}
     )
 
     set_target_properties(
-      TestCustomModelsFromONNXForAlpakaCuda
+      ${ALPAKA_TEST_TARGET}
       PROPERTIES
         CUDA_SEPARABLE_COMPILATION OFF
         CUDA_STANDARD 20
@@ -190,13 +214,12 @@ if (ENABLE_ALPAKA_TESTS)
     )
 
     target_compile_definitions(
-      TestCustomModelsFromONNXForAlpakaCuda PRIVATE
+      ${ALPAKA_TEST_TARGET} PRIVATE
       ALPAKA_ACC_GPU_CUDA_ENABLED
-      ALPAKA_HAS_STD_ATOMIC_REF
     )
 
     target_compile_options(
-      TestCustomModelsFromONNXForAlpakaCuda PRIVATE
+      ${ALPAKA_TEST_TARGET} PRIVATE
       $<$<COMPILE_LANGUAGE:CUDA>:
         --extended-lambda
         --expt-relaxed-constexpr
@@ -220,25 +243,50 @@ if (ENABLE_ALPAKA_TESTS)
 
     # ROOT-compatible: plain signature only
     target_link_libraries(
-      TestCustomModelsFromONNXForAlpakaCuda
+      ${ALPAKA_TEST_TARGET}
       CUDA::cudart
       CUDA::cublas
       CUDA::cublasLt
     )
 
-    ROOTTEST_ADD_TEST(
-      TestCustomModelsFromONNXForAlpakaCuda
-      EXEC ./TestCustomModelsFromONNXForAlpakaCuda
-      FIXTURES_REQUIRED sofie-compile-models-onnx-alpaka;sofie-lowrank-emit;sofie-test-models-onnx-alpaka-build
+  elseif (_alpaka_backend STREQUAL "hip")
+
+    set_target_properties(
+      ${ALPAKA_TEST_TARGET}
+      PROPERTIES
+        HIP_STANDARD 20
+        HIP_STANDARD_REQUIRED ON
     )
 
-  elseif (_alpaka_backend STREQUAL "hip")
-    message(FATAL_ERROR
-      "ALPAKA_BACKEND=hip is not implemented yet (AMD GPU support is planned, "
-      "see test/alpaka/). Use ALPAKA_BACKEND=cuda for now.")
-  elseif (_alpaka_backend STREQUAL "sycl")
-    message(FATAL_ERROR "ALPAKA_BACKEND=sycl is not implemented yet.")
-  elseif (_alpaka_backend STREQUAL "cpu")
-    message(FATAL_ERROR "ALPAKA_BACKEND=cpu is not implemented yet.")
-  endif() # cuda backend
+    target_compile_definitions(
+      ${ALPAKA_TEST_TARGET} PRIVATE
+      ALPAKA_ACC_GPU_HIP_ENABLED
+    )
+
+    target_compile_options(
+      ${ALPAKA_TEST_TARGET} PRIVATE
+      -O2
+      -g
+      -fPIC
+      -pthread
+    )
+
+    target_include_directories(${ALPAKA_TEST_TARGET} PRIVATE ${ROCM_BASE}/include)
+    target_link_directories(${ALPAKA_TEST_TARGET} PRIVATE ${ROCM_BASE}/lib)
+
+    # ROOT-compatible: plain signature only
+    target_link_libraries(
+      ${ALPAKA_TEST_TARGET}
+      hipblaslt
+      hipblas
+      amdhip64
+    )
+
+  endif()
+
+  ROOTTEST_ADD_TEST(
+    ${ALPAKA_TEST_TARGET}
+    EXEC ./${ALPAKA_TEST_TARGET}
+    FIXTURES_REQUIRED sofie-compile-models-onnx-alpaka;sofie-lowrank-emit;sofie-test-models-onnx-alpaka-build
+  )
 endif()   # ENABLE_ALPAKA_TESTS
diff --git a/test/alpaka/TestAlpakaCommon.h b/test/alpaka/TestAlpakaCommon.h
index 39b6f8cf..f64b74d9 100644
--- a/test/alpaka/TestAlpakaCommon.h
+++ b/test/alpaka/TestAlpakaCommon.h
@@ -4,8 +4,6 @@
 #include <numeric>
 #include <cstddef>
 #include <alpaka/alpaka.hpp>
-#include <cuda_runtime.h>
-#include <nvml.h>
 #include "gtest/gtest.h"
 
 constexpr float DEFAULT_TOLERANCE = 1e-3f;
@@ -14,16 +12,30 @@ using Idx = std::size_t;
 using Dim = alpaka::DimInt<1>;
 using Ext1D = alpaka::Vec<Dim, Idx>;
 
+/* The backend under test is selected from the accelerator macro the build
+   defines, so the same test sources compile for every alpaka backend. */
+#if defined(ALPAKA_ACC_GPU_CUDA_ENABLED)
+using TestTag = alpaka::TagGpuCudaRt;
+#elif defined(ALPAKA_ACC_GPU_HIP_ENABLED)
+using TestTag = alpaka::TagGpuHipRt;
+#else
+#error "No alpaka backend enabled for the SOFIE tests"
+#endif
+
+using TestAcc = alpaka::TagToAcc<TestTag, Dim, Idx>;
+using TestDev = alpaka::Dev<TestAcc>;
+using TestQueue = alpaka::Queue<TestDev, alpaka::NonBlocking>;
+
 class SofieAlpakaTest : public ::testing::Test {
 protected:
     // Shared devices and platforms
     alpaka::PlatformCpu hostPlatform;
     alpaka::DevCpu host;
-    alpaka::PlatformCudaRt platform;
-    alpaka::DevCudaRt device;
-    alpaka::Queue<alpaka::DevCudaRt, alpaka::NonBlocking> queue;
+    alpaka::Platform<TestAcc> platform;
+    TestDev device;
+    TestQueue queue;
 
-    SofieAlpakaTest() 
+    SofieAlpakaTest()
         : hostPlatform{}
         , host(alpaka::getDevByIdx(hostPlatform, 0u))
         , platform{}
@@ -33,25 +45,25 @@ class SofieAlpakaTest : public ::testing::Test {
     }
 
     void SetUp() override {
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
     }
 
     void TearDown() override {
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
     }
 
     ~SofieAlpakaTest() override {
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
     }
 };
 
 // Helper: copy a host C-array into an Alpaka host buffer then to device.
 template <typename T>
-static alpaka::Buf<alpaka::DevCudaRt, T, Dim, Idx>
+static alpaka::Buf<TestDev, T, Dim, Idx>
 makeDeviceBuf(alpaka::DevCpu const& host,
-              alpaka::DevCudaRt const& device,
-              alpaka::Queue<alpaka::DevCudaRt, alpaka::NonBlocking>& queue,
+              TestDev const& device,
+              TestQueue& queue,
               const T* src, std::size_t n)
 {
    auto hbuf = alpaka::allocBuf<T, Idx>(host, Ext1D::all(Idx{n}));
diff --git a/test/alpaka/TestAlpakaConv.cxx b/test/alpaka/TestAlpakaConv.cxx
index d0577f5a..f39f3ddb 100644
--- a/test/alpaka/TestAlpakaConv.cxx
+++ b/test/alpaka/TestAlpakaConv.cxx
@@ -57,10 +57,10 @@ TEST_F(SofieAlpakaTest, ConvWithPadding)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(ConvWithPadding_ExpectedOutput::all_ones) / sizeof(float)}));
 
    {
-        SOFIE_ConvWithPadding::Session<alpaka::TagGpuCudaRt> session("ConvWithPadding_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ConvWithPadding::Session<TestTag> session("ConvWithPadding_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
 
@@ -94,10 +94,10 @@ TEST_F(SofieAlpakaTest, ConvWithoutPadding)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(ConvWithoutPadding_ExpectedOutput::all_ones) / sizeof(float)}));
 
    {
-        SOFIE_ConvWithoutPadding::Session<alpaka::TagGpuCudaRt> session("ConvWithoutPadding_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ConvWithoutPadding::Session<TestTag> session("ConvWithoutPadding_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
 
@@ -133,10 +133,10 @@ TEST_F(SofieAlpakaTest, ConvWithAutopadSameLower)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(ConvWithAutopadSameLower_ExpectedOutput::all_ones) / sizeof(float)}));
 
    {
-        SOFIE_ConvWithAutopadSameLower::Session<alpaka::TagGpuCudaRt> session("ConvWithAutopadSameLower_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ConvWithAutopadSameLower::Session<TestTag> session("ConvWithAutopadSameLower_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
 
@@ -169,10 +169,10 @@ TEST_F(SofieAlpakaTest, ConvWithAutopadSameUpper)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(ConvWithAutopadSameUpper_ExpectedOutput::all_ones) / sizeof(float)}));
 
    {
-        SOFIE_ConvWithAutopadSameUpper::Session<alpaka::TagGpuCudaRt> session("ConvWithAutopadSameUpper_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ConvWithAutopadSameUpper::Session<TestTag> session("ConvWithAutopadSameUpper_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
    }
@@ -206,10 +206,10 @@ TEST_F(SofieAlpakaTest, ConvWithStridesPadding)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(ConvWithStridesPadding_ExpectedOutput::all_ones) / sizeof(float)}));
 
    {
-        SOFIE_ConvWithStridesPadding::Session<alpaka::TagGpuCudaRt> session("ConvWithStridesPadding_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ConvWithStridesPadding::Session<TestTag> session("ConvWithStridesPadding_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
 
@@ -244,10 +244,10 @@ TEST_F(SofieAlpakaTest, ConvWithStridesNoPadding)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(ConvWithStridesNoPadding_ExpectedOutput::all_ones) / sizeof(float)}));
 
    {
-        SOFIE_ConvWithStridesNoPadding::Session<alpaka::TagGpuCudaRt> session("ConvWithStridesNoPadding_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ConvWithStridesNoPadding::Session<TestTag> session("ConvWithStridesNoPadding_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
 
@@ -283,10 +283,10 @@ TEST_F(SofieAlpakaTest, ConvWithAsymmetricPadding)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(ConvWithAsymmetricPadding_ExpectedOutput::all_ones) / sizeof(float)}));
 
    {
-        SOFIE_ConvWithAsymmetricPadding::Session<alpaka::TagGpuCudaRt> session("ConvWithAsymmetricPadding_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ConvWithAsymmetricPadding::Session<TestTag> session("ConvWithAsymmetricPadding_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
 
@@ -319,10 +319,10 @@ TEST_F(SofieAlpakaTest, ConvGroup2)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(ConvGroup2_ExpectedOutput::correct) / sizeof(float)}));
 
    {
-      SOFIE_ConvGroup2::Session<alpaka::TagGpuCudaRt> session("ConvGroup2_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_ConvGroup2::Session<TestTag> session("ConvGroup2_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(input_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -353,10 +353,10 @@ TEST_F(SofieAlpakaTest, ConvGroup4)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(ConvGroup4_ExpectedOutput::correct) / sizeof(float)}));
 
    {
-      SOFIE_ConvGroup4::Session<alpaka::TagGpuCudaRt> session("ConvGroup4_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_ConvGroup4::Session<TestTag> session("ConvGroup4_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(input_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -387,10 +387,10 @@ TEST_F(SofieAlpakaTest, ConvBatch4Group2)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(ConvBatch4Group2_ExpectedOutput::correct) / sizeof(float)}));
 
    {
-      SOFIE_ConvBatch4Group2::Session<alpaka::TagGpuCudaRt> session("ConvBatch4Group2_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_ConvBatch4Group2::Session<TestTag> session("ConvBatch4Group2_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(input_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -421,10 +421,10 @@ TEST_F(SofieAlpakaTest, ConvGroupBatch)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{nOut}));
 
    {
-      SOFIE_ConvGroupBatch::Session<alpaka::TagGpuCudaRt> session("ConvGroupBatch_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_ConvGroupBatch::Session<TestTag> session("ConvGroupBatch_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(input_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -454,10 +454,10 @@ TEST_F(SofieAlpakaTest, ConvBatch2)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(ConvBatch2_ExpectedOutput::correct) / sizeof(float)}));
 
    {
-      SOFIE_ConvBatch2::Session<alpaka::TagGpuCudaRt> session("ConvBatch2_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_ConvBatch2::Session<TestTag> session("ConvBatch2_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(input_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -488,10 +488,10 @@ TEST_F(SofieAlpakaTest, ConvBatch4)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(ConvBatch4_ExpectedOutput::correct) / sizeof(float)}));
 
    {
-      SOFIE_ConvBatch4::Session<alpaka::TagGpuCudaRt> session("ConvBatch4_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_ConvBatch4::Session<TestTag> session("ConvBatch4_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(input_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -522,10 +522,10 @@ TEST_F(SofieAlpakaTest, ConvBatch8)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(ConvBatch8_ExpectedOutput::correct) / sizeof(float)}));
 
    {
-      SOFIE_ConvBatch8::Session<alpaka::TagGpuCudaRt> session("ConvBatch8_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_ConvBatch8::Session<TestTag> session("ConvBatch8_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(input_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -557,10 +557,10 @@ TEST_F(SofieAlpakaTest, ConvWithBias)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(ConvWithBias_ExpectedOutput::all_ones) / sizeof(float)}));
 
    {
-        SOFIE_ConvWithBias::Session<alpaka::TagGpuCudaRt> session("ConvWithBias_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ConvWithBias::Session<TestTag> session("ConvWithBias_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
    }
@@ -593,10 +593,10 @@ TEST_F(SofieAlpakaTest, Conv1d)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(Conv1d_ExpectedOutput::all_ones) / sizeof(float)}));
 
    {
-        SOFIE_Conv1d::Session<alpaka::TagGpuCudaRt> session("Conv1d_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Conv1d::Session<TestTag> session("Conv1d_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
    }
@@ -629,10 +629,10 @@ TEST_F(SofieAlpakaTest, Conv3d)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(Conv3d_ExpectedOutput::all_ones) / sizeof(float)}));
 
    {
-        SOFIE_Conv3d::Session<alpaka::TagGpuCudaRt> session("Conv3d_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Conv3d::Session<TestTag> session("Conv3d_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
    }
@@ -664,10 +664,10 @@ TEST_F(SofieAlpakaTest, ConvWithDilation)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(ConvWithDilation_ExpectedOutput::all_ones) / sizeof(float)}));
 
    {
-        SOFIE_ConvWithDilation::Session<alpaka::TagGpuCudaRt> session("ConvWithDilation_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ConvWithDilation::Session<TestTag> session("ConvWithDilation_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
    }
diff --git a/test/alpaka/TestAlpakaElementwiseBinaryLogic.cxx b/test/alpaka/TestAlpakaElementwiseBinaryLogic.cxx
index 5b053f8a..cb80f250 100644
--- a/test/alpaka/TestAlpakaElementwiseBinaryLogic.cxx
+++ b/test/alpaka/TestAlpakaElementwiseBinaryLogic.cxx
@@ -75,10 +75,10 @@ TEST_F(SofieAlpakaTest, AddBroadcast1)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{20}));
    
    {
-       SOFIE_AddBroadcast1::Session<alpaka::TagGpuCudaRt> session;
+       SOFIE_AddBroadcast1::Session<TestTag> session;
       auto result = session.infer(A_d, B_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
 
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
@@ -114,10 +114,10 @@ TEST_F(SofieAlpakaTest, Equal)
     auto result_h = alpaka::allocBuf<uint8_t, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_Equal::Session<alpaka::TagGpuCudaRt> session("Equal_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Equal::Session<TestTag> session("Equal_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input1_d, input2_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -151,10 +151,10 @@ TEST_F(SofieAlpakaTest, LessOrEqual)
     auto result_h = alpaka::allocBuf<uint8_t, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_LessOrEqual::Session<alpaka::TagGpuCudaRt> session("LessOrEqual_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_LessOrEqual::Session<TestTag> session("LessOrEqual_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input1_d, input2_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -188,10 +188,10 @@ TEST_F(SofieAlpakaTest, GreaterOrEqual)
     auto result_h = alpaka::allocBuf<uint8_t, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_GreaterOrEqual::Session<alpaka::TagGpuCudaRt> session("GreaterOrEqual_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GreaterOrEqual::Session<TestTag> session("GreaterOrEqual_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input1_d, input2_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -225,10 +225,10 @@ TEST_F(SofieAlpakaTest, Greater)
     auto result_h = alpaka::allocBuf<uint8_t, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_Greater::Session<alpaka::TagGpuCudaRt> session("Greater_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Greater::Session<TestTag> session("Greater_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input1_d, input2_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -262,10 +262,10 @@ TEST_F(SofieAlpakaTest, Less)
     auto result_h = alpaka::allocBuf<uint8_t, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_Less::Session<alpaka::TagGpuCudaRt> session("Less_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Less::Session<TestTag> session("Less_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input1_d, input2_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -310,10 +310,10 @@ TEST_F(SofieAlpakaTest, Where)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{correct.size()}));
 
     {
-        SOFIE_Where::Session<alpaka::TagGpuCudaRt> session("Where_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Where::Session<TestTag> session("Where_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input1_d, input2_d, cond_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -343,10 +343,10 @@ TEST_F(SofieAlpakaTest, IsInf)
     auto result_h = alpaka::allocBuf<uint8_t, Idx>(host, Ext1D::all(Idx{N}));
 
     {
-        SOFIE_IsInf::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_IsInf::Session<TestTag> session;
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -376,10 +376,10 @@ TEST_F(SofieAlpakaTest, IsNaN)
     auto result_h = alpaka::allocBuf<uint8_t, Idx>(host, Ext1D::all(Idx{N}));
 
     {
-        SOFIE_IsNaN::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_IsNaN::Session<TestTag> session;
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -415,10 +415,10 @@ TEST_F(SofieAlpakaTest, Clip)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{N}));
 
     {
-        SOFIE_Clip::Session<alpaka::TagGpuCudaRt> session("Clip_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Clip::Session<TestTag> session("Clip_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -448,10 +448,10 @@ TEST_F(SofieAlpakaTest, Not)
     auto result_h = alpaka::allocBuf<uint8_t, Idx>(host, Ext1D::all(Idx{N}));
 
     {
-        SOFIE_Not::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_Not::Session<TestTag> session;
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -474,10 +474,10 @@ TEST_F(SofieAlpakaTest, Logic_And)
 
    auto result_h = alpaka::allocBuf<uint8_t, Idx>(host, Ext1D::all(Idx{N}));
    {
-      SOFIE_Logic_And::Session<alpaka::TagGpuCudaRt> session;
+      SOFIE_Logic_And::Session<TestTag> session;
       auto result = session.infer(d_a, d_b);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -499,10 +499,10 @@ TEST_F(SofieAlpakaTest, Logic_Or)
 
    auto result_h = alpaka::allocBuf<uint8_t, Idx>(host, Ext1D::all(Idx{N}));
    {
-      SOFIE_Logic_Or::Session<alpaka::TagGpuCudaRt> session;
+      SOFIE_Logic_Or::Session<TestTag> session;
       auto result = session.infer(d_a, d_b);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -524,10 +524,10 @@ TEST_F(SofieAlpakaTest, Logic_Xor)
 
    auto result_h = alpaka::allocBuf<uint8_t, Idx>(host, Ext1D::all(Idx{N}));
    {
-      SOFIE_Logic_Xor::Session<alpaka::TagGpuCudaRt> session;
+      SOFIE_Logic_Xor::Session<TestTag> session;
       auto result = session.infer(d_a, d_b);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -549,10 +549,10 @@ TEST_F(SofieAlpakaTest, Logic_BitwiseAnd)
 
    auto result_h = alpaka::allocBuf<int32_t, Idx>(host, Ext1D::all(Idx{N}));
    {
-      SOFIE_Logic_BitwiseAnd::Session<alpaka::TagGpuCudaRt> session;
+      SOFIE_Logic_BitwiseAnd::Session<TestTag> session;
       auto result = session.infer(d_a, d_b);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -574,10 +574,10 @@ TEST_F(SofieAlpakaTest, Logic_BitwiseOr)
 
    auto result_h = alpaka::allocBuf<int32_t, Idx>(host, Ext1D::all(Idx{N}));
    {
-      SOFIE_Logic_BitwiseOr::Session<alpaka::TagGpuCudaRt> session;
+      SOFIE_Logic_BitwiseOr::Session<TestTag> session;
       auto result = session.infer(d_a, d_b);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -599,10 +599,10 @@ TEST_F(SofieAlpakaTest, Logic_BitwiseXor)
 
    auto result_h = alpaka::allocBuf<int32_t, Idx>(host, Ext1D::all(Idx{N}));
    {
-      SOFIE_Logic_BitwiseXor::Session<alpaka::TagGpuCudaRt> session;
+      SOFIE_Logic_BitwiseXor::Session<TestTag> session;
       auto result = session.infer(d_a, d_b);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -622,10 +622,10 @@ TEST_F(SofieAlpakaTest, Logic_BitwiseNot)
 
    auto result_h = alpaka::allocBuf<int32_t, Idx>(host, Ext1D::all(Idx{N}));
    {
-      SOFIE_Logic_BitwiseNot::Session<alpaka::TagGpuCudaRt> session;
+      SOFIE_Logic_BitwiseNot::Session<TestTag> session;
       auto result = session.infer(d_input);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
diff --git a/test/alpaka/TestAlpakaElementwiseUnary.cxx b/test/alpaka/TestAlpakaElementwiseUnary.cxx
index 61f714bd..ee1da59f 100644
--- a/test/alpaka/TestAlpakaElementwiseUnary.cxx
+++ b/test/alpaka/TestAlpakaElementwiseUnary.cxx
@@ -40,10 +40,10 @@ TEST_F(SofieAlpakaTest, Sin)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{input.size()}));
 
     {
-        SOFIE_Sin::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_Sin::Session<TestTag> session;
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -75,10 +75,10 @@ TEST_F(SofieAlpakaTest, Cos)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{input.size()}));
 
     {
-        SOFIE_Cos::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_Cos::Session<TestTag> session;
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -106,10 +106,10 @@ TEST_F(SofieAlpakaTest, Abs)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{input.size()}));
 
     {
-        SOFIE_Abs::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_Abs::Session<TestTag> session;
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -138,10 +138,10 @@ TEST_F(SofieAlpakaTest, Sqrt)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_Sqrt::Session<alpaka::TagGpuCudaRt> session("Sqrt_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Sqrt::Session<TestTag> session("Sqrt_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -171,10 +171,10 @@ TEST_F(SofieAlpakaTest, Reciprocal)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_Reciprocal::Session<alpaka::TagGpuCudaRt> session("Reciprocal_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Reciprocal::Session<TestTag> session("Reciprocal_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -208,10 +208,10 @@ TEST_F(SofieAlpakaTest, Exp)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_Exp::Session<alpaka::TagGpuCudaRt> session("Exp_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Exp::Session<TestTag> session("Exp_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -241,10 +241,10 @@ TEST_F(SofieAlpakaTest, Log)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_Log::Session<alpaka::TagGpuCudaRt> session("Log_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Log::Session<TestTag> session("Log_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -278,10 +278,10 @@ TEST_F(SofieAlpakaTest, Neg)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_Neg::Session<alpaka::TagGpuCudaRt> session("Neg_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Neg::Session<TestTag> session("Neg_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -310,10 +310,10 @@ TEST_F(SofieAlpakaTest, Softplus)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{input.size()}));
 
     {
-        SOFIE_Softplus::Session<alpaka::TagGpuCudaRt> session("Softplus_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Softplus::Session<TestTag> session("Softplus_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -344,10 +344,10 @@ TEST_F(SofieAlpakaTest, Elu)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{nOut}));
 
     {
-        SOFIE_Elu::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_Elu::Session<TestTag> session;
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -377,10 +377,10 @@ TEST_F(SofieAlpakaTest, SeluNonDefaultCoeffs)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{nOut}));
 
     {
-        SOFIE_SeluNonDefaultCoeffs::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_SeluNonDefaultCoeffs::Session<TestTag> session;
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
diff --git a/test/alpaka/TestAlpakaGNN.cxx b/test/alpaka/TestAlpakaGNN.cxx
index 8f112515..5331fd01 100644
--- a/test/alpaka/TestAlpakaGNN.cxx
+++ b/test/alpaka/TestAlpakaGNN.cxx
@@ -36,10 +36,10 @@ TEST_F(SofieAlpakaTest, GNN_model)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{N_out}));
 
     {
-        SOFIE_GNN_model::Session<alpaka::TagGpuCudaRt> session("GNN_model_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GNN_model::Session<TestTag> session("GNN_model_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(x_d, ef_d, ei_d);
         alpaka::wait(session.queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
diff --git a/test/alpaka/TestAlpakaKernelOnly.cxx b/test/alpaka/TestAlpakaKernelOnly.cxx
index 95ae2054..fd617bda 100644
--- a/test/alpaka/TestAlpakaKernelOnly.cxx
+++ b/test/alpaka/TestAlpakaKernelOnly.cxx
@@ -5,8 +5,6 @@
 #include "TestAlpakaCommon.h"
 #include "LeakyRelu_KernelOnly_GPU_ALPAKA.hxx"
 
-using Acc = alpaka::TagToAcc<alpaka::TagGpuCudaRt, Dim, Idx>;
-
 TEST_F(SofieAlpakaTest, KernelOnlyLeakyRelu)
 {
     constexpr float TOLERANCE = DEFAULT_TOLERANCE;
@@ -18,12 +16,12 @@ TEST_F(SofieAlpakaTest, KernelOnlyLeakyRelu)
     auto output_d = alpaka::allocBuf<float, Idx>(device, Ext1D::all(Idx{n}));
 
     auto workDiv = sofie_workdiv<Dim, Idx>(Ext1D::all(Idx{n}));
-    auto task = alpaka::createTaskKernel<Acc>(workDiv, SOFIE_LeakyReluKernelOnly::LeakyReluKernel{},
+    auto task = alpaka::createTaskKernel<TestAcc>(workDiv, SOFIE_LeakyReluKernelOnly::LeakyReluKernel{},
                                                alpaka::getPtrNative(input_d), alpaka::getPtrNative(output_d),
                                                n, alpha);
     alpaka::enqueue(queue, task);
     alpaka::wait(queue);
-    cudaDeviceSynchronize();
+    alpaka::wait(device);
 
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{n}));
     alpaka::memcpy(queue, result_h, output_d);
diff --git a/test/alpaka/TestAlpakaLinear.cxx b/test/alpaka/TestAlpakaLinear.cxx
index d46e0609..f98f5877 100644
--- a/test/alpaka/TestAlpakaLinear.cxx
+++ b/test/alpaka/TestAlpakaLinear.cxx
@@ -25,10 +25,10 @@ TEST_F(SofieAlpakaTest, Linear64)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{640}));
 
    {
-      SOFIE_Linear_64::Session<alpaka::TagGpuCudaRt> session("Linear_64_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_Linear_64::Session<TestTag> session("Linear_64_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(A_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
 
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
@@ -66,10 +66,10 @@ TEST_F(SofieAlpakaTest, LinearWithLeakyRelu)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{24}));
    
    {
-      SOFIE_LinearWithLeakyRelu::Session<alpaka::TagGpuCudaRt> session;
+      SOFIE_LinearWithLeakyRelu::Session<TestTag> session;
       auto result = session.infer(A_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
 
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
@@ -102,10 +102,10 @@ TEST_F(SofieAlpakaTest, LinearWithSigmoid)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{24}));
    
    {
-      SOFIE_LinearWithSigmoid::Session<alpaka::TagGpuCudaRt> session("LinearWithSigmoid_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_LinearWithSigmoid::Session<TestTag> session("LinearWithSigmoid_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(A_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
 
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
diff --git a/test/alpaka/TestAlpakaLowRank.cxx b/test/alpaka/TestAlpakaLowRank.cxx
index a26e2cf3..361ffa7a 100644
--- a/test/alpaka/TestAlpakaLowRank.cxx
+++ b/test/alpaka/TestAlpakaLowRank.cxx
@@ -30,10 +30,10 @@ TEST_F(SofieAlpakaTest, LowRankMatchesFactorReconstruction)
    alpaka::memcpy(queue, A_d, A);
    alpaka::wait(queue);
 
-   SOFIE_LowRankGemmLRGpu::Session<alpaka::TagGpuCudaRt> session("LowRankGemm_LowRank_GPU_ALPAKA.dat");
+   SOFIE_LowRankGemmLRGpu::Session<TestTag> session("LowRankGemm_LowRank_GPU_ALPAKA.dat");
    auto result = session.infer(A_d);
    alpaka::wait(queue);
-   cudaDeviceSynchronize();
+   alpaka::wait(device);
 
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{kM * kN}));
    alpaka::memcpy(queue, result_h, result);
@@ -82,10 +82,10 @@ TEST_F(SofieAlpakaTest, DenseGpuUnaffectedByFeature)
    alpaka::memcpy(queue, A_d, A);
    alpaka::wait(queue);
 
-   SOFIE_LowRankGemmDenseGpu::Session<alpaka::TagGpuCudaRt> session("LowRankGemm_Dense_GPU_ALPAKA.dat");
+   SOFIE_LowRankGemmDenseGpu::Session<TestTag> session("LowRankGemm_Dense_GPU_ALPAKA.dat");
    auto result = session.infer(A_d);
    alpaka::wait(queue);
-   cudaDeviceSynchronize();
+   alpaka::wait(device);
 
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{kM * kN}));
    alpaka::memcpy(queue, result_h, result);
diff --git a/test/alpaka/TestAlpakaNormReduction.cxx b/test/alpaka/TestAlpakaNormReduction.cxx
index f9a9d1ca..5dd13d49 100644
--- a/test/alpaka/TestAlpakaNormReduction.cxx
+++ b/test/alpaka/TestAlpakaNormReduction.cxx
@@ -27,10 +27,10 @@ TEST_F(SofieAlpakaTest, RMSNorm)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_RMSNorm::Session<alpaka::TagGpuCudaRt> session("RMSNorm_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_RMSNorm::Session<TestTag> session("RMSNorm_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -45,7 +45,7 @@ TEST_F(SofieAlpakaTest, RMSNorm)
 
 TEST_F(SofieAlpakaTest, RMSNormResetState)
 {
-    SOFIE_RMSNorm::Session<alpaka::TagGpuCudaRt> session("RMSNorm_FromONNX_GPU_ALPAKA.dat");
+    SOFIE_RMSNorm::Session<TestTag> session("RMSNorm_FromONNX_GPU_ALPAKA.dat");
     // resetState must be callable; for a stateless operator it is a no-op
     EXPECT_NO_THROW(session.resetState(session.queue));
 }
@@ -62,10 +62,10 @@ TEST_F(SofieAlpakaTest, GroupNorm)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_GroupNorm::Session<alpaka::TagGpuCudaRt> session("GroupNorm_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GroupNorm::Session<TestTag> session("GroupNorm_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -90,10 +90,10 @@ TEST_F(SofieAlpakaTest, CumSumInclusive)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_CumSum::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_CumSum::Session<TestTag> session;
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -118,10 +118,10 @@ TEST_F(SofieAlpakaTest, CumSumExclusive)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_CumSumExclusive::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_CumSumExclusive::Session<TestTag> session;
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
diff --git a/test/alpaka/TestAlpakaNormalization.cxx b/test/alpaka/TestAlpakaNormalization.cxx
index 7ab0736d..93d0062a 100644
--- a/test/alpaka/TestAlpakaNormalization.cxx
+++ b/test/alpaka/TestAlpakaNormalization.cxx
@@ -27,10 +27,10 @@ TEST_F(SofieAlpakaTest, BatchNormalization)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_BatchNorm::Session<alpaka::TagGpuCudaRt> session("BatchNorm_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_BatchNorm::Session<TestTag> session("BatchNorm_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -64,10 +64,10 @@ TEST_F(SofieAlpakaTest, BatchNormalizationRelu)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_BatchNormRelu::Session<alpaka::TagGpuCudaRt> session("BatchNormRelu_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_BatchNormRelu::Session<TestTag> session("BatchNormRelu_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -100,10 +100,10 @@ TEST_F(SofieAlpakaTest, LayerNorm)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_LayerNorm::Session<alpaka::TagGpuCudaRt> session("LayerNorm_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_LayerNorm::Session<TestTag> session("LayerNorm_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -147,10 +147,10 @@ TEST_F(SofieAlpakaTest, LayerNormScaleBias)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_LayerNormScaleBias::Session<alpaka::TagGpuCudaRt> session("LayerNormScaleBias_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_LayerNormScaleBias::Session<TestTag> session("LayerNormScaleBias_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -188,10 +188,10 @@ TEST_F(SofieAlpakaTest, LayerNorm3D)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_LayerNorm3D::Session<alpaka::TagGpuCudaRt> session("LayerNorm3D_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_LayerNorm3D::Session<TestTag> session("LayerNorm3D_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
diff --git a/test/alpaka/TestAlpakaPool.cxx b/test/alpaka/TestAlpakaPool.cxx
index 993920af..63a6dfad 100644
--- a/test/alpaka/TestAlpakaPool.cxx
+++ b/test/alpaka/TestAlpakaPool.cxx
@@ -38,10 +38,10 @@ TEST_F(SofieAlpakaTest, MaxPool2d)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(MaxPool2d_ExpectedOutput::output) / sizeof(float)}));
 
    {
-      SOFIE_MaxPool2d::Session<alpaka::TagGpuCudaRt> session("MaxPool2d_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_MaxPool2d::Session<TestTag> session("MaxPool2d_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(input_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -78,10 +78,10 @@ TEST_F(SofieAlpakaTest, MaxPool1d)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(MaxPool1d_ExpectedOutput::output) / sizeof(float)}));
 
    {
-      SOFIE_MaxPool1d::Session<alpaka::TagGpuCudaRt> session("MaxPool1d_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_MaxPool1d::Session<TestTag> session("MaxPool1d_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(input_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -114,10 +114,10 @@ TEST_F(SofieAlpakaTest, MaxPool3d)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(MaxPool3d_ExpectedOutput::output) / sizeof(float)}));
 
    {
-      SOFIE_MaxPool3d::Session<alpaka::TagGpuCudaRt> session("MaxPool3d_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_MaxPool3d::Session<TestTag> session("MaxPool3d_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(input_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -160,10 +160,10 @@ TEST_F(SofieAlpakaTest, AvgPool)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(AvgPool_ExpectedOutput::output) / sizeof(float)}));
 
    {
-      SOFIE_AvgPool::Session<alpaka::TagGpuCudaRt> session("AvgPool_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_AvgPool::Session<TestTag> session("AvgPool_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(input_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -196,10 +196,10 @@ TEST_F(SofieAlpakaTest, AvgPoolPad)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(AvgPoolPad_ExpectedOutput::output) / sizeof(float)}));
 
    {
-      SOFIE_AvgPoolPad::Session<alpaka::TagGpuCudaRt> session("AvgPoolPad_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_AvgPoolPad::Session<TestTag> session("AvgPoolPad_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(input_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -233,10 +233,10 @@ TEST_F(SofieAlpakaTest, AvgPoolCountIncludePad)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(AvgPoolCountIncludePad_ExpectedOutput::output) / sizeof(float)}));
 
    {
-      SOFIE_AvgPoolCountIncludePad::Session<alpaka::TagGpuCudaRt> session("AvgPoolCountIncludePad_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_AvgPoolCountIncludePad::Session<TestTag> session("AvgPoolCountIncludePad_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(input_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -270,10 +270,10 @@ TEST_F(SofieAlpakaTest, GlobalAvgPool2d)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{sizeof(GlobalAvgPool2d_ExpectedOutput::output) / sizeof(float)}));
 
    {
-      SOFIE_GlobalAvgPool2d::Session<alpaka::TagGpuCudaRt> session("GlobalAvgPool2d_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_GlobalAvgPool2d::Session<TestTag> session("GlobalAvgPool2d_FromONNX_GPU_ALPAKA.dat");
       auto result = session.infer(input_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
diff --git a/test/alpaka/TestAlpakaReduce.cxx b/test/alpaka/TestAlpakaReduce.cxx
index 6005b38b..1ffdf82b 100644
--- a/test/alpaka/TestAlpakaReduce.cxx
+++ b/test/alpaka/TestAlpakaReduce.cxx
@@ -34,10 +34,10 @@ TEST_F(SofieAlpakaTest, ReduceMean)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_ReduceMean::Session<alpaka::TagGpuCudaRt> session("ReduceMean_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ReduceMean::Session<TestTag> session("ReduceMean_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -67,10 +67,10 @@ TEST_F(SofieAlpakaTest, ReduceProd)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_ReduceProd::Session<alpaka::TagGpuCudaRt> session("ReduceProd_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ReduceProd::Session<TestTag> session("ReduceProd_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -100,10 +100,10 @@ TEST_F(SofieAlpakaTest, ReduceSum)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{correct.size()}));
 
     {
-        SOFIE_ReduceSum::Session<alpaka::TagGpuCudaRt> session("ReduceSum_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ReduceSum::Session<TestTag> session("ReduceSum_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -132,10 +132,10 @@ TEST_F(SofieAlpakaTest, ReduceSumSquare)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{correct.size()}));
 
     {
-        SOFIE_ReduceSumSquare::Session<alpaka::TagGpuCudaRt> session("ReduceSumSquare_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ReduceSumSquare::Session<TestTag> session("ReduceSumSquare_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -165,10 +165,10 @@ TEST_F(SofieAlpakaTest, ReduceL2)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_ReduceL2::Session<alpaka::TagGpuCudaRt> session("ReduceL2_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ReduceL2::Session<TestTag> session("ReduceL2_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -215,10 +215,10 @@ TEST_F(SofieAlpakaTest, ReduceL2Large)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_ReduceL2Large::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_ReduceL2Large::Session<TestTag> session;
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -247,10 +247,10 @@ TEST_F(SofieAlpakaTest, ReduceMax)
 
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
     {
-        SOFIE_ReduceMax::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_ReduceMax::Session<TestTag> session;
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -284,10 +284,10 @@ TEST_F(SofieAlpakaTest, ReduceMax_axis0)
 
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
     {
-        SOFIE_ReduceMax_axis0::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_ReduceMax_axis0::Session<TestTag> session;
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -324,10 +324,10 @@ TEST_F(SofieAlpakaTest, ReduceMax_mid)
 
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
     {
-        SOFIE_ReduceMax_mid::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_ReduceMax_mid::Session<TestTag> session;
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
diff --git a/test/alpaka/TestAlpakaSequenceOps.cxx b/test/alpaka/TestAlpakaSequenceOps.cxx
index 93859ad9..6849d602 100644
--- a/test/alpaka/TestAlpakaSequenceOps.cxx
+++ b/test/alpaka/TestAlpakaSequenceOps.cxx
@@ -29,10 +29,10 @@ TEST_F(SofieAlpakaTest, SDPA)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_SDPA::Session<alpaka::TagGpuCudaRt> session("SDPA_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_SDPA::Session<TestTag> session("SDPA_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(q_d, k_d, v_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -61,10 +61,10 @@ TEST_F(SofieAlpakaTest, MambaScan)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_MambaScan::Session<alpaka::TagGpuCudaRt> session("MambaScan_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_MambaScan::Session<TestTag> session("MambaScan_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(u_d, delta_d, B_d, C_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -79,7 +79,7 @@ TEST_F(SofieAlpakaTest, MambaScan)
 
 TEST_F(SofieAlpakaTest, MambaScanResetState)
 {
-    SOFIE_MambaScan::Session<alpaka::TagGpuCudaRt> session("MambaScan_FromONNX_GPU_ALPAKA.dat");
+    SOFIE_MambaScan::Session<TestTag> session("MambaScan_FromONNX_GPU_ALPAKA.dat");
     EXPECT_NO_THROW(session.resetState(session.queue));
 }
 
@@ -98,10 +98,10 @@ TEST_F(SofieAlpakaTest, RWKV_WKV6)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_RWKV_WKV6::Session<alpaka::TagGpuCudaRt> session("RWKV_WKV6_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_RWKV_WKV6::Session<TestTag> session("RWKV_WKV6_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(r_d, k_d, v_d, w_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -116,7 +116,7 @@ TEST_F(SofieAlpakaTest, RWKV_WKV6)
 
 TEST_F(SofieAlpakaTest, RWKV_WKV6ResetState)
 {
-    SOFIE_RWKV_WKV6::Session<alpaka::TagGpuCudaRt> session("RWKV_WKV6_FromONNX_GPU_ALPAKA.dat");
+    SOFIE_RWKV_WKV6::Session<TestTag> session("RWKV_WKV6_FromONNX_GPU_ALPAKA.dat");
     EXPECT_NO_THROW(session.resetState(session.queue));
 }
 
@@ -133,10 +133,10 @@ TEST_F(SofieAlpakaTest, GriffinRGLRU)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_GriffinRGLRU::Session<alpaka::TagGpuCudaRt> session("GriffinRGLRU_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GriffinRGLRU::Session<TestTag> session("GriffinRGLRU_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(x_d, a_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -151,6 +151,6 @@ TEST_F(SofieAlpakaTest, GriffinRGLRU)
 
 TEST_F(SofieAlpakaTest, GriffinRGLRUResetState)
 {
-    SOFIE_GriffinRGLRU::Session<alpaka::TagGpuCudaRt> session("GriffinRGLRU_FromONNX_GPU_ALPAKA.dat");
+    SOFIE_GriffinRGLRU::Session<TestTag> session("GriffinRGLRU_FromONNX_GPU_ALPAKA.dat");
     EXPECT_NO_THROW(session.resetState(session.queue));
 }
diff --git a/test/alpaka/TestAlpakaShapeIndexing.cxx b/test/alpaka/TestAlpakaShapeIndexing.cxx
index f445b3a7..0e7cc1e0 100644
--- a/test/alpaka/TestAlpakaShapeIndexing.cxx
+++ b/test/alpaka/TestAlpakaShapeIndexing.cxx
@@ -92,10 +92,10 @@ TEST_F(SofieAlpakaTest, Transpose)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_Transpose::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_Transpose::Session<TestTag> session;
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
 
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
@@ -153,11 +153,11 @@ TEST_F(SofieAlpakaTest, Concat0D)
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{expected_output.size()}));
 
    {
-      SOFIE_Concat_0D::Session<alpaka::TagGpuCudaRt> session("Concat_0D_FromONNX_GPU_ALPAKA.dat");
+      SOFIE_Concat_0D::Session<TestTag> session("Concat_0D_FromONNX_GPU_ALPAKA.dat");
 
       auto result = session.infer(input_d);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
 
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
@@ -206,10 +206,10 @@ TEST_F(SofieAlpakaTest, ScatterElements)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{correct.size()}));
 
     {
-        SOFIE_ScatterElements::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_ScatterElements::Session<TestTag> session;
         auto result = session.infer(input_d, indices_d, updates_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
 
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
@@ -241,10 +241,10 @@ TEST_F(SofieAlpakaTest, ScatterND_Ex1)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{correct.size()}));
 
     {
-        SOFIE_ScatterND_Ex1::Session<alpaka::TagGpuCudaRt> session("ScatterND_Ex1_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ScatterND_Ex1::Session<TestTag> session("ScatterND_Ex1_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(data_d, indices_d, updates_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -277,10 +277,10 @@ TEST_F(SofieAlpakaTest, ScatterND_Ex2)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{correct.size()}));
 
     {
-        SOFIE_ScatterND_Ex2::Session<alpaka::TagGpuCudaRt> session("ScatterND_Ex2_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ScatterND_Ex2::Session<TestTag> session("ScatterND_Ex2_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(data_d, indices_d, updates_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -306,10 +306,10 @@ TEST_F(SofieAlpakaTest, ScatterND_NegativeIndices)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{correct.size()}));
 
     {
-        SOFIE_ScatterND_NegativeIndices::Session<alpaka::TagGpuCudaRt> session("ScatterND_NegativeIndices_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ScatterND_NegativeIndices::Session<TestTag> session("ScatterND_NegativeIndices_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(data_d, indices_d, updates_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -336,10 +336,10 @@ TEST_F(SofieAlpakaTest, ScatterND_2D)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{correct.size()}));
 
     {
-        SOFIE_ScatterND_2D::Session<alpaka::TagGpuCudaRt> session("ScatterND_2D_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ScatterND_2D::Session<TestTag> session("ScatterND_2D_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(data_d, indices_d, updates_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -369,10 +369,10 @@ TEST_F(SofieAlpakaTest, Split_0)
     auto result1_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{correct_output[1].size()}));
 
     {
-        SOFIE_Split_0::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_Split_0::Session<TestTag> session;
         auto [result0, result1] = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
 
         alpaka::memcpy(queue, result0_h, result0);
         alpaka::memcpy(queue, result1_h, result1);
@@ -408,10 +408,10 @@ TEST_F(SofieAlpakaTest, Split_1)
     auto result1_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{correct_output[1].size()}));
 
     {
-        SOFIE_Split_1::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_Split_1::Session<TestTag> session;
         auto [result0, result1] = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
 
         alpaka::memcpy(queue, result0_h, result0);
         alpaka::memcpy(queue, result1_h, result1);
@@ -448,10 +448,10 @@ TEST_F(SofieAlpakaTest, Split_2)
     auto result1_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{correct_output[1].size()}));
 
     {
-        SOFIE_Split_2::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_Split_2::Session<TestTag> session;
         auto [result0, result1] = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
 
         alpaka::memcpy(queue, result0_h, result0);
         alpaka::memcpy(queue, result1_h, result1);
@@ -507,9 +507,9 @@ TEST_F(SofieAlpakaTest, Tile5D)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_Tile5D::Session<alpaka::TagGpuCudaRt> session;
+        SOFIE_Tile5D::Session<TestTag> session;
         auto result = session.infer(input_d);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
 
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
@@ -541,10 +541,10 @@ TEST_F(SofieAlpakaTest, GatherAxis0)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_GatherAxis0::Session<alpaka::TagGpuCudaRt> session("GatherAxis0_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GatherAxis0::Session<TestTag> session("GatherAxis0_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
 
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
@@ -575,10 +575,10 @@ TEST_F(SofieAlpakaTest, GatherAxis1)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_GatherAxis1::Session<alpaka::TagGpuCudaRt> session("GatherAxis1_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GatherAxis1::Session<TestTag> session("GatherAxis1_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
 
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
@@ -609,10 +609,10 @@ TEST_F(SofieAlpakaTest, GatherAxis2)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_GatherAxis2::Session<alpaka::TagGpuCudaRt> session("GatherAxis2_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GatherAxis2::Session<TestTag> session("GatherAxis2_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
 
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
@@ -643,10 +643,10 @@ TEST_F(SofieAlpakaTest, GatherAxis3)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_GatherAxis3::Session<alpaka::TagGpuCudaRt> session("GatherAxis3_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GatherAxis3::Session<TestTag> session("GatherAxis3_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
 
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
@@ -677,10 +677,10 @@ TEST_F(SofieAlpakaTest, Gather2d)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_Gather2d::Session<alpaka::TagGpuCudaRt> session("Gather2d_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Gather2d::Session<TestTag> session("Gather2d_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
 
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
@@ -711,10 +711,10 @@ TEST_F(SofieAlpakaTest, GatherNegativeIndices)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_GatherNegativeIndices::Session<alpaka::TagGpuCudaRt> session("GatherNegativeIndices_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GatherNegativeIndices::Session<TestTag> session("GatherNegativeIndices_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
 
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
@@ -746,10 +746,10 @@ TEST_F(SofieAlpakaTest, ExpandSameSize)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_ExpandSameSize::Session<alpaka::TagGpuCudaRt> session("ExpandSameSize_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ExpandSameSize::Session<TestTag> session("ExpandSameSize_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
 
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
@@ -781,10 +781,10 @@ TEST_F(SofieAlpakaTest, ExpandDiffSize)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_ExpandDiffSize::Session<alpaka::TagGpuCudaRt> session("ExpandDiffSize_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_ExpandDiffSize::Session<TestTag> session("ExpandDiffSize_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
 
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
@@ -815,10 +815,10 @@ TEST_F(SofieAlpakaTest, GatherND_Ex1)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{expected.size()}));
 
     {
-        SOFIE_GatherND_Ex1::Session<alpaka::TagGpuCudaRt> session("GatherND_Ex1_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GatherND_Ex1::Session<TestTag> session("GatherND_Ex1_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -847,10 +847,10 @@ TEST_F(SofieAlpakaTest, GatherND_Ex2)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{expected.size()}));
 
     {
-        SOFIE_GatherND_Ex2::Session<alpaka::TagGpuCudaRt> session("GatherND_Ex2_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GatherND_Ex2::Session<TestTag> session("GatherND_Ex2_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -879,10 +879,10 @@ TEST_F(SofieAlpakaTest, GatherND_Ex3)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{expected.size()}));
 
     {
-        SOFIE_GatherND_Ex3::Session<alpaka::TagGpuCudaRt> session("GatherND_Ex3_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GatherND_Ex3::Session<TestTag> session("GatherND_Ex3_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -911,10 +911,10 @@ TEST_F(SofieAlpakaTest, GatherND_Ex4)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{expected.size()}));
 
     {
-        SOFIE_GatherND_Ex4::Session<alpaka::TagGpuCudaRt> session("GatherND_Ex4_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GatherND_Ex4::Session<TestTag> session("GatherND_Ex4_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -943,10 +943,10 @@ TEST_F(SofieAlpakaTest, GatherND_Ex5)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{expected.size()}));
 
     {
-        SOFIE_GatherND_Ex5::Session<alpaka::TagGpuCudaRt> session("GatherND_Ex5_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GatherND_Ex5::Session<TestTag> session("GatherND_Ex5_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -975,10 +975,10 @@ TEST_F(SofieAlpakaTest, GatherND_NegativeIndices)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{expected.size()}));
 
     {
-        SOFIE_GatherND_NegativeIndices::Session<alpaka::TagGpuCudaRt> session("GatherND_NegativeIndices_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GatherND_NegativeIndices::Session<TestTag> session("GatherND_NegativeIndices_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -1008,10 +1008,10 @@ TEST_F(SofieAlpakaTest, GatherND_Batch)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{expected.size()}));
 
     {
-        SOFIE_GatherND_Batch::Session<alpaka::TagGpuCudaRt> session("GatherND_Batch_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_GatherND_Batch::Session<TestTag> session("GatherND_Batch_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -1040,10 +1040,10 @@ TEST_F(SofieAlpakaTest, Slice)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_Slice::Session<alpaka::TagGpuCudaRt> session("Slice_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Slice::Session<TestTag> session("Slice_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -1073,10 +1073,10 @@ TEST_F(SofieAlpakaTest, Slice_Default_Axis)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_Slice_Default_Axis::Session<alpaka::TagGpuCudaRt> session("Slice_Default_Axis_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Slice_Default_Axis::Session<TestTag> session("Slice_Default_Axis_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -1106,10 +1106,10 @@ TEST_F(SofieAlpakaTest, Slice_Default_Steps)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_Slice_Default_Steps::Session<alpaka::TagGpuCudaRt> session("Slice_Default_Steps_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Slice_Default_Steps::Session<TestTag> session("Slice_Default_Steps_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -1139,10 +1139,10 @@ TEST_F(SofieAlpakaTest, Slice_Neg)
     auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{outputSize}));
 
     {
-        SOFIE_Slice_Neg::Session<alpaka::TagGpuCudaRt> session("Slice_Neg_FromONNX_GPU_ALPAKA.dat");
+        SOFIE_Slice_Neg::Session<TestTag> session("Slice_Neg_FromONNX_GPU_ALPAKA.dat");
         auto result = session.infer(input_d);
         alpaka::wait(queue);
-        cudaDeviceSynchronize();
+        alpaka::wait(device);
         alpaka::memcpy(queue, result_h, result);
         alpaka::wait(queue);
     }
@@ -1162,10 +1162,10 @@ TEST_F(SofieAlpakaTest, Trilu_upper)
 
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{N}));
    {
-      SOFIE_Trilu_upper::Session<alpaka::TagGpuCudaRt> session;
+      SOFIE_Trilu_upper::Session<TestTag> session;
       auto result = session.infer(d_input);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -1185,10 +1185,10 @@ TEST_F(SofieAlpakaTest, Trilu_lower)
 
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{N}));
    {
-      SOFIE_Trilu_lower::Session<alpaka::TagGpuCudaRt> session;
+      SOFIE_Trilu_lower::Session<TestTag> session;
       auto result = session.infer(d_input);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -1208,10 +1208,10 @@ TEST_F(SofieAlpakaTest, Trilu_k2)
 
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{N}));
    {
-      SOFIE_Trilu_k2::Session<alpaka::TagGpuCudaRt> session;
+      SOFIE_Trilu_k2::Session<TestTag> session;
       auto result = session.infer(d_input);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -1231,10 +1231,10 @@ TEST_F(SofieAlpakaTest, Trilu_kn1)
 
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{N}));
    {
-      SOFIE_Trilu_kn1::Session<alpaka::TagGpuCudaRt> session;
+      SOFIE_Trilu_kn1::Session<TestTag> session;
       auto result = session.infer(d_input);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }
@@ -1254,10 +1254,10 @@ TEST_F(SofieAlpakaTest, Trilu_3D)
 
    auto result_h = alpaka::allocBuf<float, Idx>(host, Ext1D::all(Idx{N}));
    {
-      SOFIE_Trilu_3D::Session<alpaka::TagGpuCudaRt> session;
+      SOFIE_Trilu_3D::Session<TestTag> session;
       auto result = session.infer(d_input);
       alpaka::wait(queue);
-      cudaDeviceSynchronize();
+      alpaka::wait(device);
       alpaka::memcpy(queue, result_h, result);
       alpaka::wait(queue);
    }