GPU: Rename OpenCL2 to OpenCL, now that we have only 1 OpenCL implementation

Author: davidrohr

GPU/GPUTracking/Base/GPUReconstruction.h

@@ -390,7 +390,7 @@ class GPUReconstruction
     void* mGPULib;
     void* mGPUEntry;
   };
-  static std::shared_ptr<LibraryLoader> sLibCUDA, sLibHIP, sLibOCL2;
+  static std::shared_ptr<LibraryLoader> sLibCUDA, sLibHIP, sLibOCL;
 
   static GPUReconstruction* GPUReconstruction_Create_CPU(const GPUSettingsDeviceBackend& cfg);
 };

GPU/GPUTracking/Base/GPUReconstructionAvailableBackends.template.h

@@ -14,4 +14,4 @@
 
 #cmakedefine CUDA_ENABLED
 #cmakedefine HIP_ENABLED
-#cmakedefine OPENCL2_ENABLED
+#cmakedefine OPENCL_ENABLED

GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx

@@ -102,9 +102,9 @@ std::shared_ptr<GPUReconstruction::LibraryLoader>* GPUReconstruction::GetLibrary
 #ifdef HIP_ENABLED
     return &sLibHIP;
 #endif
-  } else if (type == DeviceType::OCL2) {
-#ifdef OPENCL2_ENABLED
-    return &sLibOCL2;
+  } else if (type == DeviceType::OCL) {
+#ifdef OPENCL_ENABLED
+    return &sLibOCL;
 #endif
   } else {
     GPUError("Error: Invalid device type %u", (uint32_t)type);
@@ -128,7 +128,7 @@ GPUReconstruction* GPUReconstruction::CreateInstance(const char* type, bool forc
 
 std::shared_ptr<GPUReconstruction::LibraryLoader> GPUReconstruction::sLibCUDA(new GPUReconstruction::LibraryLoader("lib" LIBRARY_PREFIX "GPUTrackingCUDA" LIBRARY_EXTENSION, "GPUReconstruction_Create_CUDA"));
 std::shared_ptr<GPUReconstruction::LibraryLoader> GPUReconstruction::sLibHIP(new GPUReconstruction::LibraryLoader("lib" LIBRARY_PREFIX "GPUTrackingHIP" LIBRARY_EXTENSION, "GPUReconstruction_Create_HIP"));
-std::shared_ptr<GPUReconstruction::LibraryLoader> GPUReconstruction::sLibOCL2(new GPUReconstruction::LibraryLoader("lib" LIBRARY_PREFIX "GPUTrackingOCL2" LIBRARY_EXTENSION, "GPUReconstruction_Create_OCL2"));
+std::shared_ptr<GPUReconstruction::LibraryLoader> GPUReconstruction::sLibOCL(new GPUReconstruction::LibraryLoader("lib" LIBRARY_PREFIX "GPUTrackingOCL" LIBRARY_EXTENSION, "GPUReconstruction_Create_OCL"));
 
 GPUReconstruction::LibraryLoader::LibraryLoader(const char* lib, const char* func) : mLibName(lib), mFuncName(func), mGPULib(nullptr), mGPUEntry(nullptr) {}
 

GPU/GPUTracking/Base/opencl2/CMakeLists.txt

@@ -9,7 +9,7 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
-set(MODULE GPUTrackingOCL2)
+set(MODULE GPUTrackingOCL)
 enable_language(ASM)
 
 message(STATUS "Building GPUTracking with OpenCL 2 support")
@@ -21,7 +21,7 @@ else()
   set(GPUDIR ${CMAKE_SOURCE_DIR}/GPU/GPUTracking)
 endif()
 set(CL_SRC ${GPUDIR}/Base/opencl-common/GPUReconstructionOCL.cl)
-set(CL_BIN ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionOCL2Code)
+set(CL_BIN ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionOCLCode)
 
 set(OCL_FLAGS -Dcl_clang_storage_class_specifiers -cl-std=CLC++2021)
 if(NOT DEFINED GPUCA_NO_FAST_MATH OR NOT ${GPUCA_NO_FAST_MATH})
@@ -39,7 +39,7 @@ set(OCL_DEFINECL "-D$<JOIN:$<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS
 set(SRCS GPUReconstructionOCL2.cxx)
 set(HDRS GPUReconstructionOCL2.h GPUReconstructionOCL2Internals.h)
 
-if(OPENCL2_ENABLED_SPIRV) # BUILD OpenCL2 intermediate code for SPIR-V target
+if(OPENCL_ENABLED_SPIRV) # BUILD OpenCL intermediate code for SPIR-V target
   # executes clang to create llvm IL code
   # Add -fintegrated-objemitter once we switch to clang >= 17
   cmake_path(GET LLVM_SPIRV PARENT_PATH TMP_LLVM_SPIRV_PATH)
@@ -56,13 +56,13 @@ if(OPENCL2_ENABLED_SPIRV) # BUILD OpenCL2 intermediate code for SPIR-V target
       MAIN_DEPENDENCY ${CL_SRC}
       IMPLICIT_DEPENDS CXX ${CL_SRC}
       COMMAND_EXPAND_LISTS
-      COMMENT "Compiling OpenCL2 CL source file ${CL_SRC} to SPIRV ${CL_BIN}.spirv")
+      COMMENT "Compiling OpenCL CL source file ${CL_SRC} to SPIRV ${CL_BIN}.spirv")
 
   create_binary_resource(${CL_BIN}.spirv ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionOCLCode.spirv.o)
   set(SRCS ${SRCS} ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionOCLCode.spirv.o)
 endif()
 
-if(OPENCL2_ENABLED) # BUILD OpenCL2 source code for runtime compilation target
+if(OPENCL_ENABLED) # BUILD OpenCL source code for runtime compilation target
   # executes clang to preprocess
   add_custom_command(
       OUTPUT ${CL_BIN}.src
@@ -76,7 +76,7 @@ if(OPENCL2_ENABLED) # BUILD OpenCL2 source code for runtime compilation target
       MAIN_DEPENDENCY ${CL_SRC}
       IMPLICIT_DEPENDS CXX ${CL_SRC}
       COMMAND_EXPAND_LISTS
-      COMMENT "Preparing OpenCL2 CL source file for run time compilation ${CL_BIN}.src")
+      COMMENT "Preparing OpenCL CL source file for run time compilation ${CL_BIN}.src")
 
   create_binary_resource(${CL_BIN}.src ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionOCLCode.src.o)
   set(SRCS ${SRCS} ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionOCLCode.src.o)
