[Outlining] Remove overlapping sequences #7146

ashleynh · 2024-12-12T07:12:18Z

While determining whether repeat sequences of instructions are candidates for outlining, remove sequences that overlap, giving weight to sequences that are longer and appear more frequently.

tlively · 2025-01-18T01:30:54Z

src/support/intervals.h

+  bool operator<(const Interval& other) const {
+    return start < other.start && weight < other.weight;
+  }


This should take end into account as well. Otherwise the std::set<Interval> returned by IntervalProcessor::getOverlaps() will not be able to hold two intervals that differ only in their ends.

tlively · 2025-01-18T01:32:59Z

src/support/intervals.cpp

+
+std::set<Interval>
+IntervalProcessor::getOverlaps(std::vector<Interval>& intervals) {
+  std::sort(intervals.begin(), intervals.end(), [](Interval a, Interval b) {


Suggested change

std::sort(intervals.begin(), intervals.end(), [](Interval a, Interval b) {

std::sort(intervals.begin(), intervals.end(), [](const Interval& a, const Interval& b) {

Just to avoid copying intervals around unnecessarily.

tlively · 2025-01-18T01:33:46Z

src/support/intervals.cpp

+  });
+
+  std::set<Interval> overlaps;
+  auto& firstInterval = intervals[0];


There should be an early return if the input vector is empty to avoid UB here.

tlively · 2025-01-18T01:36:27Z

src/passes/hash-stringify-walker.cpp

+    for (auto startIdx : substring.StartIndices) {
+      auto interval =
+        Interval(startIdx,
+                 startIdx + substring.Length - 1,


I'm surprised we're using intervals inclusive of their ends. Would this work without the - 1 as well?

tlively · 2025-01-18T01:36:53Z

src/passes/hash-stringify-walker.cpp

+      auto interval =
+        Interval(startIdx,
+                 startIdx + substring.Length - 1,
+                 substring.Length * substring.StartIndices.size());


Probably worth a comment about why we are using this weight.

tlively · 2025-01-18T01:40:35Z

src/passes/hash-stringify-walker.cpp

+  std::set<Interval> overlaps = IntervalProcessor::getOverlaps(intervals);
+  std::set<unsigned> doNotInclude;
+  for (auto& interval : overlaps) {
+    doNotInclude.insert(intervalMap[interval]);
+  }


We could simplify the code here and get away without any map or set lookups if IntervalProcessor returned a sequence of kept indices in its input vector rather than a set of removed intervals. With a sequence of kept indices, we could directly construct the list of kept substrings.

great idea, thanks!

tlively · 2025-01-18T01:42:23Z

test/lit/passes/outlining.wast

@@ -1006,3 +1006,57 @@
    (loop (nop))
  )
 )
+
+;; Test that no attempt is made to outline overlapping repeat substrings


It would be good to add comments about what the overlapping substrings are.

tlively · 2025-01-18T01:44:04Z

test/lit/passes/outlining.wast

+    (drop (i32.add
+      (i32.const 0)
+      (i32.const 1)
+    ))


We could make the test more concise and easy to read by just using constants and drops, unless I'm missing some reason why this wouldn't work.

(drop (i32.const 0)) (drop (i32.const 1)) (drop (i32.const 2)) (drop (i32.const 3)) (drop (i32.const 0)) (drop (i32.const 1)) (drop (i32.const 2)) (drop (i32.const 3)) (drop (i32.const 1)) (drop (i32.const 2)) (drop (i32.const 1)) (drop (i32.const 2))

good call, thanks

ashleynh · 2025-01-23T01:42:51Z

src/support/intervals.h

+};
+
+struct IntervalProcessor {
+  static std::set<Interval> getOverlaps(std::vector<Interval>&);


add gTests for edge cases

tlively

It would still be good to include gtest unit tests for the various kinds of overlaps.

tlively · 2025-01-30T19:27:13Z

src/passes/hash-stringify-walker.cpp

+  for (Index i = 0; i < substrings.size(); i++) {
+    auto substring = substrings[i];
+    for (auto startIdx : substring.StartIndices) {
+      // TODO: This weight was picked with an assumption


What assumption?

tlively · 2025-01-30T19:27:33Z

src/passes/Outlining.cpp

@@ -280,6 +280,8 @@ struct Outlining : public Pass {
    DBG(printHashString(stringify.hashString, stringify.exprs));
    // Remove substrings that are substrings of longer repeat substrings.
    substrings = StringifyProcessor::dedupe(substrings);
+    // Remove substrings with overlapping indices


Suggested change

// Remove substrings with overlapping indices

// Remove substrings with overlapping indices.

tlively · 2025-01-30T19:28:27Z

src/passes/hash-stringify-walker.cpp

+  std::vector<Interval> intervals;
+  std::vector<int> substringIdxs;


It would be good to have a comment saying how these two vectors relate to each other.

tlively · 2025-01-30T19:36:27Z

src/passes/hash-stringify-walker.cpp

+    if (substringsIncluded.find(substringIdx) != substringsIncluded.end()) {
+      continue;
+    }
+    substringsIncluded.insert(substringIdx);


Suggested change

if (substringsIncluded.find(substringIdx) != substringsIncluded.end()) {

continue;

}

substringsIncluded.insert(substringIdx);

if (!substringsIncluded.insert(substringIdx)->second) {

continue;

}

tlively · 2025-01-30T19:37:24Z

src/support/intervals.h

+};
+
+struct IntervalProcessor {
+  // TODO: Given a vector of Interval, returns a vector of the indices, mapping


What's the TODO here?

it was for me to review the comment before submitting

ashleynh · 2025-01-30T21:20:07Z

test/lit/passes/outlining.wast

-  ;; CHECK-NEXT:   (i32.add
-  ;; CHECK-NEXT:    (i32.const 0)
-  ;; CHECK-NEXT:    (i32.const 1)
+  ;; CHECK-NEXT:   (i32.sub


This test changed because the order of the outlined functions to be created changed. This is theoretically possible now because we wait to add substrings to the result vector in hash-stringify-walker's removeOverlaps() until every interval for a repeat substring has been seen. For our purposes, It does not actually matter what order the substrings are in, because we create an OutliningSequence to represent each substring, and ensure that is sorted by idx, line 373 in Outlining.cpp.

tlively · 2025-01-30T21:09:17Z

src/passes/hash-stringify-walker.cpp

+    if (seenCount[substringIdx] == substring.StartIndices.size() &&
+        substringsIncluded.insert(substringIdx).second) {
+      result.push_back(substring);


So we're only considering a substring for outlining at all if all of its ocurrences survive overlap filtering? Could we keep the substring in consideration and just remove the particular occurrence of it that had the overlap instead?

tlively · 2025-01-30T21:11:43Z

src/support/intervals.cpp

@@ -36,26 +37,24 @@ IntervalProcessor::filterOverlaps(std::vector<Interval>& intervals) {

  std::sort(
    intIntervals.begin(), intIntervals.end(), [](const auto& a, const auto& b) {
-      return a.first.start < b.first.end;
+      return a.first.start < b.first.start;


No need for the lambda here if you fix operator< to be a total order (meaning that for any pair of intervals a and b, exactly one of a < b,b < a, or a == b is true)

tlively · 2025-01-30T21:19:04Z

src/support/intervals.cpp

    });

  std::vector<int> result;
-  auto& firstInterval = intIntervals[0];
+  auto& formerInterval = intIntervals[0];


Making this a reference means that when you do formerInterval = latterInterval below, it writes to the first element in intIntervals, which is a little odd. Intervals should be small enough that copying them is cheap, so let's just make this a non-reference. Alternatively, to avoid copying intervals, you could make this an index.

tlively · 2025-01-30T21:21:59Z

src/support/intervals.cpp

-      firstInterval = nextInterval;
-    } else {
-      result.push_back(firstInterval.second);
+    if (latterInterval.first.weight > formerInterval.first.weight) {


If the weights are equal, perhaps you can choose to keep the interval with the nearest end to reduce its potential to overlap with subsequent intervals.

tlively · 2025-01-30T21:22:50Z

src/support/intervals.h

-  // back to the original input vector, of non-overlapping indices, ie, the
-  // intervals that overlap have already been removed.
+  // Given a vector of Interval, returns a vector of the indices that, mapping
+  // back to the original input vector, do not overlap with each other, ie: the


Suggested change

// back to the original input vector, do not overlap with each other, ie: the

// back to the original input vector, do not overlap with each other, i.e. the

tlively · 2025-01-30T21:26:03Z

test/gtest/intervals.cpp

+  std::vector<Interval> intervals;
+  intervals.emplace_back(Interval{0, 4, 2});
+  intervals.emplace_back(Interval{4, 8, 2});
+  ASSERT_EQ(IntervalProcessor::filterOverlaps(intervals).size(), 2u);


It would be better to test the precise results rather than just the size of the results. You can still do it with a single ASSERT_EQ:

std::vector<int> expected{0, 1}; ASSERT_EQ(IntervalProcessor::filterOverlaps(intervals), expected);

tlively · 2025-01-30T21:26:52Z

test/gtest/intervals.cpp

+  ASSERT_EQ(IntervalProcessor::filterOverlaps(intervals).size(), 2u);
+}
+
+TEST(IntervalsTest, TestOverlapFound) {


It would be good to add tests for different kinds of overlaps, different input orders, different weights. There are a lot of interesting combinations!

ashleynh · 2025-01-30T21:28:27Z

src/support/intervals.h

+
+struct IntervalProcessor {
+  // Given a vector of Interval, returns a vector of the indices that, mapping
+  // back to the original input vector, do not overlap with each other, ie: the


adjust punctuation around ie to , i.e.,

ashleynh force-pushed the intervals branch from 4c6c9f9 to 564e54e Compare December 19, 2024 22:58

ashleynh force-pushed the intervals branch 3 times, most recently from 1a589b6 to 0d961b8 Compare January 17, 2025 21:03

ashleynh changed the title ~~[*WIP* - Outlining] Remove overlapping sequences~~ [Outlining] Remove overlapping sequences Jan 17, 2025

ashleynh requested a review from tlively January 18, 2025 00:05

ashleynh marked this pull request as ready for review January 18, 2025 00:05

tlively reviewed Jan 18, 2025

View reviewed changes

ashleynh commented Jan 23, 2025

View reviewed changes

ashleynh added 6 commits January 23, 2025 19:06

non-overlapping intervals

ab65ba2

offby1

4636a3f

commit

aff6cd7

first pass addressing comments

76d31b0

reworked removeOverlaps

6a5aa0f

lint

b05f948

ashleynh force-pushed the intervals branch from 0d961b8 to b05f948 Compare January 23, 2025 19:26

ashleynh added 2 commits January 23, 2025 19:48

next

15485fa

set better

c68c921

tlively reviewed Jan 30, 2025

View reviewed changes

updates

956dbd0

ashleynh commented Jan 30, 2025

View reviewed changes

tlively reviewed Jan 30, 2025

View reviewed changes

ashleynh commented Jan 30, 2025

View reviewed changes

changes

6408a25

	std::sort(intervals.begin(), intervals.end(), [](Interval a, Interval b) {
	std::sort(intervals.begin(), intervals.end(), [](const Interval& a, const Interval& b) {

	// Remove substrings with overlapping indices
	// Remove substrings with overlapping indices.

		std::vector<Interval> intervals;
		std::vector<int> substringIdxs;

	// back to the original input vector, do not overlap with each other, ie: the
	// back to the original input vector, do not overlap with each other, i.e. the

[Outlining] Remove overlapping sequences #7146

Are you sure you want to change the base?

[Outlining] Remove overlapping sequences #7146

Conversation

ashleynh commented Dec 12, 2024

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ashleynh Jan 23, 2025 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

tlively left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ashleynh Jan 23, 2025 •

edited

Loading