GPU: improve some variable names, fix compiler warnings

Author: davidrohr

GPU/GPUTracking/Base/GPUReconstruction.cxx

@@ -1195,9 +1195,9 @@ int32_t GPUReconstruction::CheckErrorCodes(bool cpuOnly, bool forceShowErrors, s
   return retVal;
 }
 
-int32_t GPUReconstruction::GPUChkErrA(const int64_t error, const char* file, int32_t line, bool failOnError)
+int32_t GPUReconstruction::GPUChkErrA(const int64_t retval, const char* file, int32_t line, bool failOnError)
 {
-  if (error == 0 || !GPUChkErrInternal(error, file, line)) {
+  if (retval == 0 || !GPUChkErrInternal(retval, file, line)) {
     return 0;
   }
   if (failOnError) {

GPU/GPUTracking/Base/GPUReconstruction.h

@@ -98,11 +98,11 @@ class GPUReconstruction
   static constexpr GeometryType geometryType = GeometryType::O2;
 #endif
 
-  enum retValValue : uint32_t { ok = 0,
-                                error = 1,
-                                doExit = 2,
-                                nonFatalErrorCode = 3,
-                                abort = 4 };
+  enum retValValue : uint32_t { retOk = 0,
+                                retError = 1,
+                                retDoExit = 2,
+                                retNonFatalErrorCode = 3,
+                                retAbort = 4 };
   static DeviceType GetDeviceType(const char* type);
   enum InOutPointerType : uint32_t { CLUSTER_DATA = 0,
                                      SECTOR_OUT_TRACK = 1,
@@ -280,7 +280,7 @@ class GPUReconstruction
   void UpdateMaxMemoryUsed();
   int32_t EnqueuePipeline(bool terminate = false);
   GPUChain* GetNextChainInQueue();
-  virtual int32_t GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const { return 0; }
+  virtual int32_t GPUChkErrInternal(const int64_t retval, const char* file, int32_t line) const { return 0; }
 
   virtual int32_t registerMemoryForGPU_internal(const void* ptr, size_t size) = 0;
   virtual int32_t unregisterMemoryForGPU_internal(const void* ptr) = 0;

GPU/GPUTracking/Base/GPUReconstructionCPU.cxx

@@ -245,7 +245,7 @@ int32_t GPUReconstructionCPU::RunChains()
       retVal = mChains[i]->RunChain();
     }
   }
-  if (retVal != GPUReconstruction::retValValue::ok && retVal != GPUReconstruction::retValValue::doExit) {
+  if (retVal != GPUReconstruction::retValValue::retOk && retVal != GPUReconstruction::retValValue::retDoExit) {
     return retVal;
   }
   mTimerTotal.Stop();

GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h

@@ -42,7 +42,7 @@ class GPUReconstructionDeviceBase : public GPUReconstructionCPU
   virtual int32_t InitDevice_Runtime() = 0;
   int32_t ExitDevice() override;
   virtual int32_t ExitDevice_Runtime() = 0;
-  virtual int32_t GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const override = 0;
+  virtual int32_t GPUChkErrInternal(const int64_t retval, const char* file, int32_t line) const override = 0;
   int32_t registerMemoryForGPU_internal(const void* ptr, size_t size) override;
   int32_t unregisterMemoryForGPU_internal(const void* ptr) override;
   void unregisterRemainingRegisteredMemory();

GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu

@@ -84,9 +84,9 @@ GPUReconstructionCUDA::~GPUReconstructionCUDA()
 }
 
 static_assert(sizeof(cudaError_t) <= sizeof(int64_t) && cudaSuccess == 0);
-int32_t GPUReconstructionCUDA::GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const
+int32_t GPUReconstructionCUDA::GPUChkErrInternal(const int64_t retval, const char* file, int32_t line) const
 {
-  return internal::GPUReconstructionCUDAChkErr(error, file, line);
+  return internal::GPUReconstructionCUDAChkErr(retval, file, line);
 }
 
 GPUReconstruction* GPUReconstruction_Create_CUDA(const GPUSettingsDeviceBackend& cfg) { return new GPUReconstructionCUDA(cfg); }

GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h

@@ -42,7 +42,7 @@ class GPUReconstructionCUDA : public GPUReconstructionProcessing::KernelInterfac
   ~GPUReconstructionCUDA() override;
 
   void PrintKernelOccupancies() override;
-  virtual int32_t GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const override;
+  virtual int32_t GPUChkErrInternal(const int64_t retval, const char* file, int32_t line) const override;
 
   template <class T, int32_t I = 0, typename... Args>
   void runKernelBackend(const krnlSetupTime& _xyz, const Args&... args);

GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAHelpers.inc

@@ -20,12 +20,12 @@
 
 namespace o2::gpu::internal
 {
-int32_t __attribute__((weak)) GPUReconstructionCUDAChkErr(const int64_t error, const char* file, int32_t line)
+int32_t __attribute__((weak)) GPUReconstructionCUDAChkErr(const int64_t retVal, const char* file, int32_t line)
 {
-  if (error != cudaSuccess) {
-    GPUError("CUDA Error: %ld / %s (%s:%d)", error, cudaGetErrorString((cudaError_t)error), file, line);
+  if (retVal != cudaSuccess) {
+    GPUError("CUDA Error: %ld / %s (%s:%d)", retVal, cudaGetErrorString((cudaError_t)retVal), file, line);
   }
-  return error != cudaSuccess;
+  return retVal != cudaSuccess;
 }
 } // namespace o2::gpu::internal
 

GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx

@@ -52,13 +52,13 @@ GPUReconstructionOCL::~GPUReconstructionOCL()
 }
 
 static_assert(sizeof(cl_int) <= sizeof(int64_t) && CL_SUCCESS == 0);
-int32_t GPUReconstructionOCL::GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const
+int32_t GPUReconstructionOCL::GPUChkErrInternal(const int64_t retval, const char* file, int32_t line) const
 {
   // Check for OPENCL Error and in the case of an error display the corresponding error string
-  if (error != CL_SUCCESS) {
-    GPUError("OpenCL Error: %ld / %s (%s:%d)", error, convertErrorToString(error), file, line);
+  if (retval != CL_SUCCESS) {
+    GPUError("OpenCL Error: %ld / %s (%s:%d)", retval, convertErrorToString(retval), file, line);
   }
-  return error != CL_SUCCESS;
+  return retval != CL_SUCCESS;
 }
 
 int32_t GPUReconstructionOCL::InitDevice_Runtime()

GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h

@@ -40,7 +40,7 @@ class GPUReconstructionOCL : public GPUReconstructionProcessing::KernelInterface
   int32_t InitDevice_Runtime() override;
   int32_t ExitDevice_Runtime() override;
 
-  virtual int32_t GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const override;
+  virtual int32_t GPUChkErrInternal(const int64_t retval, const char* file, int32_t line) const override;
 
   void SynchronizeGPU() override;
   int32_t GPUDebug(const char* state = "UNKNOWN", int32_t stream = -1, bool force = false) override;

GPU/GPUTracking/Global/GPUChainTracking.cxx

@@ -677,7 +677,7 @@ int32_t GPUChainTracking::RunChain()
   const bool needQA = GPUQA::QAAvailable() && (GetProcessingSettings().runQA || (GetProcessingSettings().eventDisplay && (mIOPtrs.nMCInfosTPC || GetProcessingSettings().runMC)));
   if (needQA && GetQA()->IsInitialized() == false) {
     if (GetQA()->InitQA(GetProcessingSettings().runQA <= 0 ? -GetProcessingSettings().runQA : gpudatatypes::gpuqa::tasksAutomatic)) {
-      return GPUReconstruction::retValValue::error;
+      return GPUReconstruction::retValValue::retError;
     }
   }
   if (needQA) {
@@ -693,7 +693,7 @@ int32_t GPUChainTracking::RunChain()
     mRec->PrepareEvent();
   } catch (const std::bad_alloc& e) {
     GPUError("Memory Allocation Error");
-    return GPUReconstruction::retValValue::error;
+    return GPUReconstruction::retValValue::retError;
   }
   mRec->getGeneralStepTimer(GeneralStep::Prepare).Stop();
 
@@ -707,11 +707,11 @@ int32_t GPUChainTracking::RunChain()
 
   if (mIOPtrs.tpcCompressedClusters) {
     if (runRecoStep(RecoStep::TPCDecompression, &GPUChainTracking::RunTPCDecompression)) {
-      return GPUReconstruction::retValValue::error;
+      return GPUReconstruction::retValValue::retError;
     }
   } else if (mIOPtrs.tpcPackedDigits || mIOPtrs.tpcZS) {
     if (runRecoStep(RecoStep::TPCClusterFinding, &GPUChainTracking::RunTPCClusterizer, false)) {
-      return GPUReconstruction::retValValue::error;
+      return GPUReconstruction::retValValue::retError;
     }
   }
 
@@ -720,17 +720,17 @@ int32_t GPUChainTracking::RunChain()
   }
 
   if (mIOPtrs.clustersNative && runRecoStep(RecoStep::TPCConversion, &GPUChainTracking::ConvertNativeToClusterData)) {
-    return GPUReconstruction::retValValue::error;
+    return GPUReconstruction::retValValue::retError;
   }
 
   mRec->PushNonPersistentMemory(qStr2Tag("TPCSLCD1")); // 1st stack level for TPC tracking sector data
   mTPCSectorScratchOnStack = true;
   if (runRecoStep(RecoStep::TPCSectorTracking, &GPUChainTracking::RunTPCTrackingSectors)) {
-    return GPUReconstruction::retValValue::error;
+    return GPUReconstruction::retValValue::retError;
   }
 
   if (runRecoStep(RecoStep::TPCMerging, &GPUChainTracking::RunTPCTrackingMerger, false)) {
-    return GPUReconstruction::retValValue::error;
+    return GPUReconstruction::retValValue::retError;
   }
   if (mTPCSectorScratchOnStack) {
     mRec->PopNonPersistentMemory(RecoStep::TPCSectorTracking, qStr2Tag("TPCSLCD1")); // Release 1st stack level, TPC sector data not needed after merger
@@ -750,16 +750,16 @@ int32_t GPUChainTracking::RunChain()
       }
     }
     if (runRecoStep(RecoStep::TPCCompression, &GPUChainTracking::RunTPCCompression)) {
-      return GPUReconstruction::retValValue::error;
+      return GPUReconstruction::retValValue::retError;
     }
   }
 
   if (runRecoStep(RecoStep::TRDTracking, &GPUChainTracking::RunTRDTracking)) {
-    return GPUReconstruction::retValValue::error;
+    return GPUReconstruction::retValValue::retError;
   }
 
   if (runRecoStep(RecoStep::Refit, &GPUChainTracking::RunRefit)) {
-    return GPUReconstruction::retValValue::error;
+    return GPUReconstruction::retValValue::retError;
   }
 
   if (!GetProcessingSettings().doublePipeline) { // Synchronize with output copies running asynchronously
@@ -770,9 +770,9 @@ int32_t GPUChainTracking::RunChain()
     mRec->SetNActiveThreads(-1);
   }
 
