mindspore 2.1.0__cp39-cp39-win_amd64.whl → 2.2.10__cp39-cp39-win_amd64.whl

mindspore/communication/__init__.py

@@ -18,12 +18,15 @@ Collective communication interface.
 Note that the APIs in the following list need to preset communication environment variables.
 
 For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
-Please see the `Ascend tutorial
-<https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_ascend.html#preparations>`_
+Please see the `rank table Startup
+<https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/rank_table.html>`_
 for more details.
 
-For the GPU devices, users need to prepare the host file and mpi, please see the `GPU tutorial
-<https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_gpu.html#preparation>`_ .
+For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
+<https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/mpirun.html>`_ .
+
+For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster Startup
+<https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/dynamic_cluster.html>`_ .
 """
 
 from mindspore.communication.management import GlobalComm, init, release, get_rank, \

mindspore/communication/_comm_helper.py

@@ -15,6 +15,7 @@
 """comm_helper"""
 
 import os
+import glob
 import ctypes
 
 import sys
@@ -25,6 +26,7 @@ from mindspore.parallel._ps_context import _is_role_worker, _is_role_pserver, _i
                                            _get_ps_context
 from mindspore import log as logger
 from mindspore._c_expression import CollectiveManager, set_cluster_exit_with_exception, MSContext
+from mindspore.common._utils import load_lib
 
 HCCL_LIB = 'libhccl_plugin.so'
 
@@ -35,8 +37,8 @@ def hccl_load_lib():
         base_dir = os.path.dirname(os.path.realpath(__file__))
         lib_path = os.path.join(base_dir, "../lib/plugin/ascend", HCCL_LIB)
         ctypes.CDLL(lib_path)
-    except Exception:
-        raise RuntimeError('Get hccl lib error.')
+    except Exception as exc:
+        raise RuntimeError('Get hccl lib error.') from exc
 
 _HCCL_TEST_AVAILABLE = False
 
@@ -57,6 +59,11 @@ HCCL_WORLD_COMM_GROUP = "hccl_world_group"
 NCCL_WORLD_COMM_GROUP = "nccl_world_group"
 MCCL_WORLD_COMM_GROUP = "mccl_world_group"
 
+DEVICE_TO_BACKEND = {
+    "Ascend": "hccl",
+    "GPU": "nccl",
+    "CPU": "mccl"
+}
 
 class Backend:
     """
@@ -102,8 +109,12 @@ class GlobalComm:
     """
     World communication information. The GlobalComm is a global class. The members contain:
 
-    - ``BACKEND`` : The communication library used, using HCCL/NCCL.
-    - ``WORLD_COMM_GROUP`` : Global communication domain.
+    - ``BACKEND`` : The communication library used, using ``"hccl"`` / ``"nccl"`` / ``"mccl"`` .
+      ``"hccl"`` means Huawei Collective Communication Library(HCCL),
+      ``"nccl"`` means NVIDIA Collective Communication Library(NCCL),
+      ``"mccl"`` means MindSpore Collective Communication Library(MCCL).
+    - ``WORLD_COMM_GROUP`` : Global communication domain,
+      using ``"hccl_world_group"`` / ``"nccl_world_group"`` / ``"mccl_world_group"`` .
     """
     BACKEND = DEFAULT_BACKEND
     WORLD_COMM_GROUP = HCCL_WORLD_COMM_GROUP
@@ -181,6 +192,60 @@ def check_parameter_available(func):
     return wrapper
 
 
