Clean up getContigMergeOfInnerSize by wujingyue · Pull Request #5936 · NVIDIA/Fuser

wujingyue · 2026-02-08T03:37:16Z

Makes the code less error prone, and removes the reliance on isValidDeviceSplit to support non-outermost sharding in the future.

Should be an NFC.

wujingyue · 2026-02-08T03:37:38Z

!test

github-actions · 2026-02-08T03:38:02Z

Review updated until commit 3cc2e10

Description

Clean up getContigMergeOfInnerSize function to remove reliance on isValidDeviceSplit
Refactor projection logic to support non-outermost sharding in the future
Move addProjectedExtent method from header to implementation file
Improve test code using structured bindings for cleaner syntax

Changes walkthrough

Relevant files

Enhancement

vectorize_helper.cpp `Clean up vectorization helper implementation` csrc/scheduler/vectorize_helper.cpp Added `addProjectedExtent` method implementation with error checking Refactored `getContigMergeOfInnerSize` to remove `isValidDeviceSplit` dependency Modified `projectId` method to include `leaf` parameter for allocation domain projection Simplified dimension mapping logic with better handling of reduction/broadcast dimensions Improved projection order to avoid duplicate extent registration	+132/-117
vectorize_helper.h `Update vectorization helper header interface` csrc/scheduler/vectorize_helper.h Moved `addProjectedExtent` method declaration from inline to cpp file Updated `projectId` method signature to include `leaf` parameter Added documentation for `projectId` method explaining root/logical and allocation domain projection	+10/-18

Tests

test_pointwise.cpp `Improve test code with structured bindings` tests/cpp/test_pointwise.cpp Used structured bindings (`auto [size, vec]`) instead of manual tuple unpacking Fixed minor formatting issue in DomainMapUnitTest constructor	+3/-7

PR Reviewer Guide

Here are some key observations to aid the review process:

🧪 No relevant tests

⚡ Recommended focus areas for review

Algorithm Correctness

The getContigMergeOfInnerSize function has been significantly refactored, removing device split logic and changing the core algorithm. The new implementation uses a different approach with allocation domain mapping and reverse iteration. While the PR claims this is NFC, the algorithm change from device-aware to device-agnostic vectorization analysis could potentially affect performance or correctness in multi-device scenarios. The logic for handling reductions, broadcasts, and parallelized dimensions has been consolidated into a single lambda, but the mapping between allocation and logical domains uses a different approach (ir_utils::getReachableIds vs DependencyCheck::getAllExprsBetween). This change should be validated with comprehensive testing.

Val* ContiguousInnerDimensionsMapper::getContigMergeOfInnerSize(
    TensorView* tv) {
  FusionGuard fg(tv->fusion());

  const std::vector<IterDomain*>& alloc = tv->getMaybeAllocationDomain();
  const std::vector<std::optional<bool>>& contiguity = tv->getContiguity();

  NVF_ERROR(hasMappedDims(tv));
  const std::vector<IterDomain*>& projected_dims = mappedLogicalIds(tv);

  Val* product_of_inner_extents = tv->container()->oneVal();
  // Order is important, need to make sure dimensions match up correctly with
  // what was propagated through the mapper. The mapper's dimensions are
  // propagated in the order of the reference. If that order doesn't match the
  // tensor we're mapping to then a transpose interfered with expanding the
  // vectorize dimension.
  auto projected_dim = projected_dims.rbegin();
  // Wish I could `zip(alloc, contiguity) | std::views::reverse` here. It
  // doesn't compile.
  NVF_ERROR_EQ(alloc.size(), contiguity.size());
  for (auto [alloc_id, contig] :
       zip(alloc | std::views::reverse, contiguity | std::views::reverse)) {
    auto is_treated_as_size_one = [](IterDomain* id) {
      return id->isReduction() || id->isBroadcast() || id->isParallelized() ||
          id->extent()->isOneInt();
    };
    if (is_treated_as_size_one(alloc_id)) {
      continue;
    }

    NVF_ERROR(contig.has_value());
    if (!contig.value()) {
      break;
    }

    while (projected_dim != projected_dims.rend() &&
           is_treated_as_size_one(*projected_dim)) {
      projected_dim++;
    }

    IterDomain* logical_id = [&]() {
      std::vector<IterDomain*> reachable_ids =
          ir_utils::getReachableIds(tv->getLogicalDomain(), {alloc_id});
      NVF_ERROR_LE(reachable_ids.size(), 1);
      return reachable_ids.empty() ? nullptr : reachable_ids.front();
    }();

    if (logical_id == nullptr) {
      // In LayoutOp, allocation IDs may not be connected to logical IDs; skip
      // expanding vectorization in that case.
      break;
    }

    // Mapping order isn't correct, cannot expand vectorization dimension.
    if (projected_dim == projected_dims.rend() ||
        *projected_dim != logical_id) {
      break;
    }
    // This assumes projected_dim can be matched only once. This assumption is
    // OK for now but when we get to non-outermost sharding such as
    // ```
    //    [iS0]
    //    /  \.
    //  iS1  iS2
    //       /  \.
    // iDIDx3  iS4
    // ```
    // We may want to allow multiple contiguous allocation IDs to match
    // projected_dim.
    projected_dim++;

    product_of_inner_extents = SimplifyingIrBuilder::mulExpr(
        product_of_inner_extents, getProjectedExtent(alloc_id));
  }
  return product_of_inner_extents;
}