@@ -122,7 +122,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   set(targetName ${MODULE})
 endif()
 
-if(OPENCL2_ENABLED_SPIRV)
-  target_compile_definitions(${targetName} PRIVATE OPENCL2_ENABLED_SPIRV)
+if(OPENCL_ENABLED_SPIRV)
+  target_compile_definitions(${targetName} PRIVATE OPENCL_ENABLED_SPIRV)
 endif()
 target_compile_definitions(${targetName} PRIVATE OCL_FLAGS=$<JOIN:${OCL_FLAGS},\ >)

GPU/GPUTracking/Base/opencl2/GPUReconstructionOCL2.cxx

@@ -9,14 +9,14 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file GPUReconstructionOCL2.cxx
+/// \file GPUReconstructionOCL.cxx
 /// \author David Rohr
 
 #define GPUCA_GPUTYPE_OPENCL
 #define __OPENCL_HOST__
 
 #include "GPUReconstructionOCL2.h"
-#include "GPUReconstructionOCL2Internals.h"
+#include "GPUReconstructionOCLInternals.h"
 #include "GPUReconstructionIncludes.h"
 
 using namespace GPUCA_NAMESPACE::gpu;
@@ -27,32 +27,32 @@ using namespace GPUCA_NAMESPACE::gpu;
 #include <cstdlib>
 
 #include "utils/qGetLdBinarySymbols.h"
