From 1a75f88e2275ddf6d46f4f33509bef0ccc4cbbc6 Mon Sep 17 00:00:00 2001 From: Anton Alkin Date: Thu, 13 Mar 2025 10:07:31 +0100 Subject: [PATCH 1/3] DPL Analysis: prevent slice cache from updating when not required by enabled process functions --- Framework/Core/include/Framework/ASoA.h | 6 +-- .../Core/include/Framework/AnalysisManagers.h | 14 ++++-- .../Core/include/Framework/AnalysisTask.h | 22 ++++----- .../Framework/ArrowTableSlicingCache.h | 45 +++++++++++------ .../Core/include/Framework/GroupSlicer.h | 2 +- Framework/Core/src/ASoA.cxx | 2 +- Framework/Core/src/ArrowSupport.cxx | 24 ++++----- Framework/Core/src/ArrowTableSlicingCache.cxx | 49 ++++++++++--------- Framework/Core/test/test_GroupSlicer.cxx | 4 +- 9 files changed, 96 insertions(+), 72 deletions(-) diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h index f21decd0d5c45..b586edb707beb 100644 --- a/Framework/Core/include/Framework/ASoA.h +++ b/Framework/Core/include/Framework/ASoA.h @@ -1397,10 +1397,10 @@ namespace o2::framework struct PreslicePolicyBase { const std::string binding; - StringPair bindingKey; + Entry bindingKey; bool isMissing() const; - StringPair const& getBindingKey() const; + Entry const& getBindingKey() const; }; struct PreslicePolicySorted : public PreslicePolicyBase { @@ -1425,7 +1425,7 @@ struct PresliceBase : public Policy { const std::string binding; PresliceBase(expressions::BindingNode index_) - : Policy{PreslicePolicyBase{{o2::soa::getLabelFromTypeForKey(std::string{index_.name})}, std::make_pair(o2::soa::getLabelFromTypeForKey(std::string{index_.name}), std::string{index_.name})}, {}} + : Policy{PreslicePolicyBase{{o2::soa::getLabelFromTypeForKey(std::string{index_.name})}, Entry(o2::soa::getLabelFromTypeForKey(std::string{index_.name}), std::string{index_.name})}, {}} { } diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h index ccabbd7a0a197..d1eb98397f4f9 100644 --- a/Framework/Core/include/Framework/AnalysisManagers.h +++ b/Framework/Core/include/Framework/AnalysisManagers.h @@ -512,39 +512,43 @@ static void setGroupedCombination(C& comb, TG& grouping, std::tuple& asso /// Preslice handling template requires(!is_preslice) -bool registerCache(T&, std::vector&, std::vector&) +bool registerCache(T&, Cache&, Cache&) { return false; } template requires std::same_as -bool registerCache(T& preslice, std::vector& bsks, std::vector&) +bool registerCache(T& preslice, Cache& bsks, Cache&) { if constexpr (T::optional) { if (preslice.binding == "[MISSING]") { return true; } } - auto locate = std::find_if(bsks.begin(), bsks.end(), [&](auto const& entry) { return (entry.first == preslice.bindingKey.first) && (entry.second == preslice.bindingKey.second); }); + auto locate = std::find_if(bsks.begin(), bsks.end(), [&](auto const& entry) { return (entry.binding == preslice.bindingKey.binding) && (entry.key == preslice.bindingKey.key); }); if (locate == bsks.end()) { bsks.emplace_back(preslice.getBindingKey()); + } else if (locate->enabled == false) { + locate->enabled = true; } return true; } template requires std::same_as -bool registerCache(T& preslice, std::vector&, std::vector& bsksU) +bool registerCache(T& preslice, Cache&, Cache& bsksU) { if constexpr (T::optional) { if (preslice.binding == "[MISSING]") { return true; } } - auto locate = std::find_if(bsksU.begin(), bsksU.end(), [&](auto const& entry) { return (entry.first == preslice.bindingKey.first) && (entry.second == preslice.bindingKey.second); }); + auto locate = std::find_if(bsksU.begin(), bsksU.end(), [&](auto const& entry) { return (entry.binding == preslice.bindingKey.binding) && (entry.key == preslice.bindingKey.key); }); if (locate == bsksU.end()) { bsksU.emplace_back(preslice.getBindingKey()); + } else if (locate->enabled == false) { + locate->enabled = true; } return true; } diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h index b78bf61aea558..3d586d56a6703 100644 --- a/Framework/Core/include/Framework/AnalysisTask.h +++ b/Framework/Core/include/Framework/AnalysisTask.h @@ -106,20 +106,20 @@ struct AnalysisDataProcessorBuilder { } template - static void addGroupingCandidates(std::vector& bk, std::vector& bku) + static void addGroupingCandidates(Cache& bk, Cache& bku, bool enabled) { - [&bk, &bku](framework::pack) mutable { + [&bk, &bku, enabled](framework::pack) mutable { std::string key; if constexpr (soa::is_iterator>) { key = std::string{"fIndex"} + o2::framework::cutString(soa::getLabelFromType>()); } - ([&bk, &bku, &key]() mutable { + ([&bk, &bku, &key, enabled]() mutable { if constexpr (soa::relatedByIndex, std::decay_t>()) { auto binding = soa::getLabelFromTypeForKey>(key); if constexpr (o2::soa::is_smallgroups>) { - framework::updatePairList(bku, binding, key); + framework::updatePairList(bku, binding, key, enabled); } else { - framework::updatePairList(bk, binding, key); + framework::updatePairList(bk, binding, key, enabled); } } }(), @@ -192,7 +192,7 @@ struct AnalysisDataProcessorBuilder { /// helper to parse the process arguments /// 1. enumeration (must be the only argument) template - static void inputsFromArgs(R (C::*)(A), const char* /*name*/, bool /*value*/, std::vector& inputs, std::vector&, std::vector&, std::vector&) + static void inputsFromArgs(R (C::*)(A), const char* /*name*/, bool /*value*/, std::vector& inputs, std::vector&, Cache&, Cache&) { std::vector inputMetadata; // FIXME: for the moment we do not support begin, end and step. @@ -201,17 +201,17 @@ struct AnalysisDataProcessorBuilder { /// 2. grouping case - 1st argument is an iterator template - static void inputsFromArgs(R (C::*)(A, Args...), const char* name, bool value, std::vector& inputs, std::vector& eInfos, std::vector& bk, std::vector& bku) + static void inputsFromArgs(R (C::*)(A, Args...), const char* name, bool value, std::vector& inputs, std::vector& eInfos, Cache& bk, Cache& bku) requires(std::is_lvalue_reference_v && (std::is_lvalue_reference_v && ...)) { - addGroupingCandidates(bk, bku); + addGroupingCandidates(bk, bku, value); constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId(); addInputsAndExpressions::parent_t, Args...>(hash, name, value, inputs, eInfos); } /// 3. generic case template - static void inputsFromArgs(R (C::*)(Args...), const char* name, bool value, std::vector& inputs, std::vector& eInfos, std::vector&, std::vector&) + static void inputsFromArgs(R (C::*)(Args...), const char* name, bool value, std::vector& inputs, std::vector& eInfos, Cache&, Cache&) requires(std::is_lvalue_reference_v && ...) { constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId(); @@ -525,8 +525,8 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args) std::vector inputs; std::vector options; std::vector expressionInfos; - std::vector bindingsKeys; - std::vector bindingsKeysUnsorted; + Cache bindingsKeys; + Cache bindingsKeysUnsorted; /// make sure options and configurables are set before expression infos are created homogeneous_apply_refs([&options, &hash](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get()); diff --git a/Framework/Core/include/Framework/ArrowTableSlicingCache.h b/Framework/Core/include/Framework/ArrowTableSlicingCache.h index 2edc23a63ce76..292a67023fc5e 100644 --- a/Framework/Core/include/Framework/ArrowTableSlicingCache.h +++ b/Framework/Core/include/Framework/ArrowTableSlicingCache.h @@ -34,51 +34,64 @@ struct SliceInfoUnsortedPtr { gsl::span getSliceFor(int value) const; }; -using StringPair = std::pair; +struct Entry { + std::string binding; + std::string key; + bool enabled; + + Entry(std::string b, std::string k, bool e = true) + : binding{b}, + key{k}, + enabled{e} + { + } +}; + +using Cache = std::vector; -void updatePairList(std::vector& list, std::string const& binding, std::string const& key); +void updatePairList(Cache& list, std::string const& binding, std::string const& key, bool enabled); struct ArrowTableSlicingCacheDef { constexpr static ServiceKind service_kind = ServiceKind::Global; - std::vector bindingsKeys; - std::vector bindingsKeysUnsorted; + Cache bindingsKeys; + Cache bindingsKeysUnsorted; - void setCaches(std::vector&& bsks); - void setCachesUnsorted(std::vector&& bsks); + void setCaches(Cache&& bsks); + void setCachesUnsorted(Cache&& bsks); }; struct ArrowTableSlicingCache { constexpr static ServiceKind service_kind = ServiceKind::Stream; - std::vector bindingsKeys; + Cache bindingsKeys; std::vector>> values; std::vector>> counts; - std::vector bindingsKeysUnsorted; + Cache bindingsKeysUnsorted; std::vector> valuesUnsorted; std::vector groups; - ArrowTableSlicingCache(std::vector&& bsks, std::vector&& bsksUnsorted = {}); + ArrowTableSlicingCache(Cache&& bsks, Cache&& bsksUnsorted = {}); // set caching information externally - void setCaches(std::vector&& bsks, std::vector&& bsksUnsorted = {}); + void setCaches(Cache&& bsks, Cache&& bsksUnsorted = {}); // update slicing info cache entry (assumes it is already present) arrow::Status updateCacheEntry(int pos, std::shared_ptr const& table); arrow::Status updateCacheEntryUnsorted(int pos, std::shared_ptr const& table); // helper to locate cache position - std::pair getCachePos(StringPair const& bindingKey) const; - int getCachePosSortedFor(StringPair const& bindingKey) const; - int getCachePosUnsortedFor(StringPair const& bindingKey) const; + std::pair getCachePos(Entry const& bindingKey) const; + int getCachePosSortedFor(Entry const& bindingKey) const; + int getCachePosUnsortedFor(Entry const& bindingKey) const; // get slice from cache for a given value - SliceInfoPtr getCacheFor(StringPair const& bindingKey) const; - SliceInfoUnsortedPtr getCacheUnsortedFor(StringPair const& bindingKey) const; + SliceInfoPtr getCacheFor(Entry const& bindingKey) const; + SliceInfoUnsortedPtr getCacheUnsortedFor(Entry const& bindingKey) const; SliceInfoPtr getCacheForPos(int pos) const; SliceInfoUnsortedPtr getCacheUnsortedForPos(int pos) const; - static void validateOrder(StringPair const& bindingKey, std::shared_ptr const& input); + static void validateOrder(Entry const& bindingKey, std::shared_ptr const& input); }; } // namespace o2::framework diff --git a/Framework/Core/include/Framework/GroupSlicer.h b/Framework/Core/include/Framework/GroupSlicer.h index 64b1d863c59e6..b8436314b057e 100644 --- a/Framework/Core/include/Framework/GroupSlicer.h +++ b/Framework/Core/include/Framework/GroupSlicer.h @@ -55,7 +55,7 @@ struct GroupSlicer { { constexpr auto index = framework::has_type_at_v>(associated_pack_t{}); auto binding = o2::soa::getLabelFromTypeForKey>(mIndexColumnName); - auto bk = std::make_pair(binding, mIndexColumnName); + auto bk = Entry(binding, mIndexColumnName); if constexpr (!o2::soa::is_smallgroups>) { if (table.size() == 0) { return; diff --git a/Framework/Core/src/ASoA.cxx b/Framework/Core/src/ASoA.cxx index 810398747de88..5940bc0427225 100644 --- a/Framework/Core/src/ASoA.cxx +++ b/Framework/Core/src/ASoA.cxx @@ -197,7 +197,7 @@ bool PreslicePolicyBase::isMissing() const return binding == "[MISSING]"; } -StringPair const& PreslicePolicyBase::getBindingKey() const +Entry const& PreslicePolicyBase::getBindingKey() const { return bindingKey; } diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx index 12a4c7131e828..203b1170b7cdf 100644 --- a/Framework/Core/src/ArrowSupport.cxx +++ b/Framework/Core/src/ArrowSupport.cxx @@ -566,27 +566,29 @@ o2::framework::ServiceSpec ArrowSupport::arrowTableSlicingCacheSpec() return ServiceSpec{ .name = "arrow-slicing-cache", .uniqueId = CommonServices::simpleServiceId(), - .init = [](ServiceRegistryRef services, DeviceState&, fair::mq::ProgOptions&) { return ServiceHandle{TypeIdHelpers::uniqueId(), - new ArrowTableSlicingCache(std::vector>{services.get().bindingsKeys}, std::vector{services.get().bindingsKeysUnsorted}), - ServiceKind::Stream, typeid(ArrowTableSlicingCache).name()}; }, + .init = [](ServiceRegistryRef services, DeviceState&, fair::mq::ProgOptions&) { + return ServiceHandle{TypeIdHelpers::uniqueId(), + new ArrowTableSlicingCache(Cache{services.get().bindingsKeys}, + Cache{services.get().bindingsKeysUnsorted}), + ServiceKind::Stream, typeid(ArrowTableSlicingCache).name()}; }, .configure = CommonServices::noConfiguration(), .preProcessing = [](ProcessingContext& pc, void* service_ptr) { auto* service = static_cast(service_ptr); auto& caches = service->bindingsKeys; - for (auto i = 0; i < caches.size(); ++i) { - if (pc.inputs().getPos(caches[i].first.c_str()) >= 0) { - auto status = service->updateCacheEntry(i, pc.inputs().get(caches[i].first.c_str())->asArrowTable()); + for (auto i = 0u; i < caches.size(); ++i) { + if (caches[i].enabled && pc.inputs().getPos(caches[i].binding.c_str()) >= 0) { + auto status = service->updateCacheEntry(i, pc.inputs().get(caches[i].binding.c_str())->asArrowTable()); if (!status.ok()) { - throw runtime_error_f("Failed to update slice cache for %s/%s", caches[i].first.c_str(), caches[i].second.c_str()); + throw runtime_error_f("Failed to update slice cache for %s/%s", caches[i].binding.c_str(), caches[i].key.c_str()); } } } auto& unsortedCaches = service->bindingsKeysUnsorted; - for (auto i = 0; i < unsortedCaches.size(); ++i) { - if (pc.inputs().getPos(unsortedCaches[i].first.c_str()) >= 0) { - auto status = service->updateCacheEntryUnsorted(i, pc.inputs().get(unsortedCaches[i].first.c_str())->asArrowTable()); + for (auto i = 0u; i < unsortedCaches.size(); ++i) { + if (unsortedCaches[i].enabled && pc.inputs().getPos(unsortedCaches[i].binding.c_str()) >= 0) { + auto status = service->updateCacheEntryUnsorted(i, pc.inputs().get(unsortedCaches[i].binding.c_str())->asArrowTable()); if (!status.ok()) { - throw runtime_error_f("failed to update slice cache (unsorted) for %s/%s", unsortedCaches[i].first.c_str(), unsortedCaches[i].second.c_str()); + throw runtime_error_f("failed to update slice cache (unsorted) for %s/%s", unsortedCaches[i].binding.c_str(), unsortedCaches[i].key.c_str()); } } } }, diff --git a/Framework/Core/src/ArrowTableSlicingCache.cxx b/Framework/Core/src/ArrowTableSlicingCache.cxx index 4b31f96e32fba..12df5ef6c080b 100644 --- a/Framework/Core/src/ArrowTableSlicingCache.cxx +++ b/Framework/Core/src/ArrowTableSlicingCache.cxx @@ -11,6 +11,7 @@ #include "Framework/ArrowTableSlicingCache.h" #include "Framework/RuntimeError.h" +#include "Framework/Logger.h" #include #include @@ -19,10 +20,10 @@ namespace o2::framework { -void updatePairList(std::vector& list, std::string const& binding, std::string const& key) +void updatePairList(Cache& list, std::string const& binding, std::string const& key, bool enabled = true) { - if (std::find_if(list.begin(), list.end(), [&binding, &key](auto const& entry) { return (entry.first == binding) && (entry.second == key); }) == list.end()) { - list.emplace_back(binding, key); + if (std::find_if(list.begin(), list.end(), [&binding, &key](auto const& entry) { return (entry.binding == binding) && (entry.key == key); }) == list.end()) { + list.emplace_back(binding, key, enabled); } } @@ -65,17 +66,17 @@ gsl::span SliceInfoUnsortedPtr::getSliceFor(int value) const return {(*groups)[value].data(), (*groups)[value].size()}; } -void ArrowTableSlicingCacheDef::setCaches(std::vector&& bsks) +void ArrowTableSlicingCacheDef::setCaches(Cache&& bsks) { bindingsKeys = bsks; } -void ArrowTableSlicingCacheDef::setCachesUnsorted(std::vector&& bsks) +void ArrowTableSlicingCacheDef::setCachesUnsorted(Cache&& bsks) { bindingsKeysUnsorted = bsks; } -ArrowTableSlicingCache::ArrowTableSlicingCache(std::vector&& bsks, std::vector&& bsksUnsorted) +ArrowTableSlicingCache::ArrowTableSlicingCache(Cache&& bsks, Cache&& bsksUnsorted) : bindingsKeys{bsks}, bindingsKeysUnsorted{bsksUnsorted} { @@ -86,7 +87,7 @@ ArrowTableSlicingCache::ArrowTableSlicingCache(std::vector&& bsks, s groups.resize(bindingsKeysUnsorted.size()); } -void ArrowTableSlicingCache::setCaches(std::vector&& bsks, std::vector&& bsksUnsorted) +void ArrowTableSlicingCache::setCaches(Cache&& bsks, Cache&& bsksUnsorted) { bindingsKeys = bsks; bindingsKeysUnsorted = bsksUnsorted; @@ -111,7 +112,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntry(int pos, std::shared_ptr< arrow::Datum value_counts; auto options = arrow::compute::ScalarAggregateOptions::Defaults(); ARROW_ASSIGN_OR_RAISE(value_counts, - arrow::compute::CallFunction("value_counts", {table->GetColumnByName(bindingsKeys[pos].second)}, + arrow::compute::CallFunction("value_counts", {table->GetColumnByName(bindingsKeys[pos].key)}, &options)); auto pair = static_cast(value_counts.array()); values[pos].reset(); @@ -128,7 +129,11 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st if (table->num_rows() == 0) { return arrow::Status::OK(); } - auto& [b, k] = bindingsKeysUnsorted[pos]; + auto& [b, k, e] = bindingsKeysUnsorted[pos]; + if (!e) { + LOG(debug) << "Update of disabled cache requested"; + return arrow::Status::OK(); + } auto column = table->GetColumnByName(k); auto row = 0; for (auto iChunk = 0; iChunk < column->num_chunks(); ++iChunk) { @@ -139,7 +144,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st if (std::find(valuesUnsorted[pos].begin(), valuesUnsorted[pos].end(), v) == valuesUnsorted[pos].end()) { valuesUnsorted[pos].push_back(v); } - if (groups[pos].size() <= v) { + if ((int)groups[pos].size() <= v) { groups[pos].resize(v + 1); } (groups[pos])[v].push_back(row); @@ -151,7 +156,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st return arrow::Status::OK(); } -std::pair ArrowTableSlicingCache::getCachePos(const StringPair& bindingKey) const +std::pair ArrowTableSlicingCache::getCachePos(const Entry& bindingKey) const { auto pos = getCachePosSortedFor(bindingKey); if (pos != -1) { @@ -161,41 +166,41 @@ std::pair ArrowTableSlicingCache::getCachePos(const StringPair& bindi if (pos != -1) { return {pos, false}; } - throw runtime_error_f("%s/%s not found neither in sorted or unsorted cache", bindingKey.first.c_str(), bindingKey.second.c_str()); + throw runtime_error_f("%s/%s not found neither in sorted or unsorted cache", bindingKey.binding.c_str(), bindingKey.key.c_str()); } -int ArrowTableSlicingCache::getCachePosSortedFor(StringPair const& bindingKey) const +int ArrowTableSlicingCache::getCachePosSortedFor(Entry const& bindingKey) const { - auto locate = std::find_if(bindingsKeys.begin(), bindingsKeys.end(), [&](StringPair const& bk) { return (bindingKey.first == bk.first) && (bindingKey.second == bk.second); }); + auto locate = std::find_if(bindingsKeys.begin(), bindingsKeys.end(), [&](Entry const& bk) { return (bindingKey.binding == bk.binding) && (bindingKey.key == bk.key); }); if (locate != bindingsKeys.end()) { return std::distance(bindingsKeys.begin(), locate); } return -1; } -int ArrowTableSlicingCache::getCachePosUnsortedFor(StringPair const& bindingKey) const +int ArrowTableSlicingCache::getCachePosUnsortedFor(Entry const& bindingKey) const { - auto locate_unsorted = std::find_if(bindingsKeysUnsorted.begin(), bindingsKeysUnsorted.end(), [&](StringPair const& bk) { return (bindingKey.first == bk.first) && (bindingKey.second == bk.second); }); + auto locate_unsorted = std::find_if(bindingsKeysUnsorted.begin(), bindingsKeysUnsorted.end(), [&](Entry const& bk) { return (bindingKey.binding == bk.binding) && (bindingKey.key == bk.key); }); if (locate_unsorted != bindingsKeysUnsorted.end()) { return std::distance(bindingsKeysUnsorted.begin(), locate_unsorted); } return -1; } -SliceInfoPtr ArrowTableSlicingCache::getCacheFor(StringPair const& bindingKey) const +SliceInfoPtr ArrowTableSlicingCache::getCacheFor(Entry const& bindingKey) const { auto [p, s] = getCachePos(bindingKey); if (!s) { - throw runtime_error_f("%s/%s is found in unsorted cache", bindingKey.first.c_str(), bindingKey.second.c_str()); + throw runtime_error_f("%s/%s is found in unsorted cache", bindingKey.binding.c_str(), bindingKey.key.c_str()); } return getCacheForPos(p); } -SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedFor(const StringPair& bindingKey) const +SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedFor(const Entry& bindingKey) const { auto [p, s] = getCachePos(bindingKey); if (s) { - throw runtime_error_f("%s/%s is found in sorted cache", bindingKey.first.c_str(), bindingKey.second.c_str()); + throw runtime_error_f("%s/%s is found in sorted cache", bindingKey.binding.c_str(), bindingKey.key.c_str()); } return getCacheUnsortedForPos(p); @@ -224,9 +229,9 @@ SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedForPos(int pos) con }; } -void ArrowTableSlicingCache::validateOrder(StringPair const& bindingKey, const std::shared_ptr& input) +void ArrowTableSlicingCache::validateOrder(Entry const& bindingKey, const std::shared_ptr& input) { - auto const& [target, key] = bindingKey; + auto const& [target, key, enabled] = bindingKey; auto column = input->GetColumnByName(key); auto array0 = static_cast>(column->chunk(0)->data()); int32_t prev = 0; diff --git a/Framework/Core/test/test_GroupSlicer.cxx b/Framework/Core/test/test_GroupSlicer.cxx index 161939141e790..091c21eeae229 100644 --- a/Framework/Core/test/test_GroupSlicer.cxx +++ b/Framework/Core/test/test_GroupSlicer.cxx @@ -683,7 +683,7 @@ TEST_CASE("ArrowDirectSlicing") std::vector slices; std::vector offsts; - auto bk = std::make_pair(soa::getLabelFromType(), "fID"); + auto bk = Entry(soa::getLabelFromType(), "fID"); ArrowTableSlicingCache cache({bk}); auto s = cache.updateCacheEntry(0, {evtTable}); auto lcache = cache.getCacheFor(bk); @@ -741,7 +741,7 @@ TEST_CASE("TestSlicingException") } auto evtTable = builderE.finalize(); - auto bk = std::make_pair(soa::getLabelFromType(), "fID"); + auto bk = Entry(soa::getLabelFromType(), "fID"); ArrowTableSlicingCache cache({bk}); try { From 8680b93a8cd72fcdf7366b5edbd9b859567fa3fa Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 13 Mar 2025 09:57:25 +0000 Subject: [PATCH 2/3] Please consider the following formatting changes --- Framework/Core/src/ArrowSupport.cxx | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx index 203b1170b7cdf..3b13e30581f70 100644 --- a/Framework/Core/src/ArrowSupport.cxx +++ b/Framework/Core/src/ArrowSupport.cxx @@ -566,11 +566,10 @@ o2::framework::ServiceSpec ArrowSupport::arrowTableSlicingCacheSpec() return ServiceSpec{ .name = "arrow-slicing-cache", .uniqueId = CommonServices::simpleServiceId(), - .init = [](ServiceRegistryRef services, DeviceState&, fair::mq::ProgOptions&) { - return ServiceHandle{TypeIdHelpers::uniqueId(), - new ArrowTableSlicingCache(Cache{services.get().bindingsKeys}, - Cache{services.get().bindingsKeysUnsorted}), - ServiceKind::Stream, typeid(ArrowTableSlicingCache).name()}; }, + .init = [](ServiceRegistryRef services, DeviceState&, fair::mq::ProgOptions&) { return ServiceHandle{TypeIdHelpers::uniqueId(), + new ArrowTableSlicingCache(Cache{services.get().bindingsKeys}, + Cache{services.get().bindingsKeysUnsorted}), + ServiceKind::Stream, typeid(ArrowTableSlicingCache).name()}; }, .configure = CommonServices::noConfiguration(), .preProcessing = [](ProcessingContext& pc, void* service_ptr) { auto* service = static_cast(service_ptr); From a80940a50ec518eea7ab250b1414622abe08dd79 Mon Sep 17 00:00:00 2001 From: Anton Alkin Date: Thu, 13 Mar 2025 14:59:40 +0100 Subject: [PATCH 3/3] Update ASoA.h --- Framework/Core/include/Framework/ASoA.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h index b586edb707beb..1ffc58791be00 100644 --- a/Framework/Core/include/Framework/ASoA.h +++ b/Framework/Core/include/Framework/ASoA.h @@ -1505,7 +1505,7 @@ auto doSliceBy(T const* table, o2::framework::PresliceBase const { if constexpr (OPT) { if (container.isMissing()) { - missingOptionalPreslice(getLabelFromType>().data(), container.bindingKey.second.c_str()); + missingOptionalPreslice(getLabelFromType>().data(), container.bindingKey.key.c_str()); } } uint64_t offset = 0; @@ -1542,7 +1542,7 @@ auto doSliceBy(T const* table, o2::framework::PresliceBase const { if constexpr (OPT) { if (container.isMissing()) { - missingOptionalPreslice(getLabelFromType>().data(), container.bindingKey.second.c_str()); + missingOptionalPreslice(getLabelFromType>().data(), container.bindingKey.key.c_str()); } } auto selection = container.getSliceFor(value); @@ -1571,7 +1571,7 @@ auto doFilteredSliceBy(T const* table, o2::framework::PresliceBase().data(), container.bindingKey.second.c_str()); + missingOptionalPreslice(getLabelFromType().data(), container.bindingKey.key.c_str()); } } uint64_t offset = 0;