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

mindspore/lib/plugin/ascend/ms_kernels_internal/lccl/include/lcal_comm.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) Huawei Technologies Co., Ltd. 2023. 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 LCAL_COMM_H
+#define LCAL_COMM_H
+
+#include <vector>
+#include <string>
+#include <unordered_map>
+
+#include <lcal_types.h>
+#include <hccl.h>
+
+namespace Lcal {
+constexpr int IPC_NAME_SIZE = 65;
+
+class LcalComm {
+public:
+    LcalComm(int rank, int rankSize, int devId = -1, const std::vector<int> &devList = {});
+    ~LcalComm();
+    LcalComm(const LcalComm &) = delete;
+    LcalComm &operator=(const LcalComm &) = delete;
+    int Init(const std::string &uid = "", int maxBuffSize = LCAL_BUFF_BYTES);
+    int InitThread();
+    int GetRank() const;
+    int GetRankSize() const;
+    const PhysicalInfo &GetPhysicalInfo() const;
+    friend class Lccl;
+    friend class Lcoc;
+
+private:
+    int SetIpcPid(const char *name, const uint32_t *pids) const;
+    int OpenIpcMem(const char names[LCAL_MAX_RANK_SIZE][IPC_NAME_SIZE]);
+    int GetDev();
+    int GetDevThread();
+    int EnablePeerAccess();
+    int InitCommMem(int maxBuffSize);
+    int InitCommon();
+    void FreePeerMem(int8_t *&mem);
+    int InitMem(int maxBuffSize);
+    int GetPid(uint32_t *pids);
+    int GetName(const char *name, char names[LCAL_MAX_RANK_SIZE][IPC_NAME_SIZE]);
+
+private:
+    std::string shmName_ = "lccl";
+    int rank_ = 0;
+    int rankSize_ = 0;
+    int devId_ = 0;
+    bool inited_ = false;
+    std::vector<int> devList_;
+    int8_t *peerMem_[LCAL_MAX_RANK_SIZE] = {}; // shared ping pong buff
+    std::unordered_map<std::string, const char *> kernelNameMap_;
+    PhysicalInfo physicalInfo_ = {};
+    bool deterministic_ = false;
+};
+} // Lcal
+
+#endif // LCAL_COMM_H