+def _is_available():
+    """
+    Returns `True` if distributed module is available.
+
+    Note:
+        Always returns `True` because MindSpore always has distributed ability on all platforms.
+    """
+    return True
+
+
+def _is_initialized():
+    """
+    Checks if distributed module is successfully initialized.
+    """
+    return CollectiveManager.get_instance().initialized()
+
+
+def _get_backend():
+    """
+    Returns the backend of communication process groups.
+
+    Note:
+        Only one communication backend is supported by MindSpore for each process.
+        It should be one of `hccl`/`nccl`/`mccl`.
+    """
+    return GlobalComm.BACKEND
+
+
+def _is_hccl_available():
+    """
+    Checks if `hccl` backend is available.
+    """
+    return _HCCL_TEST_AVAILABLE
+
+
+def _is_nccl_available():
+    """
+    Checks if `nccl` backend is available.
+    """
+    base_dir = os.path.dirname(os.path.realpath(__file__))
+    lib_path = os.path.join(base_dir, "../lib/plugin/gpu*/libnvidia_collective.so")
+    file_paths = glob.glob(lib_path)
+    return all(list(load_lib(f) for f in file_paths))
+
+
+def _is_mpi_available():
+    """
+    Checks if OpenMPI's library is available.
+    """
+    base_dir = os.path.dirname(os.path.realpath(__file__))
+    lib_path = os.path.join(base_dir, "../lib/libmpi_collective.so")
+    return load_lib(lib_path)
+
+
 @check_parameter_available
 def _get_rank_helper(group):
     """
@@ -320,6 +385,20 @@ def _get_group_rank_from_world_rank_helper(world_rank_id, group):
     return group_rank_id
 
 
+@check_parameter_available
+def _get_group_ranks(group):
+    """
+    The Helper to do get_group_ranks.
+
+    Args:
+        group (str): The communication group.
+
+    Returns:
+        List. The ranks of specified group.
+    """
+    return CollectiveManager.get_instance().get_group_ranks(group)
+
+
 @check_parameter_available
 def _create_group_helper(group, rank_ids):
     """

mindspore/communication/management.py

@@ -20,7 +20,7 @@ from mindspore.parallel._ps_context import _is_ps_mode, _is_role_pserver, _is_ro
 from mindspore.communication._comm_helper import Backend, _get_rank_helper, _get_size_helper, \
     _get_world_rank_from_group_rank_helper, _get_group_rank_from_world_rank_helper, \
     _create_group_helper, _destroy_group_helper, HCCL_WORLD_COMM_GROUP, NCCL_WORLD_COMM_GROUP, \
-    MCCL_WORLD_COMM_GROUP, _get_local_rank_helper, _get_local_size_helper, GlobalComm, \
+    MCCL_WORLD_COMM_GROUP, DEVICE_TO_BACKEND, _get_local_rank_helper, _get_local_size_helper, GlobalComm, \
     _check_mpi_envs, _set_elegant_exit_handle
 from mindspore._c_expression import init_hccl, finalize_hccl, init_cluster, MSContext, ms_ctx_param
 
@@ -93,18 +93,20 @@ def _check_parallel_envs():
 
 def init(backend_name=None):
     """
-    Initialize distributed backends required by communication services, e.g. HCCL/NCCL. It is usually used in
-    distributed parallel scenarios and set before using communication services.
+    Initialize distributed backends required by communication services, e.g. ``"hccl"`` / ``"nccl"`` / ``"mccl"``.
+    It is usually used in distributed parallel scenarios and set before using communication services.
 
     Note:
-        - The full name of HCCL is Huawei Collective Communication Library.
-        - The full name of NCCL is NVIDIA Collective Communication Library.
-        - The full name of MCCL is MindSpore Collective Communication Library.
+        - The full name of ``"hccl"`` is Huawei Collective Communication Library(HCCL).
+        - The full name of ``"nccl"`` is NVIDIA Collective Communication Library(NCCL).
+        - The full name of ``"mccl"`` is MindSpore Collective Communication Library(MCCL).
 
     Args:
-        backend_name (str): Backend, using HCCL/NCCL/MCCL. HCCL should be used for Ascend hardware platforms and
-                            NCCL for GPU hardware platforms. If not set, inference is automatically made based on the
-                            hardware platform type (device_target). Default: ``None`` .
+        backend_name (str): Backend, using ``"hccl"`` / ``"nccl"`` / ``"mccl"``.
+                            ``"hccl"`` should be used for Ascend hardware platforms,
+                            ``"nccl"`` for GPU hardware platforms and ``"mccl"`` for CPU hardware platforms.
+                            If not set, inference is automatically made based on the hardware
+                            platform type (device_target). Default: ``None`` .
 
     Raises:
         TypeError: If `backend_name` is not a string.
@@ -120,12 +122,15 @@ def init(backend_name=None):
             Before running the following examples, you need to configure the communication environment variables.
 
             For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
-            Please see the `Ascend tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_ascend.html#preparations>`_
+            Please see the `rank table Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/rank_table.html>`_
             for more details.
 
-            For the GPU devices, users need to prepare the host file and mpi, please see the `GPU tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_gpu.html#preparation>`_ .
+            For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/mpirun.html>`_ .
+
+            For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
+            Startup <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/dynamic_cluster.html>`_ .
 
         >>> from mindspore.communication import init
         >>> init()
@@ -158,29 +163,35 @@ def init(backend_name=None):
                 _set_elegant_exit_handle()
                 return
         if device_target != "Ascend":
-            raise RuntimeError("For 'init', the argument  'backend_name' should be 'Ascend' to init hccl, "
-                               "but got {}".format(device_target))
+            raise RuntimeError("For 'init', the argument 'backend_name' should be '{}' to init '{}', "
+                               "but got 'hccl'.".format(DEVICE_TO_BACKEND[device_target], device_target))
         if not host_init:
             _check_parallel_envs()
         GlobalComm.BACKEND = Backend("hccl")
         init_hccl()
         GlobalComm.WORLD_COMM_GROUP = HCCL_WORLD_COMM_GROUP
     elif backend_name == "nccl":
+        if device_target != "GPU":
+            raise RuntimeError("For 'init', the argument 'backend_name' should be '{}' to init '{}', "
+                               "but got 'nccl'.".format(DEVICE_TO_BACKEND[device_target], device_target))
         init_cluster()
+        GlobalComm.BACKEND = Backend("nccl")
         GlobalComm.WORLD_COMM_GROUP = NCCL_WORLD_COMM_GROUP
     elif backend_name == "mccl":
         init_cluster()
+        GlobalComm.BACKEND = Backend("mccl")
         GlobalComm.WORLD_COMM_GROUP = MCCL_WORLD_COMM_GROUP
     else:
-        raise RuntimeError("For 'init', the argument 'backend_name' must be nccl while 'device_target' is GPU, "
-                           "but got the 'backend_name' : hccl.")
+        raise RuntimeError("For 'init', the argument 'backend_name' must be one of 'hccl', 'nccl' and 'mccl', "
+                           "but got 'backend_name' : {}".format(backend_name))
+
     GlobalComm.INITED = True
     _set_elegant_exit_handle()
 
 
 def release():
     """
