Project
Loading...
Searching...
No Matches
GPUTPCTracker.cxx
Go to the documentation of this file.
1// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
2// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
3// All rights not expressly granted are reserved.
4//
5// This software is distributed under the terms of the GNU General Public
6// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
7//
8// In applying this license CERN does not waive the privileges and immunities
9// granted to it by virtue of its status as an Intergovernmental Organization
10// or submit itself to any jurisdiction.
11
14
15#include "GPUTPCTracker.h"
16#include "GPUTPCRow.h"
17#include "GPUTPCTrack.h"
18#include "GPUCommonMath.h"
19
20#include "GPUTPCClusterData.h"
21#include "GPUO2DataTypes.h"
22#include "GPUTPCTrackParam.h"
23#include "GPUParam.inc"
24#include "GPUTPCConvertImpl.h"
25#include "GPUDefParametersRuntime.h"
26
27#if !defined(GPUCA_GPUCODE)
28#include <cstring>
29#include <cmath>
30#include <algorithm>
31#include <stdexcept>
32
33#include "GPUReconstruction.h"
35#endif
36
37using namespace o2::gpu;
38using namespace o2::tpc;
39
40#if !defined(GPUCA_GPUCODE)
41
43
44// ----------------------------------------------------------------------------------
45void GPUTPCTracker::SetSector(int32_t iSector) { mISector = iSector; }
47{
48 if (mISector < 0) {
49 throw std::runtime_error("Sector not set");
50 }
53}
54
55void* GPUTPCTracker::SetPointersDataLinks(void* mem) { return mData.SetPointersLinks(mem); }
56void* GPUTPCTracker::SetPointersDataWeights(void* mem) { return mData.SetPointersWeights(mem); }
58void* GPUTPCTracker::SetPointersDataRows(void* mem) { return mData.SetPointersRows(mem); }
59
61{
62 computePointerWithAlignment(mem, mTrackletStartHits, mNMaxStartHits);
63 if (mRec->GetProcessingSettings().memoryAllocationStrategy != GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
64 mem = SetPointersTracklets(mem);
65 }
67 computePointerWithAlignment(mem, mTrackletTmpStartHits, GPUCA_ROW_COUNT * mNMaxRowStartHits);
68 computePointerWithAlignment(mem, mRowStartHitCountOffset, GPUCA_ROW_COUNT);
69 }
70 return mem;
71}
72
74{
75 if (mRec->GetProcessingSettings().keepDisplayMemory) {
76 computePointerWithAlignment(mem, mLinkTmpMemory, mRec->Res(mMemoryResLinks).Size());
77 }
79 return mem;
80}
81
83{
84 computePointerWithAlignment(mem, mCommonMem, 1);
85 return mem;
86}
87
89{
91 bool reuseCondition = !mRec->GetProcessingSettings().keepDisplayMemory && ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSectorTracking) || mRec->GetProcessingSettings().inKernelParallel == 1 || mRec->GetProcessingSettings().nHostThreads == 1);
92 GPUMemoryReuse reLinks{reuseCondition, GPUMemoryReuse::REUSE_1TO1, GPUMemoryReuse::TrackerDataLinks, (uint16_t)(mISector % mRec->GetProcessingSettings().nStreams)};
95 GPUMemoryReuse reWeights{reuseCondition, GPUMemoryReuse::REUSE_1TO1, GPUMemoryReuse::TrackerDataWeights, (uint16_t)(mISector % mRec->GetProcessingSettings().nStreams)};
97 GPUMemoryReuse reScratch{reuseCondition, GPUMemoryReuse::REUSE_1TO1, GPUMemoryReuse::TrackerScratch, (uint16_t)(mISector % mRec->GetProcessingSettings().nStreams)};
102
104 if (mRec->GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) { // For individual scheme, we allocate tracklets separately, and change the type for the following allocations to custom
106 mMemoryResTracklets = mRec->RegisterMemoryAllocation(this, &GPUTPCTracker::SetPointersTracklets, type, "TPCTrackerTracklets");
107 }
108 mMemoryResOutput = mRec->RegisterMemoryAllocation(this, &GPUTPCTracker::SetPointersOutput, type, "TPCTrackerTracks");
109}
110
111GPUhd() void* GPUTPCTracker::SetPointersTracklets(void* mem)
112{
113 computePointerWithAlignment(mem, mTracklets, mNMaxTracklets);
114 computePointerWithAlignment(mem, mTrackletRowHits, mNMaxRowHits);
115 return mem;
116}
117
118GPUhd() void* GPUTPCTracker::SetPointersOutput(void* mem)
119{
120 computePointerWithAlignment(mem, mTracks, mNMaxTracks);
121 computePointerWithAlignment(mem, mTrackHits, mNMaxTrackHits);
122 return mem;
123}
124
126{
127 if (mRec->GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
128 mNMaxStartHits = mData.NumberOfHits();
129 } else {
130 mNMaxStartHits = mRec->MemoryScalers()->NTPCStartHits(mData.NumberOfHits());
131 }
132 if (io.clustersNative) {
133 uint32_t maxRowHits = 0;
134 for (uint32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
135 if (io.clustersNative->nClusters[mISector][i] > maxRowHits) {
136 maxRowHits = io.clustersNative->nClusters[mISector][i];
137 }
138 }
139 mNMaxRowStartHits = mRec->MemoryScalers()->NTPCRowStartHits(maxRowHits * GPUCA_ROW_COUNT);
140 } else {
141 mNMaxRowStartHits = mRec->MemoryScalers()->NTPCRowStartHits(mData.NumberOfHits());
142 }
143 mNMaxTracklets = mRec->MemoryScalers()->NTPCTracklets(mData.NumberOfHits());
144 mNMaxRowHits = mRec->MemoryScalers()->NTPCTrackletHits(mData.NumberOfHits());
145 mNMaxTracks = mRec->MemoryScalers()->NTPCSectorTracks(mData.NumberOfHits());
146 mNMaxTrackHits = mRec->MemoryScalers()->NTPCSectorTrackHits(mData.NumberOfHits(), mRec->GetProcessingSettings().tpcInputWithClusterRejection);
147
149 if (mNMaxStartHits > mNMaxRowStartHits * GPUCA_ROW_COUNT) {
150 mNMaxStartHits = mNMaxRowStartHits * GPUCA_ROW_COUNT;
151 }
152 }
153 mData.SetMaxData();
154}
155
157{
158 mNMaxTracklets = mCommonMem->nStartHits;
159 mNMaxTracks = mNMaxTracklets * 2 + 50;
160 mNMaxRowHits = mNMaxTracklets * GPUCA_ROW_COUNT;
161}
162
164
165GPUh() int32_t GPUTPCTracker::CheckEmptySector()
166{
167 // Check if the Sector is empty, if so set the output apropriate and tell the reconstuct procesdure to terminate
168 if (NHitsTotal() < 1) {
169 mCommonMem->nTracks = mCommonMem->nTrackHits = 0;
170 return 1;
171 }
172 return 0;
173}
174
175#endif
int32_t i
#define GPUhd()
#define GPUh()
#define GPUCA_ROW_COUNT
GPUReconstruction * mRec
static void computePointerWithAlignment(T *&basePtr, S *&objPtr, size_t nEntries=1)
RecoStepField GetRecoStepsGPU() const
int16_t RegisterMemoryAllocation(T *proc, void *(T::*setPtr)(void *), int32_t type, const char *name="", const GPUMemoryReuse &re=GPUMemoryReuse())
GPUMemoryResource & Res(int16_t num)
GPUMemorySizeScalers * MemoryScalers()
const GPUSettingsProcessing & GetProcessingSettings() const
virtual const GPUDefParameters & getGPUParameters(bool doGPU) const =0
void * SetPointersScratchHost(void *mem)
void * SetPointersDataWeights(void *mem)
void * SetPointersDataRows(void *mem)
void * SetPointersOutput(void *mem)
void SetMaxData(const GPUTrackingInOutPointers &io)
void * SetPointersDataLinks(void *mem)
void * SetPointersDataScratch(void *mem)
void InitializeRows(const GPUParam *param)
void * SetPointersCommon(void *mem)
void * SetPointersTracklets(void *mem)
void * SetPointersScratch(void *mem)
void SetSector(int32_t iSector)
void * SetPointersScratch(void *mem, bool idsOnGPU)
void * SetPointersClusterIds(void *mem, bool idsOnGPU)
GLint GLint GLsizei GLint GLenum GLenum type
Definition glcorearb.h:275
typedef void(APIENTRYP PFNGLCULLFACEPROC)(GLenum mode)
Global TPC definitions and constants.
Definition SimTraits.h:167
size_t NTPCSectorTrackHits(size_t tpcHits, uint8_t withRejection=0)
size_t NTPCTracklets(size_t tpcHits)
size_t NTPCTrackletHits(size_t tpcHits)
size_t NTPCSectorTracks(size_t tpcHits)
size_t NTPCRowStartHits(size_t tpcHits)
size_t NTPCStartHits(size_t tpcHits)
const o2::tpc::ClusterNativeAccess * clustersNative
unsigned int nClusters[constants::MAXSECTOR][constants::MAXGLOBALPADROW]