Project
Loading...
Searching...
No Matches
GPUChainTracking.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
17#include <fstream>
18#include <chrono>
19
20#include "GPUChainTracking.h"
21#include "GPUChainTrackingGetters.inc"
22#include "GPUReconstructionIO.h"
24#include "GPUTPCClusterData.h"
26#include "GPUTPCGMMergedTrack.h"
28#include "GPUTPCTrack.h"
29#include "GPUTPCHitId.h"
30#include "TPCZSLinkMapping.h"
31#include "GPUTRDTrackletWord.h"
33#include "GPUTPCMCInfo.h"
34#include "GPUTRDTrack.h"
35#include "GPUTRDTracker.h"
36#include "AliHLTTPCRawCluster.h"
39#include "GPUQA.h"
40#include "GPULogging.h"
43#include "GPUNewCalibValues.h"
44#include "GPUTriggerOutputs.h"
45#include "GPUDefParametersRuntime.h"
46
48#include "GPUHostDataTypes.h"
50#include "GPUTrackingRefit.h"
51#include "CalibdEdxContainer.h"
52
53#include "TPCFastTransform.h"
55
56#include "utils/linux_helpers.h"
57#include "utils/strtag.h"
58using namespace o2::gpu;
59
60#include "GPUO2DataTypes.h"
61
62using namespace o2::tpc;
63using namespace o2::trd;
64
65GPUChainTracking::GPUChainTracking(GPUReconstruction* rec, uint32_t maxTPCHits, uint32_t maxTRDTracklets) : GPUChain(rec), mIOPtrs(processors()->ioPtrs), mInputsHost(new GPUTrackingInputProvider), mInputsShadow(new GPUTrackingInputProvider), mClusterNativeAccess(new ClusterNativeAccess), mTriggerBuffer(new GPUTriggerOutputs), mMaxTPCHits(maxTPCHits), mMaxTRDTracklets(maxTRDTracklets), mDebugFile(new std::ofstream)
66{
70}
71
73
75{
76 if (mRec->IsGPU()) {
80 }
81
83 if (GetRecoSteps() & RecoStep::TPCSectorTracking) {
84 for (uint32_t i = 0; i < NSECTORS; i++) {
85 mRec->RegisterGPUProcessor(&processors()->tpcTrackers[i], GetRecoStepsGPU() & RecoStep::TPCSectorTracking);
86 }
87 }
88 if (GetRecoSteps() & RecoStep::TPCMerging) {
89 mRec->RegisterGPUProcessor(&processors()->tpcMerger, GetRecoStepsGPU() & RecoStep::TPCMerging);
90 }
91 if (GetRecoSteps() & RecoStep::TRDTracking) {
92 mRec->RegisterGPUProcessor(&processors()->trdTrackerGPU, GetRecoStepsGPU() & RecoStep::TRDTracking);
93 }
94 if (GetRecoSteps() & RecoStep::TRDTracking) {
95 mRec->RegisterGPUProcessor(&processors()->trdTrackerO2, GetRecoStepsGPU() & RecoStep::TRDTracking);
96 }
97 if (GetRecoSteps() & RecoStep::TPCConversion) {
98 mRec->RegisterGPUProcessor(&processors()->tpcConverter, GetRecoStepsGPU() & RecoStep::TPCConversion);
99 }
100 if (GetRecoSteps() & RecoStep::TPCCompression) {
101 mRec->RegisterGPUProcessor(&processors()->tpcCompressor, GetRecoStepsGPU() & RecoStep::TPCCompression);
102 }
103 if (GetRecoSteps() & RecoStep::TPCDecompression) {
104 mRec->RegisterGPUProcessor(&processors()->tpcDecompressor, GetRecoStepsGPU() & RecoStep::TPCDecompression);
105 }
106 if (GetRecoSteps() & RecoStep::TPCClusterFinding) {
107 for (uint32_t i = 0; i < NSECTORS; i++) {
108 mRec->RegisterGPUProcessor(&processors()->tpcClusterer[i], GetRecoStepsGPU() & RecoStep::TPCClusterFinding);
109#ifdef GPUCA_HAS_ONNX
110 mRec->RegisterGPUProcessor(&processors()->tpcNNClusterer[i], GetRecoStepsGPU() & RecoStep::TPCClusterFinding);
111#endif
112 }
113 }
114 if (GetRecoSteps() & RecoStep::Refit) {
115 mRec->RegisterGPUProcessor(&processors()->trackingRefit, GetRecoStepsGPU() & RecoStep::Refit);
116 }
117#ifdef GPUCA_KERNEL_DEBUGGER_OUTPUT
118 mRec->RegisterGPUProcessor(&processors()->debugOutput, true);
119#endif
121}
122
124{
125 if (mRec->IsGPU()) {
127 }
128 memcpy((void*)&processorsShadow()->trdTrackerGPU, (const void*)&processors()->trdTrackerGPU, sizeof(processors()->trdTrackerGPU));
129 if (GetRecoStepsGPU() & RecoStep::TPCSectorTracking) {
130 for (uint32_t i = 0; i < NSECTORS; i++) {
131 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcTrackers[i], &processors()->tpcTrackers[i]);
132 }
133 }
134 if (GetRecoStepsGPU() & RecoStep::TPCMerging) {
135 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcMerger, &processors()->tpcMerger);
136 }
137 if (GetRecoStepsGPU() & RecoStep::TRDTracking) {
138 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->trdTrackerGPU, &processors()->trdTrackerGPU);
139 }
140
141 memcpy((void*)&processorsShadow()->trdTrackerO2, (const void*)&processors()->trdTrackerO2, sizeof(processors()->trdTrackerO2));
142 if (GetRecoStepsGPU() & RecoStep::TRDTracking) {
143 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->trdTrackerO2, &processors()->trdTrackerO2);
144 }
145 if (GetRecoStepsGPU() & RecoStep::TPCConversion) {
146 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcConverter, &processors()->tpcConverter);
147 }
148 if (GetRecoStepsGPU() & RecoStep::TPCCompression) {
149 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcCompressor, &processors()->tpcCompressor);
150 }
151 if (GetRecoStepsGPU() & RecoStep::TPCDecompression) {
152 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcDecompressor, &processors()->tpcDecompressor);
153 }
154 if (GetRecoStepsGPU() & RecoStep::TPCClusterFinding) {
155 for (uint32_t i = 0; i < NSECTORS; i++) {
156 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcClusterer[i], &processors()->tpcClusterer[i]);
157#ifdef GPUCA_HAS_ONNX
158 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcNNClusterer[i], &processors()->tpcNNClusterer[i]);
159#endif
160 }
161 }
162 if (GetRecoStepsGPU() & RecoStep::Refit) {
163 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->trackingRefit, &processors()->trackingRefit);
164 }
165#ifdef GPUCA_KERNEL_DEBUGGER_OUTPUT
166 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->debugOutput, &processors()->debugOutput);
167#endif
168}
169
170void GPUChainTracking::MemorySize(size_t& gpuMem, size_t& pageLockedHostMem)
171{
172 gpuMem = GPUCA_MEMORY_SIZE;
173 pageLockedHostMem = GPUCA_HOST_MEMORY_SIZE;
174}
175
177{
179 GPUError("Invalid Reconstruction Step Setting: dEdx requires TPC Merger to be active");
180 return false;
181 }
183 GPUError("Invalid GPU Reconstruction Step Setting: dEdx requires TPC Merger to be active");
184 return false;
185 }
186 if (!param().par.earlyTpcTransform) {
188 GPUError("Invalid Reconstruction Step Setting: Tracking without early transform requires TPC Conversion to be active");
189 return false;
190 }
191 }
193 GPUError("Invalid input, TPC Clusterizer needs TPC raw input");
194 return false;
195 }
197 GPUError("Invalid input / output / step, merger cannot read/store sectors tracks and needs TPC conversion");
198 return false;
199 }
201 if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging) && !tpcClustersAvail) {
202 GPUError("Invalid Inputs for track merging, TPC Clusters required");
203 return false;
204 }
205#ifndef GPUCA_TPC_GEOMETRY_O2
207 GPUError("Can not run TPC GPU Cluster Finding with Run 2 Data");
208 return false;
209 }
210#endif
212 GPUError("Missing input for TPC Cluster conversion / sector tracking / compression / dEdx: TPC Clusters required");
213 return false;
214 }
216 GPUError("Input for TPC merger missing");
217 return false;
218 }
220 GPUError("Input for TPC compressor missing");
221 return false;
222 }
224 GPUError("Input for TRD Tracker missing");
225 return false;
226 }
228 GPUError("TPC Raw / TPC Clusters / TRD Tracklets cannot be output");
229 return false;
230 }
232 GPUError("No TPC Merged Track Output available");
233 return false;
234 }
236 GPUError("No TPC Compression Output available");
237 return false;
238 }
240 GPUError("No TRD Tracker Output available");
241 return false;
242 }
243 if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCdEdx) && (processors()->calibObjects.dEdxCalibContainer == nullptr)) {
244 GPUError("Cannot run dE/dx without dE/dx calibration container object");
245 return false;
246 }
247 if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCClusterFinding) && processors()->calibObjects.tpcPadGain == nullptr) {
248 GPUError("Cannot run gain calibration without calibration object");
249 return false;
250 }
251 if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCClusterFinding) && processors()->calibObjects.tpcZSLinkMapping == nullptr && mIOPtrs.tpcZS != nullptr) {
252 GPUError("Cannot run TPC ZS Decoder without mapping object. (tpczslinkmapping.dump missing?)");
253 return false;
254 }
255 return true;
256}
257
259{
260 int32_t gatherMode = mRec->GetProcessingSettings().tpcCompressionGatherMode == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression).par_COMP_GATHER_MODE : mRec->GetProcessingSettings().tpcCompressionGatherMode;
261 if ((param().rec.tpc.nWays & 1) == 0) {
262 GPUError("nWay setting musst be odd number!");
263 return false;
264 }
265 if (param().rec.tpc.mergerInterpolateErrors && param().rec.tpc.nWays == 1) {
266 GPUError("Cannot do error interpolation with NWays = 1!");
267 return false;
268 }
269 if (param().continuousMaxTimeBin > (int32_t)GPUSettings::TPC_MAX_TF_TIME_BIN) {
270 GPUError("configured max time bin exceeds 256 orbits");
271 return false;
272 }
273 if ((GetRecoStepsGPU() & RecoStep::TPCClusterFinding) && std::max(GetProcessingSettings().nTPCClustererLanes + 1, GetProcessingSettings().nTPCClustererLanes * 2) + (GetProcessingSettings().doublePipeline ? 1 : 0) > (int32_t)mRec->NStreams()) {
274 GPUError("NStreams of %d insufficient for %d nTPCClustererLanes", mRec->NStreams(), (int32_t)GetProcessingSettings().nTPCClustererLanes);
275 return false;
276 }
277 if (GetProcessingSettings().noGPUMemoryRegistration && gatherMode != 3) {
278 GPUError("noGPUMemoryRegistration only possible with gather mode 3");
279 return false;
280 }
281 if (GetProcessingSettings().doublePipeline) {
283 GPUError("Invalid outputs for double pipeline mode 0x%x", (uint32_t)GetRecoStepsOutputs());
284 return false;
285 }
290 GPUError("Must use external output for double pipeline mode");
291 return false;
292 }
293 if (gatherMode == 1) {
294 GPUError("Double pipeline incompatible to compression mode 1");
295 return false;
296 }
298 GPUError("Invalid reconstruction settings for double pipeline: Needs compression and cluster finding");
299 return false;
300 }
301 }
302 if ((GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) && !(GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) && (gatherMode == 1 || gatherMode == 3)) {
303 GPUError("Invalid tpcCompressionGatherMode for compression on CPU");
304 return false;
305 }
306 if (GetProcessingSettings().tpcApplyClusterFilterOnCPU > 0 && (GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding || GetProcessingSettings().runMC)) {
307 GPUError("tpcApplyClusterFilterOnCPU cannot be used with GPU clusterization or with MC labels");
308 return false;
309 }
310 if (GetRecoSteps() & RecoStep::TRDTracking) {
311 if (GetProcessingSettings().trdTrackModelO2 && (GetProcessingSettings().createO2Output == 0 || param().rec.tpc.nWaysOuter == 0 || (GetMatLUT() == nullptr && !GetProcessingSettings().willProvideO2PropagatorLate))) {
312 GPUError("TRD tracking can only run on O2 TPC tracks if createO2Output is enabled (%d), nWaysOuter is set (%d), and matBudLUT is available (0x%p)", (int32_t)GetProcessingSettings().createO2Output, (int32_t)param().rec.tpc.nWaysOuter, (void*)GetMatLUT());
313 return false;
314 }
315 if ((GetRecoStepsGPU() & RecoStep::TRDTracking) && !GetProcessingSettings().trdTrackModelO2 && GetProcessingSettings().createO2Output > 1) {
316 GPUError("TRD tracking can only run on GPU TPC tracks if the createO2Output setting does not suppress them");
317 return false;
318 }
319 if ((((GetRecoStepsGPU() & RecoStep::TRDTracking) && GetProcessingSettings().trdTrackModelO2) || ((GetRecoStepsGPU() & RecoStep::Refit) && !param().rec.trackingRefitGPUModel)) && (!GetProcessingSettings().o2PropagatorUseGPUField || (GetMatLUT() == nullptr && !GetProcessingSettings().willProvideO2PropagatorLate))) {
320 GPUError("Cannot use TRD tracking or Refit on GPU without GPU polynomial field map (%d) or matlut table (%p)", (int32_t)GetProcessingSettings().o2PropagatorUseGPUField, (void*)GetMatLUT());
321 return false;
322 }
323 }
324 return true;
325}
326
328{
329 const auto& threadContext = GetThreadContext();
330 if (GetProcessingSettings().debugLevel >= 1) {
331 printf("Enabled Reconstruction Steps: 0x%x (on GPU: 0x%x)", (int32_t)GetRecoSteps().get(), (int32_t)GetRecoStepsGPU().get());
332 for (uint32_t i = 0; i < sizeof(GPUDataTypes::RECO_STEP_NAMES) / sizeof(GPUDataTypes::RECO_STEP_NAMES[0]); i++) {
333 if (GetRecoSteps().isSet(1u << i)) {
334 printf(" - %s", GPUDataTypes::RECO_STEP_NAMES[i]);
335 if (GetRecoStepsGPU().isSet(1u << i)) {
336 printf(" (G)");
337 }
338 }
339 }
340 printf("\n");
341 }
342 if (!ValidateSteps()) {
343 return 1;
344 }
345
346 for (uint32_t i = 0; i < mSubOutputControls.size(); i++) {
347 if (mSubOutputControls[i] == nullptr) {
349 }
350 }
351
352 if (!ValidateSettings()) {
353 return 1;
354 }
355
358 if (!qa) {
359 qa.reset(new GPUQA(this));
360 }
361 }
364 if (mEventDisplay == nullptr) {
365 throw std::runtime_error("Error loading event display");
366 }
367 }
368
371
372 if (mRec->IsGPU()) {
374 UpdateGPUCalibObjectsPtrs(-1); // First initialization, for users not using RunChain
376 WriteToConstantMemory(RecoStep::NoRecoStep, (char*)&processors()->errorCodes - (char*)processors(), &processorsShadow()->errorCodes, sizeof(processorsShadow()->errorCodes), -1);
377 TransferMemoryResourceLinkToGPU(RecoStep::NoRecoStep, mInputsHost->mResourceErrorCodes);
378 }
379
380 if (GetProcessingSettings().debugLevel >= 6) {
381 mDebugFile->open(mRec->IsGPU() ? "GPU.out" : "CPU.out");
382 }
383
384 return 0;
385}
386
388{
389 if (processors()->calibObjects.fastTransform && (ptrMask == nullptr || ptrMask->fastTransform)) {
390 memcpy((void*)mFlatObjectsShadow.mCalibObjects.fastTransform, (const void*)processors()->calibObjects.fastTransform, sizeof(*processors()->calibObjects.fastTransform));
391 memcpy((void*)mFlatObjectsShadow.mTpcTransformBuffer, (const void*)processors()->calibObjects.fastTransform->getFlatBufferPtr(), processors()->calibObjects.fastTransform->getFlatBufferSize());
392 mFlatObjectsShadow.mCalibObjects.fastTransform->clearInternalBufferPtr();
395 }
396 if (processors()->calibObjects.fastTransformMShape && (ptrMask == nullptr || ptrMask->fastTransformMShape)) {
397 memcpy((void*)mFlatObjectsShadow.mCalibObjects.fastTransformMShape, (const void*)processors()->calibObjects.fastTransformMShape, sizeof(*processors()->calibObjects.fastTransformMShape));
398 memcpy((void*)mFlatObjectsShadow.mTpcTransformMShapeBuffer, (const void*)processors()->calibObjects.fastTransformMShape->getFlatBufferPtr(), processors()->calibObjects.fastTransformMShape->getFlatBufferSize());
399 mFlatObjectsShadow.mCalibObjects.fastTransformMShape->clearInternalBufferPtr();
402 }
403 if (processors()->calibObjects.fastTransformRef && (ptrMask == nullptr || ptrMask->fastTransformRef)) {
404 memcpy((void*)mFlatObjectsShadow.mCalibObjects.fastTransformRef, (const void*)processors()->calibObjects.fastTransformRef, sizeof(*processors()->calibObjects.fastTransformRef));
405 memcpy((void*)mFlatObjectsShadow.mTpcTransformRefBuffer, (const void*)processors()->calibObjects.fastTransformRef->getFlatBufferPtr(), processors()->calibObjects.fastTransformRef->getFlatBufferSize());
406 mFlatObjectsShadow.mCalibObjects.fastTransformRef->clearInternalBufferPtr();
409 }
410 if (processors()->calibObjects.fastTransformHelper && (ptrMask == nullptr || ptrMask->fastTransformHelper)) {
411 memcpy((void*)mFlatObjectsShadow.mCalibObjects.fastTransformHelper, (const void*)processors()->calibObjects.fastTransformHelper, sizeof(*processors()->calibObjects.fastTransformHelper));
415 }
416 if (processors()->calibObjects.dEdxCalibContainer && (ptrMask == nullptr || ptrMask->dEdxCalibContainer)) {
417 memcpy((void*)mFlatObjectsShadow.mCalibObjects.dEdxCalibContainer, (const void*)processors()->calibObjects.dEdxCalibContainer, sizeof(*processors()->calibObjects.dEdxCalibContainer));
418 memcpy((void*)mFlatObjectsShadow.mdEdxSplinesBuffer, (const void*)processors()->calibObjects.dEdxCalibContainer->getFlatBufferPtr(), processors()->calibObjects.dEdxCalibContainer->getFlatBufferSize());
419 mFlatObjectsShadow.mCalibObjects.dEdxCalibContainer->clearInternalBufferPtr();
422 }
423 if (processors()->calibObjects.matLUT && (ptrMask == nullptr || ptrMask->matLUT)) {
424 memcpy((void*)mFlatObjectsShadow.mCalibObjects.matLUT, (const void*)processors()->calibObjects.matLUT, sizeof(*processors()->calibObjects.matLUT));
425 memcpy((void*)mFlatObjectsShadow.mMatLUTBuffer, (const void*)processors()->calibObjects.matLUT->getFlatBufferPtr(), processors()->calibObjects.matLUT->getFlatBufferSize());
426 mFlatObjectsShadow.mCalibObjects.matLUT->clearInternalBufferPtr();
429 }
430 if (processors()->calibObjects.trdGeometry && (ptrMask == nullptr || ptrMask->trdGeometry)) {
431 memcpy((void*)mFlatObjectsShadow.mCalibObjects.trdGeometry, (const void*)processors()->calibObjects.trdGeometry, sizeof(*processors()->calibObjects.trdGeometry));
432 mFlatObjectsShadow.mCalibObjects.trdGeometry->clearInternalBufferPtr();
433 }
434 if (processors()->calibObjects.tpcPadGain && (ptrMask == nullptr || ptrMask->tpcPadGain)) {
435 memcpy((void*)mFlatObjectsShadow.mCalibObjects.tpcPadGain, (const void*)processors()->calibObjects.tpcPadGain, sizeof(*processors()->calibObjects.tpcPadGain));
436 }
437 if (processors()->calibObjects.tpcZSLinkMapping && (ptrMask == nullptr || ptrMask->tpcZSLinkMapping)) {
438 memcpy((void*)mFlatObjectsShadow.mCalibObjects.tpcZSLinkMapping, (const void*)processors()->calibObjects.tpcZSLinkMapping, sizeof(*processors()->calibObjects.tpcZSLinkMapping));
439 }
440 if (processors()->calibObjects.o2Propagator && (ptrMask == nullptr || ptrMask->o2Propagator)) {
441 memcpy((void*)mFlatObjectsShadow.mCalibObjects.o2Propagator, (const void*)processors()->calibObjects.o2Propagator, sizeof(*processors()->calibObjects.o2Propagator));
442 mFlatObjectsShadow.mCalibObjects.o2Propagator->setGPUField(&processorsDevice()->param.polynomialField);
444 }
446 memcpy((void*)&processorsShadow()->calibObjects, (void*)&mFlatObjectsDevice.mCalibObjects, sizeof(mFlatObjectsDevice.mCalibObjects));
447}
448
450{
451 WriteToConstantMemory(RecoStep::NoRecoStep, (char*)&processors()->calibObjects - (char*)processors(), &mFlatObjectsDevice.mCalibObjects, sizeof(mFlatObjectsDevice.mCalibObjects), stream);
452}
453
455{
459 }
460 if (mIOPtrs.tpcZS && param().rec.fwdTPCDigitsAsClusters) {
461 throw std::runtime_error("Forwading zero-suppressed hits not supported");
462 }
464 return 0;
465}
466
468{
470 if (!qa) {
471 qa.reset(new GPUQA(this));
472 }
473 if (!GetQA()->IsInitialized()) {
474 return GetQA()->InitQA();
475 }
476 return 0;
477}
478
480{
481 if (GetProcessingSettings().runQA && GetQA()->IsInitialized() && !(mConfigQA && mConfigQA->shipToQC) && !mQAFromForeignChain) {
482 GetQA()->UpdateChain(this);
484 }
485 if (GetProcessingSettings().debugLevel >= 6) {
486 mDebugFile->close();
487 }
489 mCompressionStatistics->Finish();
490 }
491 return 0;
492}
493
495{
496 char* fastTransformBase = (char*)mem;
500 }
504 }
508 }
511 }
512 if ((char*)mem - fastTransformBase < mChainTracking->GetProcessingSettings().fastTransformObjectsMinMemorySize) {
513 mem = fastTransformBase + mChainTracking->GetProcessingSettings().fastTransformObjectsMinMemorySize; // TODO: Fixme and do proper dynamic allocation
514 }
517 }
520 }
521 char* dummyPtr;
525 } else if (mChainTracking->GetProcessingSettings().lateO2MatLutProvisioningSize) {
526 computePointerWithAlignment(mem, dummyPtr, mChainTracking->GetProcessingSettings().lateO2MatLutProvisioningSize);
527 }
531 }
534 }
537 mCalibObjects.o2Propagator = nullptr; // Always reserve memory for o2::Propagator, since it may be propagatred only during run() not during init().
538 }
540 mem = (char*)mem + mChainTracking->GetProcessingSettings().calibObjectsExtraMemorySize; // TODO: Fixme and do proper dynamic allocation
541 }
542 return mem;
543}
544
546{
547 std::memset((void*)&mIOPtrs, 0, sizeof(mIOPtrs));
549 new (&mIOMem) InOutMemory;
550}
551
553{
554 for (uint32_t i = 0; i < NSECTORS; i++) {
559 }
561 std::memset(mIOMem.clusterNativeAccess.get(), 0, sizeof(ClusterNativeAccess)); // ClusterNativeAccess has no its own constructor
576}
577
578void GPUChainTracking::SetTPCFastTransform(std::unique_ptr<TPCFastTransform>&& tpcFastTransform, std::unique_ptr<CorrectionMapsHelper>&& tpcTransformHelper)
579{
580 mTPCFastTransformU = std::move(tpcFastTransform);
581 mTPCFastTransformHelperU = std::move(tpcTransformHelper);
584}
585
586void GPUChainTracking::SetMatLUT(std::unique_ptr<o2::base::MatLayerCylSet>&& lut)
587{
588 mMatLUTU = std::move(lut);
590}
591
592void GPUChainTracking::SetTRDGeometry(std::unique_ptr<o2::trd::GeometryFlat>&& geo)
593{
594 mTRDGeometryU = std::move(geo);
596}
597
598int32_t GPUChainTracking::DoQueuedUpdates(int32_t stream, bool updateSlave)
599{
600 int32_t retVal = 0;
601 std::unique_ptr<GPUSettingsGRP> grp;
602 const GPUSettingsProcessing* p = nullptr;
603 std::lock_guard lk(mMutexUpdateCalib);
605 if (mNewCalibValues->newSolenoidField || mNewCalibValues->newContinuousMaxTimeBin || mNewCalibValues->newTPCTimeBinCut) {
606 grp = std::make_unique<GPUSettingsGRP>(mRec->GetGRPSettings());
607 if (mNewCalibValues->newSolenoidField) {
608 grp->solenoidBzNominalGPU = mNewCalibValues->solenoidField;
609 }
610 if (mNewCalibValues->newContinuousMaxTimeBin) {
611 grp->grpContinuousMaxTimeBin = mNewCalibValues->continuousMaxTimeBin;
612 }
613 if (mNewCalibValues->newTPCTimeBinCut) {
614 grp->tpcCutTimeBin = mNewCalibValues->tpcTimeBinCut;
615 }
616 }
617 }
618 if (GetProcessingSettings().tpcDownscaledEdx != 0) {
620 }
621 if (grp || p) {
622 mRec->UpdateSettings(grp.get(), p);
623 retVal = 1;
624 }
626 if (mNewCalibObjects->o2Propagator && ((mNewCalibObjects->o2Propagator->getGPUField() != nullptr) ^ GetProcessingSettings().o2PropagatorUseGPUField)) {
627 GPUFatal("GPU magnetic field for propagator requested, but received an O2 propagator without GPU field");
628 }
629 void* const* pSrc = (void* const*)mNewCalibObjects.get();
630 void** pDst = (void**)&processors()->calibObjects;
631 for (uint32_t i = 0; i < sizeof(processors()->calibObjects) / sizeof(void*); i++) {
632 if (pSrc[i]) {
633 pDst[i] = pSrc[i];
634 }
635 }
637 if (GetProcessingSettings().trdTrackModelO2) {
639 if (mRec->IsGPU()) {
640 TransferMemoryResourceLinkToGPU(RecoStep::NoRecoStep, processors()->trdTrackerO2.MemoryPermanent(), stream);
641 }
642 } else {
644 if (mRec->IsGPU()) {
645 TransferMemoryResourceLinkToGPU(RecoStep::NoRecoStep, processors()->trdTrackerGPU.MemoryPermanent(), stream);
646 }
647 }
648 }
649 if (mRec->IsGPU()) {
650 std::array<uint8_t, sizeof(GPUTrackingFlatObjects)> oldFlatPtrs, oldFlatPtrsDevice;
651 memcpy(oldFlatPtrs.data(), (void*)&mFlatObjectsShadow, oldFlatPtrs.size());
652 memcpy(oldFlatPtrsDevice.data(), (void*)&mFlatObjectsDevice, oldFlatPtrsDevice.size());
654 bool ptrsChanged = memcmp(oldFlatPtrs.data(), (void*)&mFlatObjectsShadow, oldFlatPtrs.size()) || memcmp(oldFlatPtrsDevice.data(), (void*)&mFlatObjectsDevice, oldFlatPtrsDevice.size());
655 if (ptrsChanged) {
656 GPUInfo("Updating all calib objects since pointers changed");
657 }
658 UpdateGPUCalibObjects(stream, ptrsChanged ? nullptr : mNewCalibObjects.get());
659 }
660 }
661
662 if ((mUpdateNewCalibObjects || (mRec->slavesExist() && updateSlave)) && mRec->IsGPU()) {
663 UpdateGPUCalibObjectsPtrs(stream); // Reinitialize
664 retVal = 1;
665 }
666 mNewCalibObjects.reset(nullptr);
667 mNewCalibValues.reset(nullptr);
669 return retVal;
670}
671
673{
674 if ((((GetRecoSteps() & RecoStep::TRDTracking) && !GetProcessingSettings().trdTrackModelO2 && !GetProcessingSettings().willProvideO2PropagatorLate) || ((GetRecoSteps() & RecoStep::Refit) && !param().rec.trackingRefitGPUModel)) && processors()->calibObjects.o2Propagator == nullptr) {
675 GPUFatal("Cannot run TRD tracking or refit with o2 track model without o2 propagator"); // This check must happen during run, since o2::Propagator cannot be available during init
676 }
677 if (GetProcessingSettings().autoAdjustHostThreads && !mRec->IsGPU()) {
679 }
680 const auto threadContext = GetThreadContext();
681 if (GetProcessingSettings().runCompressionStatistics && mCompressionStatistics == nullptr) {
683 }
684 const bool needQA = GPUQA::QAAvailable() && (GetProcessingSettings().runQA || (GetProcessingSettings().eventDisplay && (mIOPtrs.nMCInfosTPC || GetProcessingSettings().runMC)));
685 if (needQA && GetQA()->IsInitialized() == false) {
686 if (GetQA()->InitQA(GetProcessingSettings().runQA ? -GetProcessingSettings().runQA : -1)) {
687 return 1;
688 }
689 }
690 if (needQA) {
691 mFractionalQAEnabled = GetProcessingSettings().qcRunFraction == 100.f || (uint32_t)(rand() % 10000) < (uint32_t)(GetProcessingSettings().qcRunFraction * 100);
692 }
693 if (GetProcessingSettings().debugLevel >= 6) {
694 *mDebugFile << "\n\nProcessing event " << mRec->getNEventsProcessed() << std::endl;
695 }
697
698 mRec->getGeneralStepTimer(GeneralStep::Prepare).Start();
699 try {
701 } catch (const std::bad_alloc& e) {
702 GPUError("Memory Allocation Error");
703 return (1);
704 }
705 mRec->getGeneralStepTimer(GeneralStep::Prepare).Stop();
706
708
709 SynchronizeStream(0); // Synchronize all init copies that might be ongoing
710
712 if (runRecoStep(RecoStep::TPCDecompression, &GPUChainTracking::RunTPCDecompression)) {
713 return 1;
714 }
715 } else if (mIOPtrs.tpcPackedDigits || mIOPtrs.tpcZS) {
716 if (runRecoStep(RecoStep::TPCClusterFinding, &GPUChainTracking::RunTPCClusterizer, false)) {
717 return 1;
718 }
719 }
720
721 if (GetProcessingSettings().autoAdjustHostThreads && !mRec->IsGPU() && mIOPtrs.clustersNative) {
723 }
724
726 return 1;
727 }
728
729 mRec->PushNonPersistentMemory(qStr2Tag("TPCSLCD1")); // 1st stack level for TPC tracking sector data
731 if (runRecoStep(RecoStep::TPCSectorTracking, &GPUChainTracking::RunTPCTrackingSectors)) {
732 return 1;
733 }
734
735 if (runRecoStep(RecoStep::TPCMerging, &GPUChainTracking::RunTPCTrackingMerger, false)) {
736 return 1;
737 }
739 mRec->PopNonPersistentMemory(RecoStep::TPCSectorTracking, qStr2Tag("TPCSLCD1")); // Release 1st stack level, TPC sector data not needed after merger
741 }
742
744 if (GetProcessingSettings().doublePipeline) {
746 if (foreignChain && foreignChain->mIOPtrs.tpcZS) {
747 if (GetProcessingSettings().debugLevel >= 3) {
748 GPUInfo("Preempting tpcZS input of foreign chain");
749 }
750 mPipelineFinalizationCtx.reset(new GPUChainTrackingFinalContext);
751 mPipelineFinalizationCtx->rec = this->mRec;
752 foreignChain->mPipelineNotifyCtx = mPipelineFinalizationCtx.get();
753 }
754 }
755 if (runRecoStep(RecoStep::TPCCompression, &GPUChainTracking::RunTPCCompression)) {
756 return 1;
757 }
758 }
759
760 if (runRecoStep(RecoStep::TRDTracking, &GPUChainTracking::RunTRDTracking)) {
761 return 1;
762 }
763
764 if (runRecoStep(RecoStep::Refit, &GPUChainTracking::RunRefit)) {
765 return 1;
766 }
767
768 if (!GetProcessingSettings().doublePipeline) { // Synchronize with output copies running asynchronously
770 }
771
772 if (GetProcessingSettings().autoAdjustHostThreads && !mRec->IsGPU()) {
774 }
775
776 int32_t retVal = 0;
777 if (CheckErrorCodes(false, false, mRec->getErrorCodeOutput())) {
778 retVal = 3;
779 if (!GetProcessingSettings().ignoreNonFatalGPUErrors) {
780 return retVal;
781 }
782 }
783
784 if (GetProcessingSettings().doublePipeline) {
785 return retVal;
786 }
787 int32_t retVal2 = RunChainFinalize();
788 return retVal2 ? retVal2 : retVal;
789}
790
791int32_t GPUChainTracking::RunChainFinalize()
792{
793 if (mIOPtrs.clustersNative && (GetRecoSteps() & RecoStep::TPCCompression) && GetProcessingSettings().runCompressionStatistics) {
796 }
797
798 if (GetProcessingSettings().outputSanityCheck) {
799 SanityCheck();
800 }
801
802 const bool needQA = GPUQA::QAAvailable() && (GetProcessingSettings().runQA || (GetProcessingSettings().eventDisplay && mIOPtrs.nMCInfosTPC));
803 if (needQA && mFractionalQAEnabled) {
804 mRec->getGeneralStepTimer(GeneralStep::QA).Start();
805 GetQA()->UpdateChain(this);
806 GetQA()->RunQA(!GetProcessingSettings().runQA);
807 mRec->getGeneralStepTimer(GeneralStep::QA).Stop();
808 if (GetProcessingSettings().debugLevel == 0) {
809 GPUInfo("Total QA runtime: %d us", (int32_t)(mRec->getGeneralStepTimer(GeneralStep::QA).GetElapsedTime() * 1000000));
810 }
811 }
812
813 if (GetProcessingSettings().showOutputStat) {
815 }
816
818
819 // PrintMemoryRelations();
820
822 if (!mDisplayRunning) {
823 if (mEventDisplay->StartDisplay()) {
824 return (1);
825 }
826 mDisplayRunning = true;
827 } else {
828 mEventDisplay->ShowNextEvent();
829 }
830
831 if (GetProcessingSettings().eventDisplay->EnableSendKey()) {
832 while (kbhit()) {
833 getch();
834 }
835 GPUInfo("Press key for next event!");
836 }
837
838 int32_t iKey;
839 do {
840 Sleep(10);
841 if (GetProcessingSettings().eventDisplay->EnableSendKey()) {
842 iKey = kbhit() ? getch() : 0;
843 if (iKey == 27) {
844 GetProcessingSettings().eventDisplay->setDisplayControl(2);
845 } else if (iKey == 'n') {
846 break;
847 } else if (iKey) {
848 while (GetProcessingSettings().eventDisplay->getSendKey() != 0) {
849 Sleep(1);
850 }
851 GetProcessingSettings().eventDisplay->setSendKey(iKey);
852 }
853 }
854 } while (GetProcessingSettings().eventDisplay->getDisplayControl() == 0);
855 if (GetProcessingSettings().eventDisplay->getDisplayControl() == 2) {
856 mDisplayRunning = false;
857 GetProcessingSettings().eventDisplay->DisplayExit();
858 const_cast<GPUSettingsProcessing&>(GetProcessingSettings()).eventDisplay = nullptr; // TODO: fixme - eventDisplay should probably not be put into ProcessingSettings in the first place
859 return (2);
860 }
861 GetProcessingSettings().eventDisplay->setDisplayControl(0);
862 GPUInfo("Loading next event");
863
864 mEventDisplay->WaitForNextEvent();
865 }
866
867 return 0;
868}
869
871{
872 if (mPipelineFinalizationCtx) {
873 {
874 std::unique_lock<std::mutex> lock(mPipelineFinalizationCtx->mutex);
875 auto* ctx = mPipelineFinalizationCtx.get();
876 mPipelineFinalizationCtx->cond.wait(lock, [ctx]() { return ctx->ready; });
877 }
878 mPipelineFinalizationCtx.reset();
879 }
880 return RunChainFinalize();
881}
882
883int32_t GPUChainTracking::CheckErrorCodes(bool cpuOnly, bool forceShowErrors, std::vector<std::array<uint32_t, 4>>* fillErrors)
884{
885 int32_t retVal = 0;
886 for (int32_t i = 0; i < 1 + (!cpuOnly && mRec->IsGPU()); i++) {
887 if (i) {
888 const auto& threadContext = GetThreadContext();
889 if (GetProcessingSettings().doublePipeline) {
890 TransferMemoryResourceLinkToHost(RecoStep::NoRecoStep, mInputsHost->mResourceErrorCodes, 0);
892 } else {
893 TransferMemoryResourceLinkToHost(RecoStep::NoRecoStep, mInputsHost->mResourceErrorCodes);
894 }
895 }
896 if (processors()->errorCodes.hasError()) {
897 static int32_t errorsShown = 0;
898 static bool quiet = false;
899 static std::chrono::time_point<std::chrono::steady_clock> silenceFrom;
900 if (!quiet && errorsShown++ >= 10 && GetProcessingSettings().throttleAlarms && !forceShowErrors) {
901 silenceFrom = std::chrono::steady_clock::now();
902 quiet = true;
903 } else if (quiet) {
904 auto currentTime = std::chrono::steady_clock::now();
905 std::chrono::duration<double> elapsed_seconds = currentTime - silenceFrom;
906 if (elapsed_seconds.count() > 60 * 10) {
907 quiet = false;
908 errorsShown = 1;
909 }
910 }
911 retVal = 1;
912 if (GetProcessingSettings().throttleAlarms && !forceShowErrors) {
913 GPUWarning("GPUReconstruction suffered from an error in the %s part", i ? "GPU" : "CPU");
914 } else {
915 GPUError("GPUReconstruction suffered from an error in the %s part", i ? "GPU" : "CPU");
916 }
917 if (!quiet) {
918 processors()->errorCodes.printErrors(GetProcessingSettings().throttleAlarms && !forceShowErrors);
919 }
920 if (fillErrors) {
921 uint32_t nErrors = processors()->errorCodes.getNErrors();
922 const uint32_t* pErrors = processors()->errorCodes.getErrorPtr();
923 for (uint32_t j = 0; j < nErrors; j++) {
924 fillErrors->emplace_back(std::array<uint32_t, 4>{pErrors[4 * j], pErrors[4 * j + 1], pErrors[4 * j + 2], pErrors[4 * j + 3]});
925 }
926 }
927 }
928 }
929 ClearErrorCodes(cpuOnly);
930 return retVal;
931}
932
934{
936 if (mRec->IsGPU() && !cpuOnly) {
937 const auto& threadContext = GetThreadContext();
938 WriteToConstantMemory(RecoStep::NoRecoStep, (char*)&processors()->errorCodes - (char*)processors(), &processorsShadow()->errorCodes, sizeof(processorsShadow()->errorCodes), 0);
939 TransferMemoryResourceLinkToGPU(RecoStep::NoRecoStep, mInputsHost->mResourceErrorCodes, 0);
940 }
941}
942
944{
945 std::lock_guard lk(mMutexUpdateCalib);
946 if (mNewCalibObjects) {
947 void* const* pSrc = (void* const*)&obj;
948 void** pDst = (void**)mNewCalibObjects.get();
949 for (uint32_t i = 0; i < sizeof(*mNewCalibObjects) / sizeof(void*); i++) {
950 if (pSrc[i]) {
951 pDst[i] = pSrc[i];
952 }
953 }
954 } else {
956 }
957 if (mNewCalibValues) {
958 mNewCalibValues->updateFrom(&vals);
959 } else {
960 mNewCalibValues.reset(new GPUNewCalibValues(vals));
961 }
963}
964
966{
967 return (mRec->IsGPU() ? processorsShadow() : processors())->calibObjects.o2Propagator;
968}
969
971{
973 if ((prop->getGPUField() != nullptr) ^ GetProcessingSettings().o2PropagatorUseGPUField) {
974 GPUFatal("GPU magnetic field for propagator requested, but received an O2 propagator without GPU field");
975 }
976}
Definition of container class for dE/dx corrections.
Helper class to access correction maps.
int32_t i
#define GPUCA_MEMORY_SIZE
#define GPUCA_HOST_MEMORY_SIZE
int32_t retVal
Online TRD tracker based on extrapolated TPC tracks.
Used for storing the MC labels for the TRD tracklets.
TRD Tracklet word for GPU tracker - 32bit tracklet info + half chamber ID + index.
Definition of a container to keep Monte Carlo truth external to simulation objects.
uint32_t j
Definition RawData.h:0
uint32_t c
Definition RawData.h:2
Definition of TPCFastTransform class.
void Start()
Definition timer.cxx:57
double GetElapsedTime()
Definition timer.cxx:108
void Stop()
Definition timer.cxx:69
bool isSet(const bitfield &v) const
Definition bitfield.h:70
size_t getFlatBufferSize() const
Gives size of the flat buffer.
Definition FlatObject.h:256
void SetMatLUT(std::unique_ptr< o2::base::MatLayerCylSet > &&lut)
std::unique_ptr< o2::base::MatLayerCylSet > mMatLUTU
const o2::base::Propagator * GetDeviceO2Propagator()
void SetTRDGeometry(std::unique_ptr< o2::trd::GeometryFlat > &&geo)
GPUChainTracking * mQAFromForeignChain
void SetO2Propagator(const o2::base::Propagator *prop)
std::unique_ptr< GPUQA > mQA
std::unique_ptr< CorrectionMapsHelper > mTPCFastTransformHelperU
GPUTrackingFlatObjects mFlatObjectsDevice
int32_t RunTPCClusterizer(bool synchronizeOutput=true)
void UpdateGPUCalibObjectsPtrs(int32_t stream)
int32_t RunTPCTrackingMerger(bool synchronizeOutput=true)
std::unique_ptr< GPUTrackingInputProvider > mInputsHost
std::unique_ptr< GPUTPCClusterStatistics > mCompressionStatistics
const o2::base::MatLayerCylSet * GetMatLUT() const
std::array< GPUOutputControl *, GPUTrackingOutputs::count()> mSubOutputControls
std::unique_ptr< std::ofstream > mDebugFile
void SetUpdateCalibObjects(const GPUCalibObjectsConst &obj, const GPUNewCalibValues &vals)
std::unique_ptr< GPUCalibObjectsConst > mNewCalibObjects
std::unique_ptr< o2::trd::GeometryFlat > mTRDGeometryU
GPUTrackingFlatObjects mFlatObjectsShadow
void RegisterPermanentMemoryAndProcessors() override
void RegisterGPUProcessors() override
void ClearErrorCodes(bool cpuOnly=false)
const GPUQA * GetQA() const
void MemorySize(size_t &gpuMem, size_t &pageLockedHostMem) override
void SetTPCFastTransform(std::unique_ptr< TPCFastTransform > &&tpcFastTransform, std::unique_ptr< CorrectionMapsHelper > &&tpcTransformHelper)
int32_t DoQueuedUpdates(int32_t stream, bool updateSlave=true)
std::unique_ptr< GPUNewCalibValues > mNewCalibValues
int32_t CheckErrorCodes(bool cpuOnly=false, bool forceShowErrors=false, std::vector< std::array< uint32_t, 4 > > *fillErrors=nullptr) override
std::unique_ptr< TPCFastTransform > mTPCFastTransformU
int32_t PrepareEvent() override
GPUChainTracking(GPUReconstruction *rec, uint32_t maxTPCHits=GPUCA_MAX_CLUSTERS, uint32_t maxTRDTracklets=GPUCA_MAX_TRD_TRACKLETS)
void UpdateGPUCalibObjects(int32_t stream, const GPUCalibObjectsConst *ptrMask=nullptr)
GPUTrackingInOutPointers & mIOPtrs
struct o2::gpu::GPUChainTracking::InOutMemory mIOMem
const o2::tpc::CalibdEdxContainer * GetdEdxCalibContainer() const
std::unique_ptr< GPUTrackingInputProvider > mInputsShadow
const GPUSettingsQA * mConfigQA
int32_t FinalizePipelinedProcessing() override
std::unique_ptr< GPUDisplayInterface > mEventDisplay
void TransferMemoryResourceLinkToGPU(RecoStep step, int16_t res, int32_t stream=-1, deviceEvent *ev=nullptr, deviceEvent *evList=nullptr, int32_t nEvents=1)
Definition GPUChain.h:123
GPUConstantMem * processorsDevice()
Definition GPUChain.h:85
GPUReconstruction::RecoStepField GetRecoStepsGPU() const
Definition GPUChain.h:71
GPUReconstruction::RecoStepField GetRecoSteps() const
Definition GPUChain.h:70
void WriteToConstantMemory(RecoStep step, size_t offset, const void *src, size_t size, int32_t stream=-1, deviceEvent *ev=nullptr)
Definition GPUChain.h:126
GPUChain * GetNextChainInQueue()
Definition GPUChain.h:224
GPUReconstruction::InOutTypeField GetRecoStepsOutputs() const
Definition GPUChain.h:73
virtual std::unique_ptr< GPUReconstructionProcessing::threadContext > GetThreadContext()
Definition GPUChain.h:108
GPUConstantMem * processors()
Definition GPUChain.h:83
GPUParam & param()
Definition GPUChain.h:86
const GPUSettingsProcessing & GetProcessingSettings() const
Definition GPUChain.h:75
void SynchronizeStream(int32_t stream)
Definition GPUChain.h:88
GPUReconstructionCPU * mRec
Definition GPUChain.h:78
GPUConstantMem * processorsShadow()
Definition GPUChain.h:84
GPUReconstruction::InOutTypeField GetRecoStepsInputs() const
Definition GPUChain.h:72
static constexpr int32_t NSECTORS
Definition GPUChain.h:57
void TransferMemoryResourceLinkToHost(RecoStep step, int16_t res, int32_t stream=-1, deviceEvent *ev=nullptr, deviceEvent *evList=nullptr, int32_t nEvents=1)
Definition GPUChain.h:124
void AllocateIOMemoryHelper(uint32_t n, const T *&ptr, std::unique_ptr< T[]> &u)
Definition GPUChain.h:138
int32_t runRecoStep(RecoStep step, S T::*func, Args... args)
Definition GPUChain.h:298
GPUReconstruction * rec()
Definition GPUChain.h:65
static constexpr const char *const RECO_STEP_NAMES[]
static GPUDisplayInterface * getDisplay(GPUDisplayFrontendInterface *frontend, GPUChainTracking *chain, GPUQA *qa, const GPUParam *param=nullptr, const GPUCalibObjectsConst *calib=nullptr, const GPUSettingsDisplay *config=nullptr)
const uint32_t * getErrorPtr() const
Definition GPUErrors.cxx:85
void setMemory(GPUglobalref() uint32_t *m)
Definition GPUErrors.h:34
void printErrors(bool silent=false)
Definition GPUErrors.cxx:57
uint32_t getNErrors() const
Definition GPUErrors.cxx:80
static void computePointerWithAlignment(T *&basePtr, S *&objPtr, size_t nEntries=1)
void InitGPUProcessor(GPUReconstruction *rec, ProcessorType type=PROCESSOR_TYPE_CPU, GPUProcessor *slaveProcessor=nullptr)
static bool QAAvailable()
Definition GPUQA.h:56
int32_t DrawQAHistograms()
Definition GPUQA.h:46
void UpdateChain(GPUChainTracking *chain)
Definition GPUQA.h:58
static bool IsInitialized()
Definition GPUQA.h:57
int32_t InitQA(int32_t tasks=0)
Definition GPUQA.h:44
void RunQA(bool matchOnly=false)
Definition GPUQA.h:45
HighResTimer & getGeneralStepTimer(GeneralStep step)
const GPUDefParameters & getGPUParameters(bool doGPU) const override
std::vector< std::array< uint32_t, 4 > > * getErrorCodeOutput()
void PopNonPersistentMemory(RecoStep step, uint64_t tag)
RecoStepField GetRecoStepsGPU() const
void RegisterGPUDeviceProcessor(GPUProcessor *proc, GPUProcessor *slaveProcessor)
void RegisterGPUProcessor(T *proc, bool deviceSlave)
void ResetRegisteredMemoryPointers(GPUProcessor *proc)
int16_t RegisterMemoryAllocation(T *proc, void *(T::*setPtr)(void *), int32_t type, const char *name="", const GPUMemoryReuse &re=GPUMemoryReuse())
void UpdateSettings(const GPUSettingsGRP *g, const GPUSettingsProcessing *p=nullptr, const GPUSettingsRecDynamic *d=nullptr)
void PushNonPersistentMemory(uint64_t tag)
GPUMemorySizeScalers * MemoryScalers()
const GPUSettingsProcessing & GetProcessingSettings() const
const GPUSettingsGRP & GetGRPSettings() const
GPUOutputControl & OutputControl()
static constexpr const uint32_t TPC_MAX_TF_TIME_BIN
Definition GPUSettings.h:47
GLenum GLfloat param
Definition glcorearb.h:271
GLuint GLuint stream
Definition glcorearb.h:1806
GPUCalibObjectsTemplate< ConstPtr > GPUCalibObjectsConst
Global TPC definitions and constants.
Definition SimTraits.h:167
Defining DataPointCompositeObject explicitly as copiable.
std::unique_ptr< GPUDisplayFrontendInterface > eventDisplay
GPUReconstruction * rec
constexpr T qStr2Tag(const char *str)
Definition strtag.h:22
S< o2::trd::GeometryFlat >::type * trdGeometry
S< o2::tpc::CalibdEdxContainer >::type * dEdxCalibContainer
S< TPCZSLinkMapping >::type * tpcZSLinkMapping
S< TPCFastTransform >::type * fastTransform
S< TPCPadGainCalib >::type * tpcPadGain
S< o2::base::PropagatorImpl< float > >::type * o2Propagator
S< o2::base::MatLayerCylSet >::type * matLUT
S< CorrectionMapsHelper >::type * fastTransformHelper
S< TPCFastTransform >::type * fastTransformRef
S< TPCFastTransform >::type * fastTransformMShape
std::unique_ptr< GPUTPCMCInfo[]> mcInfosTPC
std::unique_ptr< GPUTRDTrackletWord[]> trdTracklets
std::unique_ptr< GPUTPCMCInfoCol[]> mcInfosTPCCol
std::unique_ptr< GPUTPCGMMergedTrackHit[]> mergedTrackHits
std::unique_ptr< int32_t[]> trdTrackletIdxFirst
std::unique_ptr< GPUTPCGMMergedTrack[]> mergedTracks
std::unique_ptr< AliHLTTPCClusterMCLabel[]> mcLabelsTPC
std::unique_ptr< GPUTPCGMMergedTrackHitXYZ[]> mergedTrackHitsXYZ
std::unique_ptr< GPUTPCClusterData[]> clusterData[NSECTORS]
std::unique_ptr< o2::tpc::ClusterNative[]> clustersNative
std::unique_ptr< float[]> trdTriggerTimes
std::unique_ptr< GPUTPCTrack[]> sectorTracks[NSECTORS]
std::unique_ptr< GPUTRDSpacePoint[]> trdSpacePoints
std::unique_ptr< uint8_t[]> trdTrigRecMask
std::unique_ptr< o2::tpc::ClusterNativeAccess > clusterNativeAccess
std::unique_ptr< AliHLTTPCRawCluster[]> rawClusters[NSECTORS]
std::unique_ptr< GPUTPCHitId[]> sectorClusters[NSECTORS]
std::unique_ptr< GPUTRDTrackGPU[]> trdTracks
GPUTRDTrackerGPU trdTrackerGPU
GPUCalibObjectsConst calibObjects
const GPUTPCGMMergedTrackHitXYZ * mergedTrackHitsXYZ
const GPUTPCHitId * sectorClusters[NSECTORS]
const o2::tpc::ClusterNativeAccess * clustersNative
const GPUTPCMCInfo * mcInfosTPC
const o2::tpc::CompressedClustersFlat * tpcCompressedClusters
const AliHLTTPCClusterMCLabel * mcLabelsTPC
const GPUTRDSpacePoint * trdSpacePoints
const GPUTPCTrack * sectorTracks[NSECTORS]
const GPUTRDTrackGPU * trdTracks
const GPUTRDTrackletWord * trdTracklets
const GPUTrackingInOutZS * tpcZS
const AliHLTTPCRawCluster * rawClusters[NSECTORS]
const GPUTPCClusterData * clusterData[NSECTORS]
const GPUTPCGMMergedTrackHit * mergedTrackHits
const GPUTrackingInOutDigits * tpcPackedDigits
const GPUTPCMCInfoCol * mcInfosTPCCol
const GPUTPCGMMergedTrack * mergedTracks
size_t getIndex(const GPUOutputControl &v)
GPUOutputControl sharedClusterMap
GPUOutputControl compressedClusters