-    Release distributed resource. e.g. HCCL/NCCL.
+    Release distributed resource. e.g. HCCL/NCCL/MCCL.
 
     Note:
         This method should be used after init().
@@ -189,19 +200,22 @@ def release():
         RuntimeError: If failed to release distributed resource.
 
     Supported Platforms:
-        ``Ascend`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         .. note::
             Before running the following examples, you need to configure the communication environment variables.
 
             For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
-            Please see the `Ascend tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_ascend.html#preparations>`_
+            Please see the `rank table Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/rank_table.html>`_
             for more details.
 
-            For the GPU devices, users need to prepare the host file and mpi, please see the `GPU tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_gpu.html#preparation>`_ .
+            For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/mpirun.html>`_ .
+
+            For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
+            Startup <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/dynamic_cluster.html>`_ .
 
         >>> from mindspore.communication import init, release
         >>> init()
@@ -227,7 +241,7 @@ def get_rank(group=GlobalComm.WORLD_COMM_GROUP):
     Raises:
         TypeError: If group is not a string.
         ValueError: If backend is invalid.
-        RuntimeError: If HCCL/NCCL is not available.
+        RuntimeError: If HCCL/NCCL/MCCL is not available.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -237,12 +251,15 @@ def get_rank(group=GlobalComm.WORLD_COMM_GROUP):
             Before running the following examples, you need to configure the communication environment variables.
 
             For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
-            Please see the `Ascend tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_ascend.html#preparations>`_
+            Please see the `rank table Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/rank_table.html>`_
             for more details.
 
-            For the GPU devices, users need to prepare the host file and mpi, please see the `GPU tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_gpu.html#preparation>`_ .
+            For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/mpirun.html>`_ .
+
+            For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
+            Startup <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/dynamic_cluster.html>`_ .
 
         >>> from mindspore.communication import init, get_rank
         >>> init()
@@ -261,7 +278,7 @@ def get_local_rank(group=GlobalComm.WORLD_COMM_GROUP):
     Gets local rank ID for current device in specified collective communication group.
 
     Note:
-        GPU version of MindSpore doesn't support this method.
+        This method isn't supported in GPU and CPU versions of MindSpore.
         This method should be used after init().
 
     Args:
