diff --git a/mindspore/ccsrc/backend/kernel_compiler/cpu/adam_weight_decay_cpu_kernel.cc b/mindspore/ccsrc/backend/kernel_compiler/cpu/adam_weight_decay_cpu_kernel.cc
index ae3182d97f7..2bdbc7fcc26 100644
--- a/mindspore/ccsrc/backend/kernel_compiler/cpu/adam_weight_decay_cpu_kernel.cc
+++ b/mindspore/ccsrc/backend/kernel_compiler/cpu/adam_weight_decay_cpu_kernel.cc
@@ -26,46 +26,26 @@ namespace mindspore {
 namespace kernel {
 constexpr size_t kSizeFloat16 = sizeof(float16);
 constexpr size_t kSizeFloat32 = sizeof(float);
+constexpr size_t kScalarIndex = 0;
 constexpr size_t kAdamWeightDecayInputSize = 9;
 constexpr size_t kAdamWeightDecayOutputSize = 3;
 
-void AdamWeightDecayCPUKernel::ParallelForAdam(const CTask &task, size_t count) {
-  auto max_thread_num = common::ThreadPool::GetInstance().GetSyncRunThreadNum();
-  const float block_size = 128.0;
-  const float align_size = 16.0;
-  size_t thread_num = count < block_size * max_thread_num ? std::ceil(count / block_size) : max_thread_num;
-  std::vector<common::Task> tasks;
-  size_t start = 0;
-  size_t once_compute_size = align_size * std::ceil(count / (align_size * thread_num));
-  while (start < count) {
-    size_t end = (start + once_compute_size) > count ? count : (start + once_compute_size);
-    auto block = [&, start, end]() {
-      task(start, end);
-      return common::SUCCESS;
-    };
-    tasks.emplace_back(block);
-    start += once_compute_size;
-  }
-  common::ThreadPool::GetInstance().SyncRun(tasks);
-}
-
 template <typename T, typename S>
-void AdamWeightDecayCPUKernel::LaunchFusedAdam(const std::vector<AddressPtr> &inputs,
-                                               const std::vector<AddressPtr> &outputs) {
-  auto var = reinterpret_cast<T *>(inputs[0]->addr);
-  auto m = reinterpret_cast<T *>(inputs[1]->addr);
-  auto v = reinterpret_cast<T *>(inputs[2]->addr);
-  auto lr = reinterpret_cast<T *>(inputs[3]->addr)[0];
-  auto beta1 = reinterpret_cast<T *>(inputs[4]->addr)[0];
-  auto beta2 = reinterpret_cast<T *>(inputs[5]->addr)[0];
-  auto epsilon = reinterpret_cast<T *>(inputs[6]->addr)[0];
-  auto decay = reinterpret_cast<T *>(inputs[7]->addr)[0];
-  auto gradient16 = reinterpret_cast<S *>(inputs[8]->addr);
+void AdamWeightDecayCPUKernel::LaunchFusedAdam(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> &) {
+  auto var = reinterpret_cast<T *>(inputs[VAR]->addr);
+  auto m = reinterpret_cast<T *>(inputs[M]->addr);
+  auto v = reinterpret_cast<T *>(inputs[V]->addr);
+  auto lr = reinterpret_cast<T *>(inputs[LR]->addr)[kScalarIndex];
+  auto beta1 = reinterpret_cast<T *>(inputs[BETA1]->addr)[kScalarIndex];
+  auto beta2 = reinterpret_cast<T *>(inputs[BETA2]->addr)[kScalarIndex];
+  auto epsilon = reinterpret_cast<T *>(inputs[EPSILON]->addr)[kScalarIndex];
+  auto decay = reinterpret_cast<T *>(inputs[DECAY]->addr)[kScalarIndex];
+  auto gradient16 = reinterpret_cast<S *>(inputs[GRAD]->addr);
   const auto beta1_minus = 1 - beta1;
   const auto beta2_minus = 1 - beta2;
 
   // multithreading
-  size_t lens = inputs[0]->size > 0 ? static_cast<size_t>(inputs[0]->size / sizeof(float)) : 1;
+  size_t lens = inputs[VAR]->size > 0 ? static_cast<size_t>(inputs[VAR]->size / sizeof(float)) : 1;
   std::function<void(size_t, size_t)> task;
 
   task = [&](size_t start, size_t end) {
@@ -81,28 +61,27 @@ void AdamWeightDecayCPUKernel::LaunchFusedAdam(const std::vector<AddressPtr> &in
       var[i] -= lr * update;
     }
   };
-  ParallelForAdam(task, lens);
+  CPUKernelUtils::ParallelFor(task, lens);
 }
 
 template <typename T>
 void AdamWeightDecayCPUKernel::LaunchAdamWeightDecay(const std::vector<AddressPtr> &inputs,
-                                                     const std::vector<AddressPtr> &outputs) {
-  auto var = reinterpret_cast<T *>(inputs[0]->addr);
-  auto m = reinterpret_cast<T *>(inputs[1]->addr);
-  auto v = reinterpret_cast<T *>(inputs[2]->addr);
-  auto lr = reinterpret_cast<T *>(inputs[3]->addr)[0];
-  auto beta1 = reinterpret_cast<T *>(inputs[4]->addr)[0];
-  auto beta2 = reinterpret_cast<T *>(inputs[5]->addr)[0];
-  auto epsilon = reinterpret_cast<T *>(inputs[6]->addr)[0];
-  auto decay = reinterpret_cast<T *>(inputs[7]->addr)[0];
-  auto gradient = reinterpret_cast<T *>(inputs[8]->addr);
+                                                     const std::vector<AddressPtr> &) {
+  auto var = reinterpret_cast<T *>(inputs[VAR]->addr);
+  auto m = reinterpret_cast<T *>(inputs[M]->addr);
+  auto v = reinterpret_cast<T *>(inputs[V]->addr);
+  auto lr = reinterpret_cast<T *>(inputs[LR]->addr)[kScalarIndex];
+  auto beta1 = reinterpret_cast<T *>(inputs[BETA1]->addr)[kScalarIndex];
+  auto beta2 = reinterpret_cast<T *>(inputs[BETA2]->addr)[kScalarIndex];
+  auto epsilon = reinterpret_cast<T *>(inputs[EPSILON]->addr)[kScalarIndex];
+  auto decay = reinterpret_cast<T *>(inputs[DECAY]->addr)[kScalarIndex];
+  auto gradient = reinterpret_cast<T *>(inputs[GRAD]->addr);
   const auto beta1_minus = 1 - beta1;
   const auto beta2_minus = 1 - beta2;
 
   // multithreading
-  size_t lens = inputs[0]->size > 0 ? static_cast<size_t>(inputs[0]->size / sizeof(float)) : 1;
+  size_t lens = inputs[VAR]->size > 0 ? static_cast<size_t>(inputs[VAR]->size / sizeof(float)) : 1;
   std::function<void(size_t, size_t)> task;
-
   task = [&](size_t start, size_t end) {
     size_t i = AdamWeightDecayFp32(var, m, v, lr, beta1, beta2, epsilon, decay, gradient, start, end);
     // remaining
@@ -114,14 +93,14 @@ void AdamWeightDecayCPUKernel::LaunchAdamWeightDecay(const std::vector<AddressPt
       var[i] -= lr * update;
     }
   };
-  ParallelForAdam(task, lens);
+  CPUKernelUtils::ParallelFor(task, lens);
 }
 
 void AdamWeightDecayCPUKernel::InitKernel(const CNodePtr &kernel_node) {
   MS_EXCEPTION_IF_NULL(kernel_node);
-  std::vector<size_t> var_shape = AnfAlgo::GetInputDeviceShape(kernel_node, 0);
-  dtype_ = AnfAlgo::GetInputDeviceDataType(kernel_node, 0);
-  gradient_dtype_ = AnfAlgo::GetInputDeviceDataType(kernel_node, 8);
+  std::vector<size_t> var_shape = AnfAlgo::GetInputDeviceShape(kernel_node, VAR);
+  dtype_ = AnfAlgo::GetInputDeviceDataType(kernel_node, VAR);
+  gradient_dtype_ = AnfAlgo::GetInputDeviceDataType(kernel_node, GRAD);
   size_t input_num = AnfAlgo::GetInputTensorNum(kernel_node);
   if (input_num != kAdamWeightDecayInputSize) {
     MS_LOG(EXCEPTION) << "Input number is " << input_num << ", but AdamWeightDecay needs 9 inputs.";
@@ -155,12 +134,12 @@ void AdamWeightDecayCPUKernel::CheckParam(const std::vector<kernel::AddressPtr>
   }
   size_t elem1_size = elem_num_ * kSizeFloat32;
   size_t elem2_size = gradient_dtype_ == kNumberTypeFloat16 ? elem_num_ * kSizeFloat16 : elem1_size;
-  if (inputs[0]->size != elem1_size || inputs[1]->size != elem1_size || inputs[2]->size != elem1_size ||
-      inputs[8]->size != elem2_size) {
+  if (inputs[VAR]->size != elem1_size || inputs[M]->size != elem1_size || inputs[V]->size != elem1_size ||
+      inputs[GRAD]->size != elem2_size) {
     MS_LOG(EXCEPTION) << "Error input data size!";
   }
-  if (inputs[3]->size != kSizeFloat32 || inputs[4]->size != kSizeFloat32 || inputs[5]->size != kSizeFloat32 ||
-      inputs[6]->size != kSizeFloat32 || inputs[7]->size != kSizeFloat32) {
+  if (inputs[LR]->size != kSizeFloat32 || inputs[BETA1]->size != kSizeFloat32 || inputs[BETA2]->size != kSizeFloat32 ||
+      inputs[EPSILON]->size != kSizeFloat32 || inputs[DECAY]->size != kSizeFloat32) {
     MS_LOG(EXCEPTION) << "The attribute beta, lr, epsilon and weight decay must be float!";
   }
 }
diff --git a/mindspore/ccsrc/backend/kernel_compiler/cpu/adam_weight_decay_cpu_kernel.h b/mindspore/ccsrc/backend/kernel_compiler/cpu/adam_weight_decay_cpu_kernel.h
index 34c56bed352..fe6f309e38e 100644
--- a/mindspore/ccsrc/backend/kernel_compiler/cpu/adam_weight_decay_cpu_kernel.h
+++ b/mindspore/ccsrc/backend/kernel_compiler/cpu/adam_weight_decay_cpu_kernel.h
@@ -32,7 +32,6 @@ class AdamWeightDecayCPUKernel : public CPUKernel {
               const std::vector<AddressPtr> &outputs) override;
 
  private:
-  void ParallelForAdam(const CTask &task, size_t count);
   void CheckParam(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> &outputs);
   template <typename T, typename S>
   void LaunchFusedAdam(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> &outputs);
@@ -41,6 +40,7 @@ class AdamWeightDecayCPUKernel : public CPUKernel {
   size_t elem_num_{0};
   TypeId dtype_{kTypeUnknown};
   TypeId gradient_dtype_{kTypeUnknown};
+  enum input_list_ { VAR, M, V, LR, BETA1, BETA2, EPSILON, DECAY, GRAD };
 };
 
 MS_REG_CPU_KERNEL(AdamWeightDecay,
diff --git a/mindspore/ccsrc/backend/kernel_compiler/cpu/nnacl/fp32/adam_fp32.c b/mindspore/ccsrc/backend/kernel_compiler/cpu/nnacl/fp32/adam_fp32.c
index 728a38964a7..19b0b7bd428 100644
--- a/mindspore/ccsrc/backend/kernel_compiler/cpu/nnacl/fp32/adam_fp32.c
+++ b/mindspore/ccsrc/backend/kernel_compiler/cpu/nnacl/fp32/adam_fp32.c
@@ -152,17 +152,15 @@ int AdamDeltaFp32(float *delta, float *m, float *v, float lr, float beta1, float
   return NNACL_OK;
 }
 
-int AdamWeightDecayFp32(float *var, float *m, float *v, float lr, float beta1, float beta2, float epsilon, float decay,
-                        const float *gradient, size_t start, size_t end) {
+size_t AdamWeightDecayFp32(float *var, float *m, float *v, float lr, float beta1, float beta2, float epsilon,
+                           float decay, const float *gradient, size_t start, size_t end) {
   size_t c1 = start;
 #ifdef ENABLE_AVX512
-  const float beta1_minus = 1 - beta1;
-  const float beta2_minus = 1 - beta2;
   struct AVX_Data beta1_r, beta2_r, beta1_minus_r, beta2_minus_r, lr_neg_r, epsilon_r, decay_r;
   beta1_r.data = _mm512_set1_ps(beta1);
   beta2_r.data = _mm512_set1_ps(beta2);
-  beta1_minus_r.data = _mm512_set1_ps(beta1_minus);
-  beta2_minus_r.data = _mm512_set1_ps(beta2_minus);
+  beta1_minus_r.data = _mm512_set1_ps(1.0f - beta1);
+  beta2_minus_r.data = _mm512_set1_ps(1.0f - beta2);
   lr_neg_r.data = _mm512_set1_ps(-lr);
   epsilon_r.data = _mm512_set1_ps(epsilon);
   decay_r.data = _mm512_set1_ps(decay);
@@ -260,17 +258,15 @@ int AdamWeightDecayFp32(float *var, float *m, float *v, float lr, float beta1, f
   return c1;
 }
 
-int FusedAdamFp32(float *var, float *m, float *v, float lr, float beta1, float beta2, float epsilon, float decay,
-                  const int16_t *gradient16, size_t start, size_t end) {
+size_t FusedAdamFp32(float *var, float *m, float *v, float lr, float beta1, float beta2, float epsilon, float decay,
+                     const int16_t *gradient16, size_t start, size_t end) {
   size_t c1 = start;
 #ifdef ENABLE_AVX512
-  const float beta1_minus = 1 - beta1;
-  const float beta2_minus = 1 - beta2;
   struct AVX_Data beta1_r, beta2_r, beta1_minus_r, beta2_minus_r, lr_neg_r, epsilon_r, decay_r;
   beta1_r.data = _mm512_set1_ps(beta1);
   beta2_r.data = _mm512_set1_ps(beta2);
-  beta1_minus_r.data = _mm512_set1_ps(beta1_minus);
-  beta2_minus_r.data = _mm512_set1_ps(beta2_minus);
+  beta1_minus_r.data = _mm512_set1_ps(1.0f - beta1);
+  beta2_minus_r.data = _mm512_set1_ps(1.0f - beta2);
   lr_neg_r.data = _mm512_set1_ps(-lr);
   epsilon_r.data = _mm512_set1_ps(epsilon);
   decay_r.data = _mm512_set1_ps(decay);
diff --git a/mindspore/ccsrc/backend/kernel_compiler/cpu/nnacl/fp32/adam_fp32.h b/mindspore/ccsrc/backend/kernel_compiler/cpu/nnacl/fp32/adam_fp32.h
index 3690cd646e6..b4f02754d27 100644
--- a/mindspore/ccsrc/backend/kernel_compiler/cpu/nnacl/fp32/adam_fp32.h
+++ b/mindspore/ccsrc/backend/kernel_compiler/cpu/nnacl/fp32/adam_fp32.h
@@ -71,10 +71,10 @@ int AdamFp32(float *var, float *m, float *v, float lr, float beta1, float beta2,
              size_t start, size_t end, bool use_nesterov);
 int AdamDeltaFp32(float *delta, float *m, float *v, float lr, float beta1, float beta2, float epsilon,
                   const float *gradient, size_t start, size_t end, bool use_nesterov);
-int AdamWeightDecayFp32(float *var, float *m, float *v, float lr, float beta1, float beta2, float epsilon, float decay,
-                        const float *gradient, size_t start, size_t end);
-int FusedAdamFp32(float *var, float *m, float *v, float lr, float beta1, float beta2, float epsilon, float decay,
-                  const int16_t *gradient16, size_t start, size_t end);
+size_t AdamWeightDecayFp32(float *var, float *m, float *v, float lr, float beta1, float beta2, float epsilon,
+                           float decay, const float *gradient, size_t start, size_t end);
+size_t FusedAdamFp32(float *var, float *m, float *v, float lr, float beta1, float beta2, float epsilon, float decay,
+                     const int16_t *gradient16, size_t start, size_t end);
 #ifdef __cplusplus
 }
 #endif
diff --git a/mindspore/ccsrc/backend/optimizer/pass/communication_op_fusion.cc b/mindspore/ccsrc/backend/optimizer/pass/communication_op_fusion.cc
index c4befc7e8f9..06b7edafb68 100644
--- a/mindspore/ccsrc/backend/optimizer/pass/communication_op_fusion.cc
+++ b/mindspore/ccsrc/backend/optimizer/pass/communication_op_fusion.cc
@@ -391,7 +391,7 @@ bool CommunicationOpFusion::DoFusion(const FuncGraphPtr &func_graph, const Commu
       MS_EXCEPTION_IF_NULL(communication_op_node_item);
       tuple_getitem->set_abstract(communication_op_node_item->abstract());
       if (kernel_graph->IsInternalOutput(communication_op_node_item, 0)) {
-        kernel_graph->ReplaceInternalOutput(communication_op_node_item, new_communication_op, 0, offset);
+        kernel_graph->ReplaceInternalOutput(communication_op_node_item, new_communication_op, 0, LongToSize(offset));
       }
       if (!manager->Replace(communication_op_node_item, tuple_getitem)) {
         MS_LOG(EXCEPTION) << "manager replace node failed";
diff --git a/mindspore/ccsrc/backend/optimizer/pass/convert_tuple_input_to_dynamic_input.cc b/mindspore/ccsrc/backend/optimizer/pass/convert_tuple_input_to_dynamic_input.cc
index 94ec9ed5ca0..c86db4644ce 100644
--- a/mindspore/ccsrc/backend/optimizer/pass/convert_tuple_input_to_dynamic_input.cc
+++ b/mindspore/ccsrc/backend/optimizer/pass/convert_tuple_input_to_dynamic_input.cc
@@ -50,7 +50,7 @@ int64_t SplitTupleInputs(const FuncGraphPtr &graph, const AnfNodePtr &tuple_inpu
   }
   for (size_t index = 0; index < input_size; ++index) {
     auto dynamic_input_node = CreatTupleGetItemNode(graph, tuple_input, index);
-    plant_inputs->emplace_back(dynamic_input_node);
+    (void)plant_inputs->emplace_back(dynamic_input_node);
   }
   return input_size;
 }
diff --git a/mindspore/ccsrc/backend/optimizer/pass/optimize_dependence.cc b/mindspore/ccsrc/backend/optimizer/pass/optimize_dependence.cc
index e8f311c04d3..4b04d4de543 100644
--- a/mindspore/ccsrc/backend/optimizer/pass/optimize_dependence.cc
+++ b/mindspore/ccsrc/backend/optimizer/pass/optimize_dependence.cc
@@ -191,6 +191,9 @@ const AnfNodePtr OptimizeDependence::Process(const FuncGraphPtr &func_graph, con
   std::vector<AnfNodePtr> new_inputs = cnode->inputs();
   bool inputs_changed = false;
   for (auto index : candidate_inputs) {
+    if (index >= new_inputs.size()) {
+      MS_LOG(EXCEPTION) << "Index is out of the size of cnode inputs.";
+    }
     auto replace_node = GetConvertNode(func_graph, cnode, index);
     if (replace_node != nullptr) {
       new_inputs[index] = replace_node;
diff --git a/mindspore/ccsrc/common/trans.cc b/mindspore/ccsrc/common/trans.cc
index bed7d3ca87b..59b95d4a0a2 100644
--- a/mindspore/ccsrc/common/trans.cc
+++ b/mindspore/ccsrc/common/trans.cc
@@ -1013,7 +1013,7 @@ bool NchwTo4D(const FormatArgs &args, void *result) {
       for (size_t hi = 0; hi < h; hi++) {
         for (size_t wi = 0; wi < w; wi++) {
           auto src_idx = ni * c * h * w + ci * h * w + hi * w + wi;
-          auto dst_idx = 0;
+          size_t dst_idx = 0;
           if (args.device_format == kOpFormat_NHWC) {
             dst_idx = ni * h * w * c + hi * w * c + wi * c + ci;
           } else if (args.device_format == kOpFormat_HWCN) {
@@ -1045,7 +1045,7 @@ bool ToNchw(const FormatArgs &args, void *result) {
       for (size_t hi = 0; hi < h; hi++) {
         for (size_t wi = 0; wi < w; wi++) {
           auto dst_idx = ni * c * h * w + ci * h * w + hi * w + wi;
-          auto src_idx = 0;
+          size_t src_idx = 0;
           if (args.device_format == kOpFormat_NHWC) {
             src_idx = ni * h * w * c + hi * w * c + wi * c + ci;
           } else if (args.device_format == kOpFormat_HWCN) {
@@ -1801,7 +1801,7 @@ bool NchwFracZTransWithGroups(const FormatArgs &args, void *result, bool to_devi
   auto c_dim = args.host_shape[kC];
   auto h_dim = args.host_shape[kH];
   auto w_dim = args.host_shape[kW];
-  size_t d_dim = 1;
+  const size_t d_dim = 1;
   size_t group_size = LongToSize(groups);
   auto cin_ori = c_dim;
   auto cout_ori = n_dim / group_size;
diff --git a/mindspore/ccsrc/runtime/device/kernel_runtime.cc b/mindspore/ccsrc/runtime/device/kernel_runtime.cc
index 7d2af553466..e15863805c0 100644
--- a/mindspore/ccsrc/runtime/device/kernel_runtime.cc
+++ b/mindspore/ccsrc/runtime/device/kernel_runtime.cc
@@ -709,7 +709,7 @@ void KernelRuntime::AssignValueNodeTensor(const ValueNodePtr &value_node, const
                              value_node.get());
       continue;
     }
-    size_t tensor_size = tensor->data().nbytes();
+    size_t tensor_size = LongToSize(tensor->data().nbytes());
     auto node_size = AnfAlgo::GetOutputTensorMemSize(value_node, output_idx);
     TypeId output_type_id = AnfAlgo::GetOutputDeviceDataType(value_node, output_idx);
     if (output_type_id == kTypeUnknown) {