[Paddle-TRT] IPluginExt -> IPluginV2

paddle/fluid/inference/tensorrt/convert/elementwise_op.cc

@@ -251,10 +251,10 @@ class ElementwiseTensorOpConverter : public OpConverter {
       } else {
         plugin::ElementWisePlugin* plugin =
             new plugin::ElementWisePlugin(op_type_, dims_x, dims_y, axis);
-        plugin->AddInput(X);
-        plugin->AddInput(Y);
-        nvinfer1::IPluginLayer* plugin_layer = engine_->AddPlugin(
-            plugin->GetInputs().data(), 2,
+
+        std::vector<nvinfer1::ITensor*> inputs{X, Y};
+        auto* plugin_layer = engine_->AddPlugin(
+            inputs.data(), inputs.size(),
             reinterpret_cast<plugin::PluginTensorRT*>(plugin));
 
         layer = plugin_layer;

paddle/fluid/inference/tensorrt/convert/instance_norm_op.cc

@@ -74,7 +74,7 @@ class InstanceNormOpConverter : public OpConverter {
     plugin::InstanceNormPlugin* plugin =
         new plugin::InstanceNormPlugin(eps, scale_v, bias_v);
     plugin->getPluginType();
-    nvinfer1::IPluginLayer* layer = engine_->AddPlugin(&input, 1, plugin);
+    auto* layer = engine_->AddPlugin(&input, 1, plugin);
 
     auto output_name = op_desc.Output("Y")[0];
     RreplenishLayerAndOutput(layer, "instance_norm", {output_name}, test_mode);

paddle/fluid/inference/tensorrt/convert/shuffle_channel_op.cc

@@ -61,7 +61,8 @@ class ShuffleChannelOpConverter : public OpConverter {
     reshape_layer->setReshapeDimensions(reshape_dim2);
 
     auto output_name = op_desc.Output("Out")[0];
-    RreplenishLayerAndOutput(reshape_layer, "concat", {output_name}, test_mode);
+    RreplenishLayerAndOutput(reshape_layer, "shuffle_channel", {output_name},
+                             test_mode);
   }
 };
 

paddle/fluid/inference/tensorrt/engine.cc

@@ -330,11 +330,11 @@ float *TensorRTEngine::GetWeightCPUData(const std::string &name,
 
 int TensorRTEngine::GetRuntimeBatch() { return runtime_batch_; }
 
-nvinfer1::IPluginLayer *TensorRTEngine::AddPlugin(
+nvinfer1::IPluginV2Layer *TensorRTEngine::AddPlugin(
     nvinfer1::ITensor *const *inputs, int num_inputs,
     plugin::PluginTensorRT *plugin) {
   owned_plugin_.emplace_back(plugin);
-  return network()->addPluginExt(inputs, num_inputs, *plugin);
+  return network()->addPluginV2(inputs, num_inputs, *plugin);
 }
 
 nvinfer1::IPluginV2Layer *TensorRTEngine::AddPluginV2Ext(

paddle/fluid/inference/tensorrt/engine.h

@@ -30,7 +30,6 @@ limitations under the License. */
 #include "paddle/fluid/inference/engine.h"
 #include "paddle/fluid/inference/tensorrt/helper.h"
 #include "paddle/fluid/inference/tensorrt/plugin/trt_plugin.h"
-#include "paddle/fluid/inference/tensorrt/plugin/trt_plugin_factory.h"
 #include "paddle/fluid/inference/tensorrt/trt_int8_calibrator.h"
 #include "paddle/fluid/inference/utils/singleton.h"
 
@@ -276,19 +275,8 @@ class TensorRTEngine {
       }
     }
 
-    if (with_dynamic_shape_) {
-      infer_engine_.reset(runtime->deserializeCudaEngine(
-          engine_serialized_data.c_str(), engine_serialized_data.size()));
-    } else {
-#if IS_TRT_VERSION_LT(8000)
-      infer_engine_.reset(runtime->deserializeCudaEngine(
-          engine_serialized_data.c_str(), engine_serialized_data.size(),
-          &inference::Singleton<plugin::PluginFactoryTensorRT>::Global()));
-#else
-      infer_engine_.reset(runtime->deserializeCudaEngine(
-          engine_serialized_data.c_str(), engine_serialized_data.size()));
-#endif
-    }
+    infer_engine_.reset(runtime->deserializeCudaEngine(
+        engine_serialized_data.c_str(), engine_serialized_data.size()));
 
     PADDLE_ENFORCE_NOT_NULL(
         infer_engine_,
@@ -311,8 +299,8 @@ class TensorRTEngine {
 
   int GetDeviceId() { return device_id_; }
 
-  nvinfer1::IPluginLayer* AddPlugin(nvinfer1::ITensor* const* inputs,
-                                    int num_inputs, plugin::PluginTensorRT*);
+  nvinfer1::IPluginV2Layer* AddPlugin(nvinfer1::ITensor* const* inputs,
+                                      int num_inputs, plugin::PluginTensorRT*);
 
   nvinfer1::IPluginV2Layer* AddPluginV2Ext(nvinfer1::ITensor* const* inputs,
                                            int num_inputs,

paddle/fluid/inference/tensorrt/plugin/CMakeLists.txt

@@ -1,6 +1,6 @@
 nv_library(tensorrt_plugin
            SRCS trt_plugin.cc split_op_plugin.cu elementwise_op_plugin.cu
-           prelu_op_plugin.cu trt_plugin_factory.cc gelu_op_plugin.cu
+           prelu_op_plugin.cu gelu_op_plugin.cu
            pool_op_plugin.cu swish_op_plugin.cu layer_norm_op_plugin.cu
            instance_norm_op_plugin.cu emb_eltwise_layernorm_plugin.cu
            qkv_to_context_plugin.cu skip_layernorm_op_plugin.cu slice_op_plugin.cu

paddle/fluid/inference/tensorrt/plugin/anchor_generator_op_plugin.cu

@@ -18,8 +18,6 @@
 #include <cassert>
 
 #include "paddle/fluid/inference/tensorrt/plugin/anchor_generator_op_plugin.h"
-#include "paddle/fluid/inference/tensorrt/plugin/trt_plugin_factory.h"
-
 #include "paddle/fluid/operators/detection/anchor_generator_op.h"
 
 namespace paddle {

paddle/fluid/inference/tensorrt/plugin/elementwise_op_plugin.cu

@@ -14,19 +14,12 @@ limitations under the License. */
 
 #include <glog/logging.h>
 #include "paddle/fluid/inference/tensorrt/plugin/elementwise_op_plugin.h"
-#include "paddle/fluid/inference/tensorrt/plugin/trt_plugin_factory.h"
 
 namespace paddle {
 namespace inference {
 namespace tensorrt {
 namespace plugin {
 
-ElementWisePlugin *CreateElementWisePluginDeserialize(const void *buffer,
-                                                      size_t length) {
-  return new ElementWisePlugin(buffer, length);
-}
-REGISTER_TRT_PLUGIN("elementwise_plugin", CreateElementWisePluginDeserialize);
-
 namespace details {
 template <typename T>
 struct Add {

paddle/fluid/inference/tensorrt/plugin/elementwise_op_plugin.h

@@ -40,14 +40,16 @@ class ElementWisePlugin : public PluginTensorRT {
     const char* elementwise_type;
     DeserializeValue(&serial_data, &serial_length, &elementwise_type);
     type_ = std::string(elementwise_type);
-    DeserializeValue(&serial_data, &serial_length, &axis_);
     DeserializeValue(&serial_data, &serial_length, &dims_x_);
     DeserializeValue(&serial_data, &serial_length, &dims_y_);
+    DeserializeValue(&serial_data, &serial_length, &axis_);
+    DeserializeValue(&serial_data, &serial_length, &prev_size_);
+    DeserializeValue(&serial_data, &serial_length, &midd_size_);
+    DeserializeValue(&serial_data, &serial_length, &post_size_);
   }
 
   ElementWisePlugin* clone() const override {
-    // return new ElementWisePlugin(dims_x_, dims_y_, axis_);
-    return nullptr;
+    return new ElementWisePlugin(type_, dims_x_, dims_y_, axis_);
   }
 
   const char* getPluginType() const override { return "elementwise_plugin"; }
@@ -65,22 +67,25 @@ class ElementWisePlugin : public PluginTensorRT {
 #endif
               void* workspace, cudaStream_t stream);
 
- protected:
-  size_t getSerializationSize() override {
-    return SerializedSize(getPluginType()) + SerializedSize(axis_) +
+  size_t getSerializationSize() const override {
+    return getBaseSerializationSize() + SerializedSize(type_.c_str()) +
            SerializedSize(dims_x_) + SerializedSize(dims_y_) +
-           getBaseSerializationSize();
+           SerializedSize(axis_) + SerializedSize(prev_size_) +
+           SerializedSize(midd_size_) + SerializedSize(post_size_);
   }
 
-  void serialize(void* buffer) override {
-    SerializeValue(&buffer, getPluginType());
+  void serialize(void* buffer) const override {
     serializeBase(buffer);
     SerializeValue(&buffer, type_.c_str());
-    SerializeValue(&buffer, axis_);
     SerializeValue(&buffer, dims_x_);
     SerializeValue(&buffer, dims_y_);
+    SerializeValue(&buffer, axis_);
+    SerializeValue(&buffer, prev_size_);
+    SerializeValue(&buffer, midd_size_);
+    SerializeValue(&buffer, post_size_);
   }
 
+ protected:
   std::string type_;
   nvinfer1::Dims dims_x_;
   nvinfer1::Dims dims_y_;
@@ -90,6 +95,20 @@ class ElementWisePlugin : public PluginTensorRT {
   int post_size_;
 };
 
+class ElementWisePluginCreator : public TensorRTPluginCreator {
+ public:
+  const char* getPluginName() const override { return "elementwise_plugin"; }
+
+  const char* getPluginVersion() const override { return "1"; }
+
+  nvinfer1::IPluginV2* deserializePlugin(const char* name,
+                                         const void* serial_data,
+                                         size_t serial_length) override {
+    return new ElementWisePlugin(serial_data, serial_length);
+  }
+};
+REGISTER_TRT_PLUGIN_V2(ElementWisePluginCreator);
+
 #if IS_TRT_VERSION_GE(6000)
 class ElementwisePluginDynamic : public DynamicPluginTensorRT {
  public:
@@ -105,7 +124,9 @@ class ElementwisePluginDynamic : public DynamicPluginTensorRT {
     return new ElementwisePluginDynamic(type_, axis_);
   }
 
-  const char* getPluginType() const override { return "elementwise_plugin"; }
+  const char* getPluginType() const override {
+    return "elementwise_plugin_dynamic";
+  }
   int getNbOutputs() const override { return 1; }
   int initialize() override;
 
@@ -150,7 +171,9 @@ class ElementwisePluginDynamic : public DynamicPluginTensorRT {
 class ElementwisePluginDynamicCreator : public nvinfer1::IPluginCreator {
  public:
   ElementwisePluginDynamicCreator() {}
-  const char* getPluginName() const override { return "elementwise_plugin"; }
+  const char* getPluginName() const override {
+    return "elementwise_plugin_dynamic";
+  }
 
   const char* getPluginVersion() const override { return "1"; }
 

paddle/fluid/inference/tensorrt/plugin/emb_eltwise_layernorm_plugin.cu

@@ -20,7 +20,6 @@
 #include "paddle/fluid/framework/tensor.h"
 #include "paddle/fluid/framework/tensor_util.h"
 #include "paddle/fluid/inference/tensorrt/plugin/emb_eltwise_layernorm_plugin.h"
-#include "paddle/fluid/inference/tensorrt/plugin/trt_plugin_factory.h"
 #include "paddle/fluid/operators/math/bert_encoder_functor.h"
 
 namespace paddle {

paddle/fluid/inference/tensorrt/plugin/gather_nd_op_plugin.cu

@@ -22,7 +22,6 @@
 
 #include "NvInferRuntimeCommon.h"
 #include "paddle/fluid/inference/tensorrt/plugin/gather_nd_op_plugin.h"
-#include "paddle/fluid/inference/tensorrt/plugin/trt_plugin_factory.h"
 #include "paddle/fluid/platform/place.h"
 
 namespace paddle {

paddle/fluid/inference/tensorrt/plugin/gelu_op_plugin.cu

@@ -16,7 +16,6 @@
 #include <cstring>
 #include <vector>
 #include "paddle/fluid/inference/tensorrt/plugin/gelu_op_plugin.h"
-#include "paddle/fluid/inference/tensorrt/plugin/trt_plugin_factory.h"
 #include "paddle/fluid/platform/float16.h"
 
 namespace paddle {
@@ -31,12 +30,6 @@ static const float kAT = 0.5;
 static const float kBT = 0.7978845608028654;    // sqrt(2.0/M_PI)
 static const float kCT = 0.035677408136300125;  // 0.044715 * sqrt(2.0/M_PI)
 
-GeluPlugin* CreateGeluPluginDeserialize(const void* buffer, size_t length) {
-  return new GeluPlugin(buffer, length);
-}
-
-REGISTER_TRT_PLUGIN("gelu_plugin", CreateGeluPluginDeserialize);
-
 bool GeluPlugin::supportsFormat(nvinfer1::DataType type,
                                 nvinfer1::PluginFormat format) const {
   if (with_fp16_) {

paddle/fluid/inference/tensorrt/plugin/gelu_op_plugin.h

@@ -51,18 +51,28 @@ class GeluPlugin : public PluginTensorRT {
 #endif
               void* workspace, cudaStream_t stream) override;
 
- protected:
-  size_t getSerializationSize() override {
-    return getBaseSerializationSize() + SerializedSize(getPluginType());
+  size_t getSerializationSize() const override {
+    return getBaseSerializationSize();
   }
 
   // TRT will call this func  to serialize the configuration of TRT
   // It should not be called by users.
-  void serialize(void* buffer) override {
-    SerializeValue(&buffer, getPluginType());
-    serializeBase(buffer);
+  void serialize(void* buffer) const override { serializeBase(buffer); }
+};
+
+class GeluPluginCreator : public TensorRTPluginCreator {
+ public:
+  const char* getPluginName() const override { return "gelu_plugin"; }
+
+  const char* getPluginVersion() const override { return "1"; }
+
+  nvinfer1::IPluginV2* deserializePlugin(const char* name,
+                                         const void* serial_data,
+                                         size_t serial_length) override {
+    return new GeluPlugin(serial_data, serial_length);
   }
 };
+REGISTER_TRT_PLUGIN_V2(GeluPluginCreator);
 
 #if IS_TRT_VERSION_GE(6000)
 class GeluPluginDynamic : public DynamicPluginTensorRT {
@@ -77,7 +87,7 @@ class GeluPluginDynamic : public DynamicPluginTensorRT {
     return new GeluPluginDynamic(with_fp16_);
   }
 
-  const char* getPluginType() const override { return "gelu_plugin"; }
+  const char* getPluginType() const override { return "gelu_plugin_dynamic"; }
   int getNbOutputs() const override { return 1; }
   int initialize() override { return 0; }
 
@@ -119,44 +129,19 @@ class GeluPluginDynamic : public DynamicPluginTensorRT {
   void destroy() override { delete this; }
 };
 
-class GeluPluginDynamicCreator : public nvinfer1::IPluginCreator {
+class GeluPluginDynamicCreator : public TensorRTPluginCreator {
  public:
-  GeluPluginDynamicCreator() {}
-  const char* getPluginName() const override { return "gelu_plugin"; }
+  const char* getPluginName() const override { return "gelu_plugin_dynamic"; }
 
   const char* getPluginVersion() const override { return "1"; }
 
-  const nvinfer1::PluginFieldCollection* getFieldNames() override {
-    return &field_collection_;
-  }
-
-  nvinfer1::IPluginV2* createPlugin(
-      const char* name, const nvinfer1::PluginFieldCollection* fc) override {
-    return nullptr;
-  }
-
   nvinfer1::IPluginV2* deserializePlugin(const char* name,
                                          const void* serial_data,
                                          size_t serial_length) override {
     auto plugin = new GeluPluginDynamic(serial_data, serial_length);
     return plugin;
   }
-
-  void setPluginNamespace(const char* lib_namespace) override {
-    plugin_namespace_ = lib_namespace;
-  }
-
-  const char* getPluginNamespace() const override {
-    return plugin_namespace_.c_str();
-  }
-
- private:
-  std::string plugin_namespace_;
-  std::string plugin_name_;
-  nvinfer1::PluginFieldCollection field_collection_{0, nullptr};
-  std::vector<nvinfer1::PluginField> plugin_attributes_;
 };
-
 REGISTER_TRT_PLUGIN_V2(GeluPluginDynamicCreator);
 #endif
 

paddle/fluid/inference/tensorrt/plugin/hard_swish_op_plugin.cu

@@ -15,20 +15,12 @@
 #include <cassert>
 #include <cstring>
 #include "paddle/fluid/inference/tensorrt/plugin/hard_swish_op_plugin.h"
-#include "paddle/fluid/inference/tensorrt/plugin/trt_plugin_factory.h"
 
 namespace paddle {
 namespace inference {
 namespace tensorrt {
 namespace plugin {
 
-HardSwishPlugin* CreateHardSwishPluginDeserialize(const void* buffer,
-                                                  size_t length) {
-  return new HardSwishPlugin(buffer, length);
-}
-
-REGISTER_TRT_PLUGIN("hard_swish_plugin", CreateHardSwishPluginDeserialize);
-
 nvinfer1::Dims HardSwishPlugin::getOutputDimensions(
     int index, const nvinfer1::Dims* in_dims, int nb_inputs) {
   assert(nb_inputs == 1);