From 113573ec588e4432505cdec6218c4f7dc37a468f Mon Sep 17 00:00:00 2001 From: Anton Alkin Date: Tue, 17 Mar 2026 09:57:54 +0100 Subject: [PATCH 1/2] DPL Analysis: force index to only bind with tables of the same origin --- Framework/Core/include/Framework/ASoA.h | 87 ++++++++++++++++++++----- 1 file changed, 69 insertions(+), 18 deletions(-) diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h index 475823b150d90..94689bfbe5eb7 100644 --- a/Framework/Core/include/Framework/ASoA.h +++ b/Framework/Core/include/Framework/ASoA.h @@ -1176,12 +1176,6 @@ struct TableIterator : IP, C... { return *this; } - template - void doSetCurrentIndex(framework::pack, TA* current) - { - (CL::setCurrent(current), ...); - } - template auto getCurrent() const { @@ -1202,7 +1196,17 @@ struct TableIterator : IP, C... { template void bindExternalIndices(TA*... current) { - (doSetCurrentIndex(external_index_columns_t{}, current), ...); + ([this](TA* cur, framework::pack){ + (CCs::setCurrent(cur),...); + }(current, external_index_columns_t{}), ...); + } + + template + void bindExternalIndex(TA* current) + { + [this](TA* cur, framework::pack){ + (CCs::setCurrent(cur),...); + }(current, external_index_columns_t{}); } template @@ -1812,6 +1816,12 @@ consteval auto computeOriginals() return o2::soa::mergeOriginals(); } +template refs> +consteval auto commonOrigin() +{ + return (refs | std::ranges::views::filter([](TableRef const& r){ return (!( r.origin_hash == "DYN"_h || r.origin_hash == "IDX"_h)); })).front().origin_hash; +} + /// A Table class which observes an arrow::Table and provides /// It is templated on a set of Column / DynamicColumn types. template @@ -1823,7 +1833,10 @@ class Table using table_t = self_t; static constexpr const auto originals = computeOriginals(); - static constexpr const auto originalLabels = [] refs, size_t... Is>(std::index_sequence) { return std::array{o2::aod::label()...}; }.template operator()(std::make_index_sequence()); + static constexpr const auto originalLabels = [] refs, size_t... Is>(std::index_sequence) { + return std::array{o2::aod::label()...}; + }.template operator()(std::make_index_sequence()); + static constexpr const uint32_t binding_origin = commonOrigin(); template bindings> requires(ref.origin_hash == "CONC"_h) @@ -1836,9 +1849,9 @@ class Table requires(ref.origin_hash == "JOIN"_h) static consteval auto isIndexTargetOf() { - return std::find_if(self_t::originals.begin(), self_t::originals.end(), + return std::ranges::find_if(self_t::originals, [](TableRef const& r) { - return std::find(bindings.begin(), bindings.end(), r) != bindings.end(); + return std::ranges::find(bindings, r) != bindings.end(); }) != self_t::originals.end(); } @@ -2179,9 +2192,20 @@ class Table template void bindExternalIndices(TA*... current) { - mBegin.bindExternalIndices(current...); + ([this](TA* cur){ + if constexpr (binding_origin == TA::binding_origin) { + mBegin.bindExternalIndex(cur); + } + }(current),...); } + template + void bindExternalIndex(TA* current) + { + mBegin.bindExternalIndex(current); //unchecked binding for the derived tables + } + + template void bindInternalIndicesTo(I const* ptr) { @@ -3395,6 +3419,17 @@ struct JoinFull : Table, D, o2::aod::Hash<"JOIN"_h>, Ts. } using base::bindExternalIndices; using base::bindInternalIndicesTo; + static constexpr const uint32_t binding_origin = base::binding_origin; + + template + void bindExternalIndices(TA*... current) + { + ([this](TA* cur){ + if constexpr (binding_origin == TA::binding_origin) { + this->bindExternalIndex(cur); + } + }(current),...); + } using self_t = JoinFull; using table_t = base; @@ -3524,6 +3559,17 @@ class FilteredBase : public T using self_t = FilteredBase; using table_t = typename T::table_t; using T::originals; + static constexpr const uint32_t binding_origin = T::binding_origin; + template + void bindExternalIndices(TA*... current) + { + ([this](TA* cur){ + if constexpr (binding_origin == TA::binding_origin) { + this->bindExternalIndex(cur); + mFilteredBegin.bindExternalIndex(cur); + } + }(current),...); + } using columns_t = typename T::columns_t; using persistent_columns_t = typename T::persistent_columns_t; using external_index_columns_t = typename T::external_index_columns_t; @@ -3645,13 +3691,6 @@ class FilteredBase : public T /// Bind the columns which refer to other tables /// to the associated tables. - template - void bindExternalIndices(TA*... current) - { - table_t::bindExternalIndices(current...); - mFilteredBegin.bindExternalIndices(current...); - } - void bindExternalIndicesRaw(std::vector&& ptrs) { mFilteredBegin.bindExternalIndicesRaw(std::forward>(ptrs)); @@ -4134,6 +4173,18 @@ struct IndexTable : Table { using first_t = typename H::binding_t; using rest_t = framework::pack; + static constexpr const uint32_t binding_origin = Key::binding_origin; + + template + void bindExternalIndices(TA*... current) + { + ([this](TA* cur){ + if constexpr (binding_origin == TA::binding_origin) { + this->bindExternalIndex(cur); + } + }(current),...); + } + IndexTable(std::shared_ptr table, uint64_t offset = 0) : base_t{table, offset} { From b4934a47e807b15cfaff2e5ce185ae53a734350c Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Tue, 17 Mar 2026 12:56:44 +0000 Subject: [PATCH 2/2] Please consider the following formatting changes --- Framework/Core/include/Framework/ASoA.h | 42 ++++++++++++++----------- 1 file changed, 23 insertions(+), 19 deletions(-) diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h index 94689bfbe5eb7..7a3307ae1a58c 100644 --- a/Framework/Core/include/Framework/ASoA.h +++ b/Framework/Core/include/Framework/ASoA.h @@ -1196,16 +1196,17 @@ struct TableIterator : IP, C... { template void bindExternalIndices(TA*... current) { - ([this](TA* cur, framework::pack){ - (CCs::setCurrent(cur),...); - }(current, external_index_columns_t{}), ...); + ([this](TA* cur, framework::pack) { + (CCs::setCurrent(cur), ...); + }(current, external_index_columns_t{}), + ...); } template void bindExternalIndex(TA* current) { - [this](TA* cur, framework::pack){ - (CCs::setCurrent(cur),...); + [this](TA* cur, framework::pack) { + (CCs::setCurrent(cur), ...); }(current, external_index_columns_t{}); } @@ -1819,7 +1820,7 @@ consteval auto computeOriginals() template refs> consteval auto commonOrigin() { - return (refs | std::ranges::views::filter([](TableRef const& r){ return (!( r.origin_hash == "DYN"_h || r.origin_hash == "IDX"_h)); })).front().origin_hash; + return (refs | std::ranges::views::filter([](TableRef const& r) { return (!(r.origin_hash == "DYN"_h || r.origin_hash == "IDX"_h)); })).front().origin_hash; } /// A Table class which observes an arrow::Table and provides @@ -1850,9 +1851,9 @@ class Table static consteval auto isIndexTargetOf() { return std::ranges::find_if(self_t::originals, - [](TableRef const& r) { - return std::ranges::find(bindings, r) != bindings.end(); - }) != self_t::originals.end(); + [](TableRef const& r) { + return std::ranges::find(bindings, r) != bindings.end(); + }) != self_t::originals.end(); } template bindings> @@ -2192,20 +2193,20 @@ class Table template void bindExternalIndices(TA*... current) { - ([this](TA* cur){ + ([this](TA* cur) { if constexpr (binding_origin == TA::binding_origin) { mBegin.bindExternalIndex(cur); } - }(current),...); + }(current), + ...); } template void bindExternalIndex(TA* current) { - mBegin.bindExternalIndex(current); //unchecked binding for the derived tables + mBegin.bindExternalIndex(current); // unchecked binding for the derived tables } - template void bindInternalIndicesTo(I const* ptr) { @@ -3424,11 +3425,12 @@ struct JoinFull : Table, D, o2::aod::Hash<"JOIN"_h>, Ts. template void bindExternalIndices(TA*... current) { - ([this](TA* cur){ + ([this](TA* cur) { if constexpr (binding_origin == TA::binding_origin) { this->bindExternalIndex(cur); } - }(current),...); + }(current), + ...); } using self_t = JoinFull; @@ -3563,12 +3565,13 @@ class FilteredBase : public T template void bindExternalIndices(TA*... current) { - ([this](TA* cur){ + ([this](TA* cur) { if constexpr (binding_origin == TA::binding_origin) { this->bindExternalIndex(cur); mFilteredBegin.bindExternalIndex(cur); } - }(current),...); + }(current), + ...); } using columns_t = typename T::columns_t; using persistent_columns_t = typename T::persistent_columns_t; @@ -4178,11 +4181,12 @@ struct IndexTable : Table { template void bindExternalIndices(TA*... current) { - ([this](TA* cur){ + ([this](TA* cur) { if constexpr (binding_origin == TA::binding_origin) { this->bindExternalIndex(cur); } - }(current),...); + }(current), + ...); } IndexTable(std::shared_ptr table, uint64_t offset = 0)