diff --git a/docs/mindspore/source_en/design/sharding_propagation.md b/docs/mindspore/source_en/design/sharding_propagation.md
index c4e8ee6a837d80fdae9967945f3c622dddaf34bb..c8259837e5e39ef0dd0bda73607ab9e8b2de6304 100644
--- a/docs/mindspore/source_en/design/sharding_propagation.md
+++ b/docs/mindspore/source_en/design/sharding_propagation.md
@@ -12,7 +12,7 @@ In op-level parallelism, we conduct SPMD (Single Program Multiple Data) style pa
 
 Distributed Operator: together, the distributed operators running on multiple devices preserve the same semantics of the stand-alone counterpart. That is, given the same input, the distributed operators’ output is the same as the stand-alone counterpart.
 
-Say a matrix multiplication (MatMul) operator with two matrix X and W as input: Y = MatMul(X, W) is to be parallelized on 4 devices. If X is replicated on 4 devices and W is partitioned along the column dimension, then after the transformation, MatMul is the distributed operator on each device. If X is partitioned along the column dimension and W is partitioned along the row dimension, then MatMul followed by AllReduce are distributed operators on each device.
+Say a matrix multiplication (MatMul) operator with two matrix X and W as input: Y = MatMul(X, W) is to be parallelized on 4 devices. If matrix X has copies on 4 devices, and W is split into 4 copies by column, one for each device, then the distributed operator corresponding to the stand-alone version of the MatMul operator is also MatMul, that is, MatMul operator is executed on each device. If X is split into 4 parts according to the column, W is cut into 4 parts by row, and each device gets a shard of X and W, then the distributed operator corresponding to the stand-alone version of the MatMul operator is MatMul->AllReduce, that is, the two operators of MatMul and AllReduce will be executed sequentially on each device to ensure mathematical equivalence.
 
 Besides the SP (Single Program) part, MD (Multiple Data) part also needs to be specified. Before that, we first define the Sharding Strategy.
 
@@ -20,17 +20,17 @@ Besides the SP (Single Program) part, MD (Multiple Data) part also needs to be s
 
 Sharding Strategy: a Sharding Strategy for an operator is a two-dimensional array, specifying how many partitions to split each dimension of each input tensor for the operator.
 
-Derived from the Sharding Strategy, Tensor Layout is defined to specify how a tensor is distributed across devices.
+From the sharding strategy, you can derive the **Tensor Layout** to describe how tensors are distributed across devices.
 
 ### Tensor Layout
 
-Tensor Layout: given a Sharding Strategy for an operator, the Tensor Layout is inferred to describe the distributions of the input tensors of the operator, which includes the **Logical Device Matrix** and the **Tensor Map**. The Logical Device Matrix is an one-dimensional array, describing how devices are arranged for the operator. The Tensor Map the dimensions of input tensors to dimensions of the device matrix, indicating that input tensors are partitioned across the Logical Device Matrix.
+Tensor Layout: given a Sharding Strategy for an operator, the **Tensor Layout** is inferred to describe the distributions of the input tensors of the operator, which includes the **Logical Device Matrix** and the **Tensor Map**. The Logical Device Matrix is an one-dimensional array, describing how devices are arranged for the operator. The Tensor Map the dimensions of input tensors to dimensions of the device matrix, indicating that input tensors are partitioned across the Logical Device Matrix.
 
 Use again the MatMul operator Y = MatMul(X, W). We configure the operator with Sharding Strategy [[2, 1], [1, 4]] and the corresponding Tensor Layout information is demonstrated in the following figure. X is partitioned into 2 parts along the row dimension, and W is partitioned into 4 parts along the column dimension (figure (b)). From the Sharding Strategy, the Logical Device Matrix and the Tensor Map are inferred, as shown in figure (c). The coordinates are also determined to describe the locations of devices in the Logical Device Matrix, based on which the distributions of tensors are determined. From the ‘2’ column in the coordinate table, Device 0—3 are assigned X<sub>0</sub>, while Device 4—7 are assigned X<sub>1</sub>. From the ‘4’ column in the coordinate table, Device 0 and Device 4 are assigned W<sub>0</sub>, Device 1 and Device 5 are assigned W<sub>1</sub>, Device 2 and Device 6 are assigned W<sub>2</sub>, and Device 3 and Device 7 are assigned W<sub>3</sub>. As a result, the local computation is determined, as shown in figure (d).
 
 ![tensor_layout](./images/tensor_layout.png "From Sharding Strategy, Tensor Layout and local computation are inferred.")
 
