cleanup unused channel operations and related logic

src/PIM/Dialect/Spatial/Spatial.td

@@ -194,111 +194,6 @@ def SpatChannelReceiveOp : SpatOp<"channel_receive", []> {
   }];
 }
 
-def SpatChannelSendTensorOp : SpatOp<"channel_send_tensor", [AttrSizedOperandSegments]> {
-  let summary = "Send equal contiguous chunks of one tensor through logical channels";
-
-  let arguments = (ins
-    Variadic<Index>:$channelIds,
-    Variadic<Index>:$sourceCoreIds,
-    Variadic<Index>:$targetCoreIds,
-    SpatTensor:$input
-  );
-
-  let hasVerifier = 1;
-  let assemblyFormat = [{
-    $input `channels` `(` $channelIds `)` `from` `(` $sourceCoreIds `)` `to` `(` $targetCoreIds `)` attr-dict `:` type($input)
-  }];
-}
-
-def SpatChannelReceiveTensorOp : SpatOp<"channel_receive_tensor", [AttrSizedOperandSegments]> {
-  let summary = "Receive equal contiguous chunks of one tensor from logical channels";
-
-  let arguments = (ins
-    Variadic<Index>:$channelIds,
-    Variadic<Index>:$sourceCoreIds,
-    Variadic<Index>:$targetCoreIds
-  );
-
-  let results = (outs
-    SpatTensor:$output
-  );
-
-  let hasVerifier = 1;
-  let assemblyFormat = [{
-    `channels` `(` $channelIds `)` `from` `(` $sourceCoreIds `)` `to` `(` $targetCoreIds `)` attr-dict `:` type($output)
-  }];
-}
-
-def SpatChannelSendBatchOp : SpatOp<"channel_send_batch", [AttrSizedOperandSegments]> {
-  let summary = "Send per-lane tensors through logical channels in a batch body";
-
-  let arguments = (ins
-    Variadic<Index>:$channelIds,
-    Variadic<Index>:$sourceCoreIds,
-    Variadic<Index>:$targetCoreIds,
-    SpatTensor:$input
-  );
-
-  let hasVerifier = 1;
-  let assemblyFormat = [{
-    $input `channels` `(` $channelIds `)` `from` `(` $sourceCoreIds `)` `to` `(` $targetCoreIds `)` attr-dict `:` type($input)
-  }];
-}
-
-def SpatChannelSendTensorBatchOp : SpatOp<"channel_send_tensor_batch", [AttrSizedOperandSegments]> {
-  let summary = "Send equal contiguous chunks of one per-lane tensor through logical channels in a batch body";
-
-  let arguments = (ins
-    Variadic<Index>:$channelIds,
-    Variadic<Index>:$sourceCoreIds,
-    Variadic<Index>:$targetCoreIds,
-    SpatTensor:$input
-  );
-
-  let hasVerifier = 1;
-  let assemblyFormat = [{
-    $input `channels` `(` $channelIds `)` `from` `(` $sourceCoreIds `)` `to` `(` $targetCoreIds `)` attr-dict `:` type($input)
-  }];
-}
-
-def SpatChannelReceiveBatchOp : SpatOp<"channel_receive_batch", [AttrSizedOperandSegments]> {
-  let summary = "Receive a per-lane tensor through logical channels in a batch body";
-
-  let arguments = (ins
-    Variadic<Index>:$channelIds,
-    Variadic<Index>:$sourceCoreIds,
-    Variadic<Index>:$targetCoreIds
-  );
-
-  let results = (outs
-    SpatTensor:$output
-  );
-
-  let hasVerifier = 1;
-  let assemblyFormat = [{
-    `channels` `(` $channelIds `)` `from` `(` $sourceCoreIds `)` `to` `(` $targetCoreIds `)` attr-dict `:` type($output)
-  }];
-}
-
-def SpatChannelReceiveTensorBatchOp : SpatOp<"channel_receive_tensor_batch", [AttrSizedOperandSegments]> {
-  let summary = "Receive equal contiguous chunks of one per-lane tensor through logical channels in a batch body";
-
-  let arguments = (ins
-    Variadic<Index>:$channelIds,
-    Variadic<Index>:$sourceCoreIds,
-    Variadic<Index>:$targetCoreIds
-  );
-
-  let results = (outs
-    SpatTensor:$output
-  );
-
-  let hasVerifier = 1;
-  let assemblyFormat = [{
-    `channels` `(` $channelIds `)` `from` `(` $sourceCoreIds `)` `to` `(` $targetCoreIds `)` attr-dict `:` type($output)
-  }];
-}
-
 //===----------------------------------------------------------------------===//
 // Math
 //===----------------------------------------------------------------------===//