API Signature Change

The projectId method signature has been changed to include additional parameters (to and leaf vectors), and the implementation has been refactored with new lambda functions for forward and backward projection. The new implementation changes the order of operations (forward_project called twice) and modifies how projected extents are accumulated. This is a breaking API change that could affect other parts of the codebase that depend on this method. The change should be verified to not introduce regressions in the projection logic.

std::vector<IterDomain*> ContiguousInnerDimensionsMapper::projectId(
    const std::vector<IterDomain*>& from,
    const std::vector<IterDomain*>& to,
    const std::vector<IterDomain*>& leaf) {
  std::vector<IterDomain*> frontier = from;

  // Process `merge_or_split` and update `frontier`, where `merge_or_split` must
  // be an expr that combines two IDs into one. For forward propagation, it must
  // be a merge, and for backward propagation, it must be a split.
  auto propagateCombine = [&frontier, this](auto* merge_or_split) {
    // Initialize state
    auto find_outer_it = frontier.begin();
    auto outer_pos = frontier.size();
    auto find_inner_it = frontier.begin();
    auto inner_pos = frontier.size();

    // Removes all entries to the left of provided `it`, if `it` is not
    // frontier.begin(). Updates all state of finding outer and inner in the
    // frontier vector after erasing.
    auto clear_left_of = [&find_outer_it,
                          &outer_pos,
                          &find_inner_it,
                          &inner_pos,
                          &frontier,
                          &merge_or_split](decltype(find_outer_it) it) {
      if (it != frontier.begin()) {
        frontier.erase(frontier.begin(), it);
      }

      // Set outer it and position
      find_outer_it =
          std::find(frontier.begin(), frontier.end(), merge_or_split->outer());
      outer_pos = std::distance(frontier.begin(), find_outer_it);

      // Set inner it and position
      find_inner_it =
          std::find(frontier.begin(), frontier.end(), merge_or_split->inner());
      inner_pos = std::distance(frontier.begin(), find_inner_it);
    };

    // Dry run to fill state
    clear_left_of(frontier.begin());

    // Cannot map through non-divisible split
    if constexpr (std::is_same_v<decltype(merge_or_split), Split*>) {
      if (divisible_splits_.find(merge_or_split) == divisible_splits_.end()) {
        if (find_inner_it != frontier.end()) {
          clear_left_of(find_inner_it + 1);
        }
        if (find_outer_it != frontier.end()) {
          clear_left_of(find_outer_it + 1);
        }
        return;
      }
    }

    // Check if the domains out of the split are contiguous in the mapped
    // domain.
    if (find_outer_it == frontier.end() && find_inner_it != frontier.end()) {
      // Outer dimension was not found, but inner dimension was. Must assume
      // everything to the left of inner is not contiguously merged.
      //
      // Clear left of inner
      clear_left_of(find_inner_it);
    } else if (
        find_outer_it != frontier.end() && find_inner_it == frontier.end()) {
      // Inner dimension was not found, outer and anything left of outer are
      // definitely not contiguous.
      //
      // Clear outer and left of outer
      clear_left_of(find_outer_it + 1);
      return;
    } else if (
        find_outer_it == frontier.end() && find_inner_it == frontier.end()) {
      // Nothing mapped, just continue
      return;
    }

    if (find_outer_it != frontier.end() && find_inner_it != frontier.end()) {
      // Both outer and inner mapped.
      if (outer_pos >= inner_pos) {
        // Make sure outer is outside inner, otherwise neither could be part
        // of a continuous mapping. There are cases where we could have
        // reversible operations e.g.:
        //    [id{3} id{5} id{6}] -> merge(1, 0)
        // -> [id{5*3} id{6}] -> split(0, 3)
        // -> [id{5} id{3} id{6}] -> transpose(0, 1)
        // -> [id{3} id{5} id{6}]
        // However we don't try and capture cases like this correcly, we'd
        // just reduce this down to only the iter domain of size 6 mapping.
        //
        // Clear outer and left of outer
        clear_left_of(find_outer_it + 1);
        return;
      }

      // Find the position inner would have to have to be considered ordered
      // relative to outer
      auto pos_after_outer = outer_pos + 1;
      for (; pos_after_outer < frontier.size(); pos_after_outer++) {
        if (frontier[pos_after_outer]->isBroadcast() &&
            pos_after_outer != inner_pos) {
          // Skip broadcast axes as they must not have been concretized in
          // the reference. We remove dimensions that underwent a
          // concretization as well as the dimensions to the left of that in
          // propagateC2P.
          return;
        }
        break;
      }

      if (inner_pos != pos_after_outer) {
        // Nothing to the left of inner could be continuous.
        //
        // Clear left of inner
        clear_left_of(find_inner_it);
      }
    }

    if constexpr (std::is_same_v<decltype(merge_or_split), Split*>) {
      frontier[inner_pos] = merge_or_split->in();
    } else {
      static_assert(std::is_same_v<decltype(merge_or_split), Merge*>);
      frontier[inner_pos] = merge_or_split->out();
    }
    bool outer_mapped = find_outer_it != frontier.end();
    if (outer_mapped) {
      // Remove outer
      frontier.erase(find_outer_it);
    } else {
      // Clear to the left of inner in since only inner maps
      frontier.erase(frontier.begin(), frontier.begin() + (int64_t)inner_pos);
    }

    combinePE(merge_or_split, outer_mapped);
  };

  // Process `merge_or_split` and update `frontier`, where `merge_or_split` must
  // be an expr that unflatten one ID into two IDs. For forward propagation, it
  // must be a split, and for backward propagation, it must be a merge
  auto propagateDistribute = [&frontier, this](auto* merge_or_split) {
    Val* combined = nullptr;
    if constexpr (std::is_same_v<decltype(merge_or_split), Split*>) {
      combined = merge_or_split->in();
    } else {
      static_assert(std::is_same_v<decltype(merge_or_split), Merge*>);
      combined = merge_or_split->out();
    }
    auto find_out_it = std::find(frontier.begin(), frontier.end(), combined);
    if (find_out_it == frontier.end()) {
      return;
    }

    auto out_pos = std::distance(frontier.begin(), find_out_it);
    frontier[out_pos] = merge_or_split->outer();
    frontier.insert(frontier.begin() + out_pos + 1, merge_or_split->inner());

    distributePE(merge_or_split);
  };

  auto propagateResize = [&frontier, this](Resize* resize_op, bool p2c) {
    IterDomain* id_from = p2c ? resize_op->in() : resize_op->out();
    IterDomain* id_to = p2c ? resize_op->out() : resize_op->in();

    auto it = std::find(frontier.begin(), frontier.end(), id_from);
    if (it == frontier.end()) {
      return;
    }
    auto pos = std::distance(frontier.begin(), it);

    // project resize op to frontier.
    frontier[pos] = id_to;
    // clear left of resize, since those are no long contiguous.
    frontier.erase(frontier.begin(), it);

    if (recording_) {
      // we need to check slice offset at this point.
      auto projected_extent = getProjectedExtent(id_from);

      // projected_extent == 0: return the projected_extent as-is
      // resize_extent == 0   : no resizing, return the projected_extent as-is
      // resize_extent != 0   : slicing/padding, return gcd(projected_extent,
      // abs(resize_extent)) This is a conservative analysis of the offset for
      // data accessing. A better approach needs to consider the actual start
      // pointer address and handle it in alignment analysis in runtime info. We
      // also need to consider multiple resize stacked together and how they
      // could interact with each other. Translating this to code: if
      // (resize_extent == 0 || projected_extent == 0) {
      //   return projected_extent;
      // } else {
      //   gcd(projected_extent, abs(resize_extent));
      // }
      auto comp = [](Val* projected_extent, Val* resize_extent) {
        return SimplifyingIrBuilder::whereExpr(
            SimplifyingIrBuilder::logicalOrExpr(
                SimplifyingIrBuilder::eqExpr(
                    resize_extent, resize_extent->container()->zeroVal()),
                SimplifyingIrBuilder::eqExpr(
                    projected_extent,
                    projected_extent->container()->zeroVal())),
            projected_extent,
            SimplifyingIrBuilder::gcdExpr(
                projected_extent, IrBuilder::absExpr(resize_extent)));
      };
      projected_extent = comp(projected_extent, resize_op->leftExpand());
      projected_extent = comp(projected_extent, resize_op->rightExpand());

      // cap extent by the destination, this is useful when the id_to is resized
      // to zero, where projected_extent shouldn't go beyond the total extent.
      projected_extent =
          SimplifyingIrBuilder::minExpr(projected_extent, id_to->extent());

      addProjectedExtent(id_to, projected_extent);
    }
  };

  // If `from` is [I1, I2, I3, I4], `to` is [I1, I5, I6, I7], where I2 =
  // merge(I5, I6) and I7 = merge(I3, I4), `from` is on both side of `to`. We
  // traverse the forward side and backward side separately. For this example,
  // we will have backward exprs {I2 = merge(I5, I6)} and forward exprs {I7 =
  // merge(I3, I4)}. If from is on the forward side only, then we will have
  // empty backward exprs, vice versa.

  auto backward_project = [&](const std::vector<IterDomain*>& to) {
    auto backward_exprs = StmtSort::getExprsBetween(
        {to.begin(), to.end()}, {frontier.begin(), frontier.end()});
    for (auto* expr : backward_exprs | std::views::reverse) {
      if (Split* split = dynamic_cast<Split*>(expr)) {
        propagateCombine(split);
      } else if (Merge* merge = dynamic_cast<Merge*>(expr)) {
        propagateDistribute(merge);
      } else if (Resize* resize = dynamic_cast<Resize*>(expr)) {
        propagateResize(resize, false);
      } else {
        NVF_THROW(
            "ProjectDimensions does not support expr type: ", expr->toString());
      }
    }
  };

  auto forward_project = [&](const std::vector<IterDomain*>& to) {
    auto forward_exprs = StmtSort::getExprsBetween(
        {frontier.begin(), frontier.end()}, {to.begin(), to.end()});
    for (auto* expr : forward_exprs) {
      if (Merge* merge = dynamic_cast<Merge*>(expr)) {
        propagateCombine(merge);
      } else if (Split* split = dynamic_cast<Split*>(expr)) {
        propagateDistribute(split);
      } else if (Resize* resize = dynamic_cast<Resize*>(expr)) {
        propagateResize(resize, true);
      } else {
        NVF_THROW(
            "ProjectDimensions does not support expr type: ", expr->toString());
      }
    }
  };

  // Projection is done in the following order to avoid addProjectedExtent for
  // the same ID multiple times.
  forward_project(to);

  std::vector<IterDomain*> frontier_saved = frontier;
  forward_project(leaf);
  frontier = frontier_saved;

  backward_project(to);

  return frontier;
}

