GPU: Switch some of the older classes to using C++11 style initialization

Author: davidrohr

GPU/GPUTracking/CMakeLists.txt

@@ -44,7 +44,6 @@ set(SRCS
     SectorTracker/GPUTPCNeighboursFinder.cxx
     SectorTracker/GPUTPCGrid.cxx
     SectorTracker/GPUTPCTrackletSelector.cxx
-    SectorTracker/GPUTPCRow.cxx
     SectorTracker/GPUTPCExtrapolationTracking.cxx
     SectorTracker/GPUTPCCreateTrackingData.cxx
     Merger/GPUTPCGMMerger.cxx

GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx

@@ -85,10 +85,7 @@ struct MergeLooperParam {
 #include "GPUMemorySizeScalers.h"
 
 GPUTPCGMMerger::GPUTPCGMMerger()
-  : mTrackLinks(nullptr), mNTotalSectorTracks(0), mNMaxTracks(0), mNMaxSingleSectorTracks(0), mNMaxOutputTrackClusters(0), mNMaxClusters(0), mMemoryResMemory(-1), mNClusters(0), mOutputTracks(nullptr), mSectorTrackInfos(nullptr), mSectorTrackInfoIndex(nullptr), mClusters(nullptr), mClustersXYZ(nullptr), mClusterAttachment(nullptr), mOutputTracksTPCO2(nullptr), mOutputClusRefsTPCO2(nullptr), mOutputTracksTPCO2MC(nullptr), mTrackOrderAttach(nullptr), mTrackOrderProcess(nullptr), mBorderMemory(nullptr), mBorderRangeMemory(nullptr), mMemory(nullptr), mRetryRefitIds(nullptr), mLoopData(nullptr)
 {
-  //* constructor
-
   for (int32_t iSector = 0; iSector < NSECTORS; iSector++) {
     mNextSectorInd[iSector] = iSector + 1;
     mPrevSectorInd[iSector] = iSector - 1;

GPU/GPUTracking/Merger/GPUTPCGMMerger.h

@@ -241,53 +241,53 @@ class GPUTPCGMMerger : public GPUProcessor
   int32_t mNextSectorInd[NSECTORS];
   int32_t mPrevSectorInd[NSECTORS];
 
-  int32_t* mTrackLinks;
+  int32_t* mTrackLinks = nullptr;
   int32_t* mTrackCCRoots; // root of the connected component of this track
 
-  uint32_t mNTotalSectorTracks;      // maximum number of incoming sector tracks
-  uint32_t mNMaxTracks;              // maximum number of output tracks
-  uint32_t mNMaxSingleSectorTracks;  // max N tracks in one sector
-  uint32_t mNMaxOutputTrackClusters; // max number of clusters in output tracks (double-counting shared clusters)
-  uint32_t mNMaxClusters;            // max total unique clusters (in event)
-  uint32_t mNMaxLooperMatches;       // Maximum number of candidate pairs for looper matching
+  uint32_t mNTotalSectorTracks = 0;      // maximum number of incoming sector tracks
+  uint32_t mNMaxTracks = 0;              // maximum number of output tracks
+  uint32_t mNMaxSingleSectorTracks = 0;  // max N tracks in one sector
+  uint32_t mNMaxOutputTrackClusters = 0; // max number of clusters in output tracks (double-counting shared clusters)
+  uint32_t mNMaxClusters = 0;            // max total unique clusters (in event)
+  uint32_t mNMaxLooperMatches = 0;       // Maximum number of candidate pairs for looper matching
 
-  uint16_t mMemoryResMemory;
-  uint16_t mMemoryResOutput;
-  uint16_t mMemoryResOutputState;
-  uint16_t mMemoryResOutputO2;
-  uint16_t mMemoryResOutputO2Clus;
-  uint16_t mMemoryResOutputO2MC;
-  uint16_t mMemoryResOutputO2Scratch;
+  uint16_t mMemoryResMemory = (uint16_t)-1;
+  uint16_t mMemoryResOutput = (uint16_t)-1;;
+  uint16_t mMemoryResOutputState = (uint16_t)-1;;
+  uint16_t mMemoryResOutputO2 = (uint16_t)-1;;
+  uint16_t mMemoryResOutputO2Clus = (uint16_t)-1;;
+  uint16_t mMemoryResOutputO2MC = (uint16_t)-1;;
+  uint16_t mMemoryResOutputO2Scratch = (uint16_t)-1;;
 
-  int32_t mNClusters;                   // Total number of incoming clusters (from sector tracks)
-  GPUTPCGMMergedTrack* mOutputTracks;   //* array of output merged tracks
-  GPUdEdxInfo* mOutputTracksdEdx;       //* dEdx information
-  GPUTPCGMSectorTrack* mSectorTrackInfos; //* additional information for sector tracks
-  int32_t* mSectorTrackInfoIndex;
-  GPUTPCGMMergedTrackHit* mClusters;
-  GPUTPCGMMergedTrackHitXYZ* mClustersXYZ;
-  GPUAtomic(uint32_t) * mClusterAttachment;
-  o2::tpc::TrackTPC* mOutputTracksTPCO2;
-  uint32_t* mOutputClusRefsTPCO2;
-  o2::MCCompLabel* mOutputTracksTPCO2MC;
-  internal::MergeLooperParam* mLooperCandidates;
+  int32_t mNClusters = 0;                           // Total number of incoming clusters (from sector tracks)
+  GPUTPCGMMergedTrack* mOutputTracks = nullptr;     //* array of output merged tracks
+  GPUdEdxInfo* mOutputTracksdEdx = nullptr;         //* dEdx information
+  GPUTPCGMSectorTrack* mSectorTrackInfos = nullptr; //* additional information for sector tracks
+  int32_t* mSectorTrackInfoIndex = nullptr;
+  GPUTPCGMMergedTrackHit* mClusters = nullptr;
+  GPUTPCGMMergedTrackHitXYZ* mClustersXYZ = nullptr;
+  GPUAtomic(uint32_t) * mClusterAttachment = nullptr;
+  o2::tpc::TrackTPC* mOutputTracksTPCO2 = nullptr;
+  uint32_t* mOutputClusRefsTPCO2 = nullptr;
+  o2::MCCompLabel* mOutputTracksTPCO2MC = nullptr;
+  internal::MergeLooperParam* mLooperCandidates = nullptr;
 
-  uint32_t* mTrackOrderAttach;
-  uint32_t* mTrackOrderProcess;
-  uint8_t* mClusterStateExt;
-  uint2* mClusRefTmp;
-  int32_t* mTrackIDs;
-  int32_t* mTmpSortMemory;
-  uint32_t* mTrackSort;
-  tmpSort* mTrackSortO2;
-  GPUAtomic(uint32_t) * mSharedCount;     // Must be uint32_t unfortunately for atomic support
-  GPUTPCGMBorderTrack* mBorderMemory;     // memory for border tracks
+  uint32_t* mTrackOrderAttach = nullptr;
+  uint32_t* mTrackOrderProcess = nullptr;
+  uint8_t* mClusterStateExt = nullptr;
+  uint2* mClusRefTmp = nullptr;
+  int32_t* mTrackIDs = nullptr;
+  int32_t* mTmpSortMemory = nullptr;
+  uint32_t* mTrackSort = nullptr;
+  tmpSort* mTrackSortO2 = nullptr;
+  GPUAtomic(uint32_t) * mSharedCount = nullptr; // Must be uint32_t unfortunately for atomic support
+  GPUTPCGMBorderTrack* mBorderMemory = nullptr; // memory for border tracks
   GPUTPCGMBorderTrack* mBorder[2 * NSECTORS];
-  gputpcgmmergertypes::GPUTPCGMBorderRange* mBorderRangeMemory;    // memory for border tracks
-  gputpcgmmergertypes::GPUTPCGMBorderRange* mBorderRange[NSECTORS]; // memory for border tracks
-  memory* mMemory;
-  uint32_t* mRetryRefitIds;
-  GPUTPCGMLoopData* mLoopData;
+  gputpcgmmergertypes::GPUTPCGMBorderRange* mBorderRangeMemory = nullptr; // memory for border tracks
+  gputpcgmmergertypes::GPUTPCGMBorderRange* mBorderRange[NSECTORS];       // memory for border tracks
+  memory* mMemory = nullptr;
+  uint32_t* mRetryRefitIds = nullptr;
+  GPUTPCGMLoopData* mLoopData = nullptr;
 };
 } // namespace o2::gpu
 

GPU/GPUTracking/SectorTracker/GPUTPCRow.cxx

@@ -32,10 +32,6 @@ class GPUTPCRow
   friend class GPUTPCTrackingData;
 
  public:
-#if !defined(GPUCA_GPUCODE)
-  GPUTPCRow();
-#endif //! GPUCA_GPUCODE
-
   GPUhd() int32_t NHits() const
   {
     return mNHits;
@@ -72,8 +68,7 @@ class GPUTPCRow
   float mHstepYi; // inverse step size
   float mHstepZi; // inverse step size
 
-  int32_t mHitNumberOffset; // index of the first hit in the hit array, used as
-  // offset in GPUTPCTrackingData::LinkUp/DownData/HitDataY/...
+  int32_t mHitNumberOffset; // index of the first hit in the hit array, used as offset in GPUTPCTrackingData::LinkUp/DownData/HitDataY/...
   uint32_t mFirstHitInBinOffset; // offset in Tracker::mRowData to find the FirstHitInBin
 };
 } // namespace o2::gpu

GPU/GPUTracking/SectorTracker/GPUTPCRow.h

@@ -39,11 +39,6 @@ using namespace o2::tpc;
 
 #if !defined(GPUCA_GPUCODE)
 
-GPUTPCTracker::GPUTPCTracker()
-  : GPUProcessor(), mLinkTmpMemory(nullptr), mISector(-1), mData(), mNMaxStartHits(0), mNMaxRowStartHits(0), mNMaxTracklets(0), mNMaxRowHits(0), mNMaxTracks(0), mNMaxTrackHits(0), mMemoryResLinks(-1), mMemoryResScratchHost(-1), mMemoryResCommon(-1), mMemoryResTracklets(-1), mMemoryResOutput(-1), mMemoryResSectorScratch(-1), mRowStartHitCountOffset(nullptr), mTrackletTmpStartHits(nullptr), mGPUTrackletTemp(nullptr), mGPUParametersConst(), mCommonMem(nullptr), mTrackletStartHits(nullptr), mTracklets(nullptr), mTrackletRowHits(nullptr), mTracks(nullptr), mTrackHits(nullptr), mOutput(nullptr), mOutputMemory(nullptr)
-{
-}
-
 GPUTPCTracker::~GPUTPCTracker()
 {
   if (mOutputMemory) {

GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx

@@ -40,7 +40,7 @@ class GPUTPCTracker : public GPUProcessor
 {
  public:
 #ifndef GPUCA_GPUCODE_DEVICE
-  GPUTPCTracker();
+  GPUTPCTracker() = default;
   ~GPUTPCTracker();
   GPUTPCTracker(const GPUTPCTracker&) = delete;
   GPUTPCTracker& operator=(const GPUTPCTracker&) = delete;
@@ -233,40 +233,40 @@ class GPUTPCTracker : public GPUProcessor
   friend class GPUTPCNeighboursFinder;
   friend class GPUTPCStartHitsSorter;
   friend class GPUTPCStartHitsFinder;
-  char* mLinkTmpMemory; // tmp memory for hits after neighbours finder
+  char* mLinkTmpMemory = nullptr; // tmp memory for hits after neighbours finder
 
-  int32_t mISector; // Number of sector
+  int32_t mISector = -1; // Number of sector
 
   GPUTPCTrackingData mData; // The TrackingData object. It is used to encapsulate the storage in memory from the access
 
-  uint32_t mNMaxStartHits;
-  uint32_t mNMaxRowStartHits;
-  uint32_t mNMaxTracklets;
-  uint32_t mNMaxRowHits;
-  uint32_t mNMaxTracks;
-  uint32_t mNMaxTrackHits;
-  int16_t mMemoryResLinks;
-  int16_t mMemoryResScratch;
-  int16_t mMemoryResScratchHost;
-  int16_t mMemoryResCommon;
-  int16_t mMemoryResTracklets;
-  int16_t mMemoryResOutput;
-  int16_t mMemoryResSectorScratch;
+  uint32_t mNMaxStartHits = 0;
+  uint32_t mNMaxRowStartHits = 0;
+  uint32_t mNMaxTracklets = 0;
+  uint32_t mNMaxRowHits = 0;
+  uint32_t mNMaxTracks = 0;
+  uint32_t mNMaxTrackHits = 0;
+  uint16_t mMemoryResLinks = (uint16_t)-1;
+  uint16_t mMemoryResScratch = (uint16_t)-1;
+  uint16_t mMemoryResScratchHost = (uint16_t)-1;
+  uint16_t mMemoryResCommon = (uint16_t)-1;
+  uint16_t mMemoryResTracklets = (uint16_t)-1;
+  uint16_t mMemoryResOutput = (uint16_t)-1;
+  uint16_t mMemoryResSectorScratch = (uint16_t)-1;
 
   // GPU Temp Arrays
-  GPUglobalref() int32_t* mRowStartHitCountOffset;   // Offset, length and new offset of start hits in row
-  GPUglobalref() GPUTPCHitId* mTrackletTmpStartHits; // Unsorted start hits
-  GPUglobalref() char* mGPUTrackletTemp;             // Temp Memory for GPU Tracklet Constructor
+  GPUglobalref() int32_t* mRowStartHitCountOffset = nullptr;   // Offset, length and new offset of start hits in row
+  GPUglobalref() GPUTPCHitId* mTrackletTmpStartHits = nullptr; // Unsorted start hits
+  GPUglobalref() char* mGPUTrackletTemp = nullptr;             // Temp Memory for GPU Tracklet Constructor
 
   StructGPUParametersConst mGPUParametersConst; // Parameters for GPU if this is a GPU tracker
 
   // event
-  GPUglobalref() commonMemoryStruct* mCommonMem;  // common event memory
-  GPUglobalref() GPUTPCHitId* mTrackletStartHits; // start hits for the tracklets
-  GPUglobalref() GPUTPCTracklet* mTracklets;      // tracklets
-  GPUglobalref() calink* mTrackletRowHits;        // Hits for each Tracklet in each row
-  GPUglobalref() GPUTPCTrack* mTracks;            // reconstructed tracks
-  GPUglobalref() GPUTPCHitId* mTrackHits;         // array of track hit numbers
+  GPUglobalref() commonMemoryStruct* mCommonMem = nullptr;  // common event memory
+  GPUglobalref() GPUTPCHitId* mTrackletStartHits = nullptr; // start hits for the tracklets
+  GPUglobalref() GPUTPCTracklet* mTracklets = nullptr;      // tracklets
+  GPUglobalref() calink* mTrackletRowHits = nullptr;        // Hits for each Tracklet in each row
+  GPUglobalref() GPUTPCTrack* mTracks = nullptr;            // reconstructed tracks
+  GPUglobalref() GPUTPCHitId* mTrackHits = nullptr;         // array of track hit numbers
 
   // output
   GPUglobalref() GPUTPCSectorOutput* mOutput; // address of pointer pointing to SectorOutput Object

GPU/GPUTracking/SectorTracker/GPUTPCTracker.h

@@ -13,7 +13,7 @@
 # author David Rohr
 
 o2_gpu_kernel_file_list(ERRORS GPUErrors.cxx)
-o2_gpu_kernel_file_list(TPCTRACKER ERRORS GPUTPCTrackParam.cxx GPUTPCTrack.cxx GPUTPCGrid.cxx GPUTPCRow.cxx GPUTPCTracker.cxx)
+o2_gpu_kernel_file_list(TPCTRACKER ERRORS GPUTPCTrackParam.cxx GPUTPCTrack.cxx GPUTPCGrid.cxx GPUTPCTracker.cxx)
 o2_gpu_kernel_file_list(TPCTRACKLETCONS GPUTPCTrackletConstructor.cxx)
 o2_gpu_kernel_file_list(TPCSECTORDATA TPCTRACKER GPUTPCTrackingData.cxx)
 o2_gpu_kernel_file_list(TPCOCCUPANCY GPUTPCClusterOccupancyMap.cxx)