remove all of cpp infer reg

mindspore/core/ops/abs.cc

@@ -56,7 +56,6 @@ AbstractBasePtr AbsInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Abs, prim::kPrimAbs, AbsInfer);
 REGISTER_PRIMITIVE_C(kNameAbs, Abs);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/adam.cc

@@ -81,8 +81,6 @@ AbstractBasePtr AdamInfer(const abstract::AnalysisEnginePtr &, const PrimitivePt
                           const std::vector<AbstractBasePtr> &input_args) {
   return std::make_shared<abstract::AbstractTensor>(AdamInfer(primitive, input_args));
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(Adam, prim::kPrimAdam, AdamInfer);
 REGISTER_PRIMITIVE_C(kNameAdam, Adam);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/add.cc

@@ -50,7 +50,6 @@ AbstractBasePtr AddInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Add, prim::kPrimAdd, AddInfer);
 REGISTER_PRIMITIVE_C(kNameAdd, Add);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/addn.cc

@@ -63,8 +63,6 @@ AbstractBasePtr AddNInfer(const abstract::AnalysisEnginePtr &, const PrimitivePt
   return std::make_shared<abstract::AbstractTensor>(TypeIdToType(infer_type),
                                                     std::make_shared<abstract::Shape>(element0_shape));
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(AddN, prim::kPrimAddN, AddNInfer);
 REGISTER_PRIMITIVE_C(kNameAddN, AddN);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/apply_momentum.cc

@@ -80,7 +80,6 @@ AbstractBasePtr ApplyMomentumInfer(const abstract::AnalysisEnginePtr &, const Pr
   auto element = g_type_tensor->element();
   return std::make_shared<abstract::AbstractTensor>(element, v_shape);
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(ApplyMomentum, prim::kPrimApplyMomentum, ApplyMomentumInfer);
 REGISTER_PRIMITIVE_C(kNameApplyMomentum, ApplyMomentum);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/arg_max.cc

@@ -67,7 +67,6 @@ AbstractBasePtr ArgMaxInfer(const abstract::AnalysisEnginePtr &, const Primitive
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(ArgMax, prim::kPrimArgMax, ArgMaxInfer);
 REGISTER_PRIMITIVE_C(kNameArgMax, ArgMax);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/arg_min.cc

@@ -67,7 +67,6 @@ AbstractBasePtr ArgMinInfer(const abstract::AnalysisEnginePtr &, const Primitive
 
   return std::make_shared<abstract::AbstractTensor>(x_dtype, std::make_shared<abstract::Shape>(out_shape));
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(ArgMin, prim::kPrimArgMin, ArgMinInfer);
 REGISTER_PRIMITIVE_C(kNameArgMin, ArgMin);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/asin.cc

@@ -46,7 +46,6 @@ AbstractBasePtr AsinInfer(const abstract::AnalysisEnginePtr &, const PrimitivePt
 
   return std::make_shared<abstract::AbstractTensor>(infer_type, infer_shape->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Asin, prim::kPrimAsin, AsinInfer);
 REGISTER_PRIMITIVE_C(kNameAsin, Asin);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/assert.cc

@@ -71,8 +71,6 @@ AbstractBasePtr AssertInfer(const abstract::AnalysisEnginePtr &, const Primitive
   }
   return std::make_shared<abstract::AbstractTensor>(TypeIdToType(kNumberTypeInt32), output_shape);
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(Assert, prim::kPrimAssert, AssertInfer);
 REGISTER_PRIMITIVE_C(kNameAssert, Assert);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/assign_add.cc

@@ -47,7 +47,6 @@ AbstractBasePtr AssignAddInfer(const abstract::AnalysisEnginePtr &, const Primit
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(AssignAdd, prim::kPrimAssignAdd, AssignAddInfer);
 REGISTER_PRIMITIVE_C(kNameAssignAdd, AssignAdd);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/atan.cc

@@ -44,7 +44,6 @@ AbstractBasePtr AtanInfer(const abstract::AnalysisEnginePtr &, const PrimitivePt
 
   return std::make_shared<abstract::AbstractTensor>(infer_type, infer_shape->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Atan, prim::kPrimAtan, AtanInfer);
 REGISTER_PRIMITIVE_C(kNameAtan, Atan);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/audio_spectrogram.cc

@@ -118,8 +118,6 @@ AbstractBasePtr AudioSpectrogramInfer(const abstract::AnalysisEnginePtr &, const
   return std::make_shared<abstract::AbstractTensor>(AudioSpectrogramInferType(primitive, input_args),
                                                     AudioSpectrogramInferShape(primitive, input_args)->shape());
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(AudioSpectrogram, prim::kPrimAudioSpectrogram, AudioSpectrogramInfer);
 REGISTER_PRIMITIVE_C(kNameAudioSpectrogram, AudioSpectrogram);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/avg_pool.cc

@@ -146,7 +146,6 @@ AbstractBasePtr AvgPoolInfer(const abstract::AnalysisEnginePtr &, const Primitiv
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(AvgPool, prim::kPrimAvgPool, AvgPoolInfer);
 REGISTER_PRIMITIVE_C(kNameAvgPool, AvgPool);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/batch_norm.cc

@@ -134,7 +134,6 @@ AbstractBasePtr BatchNormInfer(const abstract::AnalysisEnginePtr &, const Primit
   AbstractBasePtrList output = {output0, output1, output2, output3, output3};
   return std::make_shared<abstract::AbstractTuple>(output);
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(BatchNorm, prim::kPrimBatchNorm, BatchNormInfer);
 REGISTER_PRIMITIVE_C(kNameBatchNorm, BatchNorm);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/batch_norm_fold.cc

@@ -109,8 +109,6 @@ AbstractBasePtr BatchNormFoldInfer(const abstract::AnalysisEnginePtr &, const Pr
   AbstractBasePtrList output1 = {output, output, output, output};
   return std::make_shared<abstract::AbstractTuple>(output1);
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(BatchNormFold, prim::kPrimBatchNormFold, BatchNormFoldInfer);
 REGISTER_PRIMITIVE_C(kNameBatchNormFold, BatchNormFold);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/batch_to_space.cc

@@ -75,7 +75,6 @@ AbstractBasePtr BatchToSpaceInfer(const abstract::AnalysisEnginePtr &, const Pri
   ret->set_shape(std::make_shared<abstract::Shape>(out_shape));
   return ret;
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(BatchToSpace, prim::kPrimBatchToSpace, BatchToSpaceInfer);
 REGISTER_PRIMITIVE_C(kNameBatchToSpace, BatchToSpace);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/batch_to_space_nd.cc

@@ -103,7 +103,6 @@ AbstractBasePtr BatchToSpaceNDInfer(const abstract::AnalysisEnginePtr &, const P
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(BatchToSpaceND, prim::kPrimBatchToSpaceND, BatchToSpaceNDInfer);
 REGISTER_PRIMITIVE_C(kNameBatchToSpaceND, BatchToSpaceND);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/bias_add.cc

@@ -74,7 +74,6 @@ AbstractBasePtr BiasAddInfer(const abstract::AnalysisEnginePtr &, const Primitiv
                                                     BiasAddInferShape(primitive, input_args));
 }
 // Add
-REGISTER_PRIMITIVE_EVAL_IMPL(BiasAdd, prim::kPrimBiasAdd, BiasAddInfer);
 REGISTER_PRIMITIVE_C(kNameBiasAdd, BiasAdd);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/binary_cross_entropy.cc

@@ -87,8 +87,6 @@ AbstractBasePtr BinaryCrossEntropyInfer(const abstract::AnalysisEnginePtr &, con
   return std::make_shared<abstract::AbstractTensor>(BinaryCrossEntroyInferType(primitive, input_args),
                                                     BinaryCrossEntroyInferShape(primitive, input_args)->shape());
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(BinaryCrossEntropy, prim::kPrimBinaryCrossEntropy, BinaryCrossEntropyInfer);
 REGISTER_PRIMITIVE_C(kNameBinaryCrossEntropy, BinaryCrossEntropy);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/broadcast.cc

@@ -64,7 +64,6 @@ AbstractBasePtr BroadcastInfer(const abstract::AnalysisEnginePtr &, const Primit
   }
   return std::make_shared<abstract::AbstractTensor>(x_type, in_shape);
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Broadcast, prim::kPrimBroadcast, BroadcastInfer);
 REGISTER_PRIMITIVE_C(kNameBroadcast, Broadcast);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/broadcast_to.cc

@@ -81,8 +81,6 @@ AbstractBasePtr BroadcastToInfer(const abstract::AnalysisEnginePtr &, const Prim
   return std::make_shared<abstract::AbstractTensor>(BroadcastToInferType(primitive, input_args),
                                                     BroadcastToInferShape(primitive, input_args)->shape());
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(BroadcastTo, prim::kPrimBroadcastTo, BroadcastToInfer);
 REGISTER_PRIMITIVE_C(kNameBroadcastTo, BroadcastTo);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/ceil.cc

@@ -43,7 +43,6 @@ AbstractBasePtr CeilInfer(const abstract::AnalysisEnginePtr &, const PrimitivePt
   MS_EXCEPTION_IF_NULL(data_type);
   return std::make_shared<abstract::AbstractTensor>(data_type, x_shape);
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Ceil, prim::kPrimCeil, CeilInfer);
 REGISTER_PRIMITIVE_C(kNameCeil, Ceil);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/concat.cc

@@ -78,8 +78,6 @@ AbstractBasePtr ConcatInfer(const abstract::AnalysisEnginePtr &, const Primitive
   return std::make_shared<abstract::AbstractTensor>(TypeIdToType(infer_type),
                                                     std::make_shared<abstract::Shape>(ret_shape));
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(Concat, prim::kPrimConcat, ConcatInfer);
 REGISTER_PRIMITIVE_C(kNameConcat, Concat);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/constant.cc

@@ -52,7 +52,6 @@ AbstractBasePtr ConstantInfer(const abstract::AnalysisEnginePtr &, const Primiti
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Constant, prim::kPrimConstant, ConstantInfer);
 REGISTER_PRIMITIVE_C(kNameConstant, Constant);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/constant_of_shape.cc

@@ -61,7 +61,6 @@ AbstractBasePtr ConstantOfShapeInfer(const abstract::AnalysisEnginePtr &, const
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(ConstantOfShape, prim::kPrimConstantOfShape, ConstantOfShapeInfer);
 REGISTER_PRIMITIVE_C(kNameConstantOfShape, ConstantOfShape);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/conv2d.cc

@@ -232,8 +232,6 @@ AbstractBasePtr Conv2dInfer(const abstract::AnalysisEnginePtr &, const Primitive
   return std::make_shared<abstract::AbstractTensor>(Conv2dInferType(primitive, input_args),
                                                     Conv2dInferShape(primitive, input_args)->shape());
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(Conv2D, prim::kPrimConv2D, Conv2dInfer);
 REGISTER_PRIMITIVE_C(kNameConv2D, Conv2D);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/conv2d_transpose.cc

@@ -192,8 +192,6 @@ AbstractBasePtr Conv2dTransposeInfer(const abstract::AnalysisEnginePtr &, const
   return std::make_shared<abstract::AbstractTensor>(Conv2dTransposeInferType(primitive, input_args),
                                                     Conv2dTransposeInferShape(primitive, input_args)->shape());
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(Conv2dTranspose, prim::kPrimConv2DTranspose, Conv2dTransposeInfer);
 REGISTER_PRIMITIVE_C(kNameConv2dTranspose, Conv2dTranspose);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/cos.cc

@@ -50,7 +50,6 @@ AbstractBasePtr CosInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Cos, prim::kPrimCos, CosInfer);
 REGISTER_PRIMITIVE_C(kNameCos, Cos);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/crop.cc

@@ -56,7 +56,6 @@ AbstractBasePtr CropInfer(const abstract::AnalysisEnginePtr &, const PrimitivePt
   auto x_type = input_args[0]->BuildType()->cast<TensorTypePtr>()->element();
   return std::make_shared<abstract::AbstractTensor>(x_type, out_shape);
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Crop, prim::kPrimCrop, CropInfer);
 REGISTER_PRIMITIVE_C(kNameCrop, Crop);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/custom_extract_features.cc

@@ -50,7 +50,6 @@ AbstractBasePtr CustomExtractFeaturesInfer(const abstract::AnalysisEnginePtr &,
   AbstractBasePtrList output = {output0, output1};
   return std::make_shared<abstract::AbstractTuple>(output);
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(CustomExtractFeatures, prim::kPrimCustomExtractFeatures, CustomExtractFeaturesInfer);
 REGISTER_PRIMITIVE_C(kNameCustomExtractFeatures, CustomExtractFeatures);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/custom_normalize.cc

@@ -62,8 +62,6 @@ AbstractBasePtr CustomNormalizeInfer(const abstract::AnalysisEnginePtr &, const
   return std::make_shared<abstract::AbstractTensor>(CustomNormalizeInferType(primitive, input_args),
                                                     CustomNormalizeInferShape(primitive, input_args)->shape());
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(CustomNormalize, prim::kPrimCustomNormalize, CustomNormalizeInfer);
 REGISTER_PRIMITIVE_C(kNameCustomNormalize, CustomNormalize);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/custom_predict.cc

@@ -58,8 +58,6 @@ AbstractBasePtr CustomPredictInfer(const abstract::AnalysisEnginePtr &, const Pr
   AbstractBasePtrList output = {output0, output1};
   return std::make_shared<abstract::AbstractTuple>(output);
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(CustomPredict, prim::kPrimCustomPredict, CustomPredictInfer);
 REGISTER_PRIMITIVE_C(kNameCustomPredict, CustomPredict);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/depth_to_space.cc

@@ -81,7 +81,6 @@ AbstractBasePtr DepthToSpaceInfer(const abstract::AnalysisEnginePtr &, const Pri
   ret->set_shape(std::make_shared<abstract::Shape>(out_shape));
   return ret;
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(DepthToSpace, prim::kPrimDepthToSpace, DepthToSpaceInfer);
 REGISTER_PRIMITIVE_C(kNameDepthToSpace, DepthToSpace);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/detection_post_process.cc

@@ -168,7 +168,6 @@ AbstractBasePtr DetectionPostProcessInfer(const abstract::AnalysisEnginePtr &, c
   }
   return std::make_shared<abstract::AbstractTuple>(output);
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(DetectionPostProcess, prim::kPrimDetectionPostProcess, DetectionPostProcessInfer);
 REGISTER_PRIMITIVE_C(kNameDetectionPostProcess, DetectionPostProcess);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/div.cc

@@ -51,7 +51,6 @@ AbstractBasePtr DivInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Div, prim::kPrimDiv, DivInfer);
 REGISTER_PRIMITIVE_C(kNameDiv, Div);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/dropout.cc

@@ -64,7 +64,6 @@ AbstractBasePtr DropoutInfer(const abstract::AnalysisEnginePtr &, const Primitiv
 
   return std::make_shared<abstract::AbstractTensor>(infer_type, infer_shape->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Dropout, prim::kPrimDropout, DropoutInfer);
 REGISTER_PRIMITIVE_C(kNameDropout, Dropout);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/elu.cc

@@ -68,8 +68,6 @@ AbstractBasePtr EluInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(Elu, prim::kPrimElu, EluInfer);
 REGISTER_PRIMITIVE_C(kNameElu, Elu);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/embedding_lookup.cc

@@ -80,8 +80,6 @@ AbstractBasePtr EmbeddingLookupInfer(const abstract::AnalysisEnginePtr &, const
   return std::make_shared<abstract::AbstractTensor>(params->element(),
                                                     std::make_shared<abstract::Shape>(shape, min_shape, max_shape));
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(EmbeddingLookup, prim::kPrimEmbeddingLookup, EmbeddingLookupInfer);
 REGISTER_PRIMITIVE_C(kNameEmbeddingLookup, EmbeddingLookup);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/equal.cc

@@ -52,7 +52,6 @@ AbstractBasePtr EqualInfer(const abstract::AnalysisEnginePtr &, const PrimitiveP
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Equal, prim::kPrimEqual, EqualInfer);
 REGISTER_PRIMITIVE_C(kNameEqual, Equal);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/exp.cc

@@ -48,7 +48,6 @@ AbstractBasePtr ExpInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Exp, prim::kPrimExp, ExpInfer);
 REGISTER_PRIMITIVE_C(kNameExp, Exp);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/expand_dims.cc

@@ -55,7 +55,6 @@ AbstractBasePtr ExpandDimsInfer(const abstract::AnalysisEnginePtr &, const Primi
   CheckAndConvertUtils::CheckSubClass("x_type", x_type, valid_x_type, prim_name);
   return std::make_shared<abstract::AbstractTensor>(x_type, out_shape);
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(ExpandDims, prim::kPrimExpandDims, ExpandDimsInfer);
 REGISTER_PRIMITIVE_C(kNameExpandDims, ExpandDims);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fake_quant_with_min_max_vars.cc

@@ -85,7 +85,6 @@ AbstractBasePtr FakeQuantWithMinMaxVarsInfer(const abstract::AnalysisEnginePtr &
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(FakeQuantWithMinMaxVars, prim::kPrimFakeQuantWithMinMaxVars, FakeQuantWithMinMaxVarsInfer);
 REGISTER_PRIMITIVE_C(kNameFakeQuantWithMinMaxVars, FakeQuantWithMinMaxVars);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fake_quant_with_min_max_vars_per_channel.cc

@@ -69,9 +69,6 @@ AbstractBasePtr FakeQuantWithMinMaxVarsPerChannelInfer(const abstract::AnalysisE
   MS_EXCEPTION_IF_NULL(data_type);
   return std::make_shared<abstract::AbstractTensor>(data_type, x_shape);
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(FakeQuantWithMinMaxVarsPerChannel, prim::kPrimFakeQuantWithMinMaxVarsPerChannel,
-                             FakeQuantWithMinMaxVarsPerChannelInfer);
 REGISTER_PRIMITIVE_C(kNameFakeQuantWithMinMaxVarsPerChannel, FakeQuantWithMinMaxVarsPerChannel);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fft_imag.cc

@@ -45,7 +45,6 @@ AbstractBasePtr FftImagInfer(const abstract::AnalysisEnginePtr &, const Primitiv
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(FftImag, prim::kPrimFftImag, FftImagInfer);
 REGISTER_PRIMITIVE_C(kNameFftImag, FftImag);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fft_real.cc

@@ -37,7 +37,6 @@ AbstractBasePtr FftRealInfer(const abstract::AnalysisEnginePtr &, const Primitiv
   out_shape.pop_back();
   return std::make_shared<abstract::AbstractTensor>(out_dtype, std::make_shared<abstract::Shape>(out_shape));
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(FftReal, prim::kPrimFftReal, FftRealInfer);
 REGISTER_PRIMITIVE_C(kNameFftReal, FftReal);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fill.cc

@@ -58,7 +58,6 @@ AbstractBasePtr FillInfer(const abstract::AnalysisEnginePtr &, const PrimitivePt
   abs->set_value(tensor);
   return abs;
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Fill, prim::kPrimFill, FillInfer);
 REGISTER_PRIMITIVE_C(kNameFill, Fill);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/flatten.cc

@@ -53,7 +53,6 @@ AbstractBasePtr FlattenInfer(const abstract::AnalysisEnginePtr &, const Primitiv
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Flatten, prim::kPrimFlatten, FlattenInfer);
 REGISTER_PRIMITIVE_C(kNameFlatten, Flatten);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/floor.cc

@@ -54,7 +54,6 @@ AbstractBasePtr FloorInfer(const abstract::AnalysisEnginePtr &, const PrimitiveP
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Floor, prim::kPrimFloor, FloorInfer);
 REGISTER_PRIMITIVE_C(kNameFloor, Floor);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fusion/add_fusion.cc

@@ -62,7 +62,6 @@ AbstractBasePtr AddFusionInfer(const abstract::AnalysisEnginePtr &, const Primit
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(AddFusion, prim::kPrimAddFusion, AddFusionInfer);
 REGISTER_PRIMITIVE_C(kNameAddFusion, AddFusion);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fusion/adder_fusion.cc

@@ -44,7 +44,6 @@ ActivationType AdderFusion::get_activation_type() const {
   auto value_ptr = GetAttr(kActivationType);
   return ActivationType(GetValue<int64_t>(value_ptr));
 }
-
 REGISTER_PRIMITIVE_C(kNameAdderFusion, AdderFusion);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fusion/avg_pool_fusion.cc

@@ -105,7 +105,6 @@ AbstractBasePtr AvgPoolFusionInfer(const abstract::AnalysisEnginePtr &, const Pr
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(AvgPoolFusion, prim::kPrimAvgPool, AvgPoolFusionInfer);
 REGISTER_PRIMITIVE_C(kNameAvgPoolFusion, AvgPoolFusion);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fusion/conv2d_backprop_filter_fusion.cc

@@ -60,7 +60,6 @@ int64_t Conv2DBackpropFilterFusion::get_in_channel() const {
   auto value_ptr = GetAttr(kInChannel);
   return GetValue<int64_t>(value_ptr);
 }
-
 REGISTER_PRIMITIVE_C(kNameConv2DBackpropFilterFusion, Conv2DBackpropFilterFusion);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fusion/full_connection.cc

@@ -110,7 +110,6 @@ AbstractBasePtr FullConnectionInfer(const abstract::AnalysisEnginePtr &, const P
   auto input0_type = input_args[0]->BuildType()->cast<TensorTypePtr>()->element();
   return std::make_shared<abstract::AbstractTensor>(input0_type, out_shape);
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(FullConnection, prim::kPrimFullConnection, FullConnectionInfer);
 REGISTER_PRIMITIVE_C(kNameFullConnection, FullConnection);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fusion/pow_fusion.cc

@@ -60,7 +60,6 @@ AbstractBasePtr PowFusionInfer(const abstract::AnalysisEnginePtr &, const Primit
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(PowFusion, prim::kPrimPowFusion, PowFusionInfer);
 REGISTER_PRIMITIVE_C(kNamePowFusion, PowFusion);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fusion/prelu_fusion.cc

@@ -42,7 +42,6 @@ std::vector<float> PReLUFusion::get_slope() const {
   auto value_ptr = GetAttr(kSlope);
   return GetValue<std::vector<float>>(value_ptr);
 }
-
 REGISTER_PRIMITIVE_C(kNamePReLUFusion, PReLUFusion);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fusion/reduce_fusion.cc

@@ -67,8 +67,6 @@ void ReduceFusion::Init(const bool keep_dims, const ReduceMode mode, const bool
   this->set_reduce_to_end(reduce_to_end);
   this->set_coeff(coeff);
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(ReduceFusion, prim::kPrimReduceMean, ReduceInfer);
 REGISTER_PRIMITIVE_C(kNameReduceFusion, ReduceFusion);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fusion/slice_fusion.cc

@@ -63,8 +63,6 @@ AbstractBasePtr SliceFusionInfer(const abstract::AnalysisEnginePtr &, const Prim
   }
   return std::make_shared<abstract::AbstractTensor>(data_type, size);
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(SliceFusion, prim::kPrimSliceFusion, SliceFusionInfer);
 REGISTER_PRIMITIVE_C(kNameSliceFusion, SliceFusion);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fusion/tile_fusion.cc

@@ -28,7 +28,6 @@ std::vector<int64_t> TileFusion::get_dims() const {
   auto value_ptr = GetAttr(kDims);
   return GetValue<std::vector<int64_t>>(value_ptr);
 }
-
 REGISTER_PRIMITIVE_C(kNameTileFusion, TileFusion);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/fusion/topk_fusion.cc

@@ -39,7 +39,6 @@ int64_t TopKFusion::get_largest() const {
   auto value_ptr = GetAttr(kLargest);
   return GetValue<int64_t>(value_ptr);
 }
-
 REGISTER_PRIMITIVE_C(kNameTopKFusion, TopKFusion);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/gather.cc

@@ -42,7 +42,6 @@ AbstractBasePtr GatherInfer(const abstract::AnalysisEnginePtr &, const Primitive
 
   return std::make_shared<abstract::AbstractTensor>(x_type, index_shape);
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Gather, prim::kPrimGather, GatherInfer);
 REGISTER_PRIMITIVE_C(kNameGather, Gather);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/gather_nd.cc

@@ -67,7 +67,6 @@ AbstractBasePtr GatherNdInfer(const abstract::AnalysisEnginePtr &, const Primiti
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(GatherNd, prim::kPrimGatherND, GatherNdInfer);
 REGISTER_PRIMITIVE_C(kNameGatherNd, GatherNd);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/gelu.cc

@@ -51,8 +51,6 @@ AbstractBasePtr GeLUInfer(const abstract::AnalysisEnginePtr &, const PrimitivePt
   return std::make_shared<abstract::AbstractTensor>(GeLUInferType(primitive, input_args),
                                                     GeLUInferShape(primitive, input_args)->shape());
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(GeLU, prim::kPrimGeLU, GeLUInfer);
 REGISTER_PRIMITIVE_C(kNameGeLU, GeLU);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/avg_pool_grad.cc

@@ -32,7 +32,6 @@ AbstractBasePtr AvgPoolGradInfer(const abstract::AnalysisEnginePtr &, const Prim
   return std::make_shared<abstract::AbstractTensor>(element, origin_input_shape);
 }
 
-REGISTER_PRIMITIVE_EVAL_IMPL(AvgPoolGrad, prim::kPrimAvgPoolGrad, AvgPoolGradInfer);
 REGISTER_PRIMITIVE_C(kNameAvgPoolGrad, AvgPoolGrad);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/batch_norm_grad.cc

@@ -66,8 +66,6 @@ AbstractBasePtr BatchNormGradInfer(const abstract::AnalysisEnginePtr &, const Pr
   AbstractBasePtrList rets = {dx, dscale, dscale, reserve_1, reserve_2};
   return std::make_shared<abstract::AbstractTuple>(rets);
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(BatchNormGrad, prim::kPrimBatchNormGrad, BatchNormGradInfer);
 REGISTER_PRIMITIVE_C(kNameBatchNormGrad, BatchNormGrad);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/bias_grad.cc

@@ -46,7 +46,6 @@ AbstractBasePtr BiasGradInfer(const abstract::AnalysisEnginePtr &, const Primiti
 
   return std::make_shared<abstract::AbstractTensor>(intype, inshape);
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(BiasGrad, prim::kPrimBiasGrad, BiasGradInfer);
 REGISTER_PRIMITIVE_C(kNameBiasGrad, BiasGrad);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/binary_cross_entropy_grad.cc

@@ -73,8 +73,6 @@ AbstractBasePtr BinaryCrossEntropyGradInfer(const abstract::AnalysisEnginePtr &,
   return std::make_shared<abstract::AbstractTensor>(BinaryCrossEntroyGradInferType(primitive, input_args),
                                                     BinaryCrossEntroyGradInferShape(primitive, input_args)->shape());
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(BinaryCrossEntropyGrad, prim::kPrimBinaryCrossEntropyGrad, BinaryCrossEntropyGradInfer);
 REGISTER_PRIMITIVE_C(kNameBinaryCrossEntropyGrad, BinaryCrossEntropyGrad);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/bn_grad.cc

@@ -39,7 +39,6 @@ float BNGrad::get_momentum() const {
   auto value_ptr = this->GetAttr(kMomentum);
   return GetValue<float>(value_ptr);
 }
-
 REGISTER_PRIMITIVE_C(kNameBNGrad, BNGrad);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/conv2d_backprop_filter.cc

@@ -146,8 +146,6 @@ AbstractBasePtr Conv2DBackpropFilterInfer(const abstract::AnalysisEnginePtr &, c
   return std::make_shared<abstract::AbstractTensor>(Conv2DBackpropFilterInferType(primitive, input_args),
                                                     Conv2DBackpropFilterInferShape(primitive, input_args)->shape());
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(Conv2DBackpropFilter, prim::kPrimConv2DBackpropFilter, Conv2DBackpropFilterInfer);
 REGISTER_PRIMITIVE_C(kNameConv2DBackpropFilter, Conv2DBackpropFilter);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/conv2d_backprop_input.cc

@@ -196,7 +196,6 @@ std::vector<int64_t> Conv2DBackpropInput::get_pad_list() const {
   auto value_ptr = GetAttr(kPadList);
   return GetValue<std::vector<int64_t>>(value_ptr);
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Conv2DBackpropInput, prim::kPrimConv2DBackpropInput, Conv2DBackpropInputInfer);
 REGISTER_PRIMITIVE_C(kNameConv2DBackpropInput, Conv2DBackpropInput);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/de_conv2d_grad_filter.cc

@@ -132,7 +132,6 @@ bool DeConv2DGradFilter::get_has_bias() const {
   auto value_ptr = GetAttr(kHasBias);
   return GetValue<bool>(value_ptr);
 }
-
 REGISTER_PRIMITIVE_C(kNameDeConv2DGradFilter, DeConv2DGradFilter);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/dropout_grad.cc

@@ -63,8 +63,6 @@ AbstractBasePtr DropoutGradInfer(const abstract::AnalysisEnginePtr &, const Prim
   return std::make_shared<abstract::AbstractTensor>(DropoutGradInferType(primitive, input_args),
                                                     DropoutGradInferShape(primitive, input_args)->shape());
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(DropoutGrad, prim::kPrimDropoutGrad, DropoutGradInfer);
 REGISTER_PRIMITIVE_C(kNameDropoutGrad, DropoutGrad);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/flatten_grad.cc

@@ -35,7 +35,6 @@ AbstractBasePtr FlattenGradInfer(const abstract::AnalysisEnginePtr &, const Prim
   ret->set_shape(std::make_shared<abstract::Shape>(out_shape));
   return ret;
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(FlattenGrad, prim::kPrimFlattenGrad, FlattenGradInfer);
 REGISTER_PRIMITIVE_C(kNameFlattenGrad, FlattenGrad);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/group_conv2d_grad_input.cc

@@ -161,7 +161,6 @@ AbstractBasePtr GroupConv2DGradInputInfer(const abstract::AnalysisEnginePtr &, c
 
   return std::make_shared<abstract::AbstractTensor>(type, shape);
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(GroupConv2DGradInput, prim::kPrimGroupConv2DGradInput, GroupConv2DGradInputInfer);
 REGISTER_PRIMITIVE_C(kNameGroupConv2DGradInput, GroupConv2DGradInput);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/max_pool_grad.cc

@@ -60,8 +60,6 @@ AbstractBasePtr MaxPoolGradInfer(const abstract::AnalysisEnginePtr &, const Prim
   auto element = tensor_type->element();
   return std::make_shared<abstract::AbstractTensor>(element, x1_shape);
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(MaxPoolGrad, prim::kPrimMaxPoolGrad, MaxPoolGradInfer);
 REGISTER_PRIMITIVE_C(kNameMaxPoolGrad, MaxPoolGrad);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/maximum_grad.cc

@@ -37,7 +37,6 @@ bool MaximumGrad::get_grad_y() const {
   auto value_ptr = GetAttr(kGradY);
   return GetValue<bool>(value_ptr);
 }
-
 REGISTER_PRIMITIVE_C(kNameMaximumGrad, MaximumGrad);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/minimum_grad.cc

@@ -37,7 +37,6 @@ bool MinimumGrad::get_grad_y() const {
   auto value_ptr = GetAttr(kGradY);
   return GetValue<bool>(value_ptr);
 }
-
 REGISTER_PRIMITIVE_C(kNameMinimumGrad, MinimumGrad);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/pool_grad.cc

@@ -19,7 +19,6 @@
 
 namespace mindspore {
 namespace ops {
-
 std::vector<int64_t> PoolGrad::_grad_check_vector(std::string arg_name, std::vector<int64_t> arg_val,
                                                   std::string op_name) {
   std::vector<int64_t> ret;
@@ -83,7 +82,6 @@ PadMode PoolGrad::get_pad_mode() const {
   auto value_ptr = GetAttr(kPadMode);
   return PadMode(GetValue<int64_t>(value_ptr));
 }
-
 REGISTER_PRIMITIVE_C(kNamePoolGrad, PoolGrad);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/sigmoid_cross_entropy_with_logits_grad.cc

@@ -58,9 +58,6 @@ AbstractBasePtr SigmoidCrossEntropyWithLogitsGradInfer(const abstract::AnalysisE
 
   return std::make_shared<abstract::AbstractTensor>(dout_type, x_shape);
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(SigmoidCrossEntropyWithLogitsGrad, prim::kPrimSigmoidCrossEntropyWithLogitsGrad,
-                             SigmoidCrossEntropyWithLogitsGradInfer);
 REGISTER_PRIMITIVE_C(kNameSigmoidCrossEntropyWithLogitsGrad, SigmoidCrossEntropyWithLogitsGrad);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/smooth_l1_loss_grad.cc

@@ -63,7 +63,6 @@ AbstractBasePtr SmoothL1LossGradInfer(const abstract::AnalysisEnginePtr &, const
 
   return std::make_shared<abstract::AbstractTensor>(dloss_type, prediction);
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(SmoothL1LossGrad, prim::kPrimSmoothL1LossGrad, SmoothL1LossGradInfer);
 REGISTER_PRIMITIVE_C(kNameSmoothL1LossGrad, SmoothL1LossGrad);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/grad/strided_slice_grad.cc

@@ -78,7 +78,6 @@ int64_t StridedSliceGrad::get_shrink_axis_mask() const {
   auto value_ptr = GetAttr(kShrinkAxisMask);
   return GetValue<int64_t>(value_ptr);
 }
-
 REGISTER_PRIMITIVE_C(kNameStridedSliceGrad, StridedSliceGrad);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/gru.cc

@@ -111,7 +111,6 @@ GateOrderMode GRU::get_gate_order() const {
   auto value_ptr = this->GetAttr(kGateOrder);
   return GateOrderMode(GetValue<int64_t>(value_ptr));
 }
-
 REGISTER_PRIMITIVE_C(kNameGRU, GRU);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/hashtable_lookup.cc

@@ -49,8 +49,6 @@ AbstractBasePtr HashtableLookupInfer(const abstract::AnalysisEnginePtr &, const
   }
   return std::make_shared<abstract::AbstractTuple>(output1);
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(HashtableLookup, prim::kPrimHashtableLookup, HashtableLookupInfer);
 REGISTER_PRIMITIVE_C(kNameHashtableLookup, HashtableLookup);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/l2_normalize.cc

@@ -59,7 +59,6 @@ AbstractBasePtr L2NormalizeInfer(const abstract::AnalysisEnginePtr &, const Prim
   }
   return input_args[0]->Broaden();
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(L2Normalize, prim::kPrimL2Normalize, L2NormalizeInfer);
 REGISTER_PRIMITIVE_C(kNameL2Normalize, L2Normalize);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/leaky_relu.cc

@@ -51,7 +51,6 @@ AbstractBasePtr LeakyReluInfer(const abstract::AnalysisEnginePtr &, const Primit
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(LeakyRelu, prim::kPrimLeakyRelu, LeakyReluInfer);
 REGISTER_PRIMITIVE_C(kNameLeakyRelu, LeakyRelu);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/less.cc

@@ -50,7 +50,6 @@ AbstractBasePtr LessInfer(const abstract::AnalysisEnginePtr &, const PrimitivePt
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Less, prim::kPrimLess, LessInfer);
 REGISTER_PRIMITIVE_C(kNameLess, Less);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/less_equal.cc

@@ -51,7 +51,6 @@ AbstractBasePtr LessEqualInfer(const abstract::AnalysisEnginePtr &, const Primit
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(LessEqual, prim::kPrimLessEqual, LessEqualInfer);
 REGISTER_PRIMITIVE_C(kNameLessEqual, LessEqual);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/local_response_normalization.cc

@@ -91,8 +91,6 @@ AbstractBasePtr LocalResponseNormalizationInfer(const abstract::AnalysisEnginePt
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(LocalResponseNormalization, prim::kPrimLocalResponseNormalization,
-                             LocalResponseNormalizationInfer);
 REGISTER_PRIMITIVE_C(kNameLocalResponseNormalization, LocalResponseNormalization);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/log.cc

@@ -41,7 +41,6 @@ AbstractBasePtr LogInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Log, prim::kPrimLog, LogInfer);
 REGISTER_PRIMITIVE_C(kNameLog, Log);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/logical_and.cc

@@ -55,7 +55,6 @@ AbstractBasePtr LogicalAndInfer(const abstract::AnalysisEnginePtr &, const Primi
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(LogicalAnd, prim::kPrimLogicalAnd, LogicalAndInfer);
 REGISTER_PRIMITIVE_C(kNameLogicalAnd, LogicalAnd);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/logical_not.cc

@@ -50,8 +50,6 @@ AbstractBasePtr LogicalNotInfer(const abstract::AnalysisEnginePtr &, const Primi
   return std::make_shared<abstract::AbstractTensor>(LogicalNotInferType(primitive, input_args),
                                                     LogicalNotInferShape(primitive, input_args)->shape());
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(LogicalNot, prim::kPrimLogicalNot, LogicalNotInfer);
 REGISTER_PRIMITIVE_C(kNameLogicalNot, LogicalNot);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/logical_or.cc

@@ -56,7 +56,6 @@ AbstractBasePtr LogicalOrInfer(const abstract::AnalysisEnginePtr &, const Primit
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(LogicalOr, prim::kPrimLogicalOr, LogicalOrInfer);
 REGISTER_PRIMITIVE_C(kNameLogicalOr, LogicalOr);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/lrn.cc

@@ -102,7 +102,6 @@ AbstractBasePtr LrnInfer(const abstract::AnalysisEnginePtr &, const PrimitivePtr
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Lrn, prim::kPrimLrn, LrnInfer);
 REGISTER_PRIMITIVE_C(kNameLrn, Lrn);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/lsh_projection.cc

@@ -64,8 +64,6 @@ AbstractBasePtr LshProjectionInfer(const abstract::AnalysisEnginePtr &, const Pr
   TypePtr infer_type = TypeIdToType(kNumberTypeInt32);
   return std::make_shared<abstract::AbstractTensor>(infer_type, out_shape);
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(LshProjection, prim::kPrimLshProjection, LshProjectionInfer);
 REGISTER_PRIMITIVE_C(kNameLshProjection, LshProjection);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/lstm.cc

@@ -169,8 +169,6 @@ AbstractBasePtr LstmInfer(const abstract::AnalysisEnginePtr &, const PrimitivePt
                           const std::vector<AbstractBasePtr> &input_args) {
   return std::make_shared<abstract::AbstractTensor>(LstmInfer(primitive, input_args));
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(LSTM, prim::kPrimLstm, LstmInfer);
 REGISTER_PRIMITIVE_C(kNameLSTM, LSTM);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/mat_mul.cc

@@ -95,7 +95,6 @@ AbstractBasePtr MatMulInfer(const abstract::AnalysisEnginePtr &, const Primitive
 }
 
 // Add
-REGISTER_PRIMITIVE_EVAL_IMPL(MatMul, prim::kPrimMatMul, MatMulInfer);
 REGISTER_PRIMITIVE_C(kNameMatMul, MatMul);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/matrix_diag.cc

@@ -80,7 +80,6 @@ AbstractBasePtr MatrixDiagInfer(const abstract::AnalysisEnginePtr &, const Primi
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(MatrixDiag, prim::kPrimMatrixDiag, MatrixDiagInfer);
 REGISTER_PRIMITIVE_C(kNameMatrixDiag, MatrixDiag);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/max_pool.cc

@@ -152,7 +152,6 @@ AbstractBasePtr MaxPoolInfer(const abstract::AnalysisEnginePtr &, const Primitiv
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(MaxPool, prim::kPrimMaxPool, MaxPoolInfer);
 REGISTER_PRIMITIVE_C(kNameMaxPool, MaxPool);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/maximum.cc

@@ -48,7 +48,6 @@ AbstractBasePtr MaximumInfer(const abstract::AnalysisEnginePtr &, const Primitiv
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Maximum, prim::kPrimMaximum, MaximumInfer);
 REGISTER_PRIMITIVE_C(kNameMaximum, Maximum);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/merge.cc

@@ -52,8 +52,6 @@ AbstractBasePtr MergeInfer(const abstract::AnalysisEnginePtr &, const PrimitiveP
   AbstractBasePtrList output = {output1, output2};
   return std::make_shared<abstract::AbstractTuple>(output);
 }
-
-REGISTER_PRIMITIVE_EVAL_IMPL(Merge, prim::kPrimMerge, MergeInfer);
 REGISTER_PRIMITIVE_C(kNameMerge, Merge);
 }  // namespace ops
 }  // namespace mindspore

mindspore/core/ops/mfcc.cc

@@ -93,7 +93,6 @@ AbstractBasePtr MfccInfer(const abstract::AnalysisEnginePtr &, const PrimitivePt
   return std::make_shared<abstract::AbstractTensor>(InferType(primitive, input_args),
                                                     InferShape(primitive, input_args)->shape());
 }
-REGISTER_PRIMITIVE_EVAL_IMPL(Mfcc, prim::kPrimMfcc, MfccInfer);
 REGISTER_PRIMITIVE_C(kNameMfcc, Mfcc);
 }  // namespace ops
 }  // namespace mindspore