From d5da7562ebbfc8af5d605c573cc28719773299a5 Mon Sep 17 00:00:00 2001 From: Andres Rios Tascon Date: Wed, 18 Sep 2024 12:44:07 -0700 Subject: [PATCH] Moved segments to SoA+PortableCollection --- RecoTracker/LSTCore/interface/Constants.h | 2 + RecoTracker/LSTCore/src/alpaka/Event.dev.cc | 153 ++++----- RecoTracker/LSTCore/src/alpaka/Event.h | 9 +- RecoTracker/LSTCore/src/alpaka/Kernels.h | 44 +-- .../LSTCore/src/alpaka/NeuralNetwork.h | 4 +- .../LSTCore/src/alpaka/PixelQuintuplet.h | 44 +-- RecoTracker/LSTCore/src/alpaka/PixelTriplet.h | 120 +++---- RecoTracker/LSTCore/src/alpaka/Quintuplet.h | 85 +++-- RecoTracker/LSTCore/src/alpaka/Segment.h | 314 +++++++----------- .../LSTCore/src/alpaka/TrackCandidate.h | 72 ++-- RecoTracker/LSTCore/src/alpaka/Triplet.h | 72 ++-- RecoTracker/LSTCore/standalone/LST/Makefile | 10 +- RecoTracker/LSTCore/standalone/Makefile | 8 +- .../standalone/code/core/AccessHelper.cc | 12 +- .../standalone/code/core/write_lst_ntuple.cc | 78 ++--- 15 files changed, 467 insertions(+), 560 deletions(-) diff --git a/RecoTracker/LSTCore/interface/Constants.h b/RecoTracker/LSTCore/interface/Constants.h index 350857ac0b2e5..bb6b72b83f894 100644 --- a/RecoTracker/LSTCore/interface/Constants.h +++ b/RecoTracker/LSTCore/interface/Constants.h @@ -2,6 +2,7 @@ #define RecoTracker_LSTCore_interface_Constants_h #include "HeterogeneousCore/AlpakaInterface/interface/config.h" +#include "DataFormats/Common/interface/StdArray.h" #ifdef CACHE_ALLOC #include "HeterogeneousCore/AlpakaInterface/interface/CachedBufAlloc.h" @@ -62,6 +63,7 @@ namespace lst { }; struct Params_LS { static constexpr int kLayers = 2, kHits = 4; + using ArrayUxLayers = edm::StdArray; }; struct Params_T3 { static constexpr int kLayers = 3, kHits = 6; diff --git a/RecoTracker/LSTCore/src/alpaka/Event.dev.cc b/RecoTracker/LSTCore/src/alpaka/Event.dev.cc index 659591b836ec9..2f73e77478de1 100644 --- a/RecoTracker/LSTCore/src/alpaka/Event.dev.cc +++ b/RecoTracker/LSTCore/src/alpaka/Event.dev.cc @@ -57,8 +57,8 @@ void Event::resetEventSync() { miniDoubletsBuffers_.reset(); rangesInGPU_.reset(); rangesBuffers_.reset(); - segmentsInGPU_.reset(); - segmentsBuffers_.reset(); + segmentsDevCol_.reset(); + segmentsDev_.reset(); tripletsInGPU_.reset(); tripletsBuffers_.reset(); quintupletsInGPU_.reset(); @@ -73,7 +73,8 @@ void Event::resetEventSync() { hitsInCPU_.reset(); rangesInCPU_.reset(); mdsInCPU_.reset(); - segmentsInCPU_.reset(); + segmentsHostCol_.reset(); + segmentsHost_.reset(); tripletsInCPU_.reset(); quintupletsInCPU_.reset(); pixelTripletsInCPU_.reset(); @@ -201,7 +202,7 @@ void Event::addPixelSegmentToEvent(std::vector const& hitIndices0, alpaka::memcpy(queue_, miniDoubletsBuffers_->nMemoryLocations_buf, nTotalMDs_buf_h); } - if (!segmentsInGPU_) { + if (!segmentsDevCol_) { // can be optimized here: because we didn't distinguish pixel segments and outer-tracker segments and call them both "segments", so they use the index continuously. // If we want to further study the memory footprint in detail, we can separate the two and allocate different memories to them @@ -221,11 +222,13 @@ void Event::addPixelSegmentToEvent(std::vector const& hitIndices0, nTotalSegments_ += n_max_pixel_segments_per_module; - segmentsInGPU_.emplace(); - segmentsBuffers_.emplace(nTotalSegments_, nLowerModules_, n_max_pixel_segments_per_module, devAcc_, queue_); - segmentsInGPU_->setData(*segmentsBuffers_); + std::array const segments_sizes{{static_cast(nTotalSegments_), static_cast(nLowerModules_+1), static_cast(n_max_pixel_segments_per_module)}}; + segmentsDevCol_.emplace(segments_sizes, queue_); - alpaka::memcpy(queue_, segmentsBuffers_->nMemoryLocations_buf, nTotalSegments_view); + segmentsDev_.emplace(); + segmentsDev_->setData(*segmentsDevCol_); + + alpaka::memcpy(queue_, alpaka::createView(devAcc_, &segmentsDev_->mem.nMemoryLocations(), 1u), nTotalSegments_view); } auto hitIndices0_dev = allocBufWrapper(devAcc_, size, queue_); @@ -240,29 +243,31 @@ void Event::addPixelSegmentToEvent(std::vector const& hitIndices0, alpaka::memcpy(queue_, hitIndices3_dev, hitIndices3, size); alpaka::memcpy(queue_, dPhiChange_dev, dPhiChange, size); - alpaka::memcpy(queue_, segmentsBuffers_->ptIn_buf, ptIn, size); - alpaka::memcpy(queue_, segmentsBuffers_->ptErr_buf, ptErr, size); - alpaka::memcpy(queue_, segmentsBuffers_->px_buf, px, size); - alpaka::memcpy(queue_, segmentsBuffers_->py_buf, py, size); - alpaka::memcpy(queue_, segmentsBuffers_->pz_buf, pz, size); - alpaka::memcpy(queue_, segmentsBuffers_->etaErr_buf, etaErr, size); - alpaka::memcpy(queue_, segmentsBuffers_->isQuad_buf, isQuad, size); - alpaka::memcpy(queue_, segmentsBuffers_->eta_buf, eta, size); - alpaka::memcpy(queue_, segmentsBuffers_->phi_buf, phi, size); - alpaka::memcpy(queue_, segmentsBuffers_->charge_buf, charge, size); - alpaka::memcpy(queue_, segmentsBuffers_->seedIdx_buf, seedIdx, size); - alpaka::memcpy(queue_, segmentsBuffers_->superbin_buf, superbin, size); - alpaka::memcpy(queue_, segmentsBuffers_->pixelType_buf, pixelType, size); + alpaka::memcpy(queue_, alpaka::createView(devAcc_, segmentsDev_->pix.ptIn(), size), ptIn, size); + alpaka::memcpy(queue_, alpaka::createView(devAcc_, segmentsDev_->pix.ptErr(), size), ptErr, size); + alpaka::memcpy(queue_, alpaka::createView(devAcc_, segmentsDev_->pix.px(), size), px, size); + alpaka::memcpy(queue_, alpaka::createView(devAcc_, segmentsDev_->pix.py(), size), py, size); + alpaka::memcpy(queue_, alpaka::createView(devAcc_, segmentsDev_->pix.pz(), size), pz, size); + alpaka::memcpy(queue_, alpaka::createView(devAcc_, segmentsDev_->pix.etaErr(), size), etaErr, size); + alpaka::memcpy(queue_, alpaka::createView(devAcc_, segmentsDev_->pix.isQuad(), size), isQuad, size); + alpaka::memcpy(queue_, alpaka::createView(devAcc_, segmentsDev_->pix.eta(), size), eta, size); + alpaka::memcpy(queue_, alpaka::createView(devAcc_, segmentsDev_->pix.phi(), size), phi, size); + alpaka::memcpy(queue_, alpaka::createView(devAcc_, segmentsDev_->pix.charge(), size), charge, size); + alpaka::memcpy(queue_, alpaka::createView(devAcc_, segmentsDev_->pix.seedIdx(), size), seedIdx, size); + alpaka::memcpy(queue_, alpaka::createView(devAcc_, segmentsDev_->pix.superbin(), size), superbin, size); + alpaka::memcpy(queue_, alpaka::createView(devAcc_, segmentsDev_->pix.pixelType(), size), pixelType, size); // Create source views for size and mdSize auto src_view_size = alpaka::createView(cms::alpakatools::host(), &size, (Idx)1u); auto src_view_mdSize = alpaka::createView(cms::alpakatools::host(), &mdSize, (Idx)1u); - auto dst_view_segments = alpaka::createSubView(segmentsBuffers_->nSegments_buf, (Idx)1u, (Idx)pixelModuleIndex); + auto nSegments_view = alpaka::createView(devAcc_, segmentsDev_->mod.nSegments(), (Idx)nLowerModules_+1); + auto dst_view_segments = alpaka::createSubView(nSegments_view, (Idx)1u, (Idx)pixelModuleIndex); alpaka::memcpy(queue_, dst_view_segments, src_view_size); + auto totOccupancySegments_view = alpaka::createView(devAcc_, segmentsDev_->mod.totOccupancySegments(), (Idx)nLowerModules_+1); auto dst_view_totOccupancySegments = - alpaka::createSubView(segmentsBuffers_->totOccupancySegments_buf, (Idx)1u, (Idx)pixelModuleIndex); + alpaka::createSubView(totOccupancySegments_view, (Idx)1u, (Idx)pixelModuleIndex); alpaka::memcpy(queue_, dst_view_totOccupancySegments, src_view_size); auto dst_view_nMDs = alpaka::createSubView(miniDoubletsBuffers_->nMDs_buf, (Idx)1u, (Idx)pixelModuleIndex); @@ -285,7 +290,7 @@ void Event::addPixelSegmentToEvent(std::vector const& hitIndices0, *rangesInGPU_, *hitsInGPU_, *mdsInGPU_, - *segmentsInGPU_, + *segmentsDev_, hitIndices0_dev.data(), hitIndices1_dev.data(), hitIndices2_dev.data(), @@ -353,10 +358,11 @@ void Event::createMiniDoublets() { } void Event::createSegmentsWithModuleMap() { - if (!segmentsInGPU_) { - segmentsInGPU_.emplace(); - segmentsBuffers_.emplace(nTotalSegments_, nLowerModules_, n_max_pixel_segments_per_module, devAcc_, queue_); - segmentsInGPU_->setData(*segmentsBuffers_); + if (!segmentsDev_) { + std::array const segments_sizes{{static_cast(nTotalSegments_), static_cast(nLowerModules_+1), static_cast(n_max_pixel_segments_per_module)}}; + segmentsDevCol_.emplace(segments_sizes, queue_); + segmentsDev_.emplace(); + segmentsDev_->setData(*segmentsDevCol_); } Vec3D const threadsPerBlockCreateSeg{1, 1, 64}; @@ -369,7 +375,7 @@ void Event::createSegmentsWithModuleMap() { CreateSegmentsInGPUv2{}, *modulesBuffers_.data(), *mdsInGPU_, - *segmentsInGPU_, + *segmentsDev_, *rangesInGPU_); WorkDiv1D const addSegmentRangesToEventExplicit_workDiv = createWorkDiv({1}, {1024}, {1}); @@ -378,7 +384,7 @@ void Event::createSegmentsWithModuleMap() { addSegmentRangesToEventExplicit_workDiv, AddSegmentRangesToEventExplicit{}, *modulesBuffers_.data(), - *segmentsInGPU_, + *segmentsDev_, *rangesInGPU_); if (addObjects_) { @@ -395,7 +401,7 @@ void Event::createTriplets() { CreateTripletArrayRanges{}, *modulesBuffers_.data(), *rangesInGPU_, - *segmentsInGPU_); + *segmentsDev_); // TODO: Why are we pulling this back down only to put it back on the device in a new struct? auto maxTriplets_buf_h = cms::alpakatools::make_host_buffer(queue_, (Idx)1u); @@ -415,7 +421,8 @@ void Event::createTriplets() { // Allocate and copy nSegments from device to host (only nLowerModules in OT, not the +1 with pLSs) auto nSegments_buf_h = cms::alpakatools::make_host_buffer(queue_, nLowerModules_); - alpaka::memcpy(queue_, nSegments_buf_h, segmentsBuffers_->nSegments_buf, nLowerModules_); + auto nSegments_buf_d = alpaka::createView(devAcc_, segmentsDev_->mod.nSegments(), nLowerModules_); + alpaka::memcpy(queue_, nSegments_buf_h, nSegments_buf_d, nLowerModules_); // ... same for module_nConnectedModules // FIXME: replace by ES host data @@ -455,7 +462,7 @@ void Event::createTriplets() { CreateTripletsInGPUv2{}, *modulesBuffers_.data(), *mdsInGPU_, - *segmentsInGPU_, + *segmentsDev_, *tripletsInGPU_, *rangesInGPU_, index_gpu_buf.data(), @@ -493,7 +500,7 @@ void Event::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets) { *modulesBuffers_.data(), *rangesInGPU_, *pixelTripletsInGPU_, - *segmentsInGPU_, + *segmentsDev_, *pixelQuintupletsInGPU_); WorkDiv1D const addpT3asTrackCandidatesInGPU_workDiv = createWorkDiv({1}, {512}, {1}); @@ -504,7 +511,7 @@ void Event::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets) { nLowerModules_, *pixelTripletsInGPU_, *trackCandidatesInGPU_, - *segmentsInGPU_, + *segmentsDev_, *rangesInGPU_); // Pull nEligibleT5Modules from the device. @@ -557,7 +564,7 @@ void Event::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets) { WorkDiv3D const checkHitspLS_workDiv = createWorkDiv(blocksPerGridCheckHitspLS, threadsPerBlockCheckHitspLS, elementsPerThread); - alpaka::exec(queue_, checkHitspLS_workDiv, CheckHitspLS{}, *modulesBuffers_.data(), *segmentsInGPU_, true); + alpaka::exec(queue_, checkHitspLS_workDiv, CheckHitspLS{}, *modulesBuffers_.data(), *segmentsDev_, true); } Vec3D const threadsPerBlock_crossCleanpLS{1, 16, 32}; @@ -572,7 +579,7 @@ void Event::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets) { *rangesInGPU_, *pixelTripletsInGPU_, *trackCandidatesInGPU_, - *segmentsInGPU_, + *segmentsDev_, *mdsInGPU_, *hitsInGPU_, *quintupletsInGPU_); @@ -587,7 +594,7 @@ void Event::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets) { AddpLSasTrackCandidateInGPU{}, nLowerModules_, *trackCandidatesInGPU_, - *segmentsInGPU_, + *segmentsDev_, tc_pls_triplets); // Check if either n_max_pixel_track_candidates or n_max_nonpixel_track_candidates was reached @@ -626,8 +633,8 @@ void Event::createPixelTriplets() { auto superbins_buf = allocBufWrapper(cms::alpakatools::host(), n_max_pixel_segments_per_module, queue_); auto pixelTypes_buf = allocBufWrapper(cms::alpakatools::host(), n_max_pixel_segments_per_module, queue_); - alpaka::memcpy(queue_, superbins_buf, segmentsBuffers_->superbin_buf); - alpaka::memcpy(queue_, pixelTypes_buf, segmentsBuffers_->pixelType_buf); + alpaka::memcpy(queue_, superbins_buf, alpaka::createView(devAcc_, segmentsDev_->pix.superbin(), n_max_pixel_segments_per_module)); + alpaka::memcpy(queue_, pixelTypes_buf, alpaka::createView(devAcc_, segmentsDev_->pix.pixelType(), n_max_pixel_segments_per_module)); auto const* superbins = superbins_buf.data(); auto const* pixelTypes = pixelTypes_buf.data(); @@ -635,7 +642,9 @@ void Event::createPixelTriplets() { auto nInnerSegments_src_view = alpaka::createView(cms::alpakatools::host(), &nInnerSegments, (size_t)1u); // Create a sub-view for the device buffer - auto dev_view_nSegments = alpaka::createSubView(segmentsBuffers_->nSegments_buf, (Idx)1u, (Idx)nLowerModules_); + unsigned int totalModules = nLowerModules_ + 1; + auto dev_view_nSegments_buf = alpaka::createView(devAcc_, segmentsDev_->mod.nSegments(), totalModules); + auto dev_view_nSegments = alpaka::createSubView(dev_view_nSegments_buf, (Idx)1u, (Idx)nLowerModules_); alpaka::memcpy(queue_, nInnerSegments_src_view, dev_view_nSegments); alpaka::wait(queue_); // wait to get nInnerSegments (also superbins and pixelTypes) before using @@ -705,7 +714,7 @@ void Event::createPixelTriplets() { *modulesBuffers_.data(), *rangesInGPU_, *mdsInGPU_, - *segmentsInGPU_, + *segmentsDev_, *tripletsInGPU_, *pixelTripletsInGPU_, connectedPixelSize_dev_buf.data(), @@ -770,7 +779,7 @@ void Event::createQuintuplets() { CreateQuintupletsInGPUv2{}, *modulesBuffers_.data(), *mdsInGPU_, - *segmentsInGPU_, + *segmentsDev_, *tripletsInGPU_, *quintupletsInGPU_, *rangesInGPU_, @@ -809,7 +818,7 @@ void Event::pixelLineSegmentCleaning(bool no_pls_dupclean) { WorkDiv3D const checkHitspLS_workDiv = createWorkDiv(blocksPerGridCheckHitspLS, threadsPerBlockCheckHitspLS, elementsPerThread); - alpaka::exec(queue_, checkHitspLS_workDiv, CheckHitspLS{}, *modulesBuffers_.data(), *segmentsInGPU_, false); + alpaka::exec(queue_, checkHitspLS_workDiv, CheckHitspLS{}, *modulesBuffers_.data(), *segmentsDev_, false); } } @@ -828,8 +837,8 @@ void Event::createPixelQuintuplets() { auto superbins_buf = allocBufWrapper(cms::alpakatools::host(), n_max_pixel_segments_per_module, queue_); auto pixelTypes_buf = allocBufWrapper(cms::alpakatools::host(), n_max_pixel_segments_per_module, queue_); - alpaka::memcpy(queue_, superbins_buf, segmentsBuffers_->superbin_buf); - alpaka::memcpy(queue_, pixelTypes_buf, segmentsBuffers_->pixelType_buf); + alpaka::memcpy(queue_, superbins_buf, alpaka::createView(devAcc_, segmentsDev_->pix.superbin(), n_max_pixel_segments_per_module)); + alpaka::memcpy(queue_, pixelTypes_buf, alpaka::createView(devAcc_, segmentsDev_->pix.pixelType(), n_max_pixel_segments_per_module)); auto const* superbins = superbins_buf.data(); auto const* pixelTypes = pixelTypes_buf.data(); @@ -837,7 +846,9 @@ void Event::createPixelQuintuplets() { auto nInnerSegments_src_view = alpaka::createView(cms::alpakatools::host(), &nInnerSegments, (size_t)1u); // Create a sub-view for the device buffer - auto dev_view_nSegments = alpaka::createSubView(segmentsBuffers_->nSegments_buf, (Idx)1u, (Idx)nLowerModules_); + unsigned int totalModules = nLowerModules_ + 1; + auto dev_view_nSegments_buf = alpaka::createView(devAcc_, segmentsDev_->mod.nSegments(), totalModules); + auto dev_view_nSegments = alpaka::createSubView(dev_view_nSegments_buf, (Idx)1u, (Idx)nLowerModules_); alpaka::memcpy(queue_, nInnerSegments_src_view, dev_view_nSegments); alpaka::wait(queue_); // wait to get nInnerSegments (also superbins and pixelTypes) before using @@ -905,7 +916,7 @@ void Event::createPixelQuintuplets() { CreatePixelQuintupletsInGPUFromMapv2{}, *modulesBuffers_.data(), *mdsInGPU_, - *segmentsInGPU_, + *segmentsDev_, *tripletsInGPU_, *quintupletsInGPU_, *pixelQuintupletsInGPU_, @@ -932,7 +943,7 @@ void Event::createPixelQuintuplets() { nLowerModules_, *pixelQuintupletsInGPU_, *trackCandidatesInGPU_, - *segmentsInGPU_, + *segmentsDev_, *rangesInGPU_); #ifdef WARNINGS @@ -979,7 +990,8 @@ void Event::addMiniDoubletsToEventExplicit() { void Event::addSegmentsToEventExplicit() { auto nSegmentsCPU_buf = allocBufWrapper(cms::alpakatools::host(), nLowerModules_, queue_); - alpaka::memcpy(queue_, nSegmentsCPU_buf, segmentsBuffers_->nSegments_buf, nLowerModules_); + auto nSegments_buf = alpaka::createView(devAcc_, segmentsDev_->mod.nSegments(), nLowerModules_); + alpaka::memcpy(queue_, nSegmentsCPU_buf, nSegments_buf, nLowerModules_); // FIXME: replace by ES host data auto module_subdets_buf = allocBufWrapper(cms::alpakatools::host(), nLowerModules_, queue_); @@ -1343,40 +1355,19 @@ MiniDoubletsBuffer& Event::getMiniDoublets(bool sync) { return mdsInCPU_.value(); } -SegmentsBuffer& Event::getSegments(bool sync) { - if (!segmentsInCPU_) { - // Get nMemoryLocations parameter to initialize host based segmentsInCPU_ - auto nMemHost_buf_h = cms::alpakatools::make_host_buffer(queue_, 1u); - alpaka::memcpy(queue_, nMemHost_buf_h, segmentsBuffers_->nMemoryLocations_buf); - alpaka::wait(queue_); // wait for the value before using - - auto const nMemHost = *nMemHost_buf_h.data(); - segmentsInCPU_.emplace(nMemHost, nLowerModules_, n_max_pixel_segments_per_module, cms::alpakatools::host(), queue_); - segmentsInCPU_->setData(*segmentsInCPU_); - - alpaka::memcpy(queue_, segmentsInCPU_->nMemoryLocations_buf, segmentsBuffers_->nMemoryLocations_buf); - alpaka::memcpy(queue_, segmentsInCPU_->nSegments_buf, segmentsBuffers_->nSegments_buf); - alpaka::memcpy(queue_, segmentsInCPU_->mdIndices_buf, segmentsBuffers_->mdIndices_buf, 2u * nMemHost); - alpaka::memcpy(queue_, - segmentsInCPU_->innerMiniDoubletAnchorHitIndices_buf, - segmentsBuffers_->innerMiniDoubletAnchorHitIndices_buf, - nMemHost); - alpaka::memcpy(queue_, - segmentsInCPU_->outerMiniDoubletAnchorHitIndices_buf, - segmentsBuffers_->outerMiniDoubletAnchorHitIndices_buf, - nMemHost); - alpaka::memcpy(queue_, segmentsInCPU_->totOccupancySegments_buf, segmentsBuffers_->totOccupancySegments_buf); - alpaka::memcpy(queue_, segmentsInCPU_->ptIn_buf, segmentsBuffers_->ptIn_buf); - alpaka::memcpy(queue_, segmentsInCPU_->eta_buf, segmentsBuffers_->eta_buf); - alpaka::memcpy(queue_, segmentsInCPU_->phi_buf, segmentsBuffers_->phi_buf); - alpaka::memcpy(queue_, segmentsInCPU_->seedIdx_buf, segmentsBuffers_->seedIdx_buf); - alpaka::memcpy(queue_, segmentsInCPU_->isDup_buf, segmentsBuffers_->isDup_buf); - alpaka::memcpy(queue_, segmentsInCPU_->isQuad_buf, segmentsBuffers_->isQuad_buf); - alpaka::memcpy(queue_, segmentsInCPU_->score_buf, segmentsBuffers_->score_buf); +Segments& Event::getSegments(bool sync) { + if (!segmentsHost_) { + if constexpr (std::is_same_v) { + segmentsHost_.emplace(*segmentsDev_); + } else { + segmentsHostCol_.emplace(cms::alpakatools::CopyToHost::copyAsync(queue_, *segmentsDevCol_)); + segmentsHost_.emplace(); + segmentsHost_->setData(*segmentsHostCol_); + } if (sync) alpaka::wait(queue_); // host consumers expect filled data } - return segmentsInCPU_.value(); + return segmentsHost_.value(); } TripletsBuffer& Event::getTriplets(bool sync) { diff --git a/RecoTracker/LSTCore/src/alpaka/Event.h b/RecoTracker/LSTCore/src/alpaka/Event.h index 2b09565cf4176..68816bbb65a6c 100644 --- a/RecoTracker/LSTCore/src/alpaka/Event.h +++ b/RecoTracker/LSTCore/src/alpaka/Event.h @@ -48,8 +48,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { std::optional> hitsBuffers_; std::optional mdsInGPU_; std::optional> miniDoubletsBuffers_; - std::optional segmentsInGPU_; - std::optional> segmentsBuffers_; + std::optional segmentsDevCol_; + std::optional segmentsDev_; std::optional tripletsInGPU_; std::optional> tripletsBuffers_; std::optional quintupletsInGPU_; @@ -65,7 +65,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { std::optional> rangesInCPU_; std::optional> hitsInCPU_; std::optional> mdsInCPU_; - std::optional> segmentsInCPU_; + std::optional segmentsHostCol_; + std::optional segmentsHost_; std::optional> tripletsInCPU_; std::optional> trackCandidatesInCPU_; std::optional> modulesInCPU_; @@ -184,7 +185,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { HitsBuffer& getHitsInCMSSW(bool sync = true); ObjectRangesBuffer& getRanges(bool sync = true); MiniDoubletsBuffer& getMiniDoublets(bool sync = true); - SegmentsBuffer& getSegments(bool sync = true); + Segments& getSegments(bool sync = true); TripletsBuffer& getTriplets(bool sync = true); QuintupletsBuffer& getQuintuplets(bool sync = true); PixelTripletsBuffer& getPixelTriplets(bool sync = true); diff --git a/RecoTracker/LSTCore/src/alpaka/Kernels.h b/RecoTracker/LSTCore/src/alpaka/Kernels.h index bc284d052cc05..1cd3ef07145de 100644 --- a/RecoTracker/LSTCore/src/alpaka/Kernels.h +++ b/RecoTracker/LSTCore/src/alpaka/Kernels.h @@ -30,10 +30,10 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { pixelQuintupletsInGPU.isDup[pixelQuintupletIndex] = true; } - ALPAKA_FN_ACC ALPAKA_FN_INLINE void rmPixelSegmentFromMemory(Segments& segmentsInGPU, + ALPAKA_FN_ACC ALPAKA_FN_INLINE void rmPixelSegmentFromMemory(Segments segments, unsigned int pixelSegmentArrayIndex, bool secondpass = false) { - segmentsInGPU.isDup[pixelSegmentArrayIndex] |= 1 + secondpass; + segments.pix.isDup()[pixelSegmentArrayIndex] |= 1 + secondpass; } ALPAKA_FN_ACC ALPAKA_FN_INLINE int checkHitsT5(unsigned int ix, @@ -331,40 +331,40 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { struct CheckHitspLS { template - ALPAKA_FN_ACC void operator()(TAcc const& acc, Modules modulesInGPU, Segments segmentsInGPU, bool secondpass) const { + ALPAKA_FN_ACC void operator()(TAcc const& acc, Modules modulesInGPU, Segments segments, bool secondpass) const { auto const globalThreadIdx = alpaka::getIdx(acc); auto const gridThreadExtent = alpaka::getWorkDiv(acc); int pixelModuleIndex = *modulesInGPU.nLowerModules; - unsigned int nPixelSegments = segmentsInGPU.nSegments[pixelModuleIndex]; + unsigned int nPixelSegments = segments.mod.nSegments()[pixelModuleIndex]; if (nPixelSegments > n_max_pixel_segments_per_module) nPixelSegments = n_max_pixel_segments_per_module; for (unsigned int ix = globalThreadIdx[1]; ix < nPixelSegments; ix += gridThreadExtent[1]) { - if (secondpass && (!segmentsInGPU.isQuad[ix] || (segmentsInGPU.isDup[ix] & 1))) + if (secondpass && (!segments.pix.isQuad()[ix] || (segments.pix.isDup()[ix] & 1))) continue; unsigned int phits1[Params_pLS::kHits]; - phits1[0] = segmentsInGPU.pLSHitsIdxs[ix].x; - phits1[1] = segmentsInGPU.pLSHitsIdxs[ix].y; - phits1[2] = segmentsInGPU.pLSHitsIdxs[ix].z; - phits1[3] = segmentsInGPU.pLSHitsIdxs[ix].w; - float eta_pix1 = segmentsInGPU.eta[ix]; - float phi_pix1 = segmentsInGPU.phi[ix]; + phits1[0] = segments.pix.pLSHitsIdxs()[ix].x; + phits1[1] = segments.pix.pLSHitsIdxs()[ix].y; + phits1[2] = segments.pix.pLSHitsIdxs()[ix].z; + phits1[3] = segments.pix.pLSHitsIdxs()[ix].w; + float eta_pix1 = segments.pix.eta()[ix]; + float phi_pix1 = segments.pix.phi()[ix]; for (unsigned int jx = ix + 1 + globalThreadIdx[2]; jx < nPixelSegments; jx += gridThreadExtent[2]) { - float eta_pix2 = segmentsInGPU.eta[jx]; - float phi_pix2 = segmentsInGPU.phi[jx]; + float eta_pix2 = segments.pix.eta()[jx]; + float phi_pix2 = segments.pix.phi()[jx]; if (alpaka::math::abs(acc, eta_pix2 - eta_pix1) > 0.1f) continue; - if (secondpass && (!segmentsInGPU.isQuad[jx] || (segmentsInGPU.isDup[jx] & 1))) + if (secondpass && (!segments.pix.isQuad()[jx] || (segments.pix.isDup()[jx] & 1))) continue; - int8_t quad_diff = segmentsInGPU.isQuad[ix] - segmentsInGPU.isQuad[jx]; - float score_diff = segmentsInGPU.score[ix] - segmentsInGPU.score[jx]; + int8_t quad_diff = segments.pix.isQuad()[ix] - segments.pix.isQuad()[jx]; + float score_diff = segments.pix.score()[ix] - segments.pix.score()[jx]; // Always keep quads over trips. If they are the same, we want the object with better score int idxToRemove; if (quad_diff > 0) @@ -379,10 +379,10 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { idxToRemove = ix; unsigned int phits2[Params_pLS::kHits]; - phits2[0] = segmentsInGPU.pLSHitsIdxs[jx].x; - phits2[1] = segmentsInGPU.pLSHitsIdxs[jx].y; - phits2[2] = segmentsInGPU.pLSHitsIdxs[jx].z; - phits2[3] = segmentsInGPU.pLSHitsIdxs[jx].w; + phits2[0] = segments.pix.pLSHitsIdxs()[jx].x; + phits2[1] = segments.pix.pLSHitsIdxs()[jx].y; + phits2[2] = segments.pix.pLSHitsIdxs()[jx].z; + phits2[3] = segments.pix.pLSHitsIdxs()[jx].w; int npMatched = 0; for (int i = 0; i < Params_pLS::kHits; i++) { @@ -402,7 +402,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { } const int minNHitsForDup_pLS = 3; if (npMatched >= minNHitsForDup_pLS) { - rmPixelSegmentFromMemory(segmentsInGPU, idxToRemove, secondpass); + rmPixelSegmentFromMemory(segments, idxToRemove, secondpass); } if (secondpass) { float dEta = alpaka::math::abs(acc, eta_pix1 - eta_pix2); @@ -410,7 +410,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { float dR2 = dEta * dEta + dPhi * dPhi; if ((npMatched >= 1) || (dR2 < 1e-5f)) { - rmPixelSegmentFromMemory(segmentsInGPU, idxToRemove, secondpass); + rmPixelSegmentFromMemory(segments, idxToRemove, secondpass); } } } diff --git a/RecoTracker/LSTCore/src/alpaka/NeuralNetwork.h b/RecoTracker/LSTCore/src/alpaka/NeuralNetwork.h index 85b7b08dc075b..7f25f5882a8e8 100644 --- a/RecoTracker/LSTCore/src/alpaka/NeuralNetwork.h +++ b/RecoTracker/LSTCore/src/alpaka/NeuralNetwork.h @@ -18,7 +18,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC ALPAKA_FN_INLINE float runInference(TAcc const& acc, Modules const& modulesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, Triplets const& tripletsInGPU, const float* xVec, const float* yVec, @@ -59,7 +59,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { layer2_adjustment = 1; // get upper segment to be in second layer } unsigned int md_idx_for_t5_eta_phi = - segmentsInGPU.mdIndices[2 * tripletsInGPU.segmentIndices[2 * innerTripletIndex + layer2_adjustment]]; + segments.mem.mdIndices()[2 * tripletsInGPU.segmentIndices[2 * innerTripletIndex + layer2_adjustment]][0]; bool is_endcap1 = (modulesInGPU.subdets[lowerModuleIndex1] == 4); // true if anchor hit 1 is in the endcap bool is_endcap2 = (modulesInGPU.subdets[lowerModuleIndex2] == 4); // true if anchor hit 2 is in the endcap bool is_endcap3 = (modulesInGPU.subdets[lowerModuleIndex3] == 4); // true if anchor hit 3 is in the endcap diff --git a/RecoTracker/LSTCore/src/alpaka/PixelQuintuplet.h b/RecoTracker/LSTCore/src/alpaka/PixelQuintuplet.h index 180d8acf88bae..7d39609fc78f2 100644 --- a/RecoTracker/LSTCore/src/alpaka/PixelQuintuplet.h +++ b/RecoTracker/LSTCore/src/alpaka/PixelQuintuplet.h @@ -108,7 +108,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC ALPAKA_FN_INLINE void addPixelQuintupletToMemory(Modules const& modulesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, Quintuplets const& quintupletsInGPU, PixelQuintuplets& pixelQuintupletsInGPU, unsigned int pixelIndex, @@ -150,9 +150,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { quintupletsInGPU.logicalLayers[T5Index * Params_T5::kLayers + 4]; pixelQuintupletsInGPU.lowerModuleIndices[Params_pT5::kLayers * pixelQuintupletIndex] = - segmentsInGPU.innerLowerModuleIndices[pixelIndex]; + segments.mem.innerLowerModuleIndices()[pixelIndex]; pixelQuintupletsInGPU.lowerModuleIndices[Params_pT5::kLayers * pixelQuintupletIndex + 1] = - segmentsInGPU.outerLowerModuleIndices[pixelIndex]; + segments.mem.outerLowerModuleIndices()[pixelIndex]; pixelQuintupletsInGPU.lowerModuleIndices[Params_pT5::kLayers * pixelQuintupletIndex + 2] = quintupletsInGPU.lowerModuleIndices[T5Index * Params_T5::kLayers]; pixelQuintupletsInGPU.lowerModuleIndices[Params_pT5::kLayers * pixelQuintupletIndex + 3] = @@ -164,8 +164,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { pixelQuintupletsInGPU.lowerModuleIndices[Params_pT5::kLayers * pixelQuintupletIndex + 6] = quintupletsInGPU.lowerModuleIndices[T5Index * Params_T5::kLayers + 4]; - unsigned int pixelInnerMD = segmentsInGPU.mdIndices[Params_pLS::kLayers * pixelIndex]; - unsigned int pixelOuterMD = segmentsInGPU.mdIndices[Params_pLS::kLayers * pixelIndex + 1]; + unsigned int pixelInnerMD = segments.mem.mdIndices()[Params_pLS::kLayers * pixelIndex][0]; + unsigned int pixelOuterMD = segments.mem.mdIndices()[Params_pLS::kLayers * pixelIndex][1]; pixelQuintupletsInGPU.hitIndices[Params_pT5::kHits * pixelQuintupletIndex] = mdsInGPU.anchorHitIndices[pixelInnerMD]; @@ -676,7 +676,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { Modules const& modulesInGPU, ObjectRanges const& rangesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, Triplets const& tripletsInGPU, Quintuplets const& quintupletsInGPU, unsigned int pixelSegmentIndex, @@ -699,7 +699,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { modulesInGPU, rangesInGPU, mdsInGPU, - segmentsInGPU, + segments, tripletsInGPU, pixelSegmentIndex, T5InnerT3Index, @@ -718,13 +718,13 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { unsigned int thirdSegmentIndex = tripletsInGPU.segmentIndices[2 * T5OuterT3Index]; unsigned int fourthSegmentIndex = tripletsInGPU.segmentIndices[2 * T5OuterT3Index + 1]; - unsigned int pixelInnerMDIndex = segmentsInGPU.mdIndices[2 * pixelSegmentIndex]; - unsigned int pixelOuterMDIndex = segmentsInGPU.mdIndices[2 * pixelSegmentIndex + 1]; - unsigned int firstMDIndex = segmentsInGPU.mdIndices[2 * firstSegmentIndex]; - unsigned int secondMDIndex = segmentsInGPU.mdIndices[2 * secondSegmentIndex]; - unsigned int thirdMDIndex = segmentsInGPU.mdIndices[2 * secondSegmentIndex + 1]; - unsigned int fourthMDIndex = segmentsInGPU.mdIndices[2 * thirdSegmentIndex + 1]; - unsigned int fifthMDIndex = segmentsInGPU.mdIndices[2 * fourthSegmentIndex + 1]; + unsigned int pixelInnerMDIndex = segments.mem.mdIndices()[pixelSegmentIndex][0]; + unsigned int pixelOuterMDIndex = segments.mem.mdIndices()[pixelSegmentIndex][1]; + unsigned int firstMDIndex = segments.mem.mdIndices()[firstSegmentIndex][0]; + unsigned int secondMDIndex = segments.mem.mdIndices()[secondSegmentIndex][0]; + unsigned int thirdMDIndex = segments.mem.mdIndices()[secondSegmentIndex][1]; + unsigned int fourthMDIndex = segments.mem.mdIndices()[thirdSegmentIndex][1]; + unsigned int fifthMDIndex = segments.mem.mdIndices()[fourthSegmentIndex][1]; uint16_t lowerModuleIndex1 = quintupletsInGPU.lowerModuleIndices[Params_T5::kLayers * quintupletIndex]; uint16_t lowerModuleIndex2 = quintupletsInGPU.lowerModuleIndices[Params_T5::kLayers * quintupletIndex + 1]; @@ -774,9 +774,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { mdsInGPU.anchorY[fifthMDIndex]}; //get the appropriate radii and centers - centerX = segmentsInGPU.circleCenterX[pixelSegmentArrayIndex]; - centerY = segmentsInGPU.circleCenterY[pixelSegmentArrayIndex]; - pixelRadius = segmentsInGPU.circleRadius[pixelSegmentArrayIndex]; + centerX = segments.pix.circleCenterX()[pixelSegmentArrayIndex]; + centerY = segments.pix.circleCenterY()[pixelSegmentArrayIndex]; + pixelRadius = segments.pix.circleRadius()[pixelSegmentArrayIndex]; float T5CenterX = quintupletsInGPU.regressionG[quintupletIndex]; float T5CenterY = quintupletsInGPU.regressionF[quintupletIndex]; @@ -822,7 +822,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC void operator()(TAcc const& acc, Modules modulesInGPU, MiniDoublets mdsInGPU, - Segments segmentsInGPU, + Segments segments, Triplets tripletsInGPU, Quintuplets quintupletsInGPU, PixelQuintuplets pixelQuintupletsInGPU, @@ -846,7 +846,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { if (modulesInGPU.moduleType[quintupletLowerModuleIndex] == TwoS) continue; uint16_t pixelModuleIndex = *modulesInGPU.nLowerModules; - if (segmentsInGPU.isDup[i_pLS]) + if (segments.pix.isDup()[i_pLS]) continue; unsigned int nOuterQuintuplets = quintupletsInGPU.nQuintuplets[quintupletLowerModuleIndex]; @@ -871,7 +871,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { modulesInGPU, rangesInGPU, mdsInGPU, - segmentsInGPU, + segments, tripletsInGPU, quintupletsInGPU, pixelSegmentIndex, @@ -899,7 +899,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { addPixelQuintupletToMemory(modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, quintupletsInGPU, pixelQuintupletsInGPU, pixelSegmentIndex, @@ -918,7 +918,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { tripletsInGPU.partOfPT5[quintupletsInGPU.tripletIndices[2 * quintupletIndex]] = true; tripletsInGPU.partOfPT5[quintupletsInGPU.tripletIndices[2 * quintupletIndex + 1]] = true; - segmentsInGPU.partOfPT5[i_pLS] = true; + segments.pix.partOfPT5()[i_pLS] = true; quintupletsInGPU.partOfPT5[quintupletIndex] = true; } // tot occupancy } // end success diff --git a/RecoTracker/LSTCore/src/alpaka/PixelTriplet.h b/RecoTracker/LSTCore/src/alpaka/PixelTriplet.h index f7f7c4da72a51..08574cc96436e 100644 --- a/RecoTracker/LSTCore/src/alpaka/PixelTriplet.h +++ b/RecoTracker/LSTCore/src/alpaka/PixelTriplet.h @@ -130,7 +130,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { }; ALPAKA_FN_ACC ALPAKA_FN_INLINE void addPixelTripletToMemory(MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, Triplets const& tripletsInGPU, PixelTriplets& pixelTripletsInGPU, unsigned int pixelSegmentIndex, @@ -173,9 +173,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { tripletsInGPU.logicalLayers[tripletIndex * Params_T3::kLayers + 2]; pixelTripletsInGPU.lowerModuleIndices[Params_pT3::kLayers * pixelTripletIndex] = - segmentsInGPU.innerLowerModuleIndices[pixelSegmentIndex]; + segments.mem.innerLowerModuleIndices()[pixelSegmentIndex]; pixelTripletsInGPU.lowerModuleIndices[Params_pT3::kLayers * pixelTripletIndex + 1] = - segmentsInGPU.outerLowerModuleIndices[pixelSegmentIndex]; + segments.mem.outerLowerModuleIndices()[pixelSegmentIndex]; pixelTripletsInGPU.lowerModuleIndices[Params_pT3::kLayers * pixelTripletIndex + 2] = tripletsInGPU.lowerModuleIndices[Params_T3::kLayers * tripletIndex]; pixelTripletsInGPU.lowerModuleIndices[Params_pT3::kLayers * pixelTripletIndex + 3] = @@ -183,8 +183,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { pixelTripletsInGPU.lowerModuleIndices[Params_pT3::kLayers * pixelTripletIndex + 4] = tripletsInGPU.lowerModuleIndices[Params_T3::kLayers * tripletIndex + 2]; - unsigned int pixelInnerMD = segmentsInGPU.mdIndices[2 * pixelSegmentIndex]; - unsigned int pixelOuterMD = segmentsInGPU.mdIndices[2 * pixelSegmentIndex + 1]; + unsigned int pixelInnerMD = segments.mem.mdIndices()[pixelSegmentIndex][0]; + unsigned int pixelOuterMD = segments.mem.mdIndices()[pixelSegmentIndex][1]; pixelTripletsInGPU.hitIndices[Params_pT3::kHits * pixelTripletIndex] = mdsInGPU.anchorHitIndices[pixelInnerMD]; pixelTripletsInGPU.hitIndices[Params_pT3::kHits * pixelTripletIndex + 1] = mdsInGPU.outerHitIndices[pixelInnerMD]; @@ -213,7 +213,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { Modules const& modulesInGPU, ObjectRanges const& rangesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, uint16_t pixelLowerModuleIndex, uint16_t outerInnerLowerModuleIndex, uint16_t outerOuterLowerModuleIndex, @@ -222,11 +222,11 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { short outerInnerLowerModuleSubdet = modulesInGPU.subdets[outerInnerLowerModuleIndex]; short outerOuterLowerModuleSubdet = modulesInGPU.subdets[outerOuterLowerModuleIndex]; - unsigned int firstMDIndex = segmentsInGPU.mdIndices[Params_LS::kLayers * innerSegmentIndex]; - unsigned int secondMDIndex = segmentsInGPU.mdIndices[Params_LS::kLayers * innerSegmentIndex + 1]; + unsigned int firstMDIndex = segments.mem.mdIndices()[Params_LS::kLayers * innerSegmentIndex][0]; + unsigned int secondMDIndex = segments.mem.mdIndices()[Params_LS::kLayers * innerSegmentIndex][1]; - unsigned int thirdMDIndex = segmentsInGPU.mdIndices[Params_LS::kLayers * outerSegmentIndex]; - unsigned int fourthMDIndex = segmentsInGPU.mdIndices[Params_LS::kLayers * outerSegmentIndex + 1]; + unsigned int thirdMDIndex = segments.mem.mdIndices()[Params_LS::kLayers * outerSegmentIndex][0]; + unsigned int fourthMDIndex = segments.mem.mdIndices()[Params_LS::kLayers * outerSegmentIndex][1]; if (outerInnerLowerModuleSubdet == Barrel and (outerOuterLowerModuleSubdet == Barrel or outerOuterLowerModuleSubdet == Endcap)) { @@ -234,7 +234,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { modulesInGPU, rangesInGPU, mdsInGPU, - segmentsInGPU, + segments, pixelLowerModuleIndex, outerInnerLowerModuleIndex, outerOuterLowerModuleIndex, @@ -249,7 +249,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { modulesInGPU, rangesInGPU, mdsInGPU, - segmentsInGPU, + segments, pixelLowerModuleIndex, outerInnerLowerModuleIndex, outerOuterLowerModuleIndex, @@ -766,7 +766,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { Modules const& modulesInGPU, ObjectRanges const& rangesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, Triplets const& tripletsInGPU, unsigned int pixelSegmentIndex, unsigned int tripletIndex, @@ -779,7 +779,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { float& rPhiChiSquaredInwards, bool runChiSquaredCuts = true) { //run pT4 compatibility between the pixel segment and inner segment, and between the pixel and outer segment of the triplet - uint16_t pixelModuleIndex = segmentsInGPU.innerLowerModuleIndices[pixelSegmentIndex]; + uint16_t pixelModuleIndex = segments.mem.innerLowerModuleIndices()[pixelSegmentIndex]; uint16_t lowerModuleIndex = tripletsInGPU.lowerModuleIndices[Params_T3::kLayers * tripletIndex]; uint16_t middleModuleIndex = tripletsInGPU.lowerModuleIndices[Params_T3::kLayers * tripletIndex + 1]; @@ -791,7 +791,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { modulesInGPU, rangesInGPU, mdsInGPU, - segmentsInGPU, + segments, pixelModuleIndex, lowerModuleIndex, middleModuleIndex, @@ -804,7 +804,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { modulesInGPU, rangesInGPU, mdsInGPU, - segmentsInGPU, + segments, pixelModuleIndex, middleModuleIndex, upperModuleIndex, @@ -815,28 +815,28 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { //pt matching between the pixel ptin and the triplet circle pt unsigned int pixelSegmentArrayIndex = pixelSegmentIndex - rangesInGPU.segmentModuleIndices[pixelModuleIndex]; - float pixelSegmentPt = segmentsInGPU.ptIn[pixelSegmentArrayIndex]; - float pixelSegmentPtError = segmentsInGPU.ptErr[pixelSegmentArrayIndex]; - float pixelSegmentPx = segmentsInGPU.px[pixelSegmentArrayIndex]; - float pixelSegmentPy = segmentsInGPU.py[pixelSegmentArrayIndex]; - float pixelSegmentPz = segmentsInGPU.pz[pixelSegmentArrayIndex]; - int pixelSegmentCharge = segmentsInGPU.charge[pixelSegmentArrayIndex]; + float pixelSegmentPt = segments.pix.ptIn()[pixelSegmentArrayIndex]; + float pixelSegmentPtError = segments.pix.ptErr()[pixelSegmentArrayIndex]; + float pixelSegmentPx = segments.pix.px()[pixelSegmentArrayIndex]; + float pixelSegmentPy = segments.pix.py()[pixelSegmentArrayIndex]; + float pixelSegmentPz = segments.pix.pz()[pixelSegmentArrayIndex]; + int pixelSegmentCharge = segments.pix.charge()[pixelSegmentArrayIndex]; - float pixelG = segmentsInGPU.circleCenterX[pixelSegmentArrayIndex]; - float pixelF = segmentsInGPU.circleCenterY[pixelSegmentArrayIndex]; - float pixelRadiusPCA = segmentsInGPU.circleRadius[pixelSegmentArrayIndex]; + float pixelG = segments.pix.circleCenterX()[pixelSegmentArrayIndex]; + float pixelF = segments.pix.circleCenterY()[pixelSegmentArrayIndex]; + float pixelRadiusPCA = segments.pix.circleRadius()[pixelSegmentArrayIndex]; - unsigned int pixelInnerMDIndex = segmentsInGPU.mdIndices[Params_pLS::kLayers * pixelSegmentIndex]; - unsigned int pixelOuterMDIndex = segmentsInGPU.mdIndices[Params_pLS::kLayers * pixelSegmentIndex + 1]; + unsigned int pixelInnerMDIndex = segments.mem.mdIndices()[Params_pLS::kLayers * pixelSegmentIndex][0]; + unsigned int pixelOuterMDIndex = segments.mem.mdIndices()[Params_pLS::kLayers * pixelSegmentIndex][1]; pixelRadius = pixelSegmentPt * kR1GeVf; float pixelRadiusError = pixelSegmentPtError * kR1GeVf; unsigned int tripletInnerSegmentIndex = tripletsInGPU.segmentIndices[2 * tripletIndex]; unsigned int tripletOuterSegmentIndex = tripletsInGPU.segmentIndices[2 * tripletIndex + 1]; - unsigned int firstMDIndex = segmentsInGPU.mdIndices[2 * tripletInnerSegmentIndex]; - unsigned int secondMDIndex = segmentsInGPU.mdIndices[2 * tripletInnerSegmentIndex + 1]; - unsigned int thirdMDIndex = segmentsInGPU.mdIndices[2 * tripletOuterSegmentIndex + 1]; + unsigned int firstMDIndex = segments.mem.mdIndices()[tripletInnerSegmentIndex][0]; + unsigned int secondMDIndex = segments.mem.mdIndices()[tripletInnerSegmentIndex][1]; + unsigned int thirdMDIndex = segments.mem.mdIndices()[tripletOuterSegmentIndex][1]; float xs[Params_T3::kLayers] = { mdsInGPU.anchorX[firstMDIndex], mdsInGPU.anchorX[secondMDIndex], mdsInGPU.anchorX[thirdMDIndex]}; @@ -922,7 +922,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { Modules modulesInGPU, ObjectRanges rangesInGPU, MiniDoublets mdsInGPU, - Segments segmentsInGPU, + Segments segments, Triplets tripletsInGPU, PixelTriplets pixelTripletsInGPU, unsigned int* connectedPixelSize, @@ -960,9 +960,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { unsigned int pixelSegmentIndex = rangesInGPU.segmentModuleIndices[pixelModuleIndex] + i_pLS; - if (segmentsInGPU.isDup[i_pLS]) + if (segments.pix.isDup()[i_pLS]) continue; - if (segmentsInGPU.partOfPT5[i_pLS]) + if (segments.pix.partOfPT5()[i_pLS]) continue; //don't make pT3s for those pixels that are part of pT5 short layer2_adjustment; @@ -992,7 +992,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { modulesInGPU, rangesInGPU, mdsInGPU, - segmentsInGPU, + segments, tripletsInGPU, pixelSegmentIndex, outerTripletIndex, @@ -1006,14 +1006,14 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { if (success) { float phi = - mdsInGPU.anchorPhi[segmentsInGPU.mdIndices[2 * tripletsInGPU.segmentIndices[2 * outerTripletIndex] + - layer2_adjustment]]; + mdsInGPU.anchorPhi[segments.mem.mdIndices()[tripletsInGPU.segmentIndices[2 * outerTripletIndex] + + layer2_adjustment][0]]; float eta = - mdsInGPU.anchorEta[segmentsInGPU.mdIndices[2 * tripletsInGPU.segmentIndices[2 * outerTripletIndex] + - layer2_adjustment]]; - float eta_pix = segmentsInGPU.eta[i_pLS]; - float phi_pix = segmentsInGPU.phi[i_pLS]; - float pt = segmentsInGPU.ptIn[i_pLS]; + mdsInGPU.anchorEta[segments.mem.mdIndices()[tripletsInGPU.segmentIndices[2 * outerTripletIndex] + + layer2_adjustment][0]]; + float eta_pix = segments.pix.eta()[i_pLS]; + float phi_pix = segments.pix.phi()[i_pLS]; + float pt = segments.pix.ptIn()[i_pLS]; float score = rPhiChiSquared + rPhiChiSquaredInwards; unsigned int totOccupancyPixelTriplets = alpaka::atomicAdd( acc, pixelTripletsInGPU.totOccupancyPixelTriplets, 1u, alpaka::hierarchy::Threads{}); @@ -1025,7 +1025,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { unsigned int pixelTripletIndex = alpaka::atomicAdd(acc, pixelTripletsInGPU.nPixelTriplets, 1u, alpaka::hierarchy::Threads{}); addPixelTripletToMemory(mdsInGPU, - segmentsInGPU, + segments, tripletsInGPU, pixelTripletsInGPU, pixelSegmentIndex, @@ -1157,7 +1157,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { Modules const& modulesInGPU, ObjectRanges const& rangesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, uint16_t pixelModuleIndex, uint16_t outerInnerLowerModuleIndex, uint16_t outerOuterLowerModuleIndex, @@ -1195,13 +1195,13 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { return false; unsigned int pixelSegmentArrayIndex = innerSegmentIndex - rangesInGPU.segmentModuleIndices[pixelModuleIndex]; - float ptIn = segmentsInGPU.ptIn[pixelSegmentArrayIndex]; + float ptIn = segments.pix.ptIn()[pixelSegmentArrayIndex]; float ptSLo = ptIn; - float px = segmentsInGPU.px[pixelSegmentArrayIndex]; - float py = segmentsInGPU.py[pixelSegmentArrayIndex]; - float pz = segmentsInGPU.pz[pixelSegmentArrayIndex]; - float ptErr = segmentsInGPU.ptErr[pixelSegmentArrayIndex]; - float etaErr = segmentsInGPU.etaErr[pixelSegmentArrayIndex]; + float px = segments.pix.px()[pixelSegmentArrayIndex]; + float py = segments.pix.py()[pixelSegmentArrayIndex]; + float pz = segments.pix.pz()[pixelSegmentArrayIndex]; + float ptErr = segments.pix.ptErr()[pixelSegmentArrayIndex]; + float etaErr = segments.pix.etaErr()[pixelSegmentArrayIndex]; ptSLo = alpaka::math::max(acc, ptCut, ptSLo - 10.0f * alpaka::math::max(acc, ptErr, 0.005f * ptSLo)); ptSLo = alpaka::math::min(acc, 10.0f, ptSLo); @@ -1272,8 +1272,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { //lots of array accesses below this... - float alpha_InLo = __H2F(segmentsInGPU.dPhiChanges[innerSegmentIndex]); - float alpha_OutLo = __H2F(segmentsInGPU.dPhiChanges[outerSegmentIndex]); + float alpha_InLo = __H2F(segments.mem.dPhiChanges()[innerSegmentIndex]); + float alpha_OutLo = __H2F(segments.mem.dPhiChanges()[outerSegmentIndex]); bool isEC_lastLayer = modulesInGPU.subdets[outerOuterLowerModuleIndex] == Endcap and modulesInGPU.moduleType[outerOuterLowerModuleIndex] == TwoS; @@ -1415,7 +1415,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { Modules const& modulesInGPU, ObjectRanges const& rangesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, uint16_t pixelModuleIndex, uint16_t outerInnerLowerModuleIndex, uint16_t outerOuterLowerModuleIndex, @@ -1452,13 +1452,13 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { unsigned int pixelSegmentArrayIndex = innerSegmentIndex - rangesInGPU.segmentModuleIndices[pixelModuleIndex]; - float ptIn = segmentsInGPU.ptIn[pixelSegmentArrayIndex]; + float ptIn = segments.pix.ptIn()[pixelSegmentArrayIndex]; float ptSLo = ptIn; - float px = segmentsInGPU.px[pixelSegmentArrayIndex]; - float py = segmentsInGPU.py[pixelSegmentArrayIndex]; - float pz = segmentsInGPU.pz[pixelSegmentArrayIndex]; - float ptErr = segmentsInGPU.ptErr[pixelSegmentArrayIndex]; - float etaErr = segmentsInGPU.etaErr[pixelSegmentArrayIndex]; + float px = segments.pix.px()[pixelSegmentArrayIndex]; + float py = segments.pix.py()[pixelSegmentArrayIndex]; + float pz = segments.pix.pz()[pixelSegmentArrayIndex]; + float ptErr = segments.pix.ptErr()[pixelSegmentArrayIndex]; + float etaErr = segments.pix.etaErr()[pixelSegmentArrayIndex]; ptSLo = alpaka::math::max(acc, ptCut, ptSLo - 10.0f * alpaka::math::max(acc, ptErr, 0.005f * ptSLo)); ptSLo = alpaka::math::min(acc, 10.0f, ptSLo); @@ -1534,8 +1534,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { if (alpaka::math::abs(acc, dPhi) > dPhiCut) return false; - float alpha_InLo = __H2F(segmentsInGPU.dPhiChanges[innerSegmentIndex]); - float alpha_OutLo = __H2F(segmentsInGPU.dPhiChanges[outerSegmentIndex]); + float alpha_InLo = __H2F(segments.mem.dPhiChanges()[innerSegmentIndex]); + float alpha_OutLo = __H2F(segments.mem.dPhiChanges()[outerSegmentIndex]); bool isEC_lastLayer = modulesInGPU.subdets[outerOuterLowerModuleIndex] == Endcap and modulesInGPU.moduleType[outerOuterLowerModuleIndex] == TwoS; diff --git a/RecoTracker/LSTCore/src/alpaka/Quintuplet.h b/RecoTracker/LSTCore/src/alpaka/Quintuplet.h index 1b75100c874e8..4fec41818a17b 100644 --- a/RecoTracker/LSTCore/src/alpaka/Quintuplet.h +++ b/RecoTracker/LSTCore/src/alpaka/Quintuplet.h @@ -751,15 +751,15 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { template ALPAKA_FN_ACC ALPAKA_FN_INLINE bool T5HasCommonMiniDoublet(Triplets const& tripletsInGPU, - Segments const& segmentsInGPU, + Segments segments, unsigned int innerTripletIndex, unsigned int outerTripletIndex) { unsigned int innerOuterSegmentIndex = tripletsInGPU.segmentIndices[2 * innerTripletIndex + 1]; unsigned int outerInnerSegmentIndex = tripletsInGPU.segmentIndices[2 * outerTripletIndex]; unsigned int innerOuterOuterMiniDoubletIndex = - segmentsInGPU.mdIndices[2 * innerOuterSegmentIndex + 1]; //inner triplet outer segment outer MD index + segments.mem.mdIndices()[innerOuterSegmentIndex][1]; //inner triplet outer segment outer MD index unsigned int outerInnerInnerMiniDoubletIndex = - segmentsInGPU.mdIndices[2 * outerInnerSegmentIndex]; //outer triplet inner segment inner MD index + segments.mem.mdIndices()[outerInnerSegmentIndex][0]; //outer triplet inner segment inner MD index return (innerOuterOuterMiniDoubletIndex == outerInnerInnerMiniDoubletIndex); } @@ -1343,7 +1343,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC ALPAKA_FN_INLINE bool runQuintupletDefaultAlgoBBBB(TAcc const& acc, Modules const& modulesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, uint16_t innerInnerLowerModuleIndex, uint16_t innerOuterLowerModuleIndex, uint16_t outerInnerLowerModuleIndex, @@ -1430,9 +1430,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { return false; // First obtaining the raw betaIn and betaOut values without any correction and just purely based on the mini-doublet hit positions - - float alpha_InLo = __H2F(segmentsInGPU.dPhiChanges[innerSegmentIndex]); - float alpha_OutLo = __H2F(segmentsInGPU.dPhiChanges[outerSegmentIndex]); + float alpha_InLo = __H2F(segments.mem.dPhiChanges()[innerSegmentIndex]); + float alpha_OutLo = __H2F(segments.mem.dPhiChanges()[outerSegmentIndex]); bool isEC_lastLayer = modulesInGPU.subdets[outerOuterLowerModuleIndex] == Endcap and modulesInGPU.moduleType[outerOuterLowerModuleIndex] == TwoS; @@ -1588,7 +1587,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC ALPAKA_FN_INLINE bool runQuintupletDefaultAlgoBBEE(TAcc const& acc, Modules const& modulesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, uint16_t innerInnerLowerModuleIndex, uint16_t innerOuterLowerModuleIndex, uint16_t outerInnerLowerModuleIndex, @@ -1686,9 +1685,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { if (alpaka::math::abs(acc, dPhi) > dPhiCut) return false; - float sdIn_alpha = __H2F(segmentsInGPU.dPhiChanges[innerSegmentIndex]); - float sdIn_alpha_min = __H2F(segmentsInGPU.dPhiChangeMins[innerSegmentIndex]); - float sdIn_alpha_max = __H2F(segmentsInGPU.dPhiChangeMaxs[innerSegmentIndex]); + float sdIn_alpha = __H2F(segments.mem.dPhiChanges()[innerSegmentIndex]); + float sdIn_alpha_min = __H2F(segments.mem.dPhiChangeMins()[innerSegmentIndex]); + float sdIn_alpha_max = __H2F(segments.mem.dPhiChangeMaxs()[innerSegmentIndex]); float sdOut_alpha = sdIn_alpha; float sdOut_alphaOut = phi_mpi_pi(acc, @@ -1698,9 +1697,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { mdsInGPU.anchorPhi[fourthMDIndex]); float sdOut_alphaOut_min = phi_mpi_pi( - acc, __H2F(segmentsInGPU.dPhiChangeMins[outerSegmentIndex]) - __H2F(segmentsInGPU.dPhiMins[outerSegmentIndex])); + acc, __H2F(segments.mem.dPhiChangeMins()[outerSegmentIndex]) - __H2F(segments.mem.dPhiMins()[outerSegmentIndex])); float sdOut_alphaOut_max = phi_mpi_pi( - acc, __H2F(segmentsInGPU.dPhiChangeMaxs[outerSegmentIndex]) - __H2F(segmentsInGPU.dPhiMaxs[outerSegmentIndex])); + acc, __H2F(segments.mem.dPhiChangeMaxs()[outerSegmentIndex]) - __H2F(segments.mem.dPhiMaxs()[outerSegmentIndex])); float tl_axis_x = mdsInGPU.anchorX[fourthMDIndex] - mdsInGPU.anchorX[firstMDIndex]; float tl_axis_y = mdsInGPU.anchorY[fourthMDIndex] - mdsInGPU.anchorY[firstMDIndex]; @@ -1835,7 +1834,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC ALPAKA_FN_INLINE bool runQuintupletDefaultAlgoEEEE(TAcc const& acc, Modules const& modulesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, uint16_t innerInnerLowerModuleIndex, uint16_t innerOuterLowerModuleIndex, uint16_t outerInnerLowerModuleIndex, @@ -1937,13 +1936,13 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { if (alpaka::math::abs(acc, dPhi) > dPhiCut) return false; - float sdIn_alpha = __H2F(segmentsInGPU.dPhiChanges[innerSegmentIndex]); + float sdIn_alpha = __H2F(segments.mem.dPhiChanges()[innerSegmentIndex]); float sdOut_alpha = sdIn_alpha; //weird float sdOut_dPhiPos = phi_mpi_pi(acc, mdsInGPU.anchorPhi[fourthMDIndex] - mdsInGPU.anchorPhi[thirdMDIndex]); - float sdOut_dPhiChange = __H2F(segmentsInGPU.dPhiChanges[outerSegmentIndex]); - float sdOut_dPhiChange_min = __H2F(segmentsInGPU.dPhiChangeMins[outerSegmentIndex]); - float sdOut_dPhiChange_max = __H2F(segmentsInGPU.dPhiChangeMaxs[outerSegmentIndex]); + float sdOut_dPhiChange = __H2F(segments.mem.dPhiChanges()[outerSegmentIndex]); + float sdOut_dPhiChange_min = __H2F(segments.mem.dPhiChangeMins()[outerSegmentIndex]); + float sdOut_dPhiChange_max = __H2F(segments.mem.dPhiChangeMaxs()[outerSegmentIndex]); float sdOut_alphaOutRHmin = phi_mpi_pi(acc, sdOut_dPhiChange_min - sdOut_dPhiPos); float sdOut_alphaOutRHmax = phi_mpi_pi(acc, sdOut_dPhiChange_max - sdOut_dPhiPos); @@ -1954,8 +1953,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { float betaIn = sdIn_alpha - phi_mpi_pi(acc, phi(acc, tl_axis_x, tl_axis_y) - mdsInGPU.anchorPhi[firstMDIndex]); - float sdIn_alphaRHmin = __H2F(segmentsInGPU.dPhiChangeMins[innerSegmentIndex]); - float sdIn_alphaRHmax = __H2F(segmentsInGPU.dPhiChangeMaxs[innerSegmentIndex]); + float sdIn_alphaRHmin = __H2F(segments.mem.dPhiChangeMins()[innerSegmentIndex]); + float sdIn_alphaRHmax = __H2F(segments.mem.dPhiChangeMaxs()[innerSegmentIndex]); float betaInRHmin = betaIn + sdIn_alphaRHmin - sdIn_alpha; float betaInRHmax = betaIn + sdIn_alphaRHmax - sdIn_alpha; @@ -2061,7 +2060,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC ALPAKA_FN_INLINE bool runQuintupletAlgoSelector(TAcc const& acc, Modules const& modulesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, uint16_t innerInnerLowerModuleIndex, uint16_t innerOuterLowerModuleIndex, uint16_t outerInnerLowerModuleIndex, @@ -2082,7 +2081,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { return runQuintupletDefaultAlgoBBBB(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, innerInnerLowerModuleIndex, innerOuterLowerModuleIndex, outerInnerLowerModuleIndex, @@ -2098,7 +2097,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { return runQuintupletDefaultAlgoBBEE(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, innerInnerLowerModuleIndex, innerOuterLowerModuleIndex, outerInnerLowerModuleIndex, @@ -2114,7 +2113,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { return runQuintupletDefaultAlgoBBBB(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, innerInnerLowerModuleIndex, innerOuterLowerModuleIndex, outerInnerLowerModuleIndex, @@ -2130,7 +2129,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { return runQuintupletDefaultAlgoBBEE(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, innerInnerLowerModuleIndex, innerOuterLowerModuleIndex, outerInnerLowerModuleIndex, @@ -2146,7 +2145,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { return runQuintupletDefaultAlgoEEEE(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, innerInnerLowerModuleIndex, innerOuterLowerModuleIndex, outerInnerLowerModuleIndex, @@ -2166,7 +2165,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC ALPAKA_FN_INLINE bool runQuintupletDefaultAlgo(TAcc const& acc, Modules& modulesInGPU, MiniDoublets& mdsInGPU, - Segments& segmentsInGPU, + Segments segments, Triplets& tripletsInGPU, uint16_t lowerModuleIndex1, uint16_t lowerModuleIndex2, @@ -2191,24 +2190,24 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { unsigned int fourthSegmentIndex = tripletsInGPU.segmentIndices[2 * outerTripletIndex + 1]; unsigned int innerOuterOuterMiniDoubletIndex = - segmentsInGPU.mdIndices[2 * secondSegmentIndex + 1]; //inner triplet outer segment outer MD index + segments.mem.mdIndices()[secondSegmentIndex][1]; //inner triplet outer segment outer MD index unsigned int outerInnerInnerMiniDoubletIndex = - segmentsInGPU.mdIndices[2 * thirdSegmentIndex]; //outer triplet inner segment inner MD index + segments.mem.mdIndices()[thirdSegmentIndex][0]; //outer triplet inner segment inner MD index //this cut reduces the number of candidates by a factor of 3, i.e., 2 out of 3 warps can end right here! if (innerOuterOuterMiniDoubletIndex != outerInnerInnerMiniDoubletIndex) return false; - unsigned int firstMDIndex = segmentsInGPU.mdIndices[2 * firstSegmentIndex]; - unsigned int secondMDIndex = segmentsInGPU.mdIndices[2 * secondSegmentIndex]; - unsigned int thirdMDIndex = segmentsInGPU.mdIndices[2 * secondSegmentIndex + 1]; - unsigned int fourthMDIndex = segmentsInGPU.mdIndices[2 * thirdSegmentIndex + 1]; - unsigned int fifthMDIndex = segmentsInGPU.mdIndices[2 * fourthSegmentIndex + 1]; + unsigned int firstMDIndex = segments.mem.mdIndices()[firstSegmentIndex][0]; + unsigned int secondMDIndex = segments.mem.mdIndices()[secondSegmentIndex][0]; + unsigned int thirdMDIndex = segments.mem.mdIndices()[secondSegmentIndex][1]; + unsigned int fourthMDIndex = segments.mem.mdIndices()[thirdSegmentIndex][1]; + unsigned int fifthMDIndex = segments.mem.mdIndices()[fourthSegmentIndex][1]; if (not runQuintupletAlgoSelector(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, lowerModuleIndex1, lowerModuleIndex2, lowerModuleIndex3, @@ -2224,7 +2223,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { if (not runQuintupletAlgoSelector(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, lowerModuleIndex1, lowerModuleIndex2, lowerModuleIndex4, @@ -2437,7 +2436,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { float inference = t5dnn::runInference(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, tripletsInGPU, xVec, yVec, @@ -2509,7 +2508,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC void operator()(TAcc const& acc, Modules modulesInGPU, MiniDoublets mdsInGPU, - Segments segmentsInGPU, + Segments segments, Triplets tripletsInGPU, Quintuplets quintupletsInGPU, ObjectRanges rangesInGPU, @@ -2550,7 +2549,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { bool success = runQuintupletDefaultAlgo(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, tripletsInGPU, lowerModule1, lowerModule2, @@ -2589,11 +2588,11 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { unsigned int quintupletIndex = rangesInGPU.quintupletModuleIndices[lowerModule1] + quintupletModuleIndex; float phi = - mdsInGPU.anchorPhi[segmentsInGPU.mdIndices[2 * tripletsInGPU.segmentIndices[2 * innerTripletIndex + - layer2_adjustment]]]; + mdsInGPU.anchorPhi[segments.mem.mdIndices()[tripletsInGPU.segmentIndices[2 * innerTripletIndex + + layer2_adjustment]][0]]; float eta = - mdsInGPU.anchorEta[segmentsInGPU.mdIndices[2 * tripletsInGPU.segmentIndices[2 * innerTripletIndex + - layer2_adjustment]]]; + mdsInGPU.anchorEta[segments.mem.mdIndices()[tripletsInGPU.segmentIndices[2 * innerTripletIndex + + layer2_adjustment]][0]]; float pt = (innerRadius + outerRadius) * k2Rinv1GeVf; float scores = chiSquared + nonAnchorChiSquared; addQuintupletToMemory(tripletsInGPU, diff --git a/RecoTracker/LSTCore/src/alpaka/Segment.h b/RecoTracker/LSTCore/src/alpaka/Segment.h index bc2d1d82a5fc9..65a3751b27c16 100644 --- a/RecoTracker/LSTCore/src/alpaka/Segment.h +++ b/RecoTracker/LSTCore/src/alpaka/Segment.h @@ -2,6 +2,8 @@ #define RecoTracker_LSTCore_src_alpaka_Segment_h #include "HeterogeneousCore/AlpakaInterface/interface/workdivision.h" +#include "DataFormats/SoATemplate/interface/SoALayout.h" +#include "DataFormats/Portable/interface/alpaka/PortableCollection.h" #include "RecoTracker/LSTCore/interface/alpaka/Constants.h" #include "RecoTracker/LSTCore/interface/Module.h" @@ -12,168 +14,65 @@ #include "ObjectRanges.h" namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { - struct Segments { - FPX* dPhis; - FPX* dPhiMins; - FPX* dPhiMaxs; - FPX* dPhiChanges; - FPX* dPhiChangeMins; - FPX* dPhiChangeMaxs; - uint16_t* innerLowerModuleIndices; - uint16_t* outerLowerModuleIndices; - unsigned int* seedIdx; - unsigned int* mdIndices; - unsigned int* nMemoryLocations; - unsigned int* innerMiniDoubletAnchorHitIndices; - unsigned int* outerMiniDoubletAnchorHitIndices; - int* charge; - int* superbin; - unsigned int* nSegments; //number of segments per inner lower module - unsigned int* totOccupancySegments; //number of segments per inner lower module - uint4* pLSHitsIdxs; - PixelType* pixelType; - char* isQuad; - char* isDup; - bool* partOfPT5; - float* ptIn; - float* ptErr; - float* px; - float* py; - float* pz; - float* etaErr; - float* eta; - float* phi; - float* score; - float* circleCenterX; - float* circleCenterY; - float* circleRadius; - - template - void setData(TBuff& buf) { - dPhis = buf.dPhis_buf.data(); - dPhiMins = buf.dPhiMins_buf.data(); - dPhiMaxs = buf.dPhiMaxs_buf.data(); - dPhiChanges = buf.dPhiChanges_buf.data(); - dPhiChangeMins = buf.dPhiChangeMins_buf.data(); - dPhiChangeMaxs = buf.dPhiChangeMaxs_buf.data(); - innerLowerModuleIndices = buf.innerLowerModuleIndices_buf.data(); - outerLowerModuleIndices = buf.outerLowerModuleIndices_buf.data(); - seedIdx = buf.seedIdx_buf.data(); - mdIndices = buf.mdIndices_buf.data(); - nMemoryLocations = buf.nMemoryLocations_buf.data(); - innerMiniDoubletAnchorHitIndices = buf.innerMiniDoubletAnchorHitIndices_buf.data(); - outerMiniDoubletAnchorHitIndices = buf.outerMiniDoubletAnchorHitIndices_buf.data(); - charge = buf.charge_buf.data(); - superbin = buf.superbin_buf.data(); - nSegments = buf.nSegments_buf.data(); - totOccupancySegments = buf.totOccupancySegments_buf.data(); - pLSHitsIdxs = buf.pLSHitsIdxs_buf.data(); - pixelType = buf.pixelType_buf.data(); - isQuad = buf.isQuad_buf.data(); - isDup = buf.isDup_buf.data(); - partOfPT5 = buf.partOfPT5_buf.data(); - ptIn = buf.ptIn_buf.data(); - ptErr = buf.ptErr_buf.data(); - px = buf.px_buf.data(); - py = buf.py_buf.data(); - pz = buf.pz_buf.data(); - etaErr = buf.etaErr_buf.data(); - eta = buf.eta_buf.data(); - phi = buf.phi_buf.data(); - score = buf.score_buf.data(); - circleCenterX = buf.circleCenterX_buf.data(); - circleCenterY = buf.circleCenterY_buf.data(); - circleRadius = buf.circleRadius_buf.data(); - } - }; - template - struct SegmentsBuffer { - Buf dPhis_buf; - Buf dPhiMins_buf; - Buf dPhiMaxs_buf; - Buf dPhiChanges_buf; - Buf dPhiChangeMins_buf; - Buf dPhiChangeMaxs_buf; - Buf innerLowerModuleIndices_buf; - Buf outerLowerModuleIndices_buf; - Buf seedIdx_buf; - Buf mdIndices_buf; - Buf nMemoryLocations_buf; - Buf innerMiniDoubletAnchorHitIndices_buf; - Buf outerMiniDoubletAnchorHitIndices_buf; - Buf charge_buf; - Buf superbin_buf; - Buf nSegments_buf; - Buf totOccupancySegments_buf; - Buf pLSHitsIdxs_buf; - Buf pixelType_buf; - Buf isQuad_buf; - Buf isDup_buf; - Buf partOfPT5_buf; - Buf ptIn_buf; - Buf ptErr_buf; - Buf px_buf; - Buf py_buf; - Buf pz_buf; - Buf etaErr_buf; - Buf eta_buf; - Buf phi_buf; - Buf score_buf; - Buf circleCenterX_buf; - Buf circleCenterY_buf; - Buf circleRadius_buf; - - Segments data_; - - template - SegmentsBuffer(unsigned int nMemoryLocationsIn, - uint16_t nLowerModules, - unsigned int maxPixelSegments, - TDevAcc const& devAccIn, - TQueue& queue) - : dPhis_buf(allocBufWrapper(devAccIn, nMemoryLocationsIn, queue)), - dPhiMins_buf(allocBufWrapper(devAccIn, nMemoryLocationsIn, queue)), - dPhiMaxs_buf(allocBufWrapper(devAccIn, nMemoryLocationsIn, queue)), - dPhiChanges_buf(allocBufWrapper(devAccIn, nMemoryLocationsIn, queue)), - dPhiChangeMins_buf(allocBufWrapper(devAccIn, nMemoryLocationsIn, queue)), - dPhiChangeMaxs_buf(allocBufWrapper(devAccIn, nMemoryLocationsIn, queue)), - innerLowerModuleIndices_buf(allocBufWrapper(devAccIn, nMemoryLocationsIn, queue)), - outerLowerModuleIndices_buf(allocBufWrapper(devAccIn, nMemoryLocationsIn, queue)), - seedIdx_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - mdIndices_buf(allocBufWrapper(devAccIn, nMemoryLocationsIn * 2, queue)), - nMemoryLocations_buf(allocBufWrapper(devAccIn, 1, queue)), - innerMiniDoubletAnchorHitIndices_buf(allocBufWrapper(devAccIn, nMemoryLocationsIn, queue)), - outerMiniDoubletAnchorHitIndices_buf(allocBufWrapper(devAccIn, nMemoryLocationsIn, queue)), - charge_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - superbin_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - nSegments_buf(allocBufWrapper(devAccIn, nLowerModules + 1, queue)), - totOccupancySegments_buf(allocBufWrapper(devAccIn, nLowerModules + 1, queue)), - pLSHitsIdxs_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - pixelType_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - isQuad_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - isDup_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - partOfPT5_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - ptIn_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - ptErr_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - px_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - py_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - pz_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - etaErr_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - eta_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - phi_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - score_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - circleCenterX_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - circleCenterY_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)), - circleRadius_buf(allocBufWrapper(devAccIn, maxPixelSegments, queue)) { - alpaka::memset(queue, nSegments_buf, 0u); - alpaka::memset(queue, totOccupancySegments_buf, 0u); - alpaka::memset(queue, partOfPT5_buf, false); - alpaka::memset(queue, pLSHitsIdxs_buf, 0u); - } + GENERATE_SOA_LAYOUT(SegmentsMemSoALayout, + SOA_COLUMN(FPX, dPhis), + SOA_COLUMN(FPX, dPhiMins), + SOA_COLUMN(FPX, dPhiMaxs), + SOA_COLUMN(FPX, dPhiChanges), + SOA_COLUMN(FPX, dPhiChangeMins), + SOA_COLUMN(FPX, dPhiChangeMaxs), + SOA_COLUMN(uint16_t, innerLowerModuleIndices), + SOA_COLUMN(uint16_t, outerLowerModuleIndices), + SOA_COLUMN(Params_LS::ArrayUxLayers, mdIndices), + SOA_COLUMN(unsigned int, innerMiniDoubletAnchorHitIndices), + SOA_COLUMN(unsigned int, outerMiniDoubletAnchorHitIndices), + SOA_SCALAR(unsigned int, nMemoryLocations)) + + GENERATE_SOA_LAYOUT(SegmentsModSoALayout, + SOA_COLUMN(unsigned int, nSegments), //number of segments per inner lower module + SOA_COLUMN(unsigned int, totOccupancySegments)) + + GENERATE_SOA_LAYOUT(SegmentsPixSoALayout, + SOA_COLUMN(unsigned int, seedIdx), + SOA_COLUMN(int, charge), + SOA_COLUMN(int, superbin), + SOA_COLUMN(uint4, pLSHitsIdxs), + SOA_COLUMN(PixelType, pixelType), + SOA_COLUMN(char, isQuad), + SOA_COLUMN(char, isDup), + SOA_COLUMN(bool, partOfPT5), + SOA_COLUMN(float, ptIn), + SOA_COLUMN(float, ptErr), + SOA_COLUMN(float, px), + SOA_COLUMN(float, py), + SOA_COLUMN(float, pz), + SOA_COLUMN(float, etaErr), + SOA_COLUMN(float, eta), + SOA_COLUMN(float, phi), + SOA_COLUMN(float, score), + SOA_COLUMN(float, circleCenterX), + SOA_COLUMN(float, circleCenterY), + SOA_COLUMN(float, circleRadius)) + + using SegmentsMemSoA = SegmentsMemSoALayout<>; + using SegmentsModSoA = SegmentsModSoALayout<>; + using SegmentsPixSoA = SegmentsPixSoALayout<>; + + using SegmentsDeviceCollection = PortableCollection3; + using SegmentsHostCollection = PortableHostMultiCollection; - inline Segments const* data() const { return &data_; } - inline void setData(SegmentsBuffer& buf) { data_.setData(buf); } + struct Segments { + SegmentsMemSoA::View mem; + SegmentsModSoA::View mod; + SegmentsPixSoA::View pix; + + template + void setData(PortableMultiCollection& segmentsCol) { + mem = segmentsCol.template view(); + mod = segmentsCol.template view(); + pix = segmentsCol.template view(); + } }; ALPAKA_FN_ACC ALPAKA_FN_INLINE float isTighterTiltedModules_seg(Modules const& modulesInGPU, @@ -355,7 +254,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { dAlphaThresholdValues[2] = dAlpha_Bfield + alpaka::math::sqrt(acc, dAlpha_res * dAlpha_res + sdMuls * sdMuls); } - ALPAKA_FN_ACC ALPAKA_FN_INLINE void addSegmentToMemory(Segments& segmentsInGPU, + ALPAKA_FN_ACC ALPAKA_FN_INLINE void addSegmentToMemory(Segments segments, unsigned int lowerMDIndex, unsigned int upperMDIndex, uint16_t innerLowerModuleIndex, @@ -369,24 +268,24 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { float dPhiChangeMin, float dPhiChangeMax, unsigned int idx) { - segmentsInGPU.mdIndices[idx * 2] = lowerMDIndex; - segmentsInGPU.mdIndices[idx * 2 + 1] = upperMDIndex; - segmentsInGPU.innerLowerModuleIndices[idx] = innerLowerModuleIndex; - segmentsInGPU.outerLowerModuleIndices[idx] = outerLowerModuleIndex; - segmentsInGPU.innerMiniDoubletAnchorHitIndices[idx] = innerMDAnchorHitIndex; - segmentsInGPU.outerMiniDoubletAnchorHitIndices[idx] = outerMDAnchorHitIndex; - - segmentsInGPU.dPhis[idx] = __F2H(dPhi); - segmentsInGPU.dPhiMins[idx] = __F2H(dPhiMin); - segmentsInGPU.dPhiMaxs[idx] = __F2H(dPhiMax); - segmentsInGPU.dPhiChanges[idx] = __F2H(dPhiChange); - segmentsInGPU.dPhiChangeMins[idx] = __F2H(dPhiChangeMin); - segmentsInGPU.dPhiChangeMaxs[idx] = __F2H(dPhiChangeMax); + segments.mem.mdIndices()[idx][0] = lowerMDIndex; + segments.mem.mdIndices()[idx][1] = upperMDIndex; + segments.mem.innerLowerModuleIndices()[idx] = innerLowerModuleIndex; + segments.mem.outerLowerModuleIndices()[idx] = outerLowerModuleIndex; + segments.mem.innerMiniDoubletAnchorHitIndices()[idx] = innerMDAnchorHitIndex; + segments.mem.outerMiniDoubletAnchorHitIndices()[idx] = outerMDAnchorHitIndex; + + segments.mem.dPhis()[idx] = __F2H(dPhi); + segments.mem.dPhiMins()[idx] = __F2H(dPhiMin); + segments.mem.dPhiMaxs()[idx] = __F2H(dPhiMax); + segments.mem.dPhiChanges()[idx] = __F2H(dPhiChange); + segments.mem.dPhiChangeMins()[idx] = __F2H(dPhiChangeMin); + segments.mem.dPhiChangeMaxs()[idx] = __F2H(dPhiChangeMax); } template ALPAKA_FN_ACC ALPAKA_FN_INLINE void addPixelSegmentToMemory(TAcc const& acc, - Segments& segmentsInGPU, + Segments segments, MiniDoublets const& mdsInGPU, unsigned int innerMDIndex, unsigned int outerMDIndex, @@ -398,20 +297,20 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { unsigned int idx, unsigned int pixelSegmentArrayIndex, float score) { - segmentsInGPU.mdIndices[idx * 2] = innerMDIndex; - segmentsInGPU.mdIndices[idx * 2 + 1] = outerMDIndex; - segmentsInGPU.innerLowerModuleIndices[idx] = pixelModuleIndex; - segmentsInGPU.outerLowerModuleIndices[idx] = pixelModuleIndex; - segmentsInGPU.innerMiniDoubletAnchorHitIndices[idx] = innerAnchorHitIndex; - segmentsInGPU.outerMiniDoubletAnchorHitIndices[idx] = outerAnchorHitIndex; - segmentsInGPU.dPhiChanges[idx] = __F2H(dPhiChange); - segmentsInGPU.isDup[pixelSegmentArrayIndex] = false; - segmentsInGPU.score[pixelSegmentArrayIndex] = score; - - segmentsInGPU.pLSHitsIdxs[pixelSegmentArrayIndex].x = hitIdxs[0]; - segmentsInGPU.pLSHitsIdxs[pixelSegmentArrayIndex].y = hitIdxs[1]; - segmentsInGPU.pLSHitsIdxs[pixelSegmentArrayIndex].z = hitIdxs[2]; - segmentsInGPU.pLSHitsIdxs[pixelSegmentArrayIndex].w = hitIdxs[3]; + segments.mem.mdIndices()[idx][0] = innerMDIndex; + segments.mem.mdIndices()[idx][1] = outerMDIndex; + segments.mem.innerLowerModuleIndices()[idx] = pixelModuleIndex; + segments.mem.outerLowerModuleIndices()[idx] = pixelModuleIndex; + segments.mem.innerMiniDoubletAnchorHitIndices()[idx] = innerAnchorHitIndex; + segments.mem.outerMiniDoubletAnchorHitIndices()[idx] = outerAnchorHitIndex; + segments.mem.dPhiChanges()[idx] = __F2H(dPhiChange); + + segments.pix.isDup()[pixelSegmentArrayIndex] = false; + segments.pix.score()[pixelSegmentArrayIndex] = score; + segments.pix.pLSHitsIdxs()[pixelSegmentArrayIndex].x = hitIdxs[0]; + segments.pix.pLSHitsIdxs()[pixelSegmentArrayIndex].y = hitIdxs[1]; + segments.pix.pLSHitsIdxs()[pixelSegmentArrayIndex].z = hitIdxs[2]; + segments.pix.pLSHitsIdxs()[pixelSegmentArrayIndex].w = hitIdxs[3]; //computing circle parameters /* @@ -442,9 +341,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { bestIndex = i; } } - segmentsInGPU.circleCenterX[pixelSegmentArrayIndex] = candidateCenterXs[bestIndex]; - segmentsInGPU.circleCenterY[pixelSegmentArrayIndex] = candidateCenterYs[bestIndex]; - segmentsInGPU.circleRadius[pixelSegmentArrayIndex] = circleRadius; + segments.pix.circleCenterX()[pixelSegmentArrayIndex] = candidateCenterXs[bestIndex]; + segments.pix.circleCenterY()[pixelSegmentArrayIndex] = candidateCenterYs[bestIndex]; + segments.pix.circleRadius()[pixelSegmentArrayIndex] = circleRadius; } template @@ -702,7 +601,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC void operator()(TAcc const& acc, Modules modulesInGPU, MiniDoublets mdsInGPU, - Segments segmentsInGPU, + Segments segments, ObjectRanges rangesInGPU) const { auto const globalBlockIdx = alpaka::getIdx(acc); auto const blockThreadIdx = alpaka::getIdx(acc); @@ -759,17 +658,17 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { dPhiChangeMin, dPhiChangeMax)) { unsigned int totOccupancySegments = alpaka::atomicAdd( - acc, &segmentsInGPU.totOccupancySegments[innerLowerModuleIndex], 1u, alpaka::hierarchy::Threads{}); + acc, &segments.mod.totOccupancySegments()[innerLowerModuleIndex], 1u, alpaka::hierarchy::Threads{}); if (static_cast(totOccupancySegments) >= rangesInGPU.segmentModuleOccupancy[innerLowerModuleIndex]) { #ifdef WARNINGS printf("Segment excess alert! Module index = %d\n", innerLowerModuleIndex); #endif } else { unsigned int segmentModuleIdx = alpaka::atomicAdd( - acc, &segmentsInGPU.nSegments[innerLowerModuleIndex], 1u, alpaka::hierarchy::Threads{}); + acc, &segments.mod.nSegments()[innerLowerModuleIndex], 1u, alpaka::hierarchy::Threads{}); unsigned int segmentIdx = rangesInGPU.segmentModuleIndices[innerLowerModuleIndex] + segmentModuleIdx; - addSegmentToMemory(segmentsInGPU, + addSegmentToMemory(segments, innerMDIndex, outerMDIndex, innerLowerModuleIndex, @@ -899,7 +798,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { template ALPAKA_FN_ACC void operator()(TAcc const& acc, Modules modulesInGPU, - Segments segmentsInGPU, + Segments segments, ObjectRanges rangesInGPU) const { // implementation is 1D with a single block static_assert(std::is_same_v, "Should be Acc1D"); @@ -909,12 +808,12 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { auto const gridThreadExtent = alpaka::getWorkDiv(acc); for (uint16_t i = globalThreadIdx[0]; i < *modulesInGPU.nLowerModules; i += gridThreadExtent[0]) { - if (segmentsInGPU.nSegments[i] == 0) { + if (segments.mod.nSegments()[i] == 0) { rangesInGPU.segmentRanges[i * 2] = -1; rangesInGPU.segmentRanges[i * 2 + 1] = -1; } else { rangesInGPU.segmentRanges[i * 2] = rangesInGPU.segmentModuleIndices[i]; - rangesInGPU.segmentRanges[i * 2 + 1] = rangesInGPU.segmentModuleIndices[i] + segmentsInGPU.nSegments[i] - 1; + rangesInGPU.segmentRanges[i * 2 + 1] = rangesInGPU.segmentModuleIndices[i] + segments.mod.nSegments()[i] - 1; } } } @@ -927,7 +826,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ObjectRanges rangesInGPU, Hits hitsInGPU, MiniDoublets mdsInGPU, - Segments segmentsInGPU, + Segments segments, unsigned int* hitIndices0, unsigned int* hitIndices1, unsigned int* hitIndices2, @@ -990,7 +889,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { hits1[2] = hitsInGPU.idxs[mdsInGPU.outerHitIndices[innerMDIndex]]; hits1[3] = hitsInGPU.idxs[mdsInGPU.outerHitIndices[outerMDIndex]]; addPixelSegmentToMemory(acc, - segmentsInGPU, + segments, mdsInGPU, innerMDIndex, outerMDIndex, @@ -1007,4 +906,17 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { }; } // namespace ALPAKA_ACCELERATOR_NAMESPACE::lst +namespace cms::alpakatools { + // This is not used, but it is needed for compilation + template + struct CopyToHost> { + template + static auto copyAsync(TQueue& queue, PortableHostMultiCollection const& srcData) { + PortableHostMultiCollection dstData(srcData.sizes(), queue); + alpaka::memcpy(queue, dstData.buffer(), srcData.buffer()); + return dstData; + } + }; +} // namespace cms::alpakatools + #endif diff --git a/RecoTracker/LSTCore/src/alpaka/TrackCandidate.h b/RecoTracker/LSTCore/src/alpaka/TrackCandidate.h index 16f36df3257cd..3ccbf52fa8fb5 100644 --- a/RecoTracker/LSTCore/src/alpaka/TrackCandidate.h +++ b/RecoTracker/LSTCore/src/alpaka/TrackCandidate.h @@ -167,20 +167,20 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC ALPAKA_FN_INLINE int checkPixelHits(unsigned int ix, unsigned int jx, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, Hits const& hitsInGPU) { int phits1[Params_pLS::kHits]; int phits2[Params_pLS::kHits]; - phits1[0] = hitsInGPU.idxs[mdsInGPU.anchorHitIndices[segmentsInGPU.mdIndices[2 * ix]]]; - phits1[1] = hitsInGPU.idxs[mdsInGPU.anchorHitIndices[segmentsInGPU.mdIndices[2 * ix + 1]]]; - phits1[2] = hitsInGPU.idxs[mdsInGPU.outerHitIndices[segmentsInGPU.mdIndices[2 * ix]]]; - phits1[3] = hitsInGPU.idxs[mdsInGPU.outerHitIndices[segmentsInGPU.mdIndices[2 * ix + 1]]]; + phits1[0] = hitsInGPU.idxs[mdsInGPU.anchorHitIndices[segments.mem.mdIndices()[ix][0]]]; + phits1[1] = hitsInGPU.idxs[mdsInGPU.anchorHitIndices[segments.mem.mdIndices()[ix][1]]]; + phits1[2] = hitsInGPU.idxs[mdsInGPU.outerHitIndices[segments.mem.mdIndices()[ix][0]]]; + phits1[3] = hitsInGPU.idxs[mdsInGPU.outerHitIndices[segments.mem.mdIndices()[ix][0]]]; - phits2[0] = hitsInGPU.idxs[mdsInGPU.anchorHitIndices[segmentsInGPU.mdIndices[2 * jx]]]; - phits2[1] = hitsInGPU.idxs[mdsInGPU.anchorHitIndices[segmentsInGPU.mdIndices[2 * jx + 1]]]; - phits2[2] = hitsInGPU.idxs[mdsInGPU.outerHitIndices[segmentsInGPU.mdIndices[2 * jx]]]; - phits2[3] = hitsInGPU.idxs[mdsInGPU.outerHitIndices[segmentsInGPU.mdIndices[2 * jx + 1]]]; + phits2[0] = hitsInGPU.idxs[mdsInGPU.anchorHitIndices[segments.mem.mdIndices()[jx][0]]]; + phits2[1] = hitsInGPU.idxs[mdsInGPU.anchorHitIndices[segments.mem.mdIndices()[jx][1]]]; + phits2[2] = hitsInGPU.idxs[mdsInGPU.outerHitIndices[segments.mem.mdIndices()[jx][0]]]; + phits2[3] = hitsInGPU.idxs[mdsInGPU.outerHitIndices[segments.mem.mdIndices()[jx][1]]]; int npMatched = 0; @@ -210,7 +210,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { Modules modulesInGPU, ObjectRanges rangesInGPU, PixelTriplets pixelTripletsInGPU, - Segments segmentsInGPU, + Segments segments, PixelQuintuplets pixelQuintupletsInGPU) const { auto const globalThreadIdx = alpaka::getIdx(acc); auto const gridThreadExtent = alpaka::getWorkDiv(acc); @@ -232,8 +232,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { for (unsigned int pixelQuintupletIndex = globalThreadIdx[1]; pixelQuintupletIndex < nPixelQuintuplets; pixelQuintupletIndex += gridThreadExtent[1]) { unsigned int pLS_jx = pixelQuintupletsInGPU.pixelIndices[pixelQuintupletIndex]; - float eta2 = segmentsInGPU.eta[pLS_jx - prefix]; - float phi2 = segmentsInGPU.phi[pLS_jx - prefix]; + float eta2 = segments.pix.eta()[pLS_jx - prefix]; + float phi2 = segments.pix.phi()[pLS_jx - prefix]; float dEta = alpaka::math::abs(acc, (eta1 - eta2)); float dPhi = calculate_dPhi(phi1, phi2); @@ -307,7 +307,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ObjectRanges rangesInGPU, PixelTriplets pixelTripletsInGPU, TrackCandidates trackCandidatesInGPU, - Segments segmentsInGPU, + Segments segments, MiniDoublets mdsInGPU, Hits hitsInGPU, Quintuplets quintupletsInGPU) const { @@ -315,14 +315,14 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { auto const gridThreadExtent = alpaka::getWorkDiv(acc); int pixelModuleIndex = *modulesInGPU.nLowerModules; - unsigned int nPixels = segmentsInGPU.nSegments[pixelModuleIndex]; + unsigned int nPixels = segments.mod.nSegments()[pixelModuleIndex]; for (unsigned int pixelArrayIndex = globalThreadIdx[2]; pixelArrayIndex < nPixels; pixelArrayIndex += gridThreadExtent[2]) { - if (!segmentsInGPU.isQuad[pixelArrayIndex] || segmentsInGPU.isDup[pixelArrayIndex]) + if (!segments.pix.isQuad()[pixelArrayIndex] || segments.pix.isDup()[pixelArrayIndex]) continue; - float eta1 = segmentsInGPU.eta[pixelArrayIndex]; - float phi1 = segmentsInGPU.phi[pixelArrayIndex]; + float eta1 = segments.pix.eta()[pixelArrayIndex]; + float phi1 = segments.pix.phi()[pixelArrayIndex]; unsigned int prefix = rangesInGPU.segmentModuleIndices[pixelModuleIndex]; unsigned int nTrackCandidates = *(trackCandidatesInGPU.nTrackCandidates); @@ -340,14 +340,14 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { float dR2 = dEta * dEta + dPhi * dPhi; if (dR2 < 1e-3f) - segmentsInGPU.isDup[pixelArrayIndex] = true; + segments.pix.isDup()[pixelArrayIndex] = true; } if (type == 5) // pT3 { int pLSIndex = pixelTripletsInGPU.pixelSegmentIndices[innerTrackletIdx]; - int npMatched = checkPixelHits(prefix + pixelArrayIndex, pLSIndex, mdsInGPU, segmentsInGPU, hitsInGPU); + int npMatched = checkPixelHits(prefix + pixelArrayIndex, pLSIndex, mdsInGPU, segments, hitsInGPU); if (npMatched > 0) - segmentsInGPU.isDup[pixelArrayIndex] = true; + segments.pix.isDup()[pixelArrayIndex] = true; int pT3Index = innerTrackletIdx; float eta2 = __H2F(pixelTripletsInGPU.eta_pix[pT3Index]); @@ -357,24 +357,24 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { float dR2 = dEta * dEta + dPhi * dPhi; if (dR2 < 0.000001f) - segmentsInGPU.isDup[pixelArrayIndex] = true; + segments.pix.isDup()[pixelArrayIndex] = true; } if (type == 7) // pT5 { unsigned int pLSIndex = innerTrackletIdx; - int npMatched = checkPixelHits(prefix + pixelArrayIndex, pLSIndex, mdsInGPU, segmentsInGPU, hitsInGPU); + int npMatched = checkPixelHits(prefix + pixelArrayIndex, pLSIndex, mdsInGPU, segments, hitsInGPU); if (npMatched > 0) { - segmentsInGPU.isDup[pixelArrayIndex] = true; + segments.pix.isDup()[pixelArrayIndex] = true; } - float eta2 = segmentsInGPU.eta[pLSIndex - prefix]; - float phi2 = segmentsInGPU.phi[pLSIndex - prefix]; + float eta2 = segments.pix.eta()[pLSIndex - prefix]; + float phi2 = segments.pix.phi()[pLSIndex - prefix]; float dEta = alpaka::math::abs(acc, eta1 - eta2); float dPhi = calculate_dPhi(phi1, phi2); float dR2 = dEta * dEta + dPhi * dPhi; if (dR2 < 0.000001f) - segmentsInGPU.isDup[pixelArrayIndex] = true; + segments.pix.isDup()[pixelArrayIndex] = true; } } } @@ -387,8 +387,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { uint16_t nLowerModules, PixelTriplets pixelTripletsInGPU, TrackCandidates trackCandidatesInGPU, - Segments segmentsInGPU, + Segments segments, ObjectRanges rangesInGPU) const { + // implementation is 1D with a single block static_assert(std::is_same_v, "Should be Acc1D"); ALPAKA_ASSERT_ACC((alpaka::getWorkDiv(acc)[0] == 1)); @@ -426,7 +427,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { &pixelTripletsInGPU.logicalLayers[Params_pT3::kLayers * pixelTripletIndex], &pixelTripletsInGPU.lowerModuleIndices[Params_pT3::kLayers * pixelTripletIndex], &pixelTripletsInGPU.hitIndices[Params_pT3::kHits * pixelTripletIndex], - segmentsInGPU.seedIdx[pT3PixelIndex - pLS_offset], + segments.pix.seedIdx()[pT3PixelIndex - pLS_offset], __H2F(pixelTripletsInGPU.centerX[pixelTripletIndex]), __H2F(pixelTripletsInGPU.centerY[pixelTripletIndex]), radius, @@ -496,15 +497,15 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC void operator()(TAcc const& acc, uint16_t nLowerModules, TrackCandidates trackCandidatesInGPU, - Segments segmentsInGPU, + Segments segments, bool tc_pls_triplets) const { auto const globalThreadIdx = alpaka::getIdx(acc); auto const gridThreadExtent = alpaka::getWorkDiv(acc); - unsigned int nPixels = segmentsInGPU.nSegments[nLowerModules]; + unsigned int nPixels = segments.mod.nSegments()[nLowerModules]; for (unsigned int pixelArrayIndex = globalThreadIdx[2]; pixelArrayIndex < nPixels; pixelArrayIndex += gridThreadExtent[2]) { - if ((tc_pls_triplets ? 0 : !segmentsInGPU.isQuad[pixelArrayIndex]) || (segmentsInGPU.isDup[pixelArrayIndex])) + if ((tc_pls_triplets ? 0 : !segments.pix.isQuad()[pixelArrayIndex]) || (segments.pix.isDup()[pixelArrayIndex])) continue; unsigned int trackCandidateIdx = @@ -523,8 +524,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { addpLSTrackCandidateToMemory(trackCandidatesInGPU, pixelArrayIndex, trackCandidateIdx, - segmentsInGPU.pLSHitsIdxs[pixelArrayIndex], - segmentsInGPU.seedIdx[pixelArrayIndex]); + segments.pix.pLSHitsIdxs()[pixelArrayIndex], + segments.pix.seedIdx()[pixelArrayIndex]); } } } @@ -536,8 +537,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { uint16_t nLowerModules, PixelQuintuplets pixelQuintupletsInGPU, TrackCandidates trackCandidatesInGPU, - Segments segmentsInGPU, + Segments segments, ObjectRanges rangesInGPU) const { + // implementation is 1D with a single block static_assert(std::is_same_v, "Should be Acc1D"); ALPAKA_ASSERT_ACC((alpaka::getWorkDiv(acc)[0] == 1)); @@ -576,7 +578,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { &pixelQuintupletsInGPU.logicalLayers[Params_pT5::kLayers * pixelQuintupletIndex], &pixelQuintupletsInGPU.lowerModuleIndices[Params_pT5::kLayers * pixelQuintupletIndex], &pixelQuintupletsInGPU.hitIndices[Params_pT5::kHits * pixelQuintupletIndex], - segmentsInGPU.seedIdx[pT5PixelIndex - pLS_offset], + segments.pix.seedIdx()[pT5PixelIndex - pLS_offset], __H2F(pixelQuintupletsInGPU.centerX[pixelQuintupletIndex]), __H2F(pixelQuintupletsInGPU.centerY[pixelQuintupletIndex]), radius, diff --git a/RecoTracker/LSTCore/src/alpaka/Triplet.h b/RecoTracker/LSTCore/src/alpaka/Triplet.h index 5e1b352748573..74ce948a0334c 100644 --- a/RecoTracker/LSTCore/src/alpaka/Triplet.h +++ b/RecoTracker/LSTCore/src/alpaka/Triplet.h @@ -138,7 +138,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { #ifdef CUT_VALUE_DEBUG ALPAKA_FN_ACC ALPAKA_FN_INLINE void addTripletToMemory(Modules const& modulesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, Triplets& tripletsInGPU, unsigned int innerSegmentIndex, unsigned int outerSegmentIndex, @@ -156,7 +156,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { #else ALPAKA_FN_ACC ALPAKA_FN_INLINE void addTripletToMemory(Modules const& modulesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, Triplets& tripletsInGPU, unsigned int innerSegmentIndex, unsigned int outerSegmentIndex, @@ -187,9 +187,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { tripletsInGPU.logicalLayers[tripletIndex * Params_T3::kLayers + 2] = modulesInGPU.layers[outerOuterLowerModuleIndex] + (modulesInGPU.subdets[outerOuterLowerModuleIndex] == 4) * 6; //get the hits - unsigned int firstMDIndex = segmentsInGPU.mdIndices[2 * innerSegmentIndex]; - unsigned int secondMDIndex = segmentsInGPU.mdIndices[2 * innerSegmentIndex + 1]; - unsigned int thirdMDIndex = segmentsInGPU.mdIndices[2 * outerSegmentIndex + 1]; + unsigned int firstMDIndex = segments.mem.mdIndices()[innerSegmentIndex][0]; + unsigned int secondMDIndex = segments.mem.mdIndices()[innerSegmentIndex][1]; + unsigned int thirdMDIndex = segments.mem.mdIndices()[outerSegmentIndex][1]; tripletsInGPU.hitIndices[tripletIndex * Params_T3::kHits] = mdsInGPU.anchorHitIndices[firstMDIndex]; tripletsInGPU.hitIndices[tripletIndex * Params_T3::kHits + 1] = mdsInGPU.outerHitIndices[firstMDIndex]; @@ -208,7 +208,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC ALPAKA_FN_INLINE bool passRZConstraint(TAcc const& acc, Modules const& modulesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, uint16_t innerInnerLowerModuleIndex, uint16_t middleLowerModuleIndex, uint16_t outerOuterLowerModuleIndex, @@ -268,7 +268,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC ALPAKA_FN_INLINE bool passPointingConstraintBBB(TAcc const& acc, Modules const& modulesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, uint16_t innerInnerLowerModuleIndex, uint16_t middleLowerModuleIndex, uint16_t outerOuterLowerModuleIndex, @@ -337,7 +337,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { return false; // raw betaIn value without any correction, based on the mini-doublet hit positions - float alpha_InLo = __H2F(segmentsInGPU.dPhiChanges[innerSegmentIndex]); + float alpha_InLo = __H2F(segments.mem.dPhiChanges()[innerSegmentIndex]); float tl_axis_x = mdsInGPU.anchorX[thirdMDIndex] - mdsInGPU.anchorX[firstMDIndex]; float tl_axis_y = mdsInGPU.anchorY[thirdMDIndex] - mdsInGPU.anchorY[firstMDIndex]; betaIn = alpha_InLo - phi_mpi_pi(acc, phi(acc, tl_axis_x, tl_axis_y) - mdsInGPU.anchorPhi[firstMDIndex]); @@ -364,7 +364,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC ALPAKA_FN_INLINE bool passPointingConstraintBBE(TAcc const& acc, Modules const& modulesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, uint16_t innerInnerLowerModuleIndex, uint16_t middleLowerModuleIndex, uint16_t outerOuterLowerModuleIndex, @@ -446,7 +446,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { float rt_InLo = mdsInGPU.anchorRt[firstMDIndex]; float rt_InOut = mdsInGPU.anchorRt[secondMDIndex]; - float sdIn_alpha = __H2F(segmentsInGPU.dPhiChanges[innerSegmentIndex]); + float sdIn_alpha = __H2F(segments.mem.dPhiChanges()[innerSegmentIndex]); float tl_axis_x = mdsInGPU.anchorX[thirdMDIndex] - mdsInGPU.anchorX[firstMDIndex]; float tl_axis_y = mdsInGPU.anchorY[thirdMDIndex] - mdsInGPU.anchorY[firstMDIndex]; @@ -483,7 +483,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC ALPAKA_FN_INLINE bool passPointingConstraintEEE(TAcc const& acc, Modules const& modulesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, uint16_t innerInnerLowerModuleIndex, uint16_t middleLowerModuleIndex, uint16_t outerOuterLowerModuleIndex, @@ -566,15 +566,15 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { float rt_InLo = mdsInGPU.anchorRt[firstMDIndex]; float rt_InOut = mdsInGPU.anchorRt[secondMDIndex]; - float sdIn_alpha = __H2F(segmentsInGPU.dPhiChanges[innerSegmentIndex]); + float sdIn_alpha = __H2F(segments.mem.dPhiChanges()[innerSegmentIndex]); float tl_axis_x = mdsInGPU.anchorX[thirdMDIndex] - mdsInGPU.anchorX[firstMDIndex]; float tl_axis_y = mdsInGPU.anchorY[thirdMDIndex] - mdsInGPU.anchorY[firstMDIndex]; betaIn = sdIn_alpha - phi_mpi_pi(acc, phi(acc, tl_axis_x, tl_axis_y) - mdsInGPU.anchorPhi[firstMDIndex]); - float sdIn_alphaRHmin = __H2F(segmentsInGPU.dPhiChangeMins[innerSegmentIndex]); - float sdIn_alphaRHmax = __H2F(segmentsInGPU.dPhiChangeMaxs[innerSegmentIndex]); + float sdIn_alphaRHmin = __H2F(segments.mem.dPhiChangeMins()[innerSegmentIndex]); + float sdIn_alphaRHmax = __H2F(segments.mem.dPhiChangeMaxs()[innerSegmentIndex]); float betaInRHmin = betaIn + sdIn_alphaRHmin - sdIn_alpha; float betaInRHmax = betaIn + sdIn_alphaRHmax - sdIn_alpha; @@ -604,7 +604,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC ALPAKA_FN_INLINE bool passPointingConstraint(TAcc const& acc, Modules const& modulesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, uint16_t innerInnerLowerModuleIndex, uint16_t middleLowerModuleIndex, uint16_t outerOuterLowerModuleIndex, @@ -627,7 +627,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { return passPointingConstraintBBB(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, innerInnerLowerModuleIndex, middleLowerModuleIndex, outerOuterLowerModuleIndex, @@ -644,7 +644,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { return passPointingConstraintBBE(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, innerInnerLowerModuleIndex, middleLowerModuleIndex, outerOuterLowerModuleIndex, @@ -663,7 +663,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { return passPointingConstraintBBE(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, innerInnerLowerModuleIndex, middleLowerModuleIndex, outerOuterLowerModuleIndex, @@ -685,7 +685,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { return passPointingConstraintEEE(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, innerInnerLowerModuleIndex, middleLowerModuleIndex, outerOuterLowerModuleIndex, @@ -739,7 +739,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC ALPAKA_FN_INLINE bool runTripletConstraintsAndAlgo(TAcc const& acc, Modules const& modulesInGPU, MiniDoublets const& mdsInGPU, - Segments const& segmentsInGPU, + Segments segments, uint16_t innerInnerLowerModuleIndex, uint16_t middleLowerModuleIndex, uint16_t outerOuterLowerModuleIndex, @@ -753,17 +753,17 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { float& circleCenterX, float& circleCenterY) { //this cut reduces the number of candidates by a factor of 4, i.e., 3 out of 4 warps can end right here! - if (segmentsInGPU.mdIndices[2 * innerSegmentIndex + 1] != segmentsInGPU.mdIndices[2 * outerSegmentIndex]) + if (segments.mem.mdIndices()[innerSegmentIndex][1] != segments.mem.mdIndices()[outerSegmentIndex][0]) return false; - unsigned int firstMDIndex = segmentsInGPU.mdIndices[2 * innerSegmentIndex]; - unsigned int secondMDIndex = segmentsInGPU.mdIndices[2 * outerSegmentIndex]; - unsigned int thirdMDIndex = segmentsInGPU.mdIndices[2 * outerSegmentIndex + 1]; + unsigned int firstMDIndex = segments.mem.mdIndices()[innerSegmentIndex][0]; + unsigned int secondMDIndex = segments.mem.mdIndices()[outerSegmentIndex][0]; + unsigned int thirdMDIndex = segments.mem.mdIndices()[outerSegmentIndex][1]; if (not(passRZConstraint(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, innerInnerLowerModuleIndex, middleLowerModuleIndex, outerOuterLowerModuleIndex, @@ -774,7 +774,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { if (not(passPointingConstraint(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, innerInnerLowerModuleIndex, middleLowerModuleIndex, outerOuterLowerModuleIndex, @@ -806,7 +806,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC void operator()(TAcc const& acc, Modules modulesInGPU, MiniDoublets mdsInGPU, - Segments segmentsInGPU, + Segments segments, Triplets tripletsInGPU, ObjectRanges rangesInGPU, uint16_t* index_gpu, @@ -824,29 +824,29 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { if (nConnectedModules == 0) continue; - unsigned int nInnerSegments = segmentsInGPU.nSegments[innerInnerLowerModuleIndex]; + unsigned int nInnerSegments = segments.mod.nSegments()[innerInnerLowerModuleIndex]; for (unsigned int innerSegmentArrayIndex = globalThreadIdx[1]; innerSegmentArrayIndex < nInnerSegments; innerSegmentArrayIndex += gridThreadExtent[1]) { unsigned int innerSegmentIndex = rangesInGPU.segmentRanges[innerInnerLowerModuleIndex * 2] + innerSegmentArrayIndex; // middle lower module - outer lower module of inner segment - uint16_t middleLowerModuleIndex = segmentsInGPU.outerLowerModuleIndices[innerSegmentIndex]; + uint16_t middleLowerModuleIndex = segments.mem.outerLowerModuleIndices()[innerSegmentIndex]; - unsigned int nOuterSegments = segmentsInGPU.nSegments[middleLowerModuleIndex]; + unsigned int nOuterSegments = segments.mod.nSegments()[middleLowerModuleIndex]; for (unsigned int outerSegmentArrayIndex = globalThreadIdx[2]; outerSegmentArrayIndex < nOuterSegments; outerSegmentArrayIndex += gridThreadExtent[2]) { unsigned int outerSegmentIndex = rangesInGPU.segmentRanges[2 * middleLowerModuleIndex] + outerSegmentArrayIndex; - uint16_t outerOuterLowerModuleIndex = segmentsInGPU.outerLowerModuleIndices[outerSegmentIndex]; + uint16_t outerOuterLowerModuleIndex = segments.mem.outerLowerModuleIndices()[outerSegmentIndex]; float zOut, rtOut, betaIn, betaInCut, circleRadius, circleCenterX, circleCenterY; bool success = runTripletConstraintsAndAlgo(acc, modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, innerInnerLowerModuleIndex, middleLowerModuleIndex, outerOuterLowerModuleIndex, @@ -879,7 +879,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { #ifdef CUT_VALUE_DEBUG addTripletToMemory(modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, tripletsInGPU, innerSegmentIndex, outerSegmentIndex, @@ -897,7 +897,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { #else addTripletToMemory(modulesInGPU, mdsInGPU, - segmentsInGPU, + segments, tripletsInGPU, innerSegmentIndex, outerSegmentIndex, @@ -923,7 +923,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC void operator()(TAcc const& acc, Modules modulesInGPU, ObjectRanges rangesInGPU, - Segments segmentsInGPU) const { + Segments segments) const { // implementation is 1D with a single block static_assert(std::is_same_v, "Should be Acc1D"); ALPAKA_ASSERT_ACC((alpaka::getWorkDiv(acc)[0] == 1)); @@ -942,7 +942,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { int occupancy, category_number, eta_number; for (uint16_t i = globalThreadIdx[0]; i < *modulesInGPU.nLowerModules; i += gridThreadExtent[0]) { - if (segmentsInGPU.nSegments[i] == 0) { + if (segments.mod.nSegments()[i] == 0) { rangesInGPU.tripletModuleIndices[i] = nTotalTriplets; rangesInGPU.tripletModuleOccupancy[i] = 0; continue; diff --git a/RecoTracker/LSTCore/standalone/LST/Makefile b/RecoTracker/LSTCore/standalone/LST/Makefile index ba5e19e6a2779..43deafa8bcc8a 100644 --- a/RecoTracker/LSTCore/standalone/LST/Makefile +++ b/RecoTracker/LSTCore/standalone/LST/Makefile @@ -44,17 +44,17 @@ LIBS=$(LIB_CPU) $(LIB_CUDA) $(LIB_ROCM) GENCODE_CUDA := -gencode arch=compute_70,code=[sm_70,compute_70] -gencode arch=compute_89,code=[sm_89,compute_89] CXX = g++ -CXXFLAGS_CPU = -march=native -mtune=native -Ofast -fno-reciprocal-math -fopenmp-simd -g -Wall -Wshadow -Woverloaded-virtual -fPIC -fopenmp -I.. -CXXFLAGS_CUDA = -O3 -g --compiler-options -Wall --compiler-options -Wshadow --compiler-options -Woverloaded-virtual --compiler-options -fPIC --compiler-options -fopenmp -dc -lineinfo --ptxas-options=-v --cudart shared $(GENCODE_CUDA) --use_fast_math --default-stream per-thread -I.. +CXXFLAGS_CPU = -march=native -mtune=native -Ofast -fno-reciprocal-math -fopenmp-simd -g -Wall -Woverloaded-virtual -fPIC -fopenmp -I.. +CXXFLAGS_CUDA = -O3 -g --compiler-options -Wall --compiler-options -Woverloaded-virtual --compiler-options -fPIC --compiler-options -fopenmp -dc -lineinfo --ptxas-options=-v --cudart shared $(GENCODE_CUDA) --use_fast_math --default-stream per-thread -I.. CXXFLAGS_ROCM = -O3 -g -Wall -Wshadow -Woverloaded-virtual -fPIC -I${ROCM_ROOT}/include -I.. CMSSWINCLUDE := -I${TRACKLOOPERDIR}/../../../ -I${CMSSW_BASE}/src ifdef CMSSW_RELEASE_BASE CMSSWINCLUDE := ${CMSSWINCLUDE} -I${CMSSW_RELEASE_BASE}/src endif ALPAKAINCLUDE = -I${ALPAKA_ROOT}/include -I/${BOOST_ROOT}/include -std=c++17 ${CMSSWINCLUDE} -ALPAKASERIAL = -DALPAKA_ACC_CPU_B_SEQ_T_SEQ_ENABLED -ALPAKACUDA = -DALPAKA_ACC_GPU_CUDA_ENABLED -DALPAKA_ACC_GPU_CUDA_ONLY --expt-relaxed-constexpr -ALPAKAROCM = -DALPAKA_ACC_GPU_HIP_ENABLED -DALPAKA_ACC_GPU_HIP_ONLY -DALPAKA_DISABLE_VENDOR_RNG +ALPAKASERIAL = -DALPAKA_ACC_CPU_B_SEQ_T_SEQ_ENABLED -DALPAKA_DISABLE_VENDOR_RNG -DALPAKA_DEFAULT_HOST_MEMORY_ALIGNMENT=128 +ALPAKACUDA = -DALPAKA_ACC_GPU_CUDA_ENABLED -DALPAKA_ACC_GPU_CUDA_ONLY -DALPAKA_DISABLE_VENDOR_RNG -DALPAKA_DEFAULT_HOST_MEMORY_ALIGNMENT=128 --expt-relaxed-constexpr +ALPAKAROCM = -DALPAKA_ACC_GPU_HIP_ENABLED -DALPAKA_ACC_GPU_HIP_ONLY -DALPAKA_DISABLE_VENDOR_RNG -DALPAKA_DEFAULT_HOST_MEMORY_ALIGNMENT=128 ROOTINCLUDE = -I$(ROOT_ROOT)/include ROOTCFLAGS = -pthread -m64 $(ROOTINCLUDE) PRINTFLAG = -DT4FromT3 diff --git a/RecoTracker/LSTCore/standalone/Makefile b/RecoTracker/LSTCore/standalone/Makefile index efcd2483c5eba..8eb677611513e 100644 --- a/RecoTracker/LSTCore/standalone/Makefile +++ b/RecoTracker/LSTCore/standalone/Makefile @@ -9,7 +9,7 @@ OBJECTS_ROCM=$(SOURCES:.cc=_rocm.o) OBJECTS=$(OBJECTS_CPU) $(OBJECTS_CUDA) $(OBJECTS_ROCM) CXX = g++ -CXXFLAGS = -g -O2 -Wall -fPIC -Wshadow -Woverloaded-virtual -Wno-unused-function -fno-var-tracking -std=c++17 +CXXFLAGS = -g -O2 -Wall -fPIC -Woverloaded-virtual -Wno-unused-function -fno-var-tracking -std=c++17 INCLUDEFLAGS= -ILST -I$(shell pwd) -Icode -Icode/core -I${ALPAKA_ROOT}/include -I/${BOOST_ROOT}/include $(shell rooutil-config --include) -I$(shell root-config --incdir) -I${TRACKLOOPERDIR}/../../../ -I${CMSSW_BASE}/src -I../interface/ -I../interface/alpaka/ -I../src/ -I../src/alpaka/ ifdef CMSSW_RELEASE_BASE INCLUDEFLAGS:= ${INCLUDEFLAGS} -I${CMSSW_RELEASE_BASE}/src @@ -20,9 +20,9 @@ LDFLAGS_ROCM= -L${ROCM_ROOT}/lib -lamdhip64 ALPAKAFLAGS = -DALPAKA_DEBUG=0 CUDAINCLUDE = -I${CUDA_HOME}/include ROCMINCLUDE = -I${ROCM_ROOT}/include -ALPAKA_CPU = -DALPAKA_ACC_CPU_B_SEQ_T_SEQ_ENABLED -ALPAKA_CUDA = -DALPAKA_ACC_GPU_CUDA_ENABLED -DALPAKA_HOST_ONLY -ALPAKA_ROCM = -DALPAKA_ACC_GPU_HIP_ENABLED -DALPAKA_HOST_ONLY -DALPAKA_DISABLE_VENDOR_RNG -D__HIP_PLATFORM_HCC__ -D__HIP_PLATFORM_AMD__ +ALPAKA_CPU = -DALPAKA_ACC_CPU_B_SEQ_T_SEQ_ENABLED -DALPAKA_DISABLE_VENDOR_RNG -DALPAKA_DEFAULT_HOST_MEMORY_ALIGNMENT=128 +ALPAKA_CUDA = -DALPAKA_ACC_GPU_CUDA_ENABLED -DALPAKA_HOST_ONLY -DALPAKA_DISABLE_VENDOR_RNG -DALPAKA_DEFAULT_HOST_MEMORY_ALIGNMENT=128 +ALPAKA_ROCM = -DALPAKA_ACC_GPU_HIP_ENABLED -DALPAKA_HOST_ONLY -DALPAKA_DISABLE_VENDOR_RNG -D__HIP_PLATFORM_HCC__ -D__HIP_PLATFORM_AMD__ -DALPAKA_DEFAULT_HOST_MEMORY_ALIGNMENT=128 EXTRAFLAGS = -ITMultiDrawTreePlayer -Wunused-variable -lTMVA -lEG -lGenVector -lXMLIO -lMLP -lTreePlayer -fopenmp DOQUINTUPLET = PTCUTFLAG = diff --git a/RecoTracker/LSTCore/standalone/code/core/AccessHelper.cc b/RecoTracker/LSTCore/standalone/code/core/AccessHelper.cc index 426a74babc4d1..a64be1c286467 100644 --- a/RecoTracker/LSTCore/standalone/code/core/AccessHelper.cc +++ b/RecoTracker/LSTCore/standalone/code/core/AccessHelper.cc @@ -28,13 +28,13 @@ std::tuple, std::vector> convertHitsToHi //____________________________________________________________________________________________ std::vector getPixelHitsFrompLS(Event* event, unsigned int pLS) { - Segments const* segments = event->getSegments().data(); + Segments& segments = event->getSegments(); MiniDoublets const* miniDoublets = event->getMiniDoublets().data(); ObjectRanges const* rangesEvt = event->getRanges().data(); Modules const* modulesEvt = event->getModules().data(); const unsigned int pLS_offset = rangesEvt->segmentModuleIndices[*(modulesEvt->nLowerModules)]; - unsigned int MD_1 = segments->mdIndices[2 * (pLS + pLS_offset)]; - unsigned int MD_2 = segments->mdIndices[2 * (pLS + pLS_offset) + 1]; + unsigned int MD_1 = segments.mem.mdIndices()[2 * (pLS + pLS_offset)][0]; + unsigned int MD_2 = segments.mem.mdIndices()[2 * (pLS + pLS_offset)][1]; unsigned int hit_1 = miniDoublets->anchorHitIndices[MD_1]; unsigned int hit_2 = miniDoublets->outerHitIndices[MD_1]; unsigned int hit_3 = miniDoublets->anchorHitIndices[MD_2]; @@ -92,9 +92,9 @@ std::tuple, std::vector> getHitIdxsAndHi //____________________________________________________________________________________________ std::vector getMDsFromLS(Event* event, unsigned int LS) { - Segments const* segments = event->getSegments().data(); - unsigned int MD_1 = segments->mdIndices[2 * LS]; - unsigned int MD_2 = segments->mdIndices[2 * LS + 1]; + Segments& segments = event->getSegments(); + unsigned int MD_1 = segments.mem.mdIndices()[2 * LS][0]; + unsigned int MD_2 = segments.mem.mdIndices()[2 * LS][1]; return {MD_1, MD_2}; } diff --git a/RecoTracker/LSTCore/standalone/code/core/write_lst_ntuple.cc b/RecoTracker/LSTCore/standalone/code/core/write_lst_ntuple.cc index e12512f5c5c7d..35970b17c3c2c 100644 --- a/RecoTracker/LSTCore/standalone/code/core/write_lst_ntuple.cc +++ b/RecoTracker/LSTCore/standalone/code/core/write_lst_ntuple.cc @@ -293,7 +293,7 @@ void setPixelQuintupletOutputBranches(Event* event) { // ============ pT5 ============= PixelQuintuplets const* pixelQuintuplets = event->getPixelQuintuplets().data(); Quintuplets const* quintuplets = event->getQuintuplets().data(); - Segments const* segments = event->getSegments().data(); + Segments& segments = event->getSegments(); Modules const* modules = event->getModules().data(); int n_accepted_simtrk = ana.tx->getBranch>("sim_TC_matched").size(); @@ -305,9 +305,9 @@ void setPixelQuintupletOutputBranches(Event* event) { for (unsigned int pT5 = 0; pT5 < nPixelQuintuplets; pT5++) { unsigned int T5Index = getT5FrompT5(event, pT5); unsigned int pLSIndex = getPixelLSFrompT5(event, pT5); - float pt = (__H2F(quintuplets->innerRadius[T5Index]) * k2Rinv1GeVf * 2 + segments->ptIn[pLSIndex]) / 2; - float eta = segments->eta[pLSIndex]; - float phi = segments->phi[pLSIndex]; + float pt = (__H2F(quintuplets->innerRadius[T5Index]) * k2Rinv1GeVf * 2 + segments.pix.ptIn()[pLSIndex]) / 2; + float eta = segments.pix.eta()[pLSIndex]; + float phi = segments.pix.phi()[pLSIndex]; std::vector hit_idx = getHitIdxsFrompT5(event, pT5); std::vector module_idx = getModuleIdxsFrompT5(event, pT5); @@ -439,7 +439,7 @@ void setQuintupletOutputBranches(Event* event) { void setPixelTripletOutputBranches(Event* event) { PixelTriplets const* pixelTriplets = event->getPixelTriplets().data(); Modules const* modules = event->getModules().data(); - Segments const* segments = event->getSegments().data(); + Segments& segments = event->getSegments(); int n_accepted_simtrk = ana.tx->getBranch>("sim_TC_matched").size(); unsigned int nPixelTriplets = *pixelTriplets->nPixelTriplets; @@ -449,10 +449,10 @@ void setPixelTripletOutputBranches(Event* event) { for (unsigned int pT3 = 0; pT3 < nPixelTriplets; pT3++) { unsigned int T3Index = getT3FrompT3(event, pT3); unsigned int pLSIndex = getPixelLSFrompT3(event, pT3); - const float pt = segments->ptIn[pLSIndex]; + const float pt = segments.pix.ptIn()[pLSIndex]; - float eta = segments->eta[pLSIndex]; - float phi = segments->phi[pLSIndex]; + float eta = segments.pix.eta()[pLSIndex]; + float phi = segments.pix.phi()[pLSIndex]; std::vector hit_idx = getHitIdxsFrompT3(event, pT3); std::vector hit_type = getHitTypesFrompT3(event, pT3); @@ -501,7 +501,7 @@ void setPixelTripletOutputBranches(Event* event) { //________________________________________________________________________________________________________________________________ void setGnnNtupleBranches(Event* event) { // Get relevant information - Segments const* segments = event->getSegments().data(); + Segments& segments = event->getSegments(); MiniDoublets const* miniDoublets = event->getMiniDoublets().data(); Hits const* hitsEvt = event->getHits().data(); Modules const* modules = event->getModules().data(); @@ -517,7 +517,7 @@ void setGnnNtupleBranches(Event* event) { unsigned int nTotalLS = 0; for (unsigned int idx = 0; idx < *(modules->nLowerModules); ++idx) { nTotalMD += miniDoublets->nMDs[idx]; - nTotalLS += segments->nSegments[idx]; + nTotalLS += segments.mod.nSegments()[idx]; } std::set lss_used_in_true_tc; @@ -556,7 +556,7 @@ void setGnnNtupleBranches(Event* event) { // } // Loop over segments - for (unsigned int jdx = 0; jdx < segments->nSegments[idx]; jdx++) { + for (unsigned int jdx = 0; jdx < segments.mod.nSegments()[idx]; jdx++) { // Get the actual index to the segments using ranges unsigned int sgIdx = ranges->segmentModuleIndices[idx] + jdx; @@ -746,7 +746,7 @@ std::tuple, std::vectorgetTrackCandidates().data(); Quintuplets const* quintuplets = event->getQuintuplets().data(); - Segments const* segments = event->getSegments().data(); + Segments& segments = event->getSegments(); // // pictorial representation of a pT5 @@ -839,9 +839,9 @@ std::tuple, std::vectorptIn[pLS]; - const float eta_pLS = segments->eta[pLS]; - const float phi_pLS = segments->phi[pLS]; + const float pt_pLS = segments.pix.ptIn()[pLS]; + const float eta_pLS = segments.pix.eta()[pLS]; + const float phi_pLS = segments.pix.phi()[pLS]; float pt_T5 = __H2F(quintuplets->innerRadius[T5Index]) * 2 * k2Rinv1GeVf; const float pt = (pt_T5 + pt_pLS) / 2; @@ -858,7 +858,7 @@ std::tuple, std::vectorgetTrackCandidates().data(); Triplets const* triplets = event->getTriplets().data(); - Segments const* segments = event->getSegments().data(); + Segments& segments = event->getSegments(); // // pictorial representation of a pT3 @@ -872,9 +872,9 @@ std::tuple, std::vectorptIn[pLS]; - const float eta_pLS = segments->eta[pLS]; - const float phi_pLS = segments->phi[pLS]; + const float pt_pLS = segments.pix.ptIn()[pLS]; + const float eta_pLS = segments.pix.eta()[pLS]; + const float phi_pLS = segments.pix.phi()[pLS]; float pt_T3 = triplets->circleRadius[T3] * 2 * k2Rinv1GeVf; // average pt @@ -925,15 +925,15 @@ std::tuple, std::vector, std::vector> parsepLS(Event* event, unsigned int idx) { TrackCandidates const* trackCandidates = event->getTrackCandidates().data(); - Segments const* segments = event->getSegments().data(); + Segments& segments = event->getSegments(); // Getting pLS index unsigned int pLS = trackCandidates->directObjectIndices[idx]; // Getting pt eta and phi - float pt = segments->ptIn[pLS]; - float eta = segments->eta[pLS]; - float phi = segments->phi[pLS]; + float pt = segments.pix.ptIn()[pLS]; + float eta = segments.pix.eta()[pLS]; + float phi = segments.pix.phi()[pLS]; // Getting hit indices and types std::vector hit_idx = getPixelHitIdxsFrompLS(event, pLS); @@ -1008,7 +1008,7 @@ void printMDs(Event* event) { //________________________________________________________________________________________________________________________________ void printLSs(Event* event) { - Segments const* segments = event->getSegments().data(); + Segments& segments = event->getSegments(); MiniDoublets const* miniDoublets = event->getMiniDoublets().data(); Hits const* hitsEvt = event->getHits().data(); Modules const* modules = event->getModules().data(); @@ -1017,11 +1017,11 @@ void printLSs(Event* event) { int nSegments = 0; for (unsigned int i = 0; i < *(modules->nLowerModules); ++i) { unsigned int idx = i; //modules->lowerModuleIndices[i]; - nSegments += segments->nSegments[idx]; - for (unsigned int jdx = 0; jdx < segments->nSegments[idx]; jdx++) { + nSegments += segments.mod.nSegments()[idx]; + for (unsigned int jdx = 0; jdx < segments.mod.nSegments()[idx]; jdx++) { unsigned int sgIdx = ranges->segmentModuleIndices[idx] + jdx; - unsigned int InnerMiniDoubletIndex = segments->mdIndices[2 * sgIdx]; - unsigned int OuterMiniDoubletIndex = segments->mdIndices[2 * sgIdx + 1]; + unsigned int InnerMiniDoubletIndex = segments.mem.mdIndices()[2 * sgIdx][0]; + unsigned int OuterMiniDoubletIndex = segments.mem.mdIndices()[2 * sgIdx][1]; unsigned int InnerMiniDoubletLowerHitIndex = miniDoublets->anchorHitIndices[InnerMiniDoubletIndex]; unsigned int InnerMiniDoubletUpperHitIndex = miniDoublets->outerHitIndices[InnerMiniDoubletIndex]; unsigned int OuterMiniDoubletLowerHitIndex = miniDoublets->anchorHitIndices[OuterMiniDoubletIndex]; @@ -1040,7 +1040,7 @@ void printLSs(Event* event) { //________________________________________________________________________________________________________________________________ void printpLSs(Event* event) { - Segments const* segments = event->getSegments().data(); + Segments& segments = event->getSegments(); MiniDoublets const* miniDoublets = event->getMiniDoublets().data(); Hits const* hitsEvt = event->getHits().data(); Modules const* modules = event->getModules().data(); @@ -1048,11 +1048,11 @@ void printpLSs(Event* event) { unsigned int i = *(modules->nLowerModules); unsigned int idx = i; //modules->lowerModuleIndices[i]; - int npLS = segments->nSegments[idx]; - for (unsigned int jdx = 0; jdx < segments->nSegments[idx]; jdx++) { + int npLS = segments.mod.nSegments()[idx]; + for (unsigned int jdx = 0; jdx < segments.mod.nSegments()[idx]; jdx++) { unsigned int sgIdx = ranges->segmentModuleIndices[idx] + jdx; - unsigned int InnerMiniDoubletIndex = segments->mdIndices[2 * sgIdx]; - unsigned int OuterMiniDoubletIndex = segments->mdIndices[2 * sgIdx + 1]; + unsigned int InnerMiniDoubletIndex = segments.mem.mdIndices()[2 * sgIdx][0]; + unsigned int OuterMiniDoubletIndex = segments.mem.mdIndices()[2 * sgIdx][1]; unsigned int InnerMiniDoubletLowerHitIndex = miniDoublets->anchorHitIndices[InnerMiniDoubletIndex]; unsigned int InnerMiniDoubletUpperHitIndex = miniDoublets->outerHitIndices[InnerMiniDoubletIndex]; unsigned int OuterMiniDoubletLowerHitIndex = miniDoublets->anchorHitIndices[OuterMiniDoubletIndex]; @@ -1071,7 +1071,7 @@ void printpLSs(Event* event) { //________________________________________________________________________________________________________________________________ void printT3s(Event* event) { Triplets const* triplets = event->getTriplets().data(); - Segments const* segments = event->getSegments().data(); + Segments segments = event->getSegments(); MiniDoublets const* miniDoublets = event->getMiniDoublets().data(); Hits const* hitsEvt = event->getHits().data(); Modules const* modules = event->getModules().data(); @@ -1084,9 +1084,9 @@ void printT3s(Event* event) { unsigned int tpIdx = idx * 5000 + jdx; unsigned int InnerSegmentIndex = triplets->segmentIndices[2 * tpIdx]; unsigned int OuterSegmentIndex = triplets->segmentIndices[2 * tpIdx + 1]; - unsigned int InnerSegmentInnerMiniDoubletIndex = segments->mdIndices[2 * InnerSegmentIndex]; - unsigned int InnerSegmentOuterMiniDoubletIndex = segments->mdIndices[2 * InnerSegmentIndex + 1]; - unsigned int OuterSegmentOuterMiniDoubletIndex = segments->mdIndices[2 * OuterSegmentIndex + 1]; + unsigned int InnerSegmentInnerMiniDoubletIndex = segments.mem.mdIndices()[2 * InnerSegmentIndex][0]; + unsigned int InnerSegmentOuterMiniDoubletIndex = segments.mem.mdIndices()[2 * InnerSegmentIndex][1]; + unsigned int OuterSegmentOuterMiniDoubletIndex = segments.mem.mdIndices()[2 * OuterSegmentIndex][1]; unsigned int hit_idx0 = miniDoublets->anchorHitIndices[InnerSegmentInnerMiniDoubletIndex]; unsigned int hit_idx1 = miniDoublets->outerHitIndices[InnerSegmentInnerMiniDoubletIndex]; @@ -1114,7 +1114,7 @@ void printT3s(Event* event) { void debugPrintOutlierMultiplicities(Event* event) { TrackCandidates const* trackCandidates = event->getTrackCandidates().data(); Triplets const* triplets = event->getTriplets().data(); - Segments const* segments = event->getSegments().data(); + Segments& segments = event->getSegments(); MiniDoublets const* miniDoublets = event->getMiniDoublets().data(); Modules const* modules = event->getModules().data(); ObjectRanges const* ranges = event->getRanges().data(); @@ -1126,7 +1126,7 @@ void debugPrintOutlierMultiplicities(Event* event) { << " trackCandidates->nTrackCandidates[idx]: " << trackCandidates->nTrackCandidates[idx] << std::endl; std::cout << " idx: " << idx << " triplets->nTriplets[idx]: " << triplets->nTriplets[idx] << std::endl; unsigned int i = idx; //modules->lowerModuleIndices[idx]; - std::cout << " idx: " << idx << " i: " << i << " segments->nSegments[i]: " << segments->nSegments[i] << std::endl; + std::cout << " idx: " << idx << " i: " << i << " segments.mod.nSegments()[i]: " << segments.mod.nSegments()[i] << std::endl; int nMD = miniDoublets->nMDs[2 * idx] + miniDoublets->nMDs[2 * idx + 1]; std::cout << " idx: " << idx << " nMD: " << nMD << std::endl; int nHits = 0;