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/grouped_matmul/kernel/grouped_matmul.h

@@ -1,245 +0,0 @@
-/**
- * Copyright (c) Huawei Technologies Co., Ltd. 2024. 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.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ASCENDC_GROUPED_MATMUL_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_GROUPED_MATMUL_H_
-
-#include "grouped_matmul_utils.h"
-#include "../tiling_data.h"
-
-namespace GROUPED_MATMUL {
-
-#define DTYPE_X half
-#define DTYPE_WEIGHT half
-#define DTYPE_BIAS half
-#define DTYPE_Y half
-
-/*@brief store variables for core split configuration
- */
-struct MNConfig {
-  uint32_t m;
-  uint32_t k;
-  uint32_t n;
-  uint32_t baseM;
-  uint32_t baseN;
-  uint32_t mIdx;
-  uint32_t nIdx;
-  uint32_t blockDimM;
-  uint32_t blockDimN;
-  uint32_t singleM;
-  uint32_t singleN;
-  uint32_t ubBaseN;
-  uint32_t ubCalSize;
-};
-
-/** @brief GroupMatmul operator Class
- */
-template <typename ComputeType>
-class GroupedMatmulProcess {
- private:
-  __aicore__ inline void Process_();
-
-  ComputeType &computeOp;  // inernal computation operator
-  const GroupedMatmulTilingData *__restrict tilingData;
-
-  uint32_t blockIdx;
-  uint32_t subBlockIdx;
-  uint32_t coreIdx;
-  uint32_t groupNum;
-  uint32_t coreNum;
-  uint32_t baseM;
-  uint32_t baseN;
-  uint32_t ubBaseM;
-  uint32_t ubBaseN;
-  uint32_t ubCalSize;
-  uint32_t ubRestBytes;
-
- public:
-  /** @brief constructor */
-  __aicore__ inline GroupedMatmulProcess(ComputeType &computeOp_) : computeOp(computeOp_) {}
-
-  __aicore__ inline void Init(const GroupedMatmulTilingData *__restrict tiling);
-
-  __aicore__ inline void Process();
-};
-
-template <typename ComputeType>
-__aicore__ inline void GroupedMatmulProcess<ComputeType>::Init(const GroupedMatmulTilingData *__restrict tiling) {
-  blockIdx = GetBlockIdx();
-  subBlockIdx = GetSubBlockIdx();
-  coreIdx = blockIdx / GetTaskRation();
-  tilingData = tiling;
-  groupNum = tilingData->groupedMatmulBaseParams.groupNum;
-  baseM = tilingData->mmTilingData.baseM;
-  baseN = tilingData->mmTilingData.baseN;
-  ubBaseM = tilingData->groupedMatmulBaseParams.ubBaseM;
-  ubBaseN = tilingData->groupedMatmulBaseParams.ubBaseN;
-  coreNum = tilingData->groupedMatmulBaseParams.coreNum;
-  ubCalSize = tilingData->groupedMatmulBaseParams.ubCalSize;
-  ubRestBytes = tilingData->groupedMatmulBaseParams.ubRestBytes;
-}
-
-template <typename ComputeType>
-__aicore__ inline void GroupedMatmulProcess<ComputeType>::Process() {
-  auto &ubM = tilingData->groupedMatmulBaseParams.mList;
-  auto &ubK = tilingData->groupedMatmulBaseParams.kList;
-  auto &ubN = tilingData->groupedMatmulBaseParams.nList;
-
-  MNConfig mnConfig;
-  mnConfig.ubBaseN = ubBaseN;
-  mnConfig.ubCalSize = ubCalSize;
-  uint32_t count = 0;
-  uint32_t wOutOffset = 0;  // for antiquant
-  for (uint32_t groupIdx(0); groupIdx < groupNum; ++groupIdx) {
-    mnConfig.m = ubM[groupIdx];
-    mnConfig.k = ubK[groupIdx];
-    mnConfig.n = ubN[groupIdx];
-    uint32_t dimM = Ceil(mnConfig.m, baseM);
-    uint32_t dimN = Ceil(mnConfig.n, baseN);
-    mnConfig.singleM = baseM;
-    mnConfig.singleN = baseN;
-    mnConfig.blockDimM = dimM;
-    mnConfig.blockDimN = dimN;
-
-    uint32_t curCount = count + dimM * dimN;
-    uint32_t curBlock = coreIdx >= count ? coreIdx : coreIdx + coreNum;
-    while (curBlock < curCount) {
-      mnConfig.mIdx = (curBlock - count) / dimN;
-      mnConfig.nIdx = (curBlock - count) % dimN;
-      if ASCEND_IS_AIC {
-        computeOp.MMCompute(groupIdx, mnConfig, subBlockIdx, wOutOffset);
-      }
-      curBlock += coreNum;
-    }
-    wOutOffset += mnConfig.k * mnConfig.n;
-    count = curCount % coreNum;
-  }
-}
-
-/** @brief intenal computation class
- */
-template <class mmType, bool sync = false>
-class GroupedMatmulCompute {
- public:
-  using AT = typename mmType::AT::T;
-  using BT = typename mmType::BT::T;
-  using CT = typename mmType::CT::T;
-  using BiasT = typename mmType::BiasT::T;
-  using WT = DTYPE_WEIGHT;
-
-  /** @brief constructor */
-  __aicore__ inline GroupedMatmulCompute(typename mmType::MT &mm_) : mm(mm_) {}
-
-  __aicore__ inline void Init(GM_ADDR x, GM_ADDR weight, GM_ADDR bias, GM_ADDR scale, GM_ADDR offset,
-                              GM_ADDR antiquantScale, GM_ADDR antiquantOffset, GM_ADDR y, GM_ADDR workspace,
-                              const GroupedMatmulTilingData *__restrict tiling, TPipe *tPipe);
-
-  __aicore__ inline void MMCompute(uint32_t groupIdx, MNConfig &mnConfig, uint32_t subBlockIdx, uint64_t wOutOffset);
-
-  __aicore__ inline void MMSync(bool waitIterateAll, bool &mmWaitStatus, bool &firstMM);
-
-  __aicore__ inline void CastWeightProcess(uint32_t curSingleN, uint64_t wInOffset, uint64_t wOutOffset,
-                                           MNConfig &mnConfig);
-  __aicore__ inline void CastWeightCompute(uint32_t curCalcK, uint32_t curCalcAlignN);
-  __aicore__ inline void DataCopyScaleAndOffset(uint32_t curBaseN, uint32_t alignBaseN, uint64_t scaleOffset,
-                                                uint32_t offsetN);
-
- private:
-  TPipe *pipe;
-  typename mmType::MT &mm;  // matmul operator
-  bool hasBias = false;
-  uint32_t mmDataTypeSize;
-  GM_ADDR xTensorPtr;
-  GM_ADDR weightTensorPtr;
-  GM_ADDR biasTensorPtr;
-  GM_ADDR yTensorPtr;
-  GM_ADDR antiScaleTensorPtr;
-  GM_ADDR antiOffsetTensorPtr;
-  GlobalTensor<AT> xGm;
-  GlobalTensor<BT> weightGm;
-  GlobalTensor<BiasT> biasGm;
-  GlobalTensor<CT> yGm;
-};
-
-template <typename mmType, bool sync>
-__aicore__ inline void GroupedMatmulCompute<mmType, sync>::Init(GM_ADDR x, GM_ADDR weight, GM_ADDR bias, GM_ADDR scale,
-                                                                GM_ADDR offset, GM_ADDR antiquantScale,
-                                                                GM_ADDR antiquantOffset, GM_ADDR y, GM_ADDR workspace,
-                                                                const GroupedMatmulTilingData *__restrict tiling,
-                                                                TPipe *tPipe) {
-  xTensorPtr = x;
-  weightTensorPtr = weight;
-  biasTensorPtr = bias;
-  yTensorPtr = y;
-  pipe = tPipe;
-  if (bias != nullptr && GetTensorAddr<BiasT>(0, biasTensorPtr) != nullptr) {
-    hasBias = true;
-  }
-}
-
-template <typename mmType, bool sync>
-__aicore__ inline void GroupedMatmulCompute<mmType, sync>::MMCompute(uint32_t groupIdx, MNConfig &mnConfig,
-                                                                     uint32_t subBlockIdx, uint64_t wOutOffset) {
-  if (subBlockIdx != 0) {
-    return;
-  }
-
-  uint32_t curSingleN = mnConfig.singleN;
-  uint32_t tailN = mnConfig.nIdx * mnConfig.singleN;
-  if (mnConfig.nIdx == mnConfig.blockDimN - 1) {
-    curSingleN = mnConfig.n - tailN;
-  }
-  uint32_t curSingleM = mnConfig.singleM;
-  if (mnConfig.mIdx == mnConfig.blockDimM - 1) {
-    curSingleM = mnConfig.m - mnConfig.mIdx * curSingleM;
-  }
-  uint64_t xOffset = mnConfig.mIdx * mnConfig.singleM * mnConfig.k;
-  uint64_t wOffset = tailN;
-  uint64_t outOffset = mnConfig.mIdx * mnConfig.singleM * mnConfig.n + tailN;
-  // init global buffer
-  xGm.SetGlobalBuffer(GetTensorAddr<AT>(groupIdx, xTensorPtr));
-  weightGm.SetGlobalBuffer(GetTensorAddr<BT>(groupIdx, weightTensorPtr));
-  yGm.SetGlobalBuffer(GetTensorAddr<CT>(groupIdx, yTensorPtr));
-  mm.SetOrgShape(mnConfig.m, mnConfig.n, mnConfig.k);
-  mm.SetSingleShape(curSingleM, curSingleN, mnConfig.k);
-  mm.SetTensorA(xGm[xOffset]);
-  mm.SetTensorB(weightGm[wOffset]);
-  if (hasBias) {
-    biasGm.SetGlobalBuffer(GetTensorAddr<BiasT>(groupIdx, biasTensorPtr));
-    mm.SetBias(biasGm[tailN]);
-  }
-  mm.template IterateAll<sync>(yGm[outOffset], 0);
-}
-
-template <typename mmType, bool sync>
-__aicore__ inline void GroupedMatmulCompute<mmType, sync>::MMSync(bool waitIterateAll, bool &mmWaitStatus,
-                                                                  bool &firstMM) {
-  if (mmWaitStatus) {
-    mm.WaitIterateAll();
-    mm.End();
-    mmWaitStatus = false;
-  }
-  if (unlikely(firstMM)) {
-    firstMM = false;
-  } else {
-    if (waitIterateAll) {
-      SyncAll<true>();
-    }
-  }
-}
-}  // namespace GROUPED_MATMUL
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_GROUPED_MATMUL_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/grouped_matmul/kernel/grouped_matmul_interface.h