@@ -274,7 +291,7 @@ def get_local_rank(group=GlobalComm.WORLD_COMM_GROUP):
     Raises:
         TypeError: If group is not a string.
         ValueError: If backend is invalid.
-        RuntimeError: If HCCL is not available or MindSpore is GPU version.
+        RuntimeError: If HCCL is not available or MindSpore is GPU/CPU version.
 
     Supported Platforms:
         ``Ascend``
@@ -284,15 +301,18 @@ def get_local_rank(group=GlobalComm.WORLD_COMM_GROUP):
             Before running the following examples, you need to configure the communication environment variables.
 
             For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
-            Please see the `Ascend tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_ascend.html#preparations>`_
+            Please see the `rank table Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/rank_table.html>`_
             for more details.
 
-            For the GPU devices, users need to prepare the host file and mpi, please see the `GPU tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_gpu.html#preparation>`_ .
+            For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/mpirun.html>`_ .
+
+            For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
+            Startup <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/dynamic_cluster.html>`_ .
 
         >>> import mindspore as ms
-        >>> from mindspore.communication.management import init, get_rank, get_local_rank
+        >>> from mindspore.communication import init, get_rank, get_local_rank
         >>> ms.set_context(device_target="Ascend")
         >>> ms.set_auto_parallel_context(device_num=16) # 2 server, each server with 8 NPU.
         >>> init()
@@ -324,7 +344,7 @@ def get_group_size(group=GlobalComm.WORLD_COMM_GROUP):
     Raises:
         TypeError: If group is not a string.
         ValueError: If backend is invalid.
-        RuntimeError: If HCCL/NCCL is not available.
+        RuntimeError: If HCCL/NCCL/MCCL is not available.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -334,15 +354,18 @@ def get_group_size(group=GlobalComm.WORLD_COMM_GROUP):
             Before running the following examples, you need to configure the communication environment variables.
 
             For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
-            Please see the `Ascend tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_ascend.html#preparations>`_
+            Please see the `rank table Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/rank_table.html>`_
             for more details.
 
-            For the GPU devices, users need to prepare the host file and mpi, please see the `GPU tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_gpu.html#preparation>`_ .
+            For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/mpirun.html>`_ .
+
+            For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
+            Startup <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/dynamic_cluster.html>`_ .
 
         >>> import mindspore as ms
-        >>> from mindspore.communication.management import init, get_group_size
+        >>> from mindspore.communication import init, get_group_size
         >>> ms.set_auto_parallel_context(device_num=8)
         >>> init()
         >>> group_size = get_group_size()
@@ -360,7 +383,7 @@ def get_local_rank_size(group=GlobalComm.WORLD_COMM_GROUP):
     Gets local rank size of the specified collective communication group.
 
     Note:
-        GPU version of MindSpore doesn't support this method.
+        This method isn't supported in GPU and CPU versions of MindSpore.
         This method should be used after init().
 
     Args:
@@ -373,7 +396,7 @@ def get_local_rank_size(group=GlobalComm.WORLD_COMM_GROUP):
     Raises:
         TypeError: If group is not a string.
         ValueError: If backend is invalid.
-        RuntimeError: If HCCL is not available or MindSpore is GPU version.
+        RuntimeError: If HCCL is not available or MindSpore is GPU/CPU version.
 
     Supported Platforms:
         ``Ascend``
@@ -383,15 +406,18 @@ def get_local_rank_size(group=GlobalComm.WORLD_COMM_GROUP):
             Before running the following examples, you need to configure the communication environment variables.
 
             For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
-            Please see the `Ascend tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_ascend.html#preparations>`_
+            Please see the `rank table Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/rank_table.html>`_
             for more details.
 
-            For the GPU devices, users need to prepare the host file and mpi, please see the `GPU tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_gpu.html#preparation>`_ .
+            For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/mpirun.html>`_ .
+
+            For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
+            Startup <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/dynamic_cluster.html>`_ .
 
         >>> import mindspore as ms
-        >>> from mindspore.communication.management import init, get_local_rank_size
+        >>> from mindspore.communication import init, get_local_rank_size
         >>> ms.set_context(device_target="Ascend")
         >>> ms.set_auto_parallel_context(device_num=16) # 2 server, each server with 8 NPU.
         >>> init()
@@ -411,7 +437,7 @@ def get_world_rank_from_group_rank(group, group_rank_id):
     the rank ID in the specified user communication group.
 
     Note:
