modify ops_def

mindspore/lite/src/ops/ops_def.cc

@@ -455,16 +455,16 @@ OP_ATTR(weight_threshold, float)
 OP_SCHEMA_DEF_END(CustomPredict)
 
 OP_SCHEMA_DEF(DeConv2DGradFilter)
-OP_ATTR(in_channel, long);
-OP_ATTR(out_channel, long);
-OP_ATTR(kernel_size, [long]);
-OP_ATTR_ENUM(pad_mode, PadMode);
-OP_ATTR(pad_list, [long]);
-OP_ATTR(stride, [long]);
-OP_ATTR(dilation, [long]);
-OP_ATTR(group, long);
-OP_ATTR_ENUM(format, Format);
-OP_ATTR_ENUM(activation_type, ActivationType);
+OP_ATTR(in_channel, long)
+OP_ATTR(out_channel, long)
+OP_ATTR(kernel_size, [long])
+OP_ATTR_ENUM(pad_mode, PadMode)
+OP_ATTR(pad_list, [long])
+OP_ATTR(stride, [long])
+OP_ATTR(dilation, [long])
+OP_ATTR(group, long)
+OP_ATTR_ENUM(format, Format)
+OP_ATTR_ENUM(activation_type, ActivationType)
 OP_SCHEMA_DEF_END(DeConv2DGradFilter)
 
 OP_SCHEMA_DEF(Depend)

mindspore/lite/src/ops/ops_def.h

@@ -58,10 +58,13 @@
     op_def.append(" {\n");
 
 #elif PRIMITIVE_WRITEABLE
