mindspore 2.3.0__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/abs_impl.h

@@ -1,29 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * 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.
- */
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ABS_IMPL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ABS_IMPL_H_
-#include "elewise_unary_impl.h"
-namespace mindspore {
-namespace internal {
-class AbsImpl : public ElewiseUnaryImpl {
- public:
-  AbsImpl(const OpParamPtr &param) : ElewiseUnaryImpl(param) {}
-  virtual ~AbsImpl() {}
-  int Launch() override;
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ABS_IMPL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/elewise_unary_impl.h

@@ -1,47 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * 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.
- */
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ELEWISE_IMPL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ELEWISE_IMPL_H_
-
-#include <vector>
-#include "include/internal_kernel.h"
-#include "include/param/elewise_param.h"
-
-namespace mindspore {
-namespace internal {
-class ElewiseUnaryImpl : public InternelKernelImpl {
- public:
-  ElewiseUnaryImpl(const OpParamPtr &param) : InternelKernelImpl(param) {}
-  virtual ~ElewiseUnaryImpl() {}
-  bool Init(const ValidateInfo &info) override;
-  int Launch() { return -1; };
-  int Tiling(HostRawBuf &tilingBuf) override;
-  void SetStream(const void *stream_ptr) override;
-  void SetDeviceTilingBuf(const DeviceRawBuf &tilingBuf) override;
-  uint64_t GetTilingBufSize() override;
-  std::vector<uint64_t> GetWorkSpaceSize() override;
-  int InferShape(const std::vector<DIMS> &input_shapes, std::vector<DIMS> &output_shapes) override;
-  virtual int32_t GetMaxUbCount(uint32_t op_dtype);
-
- protected:
-  void *stream_ptr_ = nullptr;
-  uint8_t *device_tiling_ = nullptr;
-  uint32_t aligned_factor_ = 128;
-  uint32_t ub_dtype = 0;
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ELEWISE_IMPL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/elewise_unary_tiling.h

@@ -1,24 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * 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.
- */
-#ifndef MS_KERNELS_INTERNAL_ASCENDC_ELEWISE_UNARY_TILING_H_
-#define MS_KERNELS_INTERNAL_ASCENDC_ELEWISE_UNARY_TILING_H_
-#include "utils/elewise_tiling.h"
-namespace mindspore::internal {
-struct ElewiseUnaryTilingData : public ElewiseTailTilingData {
-  uint32_t op_dtype_{0};
-};
-}  // namespace mindspore::internal
-#endif  // MS_KERNELS_INTERNAL_ASCENDC_ELEWISE_UNARY_TILING_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/exp_impl.h

@@ -1,29 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * 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.
- */
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ELEWISE_UNARY_EXP_IMPL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ELEWISE_UNARY_EXP_IMPL_H_
-#include "elewise_unary_impl.h"
-namespace mindspore {
-namespace internal {
-class ExpImpl : public ElewiseUnaryImpl {
- public:
-  ExpImpl(const OpParamPtr &param) : ElewiseUnaryImpl(param) {}
-  virtual ~ExpImpl() {}
-  int Launch() override;
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ELEWISE_UNARY_EXP_IMPL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/kernel/abs_kernel.h

@@ -1,45 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * 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 Absress or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_ABS_KERNEL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_ABS_KERNEL_H_
-
-#include "elewise_unary_base.h"
-
-template <typename T = float>
-class AbsFp32 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline AbsFp32() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Abs); }
-};
-
-template <typename T = half>
-class AbsFp16 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline AbsFp16() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Abs); }
-};
-
-extern "C" __global__ __aicore__ void abs_device(GM_ADDR x, GM_ADDR y, GM_ADDR tiling, int32_t dtype) {
-  if (dtype == 1) {  // fp16
-    AbsFp16<half> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  } else if (dtype == 0) {  // fp32
-    AbsFp32<float> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  }
-}
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_ABS_KERNEL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/kernel/elewise_unary_base.h

@@ -1,148 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * 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.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_ELEWISE_BASE_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_ELEWISE_BASE_H_
-
-#include "kernel_operator.h"
-using namespace AscendC;
-
-template <typename IN_TYPE>
-class ElewiseBaseWide {
- public:
-  __aicore__ inline ElewiseBaseWide(){};
-
-  __aicore__ inline void InitUnary(GM_ADDR in, GM_ADDR out, GM_ADDR tiling) {
-    gm_in1 = reinterpret_cast<__gm__ IN_TYPE *>(in);
-    gm_out = reinterpret_cast<__gm__ IN_TYPE *>(out);
-    SetTilingInfo(tiling);
-  }
-
-  __aicore__ inline void ProcessUnary() { CalculateUnary(); }
-
-  __aicore__ inline void SetUnaryFunc(void (*func)(const LocalTensor<IN_TYPE> &dstLocal,
-                                                   const LocalTensor<IN_TYPE> &srcLocal, const int &calCount)) {
-    elewise_unary_func_ = func;
-  }
-
- private:
-  __aicore__ inline void SetTilingInfo(GM_ADDR tiling) {
-    core_idx = get_block_idx();
-    core_num = get_block_num();
-
-    avg_block_count = (uint32_t)(*((__gm__ uint32_t *)tiling + 0));
-    avg_block_ub_num = (uint32_t)(*((__gm__ uint32_t *)tiling + 1));
-    avg_block_ub_tail = (uint32_t)(*((__gm__ uint32_t *)tiling + 2));
-    avg_block_ub_loop = (uint32_t)(*((__gm__ uint32_t *)tiling + 3));
-    tail_block_count = (uint32_t)(*((__gm__ uint32_t *)tiling + 4));
-    tail_block_ub_num = (uint32_t)(*((__gm__ uint32_t *)tiling + 5));
-    tail_block_ub_tail = (uint32_t)(*((__gm__ uint32_t *)tiling + 6));
-    tail_block_ub_loop = (uint32_t)(*((__gm__ uint32_t *)tiling + 7));
-
-    buffer_num = (uint32_t)(*((__gm__ uint32_t *)tiling + 8));
-  }
-  __aicore__ inline void SetUbParam(uint32_t &ub_count, uint32_t &ub_loop, uint32_t &ub_tail) {
-    ub_count = avg_block_ub_num;
-    ub_loop = avg_block_ub_loop;
-    ub_tail = avg_block_ub_tail;
-
-    if (core_idx == core_num - 1) {
-      ub_count = tail_block_ub_num;
-      ub_loop = tail_block_ub_loop;
-      ub_tail = tail_block_ub_tail;
-    }
-  }
-
-  __aicore__ inline void InitUnaryInOut(uint32_t count) {
-    pipe.InitBuffer(in1Que, buffer_num, count * sizeof(IN_TYPE));
-    pipe.InitBuffer(outQue, buffer_num, count * sizeof(IN_TYPE));
-  }
-
-  __aicore__ inline void CopyOut(uint32_t idx, uint32_t stride, uint32_t count) {
-    LocalTensor<IN_TYPE> out = outQue.DeQue<IN_TYPE>();
-    DataCopy(outGm[idx * stride], out, count);
-    outQue.FreeTensor(out);
-  }
-
-  __aicore__ inline void CopyIn1(uint32_t idx, uint32_t stride, uint32_t count) {
-    LocalTensor<IN_TYPE> in1 = in1Que.AllocTensor<IN_TYPE>();
-    DataCopy(in1, in1Gm[idx * stride], count);
-    in1Que.EnQue(in1);
-  }
-
-  __aicore__ inline void CalculateUnary() {
-    uint32_t ub_count, ub_loop, ub_tail;
-    SetUbParam(ub_count, ub_loop, ub_tail);
-
-    in1Gm.SetGlobalBuffer(gm_in1 + core_idx * avg_block_count);
-    outGm.SetGlobalBuffer(gm_out + core_idx * avg_block_count);
-
-    InitUnaryInOut(ub_count);
-
-    uint32_t loop = 0;
-    for (; loop < ub_loop - 1; loop++) {
-      CopyIn1(loop, ub_count, ub_count);
-      ComputeUnary(ub_count);
-      CopyOut(loop, ub_count, ub_count);
-    }
-
-    /* for ub tail */
-    if (ub_tail <= 0) {
-      return;
-    }
-    CopyIn1(loop, ub_count, ub_tail);
-    ComputeUnary(ub_tail);
-    CopyOut(loop, ub_count, ub_tail);
-  }
-
-  __aicore__ inline void ComputeUnary(uint32_t count) {
-    LocalTensor<IN_TYPE> in1 = in1Que.DeQue<IN_TYPE>();
-    LocalTensor<IN_TYPE> out = outQue.AllocTensor<IN_TYPE>();
-    elewise_unary_func_(out, in1, count);
-    in1Que.FreeTensor(in1);
-    outQue.EnQue(out);
-  }
-
- private:
-  void (*elewise_unary_func_)(const LocalTensor<IN_TYPE> &dstLocal, const LocalTensor<IN_TYPE> &srcLocal,
-                              const int &calCount);
-
-  TPipe pipe;
-  TQue<AscendC::QuePosition::VECIN, 1> in1Que;
-  TQue<AscendC::QuePosition::VECOUT, 1> outQue;
-
-  __gm__ IN_TYPE *__restrict__ gm_in1{nullptr};
-  __gm__ IN_TYPE *__restrict__ gm_out{nullptr};
-
-  GlobalTensor<IN_TYPE> in1Gm;
-  GlobalTensor<IN_TYPE> outGm;
-
-  uint32_t core_idx{0};
-  uint32_t core_num{0};
-  uint32_t buffer_num{0};
-
-  uint32_t avg_block_count{0};
-  uint32_t avg_block_ub_num{0};
-  uint32_t avg_block_ub_tail{0};
-  uint32_t avg_block_ub_loop{0};
-
-  uint32_t tail_block_count{0};
-  uint32_t tail_block_ub_num{0};
-  uint32_t tail_block_ub_tail{0};
-  uint32_t tail_block_ub_loop{0};
-};
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_ELEWISE_BASE_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/kernel/elewise_unary_kernel.h

@@ -1,31 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * 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.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_KERNEL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_KERNEL_H_
-
-void elewise_exp(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling, int dtype);
-void elewise_abs(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling, int dtype);
-void elewise_ln(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling, int dtype);
-void elewise_not(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling, int dtype);
-void elewise_relu(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling, int dtype);
-void elewise_sqrt(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling, int dtype);
-void elewise_rsqrt(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling,
-                   int dtype);
-void elewise_reciprocal(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *in, uint8_t *out, uint8_t *tiling,
-                        int dtype);
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_KERNEL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/kernel/exp_kernel.h

@@ -1,45 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * 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.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_EXP_KERNEL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_EXP_KERNEL_H_
-
-#include "elewise_unary_base.h"
-
-template <typename T = float>
-class ExpFp32 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline ExpFp32() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Exp); }
-};
-
-template <typename T = half>
-class ExpFp16 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline ExpFp16() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Exp); }
-};
-
-extern "C" __global__ __aicore__ void exp_device(GM_ADDR x, GM_ADDR y, GM_ADDR tiling, int32_t dtype) {
-  if (dtype == 1) {  // fp16
-    ExpFp16<half> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  } else if (dtype == 0) {  // fp32
-    ExpFp32<float> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  }
-}
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_EXP_KERNEL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/kernel/ln_kernel.h