-        GPU version of MindSpore doesn't support this method.
+        This method isn't supported in GPU and CPU versions of MindSpore.
         The parameter group should not be "hccl_world_group".
         This method should be used after init().
 
@@ -425,7 +451,7 @@ def get_world_rank_from_group_rank(group, group_rank_id):
     Raises:
         TypeError: If `group_rank_id` is not an integer or the group is not a string.
         ValueError: If group is 'hccl_world_group' or backend is invalid.
-        RuntimeError: If HCCL is not available or MindSpore is GPU version.
+        RuntimeError: If HCCL is not available or MindSpore is GPU/CPU version.
 
     Supported Platforms:
         ``Ascend``
@@ -435,22 +461,27 @@ def get_world_rank_from_group_rank(group, group_rank_id):
             Before running the following examples, you need to configure the communication environment variables.
 
             For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
-            Please see the `Ascend tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_ascend.html#preparations>`_
+            Please see the `rank table Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/rank_table.html>`_
             for more details.
 
-            For the GPU devices, users need to prepare the host file and mpi, please see the `GPU tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_gpu.html#preparation>`_ .
+            For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/mpirun.html>`_
+
+            For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
+            Startup <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/dynamic_cluster.html>`_ .
 
+        >>> import mindspore as ms
         >>> from mindspore import set_context
-        >>> from mindspore.communication.management import init, create_group, get_world_rank_from_group_rank
-        >>> set_context(device_target="Ascend")
+        >>> from mindspore.communication import init, create_group, get_world_rank_from_group_rank, get_rank
+        >>> set_context(mode=ms.GRAPH_MODE, device_target="Ascend")
         >>> init()
         >>> group = "0-4"
         >>> rank_ids = [0,4]
-        >>> create_group(group, rank_ids)
-        >>> world_rank_id = get_world_rank_from_group_rank(group, 1)
-        >>> print("world_rank_id is: ", world_rank_id)
+        >>> if get_rank() in rank_ids:
+        ...     create_group(group, rank_ids)
+        ...     world_rank_id = get_world_rank_from_group_rank(group, 1)
+        ...     print("world_rank_id is: ", world_rank_id)
         world_rank_id is: 4
     """
     if not isinstance(group, str):
@@ -465,7 +496,7 @@ def get_group_rank_from_world_rank(world_rank_id, group):
     the rank ID in the world communication group.
 
     Note:
-        GPU version of MindSpore doesn't support this method.
+        This method isn't supported in GPU and CPU versions of MindSpore.
         The parameter group should not be "hccl_world_group".
         This method should be used after init().
 
@@ -479,7 +510,7 @@ def get_group_rank_from_world_rank(world_rank_id, group):
     Raises:
         TypeError: If world_rank_id is not an integer or the group is not a string.
         ValueError: If group is 'hccl_world_group' or backend is invalid.
-        RuntimeError: If HCCL is not available or MindSpore is GPU version.
+        RuntimeError: If HCCL is not available or MindSpore is GPU/CPU version.
 
     Supported Platforms:
         ``Ascend``
@@ -489,22 +520,27 @@ def get_group_rank_from_world_rank(world_rank_id, group):
             Before running the following examples, you need to configure the communication environment variables.
 
             For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
-            Please see the `Ascend tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_ascend.html#preparations>`_
+            Please see the `rank table Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/rank_table.html>`_
             for more details.
 
-            For the GPU devices, users need to prepare the host file and mpi, please see the `GPU tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_gpu.html#preparation>`_ .
+            For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/mpirun.html>`_
+
+            For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
+            Startup <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/dynamic_cluster.html>`_ .
 
+        >>> import mindspore as ms
         >>> from mindspore import set_context
-        >>> from mindspore.communication.management import init, create_group, get_group_rank_from_world_rank
-        >>> set_context(device_target="Ascend")
+        >>> from mindspore.communication import init, create_group, get_group_rank_from_world_rank, get_rank
+        >>> set_context(mode=ms.GRAPH_MODE, device_target="Ascend")
         >>> init()
         >>> group = "0-4"
         >>> rank_ids = [0,4]
-        >>> create_group(group, rank_ids)
-        >>> group_rank_id = get_group_rank_from_world_rank(4, group)
-        >>> print("group_rank_id is: ", group_rank_id)
+        >>> if get_rank() in rank_ids:
+        ...     create_group(group, rank_ids)
+        ...     group_rank_id = get_group_rank_from_world_rank(4, group)
+        ...     print("group_rank_id is: ", group_rank_id)
         group_rank_id is: 1
     """
     if not isinstance(group, str):