-#define OP_SCHEMA_DEF(OP)                                                      \
-  namespace mindspore::lite::ops {                                             \
-  mindspore::schema::PrimitiveT *MSOp2SchemaOp(const mindspore::ops::OP *op) { \
-    mindspore::schema::OP##T *schema_op = new (std::nothrow) mindspore::schema::OP##T();
+#define OP_SCHEMA_DEF(OP)                                                           \
+  namespace mindspore::lite::ops {                                                  \
+  std::unique_ptr<schema::PrimitiveT> MSOp2SchemaOp(const mindspore::ops::OP *op) { \
+    auto schema_op = std::make_unique<schema::OP##T>();                             \
+    if (schema_op == nullptr) {                                                     \
+      return nullptr;                                                               \
+    }
 #else
 #define OP_SCHEMA_DEF(OP)
 #endif
@@ -71,34 +74,32 @@
 #define OP_ATTR_ENUM(key, type) op_def.append("    ").append(#key).append(": ").append(#type).append(";\n");
 #define OP_ATTR_VEC2D(key, type) op_def.append("    ").append(#key).append(": ").append(#type).append(";\n");
 #elif PRIMITIVE_WRITEABLE
-#define OP_ATTR(key, type)              \
-  if (schema_op != nullptr) {           \
-    if (op->GetAttr(#key) != nullptr) { \
-      schema_op->key = op->get_##key(); \
-    }                                   \
-  } else {                              \
-    return nullptr;                     \
+#define OP_ATTR(key, type)            \
+  if (op->GetAttr(#key) != nullptr) { \
+    schema_op->key = op->get_##key(); \
   }
 
-#define OP_ATTR_ENUM(key, type)                                    \
-  if (schema_op != nullptr) {                                      \
-    if (op->GetAttr(#key) != nullptr) {                            \
-      schema_op->key = static_cast<schema::type>(op->get_##key()); \
-    }                                                              \
+#define OP_ATTR_ENUM(key, type)                                  \
+  if (op->GetAttr(#key) != nullptr) {                            \
+    schema_op->key = static_cast<schema::type>(op->get_##key()); \
   }
 
-#define OP_ATTR_VEC2D(key, type)                                \
-  if (schema_op != nullptr) {                                   \
-    auto vec2d = std::make_unique<schema::Vec2DT>();            \
-    if (op->GetAttr(#key) != nullptr) {                         \
-      auto data = op->get_##key();                              \
-      for (size_t i = 0; i < data.size(); ++i) {                \
-        auto vec = std::make_unique<schema::VecT>();            \
-        vec->data.assign(data.at(i).begin(), data.at(i).end()); \
-        vec2d->data.push_back(std::move(vec));                  \
-      }                                                         \
-      schema_op->key = std::move(vec2d);                        \
-    }                                                           \
+#define OP_ATTR_VEC2D(key, type)                              \
+  if (op->GetAttr(#key) != nullptr) {                         \
+    auto vec2d = std::make_unique<schema::Vec2DT>();          \
+    if (vec2d == nullptr) {                                   \
+      return nullptr;                                         \
+    }                                                         \
+    auto data = op->get_##key();                              \
+    for (size_t i = 0; i < data.size(); ++i) {                \
+      auto vec = std::make_unique<schema::VecT>();            \
+      if (vec == nullptr) {                                   \
+        return nullptr;                                       \
+      }                                                       \
+      vec->data.assign(data.at(i).begin(), data.at(i).end()); \
+      vec2d->data.push_back(std::move(vec));                  \
+    }                                                         \
+    schema_op->key = std::move(vec2d);                        \
   }
 
 #else
@@ -114,19 +115,13 @@
   op_def.append("    ").append(#key).append(": ").append(#type).append(" = ").append(#value).append(";\n");
 #elif PRIMITIVE_WRITEABLE
 #define OP_ATTR_WITH_VALUE(key, type, value) \
-  if (schema_op != nullptr) {                \
-    if (op->GetAttr(#key) != nullptr) {      \
-      schema_op->key = op->get_##key();      \
-    }                                        \
-  } else {                                   \
-    return nullptr;                          \
+  if (op->GetAttr(#key) != nullptr) {        \
+    schema_op->key = op->get_##key();        \
   }
 
-#define OP_ATTR_ENUM_WITH_VALUE(key, type, value)                  \
-  if (schema_op != nullptr) {                                      \
-    if (op->GetAttr(#key) != nullptr) {                            \
-      schema_op->key = static_cast<schema::type>(op->get_##key()); \
-    }                                                              \
+#define OP_ATTR_ENUM_WITH_VALUE(key, type, value)                \
+  if (op->GetAttr(#key) != nullptr) {                            \
+    schema_op->key = static_cast<schema::type>(op->get_##key()); \
   }
 #else
 #define OP_ATTR_WITH_VALUE(key, type, value)
@@ -141,15 +136,15 @@
   SchemaOpRegister g_schema_op_##OP(Gen##OP##Def); \
   }  // namespace mindspore::lite::ops
 #elif PRIMITIVE_WRITEABLE
-#define OP_SCHEMA_DEF_END(OP)                                         \
-  schema::PrimitiveT *prim = new (std::nothrow) schema::PrimitiveT(); \
-  if (prim == nullptr) {                                              \
-    return nullptr;                                                   \
-  }                                                                   \
-  prim->value.value = schema_op;                                      \
-  prim->value.type = schema::PrimitiveType_##OP;                      \
-  return prim;                                                        \
-  }                                                                   \
+#define OP_SCHEMA_DEF_END(OP)                         \
+  auto prim = std::make_unique<schema::PrimitiveT>(); \
+  if (prim == nullptr) {                              \
+    return nullptr;                                   \
+  }                                                   \
+  prim->value.value = schema_op.release();            \
+  prim->value.type = schema::PrimitiveType_##OP;      \
+  return prim;                                        \
+  }                                                   \
   }  // namespace mindspore::lite::ops
 #else
 #define OP_SCHEMA_DEF_END(OP)

mindspore/lite/src/ops/ops_func_declare.h

@@ -17,6 +17,7 @@
 #define MINDSPORE_LITE_SRC_OPS_OPS_FUNC_DECLARE_H_
 
 #ifdef PRIMITIVE_WRITEABLE
+#include <memory>
 #include "schema/inner/model_generated.h"
 #include "ops/abs.h"
 #include "ops/adam.h"
@@ -239,216 +240,215 @@
 #include "ops/cumsum.h"
 #include "ops/split_with_overlap.h"
 
-#define FUNC_MSOP2SCHEMAOP_DECLARE(OP)                                        \
-  namespace mindspore::lite::ops {                                            \
-  mindspore::schema::PrimitiveT *MSOp2SchemaOp(const mindspore::ops::OP *op); \
-  }
-#else
-#define FUNC_MSOP2SCHEMAOP_DECLARE(OP)
-#endif
+namespace mindspore::lite::ops {
+#define FUNC_MSOP2SCHEMAOP_DECLARE(OP) std::unique_ptr<schema::PrimitiveT> MSOp2SchemaOp(const mindspore::ops::OP *op);
 
 #ifdef PRIMITIVE_WRITEABLE
-FUNC_MSOP2SCHEMAOP_DECLARE(Abs);
-FUNC_MSOP2SCHEMAOP_DECLARE(Activation);
-FUNC_MSOP2SCHEMAOP_DECLARE(ActivationGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(Adam);
-FUNC_MSOP2SCHEMAOP_DECLARE(AddFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(AdderFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(AddGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(AddN);
-FUNC_MSOP2SCHEMAOP_DECLARE(All);
-FUNC_MSOP2SCHEMAOP_DECLARE(ApplyMomentum);
-FUNC_MSOP2SCHEMAOP_DECLARE(ArgMax);
-FUNC_MSOP2SCHEMAOP_DECLARE(ArgMaxFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(ArgMin);
-FUNC_MSOP2SCHEMAOP_DECLARE(ArgMinFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(Asin);
-FUNC_MSOP2SCHEMAOP_DECLARE(Assert);
-FUNC_MSOP2SCHEMAOP_DECLARE(Assign);
-FUNC_MSOP2SCHEMAOP_DECLARE(AssignAdd);
-FUNC_MSOP2SCHEMAOP_DECLARE(Atan);
-FUNC_MSOP2SCHEMAOP_DECLARE(AudioSpectrogram);
-FUNC_MSOP2SCHEMAOP_DECLARE(AvgPoolFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(AvgPoolGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(BatchNorm);
-FUNC_MSOP2SCHEMAOP_DECLARE(BatchNormGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(BatchToSpace);
-FUNC_MSOP2SCHEMAOP_DECLARE(BatchToSpaceND);
-FUNC_MSOP2SCHEMAOP_DECLARE(BiasAdd);
-FUNC_MSOP2SCHEMAOP_DECLARE(BiasAddGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(BinaryCrossEntropy);
-FUNC_MSOP2SCHEMAOP_DECLARE(BinaryCrossEntropyGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(BroadcastTo);
-FUNC_MSOP2SCHEMAOP_DECLARE(Cast);
-FUNC_MSOP2SCHEMAOP_DECLARE(Ceil);
-FUNC_MSOP2SCHEMAOP_DECLARE(Clip);
-FUNC_MSOP2SCHEMAOP_DECLARE(Concat);
-FUNC_MSOP2SCHEMAOP_DECLARE(ControlDepend);
-FUNC_MSOP2SCHEMAOP_DECLARE(ConstantOfShape);
-FUNC_MSOP2SCHEMAOP_DECLARE(Conv2DBackpropFilterFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(Conv2DBackpropInputFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(Conv2DFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(Conv2dTransposeFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(Cos);
-FUNC_MSOP2SCHEMAOP_DECLARE(Crop);
-FUNC_MSOP2SCHEMAOP_DECLARE(CustomExtractFeatures);
-FUNC_MSOP2SCHEMAOP_DECLARE(CustomNormalize);
-FUNC_MSOP2SCHEMAOP_DECLARE(CustomPredict);
-FUNC_MSOP2SCHEMAOP_DECLARE(DeConv2DGradFilter);
-FUNC_MSOP2SCHEMAOP_DECLARE(Depend);
-FUNC_MSOP2SCHEMAOP_DECLARE(DepthToSpace);
-FUNC_MSOP2SCHEMAOP_DECLARE(DetectionPostProcess);
-FUNC_MSOP2SCHEMAOP_DECLARE(DivFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(DivGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(Dropout);
-FUNC_MSOP2SCHEMAOP_DECLARE(DropoutGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(Eltwise);
-FUNC_MSOP2SCHEMAOP_DECLARE(Elu);
-FUNC_MSOP2SCHEMAOP_DECLARE(EmbeddingLookupFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(Equal);
-FUNC_MSOP2SCHEMAOP_DECLARE(ExpFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(ExpandDims);
-FUNC_MSOP2SCHEMAOP_DECLARE(FakeQuantWithMinMaxVars);
-FUNC_MSOP2SCHEMAOP_DECLARE(FakeQuantWithMinMaxVarsPerChannel);
-FUNC_MSOP2SCHEMAOP_DECLARE(FftImag);
-FUNC_MSOP2SCHEMAOP_DECLARE(FftReal);
-FUNC_MSOP2SCHEMAOP_DECLARE(Fill);
-FUNC_MSOP2SCHEMAOP_DECLARE(Flatten);
-FUNC_MSOP2SCHEMAOP_DECLARE(FlattenGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(Floor);
-FUNC_MSOP2SCHEMAOP_DECLARE(FloorDiv);
-FUNC_MSOP2SCHEMAOP_DECLARE(FloorMod);
-FUNC_MSOP2SCHEMAOP_DECLARE(FullConnection);
-FUNC_MSOP2SCHEMAOP_DECLARE(FusedBatchNorm);
-FUNC_MSOP2SCHEMAOP_DECLARE(Gather);
-FUNC_MSOP2SCHEMAOP_DECLARE(GatherNd);
-FUNC_MSOP2SCHEMAOP_DECLARE(Greater);
-FUNC_MSOP2SCHEMAOP_DECLARE(GreaterEqual);
-FUNC_MSOP2SCHEMAOP_DECLARE(GroupConv2DGradInput);
-FUNC_MSOP2SCHEMAOP_DECLARE(HashtableLookup);
-FUNC_MSOP2SCHEMAOP_DECLARE(InstanceNorm);
-FUNC_MSOP2SCHEMAOP_DECLARE(LayerNormFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(LeakyRelu);
-FUNC_MSOP2SCHEMAOP_DECLARE(Less);
-FUNC_MSOP2SCHEMAOP_DECLARE(LessEqual);
-FUNC_MSOP2SCHEMAOP_DECLARE(Log);
-FUNC_MSOP2SCHEMAOP_DECLARE(LogGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(LogicalAnd);
-FUNC_MSOP2SCHEMAOP_DECLARE(LogicalNot);
-FUNC_MSOP2SCHEMAOP_DECLARE(LogicalOr);
-FUNC_MSOP2SCHEMAOP_DECLARE(LogicalXor);
-FUNC_MSOP2SCHEMAOP_DECLARE(LpNormalization);
-FUNC_MSOP2SCHEMAOP_DECLARE(LRN);
-FUNC_MSOP2SCHEMAOP_DECLARE(LshProjection);
-FUNC_MSOP2SCHEMAOP_DECLARE(LSTM);
-FUNC_MSOP2SCHEMAOP_DECLARE(L2NormalizeFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(MatMul);
-FUNC_MSOP2SCHEMAOP_DECLARE(Maximum);
-FUNC_MSOP2SCHEMAOP_DECLARE(MaximumGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(MaxPoolFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(MaxPoolGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(Merge);
-FUNC_MSOP2SCHEMAOP_DECLARE(Mfcc);
-FUNC_MSOP2SCHEMAOP_DECLARE(Minimum);
-FUNC_MSOP2SCHEMAOP_DECLARE(MinimumGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(Mod);
-FUNC_MSOP2SCHEMAOP_DECLARE(MulFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(MulGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(Neg);
-FUNC_MSOP2SCHEMAOP_DECLARE(NegGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(NotEqual);
-FUNC_MSOP2SCHEMAOP_DECLARE(NonMaxSuppression);
-FUNC_MSOP2SCHEMAOP_DECLARE(OneHot);
-FUNC_MSOP2SCHEMAOP_DECLARE(OnesLike);
-FUNC_MSOP2SCHEMAOP_DECLARE(PadFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(PartialFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(PowFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(PowerGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(PReLUFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(PriorBox);
-FUNC_MSOP2SCHEMAOP_DECLARE(Proposal);
-FUNC_MSOP2SCHEMAOP_DECLARE(Rank);
-FUNC_MSOP2SCHEMAOP_DECLARE(Range);
-FUNC_MSOP2SCHEMAOP_DECLARE(Rank);
-FUNC_MSOP2SCHEMAOP_DECLARE(RealDiv);
-FUNC_MSOP2SCHEMAOP_DECLARE(Reciprocal);
-FUNC_MSOP2SCHEMAOP_DECLARE(ReduceFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(Reshape);
-FUNC_MSOP2SCHEMAOP_DECLARE(Resize);
-FUNC_MSOP2SCHEMAOP_DECLARE(ReverseSequence);
-FUNC_MSOP2SCHEMAOP_DECLARE(ReverseV2);
-FUNC_MSOP2SCHEMAOP_DECLARE(Rfft);
-FUNC_MSOP2SCHEMAOP_DECLARE(ROIPooling);
-FUNC_MSOP2SCHEMAOP_DECLARE(Round);
-FUNC_MSOP2SCHEMAOP_DECLARE(Rsqrt);
-FUNC_MSOP2SCHEMAOP_DECLARE(QuantDTypeCast);
-FUNC_MSOP2SCHEMAOP_DECLARE(Scale);
-FUNC_MSOP2SCHEMAOP_DECLARE(ScaleFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(ScatterNd);
-FUNC_MSOP2SCHEMAOP_DECLARE(Select);
-FUNC_MSOP2SCHEMAOP_DECLARE(SGD);
-FUNC_MSOP2SCHEMAOP_DECLARE(Shape);
-FUNC_MSOP2SCHEMAOP_DECLARE(SigmoidCrossEntropyWithLogits);
-FUNC_MSOP2SCHEMAOP_DECLARE(SigmoidCrossEntropyWithLogitsGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(Sin);
-FUNC_MSOP2SCHEMAOP_DECLARE(SkipGram);
-FUNC_MSOP2SCHEMAOP_DECLARE(SliceFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(SmoothL1Loss);
-FUNC_MSOP2SCHEMAOP_DECLARE(SmoothL1LossGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(Softmax);
-FUNC_MSOP2SCHEMAOP_DECLARE(SoftmaxCrossEntropyWithLogits);
-FUNC_MSOP2SCHEMAOP_DECLARE(SpaceToBatch);
-FUNC_MSOP2SCHEMAOP_DECLARE(SpaceToBatchND);
-FUNC_MSOP2SCHEMAOP_DECLARE(SpaceToDepth);
-FUNC_MSOP2SCHEMAOP_DECLARE(SparseSoftmaxCrossEntropyWithLogits);
-FUNC_MSOP2SCHEMAOP_DECLARE(SparseToDense);
-FUNC_MSOP2SCHEMAOP_DECLARE(Split);
-FUNC_MSOP2SCHEMAOP_DECLARE(Sqrt);
-FUNC_MSOP2SCHEMAOP_DECLARE(Square);
-FUNC_MSOP2SCHEMAOP_DECLARE(SquaredDifference);
-FUNC_MSOP2SCHEMAOP_DECLARE(Squeeze);
-FUNC_MSOP2SCHEMAOP_DECLARE(Stack);
-FUNC_MSOP2SCHEMAOP_DECLARE(StridedSlice);
-FUNC_MSOP2SCHEMAOP_DECLARE(Sub);
-FUNC_MSOP2SCHEMAOP_DECLARE(SubFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(SubGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(Switch);
-FUNC_MSOP2SCHEMAOP_DECLARE(Tan);
-FUNC_MSOP2SCHEMAOP_DECLARE(TensorListFromTensor);
-FUNC_MSOP2SCHEMAOP_DECLARE(TensorListGetItem);
-FUNC_MSOP2SCHEMAOP_DECLARE(TensorListReserve);
-FUNC_MSOP2SCHEMAOP_DECLARE(TensorListSetItem);
-FUNC_MSOP2SCHEMAOP_DECLARE(TensorListStack);
-FUNC_MSOP2SCHEMAOP_DECLARE(TileFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(TopKFusion);
-FUNC_MSOP2SCHEMAOP_DECLARE(Transpose);
-FUNC_MSOP2SCHEMAOP_DECLARE(Unique);
-FUNC_MSOP2SCHEMAOP_DECLARE(UnsortedSegmentSum);
-FUNC_MSOP2SCHEMAOP_DECLARE(Unsqueeze);
-FUNC_MSOP2SCHEMAOP_DECLARE(Unstack);
-FUNC_MSOP2SCHEMAOP_DECLARE(Where);
-FUNC_MSOP2SCHEMAOP_DECLARE(ZerosLike);
-FUNC_MSOP2SCHEMAOP_DECLARE(Select);
-FUNC_MSOP2SCHEMAOP_DECLARE(GRU);
-FUNC_MSOP2SCHEMAOP_DECLARE(NonZero);
-FUNC_MSOP2SCHEMAOP_DECLARE(InvertPermutation);
-FUNC_MSOP2SCHEMAOP_DECLARE(Size);
-FUNC_MSOP2SCHEMAOP_DECLARE(RandomStandardNormal);
-FUNC_MSOP2SCHEMAOP_DECLARE(CropAndResize);
-FUNC_MSOP2SCHEMAOP_DECLARE(Erf);
-FUNC_MSOP2SCHEMAOP_DECLARE(StridedSliceGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(IsFinite);
-FUNC_MSOP2SCHEMAOP_DECLARE(LinSpace);
-FUNC_MSOP2SCHEMAOP_DECLARE(UniformReal);
-FUNC_MSOP2SCHEMAOP_DECLARE(AbsGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(RsqrtGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(SqrtGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(LayerNormGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(ResizeGrad);
-FUNC_MSOP2SCHEMAOP_DECLARE(Splice);
-FUNC_MSOP2SCHEMAOP_DECLARE(LogSoftmax);
-FUNC_MSOP2SCHEMAOP_DECLARE(Call);
-FUNC_MSOP2SCHEMAOP_DECLARE(CumSum);
-FUNC_MSOP2SCHEMAOP_DECLARE(SplitWithOverlap);
+FUNC_MSOP2SCHEMAOP_DECLARE(Abs)
+FUNC_MSOP2SCHEMAOP_DECLARE(Activation)
+FUNC_MSOP2SCHEMAOP_DECLARE(ActivationGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(Adam)
+FUNC_MSOP2SCHEMAOP_DECLARE(AddFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(AdderFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(AddGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(AddN)
+FUNC_MSOP2SCHEMAOP_DECLARE(All)
+FUNC_MSOP2SCHEMAOP_DECLARE(ApplyMomentum)
+FUNC_MSOP2SCHEMAOP_DECLARE(ArgMax)
+FUNC_MSOP2SCHEMAOP_DECLARE(ArgMaxFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(ArgMin)
+FUNC_MSOP2SCHEMAOP_DECLARE(ArgMinFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(Asin)
+FUNC_MSOP2SCHEMAOP_DECLARE(Assert)
+FUNC_MSOP2SCHEMAOP_DECLARE(Assign)
+FUNC_MSOP2SCHEMAOP_DECLARE(AssignAdd)
+FUNC_MSOP2SCHEMAOP_DECLARE(Atan)
+FUNC_MSOP2SCHEMAOP_DECLARE(AudioSpectrogram)
+FUNC_MSOP2SCHEMAOP_DECLARE(AvgPoolFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(AvgPoolGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(BatchNorm)
+FUNC_MSOP2SCHEMAOP_DECLARE(BatchNormGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(BatchToSpace)
+FUNC_MSOP2SCHEMAOP_DECLARE(BatchToSpaceND)
+FUNC_MSOP2SCHEMAOP_DECLARE(BiasAdd)
+FUNC_MSOP2SCHEMAOP_DECLARE(BiasAddGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(BinaryCrossEntropy)
+FUNC_MSOP2SCHEMAOP_DECLARE(BinaryCrossEntropyGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(BroadcastTo)
+FUNC_MSOP2SCHEMAOP_DECLARE(Cast)
+FUNC_MSOP2SCHEMAOP_DECLARE(Ceil)
+FUNC_MSOP2SCHEMAOP_DECLARE(Clip)
+FUNC_MSOP2SCHEMAOP_DECLARE(Concat)
+FUNC_MSOP2SCHEMAOP_DECLARE(ControlDepend)
+FUNC_MSOP2SCHEMAOP_DECLARE(ConstantOfShape)
+FUNC_MSOP2SCHEMAOP_DECLARE(Conv2DBackpropFilterFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(Conv2DBackpropInputFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(Conv2DFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(Conv2dTransposeFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(Cos)
+FUNC_MSOP2SCHEMAOP_DECLARE(Crop)
+FUNC_MSOP2SCHEMAOP_DECLARE(CustomExtractFeatures)
+FUNC_MSOP2SCHEMAOP_DECLARE(CustomNormalize)
+FUNC_MSOP2SCHEMAOP_DECLARE(CustomPredict)
+FUNC_MSOP2SCHEMAOP_DECLARE(DeConv2DGradFilter)
+FUNC_MSOP2SCHEMAOP_DECLARE(Depend)
+FUNC_MSOP2SCHEMAOP_DECLARE(DepthToSpace)
+FUNC_MSOP2SCHEMAOP_DECLARE(DetectionPostProcess)
+FUNC_MSOP2SCHEMAOP_DECLARE(DivFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(DivGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(Dropout)
+FUNC_MSOP2SCHEMAOP_DECLARE(DropoutGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(Eltwise)
+FUNC_MSOP2SCHEMAOP_DECLARE(Elu)
+FUNC_MSOP2SCHEMAOP_DECLARE(EmbeddingLookupFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(Equal)
+FUNC_MSOP2SCHEMAOP_DECLARE(ExpFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(ExpandDims)
+FUNC_MSOP2SCHEMAOP_DECLARE(FakeQuantWithMinMaxVars)
+FUNC_MSOP2SCHEMAOP_DECLARE(FakeQuantWithMinMaxVarsPerChannel)
+FUNC_MSOP2SCHEMAOP_DECLARE(FftImag)
+FUNC_MSOP2SCHEMAOP_DECLARE(FftReal)
+FUNC_MSOP2SCHEMAOP_DECLARE(Fill)
+FUNC_MSOP2SCHEMAOP_DECLARE(Flatten)
+FUNC_MSOP2SCHEMAOP_DECLARE(FlattenGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(Floor)
+FUNC_MSOP2SCHEMAOP_DECLARE(FloorDiv)
+FUNC_MSOP2SCHEMAOP_DECLARE(FloorMod)
+FUNC_MSOP2SCHEMAOP_DECLARE(FullConnection)
+FUNC_MSOP2SCHEMAOP_DECLARE(FusedBatchNorm)
+FUNC_MSOP2SCHEMAOP_DECLARE(Gather)
+FUNC_MSOP2SCHEMAOP_DECLARE(GatherNd)
+FUNC_MSOP2SCHEMAOP_DECLARE(Greater)
+FUNC_MSOP2SCHEMAOP_DECLARE(GreaterEqual)
+FUNC_MSOP2SCHEMAOP_DECLARE(GroupConv2DGradInput)
+FUNC_MSOP2SCHEMAOP_DECLARE(HashtableLookup)
+FUNC_MSOP2SCHEMAOP_DECLARE(InstanceNorm)
+FUNC_MSOP2SCHEMAOP_DECLARE(LayerNormFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(LeakyRelu)
+FUNC_MSOP2SCHEMAOP_DECLARE(Less)
+FUNC_MSOP2SCHEMAOP_DECLARE(LessEqual)
+FUNC_MSOP2SCHEMAOP_DECLARE(Log)
+FUNC_MSOP2SCHEMAOP_DECLARE(LogGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(LogicalAnd)
+FUNC_MSOP2SCHEMAOP_DECLARE(LogicalNot)
+FUNC_MSOP2SCHEMAOP_DECLARE(LogicalOr)
+FUNC_MSOP2SCHEMAOP_DECLARE(LogicalXor)
+FUNC_MSOP2SCHEMAOP_DECLARE(LpNormalization)
+FUNC_MSOP2SCHEMAOP_DECLARE(LRN)
+FUNC_MSOP2SCHEMAOP_DECLARE(LshProjection)
+FUNC_MSOP2SCHEMAOP_DECLARE(LSTM)
+FUNC_MSOP2SCHEMAOP_DECLARE(L2NormalizeFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(MatMul)
+FUNC_MSOP2SCHEMAOP_DECLARE(Maximum)
+FUNC_MSOP2SCHEMAOP_DECLARE(MaximumGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(MaxPoolFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(MaxPoolGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(Merge)
+FUNC_MSOP2SCHEMAOP_DECLARE(Mfcc)
+FUNC_MSOP2SCHEMAOP_DECLARE(Minimum)
+FUNC_MSOP2SCHEMAOP_DECLARE(MinimumGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(Mod)
+FUNC_MSOP2SCHEMAOP_DECLARE(MulFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(MulGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(Neg)
+FUNC_MSOP2SCHEMAOP_DECLARE(NegGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(NotEqual)
+FUNC_MSOP2SCHEMAOP_DECLARE(NonMaxSuppression)
+FUNC_MSOP2SCHEMAOP_DECLARE(OneHot)
+FUNC_MSOP2SCHEMAOP_DECLARE(OnesLike)
+FUNC_MSOP2SCHEMAOP_DECLARE(PadFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(PartialFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(PowFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(PowerGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(PReLUFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(PriorBox)
+FUNC_MSOP2SCHEMAOP_DECLARE(Proposal)
+FUNC_MSOP2SCHEMAOP_DECLARE(Rank)
+FUNC_MSOP2SCHEMAOP_DECLARE(Range)
+FUNC_MSOP2SCHEMAOP_DECLARE(Rank)
+FUNC_MSOP2SCHEMAOP_DECLARE(RealDiv)
+FUNC_MSOP2SCHEMAOP_DECLARE(Reciprocal)
+FUNC_MSOP2SCHEMAOP_DECLARE(ReduceFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(Reshape)
+FUNC_MSOP2SCHEMAOP_DECLARE(Resize)
+FUNC_MSOP2SCHEMAOP_DECLARE(ReverseSequence)
+FUNC_MSOP2SCHEMAOP_DECLARE(ReverseV2)
+FUNC_MSOP2SCHEMAOP_DECLARE(Rfft)
+FUNC_MSOP2SCHEMAOP_DECLARE(ROIPooling)
+FUNC_MSOP2SCHEMAOP_DECLARE(Round)
+FUNC_MSOP2SCHEMAOP_DECLARE(Rsqrt)
+FUNC_MSOP2SCHEMAOP_DECLARE(QuantDTypeCast)
+FUNC_MSOP2SCHEMAOP_DECLARE(Scale)
+FUNC_MSOP2SCHEMAOP_DECLARE(ScaleFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(ScatterNd)
+FUNC_MSOP2SCHEMAOP_DECLARE(Select)
+FUNC_MSOP2SCHEMAOP_DECLARE(SGD)
+FUNC_MSOP2SCHEMAOP_DECLARE(Shape)
+FUNC_MSOP2SCHEMAOP_DECLARE(SigmoidCrossEntropyWithLogits)
+FUNC_MSOP2SCHEMAOP_DECLARE(SigmoidCrossEntropyWithLogitsGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(Sin)
+FUNC_MSOP2SCHEMAOP_DECLARE(SkipGram)
+FUNC_MSOP2SCHEMAOP_DECLARE(SliceFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(SmoothL1Loss)
+FUNC_MSOP2SCHEMAOP_DECLARE(SmoothL1LossGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(Softmax)
+FUNC_MSOP2SCHEMAOP_DECLARE(SoftmaxCrossEntropyWithLogits)
+FUNC_MSOP2SCHEMAOP_DECLARE(SpaceToBatch)
+FUNC_MSOP2SCHEMAOP_DECLARE(SpaceToBatchND)
+FUNC_MSOP2SCHEMAOP_DECLARE(SpaceToDepth)
+FUNC_MSOP2SCHEMAOP_DECLARE(SparseSoftmaxCrossEntropyWithLogits)
+FUNC_MSOP2SCHEMAOP_DECLARE(SparseToDense)
+FUNC_MSOP2SCHEMAOP_DECLARE(Split)
+FUNC_MSOP2SCHEMAOP_DECLARE(Sqrt)
+FUNC_MSOP2SCHEMAOP_DECLARE(Square)
+FUNC_MSOP2SCHEMAOP_DECLARE(SquaredDifference)
+FUNC_MSOP2SCHEMAOP_DECLARE(Squeeze)
+FUNC_MSOP2SCHEMAOP_DECLARE(Stack)
+FUNC_MSOP2SCHEMAOP_DECLARE(StridedSlice)
+FUNC_MSOP2SCHEMAOP_DECLARE(Sub)
+FUNC_MSOP2SCHEMAOP_DECLARE(SubFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(SubGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(Switch)
+FUNC_MSOP2SCHEMAOP_DECLARE(Tan)
+FUNC_MSOP2SCHEMAOP_DECLARE(TensorListFromTensor)
+FUNC_MSOP2SCHEMAOP_DECLARE(TensorListGetItem)
+FUNC_MSOP2SCHEMAOP_DECLARE(TensorListReserve)
+FUNC_MSOP2SCHEMAOP_DECLARE(TensorListSetItem)
+FUNC_MSOP2SCHEMAOP_DECLARE(TensorListStack)
+FUNC_MSOP2SCHEMAOP_DECLARE(TileFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(TopKFusion)
+FUNC_MSOP2SCHEMAOP_DECLARE(Transpose)
+FUNC_MSOP2SCHEMAOP_DECLARE(Unique)
+FUNC_MSOP2SCHEMAOP_DECLARE(UnsortedSegmentSum)
+FUNC_MSOP2SCHEMAOP_DECLARE(Unsqueeze)
+FUNC_MSOP2SCHEMAOP_DECLARE(Unstack)
+FUNC_MSOP2SCHEMAOP_DECLARE(Where)
+FUNC_MSOP2SCHEMAOP_DECLARE(ZerosLike)
+FUNC_MSOP2SCHEMAOP_DECLARE(Select)
+FUNC_MSOP2SCHEMAOP_DECLARE(GRU)
+FUNC_MSOP2SCHEMAOP_DECLARE(NonZero)
+FUNC_MSOP2SCHEMAOP_DECLARE(InvertPermutation)
+FUNC_MSOP2SCHEMAOP_DECLARE(Size)
+FUNC_MSOP2SCHEMAOP_DECLARE(RandomStandardNormal)
+FUNC_MSOP2SCHEMAOP_DECLARE(CropAndResize)
+FUNC_MSOP2SCHEMAOP_DECLARE(Erf)
+FUNC_MSOP2SCHEMAOP_DECLARE(StridedSliceGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(IsFinite)
+FUNC_MSOP2SCHEMAOP_DECLARE(LinSpace)
+FUNC_MSOP2SCHEMAOP_DECLARE(UniformReal)
+FUNC_MSOP2SCHEMAOP_DECLARE(AbsGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(RsqrtGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(SqrtGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(LayerNormGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(ResizeGrad)
+FUNC_MSOP2SCHEMAOP_DECLARE(Splice)
+FUNC_MSOP2SCHEMAOP_DECLARE(LogSoftmax)
+FUNC_MSOP2SCHEMAOP_DECLARE(Call)
+FUNC_MSOP2SCHEMAOP_DECLARE(CumSum)
+FUNC_MSOP2SCHEMAOP_DECLARE(SplitWithOverlap)
+#endif
+}  // namespace mindspore::lite::ops
+#else
+#define FUNC_MSOP2SCHEMAOP_DECLARE(OP)
 #endif
 #endif  // MINDSPORE_LITE_SRC_OPS_OPS_FUNC_DECLARE_H_

mindspore/lite/src/ops/ops_utils.cc

@@ -15,6 +15,7 @@
  */
 
 #include <memory>
+#include <utility>
 #include "src/ops/ops_utils.h"
 
 #ifdef PRIMITIVE_WRITEABLE
@@ -22,7 +23,7 @@
 
 namespace mindspore {
 namespace lite {
-schema::PrimitiveT *GetPrimitiveT(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> GetPrimitiveT(const AnfNodePtr &node) {
   auto prim = GetValueNode<std::shared_ptr<Primitive>>(node);
   if (prim == nullptr) {
     MS_LOG(DEBUG) << "primitive is nullptr";
@@ -44,723 +45,723 @@ schema::PrimitiveT *GetPrimitiveT(const AnfNodePtr &node) {
   }
 }
 
-schema::PrimitiveT *AbsPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> AbsPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Abs>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *AbsGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> AbsGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AbsGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ActivationPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ActivationPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Activation>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ActivationGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ActivationGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ActivationGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *AdamPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> AdamPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Adam>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *AdderFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> AdderFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AdderFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *AddFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> AddFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AddFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *AddGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> AddGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AddGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *AddNPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> AddNPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AddN>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *AllPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> AllPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::All>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ApplyMomentumPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ApplyMomentumPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ApplyMomentum>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ArgMaxFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ArgMaxFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ArgMaxFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ArgMinFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ArgMinFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ArgMinFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *AssertPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> AssertPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Assert>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *AssignPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> AssignPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Assign>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *AssignAddPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> AssignAddPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AssignAdd>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *AudioSpectrogramPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> AudioSpectrogramPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AudioSpectrogram>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *AvgPoolFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> AvgPoolFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AvgPoolFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *AvgPoolGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> AvgPoolGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AvgPoolGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *BatchNormPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> BatchNormPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::BatchNorm>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *BatchToSpacePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> BatchToSpacePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::BatchToSpace>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *BatchToSpaceNDPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> BatchToSpaceNDPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::BatchToSpaceND>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *BiasAddPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> BiasAddPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::BiasAdd>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *BiasAddGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> BiasAddGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::BiasAddGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *BNGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> BNGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::BatchNormGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *BroadcastToPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> BroadcastToPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::BroadcastTo>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *CastPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> CastPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Cast>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *CeilPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> CeilPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Ceil>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ClipPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ClipPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Clip>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ConcatPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ConcatPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Concat>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ConstantOfShapePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ConstantOfShapePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ConstantOfShape>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ControlDependPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ControlDependPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ControlDepend>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *Conv2DBackpropFilterFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> Conv2DBackpropFilterFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Conv2DBackpropFilterFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *Conv2DBackpropInputFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> Conv2DBackpropInputFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Conv2DBackpropInputFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *Conv2DFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> Conv2DFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Conv2DFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *Conv2dTransposeFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> Conv2dTransposeFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Conv2dTransposeFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *CosPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> CosPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Cos>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *CropPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> CropPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Crop>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *CropAndResizePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> CropAndResizePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::CropAndResize>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *CustomExtractFeaturesPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> CustomExtractFeaturesPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::CustomExtractFeatures>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *CustomNormalizePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> CustomNormalizePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::CustomNormalize>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *CustomPredictPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> CustomPredictPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::CustomPredict>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *DependPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> DependPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Depend>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *DepthToSpacePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> DepthToSpacePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::DepthToSpace>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *DetectionPostProcessPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> DetectionPostProcessPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::DetectionPostProcess>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *DivFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> DivFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::DivFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *DivGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> DivGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::DivGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *DropoutPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> DropoutPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Dropout>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *DropoutGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> DropoutGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::DropoutGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *GRUPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> GRUPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::GRU>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *EltwisePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> EltwisePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Eltwise>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *EluPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> EluPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Elu>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *EmbeddingLookupFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> EmbeddingLookupFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::EmbeddingLookupFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *EqualPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> EqualPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Equal>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ExpandDimsPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ExpandDimsPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ExpandDims>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ExpFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ExpFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ExpFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *FftImagPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> FftImagPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::FftImag>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *FftRealPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> FftRealPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::FftReal>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *FillPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> FillPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Fill>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *FlattenPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> FlattenPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Flatten>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *FlattenGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> FlattenGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::FlattenGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *FloorPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> FloorPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Floor>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *FloorDivPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> FloorDivPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::FloorDiv>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *FloorModPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> FloorModPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::FloorMod>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *FullConnectionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> FullConnectionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::FullConnection>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *FusedBatchNormPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> FusedBatchNormPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::FusedBatchNorm>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *GatherPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> GatherPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Gather>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *GatherNdPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> GatherNdPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::GatherNd>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *GreaterPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> GreaterPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Greater>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *GreaterEqualPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> GreaterEqualPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::GreaterEqual>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *HashtableLookupPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> HashtableLookupPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::HashtableLookup>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *InstanceNormPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> InstanceNormPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::InstanceNorm>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *InvertPermutationPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> InvertPermutationPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::InvertPermutation>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *LayerNormFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> LayerNormFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LayerNormFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *LayerNormGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> LayerNormGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LayerNormGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *LeakyReluPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> LeakyReluPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LeakyRelu>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *LessPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> LessPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Less>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *LessEqualPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> LessEqualPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LessEqual>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *LogPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> LogPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Log>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *LogGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> LogGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LogGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *LogicalAndPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> LogicalAndPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LogicalAnd>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *LogicalNotPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> LogicalNotPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LogicalNot>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *LogicalOrPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> LogicalOrPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LogicalOr>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *LrnPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> LrnPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LRN>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *LpNormalizationPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> LpNormalizationPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LpNormalization>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *LshProjectionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> LshProjectionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LshProjection>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *LSTMPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> LSTMPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LSTM>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *L2NormalizeFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> L2NormalizeFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::L2NormalizeFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *MatMulPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> MatMulPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::MatMul>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *MaximumPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> MaximumPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Maximum>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *MaximumGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> MaximumGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::MaximumGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *MaxPoolFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> MaxPoolFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::MaxPoolFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *MaxPoolGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> MaxPoolGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::MaxPoolGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *MergePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> MergePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Merge>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *MfccPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> MfccPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Mfcc>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *MinimumPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> MinimumPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Minimum>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *MinimumGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> MinimumGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::MinimumGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ModPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ModPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Mod>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *MulFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> MulFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::MulFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *MulGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> MulGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::MulGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *NegPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> NegPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Neg>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *NegGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> NegGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::NegGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *NotEqualPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> NotEqualPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::NotEqual>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *NonMaxSuppressionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> NonMaxSuppressionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::NonMaxSuppression>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *OneHotPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> OneHotPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::OneHot>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *OnesLikePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> OnesLikePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::OnesLike>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *PadFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> PadFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::PadFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *PartialFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> PartialFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::PartialFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *PowerGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> PowerGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::PowerGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *PowFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> PowFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::PowFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *PReLUFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> PReLUFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::PReLUFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *QuantDTypeCastPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> QuantDTypeCastPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::QuantDTypeCast>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *RangePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> RangePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Range>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *RandomStandardNormalPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> RandomStandardNormalPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::RandomStandardNormal>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *RankPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> RankPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Rank>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *RealDivPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> RealDivPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::RealDiv>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ReciprocalPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ReciprocalPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Reciprocal>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ReduceFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ReduceFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ReduceFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ReshapePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ReshapePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Reshape>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ResizePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ResizePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Resize>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ResizeGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ResizeGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ResizeGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ReverseV2PrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ReverseV2PrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ReverseV2>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ReverseSequencePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ReverseSequencePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ReverseSequence>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *RfftPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> RfftPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Rfft>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ROIPoolingPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ROIPoolingPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ROIPooling>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *RoundPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> RoundPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Round>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *RsqrtPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> RsqrtPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Rsqrt>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *RsqrtGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> RsqrtGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::RsqrtGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ScaleFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ScaleFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ScaleFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ScatterNdPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ScatterNdPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ScatterNd>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SelectPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SelectPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Select>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SGDPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SGDPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SGD>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ShapePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ShapePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Shape>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SigmoidCrossEntropyWithLogitsPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SigmoidCrossEntropyWithLogitsPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SigmoidCrossEntropyWithLogits>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SigmoidCrossEntropyWithLogitsGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SigmoidCrossEntropyWithLogitsGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SigmoidCrossEntropyWithLogitsGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SinPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SinPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Sin>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SizePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SizePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Size>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SkipGramPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SkipGramPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SkipGram>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SliceFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SliceFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SliceFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SmoothL1LossPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SmoothL1LossPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SmoothL1Loss>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SmoothL1LossGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SmoothL1LossGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SmoothL1LossGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SoftmaxPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SoftmaxPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Softmax>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SoftmaxCrossEntropyWithLogitsPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SoftmaxCrossEntropyWithLogitsPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SoftmaxCrossEntropyWithLogits>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SpaceToBatchPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SpaceToBatchPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SpaceToBatch>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SpaceToBatchNDPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SpaceToBatchNDPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SpaceToBatchND>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SpaceToDepthPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SpaceToDepthPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SpaceToDepth>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SparseSoftmaxCrossEntropyWithLogitsPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SparseSoftmaxCrossEntropyWithLogitsPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SparseSoftmaxCrossEntropyWithLogits>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SparseToDensePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SparseToDensePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SparseToDense>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SplitPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SplitPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Split>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SqrtPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SqrtPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Sqrt>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SqrtGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SqrtGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SqrtGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SquarePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SquarePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Square>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SquaredDifferencePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SquaredDifferencePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SquaredDifference>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SqueezePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SqueezePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Squeeze>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *StackPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> StackPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Stack>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *StridedSlicePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> StridedSlicePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::StridedSlice>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *StridedSliceGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> StridedSliceGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::StridedSliceGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SubFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SubFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SubFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SubGradPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SubGradPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SubGrad>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *SwitchPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SwitchPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Switch>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *TensorListFromTensorPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> TensorListFromTensorPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::TensorListFromTensor>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *TensorListGetItemPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> TensorListGetItemPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::TensorListGetItem>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *TensorListReservePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> TensorListReservePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::TensorListReserve>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *TensorListSetItemPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> TensorListSetItemPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::TensorListSetItem>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *TensorListStackPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> TensorListStackPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::TensorListStack>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *TileFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> TileFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::TileFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *TopKFusionPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> TopKFusionPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::TopKFusion>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *TransposePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> TransposePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Transpose>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *UniquePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> UniquePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Unique>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *UnstackPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> UnstackPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Unstack>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *UnsortedSegmentSumPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> UnsortedSegmentSumPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::UnsortedSegmentSum>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *UnsqueezePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> UnsqueezePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Unsqueeze>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *WherePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> WherePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Where>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ZerosLikePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ZerosLikePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ZerosLike>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
-schema::PrimitiveT *ErfPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> ErfPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Erf>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
 
-schema::PrimitiveT *SplicePrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> SplicePrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Splice>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
 
-schema::PrimitiveT *LogSoftmaxPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> LogSoftmaxPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LogSoftmax>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
 
-schema::PrimitiveT *CallPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> CallPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Call>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
 
-schema::PrimitiveT *CumSumPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> CumSumPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::CumSum>>(node);
   return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
 }
@@ -982,9 +983,9 @@ RegistryMSOps g_LogSoftmaxPrimitiveCreatorRegistry("LogSoftmax", LogSoftmaxPrimi
 RegistryMSOps g_CallPrimitiveCreatorRegistry("call", CallPrimitiveCreator);
 RegistryMSOps g_CumSumPrimitiveCreatorRegistry("CumSum", CumSumPrimitiveCreator);
 
-schema::PrimitiveT *CustomPrimitiveCreator(const AnfNodePtr &node) {
+std::unique_ptr<schema::PrimitiveT> CustomPrimitiveCreator(const AnfNodePtr &node) {
   auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Custom>>(node);
-  auto *schema_op = new (std::nothrow) schema::CustomT();
+  auto schema_op = std::make_unique<schema::CustomT>();
   if (schema_op == nullptr) {
     return nullptr;
   }
@@ -994,21 +995,21 @@ schema::PrimitiveT *CustomPrimitiveCreator(const AnfNodePtr &node) {
   if (ms_primc->GetAttr("attr") != nullptr) {
     auto attr_map = ms_primc->get_attr();
     for (const auto &attr_item : attr_map) {
-      auto *attr = new (std::nothrow) schema::AttributeT();
+      auto attr = std::make_unique<schema::AttributeT>();
       if (attr == nullptr) {
         return nullptr;
       }
       attr->name = attr_item.first;
       attr->data = attr_item.second;
-      schema_op->attr.emplace_back(attr);
+      schema_op->attr.emplace_back(std::move(attr));
     }
   }
 
-  auto *prim = new (std::nothrow) schema::PrimitiveT();
+  auto prim = std::make_unique<schema::PrimitiveT>();
   if (prim == nullptr) {
     return nullptr;
   }
-  prim->value.value = schema_op;
+  prim->value.value = schema_op.release();
   prim->value.type = schema::PrimitiveType_Custom;
   return prim;
 }

mindspore/lite/src/ops/ops_utils.h

@@ -19,12 +19,13 @@
 
 #include <map>
 #include <string>
+#include <memory>
 #include "src/ops/ops_func_declare.h"
 
 #ifdef PRIMITIVE_WRITEABLE
 namespace mindspore {
 namespace lite {
-typedef schema::PrimitiveT *(*PrimitiveTCreator)(const AnfNodePtr &node);
+typedef std::unique_ptr<schema::PrimitiveT> (*PrimitiveTCreator)(const AnfNodePtr &node);
 
 class MSOpsRegistry {
  public:
@@ -32,8 +33,8 @@ class MSOpsRegistry {
     static MSOpsRegistry registry;
     return &registry;
   }
-  void InsertPrimitiveTMap(std::string name, PrimitiveTCreator creator) { primitive_creators[name] = creator; }
-  PrimitiveTCreator GetPrimitiveCreator(std::string name) {
+  void InsertPrimitiveTMap(const std::string &name, PrimitiveTCreator creator) { primitive_creators[name] = creator; }
+  PrimitiveTCreator GetPrimitiveCreator(const std::string &name) {
     if (primitive_creators.find(name) != primitive_creators.end()) {
       return primitive_creators[name];
     } else {
@@ -48,13 +49,13 @@ class MSOpsRegistry {
 
 class RegistryMSOps {
  public:
-  RegistryMSOps(std::string name, PrimitiveTCreator creator) {
+  RegistryMSOps(const std::string &name, PrimitiveTCreator creator) {
     MSOpsRegistry::GetInstance()->InsertPrimitiveTMap(name, creator);
   }
   ~RegistryMSOps() = default;
 };
 
-schema::PrimitiveT *GetPrimitiveT(const mindspore::AnfNodePtr &node);
+std::unique_ptr<schema::PrimitiveT> GetPrimitiveT(const mindspore::AnfNodePtr &node);
 }  // namespace lite
 }  // namespace mindspore
 #endif

mindspore/lite/tools/anf_exporter/anf_exporter.cc

@@ -21,9 +21,7 @@
 #include <functional>
 #include <utility>
 #include <vector>
-#include <algorithm>
 #include "tools/converter/converter_flags.h"
-#include "tools/common/tensor_util.h"
 #include "abstract/abstract_value.h"
 #include "mindspore/core/ir/primitive.h"
 #include "mindspore/core/ops/op_utils.h"
@@ -35,7 +33,6 @@
 #include "tools/optimizer/common/gllo_utils.h"
 #include "tools/converter/quantizer/bitpacking.h"
 #include "src/common/utils.h"
-#include "ops/op_utils.h"
 #include "tools/common/graph_util.h"
 #include "src/ops/ops_utils.h"
 #include "tools/common/node_util.h"
@@ -286,7 +283,7 @@ int AnfExporter::Anf2Fb(const FuncGraphPtr &func_graph, const std::unique_ptr<sc
   auto cnodes = GetOrderedCNodes(func_graph);
   for (const auto &cnode : cnodes) {
     auto prim = GetValueNode<std::shared_ptr<Primitive>>(cnode->input(0));
-    schema::PrimitiveT *primT = nullptr;
+    std::unique_ptr<schema::PrimitiveT> primT;
     if (prim == nullptr) {
       auto fg = GetValueNode<FuncGraphPtr>(cnode->input(0));
       if (fg != nullptr) {
@@ -344,7 +341,7 @@ int AnfExporter::Anf2Fb(const FuncGraphPtr &func_graph, const std::unique_ptr<sc
       primT = GetPrimitiveT(cnode->input(0));
     }
     node->name = cnode->fullname_with_scope();
-    node->primitive = std::unique_ptr<schema::PrimitiveT>(primT);
+    node->primitive = std::move(primT);
     auto device_type_attr = cnode->GetAttr(mindspore::ops::kDeviceType);
     node->deviceType = (device_type_attr != nullptr) ? GetValue<int32_t>(device_type_attr) : -1;
     ret = SetOpInputNode(cnode, meta_graphT, node.get());

mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc

@@ -146,8 +146,8 @@ kernel::LiteKernel *GetLiteKernel(std::vector<Tensor *> inputs, std::vector<Tens
   MS_ASSERT(cnode != nullptr && context != nullptr);
   auto prim_t = lite::GetPrimitiveT(cnode->input(0));
   flatbuffers::FlatBufferBuilder fbb(INITIAL_SIZE);
-  auto prim = lite::ConvertToPrimitive(prim_t, &fbb);
-  delete prim_t;
+  auto prim = lite::ConvertToPrimitive(prim_t.release(), &fbb);
+  prim_t.reset();
   if (prim == nullptr) {
     fbb.Clear();
     MS_LOG(ERROR) << "get primitive failed.";

mindspore/lite/tools/optimizer/graph/infershape_pass.cc

@@ -400,8 +400,8 @@ bool InferShapePass::Run(const FuncGraphPtr &func_graph) {
     }
 
     flatbuffers::FlatBufferBuilder fbb(INITIAL_SIZE);
-    auto prim = lite::ConvertToPrimitive(prim_t, &fbb);
-    delete prim_t;
+    auto prim = lite::ConvertToPrimitive(prim_t.release(), &fbb);
+    prim_t.reset();
     if (prim == nullptr) {
       MS_LOG(ERROR) << "get primitive failed.";
       FreeTensors(&input_tensors);

mindspore/lite/tools/optimizer/graph/node_infershape.cc

@@ -117,7 +117,7 @@ bool NodeInferShape::JudgeOpSupportInfer(const CNodePtr &cnode) {
   }
   auto parameter_gen = lite::PopulateRegistry::GetInstance()->GetParameterCreator(prim_t->value.type, lite::SCHEMA_CUR);
   if (parameter_gen == nullptr) {
-    delete prim_t;
+    prim_t.reset();
     return false;
   }
   return true;
@@ -153,8 +153,8 @@ STATUS NodeInferShape::InferShape(const CNodePtr &cnode) {
     return lite::RET_ERROR;
   }
   flatbuffers::FlatBufferBuilder fbb(INITIAL_SIZE);
-  auto prim = lite::ConvertToPrimitive(prim_t, &fbb);
-  delete prim_t;
+  auto prim = lite::ConvertToPrimitive(prim_t.release(), &fbb);
+  prim_t.reset();
   if (prim == nullptr) {
     MS_LOG(ERROR) << "get primitive failed.";
     FreeTensors(&inputs);