wujingyue · 2026-02-08T06:47:37Z

!test

wujingyue · 2026-02-10T18:36:07Z

!test

wujingyue · 2026-02-10T23:03:05Z

!test

wujingyue · 2026-02-11T01:33:22Z

!test

wujingyue · 2026-02-11T01:34:50Z

csrc/scheduler/vectorize_helper.cpp

      getProjectedExtent(id), commonOrConstExtent(ca_map_, id));
 }

+void ContiguousInnerDimensionsMapper::addProjectedExtent(


https://google.github.io/styleguide/cppguide.html#Defining_Functions_in_Header_Files

wujingyue · 2026-02-11T01:35:50Z

csrc/scheduler/vectorize_helper.cpp

  // Ordering of dimensions is important in this analysis, if an ordering is
  // contiguous in the reference, but not the target tensor views, then we
  // cannot consider that a contiguous merge dimension for vectorization.
-  auto projected_logical = projectId(filtered_ids, logical_domain);


projected_logical gives me the wrong impression that the whole logical domain is projected. In fact, it's still as filtered as filtered_ids.

greptile-apps · 2026-02-11T01:36:41Z

Greptile Summary

Refactored getContigMergeOfInnerSize to compute vectorization extent using allocation IDs instead of traversing from allocation to logical via device splits. The projectId function now projects to both target (to) and leaf (leaf) domains to record projected extents for allocation IDs. Removed dependency on isValidDeviceSplit to support non-outermost sharding in the future.

Key changes:

projectId now accepts a leaf parameter for allocation domain projection and records allocation ID extents via forward_project(leaf)
getContigMergeOfInnerSize uses getProjectedExtent(alloc_id) directly instead of computing getProjectedExtent(logical_id) / num_devices
Simplified logic eliminates manual device split traversal and sharding calculations
Test file includes minor style improvements (structured bindings)

Potential concerns:

The shift from logical_id to alloc_id extents changes semantics when allocation domain differs from logical domain beyond simple permutation
If forward_project(leaf) doesn't successfully record all allocation IDs (e.g., due to complex transformations), getProjectedExtent(alloc_id) will throw despite logical_id != nullptr check

Confidence Score: 2/5

Refactoring changes core vectorization logic with potential runtime and semantic issues
The PR makes significant changes to how vectorization extents are computed, switching from logical_id to alloc_id extents. While the author claims this is NFC, previous review threads highlight two critical concerns: (1) getProjectedExtent(alloc_id) may throw if allocation IDs weren't recorded during projection, and (2) using allocation-ID extents can produce incorrect results when allocation domain differs from logical domain beyond permutation. The LayoutOp nullptr check handles disconnected domains but doesn't prevent all failure modes. Additional testing and validation needed before merge.
Primary attention needed for csrc/scheduler/vectorize_helper.cpp - specifically the getContigMergeOfInnerSize function and allocation ID extent computation on line 837

Important Files Changed

Filename	Overview
csrc/scheduler/vectorize_helper.cpp	Refactored `getContigMergeOfInnerSize` to use allocation IDs and simplified projection logic. Risk: `getProjectedExtent(alloc_id)` may throw if allocation IDs weren't recorded during projection, despite `logical_id != nullptr` check.
csrc/scheduler/vectorize_helper.h	Moved `addProjectedExtent` to .cpp file and updated `projectId` signature to accept `leaf` parameter for allocation domain projection.
tests/cpp/test_pointwise.cpp	Code style improvements using structured bindings in range loops, removing unnecessary semicolons. No functional changes.

Flowchart

%%{init: {'theme': 'neutral'}}%%
flowchart TD
    A[Start: projectId with from/to/leaf domains] --> B[forward_project to 'to' domain]
    B --> C[Save frontier state]
    C --> D[forward_project to 'leaf' allocation domain]
    D --> E[Restore frontier state]
    E --> F[backward_project to 'to' domain]
    F --> G[Return projected IDs]
    
    D --> H[During projection: combinePE/distributePE]
    H --> I[addProjectedExtent records allocation IDs]
    
    G --> J[getContigMergeOfInnerSize uses projected extents]
    J --> K{Is alloc_id contiguous?}
    K -->|Yes| L[Find logical_id from alloc_id]
    L --> M{logical_id found?}
    M -->|No| N[Break - LayoutOp case]
    M -->|Yes| O{Matches projected_dim?}
    O -->|No| N
    O -->|Yes| P[getProjectedExtent alloc_id]
    P --> Q{alloc_id in projected_extent_?}
    Q -->|No| R[THROW: Not projected]
    Q -->|Yes| S[Multiply into product]
    S --> K

_{Last reviewed commit: 3cc2e10}

greptile-apps

_{3 files reviewed, 2 comments}

_{Edit Code Review Agent Settings | Greptile}

greptile-apps · 2026-02-11T01:36:44Z

csrc/scheduler/vectorize_helper.cpp

+  for (auto [alloc_id, cont] :
+       zip(alloc | std::views::reverse, contiguity | std::views::reverse)) {
+    auto is_treated_as_size_one = [](IterDomain* id) {
+      return id->isReduction() || id->isBroadcast() || id->isParallelized() ||
+          id->extent()->isOneInt();
+    };
+    if (is_treated_as_size_one(alloc_id)) {
      continue;
    }

-    auto contiguity_i = contiguity.at(alloc_ii);
-    if (!contiguity_i.has_value()) {
-      NVF_THROW("contiguity flag at alloc_ii can't be null");
-    } else {
-      // Not contiguous
-      if (!contiguity_i.value()) {
-        break;
-      }
+    NVF_ERROR(cont.has_value());
+    if (!cont.value()) {
+      break;
    }

-    // Get the logical ID corresponding to the allocation ID.
-    auto exprs = DependencyCheck::getAllExprsBetween(
-        {tv->getLogicalDomain().begin(), tv->getLogicalDomain().end()},
-        {alloc_iid});
-    IterDomain* logical_id = alloc_iid;
-    Val* num_devices = tv->container()->oneVal();
-    bool only_valid_device_split = true;
-    for (Expr* expr : exprs | std::views::reverse) {
-      if (!isValidDeviceSplit(expr)) {
-        only_valid_device_split = false;
-        break;
-      }
-      auto* split = expr->as<Split>();
-      logical_id = split->in();
-      num_devices = SimplifyingIrBuilder::mulExpr(num_devices, split->factor());
+    while (projected_dim != projected_dims.rend() &&
+           is_treated_as_size_one(*projected_dim)) {
+      projected_dim++;
    }

-    // Non device split could lead to padding, which prevents vectorization
-    if (!only_valid_device_split) {
-      break;
-    }
+    IterDomain* logical_id = [&]() {
+      std::vector<IterDomain*> reachable_ids =
+          ir_utils::getReachableIds(tv->getLogicalDomain(), {alloc_id});
+      NVF_ERROR_EQ(reachable_ids.size(), 1);
+      return reachable_ids.front();
+    }();

    // Mapping order isn't correct, cannot expand vectorization dimension.
-    if (projected_dims[--projected_dims_i] != logical_id) {
+    if (projected_dim == projected_dims.rend() ||
+        *projected_dim != logical_id) {
      break;
    }
-
-    Val* sharded_extent;
-    if (logical_id->isDeviceDim()) {
-      sharded_extent = tv->container()->oneVal();
-    } else {
-      sharded_extent = SimplifyingIrBuilder::divExpr(
-          getProjectedExtent(logical_id), num_devices);
-    }
-    product_of_inner_extents =
-        SimplifyingIrBuilder::mulExpr(product_of_inner_extents, sharded_extent);
+    // This assumes projected_dim can be matched only once. This assumption is
+    // OK for now but when we get to non-outermost sharding such as
+    // ```
+    //    [iS0]
+    //    /  \.
+    //  iS1  iS2
+    //       /  \.
+    // iDIDx3  iS4
+    // ```
+    // We may want to allow multiple contiguous allocation IDs to match
+    // projected_dim.
+    projected_dim++;
+
+    product_of_inner_extents = SimplifyingIrBuilder::mulExpr(
+        product_of_inner_extents, getProjectedExtent(alloc_id));


Allocation extent mismatched

getContigMergeOfInnerSize now multiplies getProjectedExtent(alloc_id) (i.e., allocation ID) after matching logical_id against mappedLogicalIds(tv) (logical IDs). projected_extent_ values originate from recording logical/root projections and are not guaranteed to include allocation IDs; in those cases getProjectedExtent(alloc_id) will throw "Not projected" at runtime. Even when present, using allocation-ID extents here changes semantics vs the previous logical-ID-based computation and can incorrectly size the contig inner extent for TVs with an allocation permutation. Consider multiplying the projected extent for the matched logical_id (or ensure allocation IDs are always recorded consistently before using them here).

csrc/scheduler/vectorize_helper.cpp

wujingyue · 2026-02-19T00:26:02Z

!test

greptile-apps

_{3 files reviewed, no comments}

_{Edit Code Review Agent Settings | Greptile}

csrc/scheduler/vectorize_helper.cpp

wujingyue · 2026-02-19T02:59:54Z

!test --diff

greptile-apps

_{3 files reviewed, 1 comment}

_{Edit Code Review Agent Settings | Greptile}

greptile-apps · 2026-02-19T03:04:05Z

csrc/scheduler/vectorize_helper.cpp

+    product_of_inner_extents = SimplifyingIrBuilder::mulExpr(
+        product_of_inner_extents, getProjectedExtent(alloc_id));


Potential runtime error if alloc_id wasn't recorded in projected_extent_ during projection. While logical_id != nullptr check on line 812 handles disconnected allocation IDs, there may be edge cases where alloc_id is reachable from logical but wasn't successfully projected (e.g., if forward_project(leaf) didn't reach it due to complex transformations). Consider checking projected_extent_.count(alloc_id) before calling getProjectedExtent, or using logical_id instead.

Suggested change

product_of_inner_extents = SimplifyingIrBuilder::mulExpr(

product_of_inner_extents, getProjectedExtent(alloc_id));

product_of_inner_extents = SimplifyingIrBuilder::mulExpr(

product_of_inner_extents, getProjectedExtent(logical_id));

wujingyue changed the title ~~Wjy/sloppy~~ Clean up getContigMergeOfInnerSize Feb 8, 2026

wujingyue force-pushed the wjy/sloppy branch 2 times, most recently from 78310cd to ba2f27d Compare February 8, 2026 06:46

wujingyue force-pushed the wjy/sloppy branch 3 times, most recently from f3a9608 to f184027 Compare February 10, 2026 06:56

wujingyue added 4 commits February 10, 2026 15:01

Unnecessary condition

ffaa4c1

WIP

160f4a7

Use getProjectedExtent

74d0b7e

WIP -- traverse to loop

28258ee

wujingyue force-pushed the wjy/sloppy branch from f184027 to b7345f7 Compare February 10, 2026 23:02

wujingyue added 3 commits February 10, 2026 16:29

WIP

c741536

Propagate to allocation instead of loop

5840c87

Clean up

12cc04e

wujingyue force-pushed the wjy/sloppy branch from aaa42fd to 12cc04e Compare February 11, 2026 00:29

wujingyue added 3 commits February 10, 2026 16:37

More

2a5d779

More

335bfb0

Skip size-1 dimensions

cb8be65

wujingyue marked this pull request as ready for review February 11, 2026 01:29

wujingyue requested review from Priya2698 and jjsjann123 February 11, 2026 01:32

wujingyue commented Feb 11, 2026

View reviewed changes

greptile-apps bot reviewed Feb 11, 2026

View reviewed changes

More checks

5849e05

greptile-apps bot reviewed Feb 19, 2026

View reviewed changes

Priya2698 reviewed Feb 19, 2026

View reviewed changes

Priya2698 approved these changes Feb 19, 2026

View reviewed changes

wujingyue added 4 commits February 18, 2026 18:55

Fix for LayoutOp

a981d48

Review

7806c56

Fix typo

cf0a386

Stale comments

3cc2e10

greptile-apps bot reviewed Feb 19, 2026

View reviewed changes

wujingyue merged commit dbfb1c6 into main Feb 19, 2026
66 of 68 checks passed

wujingyue deleted the wjy/sloppy branch February 19, 2026 06:02

		product_of_inner_extents = SimplifyingIrBuilder::mulExpr(
		product_of_inner_extents, getProjectedExtent(alloc_id));

Comments

Conversation

wujingyue commented Feb 8, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

wujingyue commented Feb 8, 2026

Uh oh!

github-actions bot commented Feb 8, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Description

Changes walkthrough

PR Reviewer Guide

Uh oh!

wujingyue commented Feb 8, 2026

Uh oh!

wujingyue commented Feb 10, 2026

Uh oh!

wujingyue commented Feb 10, 2026

Uh oh!

wujingyue commented Feb 11, 2026

Uh oh!

wujingyue Feb 11, 2026

Choose a reason for hiding this comment

Uh oh!

wujingyue Feb 11, 2026

Choose a reason for hiding this comment

Uh oh!

greptile-apps bot commented Feb 11, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Greptile Summary

Confidence Score: 2/5

Important Files Changed

Flowchart

Uh oh!

greptile-apps bot left a comment

Choose a reason for hiding this comment

Uh oh!

greptile-apps bot Feb 11, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

wujingyue commented Feb 19, 2026

Uh oh!

greptile-apps bot left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

wujingyue commented Feb 19, 2026

Uh oh!

greptile-apps bot left a comment

Choose a reason for hiding this comment

Uh oh!

greptile-apps bot Feb 19, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

wujingyue commented Feb 8, 2026 •

edited

Loading

github-actions bot commented Feb 8, 2026 •

edited

Loading

greptile-apps bot commented Feb 11, 2026 •

edited

Loading