-QGET_LD_BINARY_SYMBOLS(GPUReconstructionOCL2Code_src);
-#ifdef OPENCL2_ENABLED_SPIRV
-QGET_LD_BINARY_SYMBOLS(GPUReconstructionOCL2Code_spirv);
+QGET_LD_BINARY_SYMBOLS(GPUReconstructionOCLCode_src);
+#ifdef OPENCL_ENABLED_SPIRV
+QGET_LD_BINARY_SYMBOLS(GPUReconstructionOCLCode_spirv);
 #endif
 
-GPUReconstruction* GPUReconstruction_Create_OCL2(const GPUSettingsDeviceBackend& cfg) { return new GPUReconstructionOCL2(cfg); }
+GPUReconstruction* GPUReconstruction_Create_OCL(const GPUSettingsDeviceBackend& cfg) { return new GPUReconstructionOCL2(cfg); }
 
-GPUReconstructionOCL2Backend::GPUReconstructionOCL2Backend(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionOCL(cfg)
+GPUReconstructionOCLBackend::GPUReconstructionOCLBackend(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionOCL(cfg)
 {
 }
 
 template <class T, int32_t I, typename... Args>
-int32_t GPUReconstructionOCL2Backend::runKernelBackend(const krnlSetupArgs<T, I, Args...>& args)
+int32_t GPUReconstructionOCLBackend::runKernelBackend(const krnlSetupArgs<T, I, Args...>& args)
 {
   cl_kernel k = args.s.y.num > 1 ? getKernelObject<cl_kernel, T, I, true>() : getKernelObject<cl_kernel, T, I, false>();
   return std::apply([this, &args, &k](auto&... vals) { return runKernelBackendInternal(args.s, k, vals...); }, args.v);
 }
 
 template <class S, class T, int32_t I, bool MULTI>
-S& GPUReconstructionOCL2Backend::getKernelObject()
+S& GPUReconstructionOCLBackend::getKernelObject()
 {
   static uint32_t krnl = FindKernel<T, I>(MULTI ? 2 : 1);
   return mInternals->kernels[krnl].first;
 }
 
-int32_t GPUReconstructionOCL2Backend::GetOCLPrograms()
+int32_t GPUReconstructionOCLBackend::GetOCLPrograms()
 {
   char platform_version[256] = {};
   GPUFailedMsg(clGetPlatformInfo(mInternals->platform, CL_PLATFORM_VERSION, sizeof(platform_version), platform_version, nullptr));
@@ -63,17 +63,17 @@ int32_t GPUReconstructionOCL2Backend::GetOCLPrograms()
 
   const char* ocl_flags = GPUCA_M_STR(OCL_FLAGS);
 
-#ifdef OPENCL2_ENABLED_SPIRV // clang-format off
+#ifdef OPENCL_ENABLED_SPIRV // clang-format off
   if (ver >= 2.2f && !GetProcessingSettings().oclCompileFromSources) {
     GPUInfo("Reading OpenCL program from SPIR-V IL (Platform version %4.2f)", ver);
-    mInternals->program = clCreateProgramWithIL(mInternals->context, _binary_GPUReconstructionOCL2Code_spirv_start, _binary_GPUReconstructionOCL2Code_spirv_len, &ocl_error);
+    mInternals->program = clCreateProgramWithIL(mInternals->context, _binary_GPUReconstructionOCLCode_spirv_start, _binary_GPUReconstructionOCLCode_spirv_len, &ocl_error);
     ocl_flags = "";
   } else
 #endif // clang-format on
   {
     GPUInfo("Compiling OpenCL program from sources (Platform version %4.2f)", ver);
-    size_t program_sizes[1] = {_binary_GPUReconstructionOCL2Code_src_len};
-    char* programs_sources[1] = {_binary_GPUReconstructionOCL2Code_src_start};
+    size_t program_sizes[1] = {_binary_GPUReconstructionOCLCode_src_len};
+    char* programs_sources[1] = {_binary_GPUReconstructionOCLCode_src_start};
     mInternals->program = clCreateProgramWithSource(mInternals->context, (cl_uint)1, (const char**)&programs_sources, program_sizes, &ocl_error);
   }
 
@@ -113,7 +113,7 @@ int32_t GPUReconstructionOCL2Backend::GetOCLPrograms()
   return 0;
 }
 
-bool GPUReconstructionOCL2Backend::CheckPlatform(uint32_t i)
+bool GPUReconstructionOCLBackend::CheckPlatform(uint32_t i)
 {
   char platform_version[64] = {}, platform_vendor[64] = {};
   clGetPlatformInfo(mInternals->platforms[i], CL_PLATFORM_VERSION, sizeof(platform_version), platform_version, nullptr);

GPU/GPUTracking/Base/opencl2/GPUReconstructionOCL2.h

@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file GPUReconstructionOCL2.h
+/// \file GPUReconstructionOCL.h
 /// \author David Rohr
 
 #ifndef GPURECONSTRUCTIONOCL2_H
@@ -18,22 +18,22 @@
 #include "GPUReconstructionOCL.h"
 
 #ifdef _WIN32
-extern "C" __declspec(dllexport) GPUCA_NAMESPACE::gpu::GPUReconstruction* GPUReconstruction_Create_OCL2(const GPUCA_NAMESPACE::gpu::GPUSettingsDeviceBackend& cfg);
+extern "C" __declspec(dllexport) GPUCA_NAMESPACE::gpu::GPUReconstruction* GPUReconstruction_Create_OCL(const GPUCA_NAMESPACE::gpu::GPUSettingsDeviceBackend& cfg);
 #else
-extern "C" GPUCA_NAMESPACE::gpu::GPUReconstruction* GPUReconstruction_Create_OCL2(const GPUCA_NAMESPACE::gpu::GPUSettingsDeviceBackend& cfg);
+extern "C" GPUCA_NAMESPACE::gpu::GPUReconstruction* GPUReconstruction_Create_OCL(const GPUCA_NAMESPACE::gpu::GPUSettingsDeviceBackend& cfg);
 #endif
 
 namespace GPUCA_NAMESPACE::gpu
 {
-struct GPUReconstructionOCL2Internals;
+struct GPUReconstructionOCLInternals;
 
-class GPUReconstructionOCL2Backend : public GPUReconstructionOCL
+class GPUReconstructionOCLBackend : public GPUReconstructionOCL
 {
  public:
-  ~GPUReconstructionOCL2Backend() override = default;
+  ~GPUReconstructionOCLBackend() override = default;
 
  protected:
-  GPUReconstructionOCL2Backend(const GPUSettingsDeviceBackend& cfg);
+  GPUReconstructionOCLBackend(const GPUSettingsDeviceBackend& cfg);
 
   template <class T, int32_t I = 0, typename... Args>
   int32_t runKernelBackend(const krnlSetupArgs<T, I, Args...>& args);
@@ -44,7 +44,7 @@ class GPUReconstructionOCL2Backend : public GPUReconstructionOCL
   bool CheckPlatform(uint32_t i) override;
 };
 
-using GPUReconstructionOCL2 = GPUReconstructionKernels<GPUReconstructionOCL2Backend>;
+using GPUReconstructionOCL2 = GPUReconstructionKernels<GPUReconstructionOCLBackend>;
 } // namespace GPUCA_NAMESPACE::gpu
 
 #endif

GPU/GPUTracking/Base/opencl2/GPUReconstructionOCL2Internals.h

@@ -22,7 +22,7 @@ endif()
 include(cmake/helpers.cmake)
 
 if(ALIGPU_BUILD_TYPE STREQUAL "ALIROOT")
-  if(ENABLE_CUDA OR ENABLE_OPENCL2 OR ENABLE_HIP)
+  if(ENABLE_CUDA OR ENABLE_OPENCL OR ENABLE_HIP)
     include(FeatureSummary)
     find_package(O2GPU)
   else()
@@ -521,14 +521,14 @@ endif()
 target_compile_options(${targetName} PRIVATE -Wno-instantiation-after-specialization)
 
 # Add CMake recipes for GPU Tracking librararies
-if(CUDA_ENABLED OR OPENCL2_ENABLED OR HIP_ENABLED)
+if(CUDA_ENABLED OR OPENCL_ENABLED OR HIP_ENABLED)
   if(CMAKE_SYSTEM_NAME MATCHES Darwin)
     message(WARNING "GPU Tracking disabled on MacOS")
   else()
     if(CUDA_ENABLED)
       add_subdirectory(Base/cuda)
     endif()
-    if(OPENCL2_ENABLED)
+    if(OPENCL_ENABLED)
       add_subdirectory(Base/opencl-common)
       add_subdirectory(Base/opencl2)
     endif()

GPU/GPUTracking/CMakeLists.txt

@@ -147,8 +147,7 @@ class GPUDataTypes
                               CPU = 1,
                               CUDA = 2,
                               HIP = 3,
-                              OCL = 4,
-                              OCL2 = 5 };
+                              OCL = 4 };
   enum ENUM_CLASS GeneralStep { Prepare = 1,
                                 QA = 2 };
 
@@ -175,7 +174,7 @@ class GPUDataTypes
                               ITSTracks = 256 };
 
 #ifdef GPUCA_NOCOMPAT_ALLOPENCL
