[API Compatibility] Implement paddle.addcmul API -part

paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/multiary_infer_sym.cc

@@ -62,6 +62,84 @@ bool AccuracyOpInferSymbolicShape(
   return true;
 }
 
+bool AddcmulOpInferSymbolicShape(
+    pir::Operation *op, pir::InferSymbolicShapeContext *infer_context) {
+  const auto &input_shape_or_data =
+      infer_context->GetShapeOrDataForValue(op->operand_source(0));
+  const auto &tensor1_shape_or_data =
+      infer_context->GetShapeOrDataForValue(op->operand_source(1));
+  const auto &tensor2_shape_or_data =
+      infer_context->GetShapeOrDataForValue(op->operand_source(2));
+  std::vector<symbol::DimExpr> input_shape = input_shape_or_data.shape();
+  std::vector<symbol::DimExpr> tensor1_shape = tensor1_shape_or_data.shape();
+  std::vector<symbol::DimExpr> tensor2_shape = tensor2_shape_or_data.shape();
+
+  // Step 1: Broadcast tensor1 and tensor2 (matches InferMeta order)
+  int tensor1_ndims = static_cast<int>(tensor1_shape.size());
+  int tensor2_ndims = static_cast<int>(tensor2_shape.size());
+  int diff_t1_t2 = tensor1_ndims - tensor2_ndims;
+  if (diff_t1_t2 > 0) {
+    for (int i = 0; i < diff_t1_t2; ++i) {
+      tensor2_shape.emplace(tensor2_shape.begin(), 1);
+    }
+  } else {
+    for (int i = 0; i < -diff_t1_t2; ++i) {
+      tensor1_shape.emplace(tensor1_shape.begin(), 1);
+    }
+  }
+
+  symbol::DimExprBuilder builder;
+  std::vector<symbol::DimExpr> mul_shape;
+  for (size_t i = 0; i < tensor1_shape.size(); ++i) {
+    if (tensor1_shape[i] == tensor2_shape[i]) {
+      mul_shape.emplace_back(tensor1_shape[i]);
+    } else if (tensor1_shape[i] == 1) {
+      mul_shape.emplace_back(tensor2_shape[i]);
+    } else if (tensor2_shape[i] == 1) {
+      mul_shape.emplace_back(tensor1_shape[i]);
+    } else {
+      mul_shape.emplace_back(
+          builder.Broadcast(tensor1_shape[i], tensor2_shape[i]));
+      infer_context->AddBroadcastableCstr(tensor1_shape[i], tensor2_shape[i]);
+    }
+  }
+
+  // Step 2: Broadcast input and mul_shape (matches InferMeta order)
+  int input_ndims = static_cast<int>(input_shape.size());
+  int mul_ndims = static_cast<int>(mul_shape.size());
+  int diff_input_mul = input_ndims - mul_ndims;
+  if (diff_input_mul > 0) {
+    for (int i = 0; i < diff_input_mul; ++i) {
+      mul_shape.emplace(mul_shape.begin(), 1);
+    }
+  } else {
+    for (int i = 0; i < -diff_input_mul; ++i) {
+      input_shape.emplace(input_shape.begin(), 1);
+    }
+  }
+
+  std::vector<symbol::DimExpr> output_shape;
+  for (size_t i = 0; i < input_shape.size(); ++i) {
+    if (input_shape[i] == mul_shape[i]) {
+      output_shape.emplace_back(input_shape[i]);
+    } else if (input_shape[i] == 1) {
+      output_shape.emplace_back(mul_shape[i]);
+    } else if (mul_shape[i] == 1) {
+      output_shape.emplace_back(input_shape[i]);
+    } else {
+      output_shape.emplace_back(
+          builder.Broadcast(input_shape[i], mul_shape[i]));
+      infer_context->AddBroadcastableCstr(input_shape[i], mul_shape[i]);
+    }
+  }
+
+  infer_context->SetShapeOrDataForValue(
+      op->result(0),
+      symbol::ShapeOrDataDimExprs{
+          symbol::TensorShapeOrDataDimExprs(output_shape)});
+  return true;
+}
+
 bool AddNOpInferSymbolicShape(pir::Operation *op,
                               pir::InferSymbolicShapeContext *infer_context) {
   const auto &input_list_shape_or_data =

paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/multiary_infer_sym.h

@@ -19,6 +19,7 @@
 namespace paddle::dialect {
 
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(Accuracy)
+OP_DECLARE_INFER_SYMBOLIC_SHAPE(Addcmul)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(Addmm)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(Addmm_)
 OP_DECLARE_INFER_SYMBOLIC_SHAPE(AddN)

paddle/phi/infermeta/ternary.cc

@@ -26,6 +26,9 @@ limitations under the License. */
 #include "paddle/phi/kernels/funcs/common_shape.h"
 #include "paddle/phi/kernels/impl/box_coder.h"
 
+#include "paddle/phi/core/infermeta_utils.h"
+#include "paddle/phi/core/meta_tensor.h"
+
 namespace phi {
 namespace detail {
 // Used in MatrixRankAtolRtolInferMeta
@@ -139,6 +142,51 @@ void AddmmInferMeta(const MetaTensor& input,
   out->set_dtype(input.dtype());
 }
 
+static DDim BroadcastTwoDims(const DDim& x_dims, const DDim& y_dims) {
+  int max_rank = std::max(x_dims.size(), y_dims.size());
+  std::vector<int64_t> out_dims_vector(max_rank);
+
+  int x_idx = x_dims.size() - 1;
+  int y_idx = y_dims.size() - 1;
+
+  for (int i = max_rank - 1; i >= 0; --i) {
+    int64_t x_val = x_idx >= 0 ? x_dims[x_idx--] : 1;
+    int64_t y_val = y_idx >= 0 ? y_dims[y_idx--] : 1;
+
+    // Check broadcast validity (dimensions must be equal, or one of them is 1)
+    if (x_val != y_val && x_val != 1 && y_val != 1) {
+      PADDLE_THROW(common::errors::InvalidArgument(
+          "Broadcast dimension mismatch. Operands could not be broadcast "
+          "together with shapes %s and %s",
+          x_dims,
+          y_dims));
+    }
+    out_dims_vector[i] = std::max(x_val, y_val);
+  }
+  return common::make_ddim(out_dims_vector);
+}
+
+void AddcmulInferMeta(const MetaTensor& input,
+                      const MetaTensor& tensor1,
+                      const MetaTensor& tensor2,
+                      MetaTensor* out) {
+  auto input_dims = input.dims();
+  auto t1_dims = tensor1.dims();
+  auto t2_dims = tensor2.dims();
+
+  // 1. First broadcast tensor1 and tensor2 (corresponding to value * tensor1 *
+  // tensor2)
+  DDim mul_dims = BroadcastTwoDims(t1_dims, t2_dims);
+
+  // 2. Then broadcast the result with input (corresponding to input + ...)
+  DDim out_dims = BroadcastTwoDims(input_dims, mul_dims);
+
+  // 3. Set output information
+  out->set_dims(out_dims);
+  out->share_lod(input);
+  out->set_dtype(input.dtype());
+}
+
 void BaddbmmInferMeta(const MetaTensor& input,
                       const MetaTensor& x,
                       const MetaTensor& y,

paddle/phi/infermeta/ternary.h

@@ -41,6 +41,11 @@ PADDLE_API void AccuracyInferMeta(const MetaTensor& out,
                                   MetaTensor* total,
                                   MetaConfig config = MetaConfig());
 
+PADDLE_API void AddcmulInferMeta(const MetaTensor& input,
+                                 const MetaTensor& tensor1,
+                                 const MetaTensor& tensor2,
+                                 MetaTensor* out);
+
 PADDLE_API void AddmmInferMeta(const MetaTensor& input,
                                const MetaTensor& x,
                                const MetaTensor& y,

paddle/phi/kernels/addcmul_grad_kernel.h

@@ -0,0 +1,33 @@
+// Copyright (c) 2026 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "paddle/phi/common/scalar.h"
+#include "paddle/phi/core/dense_tensor.h"
+
+namespace phi {
+
+template <typename T, typename Context>
+void AddcmulGradKernel(const Context& dev_ctx,
+                       const DenseTensor& input,
+                       const DenseTensor& tensor1,
+                       const DenseTensor& tensor2,
+                       const DenseTensor& out_grad,
+                       const Scalar& value,
+                       DenseTensor* input_grad,
+                       DenseTensor* tensor1_grad,
+                       DenseTensor* tensor2_grad);
+
+}  // namespace phi

paddle/phi/kernels/addcmul_kernel.h

@@ -0,0 +1,30 @@
+// Copyright (c) 2026 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "paddle/phi/common/scalar.h"
+#include "paddle/phi/core/dense_tensor.h"
+
+namespace phi {
+
+template <typename T, typename Context>
+void AddcmulKernel(const Context& dev_ctx,
+                   const DenseTensor& input,
+                   const DenseTensor& tensor1,
+                   const DenseTensor& tensor2,
+                   const Scalar& value,
+                   DenseTensor* out);
+
+}  // namespace phi

paddle/phi/kernels/cpu/addcmul_grad_kernel.cc

@@ -0,0 +1,22 @@
+// Copyright (c) 2026 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "paddle/phi/kernels/addcmul_grad_kernel.h"
+
+#include "paddle/phi/backends/cpu/cpu_context.h"
+#include "paddle/phi/core/kernel_registry.h"
+#include "paddle/phi/kernels/impl/addcmul_grad_kernel_impl.h"
+
+PD_REGISTER_KERNEL(
+    addcmul_grad, CPU, ALL_LAYOUT, phi::AddcmulGradKernel, float, double) {}

paddle/phi/kernels/cpu/addcmul_kernel.cc

@@ -0,0 +1,23 @@
+// Copyright (c) 2026 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "paddle/phi/kernels/addcmul_kernel.h"
+
+#include "paddle/phi/backends/cpu/cpu_context.h"
+#include "paddle/phi/core/kernel_registry.h"
+#include "paddle/phi/kernels/impl/addcmul_kernel_impl.h"
+
+PD_REGISTER_KERNEL(
+    addcmul, CPU, ALL_LAYOUT, phi::AddcmulKernel, float, double, int, int64_t) {
+}

paddle/phi/kernels/funcs/common_shape.h

@@ -128,7 +128,19 @@ static void GetBroadcastDims(const DDim &in_dims,
     if (in_dims[i] == out_dims[i]) {
       (*bcast_dims)[i] = 1;
     } else {
-      (*bcast_dims)[i] = std::max(in_dims[i], out_dims[i]);
+      // Calculate broadcast factor: out_dims[i] / in_dims[i]
+      // in_dims[i] should be 1 for valid broadcasting
+      PADDLE_ENFORCE_EQ(
+          in_dims[i],
+          1,
+          common::errors::InvalidArgument(
+              "Tensor dimension mismatch for broadcasting. "
+              "Input dimension %d is %d, output dimension is %d. "
+              "For broadcasting, input dimension must be 1 or equal to output.",
+              i,
+              in_dims[i],
+              out_dims[i]));
+      (*bcast_dims)[i] = out_dims[i];
     }
   }
 }

paddle/phi/kernels/gpu/addcmul_grad_kernel.cu

@@ -0,0 +1,28 @@
+// Copyright (c) 2026 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "paddle/phi/kernels/addcmul_grad_kernel.h"
+
+#include "paddle/phi/backends/gpu/gpu_context.h"
+#include "paddle/phi/core/kernel_registry.h"
+#include "paddle/phi/kernels/impl/addcmul_grad_kernel_impl.h"
+
+PD_REGISTER_KERNEL(addcmul_grad,
+                   GPU,
+                   ALL_LAYOUT,
+                   phi::AddcmulGradKernel,
+                   float,
+                   double,
+                   phi::dtype::float16,
+                   phi::dtype::bfloat16) {}

paddle/phi/kernels/gpu/addcmul_kernel.cu

@@ -0,0 +1,30 @@
+// Copyright (c) 2026 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "paddle/phi/kernels/addcmul_kernel.h"
+
+#include "paddle/phi/backends/gpu/gpu_context.h"
+#include "paddle/phi/core/kernel_registry.h"
+#include "paddle/phi/kernels/impl/addcmul_kernel_impl.h"
+
+PD_REGISTER_KERNEL(addcmul,
+                   GPU,
+                   ALL_LAYOUT,
+                   phi::AddcmulKernel,
+                   float,
+                   double,
+                   phi::dtype::float16,
+                   phi::dtype::bfloat16,
+                   int,
+                   int64_t) {}