@@ -1,24 +0,0 @@
-/**
- * Copyright (c) Huawei Technologies Co., Ltd. 2024. 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.
- */
-
-#ifndef GROUPED_MATMUL_INTERFACE_H
-#define GROUPED_MATMUL_INTERFACE_H
-
-void grouped_matmul_do(uint32_t blockDim, void *l2ctrl, void *stream, uint8_t *x, uint8_t *weight, uint8_t *bias,
-                       uint8_t *scale, uint8_t *offset, uint8_t *antiquantScale, uint8_t *antiquantOffset,
-                       uint8_t *group_list, uint8_t *y, uint8_t *workspace, uint8_t *tiling);
-
-#endif  // GROUPED_MATMUL_INTERFACE_H

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/grouped_matmul/kernel/grouped_matmul_utils.h

@@ -1,111 +0,0 @@
-/**
- * Copyright (c) Huawei Technologies Co., Ltd. 2024. 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.
- */
-
-#ifndef MS_KERNELS_INTERNAL_KERNEL_ASCENDC_GROUPED_MATMUL_UTILS_H_
-#define MS_KERNELS_INTERNAL_KERNEL_ASCENDC_GROUPED_MATMUL_UTILS_H_
-
-#include "kernel_tiling/kernel_tiling.h"
-#include "kernel_operator.h"
-#include "lib/matmul_intf.h"
-
-namespace GROUPED_MATMUL {
-using namespace AscendC;
-
-constexpr uint32_t UB_BLOCK_UNIT_SIZE = 32;                           // 32: a block has 32 bytes data
-constexpr uint32_t HALF_UB_BLOCK_UNIT_SIZE = UB_BLOCK_UNIT_SIZE / 2;  // 2: a float16 data has two bytes
-
-constexpr MatmulConfig NZ_CFG_MDL = GetMDLConfig(false, false, 0, true, false, false, false);
-
-template <class AT_, class BT_, class CT_, class BiasT_, const MatmulConfig &MM_CFG = CFG_MDL>
-struct MMType {
-  using AT = AT_;
-  using BT = BT_;
-  using CT = CT_;
-  using BiasT = BiasT_;
-  using MT = matmul::Matmul<AT, BT, CT, BiasT, MM_CFG>;
-};
-
-template <class AT_, class BT_, class CT_, class BiasT_, const MatmulConfig &MM_CFG = CFG_MDL>
-struct MMImplType {
-  using AT = AT_;
-  using BT = BT_;
-  using CT = CT_;
-  using BiasT = BiasT_;
-  using MT = matmul::MatmulImpl<AT, BT, CT, BiasT, MM_CFG>;
-};
-
-template <typename T>
-__aicore__ inline T Max(T a, T b) {
-  return a > b ? a : b;
-}
-
-template <typename T>
-__aicore__ inline T Min(T a, T b) {
-  return a > b ? b : a;
-}
-
-template <uint32_t base, typename T = uint32_t>
-__aicore__ inline T AlignUp(T a) {
-  return (a + base - 1) / base * base;
-}
-
-template <typename T>
-__aicore__ inline T AlignUp(T a, T base) {
-  return (a + base - 1) / base * base;
-}
-
-template <typename T>
-__aicore__ inline T AlignDown(T a, T base) {
-  if (unlikely(base == 0)) {
-    return a;
-  }
-  return a / base * base;
-}
-
-template <>
-__aicore__ inline uint32_t AlignUp<4, uint32_t>(uint32_t a) {
-  // to be Multiple of 4, result should be in a format of b(xxxx,x100).
-  // This means last two bits should be zero, requiring that
-  // result = num & b(1111,1100) = num & (~3).
-  // &(~3) operator may reduces num into the range [num, num - 3].
-  // As the result should be no less than a (result >= a), it means num - 3 >= a in the worst case.
-  // In this case, num >= a+3. On the other hand, num should also be less then a+4, otherwise,
-  // the result will not be least multiple of 4 for 3. In other cases like [num, num - 2],
-  // num = a + 3 also satisfies the goal condition.
-  return (a + 3) & ~3;  // & ~3: set last two bits of (a+3) to be zero
-}
-
-template <>
-__aicore__ inline uint32_t AlignUp<16, uint32_t>(uint32_t a) {
-  // In general, if we want to get the least multiple of b (b is the power of 2) for a,
-  // it comes to a conclusion from the above comment: result = (a + (b - 1)) & (~b)
-  return (a + 15) & ~15;  // & ~15: set last four bits of (a+15) to be zero
-}
-
-template <>
-__aicore__ inline uint32_t AlignUp<32, uint32_t>(uint32_t a) {
-  // refer to the above comments.
-  return (a + 31) & ~31;  // & ~31: set last five bits of (a+31) to be zero}
-}
-
-template <typename T>
-__aicore__ inline __gm__ T *GetTensorAddr(uint16_t index, GM_ADDR tensorPtr) {
-  __gm__ uint64_t *dataAddr = reinterpret_cast<__gm__ uint64_t *>(tensorPtr);
-  return reinterpret_cast<__gm__ T *>(*(dataAddr + index));
-}
-}  // namespace GROUPED_MATMUL
-
-#endif  // MS_KERNELS_INTERNAL_KERNEL_ASCENDC_GROUPED_MATMUL_UTILS_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/grouped_matmul/tiling_data.h