-  int32_t retVal = GPUReconstruction::retValValue::ok;
+  int32_t retVal = GPUReconstruction::retValValue::retOk;
   if (CheckErrorCodes(false, false, mRec->getErrorCodeOutput())) { // TODO: Eventually, we should use GPUReconstruction::CheckErrorCodes
-    retVal = GPUReconstruction::retValValue::nonFatalErrorCode;
+    retVal = GPUReconstruction::retValValue::retNonFatalErrorCode;
     if (!GetProcessingSettings().ignoreNonFatalGPUErrors) {
       return retVal;
     }
@@ -820,7 +820,7 @@ int32_t GPUChainTracking::RunChainFinalize()
       GPUInfo("Starting Event Display...");
       if (mEventDisplay->StartDisplay()) {
         GPUError("Error starting Event Display");
-        return GPUReconstruction::retValValue::error;
+        return GPUReconstruction::retValValue::retError;
       }
       mDisplayRunning = true;
     } else {
@@ -857,15 +857,15 @@ int32_t GPUChainTracking::RunChainFinalize()
       mDisplayRunning = false;
       GetProcessingSettings().eventDisplay->DisplayExit();
       const_cast<GPUSettingsProcessing&>(GetProcessingSettings()).eventDisplay = nullptr; // TODO: fixme - eventDisplay should probably not be put into ProcessingSettings in the first place
-      return GPUReconstruction::retValValue::doExit;
+      return GPUReconstruction::retValValue::retDoExit;
     }
     GetProcessingSettings().eventDisplay->setDisplayControl(0);
     GPUInfo("Loading next event...");
 
     mEventDisplay->BlockTillNextEvent();
   }
 
-  return GPUReconstruction::retValValue::ok;
+  return GPUReconstruction::retValValue::retOk;
 }
 
 int32_t GPUChainTracking::FinalizePipelinedProcessing()