src/PIM/Dialect/Spatial/SpatialOpsVerify.cpp

@@ -95,13 +95,6 @@ static FailureOr<ArrayRef<int64_t>> getWeightShapeForWeightedOp(Value weight) {
   return shapedType.getShape();
 }
 
-static FailureOr<int32_t> getParentBatchLaneCount(Operation* op) {
-  auto batchOp = op->getParentOfType<SpatComputeBatch>();
-  if (!batchOp)
-    return failure();
-  return batchOp.getLaneCount();
-}
-
 static bool isBatchOutputArgument(SpatComputeBatch batchOp, Value value) {
   if (batchOp.getNumResults() == 0)
     return false;
@@ -233,68 +226,6 @@ static LogicalResult verifyStaticUnitStrideParallelInsertSliceOp(tensor::Paralle
   return success();
 }
 
-static LogicalResult verifyTensorChannelSizes(
-  Operation* op, Type type, size_t channelCount, size_t sourceCoreCount, size_t targetCoreCount, StringRef kind) {
-  if (channelCount != sourceCoreCount || channelCount != targetCoreCount)
-    return op->emitError("channelIds, sourceCoreIds, and targetCoreIds must have the same length");
-  if (channelCount == 0)
-    return op->emitError() << kind << " must carry at least one chunk";
-
-  auto shapedType = dyn_cast<ShapedType>(type);
-  if (!shapedType || !shapedType.hasStaticShape())
-    return op->emitError() << kind << " requires a static shaped tensor";
-
-  int64_t elementBits = shapedType.getElementTypeBitWidth();
-  if (elementBits <= 0 || elementBits % 8 != 0)
-    return op->emitError() << kind << " requires byte-sized elements";
-
-  int64_t totalBytes = shapedType.getNumElements() * elementBits / 8;
-  if (totalBytes % static_cast<int64_t>(channelCount) != 0)
-    return op->emitError() << kind << " tensor byte size must be divisible by the number of channel ids";
-  return success();
-}
-
-static LogicalResult
-verifyBatchChannelSizes(Operation* op, size_t channelCount, size_t sourceCoreCount, size_t targetCoreCount) {
-  if (channelCount != sourceCoreCount || channelCount != targetCoreCount)
-    return op->emitError("channelIds, sourceCoreIds, and targetCoreIds must have the same length");
-
-  auto laneCount = getParentBatchLaneCount(op);
-  if (failed(laneCount))
-    return op->emitError("must be nested inside spat.compute_batch");
-  if (channelCount != static_cast<size_t>(*laneCount))
-    return op->emitError("channel metadata length must match parent laneCount");
-
-  return success();
-}
-
-static LogicalResult verifyTensorBatchChannelSizes(
-  Operation* op, Type type, size_t channelCount, size_t sourceCoreCount, size_t targetCoreCount, StringRef kind) {
-  if (channelCount != sourceCoreCount || channelCount != targetCoreCount)
-    return op->emitError("channelIds, sourceCoreIds, and targetCoreIds must have the same length");
-
-  auto laneCount = getParentBatchLaneCount(op);
-  if (failed(laneCount))
-    return op->emitError("must be nested inside spat.compute_batch");
-  if (channelCount == 0 || channelCount % static_cast<size_t>(*laneCount) != 0)
-    return op->emitError() << kind << " channel metadata length must be a positive multiple of parent laneCount";
-
-  auto shapedType = dyn_cast<ShapedType>(type);
-  if (!shapedType || !shapedType.hasStaticShape())
-    return op->emitError() << kind << " requires a static shaped tensor";
-
-  int64_t elementBits = shapedType.getElementTypeBitWidth();
-  if (elementBits <= 0 || elementBits % 8 != 0)
-    return op->emitError() << kind << " requires byte-sized elements";
-
-  int64_t chunkCount = static_cast<int64_t>(channelCount) / *laneCount;
-  int64_t totalBytes = shapedType.getNumElements() * elementBits / 8;
-  if (totalBytes % chunkCount != 0)
-    return op->emitError() << kind << " tensor byte size must be divisible by the chunk count per lane";
-
-  return success();
-}
-
 static Region* getParentRegion(Value value) {
   if (auto blockArg = dyn_cast<BlockArgument>(value))
     return blockArg.getOwner()->getParent();
@@ -564,52 +495,6 @@ LogicalResult SpatCompute::verify() {
   return success();
 }
 
-LogicalResult SpatChannelSendTensorOp::verify() {
-  return verifyTensorChannelSizes(getOperation(),
-                                  getInput().getType(),
-                                  getChannelIds().size(),
-                                  getSourceCoreIds().size(),
-                                  getTargetCoreIds().size(),
-                                  "channel_send_tensor");
-}
-
-LogicalResult SpatChannelReceiveTensorOp::verify() {
-  return verifyTensorChannelSizes(getOperation(),
-                                  getOutput().getType(),
-                                  getChannelIds().size(),
-                                  getSourceCoreIds().size(),
-                                  getTargetCoreIds().size(),
-                                  "channel_receive_tensor");
-}
-
-LogicalResult SpatChannelSendBatchOp::verify() {
-  return verifyBatchChannelSizes(
-    getOperation(), getChannelIds().size(), getSourceCoreIds().size(), getTargetCoreIds().size());
-}
-
-LogicalResult SpatChannelSendTensorBatchOp::verify() {
-  return verifyTensorBatchChannelSizes(getOperation(),
-                                       getInput().getType(),
-                                       getChannelIds().size(),
-                                       getSourceCoreIds().size(),
-                                       getTargetCoreIds().size(),
-                                       "channel_send_tensor_batch");
-}
-
-LogicalResult SpatChannelReceiveBatchOp::verify() {
-  return verifyBatchChannelSizes(
-    getOperation(), getChannelIds().size(), getSourceCoreIds().size(), getTargetCoreIds().size());
-}
-
-LogicalResult SpatChannelReceiveTensorBatchOp::verify() {
-  return verifyTensorBatchChannelSizes(getOperation(),
-                                       getOutput().getType(),
-                                       getChannelIds().size(),
-                                       getSourceCoreIds().size(),
-                                       getTargetCoreIds().size(),
-                                       "channel_receive_tensor_batch");
-}
-
 LogicalResult SpatComputeBatch::verify() {
   int32_t count = getLaneCount();
   if (count <= 0)

src/PIM/Dialect/Spatial/Transforms/MergeComputeNodes/MergeComputeNodesPass.cpp

@@ -79,8 +79,6 @@ struct MergeIrCounts {
   uint64_t topLevelComputeBatchCount = 0;
   uint64_t scalarChannelSendCount = 0;
   uint64_t scalarChannelReceiveCount = 0;
-  uint64_t tensorChannelSendCount = 0;
-  uint64_t tensorChannelReceiveCount = 0;
   uint64_t wvmmCount = 0;
   uint64_t vaddCount = 0;
   uint64_t scfForCount = 0;
@@ -95,10 +93,6 @@ MergeIrCounts collectMergeIrCounts(func::FuncOp funcOp) {
         ++counts.scalarChannelSendCount;
       else if (isa<spatial::SpatChannelReceiveOp>(nestedOp))
         ++counts.scalarChannelReceiveCount;
-      else if (isa<spatial::SpatChannelSendTensorOp, spatial::SpatChannelSendTensorBatchOp>(nestedOp))
-        ++counts.tensorChannelSendCount;
-      else if (isa<spatial::SpatChannelReceiveTensorOp, spatial::SpatChannelReceiveTensorBatchOp>(nestedOp))
-        ++counts.tensorChannelReceiveCount;
       else if (isa<spatial::SpatVMMOp>(nestedOp))
         ++counts.wvmmCount;
       else if (isa<spatial::SpatVAddOp>(nestedOp))
@@ -130,9 +124,8 @@ void emitMergeIrCounts(StringRef phaseName, func::FuncOp funcOp) {
                << " compute=" << counts.topLevelComputeCount << " compute_batch=" << counts.topLevelComputeBatchCount
                << " scalar_send=" << counts.scalarChannelSendCount
                << " scalar_recv=" << counts.scalarChannelReceiveCount
-               << " tensor_send=" << counts.tensorChannelSendCount
-               << " tensor_recv=" << counts.tensorChannelReceiveCount << " wvmm=" << counts.wvmmCount
-               << " vadd=" << counts.vaddCount << " scf_for=" << counts.scfForCount << "\n";
+               << " wvmm=" << counts.wvmmCount << " vadd=" << counts.vaddCount
+               << " scf_for=" << counts.scfForCount << "\n";
 }
 
 static std::optional<int32_t> getComputeCoreId(SpatCompute compute) {