Update

Author: nhat-nguyen

lib/Conversion/StructuredToMemref/StructuredToMemref.cpp

@@ -59,13 +59,6 @@ static memref::SubViewOp getSubview(int rank, ArrayRef<OpFoldResult> dims,
                                      offsets, dims, strides);
 }
 
-static Value getPtr(Value v) {
-  while (auto op = v.getDefiningOp()) {
-    v = op->getOperand(0);
-  }
-  return v;
-}
-
 namespace {
 
 struct MakeTensorPtrConverter

lib/Conversion/StructuredToMemref/StructuredToMemrefPass.cpp

@@ -144,133 +144,6 @@ class StructuredToMemrefPass
                     ttx::TritonTilingExtDialect, memref::MemRefDialect>();
   }
 
-  LogicalResult convertArgsToMemrefType() {
-    auto moduleOp = getOperation();
-
-    RewritePatternSet patterns(&getContext());
-    ConversionTarget target(getContext());
-    TritonFunctionSignatureConverter typeConverter;
-
-    // Update function signature to use memrefs
-    target.addDynamicallyLegalOp<func::FuncOp>([&](func::FuncOp op) {
-      return typeConverter.isSignatureLegal(op.getFunctionType());
-    });
-
-    populateFunctionOpInterfaceTypeConversionPattern<func::FuncOp>(
-        patterns, typeConverter);
-
-    return applyPartialConversion(moduleOp, target, std::move(patterns));
-  }
-
-  // We leverage the 1->N conversion infrastructure to convert tt.addptr for
-  // scalar to memref.reinterpret_cast.
-  //
-  // A tt.addptr has the following form:
-  //
-  // %new_ptr = tt.addptr %ptr %offset
-  //
-  // where %new_ptr and %ptr have tt.ptr type, and %offset is of index type.
-  //
-  // With this form, there can be a chain of tt.addptr where we keep adding
-  // offsets to an existing pointer:
-  //
-  // %ptr_1 = tt.addptr %arg0 %offset
-  // %ptr_2 = tt.addptr %ptr_1 %offset
-  // %ptr_3 = tt.addptr %ptr_2 %offset
-  //
-  // Now, we want to lower each tt.addptr to a memref.reinterpret_cast so that
-  // the pointers can be used by affine.load and affine.store (lowered from
-  // tt.load and tt.store).
-  //
-  // A memref.reinterpret_cast op also takes an offset and returns a memref in a
-  // similar fashion to tt.addptr:
-  //
-  //  %reinterpret_cast = memref.reinterpret_cast %arg0 to offset: [0], sizes:
-  //  [1], strides: [1] : memref<*xf32> to memref<1xf32, strided<[1], offset:
-  //  ?>>
-  //
-  // However, since the semantic of memref.reinterpret_cast is different,
-  // the following lowering would be incorrect for the sequence of tt.addptr
-  // above:
-  //
-  //  %cast_1 = memref.reinterpret_cast %arg0 to offset [%offset]
-  //  %cast_2 = memref.reinterpret_cast %cast_1 to offset [%offset]
-  //  %cast_3 = memref.reinterpret_cast %cast_2 to offset [%offset]
-  //
-  // The above sequence is equivalent to:
-  //
-  //  %cast_1 = memref.reinterpret_cast %arg0 to offset [%offset]
-  //  %cast_2 = memref.reinterpret_cast %arg0 to offset [%offset]
-  //  %cast_3 = memref.reinterpret_cast %arg0 to offset [%offset]
-  //
-  // In other word, memref.reinterpret_cast ignores the current offset of the
-  // input buffer.
-  //
-  // Therefore, we have to manually track the offset for each addptr by lowering
-  // to the following form:
-  //
-  // %offset_1 = arith.addi %cst_0 %offset
-  // %cast_1 = memref.reinterpret_cast %arg0 to offset [%offset_1]
-  //
-  // %offset_2 = arith.addi %offset_1 %offset
-  // %cast_2 = memref.reinterpret_cast %arg0 to offset [%offset_2]
-  //
-  // %offset_3 = arith.addi %offset_2 %offset
-  // %cast_3 = memref.reinterpret_cast %arg0 to offset [%offset_3]
-  //
-  // Each tt.addptr is lowered to a pair of arith.addi that accumulates the
-  // current offset before using that offset to the reinterpret_cast.
-  LogicalResult convertAddPtrToReinterpretCast() {
-    auto moduleOp = getOperation();
-
-    RewritePatternSet patterns(&getContext());
-
-    auto context = &getContext();
-    OneToNTypeConverter converter;
-    converter.addConversion([](Type type) { return type; });
-
-    // We are doing a 1->2 type conversion here, where a triton pointer type
-    // maps to a pair of {memref, index} type for the the buffer and offset.
-    converter.addConversion(
-        [context](triton::PointerType ptrType, SmallVectorImpl<Type> &types)
-            -> std::optional<LogicalResult> {
-          types = SmallVector<Type>{getMemrefTypeForScalarPtr(ptrType, context),
-                                    IndexType::get(context)};
-          return success();
-        });
-
-    // Hooks to compute the correct materialization, "argument" and "source"
-    // materialization are used when we need to convert a pair of {memref,
-    // index} type back to the original triton pointer type.
-    // These are used when there are ops that still need to use the original
-    // pointer type. For instance, we convert the result of tt.addptr from
-    // tt.ptr type to a pair of {memref, index}, but the original ptr result is
-    // still being used by another tt.load or tt.store.
-    converter.addArgumentMaterialization(buildCastOp);
-    converter.addSourceMaterialization(buildCastOp);
-
-    // Compute the target materialization, given a value with the pointer type,
-    // convert that value to a pair of {memref, index} type.
-    converter.addTargetMaterialization(buildCastAndOffsetOps);
-
-    patterns.add<ScalarAddptrConverter>(converter, context);
-
-    scf::populateSCFStructuralOneToNTypeConversions(converter, patterns);
-
-    if (failed(applyPartialOneToNConversion(getOperation(), converter,
-                                            std::move(patterns)))) {
-      return failure();
-    }
-
-    PassManager pm(&getContext(), moduleOp.getOperationName());
-    pm.addPass(createCanonicalizerPass());
-    if (failed(runPipeline(pm, getOperation()))) {
-      return failure();
-    }
-
-    return success();
-  }
-
   void runOnOperation() override {
     auto moduleOp = getOperation();