@@ -1,54 +0,0 @@
-#ifndef __GROUPED_MATMUL_TILING_DATA_H__
-#define __GROUPED_MATMUL_TILING_DATA_H__
-
-#include <cstdint>
-#include <cstring>
-
-#include "kernel_tiling/kernel_tiling.h"
-
-constexpr uint16_t MAX_TENSOR_CONT = 128;
-
-#pragma pack(1)
-struct GroupedMatmulBaseParams {
-  uint32_t groupNum = 0;
-  uint32_t coreNum = 0;
-  uint32_t activeType = 0;
-  uint32_t ubBaseM = 0;
-  uint32_t ubBaseN = 0;
-  uint32_t ubCalSize = 0;
-  uint32_t ubRestBytes = 0;
-  uint32_t workspaceSize = 0;
-  int32_t mList[MAX_TENSOR_CONT] = {};
-  int32_t kList[MAX_TENSOR_CONT] = {};
-  int32_t nList[MAX_TENSOR_CONT] = {};
-};
-#pragma pack()
-
-#pragma pack(1)
-struct GroupedMatmulCtxParams {
-  uint32_t tilingKey = 0;
-  uint32_t blockDim = 0;
-  uint32_t blockDim2 = 0;
-  uint32_t blockDim3 = 0;
-  uint32_t blockDim4 = 0;
-  uint32_t blockDim5 = 0;
-  uint32_t blockDim6 = 0;
-  uint32_t blockDim7 = 0;
-  uint32_t blockDim8 = 0;
-};
-#pragma pack()
-
-#pragma pack(1)
-struct GroupedMatmulTilingData {
-  GroupedMatmulBaseParams groupedMatmulBaseParams;
-  TCubeTiling mmTilingData;
-  GroupedMatmulCtxParams gmmCtxParams;
-};
-#pragma pack()
-
-#undef GET_TILING_DATA
-#define GET_TILING_DATA(tiling_data, tiling_arg) \
-  GroupedMatmulTilingData tiling_data;           \
-  InitGroupedMatmulTilingData(tiling_arg, &tiling_data)
-
-#endif

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/param/compare_param.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 COMPARE_PARAMS_H_
-#define COMPARE_PARAMS_H_
-
-#include "types.h"
-#include "op_param.h"
-#include <set>
-
-namespace mindspore {
-namespace internal {
-struct CompareParam : public OpParam {
-  DIMS input1_dims_;
-  DIMS input2_dims_;
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/param/elewise_param.h

@@ -1,41 +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 ELEWISE_PARAMS_H_
-#define ELEWISE_PARAMS_H_
-
-#include "types.h"
-#include "op_param.h"
-#include <set>
-namespace mindspore {
-namespace internal {
-#define MAX_ELEWISE_SHAPE_LEN 16
-struct ElewiseBaseParam : public OpParam {
-  size_t dims_;
-  int32_t dtype_;
-};
-
-struct ElewiseUnaryParam : public ElewiseBaseParam {};
-
-struct ElewiseBinaryParam : public ElewiseBaseParam {
-  DIMS input0_dims_;
-  DIMS input1_dims_;
-  uint32_t broadcast_mode_;
-  int64_t in0_shape_[MAX_ELEWISE_SHAPE_LEN];
-  int64_t in1_shape_[MAX_ELEWISE_SHAPE_LEN];
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif  // ELEWISE_PARAMS_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/param/grouped_matmul_param.h

@@ -1,40 +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 GROUPED_MATMUL_PARAMS_H
-#define GROUPED_MATMUL_PARAMS_H
-
-#include "types.h"
-#include "op_param.h"
-
-namespace mindspore {
-namespace internal {
-struct GroupedMatmulParam : public OpParam {
-  /*
-  split_item   inputs       weight       bias         outputs
-        0:     separated    separated    separated    separated
-        1:     integrated   e, k, n      e, n         separated
-        2:     separated    separated    separated    integrated
-        3:     integrated   e, k, n      e, n         integrated
-  */
-  int split_item = 0;
-  int dtype = 0;  // TODO dtype 什么用处
-  bool transpose_weight = false;
-  int group_num = 1;
-  bool has_bias = false;
-};
-}  // namespace internal
-}  // namespace mindspore
-#endif