@@ -1,45 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * 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 Lnress or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_LN_KERNEL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_LN_KERNEL_H_
-
-#include "elewise_unary_base.h"
-
-template <typename T = float>
-class LnFp32 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline LnFp32() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Ln); }
-};
-
-template <typename T = half>
-class LnFp16 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline LnFp16() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Ln); }
-};
-
-extern "C" __global__ __aicore__ void ln_device(GM_ADDR x, GM_ADDR y, GM_ADDR tiling, int32_t dtype) {
-  if (dtype == 1) {  // fp16
-    LnFp16<half> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  } else if (dtype == 0) {  // fp32
-    LnFp32<float> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  }
-}
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_LN_KERNEL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/kernel/not_kernel.h

@@ -1,45 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * 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.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_NOT_KERNEL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_NOT_KERNEL_H_
-
-#include "elewise_unary_base.h"
-
-template <typename T = int16_t>
-class NotI16 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline NotI16() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Not); }
-};
-
-template <typename T = uint16_t>
-class NotU16 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline NotU16() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Not); }
-};
-
-extern "C" __global__ __aicore__ void not_device(GM_ADDR x, GM_ADDR y, GM_ADDR tiling, int32_t dtype) {
-  if (dtype == 6) {  // int16
-    NotI16<int16_t> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  } else if (dtype == 7) {  // uint16
-    NotU16<uint16_t> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  }
-}
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_NOT_KERNEL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/kernel/reciprocal_kernel.h