-For two consecutive operators that are dependent, the Tensor Layouts defined by two operators may be inconsistent, due to either Logical Device Matrix or Tensor Map. We propose an algorithm, called Tensor Redistribution, that transforms the inconsistent Tensor Layout. We omit the algorithm here, and only give a definition.
+For two consecutive operators that are dependent, the Tensor Layouts defined by two operators may be inconsistent, due to either Logical Device Matrix or Tensor Map. We propose an algorithm, called **Tensor Redistribution**, that transforms the inconsistent Tensor Layout. We omit the algorithm here, and only give a definition.
 
 ### Tensor Redistribution
 
@@ -38,13 +38,13 @@ Tensor Redistribution: given two inconsistent Tensor Layouts of a tensor, Tensor
 
 Here, the communication cost is measured by the bytes that each device transmits.
 
-Say a two-operator example: Z = MatMul(X, W), O = MatMul(Z, Y). To make Tensor Redistribution effective, two operators are configured Sharding Strategies so that the Tensor Layouts of Z are inconsistent, as shown in the following figure. In figure (a), the output of the first MatMul is row partitioned, while the second MatMul requires that Z are full-sized. Therefore, an AllGather is inferred by Tensor Redistribution to perform the transformation[1]. In figure (b), an AllToAll in inferred to perform the transformation.
+Say a two-operator example: Z = MatMul(X, W), O = MatMul(Z, Y). To make Tensor Redistribution effective, two operators are configured Sharding Strategies so that the Tensor Layouts of Z are inconsistent, as shown in the following figure. In figure (a), the output of the first MatMul is row partitioned, while the second MatMul requires that Z are full-sized. Therefore, an AllGather is inferred by Tensor Redistribution to perform the transformation[1]. In figure (b), the output tensor Z of the first matrix multiplication operator is row-sliced, while the second matrix multiplicator requires that the tensor Z be split by columns, so the tensor redistribution derivation needs to be inserted here to complete the conversion.
 
 ![tensor_redistribution](./images/tensor_redistribution.png "The full-sized programs with Sharding Strategy, and their corresponding local computation for each device.")
 
 ## Sharding Propagation
 
-Given a computation graph, Sharding Propagation is a functionality that propagates the Sharding Strategies from configured operator to the whole graph, with the goal of minimizing the communication cost in Tensor Redistribution.
+Given a computation graph, **Sharding Propagation** is a functionality that propagates the Sharding Strategies from configured operator to the whole graph, with the goal of minimizing the communication cost in Tensor Redistribution.
 
 The input of Sharding Propagation is a computation graph, in which nodes represent operators, and edges encode the data-dependency relationship of operators. From a model definition with some operators configured Sharding Strategies, Sharding Propagation executes as follows:
 
@@ -58,7 +58,7 @@ The following figure illustrates an example process of applying Sharding Propaga
 
 ## How to use Sharding Propagation in MindSpore
 
-### Preliminaries
+### Sample Code Description
 
 > Download the complete sample code:
 >
diff --git a/docs/mindspore/source_en/design/technical_white_paper.md b/docs/mindspore/source_en/design/technical_white_paper.md
index 3fc17a270a4b71bcfce600581e1073704f30c64f..5099653c3571c71cb4540a545dcd5052e3cb0439 100644
--- a/docs/mindspore/source_en/design/technical_white_paper.md
+++ b/docs/mindspore/source_en/design/technical_white_paper.md
@@ -4,12 +4,30 @@
 
 ## Introduction
 
-Deep learning research and application have experienced explosive development in recent decades, triggering the third wave of artificial intelligence and achieving great success in image recognition, speech recognition and synthesis, unmanned driving, and machine vision. This also poses higher requirements on the algorithm application and dependent frameworks. With the continuous development of deep learning frameworks, a large quantity of computing resources can be conveniently used when neural network models are trained on large datasets.
+Deep learning research and application have experienced explosive development in recent decades, triggering the third wave of artificial intelligence and achieving great success in image recognition, speech recognition and synthesis, unmanned driving, and machine vision. This also poses higher requirements on the algorithm application and dependent frameworks.
 