mindspore/lib/plugin/ascend/ms_kernels_internal/lccl/include/lcal_types.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) Huawei Technologies Co., Ltd. 2023. 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 LCAL_TYPES_H
+#define LCAL_TYPES_H
+
+#include <cstdint>
+#include <hccl_types.h>
+#include <map>
+#include <string>
+
+namespace Lcal {
+constexpr int LCAL_SUCCESS = 0;
+constexpr int LCAL_ERROR_NOT_INITIALIZED = -1;
+constexpr int LCAL_ERROR_ASDRT = -2;
+constexpr int LCAL_ERROR_PARA_CHECK_FAIL = -3;
+constexpr int LCAL_ERROR_INTERNAL = -4;
+constexpr int LCAL_ERROR_TIMEOUT = -5;
+constexpr int LCCL_ERROR_INIT_HCCL_FAILED = -6;
+constexpr int64_t LCAL_INVALID_VALUE = -1;
+constexpr int LCAL_BUFF_BYTES = 202 * 1024 * 1024; // shared buffer size
+constexpr int LCAL_MAX_RANK_SIZE = 8;
+
+constexpr uint32_t ALIGN_BYTES = 512;
+
+enum class ChipName {
+    CHIP_310P3,
+    CHIP_910B1,
+    CHIP_910B2,
+    CHIP_910B3,
+    CHIP_910B4,
+    RESERVED,
+};
+
+enum class PhysicalLink {
+    HCCS = 0,
+    PCIE = 1,
+    RESERVED,
+};
+
+// 包含 物理链路、芯片名称 信息。
+struct PhysicalInfo {
+    ChipName chipName = ChipName::RESERVED;
+    PhysicalLink physicalLink = PhysicalLink::RESERVED;
+    uint32_t coreNum = 0;
+};
+
+enum class LcalType {
+    ALL_REDUCE = 1,
+    REDUCE_SCATTER = 2,
+    ALL_GATHER = 3,
+    BROADCAST = 4,
+    ALL2ALL = 5,
+    PURE_MATMUL = 101,
+    MATMUL_ALL_REDUCE = 102,
+    MATMUL_REDUCE_SCATTER = 103,
+    ALL_GATHER_MATMUL = 104,
+    ALL_GATHER_MATMUL_V2 = 105,
+    ALL2ALL_MATMUL = 106,
+    MATMUL_ALL2ALL = 107,
+    MTE2_TEST = 108,
+    MATMUL_ALL_REDUCE_DETERMINISTIC = 109,
+    MATMUL_REDUCE_SCATTER_DETERMINISTIC = 110,
+    LCAL_TYPE_MAX = 111,
+};
+
+const std::map<LcalType, std::string> LCAL_TYPE2NAME = {
+    { LcalType::ALL_REDUCE, "LcalAllReduce" },
+    { LcalType::REDUCE_SCATTER, "LcalReduceScatter" },
+    { LcalType::ALL_GATHER, "LcalAllGather" },
+    { LcalType::BROADCAST, "LcalBroadcast" },
+    { LcalType::ALL2ALL, "LcalAll2All" },
+    { LcalType::PURE_MATMUL, "LcalPureMatmul" },
+    { LcalType::MATMUL_ALL_REDUCE, "LcalMatmulAllReduce" },
+    { LcalType::MATMUL_REDUCE_SCATTER, "LcalMatmulReduceScatter" },
+    { LcalType::ALL_GATHER_MATMUL, "LcalAllGatherMatmul" },
+    { LcalType::ALL_GATHER_MATMUL_V2, "LcalAllGatherMatmulV2" },
+    { LcalType::ALL2ALL_MATMUL, "LcalAll2AllMatmul" },
+    { LcalType::MATMUL_ALL2ALL, "LcalMatmulAll2All" },
+    { LcalType::MTE2_TEST, "LcalMTE2Test" },
+    { LcalType::MATMUL_ALL_REDUCE_DETERMINISTIC, "LcalMatmulAllReduceDeterministic" },
+    { LcalType::MATMUL_REDUCE_SCATTER_DETERMINISTIC, "LcalMatmulReduceScatterDeterministic" },
+};
+
+const std::map<LcalType, LcalType> NORMAL2DETERMINISTIC = {
+    { LcalType::MATMUL_ALL_REDUCE, LcalType::MATMUL_ALL_REDUCE_DETERMINISTIC },
+    { LcalType::MATMUL_REDUCE_SCATTER, LcalType::MATMUL_REDUCE_SCATTER_DETERMINISTIC }
+};
+
+} // namespace Lcal
+#endif // LCAL_TYPES_H

mindspore/lib/plugin/ascend/ms_kernels_internal/lccl/include/lccl.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Huawei Technologies Co., Ltd. 2023. 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 LACL_LCCL_H
+#define LACL_LCCL_H
+
+#include <lcal_comm.h>
+
+
+namespace Lcal {
+class Lccl {
+public:
+    Lccl(LcalComm &comm);
+    ~Lccl();
+    int Init(const std::string &uid = "", int maxBuffSize = LCAL_BUFF_BYTES);
+    int InitThread();
+    int AllReduce(void *sendBuff, void *recvBuff, int64_t count, HcclDataType dataType,
+        HcclReduceOp op = HCCL_REDUCE_SUM, aclrtStream stream = nullptr);
+    int ReduceScatter(void *sendBuff, void *recvBuff, int64_t count, HcclDataType dataType,
+        HcclReduceOp op = HCCL_REDUCE_SUM, aclrtStream stream = nullptr);
+    int AllGather(void *sendBuff, void *recvBuff, int64_t count, HcclDataType dataType, aclrtStream stream = nullptr);
+    int All2All(void *sendBuff, void *recvBuff, int64_t count, HcclDataType dataType, aclrtStream stream = nullptr);
+    int Broadcast(void *buff, int64_t count, HcclDataType dataType, int32_t root, aclrtStream stream = nullptr);
+
+private:
+    bool CheckDataType(const HcclDataType &dataType) const;
+    int LoopBack(void *sendBuff, void *recvBuff, int64_t count, HcclDataType dataType);
+
+private:
+    LcalComm &comm_;
+    int rank_ = 0;
+    int rankSize_ = 0;
+};
+}
+#endif // LACL_LCCL_H

mindspore/lib/plugin/ascend/ms_kernels_internal/lccl/include/lccl_wrapper.h