@@ -1,45 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * 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.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_RECIPROCAL_KERNEL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_RECIPROCAL_KERNEL_H_
-
-#include "elewise_unary_base.h"
-
-template <typename T = float>
-class ReciprocalFp32 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline ReciprocalFp32() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Reciprocal); }
-};
-
-template <typename T = half>
-class ReciprocalFp16 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline ReciprocalFp16() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Reciprocal); }
-};
-
-extern "C" __global__ __aicore__ void reciprocal_device(GM_ADDR x1, GM_ADDR y, GM_ADDR tiling, int32_t dtype) {
-  if (dtype == 1) {  // fp16
-    ReciprocalFp16<half> op;
-    op.InitUnary(x1, y, tiling);
-    op.ProcessUnary();
-  } else if (dtype == 0) {  // fp32
-    ReciprocalFp32<float> op;
-    op.InitUnary(x1, y, tiling);
-    op.ProcessUnary();
-  }
-}
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_RECIPROCAL_KERNEL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/kernel/relu_kernel.h

@@ -1,55 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * 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.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_RELU_KERNEL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_RELU_KERNEL_H_
-
-#include "elewise_unary_base.h"
-
-template <typename T = float>
-class ReluFp32 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline ReluFp32() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Relu); }
-};
-
-template <typename T = half>
-class ReluFp16 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline ReluFp16() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Relu); }
-};
-
-template <typename T = int32_t>
-class ReluI32 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline ReluI32() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Relu); }
-};
-
-extern "C" __global__ __aicore__ void relu_device(GM_ADDR x, GM_ADDR y, GM_ADDR tiling, int32_t dtype) {
-  if (dtype == 1) {  // fp16
-    ReluFp16<half> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  } else if (dtype == 0) {  // fp32
-    ReluFp32<float> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  } else if (dtype == 3) {  // int32
-    ReluI32<int32_t> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  }
-}
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_RELU_KERNEL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/elewise_unary/kernel/rsqrt_kernel.h

@@ -1,45 +0,0 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
- *
- * 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.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_RSQRT_KERNEL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_RSQRT_KERNEL_H_
-
-#include "elewise_unary_base.h"
-
-template <typename T = float>
-class RsqrtFp32 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline RsqrtFp32() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Rsqrt); }
-};
-
-template <typename T = half>
-class RsqrtFp16 : public ElewiseBaseWide<T> {
- public:
-  __aicore__ inline RsqrtFp16() { ElewiseBaseWide<T>::SetUnaryFunc(AscendC::Rsqrt); }
-};
-
-extern "C" __global__ __aicore__ void rsqrt_device(GM_ADDR x, GM_ADDR y, GM_ADDR tiling, int32_t dtype) {
-  if (dtype == 1) {  // fp16
-    RsqrtFp16<half> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  } else if (dtype == 0) {  // fp32
-    RsqrtFp32<float> op;
-    op.InitUnary(x, y, tiling);
-    op.ProcessUnary();
-  }
-}
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_ELEWISE_UNARY_RSQRT_KERNEL_H_