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/paged_attention/paged_attention_impl.h

@@ -37,6 +37,7 @@ class PagedAttentionImpl : public InternelKernelImpl {
   virtual ~PagedAttentionImpl() = default;
   bool Init(const ValidateInfo &info) override;
   void SetInputs(const std::vector<Tensor *> &inputs) override;
+  void SetOutputs(const std::vector<Tensor *> &outputs) override;
   void SetWorkSpace(const std::vector<DeviceRawBuf> &workspace) override;
   void SetStream(const void *stream_ptr) override;
   void SetDeviceTilingBuf(const DeviceRawBuf &tilingBuf) override;
@@ -45,14 +46,12 @@ class PagedAttentionImpl : public InternelKernelImpl {
   int Tiling(HostRawBuf &tilingBuf) override;
   std::vector<uint64_t> GetWorkSpaceSize() override;
   int InferShape(const std::vector<DIMS> &input_shapes, std::vector<DIMS> &output_shapes) override;
-  bool IsSupported() override;
 
  private:
-  // init val
-  int inner_precise_ = 0;
-  // impl val
-  uint64_t B, N, S, D, G, CORE_NUM, table_block_size, q_seqlen;
+  uint64_t B, N, S, D, G, CORE_NUM, table_block_size;
   bool BFLOAT16, BSH, ALIBI;
+  const std::vector<Tensor *> *inputs_;
+  const std::vector<Tensor *> *outputs_;
   void *stream_ptr_ = nullptr;
   void *workspace_addr = nullptr;
   void *tiling_addr_ = nullptr;

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/paged_attention/paged_attention_tiling.h

@@ -22,6 +22,8 @@ typedef struct {
 #define ROWMAX true
 #define OP_NAME PagedAttention
 #define BUFFER_NUM 4            // 核间流水数，暂不支持修改
+constexpr uint64_t WORKSPACE_MAX_SEQLEN = 16384;    // max seqlen
+constexpr uint64_t WORKSPACE_SIZE = 64 * WORKSPACE_MAX_SEQLEN;
 
 #if BFLOAT16
 #define TYPE_NAME _bf16
@@ -55,14 +57,7 @@ typedef struct {
 // 第四种：全矩阵，LOWER_TRIANGLE、BLOCK_SPARSE和AMASK如果全部关闭，则此attention采用全矩阵运算，不抑制S中的元素
 // *******************************************//
 
-constexpr uint64_t WORKSPACE_MAX_SEQLEN = 16384;
-constexpr uint64_t MAX_ROW = 128;
 constexpr uint64_t WORKSPACE_MAX_SEQLEN_BLOCK = WORKSPACE_MAX_SEQLEN / 16;
-constexpr uint64_t MAX_BN_NUM = 128;
-constexpr uint64_t WORKSPACE_SIZE0 = 64 * WORKSPACE_MAX_SEQLEN;      // for s, p
-constexpr uint64_t WORKSPACE_SIZE1 = MAX_BN_NUM * MAX_ROW * MAX_ROW;    // for o_tmp
-constexpr uint64_t WORKSPACE_SIZE2 = MAX_BN_NUM * MAX_ROW;      // for softmax_max
-constexpr uint64_t WORKSPACE_SIZE3 = MAX_BN_NUM * MAX_ROW;      // for softmax_sum
-constexpr uint64_t WORKSPACE_SIZE = WORKSPACE_SIZE0 + WORKSPACE_SIZE1 + WORKSPACE_SIZE2 + WORKSPACE_SIZE3;
-constexpr uint64_t BUFFER_SIZE = (WORKSPACE_SIZE) * MAX_CORE_NUM * sizeof(uint16_t);
+constexpr uint64_t BUFFER_SIZE = MAX_CORE_NUM * WORKSPACE_SIZE * sizeof(uint16_t);
+
 #endif

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

@@ -16,6 +16,7 @@
 #ifndef ATTENTION_PARAMS_H
 #define ATTENTION_PARAMS_H
 
+#include "types.h"
 #include "op_param.h"
 
 namespace mindspore {
@@ -26,10 +27,6 @@ struct FlashAttentionScoreParam : public OpParam {
   int pre_tokens = 2147483647;
   int next_tokens = 0;
   int sparse_mode = 0;
-  int32_t mask_dtype_ = 0;
-  DIMS mask_dims_;
-
-  bool CanSupportAsd();
 };
 
 struct PagedAttentionParam : public OpParam {
@@ -37,4 +34,4 @@ struct PagedAttentionParam : public OpParam {
 };
 }  // namespace internal
 }  // namespace mindspore
-#endif
+#endif

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

@@ -25,7 +25,6 @@ namespace internal {
 struct MatMulExtParam : public OpParam {
   int input_dtype = -1;
   int weight_dtype = -1;
-  int bias_dtype = -1;
   int output_dtype = -1;
   bool with_relu = false;
   bool with_gelu = false;

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

@@ -22,21 +22,15 @@
 namespace mindspore {
 namespace internal {
 struct MatmulQkvParam : public OpParam {
-  uint32_t n0_len{0};
-  uint32_t n1_len{0};
-  uint32_t n2_len{0};
   bool transposeA;
   bool transposeB;
   MatmulQkvParam() : transposeA(false), transposeB(true) {}
-  MatmulQkvParam(uint32_t n0, uint32_t n1, uint32_t n2, bool tA, bool tB)
-      : n0_len(n0), n1_len(n1), n2_len(n2), transposeA(tA), transposeB(tB) {}
-  bool operator==(const MatmulQkvParam &other) const {
-    return (this->n0_len == other.n0_len && this->n1_len == other.n1_len && this->n2_len == other.n2_len &&
-            this->transposeA == other.transposeA && this->transposeB == other.transposeB);
+  MatmulQkvParam(bool tA, bool tB) : transposeA(tA), transposeB(tB) {}
+  bool operator==(const MatmulQkvParam &other) const { 
+    return (this->transposeA == other.transposeA && this->transposeB == other.transposeB); 
   }
-  int32_t silu_position{-1};
-  bool with_bias{false};
 };
+
 }  // namespace internal
 }  // namespace mindspore
 #endif

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

@@ -27,6 +27,18 @@ struct SubParam : public OpParam {
   TensorDType input2_dtype_;
   DIMS input1_dims_;
   DIMS input2_dims_;
+  bool canSupport() {
+    if (input2_dtype_ != AsdOps::TensorDType::TENSOR_DTYPE_INT32) {
+      return false;
+    }
+    if (input2_dims_.size() == 0 || (input2_dims_.size() == 1 && input2_dims_[0] == 1)) {
+      return true;
+    }
+    if (input1_dims_.size() == 0 || (input1_dims_.size() == 1 && input1_dims_[0] == 1)) {
+      return true;
+    }
+    return false;
+  }
 };
 }  // namespace internal
 }  // namespace mindspore

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/rms_norm/rms_norm_impl.h

@@ -33,7 +33,6 @@ class RmsNormImpl : public InternelKernelImpl {
   int Tiling(HostRawBuf &tilingBuf) override;
   std::vector<uint64_t> GetWorkSpaceSize() override;
   int InferShape(const std::vector<DIMS> &input_shapes, std::vector<DIMS> &output_shapes) override;
-  bool IsSupported() override;
 
  private:
   std::vector<DeviceRawBuf> inputs_device_buf_;

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/sub/sub_impl.h

@@ -34,7 +34,6 @@ class SubImpl : public InternelKernelImpl {
   int Tiling(HostRawBuf &tilingBuf) override;
   std::vector<uint64_t> GetWorkSpaceSize() override;
   int InferShape(const std::vector<DIMS> &input_shapes, std::vector<DIMS> &output_shapes) override;
-  bool IsSupported();
 
  private:
   int32_t GetMaxUbCount(uint32_t in_dtype);

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/tune_repo/matmul_table.h

@@ -20,7 +20,7 @@
 
 /// The key and value of this map are arranged in the following format.
 /// - key: {b_shape, m_shape, k_shape, n_shape, trans_a, trans_b, inDtype, outDtype}
-/// - value : {m0, n0, k0, mLoop, nLoop, kLoop, coreLoop, blockDim, swizzlCount, swizzleDirect}
+/// - value : {m0, n0, k0, mLoop, nLoop, kLoop, coreLoop, blockDim, swizzlCount, swizzlDirect}
 static REPO tlmTuneConfig910B4{
   {{1, 1, 1024, 50257, 0, 1, 2, 2}, {64, 256, 256, 1, 197, 4, 197, 20, 14, 1}},
   {{1, 4, 1024, 1024, 0, 1, 2, 2}, {16, 64, 256, 1, 16, 4, 16, 16, 4, 0}},

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/utils/backend.h

@@ -20,7 +20,8 @@
 
 namespace mindspore {
 namespace internal {
-inline void GetHardwareInfo(HardwareInfo &hwInfo, std::string soc) {
+int GetCoreNum(std::string soc) {
+  HardwareInfo hwInfo;
   if (soc == "Ascend910B2") {
     GetHardwareInfoPPMatmul910B2(hwInfo);
   } else if (soc == "Ascend910B1") {
@@ -30,17 +31,8 @@ inline void GetHardwareInfo(HardwareInfo &hwInfo, std::string soc) {
   } else {
     GetHardwareInfoPPMatmul910B4(hwInfo);
   }
-}
-inline int GetCoreNum(std::string soc) {
-  HardwareInfo hwInfo;
-  GetHardwareInfo(hwInfo, soc);
   return hwInfo.coreNum;
 }
-inline uint32_t GetMaxUbSize(std::string soc) {
-  HardwareInfo hwInfo;
-  GetHardwareInfo(hwInfo, soc);
-  return hwInfo.ubSize;
-}
 }  // namespace internal
 }  // namespace mindspore
 #endif  // MS_KERNELS_INTERNAL_SRC_UTILS_BACKEND_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/utils/elewise_utils.h

@@ -2,21 +2,17 @@
 #define MS_KERNELS_INTERNAL_KERNEL_UTILS_ELEWISE_UTILS_H_
 #include <stdint.h>
 #include <vector>
-#include <functional>
 #include "elewise_tiling.h"
 #include "include/types.h"
-#include "include/param/elewise_param.h"
 namespace mindspore {
 namespace internal {
-#define MAX_COMPARE_SHAPE_LEN MAX_ELEWISE_SHAPE_LEN
+#define MAX_COMPARE_SHAPE_LEN 16
 
-/* infershape */
 int GetBroadcastMode(const int64_t *in_shape0, const int64_t *in_shape1, const size_t ndims, uint32_t *mode);
 int BroadcastInferShape(const int64_t *in_shape0, const int64_t *in_shape1, const size_t ndim, int64_t *output_shape);
 void MakeUpInputShapes(const size_t origin_inshape0_size, const size_t origin_inshape1_size,
                        const int64_t *origin_inshape0, const int64_t *origin_inshape1, size_t *ndim, int64_t *in_shape0,
                        int64_t *in_shape1);
-bool IsScalarTensor(const int64_t *shape, const size_t ndims);
 
 /* elewise tail tiling */
 void ElewiseTailCoreTiling(const uint32_t aligned, const uint32_t total_num, uint32_t &avg_block_count,

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/utils/log/log.h

@@ -20,7 +20,6 @@
 #include "utils/log/log_sink.h"
 #include "utils/log/log_entity.h"
 #include "utils/log/log_tiling.h"
-#include "utils/log/log_utils.h"
 
 #define MSOP_LOG(level) MSOP_LOG_##level
 

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/utils/log/log_tiling.h

@@ -5,8 +5,6 @@
 #include "src/utils/elewise_tiling.h"
 #include "src/compare/compare_tiling.h"
 #include "src/cast/cast_tiling.h"
-#include "src/elewise_binary/elewise_binary_tiling.h"
-#include "src/elewise_unary/elewise_unary_tiling.h"
 #include "src/sub/sub_tiling.h"
 
 namespace mindspore::internal {
@@ -45,21 +43,6 @@ static std::ostream &operator<<(std::ostream &os, const CompareTilingData &dt) {
   os << *ele_tiling;
   return os;
 }
-
-static std::ostream &operator<<(std::ostream &os, const ElewiseBinaryTilingData &dt) {
-  os << "broadcast_mode:" << dt.broadcast_mode_;
-  os << ", op_dtype:" << dt.op_dtype_;
-  ElewiseTailTilingData *ele_tiling = (ElewiseTailTilingData *)&dt;
-  os << *ele_tiling;
-  return os;
-}
-
-static std::ostream &operator<<(std::ostream &os, const ElewiseUnaryTilingData &dt) {
-  os << "op_dtype:" << dt.op_dtype_;
-  ElewiseTailTilingData *ele_tiling = (ElewiseTailTilingData *)&dt;
-  os << *ele_tiling;
-  return os;
-}
 static std::ostream &operator<<(std::ostream &os, const SubTilingData &dt) {
   os << ", broadcast_mode_:" << dt.broadcast_mode_;
   os << ", input_dtype_:" << dt.input_dtype_;

mindspore/lib/plugin/ascend/ms_kernels_internal/internal_kernel/include/utils/math.h

@@ -15,6 +15,11 @@
  */
 #ifndef MS_KERNELS_INTERNAL_SRC_UTILS_MATH_H_
 #define MS_KERNELS_INTERNAL_SRC_UTILS_MATH_H_
-
-#include "src/acme/src/utils/comm_utils.h"
+#include <cstdint>
+namespace mindspore {
+namespace internal {
+#define CeilDiv(dividend, divisor) (((divisor) == 0) ? 0 : (((dividend) + (divisor)-1) / (divisor)))
+#define UpRound(in, round) ((((in) + (round)-1) / (round)) * (round))
+}  // namespace internal
+}  // namespace mindspore
 #endif  // MS_KERNELS_INTERNAL_SRC_UTILS_MATH_H_

mindspore/mindrecord/filewriter.py

@@ -349,7 +349,7 @@ class FileWriter:
 
                 # launch the workers for parallel write
                 self._queue._joincancelled = True  # pylint: disable=W0212
-                p = mp.Process(target=self._write_worker, name="WriterWorker" + str(i), args=(i, self._queue))
+                p = mp.Process(target=self._write_worker, args=(i, self._queue))
                 p.daemon = True
                 p.start()
                 logger.info("Start worker process(pid:{}) to parallel write.".format(p.pid))
@@ -546,7 +546,7 @@ class FileWriter:
             # use parallel index workers to generator index
             self._index_workers = [None] * len(self._paths)
             for index in range(len(self._paths)):
-                p = mp.Process(target=self._index_worker, name="IndexWorker" + str(index), args=(index,))
+                p = mp.Process(target=self._index_worker, args=(index,))
                 p.daemon = True
                 p.start()
                 logger.info("Start worker process(pid:{}) to generate index.".format(p.pid))