-Deep learning is a kind of machine learning algorithm that uses a multi-layer structure to automatically learn and extract high-level features from raw data. Generally, it is very difficult to extract high-level abstract features from raw data. There are two mainstream deep learning frameworks. One is to build a static graph before execution to define all operations and network structures, for example, TensorFlow. This method improves the training performance at the cost of usability. The other is dynamic graph computing that is executed immediately, for example, PyTorch. Different from static graphs, dynamic graphs are more flexible and easier to debug, but the performance is sacrificed. Therefore, the existing deep learning framework cannot meet the requirements of easy development and efficient execution at the same time.
+With the continuous development of deep learning frameworks, a large quantity of computing resources can be conveniently used when neural network models are trained on large datasets.
+
+Deep learning is a kind of machine learning algorithm that uses a multi-layer structure to automatically learn and extract high-level features from raw data. Generally, it is very difficult to extract high-level abstract features from raw data.
+
+There are two mainstream deep learning frameworks. One is to build a **static graph** before execution to define all operations and network structures, for example, TensorFlow. This method improves the training performance at the cost of usability. The other is **dynamic graph** computing that is executed immediately, for example, PyTorch.
+
+Different from static graphs, dynamic graphs are more flexible and easier to debug, but the performance is sacrificed. Therefore, the existing deep learning framework cannot meet the requirements of easy development and efficient execution at the same time.
 
 ## Overview
 
-MindSpore is a next-generation deep learning framework that incorporates the best practices of the industry. It best manifests the computing power of the Ascend AI Processor and supports flexible all-scenario deployment across device-edge-cloud. MindSpore creates a brand-new AI programming paradigm and lowers the threshold for AI development. MindSpore aims to achieve easy development, efficient execution, and all-scenario coverage. To facilitate easy development, MindSpore adopts an automatic differentiation (AD) mechanism based on source code transformation (SCT), which can represent complex combinations through control flows. A function is converted into an intermediate representation (IR) which constructs a computational graph that can be parsed and executed on devices. Before execution, multiple software and hardware collaborative optimization technologies are used in the graph to improve performance and efficiency in various scenarios across the device, edge, and cloud. MindSpore supports dynamic graphs for checking the running mode. Thanks to the AD mechanism, the mode switching between dynamic and static graphs becomes very simple. To effectively train large models on large datasets, MindSpore supports data parallel, model parallel, and hybrid parallel training through advanced manual configuration policies, which is highly flexible. In addition, MindSpore supports the automatic parallelism which efficiently searches for a fast parallel strategy in a large strategy space. For details about the advantages of the MindSpore framework,
+MindSpore is a next-generation deep learning framework that incorporates the best practices of the industry. It best manifests the computing power of the Ascend AI Processor and supports flexible all-scenario deployment across device-edge-cloud. MindSpore creates a brand-new AI programming paradigm and lowers the threshold for AI development. MindSpore aims to achieve easy development, efficient execution, and all-scenario coverage.
+
+To facilitate easy development, MindSpore adopts an automatic differentiation (AD) mechanism based on source code transformation (SCT), which can represent complex combinations through control flows. A function is converted into an intermediate representation (IR) which constructs a computational graph that can be parsed and executed on devices.
+
+Before execution, multiple software and hardware collaborative optimization technologies are used in the graph to improve performance and efficiency in various scenarios across the device, edge, and cloud. MindSpore supports dynamic graphs for checking the running mode. Thanks to the AD mechanism, the mode switching between dynamic and static graphs becomes very simple.
+
+To effectively train large models on large datasets, MindSpore supports data parallel, model parallel, and hybrid parallel training through advanced manual configuration policies, which is highly flexible. In addition, MindSpore supports the "automatic parallel" which efficiently searches for a fast parallel strategy in a large strategy space. For details about the advantages of the MindSpore framework,
+
+For the specific benefits of the MindSpore framework, please see the details.
+
+[MindSpore technical white paper](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com:443/white_paper/MindSpore_white_paperV1.1.pdf)
+
+For an introduction to the architecture of the MindSpore framework, check out the beginner tutorial.
 
