[ssbuffer](feat) scalar v2c dep fix v2

third_party/ascend/include/DynamicCVPipeline/Common/SSBufferManager.h

@@ -90,27 +90,31 @@ class SSBufferManager {
 static constexpr int ADDR_INT_TYPE = 64;
 static constexpr int CONST_INT_TYPE = 32;
 
-inline MemRefType getSsbufMemrefType(Builder &builder) {
-  auto i32Type = builder.getIntegerType(CONST_INT_TYPE);
+inline MemRefType getSsbufMemrefType(Builder &builder, Type elemType) {
   auto addressSpaceAttr =
       builder.getAttr<hivm::AddressSpaceAttr>(hivm::AddressSpace::SSBUF);
-  return MemRefType::get({}, i32Type, nullptr, addressSpaceAttr);
+  return MemRefType::get({}, elemType, nullptr, addressSpaceAttr);
 }
 
 inline std::pair<arith::ConstantOp, hivm::PointerCastOp>
-getSsbufConstAndPointerCast(OpBuilder &builder, Location loc, uint64_t addr) {
+getSsbufConstAndPointerCast(OpBuilder &builder, Location loc, uint64_t addr,
+                            Type elemType) {
   auto i64Type = builder.getIntegerType(ADDR_INT_TYPE);
   auto addrAttr = builder.getIntegerAttr(i64Type, addr);
   auto addrConst = builder.create<arith::ConstantOp>(loc, i64Type, addrAttr);
 
   return {addrConst,
-          builder.create<hivm::PointerCastOp>(loc, getSsbufMemrefType(builder),
+          builder.create<hivm::PointerCastOp>(loc,
+                                              getSsbufMemrefType(builder,
+                                                                 elemType),
                                               addrConst.getResult())};
 }
 
 inline hivm::PointerCastOp createPointerCastOp(OpBuilder &builder, Location loc,
                                                uint64_t addr) {
-  return getSsbufConstAndPointerCast(builder, loc, addr).second;
+  // Default to i32 for callers that only store i32 values into SSBuffer.
+  auto i32Type = builder.getIntegerType(CONST_INT_TYPE);
+  return getSsbufConstAndPointerCast(builder, loc, addr, i32Type).second;
 }
 
 } // namespace triton

third_party/ascend/include/DynamicCVPipeline/SplitDataflow/DataDependencyAnalysis.h

@@ -144,6 +144,13 @@ class DataDependencyAnalysisPass
                          mlir::Operation *predOp, mlir::Operation *nextOp);
   void analyzeExternalInputs(DataDependencyInfo &info);
   void analyzeExternalOutputs(DataDependencyInfo &info);
+  void analyzeScalarVToCDependencies(DataDependencyInfo &info);
+  void analyzeScalarExtractDependencies(
+      DataDependencyInfo &info,
+      llvm::DenseSet<mlir::Value> &handledScalarValues);
+  void analyzeScalarControlFlowDependencies(
+      DataDependencyInfo &info,
+      llvm::DenseSet<mlir::Value> &handledScalarValues);
 
   void analyzeMemoryEffect(DataDependencyInfo &info);
   std::pair<int, int> findCommonLevelBlockIds(DataDependencyInfo &info,

third_party/ascend/lib/DynamicCVPipeline/AddControlFlowCondition/UpdateConditionInfo.cpp

@@ -95,7 +95,7 @@ UpdateConditionInfoPass::allocSSBuffer(ModuleOp module) {
   OpBuilder builder(module.getContext());
   auto i64Type = builder.getIntegerType(ADDR_INT_TYPE);
   auto i32Type = builder.getIntegerType(CONST_INT_TYPE);
-  auto memrefType = getSsbufMemrefType(builder);
+  auto memrefType = getSsbufMemrefType(builder, i32Type);
 
   // alloc 2 group of ssbuffer pointers:
   // Core Vector 0: allocate ssbuffer address: 0, 4, 8, ...
@@ -489,7 +489,8 @@ UpdateConditionInfoPass::computeVectorSSBufferMemrefs(
     auto ssbAddr =
         builder.create<arith::AddIOp>(loc, ssbBaseAddr, ssbAddrOffset);
     Value memref = builder.create<PointerCastOp>(
-        loc, getSsbufMemrefType(builder), ssbAddr.getResult());
+        loc, getSsbufMemrefType(builder, builder.getIntegerType(CONST_INT_TYPE)),
+        ssbAddr.getResult());
     vectorSSBufferMemrefs[groupIdx] = memref;
   }
 

third_party/ascend/lib/DynamicCVPipeline/Common/SSBufferManager.cpp

@@ -103,8 +103,9 @@ SSBufferManager::writeToSSBuffer(Value value, OpBuilder &builder,
 
   int64_t addrValue = addrResult.value();
   Location loc = builder.getUnknownLoc();
+  // memref.store requires value type == memref element type.
   auto [constOp, pointerCastOp] =
-      getSsbufConstAndPointerCast(builder, loc, addrValue);
+      getSsbufConstAndPointerCast(builder, loc, addrValue, value.getType());
   createdOps.push_back(constOp);
   createdOps.push_back(pointerCastOp);
 
@@ -129,8 +130,8 @@ SSBufferManager::readFromSSBuffer(int64_t addr, OpBuilder &builder,
   }
 
   Location loc = builder.getUnknownLoc();
-  auto [constOp, pointerCastOp] =
-      getSsbufConstAndPointerCast(builder, loc, addr);
+  auto [constOp, pointerCastOp] = getSsbufConstAndPointerCast(
+      builder, loc, addr, findResult.value().second);
   createdOps.push_back(constOp);
   createdOps.push_back(pointerCastOp);
 

third_party/ascend/lib/DynamicCVPipeline/Common/Utils.cpp

@@ -108,7 +108,7 @@ bool isVectorOnlyOp(Operation *op) {
 
   return llvm::TypeSwitch<Operation *, bool>(op)
       .Case([](linalg::ReduceOp) { return true; })
-      .Case<arith::SelectOp, math::FloorOp>([](Operation *op) {
+      .Case<arith::SelectOp, math::FloorOp, math::CeilOp>([](Operation *op) {
         return isa<RankedTensorType>(op->getResult(0).getType());
       })
       .Default([](auto) { return false; });

third_party/ascend/lib/DynamicCVPipeline/PlanComputeBlock/OpClassifier.cpp

@@ -703,6 +703,41 @@ void OpClassifierPass::getUpstreamOpsWithMemoryDeps(
   }
 }
 
+// arith/math op with a tensor result is VECTOR-only (not CUBE).
+static bool isTensorArithOrMathOp(Operation *op) {
+  if (!isa<arith::ArithDialect, math::MathDialect>(op->getDialect())) {
+    return false;
+  }
+  for (Value result : op->getResults()) {
+    if (isa<RankedTensorType>(result.getType())) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// True if `value`'s defining chain reaches a VECTOR-only op.  An extract of
+// such a tensor is itself VECTOR (CUBE gets the scalar via SSBuffer), so it
+// must not be marked CUBE.
+static bool hasVectorOnlyProducer(Value value) {
+  llvm::SmallVector<Value> worklist{value};
+  llvm::DenseSet<Operation *> visited;
+  while (!worklist.empty()) {
+    Value cur = worklist.pop_back_val();
+    Operation *defOp = cur.getDefiningOp();
+    if (!defOp || !visited.insert(defOp).second) {
+      continue;
+    }
+    if (CVPipeline::isVectorOnlyOp(defOp)) {
+      return true;
+    }
+    for (Value operand : defOp->getOperands()) {
+      worklist.push_back(operand);
+    }
+  }
+  return false;
+}
+
 // Propagate CUBE core type upstream
 int OpClassifierPass::propagateCubeUpstream() {
   LLVM_DEBUG(DBGS() << "--- Step 2: CUBE upstream BFS --->\n");
@@ -729,19 +764,20 @@ int OpClassifierPass::propagateCubeUpstream() {
       if (!def || cubeVisited.count(def) || isa<linalg::MatmulOp>(def))
         continue;
 
-      // Skip arith dialect ops with tensor results (they should be VECTOR, not
-      // CUBE)
-      if (isa<arith::ArithDialect>(def->getDialect())) {
-        bool hasTensorResult = false;
-        for (Value result : def->getResults()) {
-          if (isa<RankedTensorType>(result.getType())) {
-            hasTensorResult = true;
-            break;
-          }
-        }
-        if (hasTensorResult) {
+      // Skip arith/math ops with tensor results (they are VECTOR-only, not
+      // CUBE); scalar arith/math may still be marked CUBE.
+      if (isTensorArithOrMathOp(def)) {
+        LLVM_DEBUG(DBGS() << "skip " << def->getName().getStringRef()
+                          << ": arith/math tensor op\n");
+        continue;
+      }
+
+      // An extract of a VECTOR-only tensor is itself VECTOR.
+      if (auto extOp = dyn_cast<tensor::ExtractOp>(def)) {
+        if (hasVectorOnlyProducer(extOp.getTensor())) {
+          cubeVisited.insert(def);
           LLVM_DEBUG(DBGS() << "skip " << def->getName().getStringRef()
-                            << ": arith tensor op\n");
+                            << ": extract of vector-only producer\n");
           continue;
         }
       }
@@ -927,6 +963,16 @@ void OpClassifierPass::propagateCubeUpstreamForOp(Operation *startOp) {
         continue;
       if (isa<linalg::MatmulOp>(upstreamOp))
         continue;
+      // Align with propagateCubeUpstream: skip arith/math with tensor results
+      // (scalar arith/math may still be marked CUBE).
+      if (isTensorArithOrMathOp(upstreamOp))
+        continue;
+
+      // Extract of a VECTOR-only tensor is itself VECTOR.
+      if (auto extOp = dyn_cast<tensor::ExtractOp>(upstreamOp)) {
+        if (hasVectorOnlyProducer(extOp.getTensor()))
+          continue;
+      }
 
       cubeVisited.insert(upstreamOp);
       LLVM_DEBUG(DBGS() << "\t\tcube upstream: "