-  static constexpr const char* const DEVICE_TYPE_NAMES[] = {"INVALID", "CPU", "CUDA", "HIP", "OCL", "OCL2"};
+  static constexpr const char* const DEVICE_TYPE_NAMES[] = {"INVALID", "CPU", "CUDA", "HIP", "OCL"};
   static constexpr const char* const RECO_STEP_NAMES[] = {"TPC Transformation", "TPC Sector Tracking", "TPC Track Merging and Fit", "TPC Compression", "TRD Tracking", "ITS Tracking", "TPC dEdx Computation", "TPC Cluster Finding", "TPC Decompression", "Global Refit"};
   static constexpr const char* const GENERAL_STEP_NAMES[] = {"Prepare", "QA"};
   typedef bitfield<RecoStep, uint32_t> RecoStepField;

GPU/GPUTracking/DataTypes/GPUDataTypes.h

@@ -473,7 +473,7 @@ EndConfig()
 BeginConfig(GPUSettingsStandalone, configStandalone)
 AddOption(runGPU, uint8_t, 1, "", 'g', "Use GPU for processing", message("GPU processing enabled"), set(2))
 AddOptionSet(runGPU, uint8_t, 0, "", 'c', "Use CPU for processing", message("CPU enabled"))
-AddOption(gpuType, std::string, "AUTO", "", 0, "GPU type (CUDA / HIP / OCL / OCL2) or CPU or AUTO")
+AddOption(gpuType, std::string, "AUTO", "", 0, "GPU type (CUDA / HIP / OCL / OCL) or CPU or AUTO")
 AddOption(runGPUforce, bool, true, "", 0, "Force usage of the specified GPU device type, no CPU fallback")
 AddOption(noprompt, bool, true, "", 0, "Do prompt for keypress before exiting")
 AddOption(continueOnError, bool, false, "", 0, "Continue processing after an error")
@@ -537,7 +537,7 @@ AddOption(constBz, bool, false, "", 0, "force constant Bz for tests")
 AddOption(setMaxTimeBin, int32_t, -2, "", 0, "maximum time bin of continuous data, 0 for triggered events, -1 for automatic continuous mode, -2 for automatic continuous / triggered")
 AddOption(overrideNHbfPerTF, int32_t, 0, "", 0, "Overrides the number of HBF per TF if != 0")
 AddOption(overrideTPCTimeBinCur, int32_t, 0, "", 0, "Overrides TPC time bin cut if > 0")
-AddOption(deviceType, std::string, "CPU", "", 0, "Device type, CPU | CUDA | HIP | OCL2")
+AddOption(deviceType, std::string, "CPU", "", 0, "Device type, CPU | CUDA | HIP | OCL")
 AddOption(forceDeviceType, bool, true, "", 0, "force device type, otherwise allows fall-back to CPU")
 AddOption(synchronousProcessing, bool, false, "", 0, "Apply performance shortcuts for synchronous processing, disable unneeded steps")
 AddOption(dump, int32_t, 0, "", 0, "Dump events for standalone benchmark: 1 = dump events, 2 = dump events and skip processing in workflow")