-see [Technical White Paper](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com:443/white_paper/MindSpore_white_paper_enV1.1.pdf).
+[MindSpore Introduction](https://mindspore.cn/tutorials/en/master/beginner/introduction.html)
\ No newline at end of file
diff --git a/docs/mindspore/source_en/note/env_var_list.md b/docs/mindspore/source_en/note/env_var_list.md
index ff495f0db11121195976ed9ca8be030494051acf..46179d10173ec764cffe1bf8e8310ffaa265e6e5 100644
--- a/docs/mindspore/source_en/note/env_var_list.md
+++ b/docs/mindspore/source_en/note/env_var_list.md
@@ -7,17 +7,20 @@ MindSpore environment variables are as follows:
 | Environment Variable | Module | Function | Type | Value Range | Configuration Relationship | Mandatory or Not | Default Value |
 | --- | --- | --- | --- | --- | --- | --- | --- |
 |MS_BUILD_PROCESS_NUM|MindSpore|Specifies the number of parallel operator build processes during Ascend backend compilation.|Integer|The number of parallel operator build processes ranges from 1 to 24. |None|Optional(Only Ascend backend)|None|
-|MS_COMPILER_CACHE_PATH|MindSpore|MindSpore compile cache directory and save the graph or operator cache files like `graph_cache`,`kernel_meta`,`somas_meta`.|String|File path, which can be a relative path or an absolute path.|None|Optional|None|
+|MS_COMPILER_CACHE_PATH|MindSpore|MindSpore compile cache directory and save the graph or operator cache files like `graph_cache`, `kernel_meta`, `somas_meta`.|String|File path, which can be a relative path or an absolute path.|None|Optional|None|
 |MS_COMPILER_CACHE_ENABLE|MindSpore|Specifies whether to save or load the cache of the graph compiled by front-end. The function is the same as the [enable_compile_cache](https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.set_context.html#mindspore.set_context) in MindSpore context.<br>Note: This environment variable has lower precedence than the context `enable_compile_cache`.|Integer|0: Disable the compile cache<br>1: Enable the compile cache|If it is used together with `MS_COMPILER_CACHE_PATH`, the directory for storing the cache files is `${MS_COMPILER_CACHE_PATH}/rank_${RANK_ID}/graph_cache/`. `RANK_ID` is the unique ID for multi-cards training, the single card scenario defaults to `RANK_ID=0`.|Optional|None|
-|MS_COMPILER_OP_LEVEL|MindSpore|Generate the TBE instruction mapping file during Ascend backend compilation|Integer|The value of compiler op level should be one of [0, 1, 2, 3, 4]. `0`: Turn off op debug and delete op compile cache files; `1`: Turn on debug, generate the `*.cce` and `*_loc.json`; `2`: Turn on debug, generate the `*.cce` and `*_loc.json` files and turn off the compile optimization switch(The CCEC compiler option is set to `-O0-g`) at the same time; `3`: Turn off op debug; `4`: Turn off op debug, generate the `*.cce` and `*_loc.json` files, generate UB fusion calculation description files(`{$kernel_name}_compute.json`) for fusion ops|None|Optional(Only Ascend backend)|None|
+|MS_COMPILER_OP_LEVEL|MindSpore|Enable debug function and generate the TBE instruction mapping file during Ascend backend compilation.|Integer|The value of compiler op level should be one of [0, 1, 2, 3, 4]. `0`: Turn off op debug and delete op compile cache files; `1`: Turn on debug, generate the `*.cce` and `*_loc.json`; `2`: Turn on debug, generate the `*.cce` and `*_loc.json` files and turn off the compile optimization switch(The CCEC compiler option is set to `-O0-g`) at the same time; `3`: Turn off op debug; `4`: Turn off op debug, generate the `*.cce` and `*_loc.json` files, generate UB fusion calculation description files(`{$kernel_name}_compute.json`) for fusion ops|None|Optional(Only Ascend backend)|None|
 |MS_DEV_DISABLE_PREBUILD|MindSpore|Turn off operator prebuild processes during Ascend backend compilation. The prebuild processing may fix the attr `fusion_type` of the operate, and then affect the operator fusion. If the performance of fusion operator can not meet the expectations, try to turn on this environment variable to verify if there is the performance problem of fusion operator.|Boolean|true:turn off prebuild, false: enable prebuild|None|Optional(Only Ascend backend)|None|
-|MS_GRAPH_KERNEL_FLAGS|MindSpore|Control options of graph kernel fusion, it can be used to open or close the graph kernel fusion, supports fine-tune of several optimizations in graph kernel fusion and supports dumping the fusion process, which is helpful in problems location and performance tuning.<br>Note: This environment variable is deprecated from version 1.6 and will be removed in a future version, use the context instead.|String|Refer to the value setting of [graph_kernel_flags](https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.set_context.html#mindspore.set_context) in mindspore/context.py<br>Note: The priority of environment variables is higher than context, that is, if both environment variables and context are set at the same time, only the settings in the environment variables will take effect.|None|Optional|None|
-|RANK_TABLE_FILE|MindSpore|Specifies the file to which a path points, including `DEVICE_IP`s corresponding to multiple Ascend AI Processor `DEVICE_ID`s. |String|File path, which can be a relative path or an absolute path.|This variable is used together with RANK_SIZE. |Optional (when the Ascend AI Processor is used, specified by user when a distributed case is executed)|None|
+|MS_GRAPH_KERNEL_FLAGS|MindSpore|Control options of graph kernel fusion, it can be used to open or close the graph kernel fusion, supports fine-tune of several optimizations in graph kernel fusion and supports dumping the fusion process, which is helpful in problems location and performance tuning.<br>Note: This environment variable is deprecated from version 1.6 and will be removed in a future version, use `graph_kernel_flags` in the context instead.|String|Refer to the value setting of [graph_kernel_flags](https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.set_context.html#mindspore.set_context) in mindspore/context.py<br>Note: The priority of environment variables is higher than context, that is, if both environment variables and context are set at the same time, only the settings in the environment variables will take effect.|None|Optional|None|
+|RANK_TABLE_FILE|MindSpore|Specifies the file to which a path points, including "device_ip" corresponding to multiple Ascend AI Processor "device_id". |String|File path, which can be a relative path or an absolute path.|This variable is used together with RANK_SIZE. |Optional (when the Ascend AI Processor is used, specified by user when a distributed case is executed)|None|
 |RANK_SIZE|MindSpore|Specifies the number of Ascend AI Processors to be called during deep learning. |Integer|The number of Ascend AI Processors to be called ranges from 1 to 8. | This variable is used together with RANK_TABLE_FILE |Optional (when the Ascend AI Processor is used, specified by user when a distributed case is executed) |None|
 |RANK_ID|MindSpore|Specifies the logical ID of the Ascend AI Processor called during deep learning.|Integer|The value ranges from 0 to 7. When multiple servers are running concurrently, `DEVICE_ID`s in different servers may be the same. RANK_ID can be used to avoid this problem. (RANK_ID = SERVER_ID * DEVICE_NUM + DEVICE_ID) |None|Optional|None|
-|GLOG_v|MindSpore|For details about the function and usage, see [GLOG_v](https://www.mindspore.cn/tutorials/experts/en/master/debug/custom_debug.html#log-related-environment-variables-and-configurations)|Integer|0-DEBUG <br>1-INFO <br>2-WARNING <br>3-ERROR|None|Optional|2|
-|GLOG_logtostderr|MindSpore|For details about the function and usage, see [GLOG_logtostderr](https://www.mindspore.cn/tutorials/experts/en/master/debug/custom_debug.html#log-related-environment-variables-and-configurations)|Integer|1:logs are output to the screen <br> 0:logs are output to a file|This variable is used together with GLOG_log_dir|Optional|1|
-|GLOG_log_dir|MindSpore|For details about the function and usage, see [GLOG_log_dir](https://www.mindspore.cn/tutorials/experts/en/master/debug/custom_debug.html#log-related-environment-variables-and-configurations)|String|File path, which can be a relative path or an absolute path.|This variable is used together with GLOG_logtostderr|Optional|None|
+|MS_RDR_ENABLE|MindSpore|Whether to turn on the program running data logger (RDR), if MindSpore has an abnormal operation, it will automatically export the pre-recorded data in MindSpore to assist in locating the cause of the abnormal operation.|Integer|1: Turn on RDR function <br/>0: Turn off RDR function |This variable is used together with `MS_RDR_MODE` and `MS_RDR_PATH`|||
+|MS_RDR_MODE|MindSpore|Specify the mode in which the Data Logger (RDR) is run to export data.|Integer|1: Export data only when the training process terminates abnormally <br/>2: The training process terminates abnormally or exports data at the end of normal times |This variable is used together with `MS_RDR_ENABLE=1`|||
+|MS_RDR_PATH|MindSpore|Configure the root path of the file exported by the program running data logger (RDR).|Integer|Directory paths, only absolute paths are supported |This variable is used together with `MS_RDR_ENABLE=1`. The final RDR file will be saved in the `${MS_RDR_PATH}/rank_${RANK_ID}/rdr/` directory, where `RANK_ID` is the card number in the multi-card training scenario, the default of the single card scene is `RANK_ID=0`.|||
+|GLOG_v|MindSpore|For details about the function and usage, see [GLOG_v](https://www.mindspore.cn/tutorials/experts/en/master/debug/custom_debug.html#log-related-environment-variables-and-configurations).|Integer|0-DEBUG <br>1-INFO <br>2-WARNING <br>3-ERROR|None|Optional|2|
+|GLOG_logtostderr|MindSpore|For details about the function and usage, see [GLOG_logtostderr](https://www.mindspore.cn/tutorials/experts/en/master/debug/custom_debug.html#log-related-environment-variables-and-configurations).|Integer|1:logs are output to the screen <br> 0:logs are output to a file|This variable is used together with GLOG_log_dir|Optional|1|
+|GLOG_log_dir|MindSpore|For details about the function and usage, see [GLOG_log_dir](https://www.mindspore.cn/tutorials/experts/en/master/debug/custom_debug.html#log-related-environment-variables-and-configurations).|String|File path, which can be a relative path or an absolute path.|This variable is used together with GLOG_logtostderr|Optional|None|
 |GLOG_stderrthreshold|For details about the function and usage, see [GLOG_stderrthreshold](https://www.mindspore.cn/tutorials/experts/en/master/debug/custom_debug.html#log-related-environment-variables-and-configurations)|Integer|0-DEBUG <br>1-INFO <br>2-WARNING <br>3-ERROR|None|Optional|2
 |MS_SUBMODULE_LOG_v|MindSpore|For details about the function and usage, see [MS_SUBMODULE_LOG_v](https://www.mindspore.cn/tutorials/experts/en/master/debug/custom_debug.html#log-related-environment-variables-and-configurations)|Dict{String:Integer...}|LogLevel: 0-DEBUG, 1-INFO, 2-WARNING, 3-ERROR<br>SubModual: COMMON, MD, DEBUG, DEVICE, COMMON, IR...|None | Optional|None|
 |GLOG_log_max|MindSpore|For details about the function and usage, see [GLOG_log_max](https://www.mindspore.cn/tutorials/experts/en/master/debug/custom_debug.html#log-related-environment-variables-and-configurations)|Integer|>0|None |Optional|50|
@@ -39,6 +42,6 @@ MindSpore environment variables are as follows:
 |MS_DEBUGGER_HOST|Debugger|Specifies the IP of the MindInsight Debugger Server. |String|IP address of the host where the MindInsight Debugger Server is located. |This variable is used together with ENABLE_MS_DEBUGGER=1 and MS_DEBUGGER_PORT.|Optional|None|
 |MS_DEBUGGER_PORT|Debugger|Specifies the port for connecting to the MindInsight Debugger Server. |Integer|Port number ranges from 1 to 65536. |This variable is used together with ENABLE_MS_DEBUGGER=1 and MS_DEBUGGER_HOST.|Optional|None|
 |MS_DEBUGGER_PARTIAL_MEM|Debugger|Determines whether to enable partial memory overcommitment. (Memory overcommitment is disabled only for nodes selected on Debugger.)|Boolean|1: enables memory overcommitment for nodes selected on Debugger. <br>0: disables memory overcommitment for nodes selected on Debugger. |None|Optional|None|
-|GRAPH_OP_RUN|MindSpore|When running the pipeline large network model in task sink mode in graph mode, it may not be able to start as expected due to the limitation of stream resources. This environment variable can specify the execution mode of the graph mode. set this variable to 1, indicating that model will be executed in nontask sink mode which has performance degradation, otherwise executed in task sink mode. |Integer|0: task sink mode. <br>1: nontask sink mode. |None |Optional |None|
+|GRAPH_OP_RUN|MindSpore|When running the pipeline large network model in task sink mode in graph mode, it may not be able to start as expected due to the limitation of stream resources. This environment variable can specify the execution mode of the graph mode. Set this variable to 1, indicating that model will be executed in nontask sink mode which has performance degradation, otherwise executed in task sink mode. |Integer|0: task sink mode. <br>1: nontask sink mode. |None |Optional |None|
 |GROUP_INFO_FILE|MindSpore|Specify communication group information storage path|String|Communication group information file path, supporting relative path and absolute path. |None|Optional|None|
 |MS_DEV_ENABLE_FALLBACK|MindSpore|Fallback function is enabled when the environment variable is set to a value other than 0. |Integer|1: enables fallback function<br> 0: disables fallback function |None|Optional|1|
diff --git a/docs/mindspore/source_zh_cn/note/env_var_list.md b/docs/mindspore/source_zh_cn/note/env_var_list.md
index 766f7957f5873234eac3352789093bf10f8a887a..f2263eac45f1b7e56cff1b2f8d5b239cc2bb5499 100644
--- a/docs/mindspore/source_zh_cn/note/env_var_list.md
+++ b/docs/mindspore/source_zh_cn/note/env_var_list.md
@@ -9,15 +9,15 @@
 |MS_BUILD_PROCESS_NUM|MindSpore|Ascend后端编译时，指定并行编译进程数|Integer|1~24：允许设置并行进程数取值范围|无|可选（仅Ascend AI处理器环境使用）|无|
 |MS_COMPILER_CACHE_PATH|MindSpore|MindSpore编译缓存目录，存储图和算子编译过程生成的缓存文件，如`graph_cache`,`kernel_meta`，`somas_meta`等|String|缓存文件路径，支持相对路径与绝对路径|无|可选|无|
 |MS_COMPILER_CACHE_ENABLE|MindSpore|指定是否保存和加载前端的图编译缓存。该功能与mindspore context中的[enable_compile_cache](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore/mindspore.set_context.html#mindspore.set_context)相同。<br>注意：该环境变量优先级低于`enable_compile_cache` context。|Integer|0: 关闭前端图编译缓存功能<br>1: 开启前端图编译缓存功能|如果与`MS_COMPILER_CACHE_PATH`一起使用，编译缓存文件将保存在`${MS_COMPILER_CACHE_PATH}/rank_${RANK_ID}/graph_cache/`目录下。其中`RANK_ID`为多卡训练场景中的卡号，单卡场景默认`RANK_ID=0`。|可选|无|
-|MS_COMPILER_OP_LEVEL|MindSpore|Ascend后端编译时，开启debug功能，生成TBE指令映射文件|Integer|0~4，允许设置级别取值范围。0：不开启算子debug功能，删除算子编译缓存文件；1：生成TBE指令映射文件（`*.cce`文件和python-cce映射文件`*_loc.json`），开启debug功能；2：生成TBE指令映射文件（`*.cce`文件和python-cce映射文件`*_loc.json`），开启debug功能，关闭编译优化开关，开启ccec调试功能（ccec编译器选项设置为-O0-g）；3：不开启算子debug功能；4：生成TBE指令映射文件（`*.cce`文件）和UB融合计算描述文件（`{$kernel_name}_compute.json`）|无|可选（仅Ascend AI处理器环境使用）|无|
-|MS_DEV_DISABLE_PREBUILD|MindSpore|Ascend后端编译时，关闭算子预编译，默认不设置此环境变量。算子预编译可能会修正算子注册的fusion_type属性进而影响到算子融合，如遇到融合算子性能较差时，可尝试开启此环境变量验证是否是融合算子本身问题|Boolean|true：关闭预编译，false：使能预编译|无|可选（仅Ascend AI处理器环境使用）|无|
-|MS_GRAPH_KERNEL_FLAGS|MindSpore|图算融合功能的控制选项，可用来开启或关闭图算融合功能、支持对图算融合功能中若干优化的精细控制、支持dump图算融合时的过程数据，用于问题定位和性能调优<br>注意：此环境变量从1.6版本起弃用，后续版本将会删除，请优先使用context中的`graph_kernel_flags`|String|格式和功能同mindspore/context.py中[graph_kernel_flags](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore/mindspore.set_context.html#mindspore.set_context)。<br>注：环境变量优先级高于context，即，若同时设置环境变量和context，则只有环境变量中的设置生效|无|可选|无|
+|MS_COMPILER_OP_LEVEL|MindSpore|Ascend后端编译时，开启debug功能，生成TBE指令映射文件。|Integer|0~4，允许设置级别取值范围。0：不开启算子debug功能，删除算子编译缓存文件；1：生成TBE指令映射文件（`*.cce`文件和python-cce映射文件`*_loc.json`），开启debug功能；2：生成TBE指令映射文件（`*.cce`文件和python-cce映射文件`*_loc.json`），开启debug功能，关闭编译优化开关，开启ccec调试功能（ccec编译器选项设置为-O0-g）；3：不开启算子debug功能；4：生成TBE指令映射文件（`*.cce`文件）和UB融合计算描述文件（`{$kernel_name}_compute.json`）|无|可选（仅Ascend AI处理器环境使用）|无|
+|MS_DEV_DISABLE_PREBUILD|MindSpore|Ascend后端编译时，关闭算子预编译，默认不设置此环境变量。算子预编译可能会修正算子注册的fusion_type属性进而影响到算子融合，如遇到融合算子性能较差时，可尝试开启此环境变量验证是否是融合算子本身问题。|Boolean|true：关闭预编译，false：使能预编译|无|可选（仅Ascend AI处理器环境使用）|无|
+|MS_GRAPH_KERNEL_FLAGS|MindSpore|图算融合功能的控制选项，可用来开启或关闭图算融合功能、支持对图算融合功能中若干优化的精细控制、支持dump图算融合时的过程数据，用于问题定位和性能调优。<br>注意：此环境变量从1.6版本起弃用，后续版本将会删除，请优先使用context中的`graph_kernel_flags`。|String|格式和功能同mindspore/context.py中[graph_kernel_flags](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore/mindspore.set_context.html#mindspore.set_context)。<br>注：环境变量优先级高于context，即，若同时设置环境变量和context，则只有环境变量中的设置生效|无|可选|无|
 |RANK_TABLE_FILE|MindSpore|路径指向文件，包含指定多Ascend AI处理器环境中Ascend AI处理器的"device_id"对应的"device_ip"。|String|文件路径，支持相对路径与绝对路径|与RANK_SIZE配合使用|可选（Ascend AI处理器，使用多卡执行分布式用例时，由用户指定）|无|
-|RANK_SIZE|MindSpore|指定深度学习时调用Ascend AI处理器的数量|Integer|1~8，调用Ascend AI处理器的数量|与RANK_TABLE_FILE配合使用|可选（Ascend AI处理器，使用多卡执行分布式用例时，由用户指定）|无|
-|RANK_ID|MindSpore|指定深度学习时调用Ascend AI处理器的逻辑ID|Integer|0~7，多机并行时不同server中DEVICE_ID会有重复，使用RANK_ID可以避免这个问题（多机并行时 RANK_ID = SERVER_ID * DEVICE_NUM + DEVICE_ID|无|可选|无|
-|MS_RDR_ENABLE|MindSpore|是否开启程序运行数据记录器（RDR），如果MindSpore出现了运行异常，会自动导出MindSpore中预先记录的数据以辅助定位运行异常的原因|Integer|1：开启RDR功能 <br>0：关闭RDR功能|配合`MS_RDR_MODE`与`MS_RDR_PATH`使用|可选|无|
-|MS_RDR_MODE|MindSpore|指定运行数据记录器（RDR）导出数据的模式|Integer|1：仅在训练进程异常终止时导出数据 <br>2：训练进程异常终止或正常结束时导出数据|配合`MS_RDR_ENABLE=1`使用|可选|1|
-|MS_RDR_PATH|MindSpore|配置程序运行数据记录器（RDR）的文件导出的根目录路径|String|目录路径，仅支持绝对路径|配合`MS_RDR_ENABLE=1`使用，最终RDR文件将保存在`${MS_RDR_PATH}/rank_${RANK_ID}/rdr/`目录下。其中`RANK_ID`为多卡训练场景中的卡号，单卡场景默认`RANK_ID=0`。|可选|无|
+|RANK_SIZE|MindSpore|指定深度学习时调用Ascend AI处理器的数量。|Integer|1~8，调用Ascend AI处理器的数量|与RANK_TABLE_FILE配合使用|可选（Ascend AI处理器，使用多卡执行分布式用例时，由用户指定）|无|
+|RANK_ID|MindSpore|指定深度学习时调用Ascend AI处理器的逻辑ID。|Integer|0~7，多机并行时不同server中DEVICE_ID会有重复，使用RANK_ID可以避免这个问题（多机并行时 RANK_ID = SERVER_ID * DEVICE_NUM + DEVICE_ID|无|可选|无|
+|MS_RDR_ENABLE|MindSpore|是否开启程序运行数据记录器（RDR），如果MindSpore出现了运行异常，会自动导出MindSpore中预先记录的数据以辅助定位运行异常的原因。|Integer|1：开启RDR功能 <br>0：关闭RDR功能|配合`MS_RDR_MODE`与`MS_RDR_PATH`使用|可选|无|
+|MS_RDR_MODE|MindSpore|指定运行数据记录器（RDR）导出数据的模式。|Integer|1：仅在训练进程异常终止时导出数据 <br>2：训练进程异常终止或正常结束时导出数据|配合`MS_RDR_ENABLE=1`使用|可选|1|
+|MS_RDR_PATH|MindSpore|配置程序运行数据记录器（RDR）的文件导出的根目录路径。|String|目录路径，仅支持绝对路径|配合`MS_RDR_ENABLE=1`使用，最终RDR文件将保存在`${MS_RDR_PATH}/rank_${RANK_ID}/rdr/`目录下。其中`RANK_ID`为多卡训练场景中的卡号，单卡场景默认`RANK_ID=0`。|可选|无|
 |GLOG_v|MindSpore|[日志功能与用法](https://www.mindspore.cn/tutorials/experts/zh-CN/master/debug/custom_debug.html#日志相关的环境变量和配置)|Integer|0-DEBUG <br>1-INFO <br>2-WARNING <br>3-ERROR|无|可选|2|
 |GLOG_logtostderr|MindSpore|[日志功能与用法](https://www.mindspore.cn/tutorials/experts/zh-CN/master/debug/custom_debug.html#日志相关的环境变量和配置)|Integer|1:日志输出到屏幕 <br> 0:日志输出到文件|与GLOG_log_dir一起使用|可选|1|
 |GLOG_log_dir|MindSpore|[日志功能与用法](https://www.mindspore.cn/tutorials/experts/zh-CN/master/debug/custom_debug.html#日志相关的环境变量和配置)|String|文件路径，支持相对路径与绝对路径|与GLOG_logtostderr一起使用|可选|无|