From c92a13d394e9e83b44c897a3dd455b2036e63f04 Mon Sep 17 00:00:00 2001 From: Anton Alkin Date: Thu, 8 May 2025 18:15:35 +0200 Subject: [PATCH] =?UTF-8?q?Revert=20"DPL=20Analysis:=20prevent=20slice=20c?= =?UTF-8?q?ache=20from=20updating=20when=20not=20required=20by=20=E2=80=A6?= =?UTF-8?q?"?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 15b4f5f19e1eef23d79bdb3225e36348a845722d. --- Framework/Core/include/Framework/ASoA.h | 12 ++--- .../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 | 19 ++++--- Framework/Core/src/ArrowTableSlicingCache.cxx | 49 +++++++++---------- Framework/Core/test/test_GroupSlicer.cxx | 4 +- 9 files changed, 73 insertions(+), 96 deletions(-) diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h index 2e478a8ca64a6..e098cd89f6d5d 100644 --- a/Framework/Core/include/Framework/ASoA.h +++ b/Framework/Core/include/Framework/ASoA.h @@ -1400,10 +1400,10 @@ namespace o2::framework struct PreslicePolicyBase { const std::string binding; - Entry bindingKey; + StringPair bindingKey; bool isMissing() const; - Entry const& getBindingKey() const; + StringPair const& getBindingKey() const; }; struct PreslicePolicySorted : public PreslicePolicyBase { @@ -1428,7 +1428,7 @@ struct PresliceBase : public Policy { const std::string binding; PresliceBase(expressions::BindingNode index_) - : Policy{PreslicePolicyBase{{o2::soa::getLabelFromTypeForKey(std::string{index_.name})}, Entry(o2::soa::getLabelFromTypeForKey(std::string{index_.name}), std::string{index_.name})}, {}} + : Policy{PreslicePolicyBase{{o2::soa::getLabelFromTypeForKey(std::string{index_.name})}, std::make_pair(o2::soa::getLabelFromTypeForKey(std::string{index_.name}), std::string{index_.name})}, {}} { } @@ -1508,7 +1508,7 @@ auto doSliceBy(T const* table, o2::framework::PresliceBase const { if constexpr (OPT) { if (container.isMissing()) { - missingOptionalPreslice(getLabelFromType>().data(), container.bindingKey.key.c_str()); + missingOptionalPreslice(getLabelFromType>().data(), container.bindingKey.second.c_str()); } } uint64_t offset = 0; @@ -1545,7 +1545,7 @@ auto doSliceBy(T const* table, o2::framework::PresliceBase const { if constexpr (OPT) { if (container.isMissing()) { - missingOptionalPreslice(getLabelFromType>().data(), container.bindingKey.key.c_str()); + missingOptionalPreslice(getLabelFromType>().data(), container.bindingKey.second.c_str()); } } auto selection = container.getSliceFor(value); @@ -1574,7 +1574,7 @@ auto doFilteredSliceBy(T const* table, o2::framework::PresliceBase().data(), container.bindingKey.key.c_str()); + missingOptionalPreslice(getLabelFromType().data(), container.bindingKey.second.c_str()); } } uint64_t offset = 0; diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h index e310f3eef990c..330eaf01f0be4 100644 --- a/Framework/Core/include/Framework/AnalysisManagers.h +++ b/Framework/Core/include/Framework/AnalysisManagers.h @@ -534,43 +534,39 @@ static void setGroupedCombination(C& comb, TG& grouping, std::tuple& asso /// Preslice handling template requires(!is_preslice) -bool registerCache(T&, Cache&, Cache&) +bool registerCache(T&, std::vector&, std::vector&) { return false; } template requires std::same_as -bool registerCache(T& preslice, Cache& bsks, Cache&) +bool registerCache(T& preslice, std::vector& bsks, std::vector&) { if constexpr (T::optional) { if (preslice.binding == "[MISSING]") { return true; } } - auto locate = std::find_if(bsks.begin(), bsks.end(), [&](auto const& entry) { return (entry.binding == preslice.bindingKey.binding) && (entry.key == preslice.bindingKey.key); }); + auto locate = std::find_if(bsks.begin(), bsks.end(), [&](auto const& entry) { return (entry.first == preslice.bindingKey.first) && (entry.second == preslice.bindingKey.second); }); 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, Cache&, Cache& bsksU) +bool registerCache(T& preslice, std::vector&, std::vector& 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.binding == preslice.bindingKey.binding) && (entry.key == preslice.bindingKey.key); }); + auto locate = std::find_if(bsksU.begin(), bsksU.end(), [&](auto const& entry) { return (entry.first == preslice.bindingKey.first) && (entry.second == preslice.bindingKey.second); }); 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 9bd2e2af173cc..c7f3da1948c62 100644 --- a/Framework/Core/include/Framework/AnalysisTask.h +++ b/Framework/Core/include/Framework/AnalysisTask.h @@ -66,20 +66,20 @@ concept is_enumeration = is_enumeration_v>; namespace { struct AnalysisDataProcessorBuilder { template - static void addGroupingCandidates(Cache& bk, Cache& bku, bool enabled) + static void addGroupingCandidates(std::vector& bk, std::vector& bku) { - [&bk, &bku, enabled](framework::pack) mutable { + [&bk, &bku](framework::pack) mutable { std::string key; if constexpr (soa::is_iterator>) { key = std::string{"fIndex"} + o2::framework::cutString(soa::getLabelFromType>()); } - ([&bk, &bku, &key, enabled]() mutable { + ([&bk, &bku, &key]() mutable { if constexpr (soa::relatedByIndex, std::decay_t>()) { auto binding = soa::getLabelFromTypeForKey>(key); if constexpr (o2::soa::is_smallgroups>) { - framework::updatePairList(bku, binding, key, enabled); + framework::updatePairList(bku, binding, key); } else { - framework::updatePairList(bk, binding, key, enabled); + framework::updatePairList(bk, binding, key); } } }(), @@ -147,7 +147,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&, Cache&, Cache&) + static void inputsFromArgs(R (C::*)(A), const char* /*name*/, bool /*value*/, std::vector& inputs, std::vector&, std::vector&, std::vector&) { std::vector inputMetadata; // FIXME: for the moment we do not support begin, end and step. @@ -156,17 +156,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, Cache& bk, Cache& bku) + static void inputsFromArgs(R (C::*)(A, Args...), const char* name, bool value, std::vector& inputs, std::vector& eInfos, std::vector& bk, std::vector& bku) requires(std::is_lvalue_reference_v && (std::is_lvalue_reference_v && ...)) { - addGroupingCandidates(bk, bku, value); + addGroupingCandidates(bk, bku); 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, Cache&, Cache&) + static void inputsFromArgs(R (C::*)(Args...), const char* name, bool value, std::vector& inputs, std::vector& eInfos, std::vector&, std::vector&) requires(std::is_lvalue_reference_v && ...) { constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId(); @@ -480,8 +480,8 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args) std::vector inputs; std::vector options; std::vector expressionInfos; - Cache bindingsKeys; - Cache bindingsKeysUnsorted; + std::vector bindingsKeys; + std::vector 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 292a67023fc5e..2edc23a63ce76 100644 --- a/Framework/Core/include/Framework/ArrowTableSlicingCache.h +++ b/Framework/Core/include/Framework/ArrowTableSlicingCache.h @@ -34,64 +34,51 @@ struct SliceInfoUnsortedPtr { gsl::span getSliceFor(int value) const; }; -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; +using StringPair = std::pair; -void updatePairList(Cache& list, std::string const& binding, std::string const& key, bool enabled); +void updatePairList(std::vector& list, std::string const& binding, std::string const& key); struct ArrowTableSlicingCacheDef { constexpr static ServiceKind service_kind = ServiceKind::Global; - Cache bindingsKeys; - Cache bindingsKeysUnsorted; + std::vector bindingsKeys; + std::vector bindingsKeysUnsorted; - void setCaches(Cache&& bsks); - void setCachesUnsorted(Cache&& bsks); + void setCaches(std::vector&& bsks); + void setCachesUnsorted(std::vector&& bsks); }; struct ArrowTableSlicingCache { constexpr static ServiceKind service_kind = ServiceKind::Stream; - Cache bindingsKeys; + std::vector bindingsKeys; std::vector>> values; std::vector>> counts; - Cache bindingsKeysUnsorted; + std::vector bindingsKeysUnsorted; std::vector> valuesUnsorted; std::vector groups; - ArrowTableSlicingCache(Cache&& bsks, Cache&& bsksUnsorted = {}); + ArrowTableSlicingCache(std::vector&& bsks, std::vector&& bsksUnsorted = {}); // set caching information externally - void setCaches(Cache&& bsks, Cache&& bsksUnsorted = {}); + void setCaches(std::vector&& bsks, std::vector&& 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(Entry const& bindingKey) const; - int getCachePosSortedFor(Entry const& bindingKey) const; - int getCachePosUnsortedFor(Entry const& bindingKey) const; + std::pair getCachePos(StringPair const& bindingKey) const; + int getCachePosSortedFor(StringPair const& bindingKey) const; + int getCachePosUnsortedFor(StringPair const& bindingKey) const; // get slice from cache for a given value - SliceInfoPtr getCacheFor(Entry const& bindingKey) const; - SliceInfoUnsortedPtr getCacheUnsortedFor(Entry const& bindingKey) const; + SliceInfoPtr getCacheFor(StringPair const& bindingKey) const; + SliceInfoUnsortedPtr getCacheUnsortedFor(StringPair const& bindingKey) const; SliceInfoPtr getCacheForPos(int pos) const; SliceInfoUnsortedPtr getCacheUnsortedForPos(int pos) const; - static void validateOrder(Entry const& bindingKey, std::shared_ptr const& input); + static void validateOrder(StringPair 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 b8436314b057e..64b1d863c59e6 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 = Entry(binding, mIndexColumnName); + auto bk = std::make_pair(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 5940bc0427225..810398747de88 100644 --- a/Framework/Core/src/ASoA.cxx +++ b/Framework/Core/src/ASoA.cxx @@ -197,7 +197,7 @@ bool PreslicePolicyBase::isMissing() const return binding == "[MISSING]"; } -Entry const& PreslicePolicyBase::getBindingKey() const +StringPair const& PreslicePolicyBase::getBindingKey() const { return bindingKey; } diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx index 3b13e30581f70..12a4c7131e828 100644 --- a/Framework/Core/src/ArrowSupport.cxx +++ b/Framework/Core/src/ArrowSupport.cxx @@ -567,27 +567,26 @@ o2::framework::ServiceSpec ArrowSupport::arrowTableSlicingCacheSpec() .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}), + new ArrowTableSlicingCache(std::vector>{services.get().bindingsKeys}, std::vector{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 = 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()); + 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()); if (!status.ok()) { - throw runtime_error_f("Failed to update slice cache for %s/%s", caches[i].binding.c_str(), caches[i].key.c_str()); + throw runtime_error_f("Failed to update slice cache for %s/%s", caches[i].first.c_str(), caches[i].second.c_str()); } } } auto& unsortedCaches = service->bindingsKeysUnsorted; - 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()); + 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()); if (!status.ok()) { - throw runtime_error_f("failed to update slice cache (unsorted) for %s/%s", unsortedCaches[i].binding.c_str(), unsortedCaches[i].key.c_str()); + throw runtime_error_f("failed to update slice cache (unsorted) for %s/%s", unsortedCaches[i].first.c_str(), unsortedCaches[i].second.c_str()); } } } }, diff --git a/Framework/Core/src/ArrowTableSlicingCache.cxx b/Framework/Core/src/ArrowTableSlicingCache.cxx index 12df5ef6c080b..4b31f96e32fba 100644 --- a/Framework/Core/src/ArrowTableSlicingCache.cxx +++ b/Framework/Core/src/ArrowTableSlicingCache.cxx @@ -11,7 +11,6 @@ #include "Framework/ArrowTableSlicingCache.h" #include "Framework/RuntimeError.h" -#include "Framework/Logger.h" #include #include @@ -20,10 +19,10 @@ namespace o2::framework { -void updatePairList(Cache& list, std::string const& binding, std::string const& key, bool enabled = true) +void updatePairList(std::vector& list, std::string const& binding, std::string const& 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); + 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); } } @@ -66,17 +65,17 @@ gsl::span SliceInfoUnsortedPtr::getSliceFor(int value) const return {(*groups)[value].data(), (*groups)[value].size()}; } -void ArrowTableSlicingCacheDef::setCaches(Cache&& bsks) +void ArrowTableSlicingCacheDef::setCaches(std::vector&& bsks) { bindingsKeys = bsks; } -void ArrowTableSlicingCacheDef::setCachesUnsorted(Cache&& bsks) +void ArrowTableSlicingCacheDef::setCachesUnsorted(std::vector&& bsks) { bindingsKeysUnsorted = bsks; } -ArrowTableSlicingCache::ArrowTableSlicingCache(Cache&& bsks, Cache&& bsksUnsorted) +ArrowTableSlicingCache::ArrowTableSlicingCache(std::vector&& bsks, std::vector&& bsksUnsorted) : bindingsKeys{bsks}, bindingsKeysUnsorted{bsksUnsorted} { @@ -87,7 +86,7 @@ ArrowTableSlicingCache::ArrowTableSlicingCache(Cache&& bsks, Cache&& bsksUnsorte groups.resize(bindingsKeysUnsorted.size()); } -void ArrowTableSlicingCache::setCaches(Cache&& bsks, Cache&& bsksUnsorted) +void ArrowTableSlicingCache::setCaches(std::vector&& bsks, std::vector&& bsksUnsorted) { bindingsKeys = bsks; bindingsKeysUnsorted = bsksUnsorted; @@ -112,7 +111,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].key)}, + arrow::compute::CallFunction("value_counts", {table->GetColumnByName(bindingsKeys[pos].second)}, &options)); auto pair = static_cast(value_counts.array()); values[pos].reset(); @@ -129,11 +128,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st if (table->num_rows() == 0) { return arrow::Status::OK(); } - auto& [b, k, e] = bindingsKeysUnsorted[pos]; - if (!e) { - LOG(debug) << "Update of disabled cache requested"; - return arrow::Status::OK(); - } + auto& [b, k] = bindingsKeysUnsorted[pos]; auto column = table->GetColumnByName(k); auto row = 0; for (auto iChunk = 0; iChunk < column->num_chunks(); ++iChunk) { @@ -144,7 +139,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 ((int)groups[pos].size() <= v) { + if (groups[pos].size() <= v) { groups[pos].resize(v + 1); } (groups[pos])[v].push_back(row); @@ -156,7 +151,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st return arrow::Status::OK(); } -std::pair ArrowTableSlicingCache::getCachePos(const Entry& bindingKey) const +std::pair ArrowTableSlicingCache::getCachePos(const StringPair& bindingKey) const { auto pos = getCachePosSortedFor(bindingKey); if (pos != -1) { @@ -166,41 +161,41 @@ std::pair ArrowTableSlicingCache::getCachePos(const Entry& bindingKey if (pos != -1) { return {pos, false}; } - throw runtime_error_f("%s/%s not found neither in sorted or unsorted cache", bindingKey.binding.c_str(), bindingKey.key.c_str()); + throw runtime_error_f("%s/%s not found neither in sorted or unsorted cache", bindingKey.first.c_str(), bindingKey.second.c_str()); } -int ArrowTableSlicingCache::getCachePosSortedFor(Entry const& bindingKey) const +int ArrowTableSlicingCache::getCachePosSortedFor(StringPair const& bindingKey) const { - auto locate = std::find_if(bindingsKeys.begin(), bindingsKeys.end(), [&](Entry const& bk) { return (bindingKey.binding == bk.binding) && (bindingKey.key == bk.key); }); + auto locate = std::find_if(bindingsKeys.begin(), bindingsKeys.end(), [&](StringPair const& bk) { return (bindingKey.first == bk.first) && (bindingKey.second == bk.second); }); if (locate != bindingsKeys.end()) { return std::distance(bindingsKeys.begin(), locate); } return -1; } -int ArrowTableSlicingCache::getCachePosUnsortedFor(Entry const& bindingKey) const +int ArrowTableSlicingCache::getCachePosUnsortedFor(StringPair const& bindingKey) const { - auto locate_unsorted = std::find_if(bindingsKeysUnsorted.begin(), bindingsKeysUnsorted.end(), [&](Entry const& bk) { return (bindingKey.binding == bk.binding) && (bindingKey.key == bk.key); }); + auto locate_unsorted = std::find_if(bindingsKeysUnsorted.begin(), bindingsKeysUnsorted.end(), [&](StringPair const& bk) { return (bindingKey.first == bk.first) && (bindingKey.second == bk.second); }); if (locate_unsorted != bindingsKeysUnsorted.end()) { return std::distance(bindingsKeysUnsorted.begin(), locate_unsorted); } return -1; } -SliceInfoPtr ArrowTableSlicingCache::getCacheFor(Entry const& bindingKey) const +SliceInfoPtr ArrowTableSlicingCache::getCacheFor(StringPair const& bindingKey) const { auto [p, s] = getCachePos(bindingKey); if (!s) { - throw runtime_error_f("%s/%s is found in unsorted cache", bindingKey.binding.c_str(), bindingKey.key.c_str()); + throw runtime_error_f("%s/%s is found in unsorted cache", bindingKey.first.c_str(), bindingKey.second.c_str()); } return getCacheForPos(p); } -SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedFor(const Entry& bindingKey) const +SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedFor(const StringPair& bindingKey) const { auto [p, s] = getCachePos(bindingKey); if (s) { - throw runtime_error_f("%s/%s is found in sorted cache", bindingKey.binding.c_str(), bindingKey.key.c_str()); + throw runtime_error_f("%s/%s is found in sorted cache", bindingKey.first.c_str(), bindingKey.second.c_str()); } return getCacheUnsortedForPos(p); @@ -229,9 +224,9 @@ SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedForPos(int pos) con }; } -void ArrowTableSlicingCache::validateOrder(Entry const& bindingKey, const std::shared_ptr& input) +void ArrowTableSlicingCache::validateOrder(StringPair const& bindingKey, const std::shared_ptr& input) { - auto const& [target, key, enabled] = bindingKey; + auto const& [target, key] = 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 091c21eeae229..161939141e790 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 = Entry(soa::getLabelFromType(), "fID"); + auto bk = std::make_pair(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 = Entry(soa::getLabelFromType(), "fID"); + auto bk = std::make_pair(soa::getLabelFromType(), "fID"); ArrowTableSlicingCache cache({bk}); try {