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 "GPUTPCGMMergedTrack.h"
26#include "GPUTPCTrack.h"
27#include "GPUTPCHitId.h"
28#include "GPUTPCClusterData.h"
29#include "TPCZSLinkMapping.h"
30#include "GPUTRDTrackletWord.h"
32#include "GPUTPCMCInfo.h"
33#include "GPUTRDTrack.h"
34#include "GPUTRDTracker.h"
35#include "AliHLTTPCRawCluster.h"
38#include "GPUQA.h"
39#include "GPULogging.h"
42#include "GPUNewCalibValues.h"
43#include "GPUTriggerOutputs.h"
44#include "GPUDefParametersRuntime.h"
45
47#include "GPUHostDataTypes.h"
49#include "GPUTrackingRefit.h"
50#include "CalibdEdxContainer.h"
51
52#include "TPCFastTransform.h"
54
55#include "utils/linux_helpers.h"
56#include "utils/strtag.h"
57using namespace o2::gpu;
58
59#include "GPUO2DataTypes.h"
60
61using namespace o2::tpc;
62using namespace o2::trd;
63
64GPUChainTracking::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)
65{
69}
70
72
74{
75 if (mRec->IsGPU()) {
79 }
80
82 if (GetRecoSteps() & RecoStep::TPCSectorTracking) {
83 for (uint32_t i = 0; i < NSECTORS; i++) {
84 mRec->RegisterGPUProcessor(&processors()->tpcTrackers[i], GetRecoStepsGPU() & RecoStep::TPCSectorTracking);
85 }
86 }
87 if (GetRecoSteps() & RecoStep::TPCMerging) {
88 mRec->RegisterGPUProcessor(&processors()->tpcMerger, GetRecoStepsGPU() & RecoStep::TPCMerging);
89 }
90 if (GetRecoSteps() & RecoStep::TRDTracking) {
91 mRec->RegisterGPUProcessor(&processors()->trdTrackerGPU, GetRecoStepsGPU() & RecoStep::TRDTracking);
92 }
93 if (GetRecoSteps() & RecoStep::TRDTracking) {
94 mRec->RegisterGPUProcessor(&processors()->trdTrackerO2, GetRecoStepsGPU() & RecoStep::TRDTracking);
95 }
96 if (GetRecoSteps() & RecoStep::TPCCompression) {
97 mRec->RegisterGPUProcessor(&processors()->tpcCompressor, GetRecoStepsGPU() & RecoStep::TPCCompression);
98 }
99 if (GetRecoSteps() & RecoStep::TPCDecompression) {
100 mRec->RegisterGPUProcessor(&processors()->tpcDecompressor, GetRecoStepsGPU() & RecoStep::TPCDecompression);
101 }
102 if (GetRecoSteps() & RecoStep::TPCClusterFinding) {
103 for (uint32_t i = 0; i < NSECTORS; i++) {
104 mRec->RegisterGPUProcessor(&processors()->tpcClusterer[i], GetRecoStepsGPU() & RecoStep::TPCClusterFinding);
105#ifdef GPUCA_HAS_ONNX
106 mRec->RegisterGPUProcessor(&processors()->tpcNNClusterer[i], GetRecoStepsGPU() & RecoStep::TPCClusterFinding);
107#endif
108 }
109 }
110 if (GetRecoSteps() & RecoStep::Refit) {
111 mRec->RegisterGPUProcessor(&processors()->trackingRefit, GetRecoStepsGPU() & RecoStep::Refit);
112 }
113#ifdef GPUCA_KERNEL_DEBUGGER_OUTPUT
114 mRec->RegisterGPUProcessor(&processors()->debugOutput, true);
115#endif
117}
118
120{
121 if (mRec->IsGPU()) {
123 }
124 memcpy((void*)&processorsShadow()->trdTrackerGPU, (const void*)&processors()->trdTrackerGPU, sizeof(processors()->trdTrackerGPU));
125 if (GetRecoStepsGPU() & RecoStep::TPCSectorTracking) {
126 for (uint32_t i = 0; i < NSECTORS; i++) {
127 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcTrackers[i], &processors()->tpcTrackers[i]);
128 }
129 }
130 if (GetRecoStepsGPU() & RecoStep::TPCMerging) {
131 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcMerger, &processors()->tpcMerger);
132 }
133 if (GetRecoStepsGPU() & RecoStep::TRDTracking) {
134 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->trdTrackerGPU, &processors()->trdTrackerGPU);
135 }
136
137 memcpy((void*)&processorsShadow()->trdTrackerO2, (const void*)&processors()->trdTrackerO2, sizeof(processors()->trdTrackerO2));
138 if (GetRecoStepsGPU() & RecoStep::TRDTracking) {
139 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->trdTrackerO2, &processors()->trdTrackerO2);
140 }
141 if (GetRecoStepsGPU() & RecoStep::TPCCompression) {
142 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcCompressor, &processors()->tpcCompressor);
143 }
144 if (GetRecoStepsGPU() & RecoStep::TPCDecompression) {
145 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcDecompressor, &processors()->tpcDecompressor);
146 }
147 if (GetRecoStepsGPU() & RecoStep::TPCClusterFinding) {
148 for (uint32_t i = 0; i < NSECTORS; i++) {
149 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcClusterer[i], &processors()->tpcClusterer[i]);
150#ifdef GPUCA_HAS_ONNX
151 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcNNClusterer[i], &processors()->tpcNNClusterer[i]);
152#endif
153 }
154 }
155 if (GetRecoStepsGPU() & RecoStep::Refit) {
156 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->trackingRefit, &processors()->trackingRefit);
157 }
158#ifdef GPUCA_KERNEL_DEBUGGER_OUTPUT
159 mRec->RegisterGPUDeviceProcessor(&processorsShadow()->debugOutput, &processors()->debugOutput);
160#endif
161}
162
163void GPUChainTracking::MemorySize(size_t& gpuMem, size_t& pageLockedHostMem)
164{
165 gpuMem = GPUCA_MEMORY_SIZE;
166 pageLockedHostMem = GPUCA_HOST_MEMORY_SIZE;
167}
168
170{
172 GPUError("Invalid Reconstruction Step Setting: dEdx requires TPC Merger to be active");
173 return false;
174 }
176 GPUError("Invalid GPU Reconstruction Step Setting: dEdx requires TPC Merger to be active");
177 return false;
178 }
180 GPUError("Invalid Reconstruction Step Setting: Tracking requires TPC Conversion to be active");
181 return false;
182 }
184 GPUError("Invalid input, TPC Clusterizer needs TPC raw input");
185 return false;
186 }
188 GPUError("Invalid input / output / step, merger cannot read/store sectors tracks and needs TPC conversion");
189 return false;
190 }
192 if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging) && !tpcClustersAvail) {
193 GPUError("Invalid Inputs for track merging, TPC Clusters required");
194 return false;
195 }
196#ifndef GPUCA_TPC_GEOMETRY_O2
198 GPUError("Can not run TPC GPU Cluster Finding with Run 2 Data");
199 return false;
200 }
201#endif
203 GPUError("Missing input for TPC Cluster conversion / sector tracking / compression / dEdx: TPC Clusters required");
204 return false;
205 }
207 GPUError("Input for TPC merger missing");
208 return false;
209 }
211 GPUError("Input for TPC compressor missing");
212 return false;
213 }
215 GPUError("Input for TRD Tracker missing");
216 return false;
217 }
219 GPUError("TPC Raw / TPC Clusters / TRD Tracklets cannot be output");
220 return false;
221 }
223 GPUError("No TPC Merged Track Output available");
224 return false;
225 }
227 GPUError("No TPC Compression Output available");
228 return false;
229 }
231 GPUError("No TRD Tracker Output available");
232 return false;
233 }
234 if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCdEdx) && (processors()->calibObjects.dEdxCalibContainer == nullptr)) {
235 GPUError("Cannot run dE/dx without dE/dx calibration container object");
236 return false;
237 }
238 if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCClusterFinding) && processors()->calibObjects.tpcPadGain == nullptr) {
239 GPUError("Cannot run gain calibration without calibration object");
240 return false;
241 }
242 if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCClusterFinding) && processors()->calibObjects.tpcZSLinkMapping == nullptr && mIOPtrs.tpcZS != nullptr) {
243 GPUError("Cannot run TPC ZS Decoder without mapping object. (tpczslinkmapping.dump missing?)");
244 return false;
245 }
246 return true;
247}
248
250{
251 int32_t gatherMode = mRec->GetProcessingSettings().tpcCompressionGatherMode == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression).par_COMP_GATHER_MODE : mRec->GetProcessingSettings().tpcCompressionGatherMode;
252 if ((param().rec.tpc.nWays & 1) == 0) {
253 GPUError("nWay setting musst be odd number!");
254 return false;
255 }
256 if (param().rec.tpc.mergerInterpolateErrors && param().rec.tpc.nWays < 3) {
257 GPUError("Cannot do error interpolation with NWays < 3!");
258 return false;
259 }
260 if (param().continuousMaxTimeBin > (int32_t)GPUSettings::TPC_MAX_TF_TIME_BIN) {
261 GPUError("configured max time bin exceeds 256 orbits");
262 return false;
263 }
264 if ((GetRecoStepsGPU() & RecoStep::TPCClusterFinding) && std::max(GetProcessingSettings().nTPCClustererLanes + 1, GetProcessingSettings().nTPCClustererLanes * 2) + (GetProcessingSettings().doublePipeline ? 1 : 0) > (int32_t)mRec->NStreams()) {
265 GPUError("NStreams of %d insufficient for %d nTPCClustererLanes", mRec->NStreams(), (int32_t)GetProcessingSettings().nTPCClustererLanes);
266 return false;
267 }
268 if ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) && GetProcessingSettings().noGPUMemoryRegistration && gatherMode != 3) {
269 GPUError("noGPUMemoryRegistration only possible with gather mode 3 (set to %d / %d)", mRec->GetProcessingSettings().tpcCompressionGatherMode, gatherMode);
270 return false;
271 }
272 if (mRec->IsGPU() && (GetProcessingSettings().clusterizerZSSanityCheck || GetProcessingSettings().mergerSanityCheck)) {
273 GPUError("Clusterizer and merger Sanity checks only supported when not running on GPU");
274 return false;
275 }
276 if (GetProcessingSettings().doublePipeline) {
278 GPUError("Invalid outputs for double pipeline mode 0x%x", (uint32_t)GetRecoStepsOutputs());
279 return false;
280 }
285 GPUError("Must use external output for double pipeline mode");
286 return false;
287 }
288 if (gatherMode == 1) {
289 GPUError("Double pipeline incompatible to compression mode 1");
290 return false;
291 }
293 GPUError("Invalid reconstruction settings for double pipeline: Needs compression and cluster finding");
294 return false;
295 }
296 }
297 if ((GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) && !(GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) && (gatherMode == 1 || gatherMode == 3)) {
298 GPUError("Invalid tpcCompressionGatherMode for compression on CPU");
299 return false;
300 }
301 if (GetProcessingSettings().tpcApplyClusterFilterOnCPU > 0 && (GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding || GetProcessingSettings().runMC)) {
302 GPUError("tpcApplyClusterFilterOnCPU cannot be used with GPU clusterization or with MC labels");
303 return false;
304 }
305 if (GetRecoSteps() & RecoStep::TRDTracking) {
306 if (GetProcessingSettings().trdTrackModelO2 && (GetProcessingSettings().createO2Output == 0 || (GetMatLUT() == nullptr && !GetProcessingSettings().willProvideO2PropagatorLate))) {
307 GPUError("TRD tracking can only run on O2 TPC tracks if createO2Output is enabled (%d), and matBudLUT is available (0x%p)", (int32_t)GetProcessingSettings().createO2Output, (void*)GetMatLUT());
308 return false;
309 }
310 if ((GetRecoStepsGPU() & RecoStep::TRDTracking) && !GetProcessingSettings().trdTrackModelO2 && GetProcessingSettings().createO2Output > 1) {
311 GPUError("TRD tracking can only run on GPU TPC tracks if the createO2Output setting does not suppress them");
312 return false;
313 }
314 if ((((GetRecoStepsGPU() & RecoStep::TRDTracking) && GetProcessingSettings().trdTrackModelO2) || ((GetRecoStepsGPU() & RecoStep::Refit) && !param().rec.trackingRefitGPUModel)) && (!GetProcessingSettings().o2PropagatorUseGPUField || (GetMatLUT() == nullptr && !GetProcessingSettings().willProvideO2PropagatorLate))) {
315 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());
316 return false;
317 }
318 }
319 return true;
320}
321
323{
324 const auto& threadContext = GetThreadContext();
325 if (GetProcessingSettings().debugLevel >= 1) {
326 printf("Enabled Reconstruction Steps: 0x%x (on GPU: 0x%x)", (int32_t)GetRecoSteps().get(), (int32_t)GetRecoStepsGPU().get());
327 for (uint32_t i = 0; i < sizeof(GPUDataTypes::RECO_STEP_NAMES) / sizeof(GPUDataTypes::RECO_STEP_NAMES[0]); i++) {
328 if (GetRecoSteps().isSet(1u << i)) {
329 printf(" - %s", GPUDataTypes::RECO_STEP_NAMES[i]);
330 if (GetRecoStepsGPU().isSet(1u << i)) {
331 printf(" (G)");
332 }
333 }
334 }
335 printf("\n");
336 }
337 if (!ValidateSteps()) {
338 return 1;
339 }
340
341 for (uint32_t i = 0; i < mSubOutputControls.size(); i++) {
342 if (mSubOutputControls[i] == nullptr) {
344 }
345 }
346
347 if (!ValidateSettings()) {
348 return 1;
349 }
350
353 if (!qa) {
354 qa.reset(new GPUQA(this));
355 }
356 }
359 if (mEventDisplay == nullptr) {
360 throw std::runtime_error("Error loading event display");
361 }
362 }
363
366
367 if (mRec->IsGPU()) {
369 UpdateGPUCalibObjectsPtrs(-1); // First initialization, for users not using RunChain
371 WriteToConstantMemory(RecoStep::NoRecoStep, (char*)&processors()->errorCodes - (char*)processors(), &processorsShadow()->errorCodes, sizeof(processorsShadow()->errorCodes), -1);
372 TransferMemoryResourceLinkToGPU(RecoStep::NoRecoStep, mInputsHost->mResourceErrorCodes);
373 }
374
375 if (GetProcessingSettings().debugLevel >= 6) {
376 std::string filename = std::string(mRec->IsGPU() ? "GPU" : "CPU") + (mRec->slaveId() != -1 ? (std::string("_slave") + std::to_string(mRec->slaveId())) : std::string(mRec->slavesExist() ? "_master" : "")) + GetProcessingSettings().debugLogSuffix + ".out";
377 mDebugFile->open(filename.c_str());
378 }
379
380 return 0;
381}
382
384{
385 if (processors()->calibObjects.fastTransform && (ptrMask == nullptr || ptrMask->fastTransform)) {
386 memcpy((void*)mFlatObjectsShadow.mCalibObjects.fastTransform, (const void*)processors()->calibObjects.fastTransform, sizeof(*processors()->calibObjects.fastTransform));
387 memcpy((void*)mFlatObjectsShadow.mTpcTransformBuffer, (const void*)processors()->calibObjects.fastTransform->getFlatBufferPtr(), processors()->calibObjects.fastTransform->getFlatBufferSize());
388 mFlatObjectsShadow.mCalibObjects.fastTransform->clearInternalBufferPtr();
391 }
392 if (processors()->calibObjects.fastTransformMShape && (ptrMask == nullptr || ptrMask->fastTransformMShape)) {
393 memcpy((void*)mFlatObjectsShadow.mCalibObjects.fastTransformMShape, (const void*)processors()->calibObjects.fastTransformMShape, sizeof(*processors()->calibObjects.fastTransformMShape));
394 memcpy((void*)mFlatObjectsShadow.mTpcTransformMShapeBuffer, (const void*)processors()->calibObjects.fastTransformMShape->getFlatBufferPtr(), processors()->calibObjects.fastTransformMShape->getFlatBufferSize());
395 mFlatObjectsShadow.mCalibObjects.fastTransformMShape->clearInternalBufferPtr();
398 }
399 if (processors()->calibObjects.fastTransformRef && (ptrMask == nullptr || ptrMask->fastTransformRef)) {
400 memcpy((void*)mFlatObjectsShadow.mCalibObjects.fastTransformRef, (const void*)processors()->calibObjects.fastTransformRef, sizeof(*processors()->calibObjects.fastTransformRef));
401 memcpy((void*)mFlatObjectsShadow.mTpcTransformRefBuffer, (const void*)processors()->calibObjects.fastTransformRef->getFlatBufferPtr(), processors()->calibObjects.fastTransformRef->getFlatBufferSize());
402 mFlatObjectsShadow.mCalibObjects.fastTransformRef->clearInternalBufferPtr();
405 }
406 if (processors()->calibObjects.fastTransformHelper && (ptrMask == nullptr || ptrMask->fastTransformHelper)) {
407 memcpy((void*)mFlatObjectsShadow.mCalibObjects.fastTransformHelper, (const void*)processors()->calibObjects.fastTransformHelper, sizeof(*processors()->calibObjects.fastTransformHelper));
411 }
412 if (processors()->calibObjects.dEdxCalibContainer && (ptrMask == nullptr || ptrMask->dEdxCalibContainer)) {
413 memcpy((void*)mFlatObjectsShadow.mCalibObjects.dEdxCalibContainer, (const void*)processors()->calibObjects.dEdxCalibContainer, sizeof(*processors()->calibObjects.dEdxCalibContainer));
414 memcpy((void*)mFlatObjectsShadow.mdEdxSplinesBuffer, (const void*)processors()->calibObjects.dEdxCalibContainer->getFlatBufferPtr(), processors()->calibObjects.dEdxCalibContainer->getFlatBufferSize());
415 mFlatObjectsShadow.mCalibObjects.dEdxCalibContainer->clearInternalBufferPtr();
418 }
419 if (processors()->calibObjects.matLUT && (ptrMask == nullptr || ptrMask->matLUT)) {
420 memcpy((void*)mFlatObjectsShadow.mCalibObjects.matLUT, (const void*)processors()->calibObjects.matLUT, sizeof(*processors()->calibObjects.matLUT));
421 memcpy((void*)mFlatObjectsShadow.mMatLUTBuffer, (const void*)processors()->calibObjects.matLUT->getFlatBufferPtr(), processors()->calibObjects.matLUT->getFlatBufferSize());
422 mFlatObjectsShadow.mCalibObjects.matLUT->clearInternalBufferPtr();
425 }
426 if (processors()->calibObjects.trdGeometry && (ptrMask == nullptr || ptrMask->trdGeometry)) {
427 memcpy((void*)mFlatObjectsShadow.mCalibObjects.trdGeometry, (const void*)processors()->calibObjects.trdGeometry, sizeof(*processors()->calibObjects.trdGeometry));
428 mFlatObjectsShadow.mCalibObjects.trdGeometry->clearInternalBufferPtr();
429 }
430 if (processors()->calibObjects.tpcPadGain && (ptrMask == nullptr || ptrMask->tpcPadGain)) {
431 memcpy((void*)mFlatObjectsShadow.mCalibObjects.tpcPadGain, (const void*)processors()->calibObjects.tpcPadGain, sizeof(*processors()->calibObjects.tpcPadGain));
432 }
433 if (processors()->calibObjects.tpcZSLinkMapping && (ptrMask == nullptr || ptrMask->tpcZSLinkMapping)) {
434 memcpy((void*)mFlatObjectsShadow.mCalibObjects.tpcZSLinkMapping, (const void*)processors()->calibObjects.tpcZSLinkMapping, sizeof(*processors()->calibObjects.tpcZSLinkMapping));
435 }
436 if (processors()->calibObjects.o2Propagator && (ptrMask == nullptr || ptrMask->o2Propagator)) {
437 memcpy((void*)mFlatObjectsShadow.mCalibObjects.o2Propagator, (const void*)processors()->calibObjects.o2Propagator, sizeof(*processors()->calibObjects.o2Propagator));
438 mFlatObjectsShadow.mCalibObjects.o2Propagator->setGPUField(&processorsDevice()->param.polynomialField);
440 }
442 memcpy((void*)&processorsShadow()->calibObjects, (void*)&mFlatObjectsDevice.mCalibObjects, sizeof(mFlatObjectsDevice.mCalibObjects));
443}
444
446{
447 WriteToConstantMemory(RecoStep::NoRecoStep, (char*)&processors()->calibObjects - (char*)processors(), &mFlatObjectsDevice.mCalibObjects, sizeof(mFlatObjectsDevice.mCalibObjects), stream);
448}
449
451{
455 }
456 if (mIOPtrs.tpcZS && param().rec.fwdTPCDigitsAsClusters) {
457 throw std::runtime_error("Forwading zero-suppressed hits not supported");
458 }
460 return 0;
461}
462
464{
466 if (!qa) {
467 qa.reset(new GPUQA(this));
468 }
469 if (!GetQA()->IsInitialized()) {
470 return GetQA()->InitQA();
471 }
472 return 0;
473}
474
476{
477 if (GetProcessingSettings().runQA && GetQA()->IsInitialized() && !(mConfigQA && mConfigQA->shipToQC) && !mQAFromForeignChain) {
478 GetQA()->UpdateChain(this);
480 }
481 if (GetProcessingSettings().debugLevel >= 6) {
482 mDebugFile->close();
483 }
485 mCompressionStatistics->Finish();
486 }
487 return 0;
488}
489
491{
492 char* fastTransformBase = (char*)mem;
496 }
500 }
504 }
507 }
508 if ((char*)mem - fastTransformBase < mChainTracking->GetProcessingSettings().fastTransformObjectsMinMemorySize) {
509 mem = fastTransformBase + mChainTracking->GetProcessingSettings().fastTransformObjectsMinMemorySize; // TODO: Fixme and do proper dynamic allocation
510 }
513 }
516 }
517 char* dummyPtr;
521 } else if (mChainTracking->GetProcessingSettings().lateO2MatLutProvisioningSize) {
522 computePointerWithAlignment(mem, dummyPtr, mChainTracking->GetProcessingSettings().lateO2MatLutProvisioningSize);
523 }
527 }
530 }
533 mCalibObjects.o2Propagator = nullptr; // Always reserve memory for o2::Propagator, since it may be propagatred only during run() not during init().
534 }
536 mem = (char*)mem + mChainTracking->GetProcessingSettings().calibObjectsExtraMemorySize; // TODO: Fixme and do proper dynamic allocation
537 }
538 return mem;
539}
540
542{
543 std::memset((void*)&mIOPtrs, 0, sizeof(mIOPtrs));
545 new (&mIOMem) InOutMemory;
546}
547
549{
550 for (uint32_t i = 0; i < NSECTORS; i++) {
555 }
557 std::memset(mIOMem.clusterNativeAccess.get(), 0, sizeof(ClusterNativeAccess)); // ClusterNativeAccess has no its own constructor
571}
572
573void GPUChainTracking::SetTPCFastTransform(std::unique_ptr<TPCFastTransform>&& tpcFastTransform, std::unique_ptr<CorrectionMapsHelper>&& tpcTransformHelper)
574{
575 mTPCFastTransformU = std::move(tpcFastTransform);
576 mTPCFastTransformHelperU = std::move(tpcTransformHelper);
579}
580
581void GPUChainTracking::SetMatLUT(std::unique_ptr<o2::base::MatLayerCylSet>&& lut)
582{
583 mMatLUTU = std::move(lut);
585}
586
587void GPUChainTracking::SetTRDGeometry(std::unique_ptr<o2::trd::GeometryFlat>&& geo)
588{
589 mTRDGeometryU = std::move(geo);
591}
592
593int32_t GPUChainTracking::DoQueuedUpdates(int32_t stream, bool updateSlave)
594{
595 int32_t retVal = 0;
596 std::unique_ptr<GPUSettingsGRP> grp;
597 const GPUSettingsProcessing* p = nullptr;
598 std::lock_guard lk(mMutexUpdateCalib);
600 if (mNewCalibValues->newSolenoidField || mNewCalibValues->newContinuousMaxTimeBin || mNewCalibValues->newTPCTimeBinCut) {
601 grp = std::make_unique<GPUSettingsGRP>(mRec->GetGRPSettings());
602 if (mNewCalibValues->newSolenoidField) {
603 grp->solenoidBzNominalGPU = mNewCalibValues->solenoidField;
604 }
605 if (mNewCalibValues->newContinuousMaxTimeBin) {
606 grp->grpContinuousMaxTimeBin = mNewCalibValues->continuousMaxTimeBin;
607 }
608 if (mNewCalibValues->newTPCTimeBinCut) {
609 grp->tpcCutTimeBin = mNewCalibValues->tpcTimeBinCut;
610 }
611 }
612 }
613 if (GetProcessingSettings().tpcDownscaledEdx != 0) {
615 }
616 if (grp || p) {
617 mRec->UpdateSettings(grp.get(), p);
618 retVal = 1;
619 }
621 if (mNewCalibObjects->o2Propagator && ((mNewCalibObjects->o2Propagator->getGPUField() != nullptr) ^ GetProcessingSettings().o2PropagatorUseGPUField)) {
622 GPUFatal("GPU magnetic field for propagator requested, but received an O2 propagator without GPU field");
623 }
624 void* const* pSrc = (void* const*)mNewCalibObjects.get();
625 void** pDst = (void**)&processors()->calibObjects;
626 for (uint32_t i = 0; i < sizeof(processors()->calibObjects) / sizeof(void*); i++) {
627 if (pSrc[i]) {
628 pDst[i] = pSrc[i];
629 }
630 }
632 if (GetProcessingSettings().trdTrackModelO2) {
634 if (mRec->IsGPU()) {
635 TransferMemoryResourceLinkToGPU(RecoStep::NoRecoStep, processors()->trdTrackerO2.MemoryPermanent(), stream);
636 }
637 } else {
639 if (mRec->IsGPU()) {
640 TransferMemoryResourceLinkToGPU(RecoStep::NoRecoStep, processors()->trdTrackerGPU.MemoryPermanent(), stream);
641 }
642 }
643 }
644 if (mRec->IsGPU()) {
645 std::array<uint8_t, sizeof(GPUTrackingFlatObjects)> oldFlatPtrs, oldFlatPtrsDevice;
646 memcpy(oldFlatPtrs.data(), (void*)&mFlatObjectsShadow, oldFlatPtrs.size());
647 memcpy(oldFlatPtrsDevice.data(), (void*)&mFlatObjectsDevice, oldFlatPtrsDevice.size());
649 bool ptrsChanged = memcmp(oldFlatPtrs.data(), (void*)&mFlatObjectsShadow, oldFlatPtrs.size()) || memcmp(oldFlatPtrsDevice.data(), (void*)&mFlatObjectsDevice, oldFlatPtrsDevice.size());
650 if (ptrsChanged) {
651 GPUInfo("Updating all calib objects since pointers changed");
652 }
653 UpdateGPUCalibObjects(stream, ptrsChanged ? nullptr : mNewCalibObjects.get());
654 }
655 }
656
657 if ((mUpdateNewCalibObjects || (mRec->slavesExist() && updateSlave)) && mRec->IsGPU()) {
658 UpdateGPUCalibObjectsPtrs(stream); // Reinitialize
659 retVal = 1;
660 }
661 mNewCalibObjects.reset(nullptr);
662 mNewCalibValues.reset(nullptr);
664 return retVal;
665}
666
668{
669 if ((((GetRecoSteps() & RecoStep::TRDTracking) && !GetProcessingSettings().trdTrackModelO2 && !GetProcessingSettings().willProvideO2PropagatorLate) || ((GetRecoSteps() & RecoStep::Refit) && !param().rec.trackingRefitGPUModel)) && processors()->calibObjects.o2Propagator == nullptr) {
670 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
671 }
672 if (GetProcessingSettings().autoAdjustHostThreads && !mRec->IsGPU()) {
674 }
675 const auto threadContext = GetThreadContext();
676 if (GetProcessingSettings().runCompressionStatistics && mCompressionStatistics == nullptr) {
678 }
679 const bool needQA = GPUQA::QAAvailable() && (GetProcessingSettings().runQA || (GetProcessingSettings().eventDisplay && (mIOPtrs.nMCInfosTPC || GetProcessingSettings().runMC)));
680 if (needQA && GetQA()->IsInitialized() == false) {
681 if (GetQA()->InitQA(GetProcessingSettings().runQA ? -GetProcessingSettings().runQA : -1)) {
682 return 1;
683 }
684 }
685 if (needQA) {
686 mFractionalQAEnabled = GetProcessingSettings().qcRunFraction == 100.f || (uint32_t)(rand() % 10000) < (uint32_t)(GetProcessingSettings().qcRunFraction * 100);
687 }
688 if (GetProcessingSettings().debugLevel >= 6) {
689 *mDebugFile << "\n\nProcessing event " << mRec->getNEventsProcessed() << std::endl;
690 }
692
693 mRec->getGeneralStepTimer(GeneralStep::Prepare).Start();
694 try {
696 } catch (const std::bad_alloc& e) {
697 GPUError("Memory Allocation Error");
698 return (1);
699 }
700 mRec->getGeneralStepTimer(GeneralStep::Prepare).Stop();
701
703
704 SynchronizeStream(0); // Synchronize all init copies that might be ongoing
705
706 if (GetProcessingSettings().debugOnFailure) {
707 mRec->setDebugDumpCallback([this]() { DoDebugRawDump(); });
708 }
709
711 if (runRecoStep(RecoStep::TPCDecompression, &GPUChainTracking::RunTPCDecompression)) {
712 return 1;
713 }
714 } else if (mIOPtrs.tpcPackedDigits || mIOPtrs.tpcZS) {
715 if (runRecoStep(RecoStep::TPCClusterFinding, &GPUChainTracking::RunTPCClusterizer, false)) {
716 return 1;
717 }
718 }
719
720 if (GetProcessingSettings().autoAdjustHostThreads && !mRec->IsGPU() && mIOPtrs.clustersNative) {
722 }
723
725 return 1;
726 }
727
728 mRec->PushNonPersistentMemory(qStr2Tag("TPCSLCD1")); // 1st stack level for TPC tracking sector data
730 if (runRecoStep(RecoStep::TPCSectorTracking, &GPUChainTracking::RunTPCTrackingSectors)) {
731 return 1;
732 }
733
734 if (runRecoStep(RecoStep::TPCMerging, &GPUChainTracking::RunTPCTrackingMerger, false)) {
735 return 1;
736 }
738 mRec->PopNonPersistentMemory(RecoStep::TPCSectorTracking, qStr2Tag("TPCSLCD1")); // Release 1st stack level, TPC sector data not needed after merger
740 }
741
743 if (GetProcessingSettings().doublePipeline) {
745 if (foreignChain && foreignChain->mIOPtrs.tpcZS) {
746 if (GetProcessingSettings().debugLevel >= 3) {
747 GPUInfo("Preempting tpcZS input of foreign chain");
748 }
749 mPipelineFinalizationCtx.reset(new GPUChainTrackingFinalContext);
750 mPipelineFinalizationCtx->rec = this->mRec;
751 foreignChain->mPipelineNotifyCtx = mPipelineFinalizationCtx.get();
752 }
753 }
754 if (runRecoStep(RecoStep::TPCCompression, &GPUChainTracking::RunTPCCompression)) {
755 return 1;
756 }
757 }
758
759 if (runRecoStep(RecoStep::TRDTracking, &GPUChainTracking::RunTRDTracking)) {
760 return 1;
761 }
762
763 if (runRecoStep(RecoStep::Refit, &GPUChainTracking::RunRefit)) {
764 return 1;
765 }
766
767 if (!GetProcessingSettings().doublePipeline) { // Synchronize with output copies running asynchronously
768 SynchronizeStream(OutputStream());
769 }
770
771 if (GetProcessingSettings().autoAdjustHostThreads && !mRec->IsGPU()) {
773 }
774
775 int32_t retVal = 0;
776 if (CheckErrorCodes(false, false, mRec->getErrorCodeOutput())) { // TODO: Eventually, we should use GPUReconstruction::CheckErrorCodes
777 retVal = 3;
778 if (!GetProcessingSettings().ignoreNonFatalGPUErrors) {
779 return retVal;
780 }
781 }
782
783 if (GetProcessingSettings().doublePipeline) {
784 return retVal;
785 }
786 int32_t retVal2 = RunChainFinalize();
787 return retVal2 ? retVal2 : retVal;
788}
789
790int32_t GPUChainTracking::RunChainFinalize()
791{
792 if (mIOPtrs.clustersNative && (GetRecoSteps() & RecoStep::TPCCompression) && GetProcessingSettings().runCompressionStatistics) {
795 }
796
797 if (GetProcessingSettings().outputSanityCheck) {
798 OutputSanityCheck();
799 }
800
801 const bool needQA = GPUQA::QAAvailable() && (GetProcessingSettings().runQA || (GetProcessingSettings().eventDisplay && mIOPtrs.nMCInfosTPC));
802 if (needQA && mFractionalQAEnabled) {
803 mRec->getGeneralStepTimer(GeneralStep::QA).Start();
804 GetQA()->UpdateChain(this);
805 GetQA()->RunQA(!GetProcessingSettings().runQA);
806 mRec->getGeneralStepTimer(GeneralStep::QA).Stop();
807 if (GetProcessingSettings().debugLevel == 0) {
808 GPUInfo("Total QA runtime: %d us", (int32_t)(mRec->getGeneralStepTimer(GeneralStep::QA).GetElapsedTime() * 1000000));
809 }
810 }
811
812 if (GetProcessingSettings().showOutputStat) {
814 }
815
817
818 // PrintMemoryRelations();
819
821 if (!mDisplayRunning) {
822 GPUInfo("Starting Event Display...");
823 if (mEventDisplay->StartDisplay()) {
824 GPUError("Error starting Event Display");
825 return (1);
826 }
827 mDisplayRunning = true;
828 } else {
829 mEventDisplay->ShowNextEvent();
830 }
831
832 mEventDisplay->WaitTillEventShown();
833
834 if (GetProcessingSettings().eventDisplay->EnableSendKey()) {
835 while (kbhit()) {
836 getch();
837 }
838 GPUInfo("Press key for next event!");
839 }
840
841 int32_t iKey;
842 do {
843 usleep(10000);
844 if (GetProcessingSettings().eventDisplay->EnableSendKey()) {
845 iKey = kbhit() ? getch() : 0;
846 if (iKey == 27) {
847 GetProcessingSettings().eventDisplay->setDisplayControl(2);
848 } else if (iKey == 'n') {
849 break;
850 } else if (iKey) {
851 while (GetProcessingSettings().eventDisplay->getSendKey() != 0) {
852 usleep(1000);
853 }
854 GetProcessingSettings().eventDisplay->setSendKey(iKey);
855 }
856 }
857 } while (GetProcessingSettings().eventDisplay->getDisplayControl() == 0);
858 if (GetProcessingSettings().eventDisplay->getDisplayControl() == 2) {
859 mDisplayRunning = false;
860 GetProcessingSettings().eventDisplay->DisplayExit();
861 const_cast<GPUSettingsProcessing&>(GetProcessingSettings()).eventDisplay = nullptr; // TODO: fixme - eventDisplay should probably not be put into ProcessingSettings in the first place
862 return (2);
863 }
864 GetProcessingSettings().eventDisplay->setDisplayControl(0);
865 GPUInfo("Loading next event...");
866
867 mEventDisplay->BlockTillNextEvent();
868 }
869
870 return 0;
871}
872
874{
875 if (mPipelineFinalizationCtx) {
876 {
877 std::unique_lock<std::mutex> lock(mPipelineFinalizationCtx->mutex);
878 auto* ctx = mPipelineFinalizationCtx.get();
879 mPipelineFinalizationCtx->cond.wait(lock, [ctx]() { return ctx->ready; });
880 }
881 mPipelineFinalizationCtx.reset();
882 }
883 return RunChainFinalize();
884}
885
886int32_t GPUChainTracking::CheckErrorCodes(bool cpuOnly, bool forceShowErrors, std::vector<std::array<uint32_t, 4>>* fillErrors)
887{
888 int32_t retVal = 0;
889 bool hasDebugError = false;
890 for (int32_t i = 0; i < 1 + (!cpuOnly && mRec->IsGPU()); i++) {
891 if (i) {
892 const auto& threadContext = GetThreadContext();
893 if (GetProcessingSettings().doublePipeline) {
894 TransferMemoryResourceLinkToHost(RecoStep::NoRecoStep, mInputsHost->mResourceErrorCodes, 0);
896 } else {
897 TransferMemoryResourceLinkToHost(RecoStep::NoRecoStep, mInputsHost->mResourceErrorCodes);
898 }
899 }
900 if (processors()->errorCodes.hasError()) {
901 static int32_t errorsShown = 0;
902 static bool quiet = false;
903 static std::chrono::time_point<std::chrono::steady_clock> silenceFrom;
904 if (!quiet && errorsShown++ >= 10 && GetProcessingSettings().throttleAlarms && !forceShowErrors) {
905 silenceFrom = std::chrono::steady_clock::now();
906 quiet = true;
907 } else if (quiet) {
908 auto currentTime = std::chrono::steady_clock::now();
909 std::chrono::duration<double> elapsed_seconds = currentTime - silenceFrom;
910 if (elapsed_seconds.count() > 60 * 10) {
911 quiet = false;
912 errorsShown = 1;
913 }
914 }
915 retVal = 1;
916 if (GetProcessingSettings().throttleAlarms && !forceShowErrors) {
917 GPUWarning("GPUReconstruction suffered from an error in the %s part", i ? "GPU" : "CPU");
918 } else {
919 GPUError("GPUReconstruction suffered from an error in the %s part", i ? "GPU" : "CPU");
920 }
921 if (!quiet) {
922 processors()->errorCodes.printErrors(GetProcessingSettings().throttleAlarms && !forceShowErrors);
923 }
924 if (fillErrors) {
925 uint32_t nErrors = processors()->errorCodes.getNErrors();
926 const uint32_t* pErrors = processors()->errorCodes.getErrorPtr();
927 for (uint32_t j = 0; j < nErrors; j++) {
928 fillErrors->emplace_back(std::array<uint32_t, 4>{pErrors[4 * j], pErrors[4 * j + 1], pErrors[4 * j + 2], pErrors[4 * j + 3]});
929 }
930 }
931 if ((GetProcessingSettings().debugOnFailure & 1) || (GetProcessingSettings().debugOnFailure & 4)) {
932 if (GetProcessingSettings().debugOnFailureErrorMask == (uint64_t)-1) {
933 hasDebugError = true;
934 } else {
935 uint32_t nErrors = processors()->errorCodes.getNErrors();
936 const uint32_t* pErrors = processors()->errorCodes.getErrorPtr();
937 for (uint32_t j = 0; j < nErrors; j++) {
938 if (GetProcessingSettings().debugOnFailureErrorMask & (1 << pErrors[4 * j])) {
939 hasDebugError = true;
940 break;
941 }
942 }
943 }
944 }
945 }
946 }
947 ClearErrorCodes(cpuOnly);
948 if (hasDebugError) {
950 }
951 return retVal;
952}
953
955{
957 if (mRec->IsGPU() && !cpuOnly) {
958 const auto& threadContext = GetThreadContext();
959 WriteToConstantMemory(RecoStep::NoRecoStep, (char*)&processors()->errorCodes - (char*)processors(), &processorsShadow()->errorCodes, sizeof(processorsShadow()->errorCodes), 0);
960 TransferMemoryResourceLinkToGPU(RecoStep::NoRecoStep, mInputsHost->mResourceErrorCodes, 0);
961 }
962}
963
965{
966 std::lock_guard lk(mMutexUpdateCalib);
967 if (mNewCalibObjects) {
968 void* const* pSrc = (void* const*)&obj;
969 void** pDst = (void**)mNewCalibObjects.get();
970 for (uint32_t i = 0; i < sizeof(*mNewCalibObjects) / sizeof(void*); i++) {
971 if (pSrc[i]) {
972 pDst[i] = pSrc[i];
973 }
974 }
975 } else {
977 }
978 if (mNewCalibValues) {
979 mNewCalibValues->updateFrom(&vals);
980 } else {
981 mNewCalibValues.reset(new GPUNewCalibValues(vals));
982 }
984}
985
987{
988 return (mRec->IsGPU() ? processorsShadow() : processors())->calibObjects.o2Propagator;
989}
990
992{
994 if ((prop->getGPUField() != nullptr) ^ GetProcessingSettings().o2PropagatorUseGPUField) {
995 GPUFatal("GPU magnetic field for propagator requested, but received an O2 propagator without GPU field");
996 }
997}
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:64
double GetElapsedTime()
Definition timer.cxx:115
void Stop()
Definition timer.cxx:76
bool isSet(const bitfield &v) const
Definition bitfield.h:66
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:124
GPUConstantMem * processorsDevice()
Definition GPUChain.h:86
GPUReconstruction::RecoStepField GetRecoStepsGPU() const
Definition GPUChain.h:72
GPUReconstruction::RecoStepField GetRecoSteps() const
Definition GPUChain.h:71
void WriteToConstantMemory(RecoStep step, size_t offset, const void *src, size_t size, int32_t stream=-1, deviceEvent *ev=nullptr)
Definition GPUChain.h:127
GPUChain * GetNextChainInQueue()
Definition GPUChain.h:225
GPUReconstruction::InOutTypeField GetRecoStepsOutputs() const
Definition GPUChain.h:74
virtual std::unique_ptr< GPUReconstructionProcessing::threadContext > GetThreadContext()
Definition GPUChain.h:109
GPUConstantMem * processors()
Definition GPUChain.h:84
GPUParam & param()
Definition GPUChain.h:87
const GPUSettingsProcessing & GetProcessingSettings() const
Definition GPUChain.h:76
void SynchronizeStream(int32_t stream)
Definition GPUChain.h:89
GPUReconstructionCPU * mRec
Definition GPUChain.h:79
GPUConstantMem * processorsShadow()
Definition GPUChain.h:85
GPUReconstruction::InOutTypeField GetRecoStepsInputs() const
Definition GPUChain.h:73
static constexpr int32_t NSECTORS
Definition GPUChain.h:58
void TransferMemoryResourceLinkToHost(RecoStep step, int16_t res, int32_t stream=-1, deviceEvent *ev=nullptr, deviceEvent *evList=nullptr, int32_t nEvents=1)
Definition GPUChain.h:125
void AllocateIOMemoryHelper(uint32_t n, const T *&ptr, std::unique_ptr< T[]> &u)
Definition GPUChain.h:139
int32_t runRecoStep(RecoStep step, S T::*func, Args... args)
Definition GPUChain.h:289
GPUReconstruction * rec()
Definition GPUChain.h:66
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 GPUSettingsProcessing *proc=nullptr)
const uint32_t * getErrorPtr() const
Definition GPUErrors.cxx:96
void setMemory(GPUglobalref() uint32_t *m)
Definition GPUErrors.h:37
bool printErrors(bool silent=false, uint64_t mask=0)
Definition GPUErrors.cxx:61
uint32_t getNErrors() const
Definition GPUErrors.cxx:91
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 setDebugDumpCallback(std::function< void()> &&callback=std::function< void()>(nullptr))
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::string to_string(gsl::span< T, Size > span)
Definition common.h:52
std::string filename()
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< 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 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