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 "GPUO2DataTypes.h"
21#include "GPUTPCTrackParam.h"
22#include "GPUParam.inc"
23#include "GPUTPCConvertImpl.h"
24#include "GPUDefParametersRuntime.h"
25
26#if !defined(GPUCA_GPUCODE)
27#include <cstring>
28#include <cmath>
29#include <algorithm>
30#include <stdexcept>
31
32#include "GPUReconstruction.h"
34#endif
35
36using namespace o2::gpu;
37using namespace o2::tpc;
38
39#if !defined(GPUCA_GPUCODE)
40
42
43// ----------------------------------------------------------------------------------
44void GPUTPCTracker::SetSector(int32_t iSector) { mISector = iSector; }
46{
47 if (mISector < 0) {
48 throw std::runtime_error("Sector not set");
49 }
50 InitializeRows(&Param());
52}
53
54void* GPUTPCTracker::SetPointersDataLinks(void* mem) { return mData.SetPointersLinks(mem); }
55void* GPUTPCTracker::SetPointersDataWeights(void* mem) { return mData.SetPointersWeights(mem); }
57void* GPUTPCTracker::SetPointersDataRows(void* mem) { return mData.SetPointersRows(mem); }
58
60{
61 computePointerWithAlignment(mem, mTrackletStartHits, mNMaxStartHits);
62 if (mRec->GetProcessingSettings().memoryAllocationStrategy != GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
63 mem = SetPointersTracklets(mem);
64 }
66 computePointerWithAlignment(mem, mTrackletTmpStartHits, GPUCA_ROW_COUNT * mNMaxRowStartHits);
67 computePointerWithAlignment(mem, mRowStartHitCountOffset, GPUCA_ROW_COUNT);
68 }
69 return mem;
70}
71
73{
74 if (mRec->GetProcessingSettings().keepDisplayMemory) {
75 computePointerWithAlignment(mem, mLinkTmpMemory, mRec->Res(mMemoryResLinks).Size());
76 }
78 return mem;
79}
80
82{
83 computePointerWithAlignment(mem, mCommonMem, 1);
84 return mem;
85}
86
88{
89 return !mRec->GetProcessingSettings().keepDisplayMemory && ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSectorTracking) || mRec->GetProcessingSettings().inKernelParallel == 1 || mRec->GetProcessingSettings().nHostThreads == 1);
90}
91
93{
95 bool reuseCondition = MemoryReuseAllowed();
96 GPUMemoryReuse reLinks{reuseCondition, GPUMemoryReuse::REUSE_1TO1, GPUMemoryReuse::TrackerDataLinks, (uint16_t)(mISector % mRec->GetProcessingSettings().nStreams)};
99 GPUMemoryReuse reWeights{reuseCondition, GPUMemoryReuse::REUSE_1TO1, GPUMemoryReuse::TrackerDataWeights, (uint16_t)(mISector % mRec->GetProcessingSettings().nStreams)};
101 GPUMemoryReuse reScratch{reuseCondition, GPUMemoryReuse::REUSE_1TO1, GPUMemoryReuse::TrackerScratch, (uint16_t)(mISector % mRec->GetProcessingSettings().nStreams)};
106
108 if (mRec->GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) { // For individual scheme, we allocate tracklets separately, and change the type for the following allocations to custom
110 mMemoryResTracklets = mRec->RegisterMemoryAllocation(this, &GPUTPCTracker::SetPointersTracklets, type | GPUMemoryResource::MEMORY_STACK, "TPCTrackerTracklets");
111 }
112 mMemoryResOutput = mRec->RegisterMemoryAllocation(this, &GPUTPCTracker::SetPointersOutput, type, "TPCTrackerTracks"); // TODO: Ideally this should eventually go on the stack, so that we can free it after the first phase of track merging
113}
114
115GPUhd() void* GPUTPCTracker::SetPointersTracklets(void* mem)
116{
117 computePointerWithAlignment(mem, mTracklets, mNMaxTracklets);
118 computePointerWithAlignment(mem, mTrackletRowHits, mNMaxRowHits);
119 return mem;
120}
121
122GPUhd() void* GPUTPCTracker::SetPointersOutput(void* mem)
123{
124 computePointerWithAlignment(mem, mTracks, mNMaxTracks);
125 computePointerWithAlignment(mem, mTrackHits, mNMaxTrackHits);
126 return mem;
127}
128
130{
131 if (mRec->GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
132 mNMaxStartHits = mData.NumberOfHits();
133 } else {
134 mNMaxStartHits = mRec->MemoryScalers()->NTPCStartHits(mData.NumberOfHits());
135 }
136 if (io.clustersNative) {
137 uint32_t maxRowHits = 0;
138 for (uint32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
139 if (io.clustersNative->nClusters[mISector][i] > maxRowHits) {
140 maxRowHits = io.clustersNative->nClusters[mISector][i];
141 }
142 }
143 mNMaxRowStartHits = mRec->MemoryScalers()->NTPCRowStartHits(maxRowHits * GPUCA_ROW_COUNT);
144 } else {
145 mNMaxRowStartHits = mRec->MemoryScalers()->NTPCRowStartHits(mData.NumberOfHits());
146 }
147 mNMaxTracklets = mRec->MemoryScalers()->NTPCTracklets(mData.NumberOfHits());
148 mNMaxRowHits = mRec->MemoryScalers()->NTPCTrackletHits(mData.NumberOfHits());
149 mNMaxTracks = mRec->MemoryScalers()->NTPCSectorTracks(mData.NumberOfHits());
150 if (io.clustersNative) {
151 uint32_t sectorOffset = mISector >= GPUCA_NSECTORS / 2 ? GPUCA_NSECTORS / 2 : 0;
152 uint32_t nextSector = (mISector + 1) % (GPUCA_NSECTORS / 2) + sectorOffset;
153 uint32_t prevSector = (mISector + GPUCA_NSECTORS - 1) % (GPUCA_NSECTORS / 2) + sectorOffset;
154 uint32_t nExtrapolationTracks = mRec->MemoryScalers()->NTPCSectorTracks((io.clustersNative->nClustersSector[nextSector] + io.clustersNative->nClustersSector[prevSector]) / 2) / 2;
155 if (nExtrapolationTracks > mNMaxTracks) {
156 mNMaxTracks = nExtrapolationTracks;
157 }
158 }
159 mNMaxTrackHits = mRec->MemoryScalers()->NTPCSectorTrackHits(mData.NumberOfHits(), mRec->GetProcessingSettings().tpcInputWithClusterRejection);
160
162 if (mNMaxStartHits > mNMaxRowStartHits * GPUCA_ROW_COUNT) {
163 mNMaxStartHits = mNMaxRowStartHits * GPUCA_ROW_COUNT;
164 }
165 }
166 mData.SetMaxData();
167}
168
170{
171 mNMaxTracklets = mCommonMem->nStartHits;
172 mNMaxTracks = mNMaxTracklets * 2 + 50;
173 mNMaxRowHits = mNMaxTracklets * GPUCA_ROW_COUNT;
174}
175
177
178GPUh() int32_t GPUTPCTracker::CheckEmptySector()
179{
180 // Check if the Sector is empty, if so set the output apropriate and tell the reconstuct procesdure to terminate
181 if (NHitsTotal() < 1) {
182 mCommonMem->nTracks = mCommonMem->nTrackHits = 0;
183 return 1;
184 }
185 return 0;
186}
187
188#endif
int32_t i
#define GPUhd()
#define GPUh()
#define GPUCA_NSECTORS
#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:168
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]
unsigned int nClustersSector[constants::MAXSECTOR]