================
@@ -3110,6 +3132,91 @@ calculateBoundsOffset(LLVM::ModuleTranslation
&moduleTranslation,
return idx;
}
+// Gathers members that are overlapping in the parent, excluding members that
+// themselves overlap, keeping the top-most (closest to parents level) map.
+static void getOverlappedMembers(llvm::SmallVector<size_t> &overlapMapDataIdxs,
+ MapInfoData &mapData,
+ omp::MapInfoOp parentOp) {
+ // No members mapped, no overlaps.
+ if (parentOp.getMembers().empty())
+ return;
+
+ // Single member, we can insert and return early.
+ if (parentOp.getMembers().size() == 1) {
+ overlapMapDataIdxs.push_back(0);
+ return;
+ }
+
+ // 1) collect list of top-level overlapping members from MemberOp
+ llvm::SmallVector<std::pair<int, mlir::ArrayAttr>> memberByIndex;
+ mlir::ArrayAttr indexAttr = parentOp.getMembersIndexAttr();
+ for (auto [memIndex, indicesAttr] : llvm::enumerate(indexAttr))
+ memberByIndex.push_back(
+ std::make_pair(memIndex, mlir::cast<mlir::ArrayAttr>(indicesAttr)));
+
+ // Sort the smallest first (higher up the parent -> member chain), so that
+ // when we remove members, we remove as much as we can in the initial
+ // iterations, shortening the number of passes required.
+ llvm::sort(memberByIndex.begin(), memberByIndex.end(),
+ [&](auto a, auto b) { return a.second.size() < b.second.size();
});
+
+ auto getAsIntegers = [](mlir::ArrayAttr values) {
+ llvm::SmallVector<int64_t> ints;
+ ints.reserve(values.size());
+ llvm::transform(values, std::back_inserter(ints),
+ [](mlir::Attribute value) {
+ return mlir::cast<mlir::IntegerAttr>(value).getInt();
+ });
+ return ints;
+ };
+
+ // Remove elements from the vector if there is a parent element that
+ // supersedes it. i.e. if member [0] is mapped, we can remove members [0,1],
+ // [0,2].. etc.
+ for (auto v : make_early_inc_range(memberByIndex)) {
+ auto vArr = getAsIntegers(v.second);
+ memberByIndex.erase(
----------------
skatrak wrote:
Do we know for sure this always works? Reading the documentation for
`make_early_inc_range`, my understanding is that we're allowed to mutate the
underlying range as long as we don't invalidate the next iterator. But, if we
try to delete elements which could be anywhere in the range, it seems possible
that we would end up doing just that.
Maybe it would be safer to just create an integer set of to-be-skipped elements
and only add to `overlapMapDataIdxs` elements in `memberByIndex` which are not
part of that set.
https://github.com/llvm/llvm-project/pull/119588
_______________________________________________
llvm-branch-commits mailing list
llvm-branch-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