@@ -0,0 +1,58 @@
+/**
+ * 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 LCCL_WRAPPER_H_
+#define LCCL_WRAPPER_H_
+
+#include <memory>
+#include "lccl.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+using namespace Lcal;
+using LcclComm = std::shared_ptr<Lccl>;
+enum class LcclResult {
+    LCAL_SUCCESS = 0,
+    LCAL_ERROR_NOT_INITIALIZED = -1,
+    LCAL_ERROR_ASDRT = -2,
+    LCAL_ERROR_PARA_CHECK_FAIL = -3,
+    LCAL_ERROR_INTERNAL = -4,
+    LCAL_ERROR_TIMEOUT = -5,
+    LCCL_ERROR_INIT_HCCL_FAILED = -6
+};
+
+extern LcclResult LcclCommInitRank(uint32_t nRanks, uint32_t rank, LcclComm *comm);
+
+extern LcclResult LcclAllReduce(void *sendBuff, void *recvBuff, int64_t count, HcclDataType dataType,
+                                HcclReduceOp op, aclrtStream stream);
+
+extern LcclResult LcclReduceScatter(void *sendBuff, void *recvBuff, int64_t count, HcclDataType dataType,
+                                    HcclReduceOp op, aclrtStream stream);
+
+extern LcclResult LcclAllGather(void *sendBuff, void *recvBuff, int64_t count, HcclDataType dataType, aclrtStream stream);
+
+extern LcclResult LcclAll2All(void *sendBuff, void *recvBuff, int64_t count, HcclDataType dataType, aclrtStream stream);
+
+extern LcclResult LcclBroadcast(void *buff, int64_t count, HcclDataType dataType, int32_t root, aclrtStream stream);
+
+extern LcclResult LcclCommDestroy(LcclComm comm);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // LCCL_WRAPPER_H_

mindspore/lib/plugin/ascend/ms_kernels_internal/lccl/include/lcoc.h

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) Huawei Technologies Co., Ltd. 2023. 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 LCAL_LCOC_H
+#define LCAL_LCOC_H
+
+#include <lcal_comm.h>
+
+namespace Lcal {
+enum CoCDataTypeDesc : int {
+    COC_DATA_TYPE_UNDEFINED = -1,
+    FP16FP16_FP32_FP16 = 0, // 无量化，无反量化
+    BF16BF16_FP32_BF16 = 1, // 无量化，无反量化
+    INT8INT8_INT32_FP16 = 2, // W8A8，未融合量化，随路反量化
+    INT8INT8_INT32_BF16 = 3, // W8A8，未融合量化，aiv反量化
+    FP16INT8_INT32_FP16 = 4, // W8A8，融合量化，随路反量化
+    BF16INT8_INT32_BF16 = 5, // W8A8，融合量化，aiv反量化
+    FP16INT8_FP32_FP16 = 6, // W8A16，融合伪量化，无反量化
+    BF16INT8_FP32_BF16 = 7, // W8A16，融合伪量化，无反量化
+    FP16INT4_FP32_FP16 = 8, // W4A16，融合伪量化，无反量化
+    BF16INT4_FP32_BF16 = 9, // W4A16，融合伪量化，无反量化
+    COC_DATA_TYPE_DESC_MAX = 10,
+};
+
+struct MatMulInfo {
+    int64_t batchSize = 1;
+    int64_t m = -1;
+    int64_t k = -1;
+    int64_t n = -1;
+    bool transA = false;
+    bool transB = false;
+    bool withBias = false;
+    bool isInt8 = false;
+};
+
+enum QuantGranularity : int {
+    QUANT_GRANULARITY_UNDEFINED = -1,
+    PER_TENSOR = 0,
+    PER_CHANNEL = 1,
+    PER_GROUP = 2,
+    QUANT_GRANULARITY_MAX = 3,
+};
+
+struct QuantInfo {
+    QuantGranularity dequantGranularity = QuantGranularity::QUANT_GRANULARITY_UNDEFINED; // 反量化（包括Matmul前置伪量化和后置反量化）粒度
+    int32_t dequantGroupSize = -1;
+
+    QuantGranularity quantGranularity = QuantGranularity::QUANT_GRANULARITY_UNDEFINED; // 量化粒度
+    int32_t quantGroupSize = -1;
+};
+
+struct CoCParamDesc {
+    CoCDataTypeDesc dataTypeDesc = FP16FP16_FP32_FP16;
+    MatMulInfo mmInfo = {};
+    QuantInfo quantInfo = {};
+    HcclReduceOp op = HCCL_REDUCE_SUM; // 当前不支持其他值
+};
+
+struct CoCTiling {
+    int32_t m0 = -1;
+    int32_t k0 = -1;
+    int32_t n0 = -1;
+    int32_t swizzlDirect = -1;
+    int32_t swizzlCount = -1;
+    int32_t splitK = -1;
+    int32_t ubMoveNum = -1;
+    int32_t pValue = -1;
+    int32_t write2OtherRank = -1;
+    int32_t blockDim = -1;
+    int32_t withSerialMode = -1;
+};
+
+struct CoCInputPkg {
+    void *matrixA = nullptr;
+    void *matrixB = nullptr;
+    void *bias = nullptr;
+
+    void *dequantScale = nullptr; // 反量化参数，当融合了Matmul前置伪量化或后置反量化操作时需要传入
+    void *dequantOffset = nullptr; // 可选，若无offset（如对称量化场景），传入空指针即可
+
+    void *quantScale = nullptr; // 量化参数，当融合了量化操作时需要传入
+    void *quantOffset = nullptr; // 可选，若无offset（如对称量化场景），传入空指针即可
+};
+
+struct CoCOutputPkg{
+    void *output = nullptr;
+    void *midOutput = nullptr; // 先通信后计算情况下，通信的中间结果
+};
+
+class Lcoc {
+public:
+    explicit Lcoc(LcalComm &comm);
+    ~Lcoc();
+    int Init(const std::string &uid = "", int maxBuffSize = LCAL_BUFF_BYTES);
+    int SetParam(LcalType lcalType, const CoCTiling &tiling, const CoCParamDesc &paramDesc);
+    int MTE2Test(CoCInputPkg inputPkg, CoCOutputPkg outputPkg, void *workspace, aclrtStream stream = nullptr);
+    int All2AllMatmul(CoCInputPkg inputPkg, CoCOutputPkg outputPkg, void *workspace, aclrtStream stream = nullptr);
+    int AllGatherMatmul(CoCInputPkg inputPkg, CoCOutputPkg outputPkg, void *workspace, aclrtStream stream = nullptr);
+    int AllGatherMatmulV2(CoCInputPkg inputPkg, CoCOutputPkg outputPkg, void *workspace, aclrtStream stream = nullptr);
+    int MatmulReduceScatter(CoCInputPkg inputPkg, CoCOutputPkg outputPkg, void *workspace,
+        aclrtStream stream = nullptr);
+    int MatmulAllReduce(CoCInputPkg inputPkg, CoCOutputPkg outputPkg, void *workspace, aclrtStream stream = nullptr);
+    int PureMatmul(CoCInputPkg inputPkg, CoCOutputPkg outputPkg, void *workspace, aclrtStream stream = nullptr);
+    int64_t GetWorkspaceSize();
+    LcalComm &GetComm();
+    MatMulInfo &GetMatMulInfo();
+    int32_t GetEleSize();
+    void GetTiling(CoCTiling &tiling);
+
+private:
+    bool CheckDataType() const;
+    bool InitTiling(const CoCTiling &tiling);
+    int LaunchOperator(CoCInputPkg &inputPkg, CoCOutputPkg &outputPkg, void *workspace, aclrtStream stream);
+    bool CheckBasic(const CoCInputPkg &inputPkg, const CoCOutputPkg &outputPkg, LcalType lcalType);
+
+private:
+    LcalComm &comm_;
+    LcalType lcalType_ = LcalType::ALL_REDUCE;
+    CoCParamDesc paramDesc_ = {};
+    CoCTiling tiling_ = {};
+    int rank_ = 0;
+    int rankSize_ = 0;
+    bool tilingSuccess_ = false;
+};
+
+struct WorkspaceDetail {
+    int64_t matrixActivationSize{ 0 };
+    int64_t matrixWeightSize{ 0 };
+    int64_t matrixIntermediateSize{ 0 };
+    int64_t formatDequantParamSize{ 0 };
+
+    int64_t GetSize() const
+    {
+        return matrixActivationSize + matrixWeightSize + matrixIntermediateSize + formatDequantParamSize;
+    }
+};
+
+WorkspaceDetail GetWorkspaceDetail(CoCDataTypeDesc dataType, const MatMulInfo &mmInfo, const QuantInfo &quantInfo);
+
+void GetLcalTypeByDeterministic(LcalType &lcalType, bool deterministic);
+}
+#endif // LCAL_LCOC_H

mindspore/log.py

@@ -234,11 +234,11 @@ def get_level():
 
     Examples:
         >>> import os
+        >>> os.environ['GLOG_v'] = '3'
         >>> import mindspore as ms
-        >>> os.environ['GLOG_v'] = '0'
         >>> level = ms.get_level()
         >>> print(level)
-        '0'
+        '3'
     """
     # level and glog level mapping dictionary
     level_to_glog_level = dict(zip(_name_to_level.values(), _gloglevel_to_name.keys()))