@@ -518,7 +554,7 @@ def create_group(group, rank_ids):
     Create a user collective communication group.
 
     Note:
-        GPU version of MindSpore doesn't support this method.
+        This method isn't supported in GPU and CPU versions of MindSpore.
         The size of rank_ids should be larger than 1, rank_ids should not have duplicate data.
         This method should be used after init().
         Only support global single communication group in PyNative mode if you do not start with mpirun.
@@ -530,7 +566,7 @@ def create_group(group, rank_ids):
     Raises:
         TypeError: If group is not a string or `rank_ids` is not a list.
         ValueError: If `rank_ids` size is not larger than 1, or `rank_ids` has duplicate data, or backend is invalid.
-        RuntimeError: If HCCL is not available or MindSpore is GPU version.
+        RuntimeError: If HCCL is not available or MindSpore is GPU/CPU version.
 
     Supported Platforms:
         ``Ascend``
@@ -540,22 +576,27 @@ def create_group(group, rank_ids):
             Before running the following examples, you need to configure the communication environment variables.
 
             For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
-            Please see the `Ascend tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_ascend.html#preparations>`_
+            Please see the `rank table Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/rank_table.html>`_
             for more details.
 
-            For the GPU devices, users need to prepare the host file and mpi, please see the `GPU tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.1/parallel/train_gpu.html#preparation>`_ .
+            For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/mpirun.html>`_ .
+
+            For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
+            Startup <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/dynamic_cluster.html>`_ .
 
+        >>> import mindspore as ms
         >>> from mindspore import set_context
         >>> import mindspore.ops as ops
-        >>> from mindspore.communication.management import init, create_group
-        >>> set_context(device_target="Ascend")
+        >>> from mindspore.communication import init, create_group, get_rank
+        >>> set_context(mode=ms.GRAPH_MODE, device_target="Ascend")
         >>> init()
-        >>> group = "0-8"
-        >>> rank_ids = [0,8]
-        >>> create_group(group, rank_ids)
-        >>> allreduce = ops.AllReduce(group)
+        >>> group = "0-7"
+        >>> rank_ids = [0,7]
+        >>> if get_rank() in rank_ids:
+        ...     create_group(group, rank_ids)
+        ...     allreduce = ops.AllReduce(group)
     """
     if not isinstance(group, str):
         raise TypeError("For 'create_group', the argument 'group' must be type of string, "
@@ -568,7 +609,7 @@ def destroy_group(group):
     Destroy the user collective communication group.
 
     Note:
-        GPU version of MindSpore doesn't support this method.
+        This method isn't supported in GPU and CPU versions of MindSpore.
         The parameter group should not be "hccl_world_group".
         This method should be used after init().
 
@@ -578,10 +619,37 @@ def destroy_group(group):
     Raises:
         TypeError: If group is not a string.
         ValueError: If group is "hccl_world_group" or backend is invalid.
-        RuntimeError: If HCCL is not available or MindSpore is GPU version.
+        RuntimeError: If HCCL is not available or MindSpore is GPU/CPU version.
 
     Supported Platforms:
         ``Ascend``
+
+    Examples:
+        .. note::
+            Before running the following examples, you need to configure the communication environment variables.
+
+            For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
+            Please see the `rank table startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/rank_table.html>`_
+            for more details.
+
+            For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun startup
+            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/mpirun.html>`_ .
+
+            For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
+            Startup <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/dynamic_cluster.html>`_ .
+
+        >>> import mindspore as ms
+        >>> from mindspore import set_context
+        >>> import mindspore.ops as ops
+        >>> from mindspore.communication import init, create_group, destroy_group, get_rank
+        >>> set_context(mode=ms.GRAPH_MODE, device_target="Ascend")
+        >>> init()
+        >>> group = "0-2"
+        >>> rank_ids = [0,2]
+        >>> if get_rank() in rank_ids:
+        ...     create_group(group, rank_ids)
+        ...     destroy_group(group)
     """
     if not isinstance(group, str):
         raise TypeError("For 'destroy_group', the argument 'group' must be type of string, "