[XPU] remove old api part3 (#8860)

Author: wangleilei001

lite/kernels/xpu/activation_compute.cc

@@ -113,13 +113,20 @@ void ReciprocalCompute::Run() {
   auto& param = this->Param<param_t>();
   auto& ctx = this->ctx_->As<XPUContext>();
 
-  int r =
-      xdnn::activation_forward(ctx.GetRawContext(),
-                               xdnn::Activation_t::RECIPROCAL,
-                               param.X->numel(),
-                               param.X->data<float>(),
-                               param.Out->mutable_data<float>(TARGET(kXPU)));
+  float* xpu_factor = nullptr;
+  XPU_CALL(xpu_malloc(reinterpret_cast<void**>(&xpu_factor), sizeof(float)));
+  int x_len = param.X->numel();
+  int r = 0;
+  r = xdnn::constant<float>(ctx.GetRawContext(), xpu_factor, 1, 1.0f);
   CHECK_EQ(r, 0);
+  r = xdnn::broadcast_div(ctx.GetRawContext(),
+                          xpu_factor,
+                          param.X->data<float>(),
+                          param.Out->mutable_data<float>(TARGET(kXPU)),
+                          {1},
+                          {x_len});
+  CHECK_EQ(r, 0);
+  XPU_CALL(xpu_free(xpu_factor));
 }
 
 void SqrtCompute::Run() {
@@ -148,28 +155,30 @@ void PowCompute::Run() {
   auto& param = this->Param<param_t>();
   auto& ctx = this->ctx_->As<XPUContext>();
 
-  xdnn::Activation_t act_type(xdnn::Activation_t::ACT_POW);
-  act_type.pow_factor = param.factor;
-
-  int r =
-      xdnn::activation_forward(ctx.GetRawContext(),
-                               act_type,
-                               param.X->numel(),
-                               param.X->data<float>(),
-                               param.Out->mutable_data<float>(TARGET(kXPU)));
+  float* xpu_factor = nullptr;
+  XPU_CALL(xpu_malloc(reinterpret_cast<void**>(&xpu_factor), sizeof(float)));
+  int x_len = param.X->numel();
+  int r = 0;
+  r = xdnn::constant<float>(ctx.GetRawContext(), xpu_factor, 1, param.factor);
+  CHECK_EQ(r, 0);
+  r = xdnn::broadcast_pow(ctx.GetRawContext(),
+                          param.X->data<float>(),
+                          xpu_factor,
+                          param.Out->mutable_data<float>(TARGET(kXPU)),
+                          {x_len},
+                          {1});
   CHECK_EQ(r, 0);
+  XPU_CALL(xpu_free(xpu_factor));
 }
 
 void SignCompute::Run() {
   auto& param = this->Param<param_t>();
   auto& ctx = this->ctx_->As<XPUContext>();
 
-  int r =
-      xdnn::activation_forward(ctx.GetRawContext(),
-                               xdnn::Activation_t::SIGN,
-                               param.X->numel(),
-                               param.X->data<float>(),
-                               param.Out->mutable_data<float>(TARGET(kXPU)));
+  int r = xdnn::sign(ctx.GetRawContext(),
+                     param.X->data<float>(),
+                     param.Out->mutable_data<float>(TARGET(kXPU)),
+                     param.X->numel());
   CHECK_EQ(r, 0);
 }
 

lite/kernels/xpu/prior_box_compute.cc

@@ -48,44 +48,7 @@ inline void ExpandAspectRatios(const std::vector<float>& input_aspect_ratior,
 
 void PriorBoxCompute::PrepareForRun() {
   auto& param = this->Param<param_t>();
-  std::vector<float> min_size = param.min_sizes;
-  std::vector<float> max_size = param.max_sizes;
-  std::vector<float> aspect_ratio = param.aspect_ratios;
   std::vector<float> variance = param.variances_;
-  std::vector<float> aspect_ratios_vec;
-  bool is_flip = param.flip;
-
-  ExpandAspectRatios(aspect_ratio, is_flip, &aspect_ratios_vec);
-  prior_num = aspect_ratios_vec.size() * min_size.size();
-  prior_num += max_size.size();
-
-  CHECK_LE(aspect_ratios_vec.size(), 16);
-  xpu_aspect_ratios_guard_ =
-      TargetWrapperXPU::MallocScratchPad(16 * sizeof(float));
-  XPU_CALL(xpu_memcpy(xpu_aspect_ratios_guard_->addr_,
-                      aspect_ratios_vec.data(),
-                      aspect_ratios_vec.size() * sizeof(float),
-                      XPUMemcpyKind::XPU_HOST_TO_DEVICE));
-  ar_num = aspect_ratios_vec.size();
-
-  CHECK_LE(min_size.size(), 8);
-  xpu_min_sizes_guard_ = TargetWrapperXPU::MallocScratchPad(8 * sizeof(float));
-  XPU_CALL(xpu_memcpy(xpu_min_sizes_guard_->addr_,
-                      min_size.data(),
-                      min_size.size() * sizeof(float),
-                      XPUMemcpyKind::XPU_HOST_TO_DEVICE));
-  min_size_num = min_size.size();
-
-  max_size_num = max_size.size();
-  if (max_size_num > 0) {
-    CHECK_LE(max_size.size(), 8);
-    xpu_max_sizes_guard_ =
-        TargetWrapperXPU::MallocScratchPad(8 * sizeof(float));
-    XPU_CALL(xpu_memcpy(xpu_max_sizes_guard_->addr_,
-                        max_size.data(),
-                        max_size.size() * sizeof(float),
-                        XPUMemcpyKind::XPU_HOST_TO_DEVICE));
-  }
 
   CHECK_EQ(variance.size(), 4);
   variance_xpu_guard_ = TargetWrapperXPU::MallocScratchPad(4 * sizeof(float));
@@ -99,6 +62,21 @@ void PriorBoxCompute::Run() {
   auto& param = this->Param<param_t>();
   auto& ctx = this->ctx_->As<XPUContext>();
 
+  std::vector<float> aspect_ratio = param.aspect_ratios;
+  std::vector<float> aspect_ratios_vec;
+  bool is_flip = param.flip;
+  ExpandAspectRatios(aspect_ratio, is_flip, &aspect_ratios_vec);
+  CHECK_LE(aspect_ratios_vec.size(), 16);
+  prior_num = aspect_ratios_vec.size() * param.min_sizes.size();
+  prior_num += param.max_sizes.size();
+  ar_num = aspect_ratios_vec.size();
+  min_size_num = param.min_sizes.size();
+  max_size_num = param.max_sizes.size();
+  CHECK_LE(min_size_num, 8);
+  if (max_size_num > 0) {
+    CHECK_LE(max_size_num, 8);
+  }
+
   bool is_clip = param.clip;
   auto image_dims = param.image->dims();
   int im_width = static_cast<int>(image_dims[3]);
@@ -125,31 +103,21 @@ void PriorBoxCompute::Run() {
   param.variances->Resize({height, width, prior_num, 4});
 
   bool min_max_aspect_ratios_order = param.min_max_aspect_ratios_order;
-  float* xpu_aspect_ratios =
-      reinterpret_cast<float*>(xpu_aspect_ratios_guard_->addr_);
-  float* xpu_min_sizes = reinterpret_cast<float*>(xpu_min_sizes_guard_->addr_);
-  float* xpu_max_sizes =
-      (max_size_num > 0)
-          ? (reinterpret_cast<float*>(xpu_max_sizes_guard_->addr_))
-          : nullptr;
-
-  int r = xdnn::prior_box_gen(ctx.GetRawContext(),
-                              param.boxes->mutable_data<float>(TARGET(kXPU)),
-                              xpu_aspect_ratios,
-                              height,
-                              width,
-                              im_height,
-                              im_width,
-                              ar_num,
-                              offset,
-                              step_width,
-                              step_height,
-                              xpu_min_sizes,
-                              xpu_max_sizes,
-                              min_size_num,
-                              max_size_num,
-                              is_clip,
-                              min_max_aspect_ratios_order);
+  int r = xdnn::gen_prior_box<float>(
+      ctx.GetRawContext(),
+      param.boxes->mutable_data<float>(TARGET(kXPU)),
+      {aspect_ratios_vec.data(), ar_num, nullptr},
+      {param.min_sizes.data(), min_size_num, nullptr},
+      {param.max_sizes.data(), max_size_num, nullptr},
+      height,
+      width,
+      im_height,
+      im_width,
+      offset,
+      step_width,
+      step_height,
+      is_clip,
+      min_max_aspect_ratios_order);
   CHECK_EQ(r, 0);
 
   float* xpu_variances_in =