PaddlePaddle
diff --git a/‎cmake/external/json.cmake
Copy file name to clipboard
-1Lines changed: 0 additions & 1 deletion b/‎cmake/external/json.cmake
Copy file name to clipboard
-1Lines changed: 0 additions & 1 deletion
diff --git a/‎paddle/fluid/framework/new_executor/instruction/tensorrt_engine_instruction.cc
Copy file name to clipboard
+2-3Lines changed: 2 additions & 3 deletions b/‎paddle/fluid/framework/new_executor/instruction/tensorrt_engine_instruction.cc
Copy file name to clipboard
+2-3Lines changed: 2 additions & 3 deletions
diff --git a/‎paddle/fluid/inference/tensorrt/CMakeLists.txt
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions b/‎paddle/fluid/inference/tensorrt/CMakeLists.txt
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions
diff --git a/‎paddle/fluid/inference/tensorrt/pir/CMakeLists.txt
Copy file name to clipboard
+12Lines changed: 12 additions & 0 deletions b/‎paddle/fluid/inference/tensorrt/pir/CMakeLists.txt
Copy file name to clipboard
+12Lines changed: 12 additions & 0 deletions
diff --git a/‎paddle/fluid/inference/tensorrt/pir/declare_plugin.h
Copy file name to clipboard
+19Lines changed: 19 additions & 0 deletions b/‎paddle/fluid/inference/tensorrt/pir/declare_plugin.h
Copy file name to clipboard
+19Lines changed: 19 additions & 0 deletions
diff --git a/‎paddle/fluid/inference/tensorrt/pir/dynamic_shape_infermeta.cc
Copy file name to clipboard
+177Lines changed: 177 additions & 0 deletions b/‎paddle/fluid/inference/tensorrt/pir/dynamic_shape_infermeta.cc
Copy file name to clipboard
+177Lines changed: 177 additions & 0 deletions
diff --git a/‎paddle/fluid/inference/tensorrt/pir/dynamic_shape_infermeta_factory.h
Copy file name to clipboard
+94Lines changed: 94 additions & 0 deletions b/‎paddle/fluid/inference/tensorrt/pir/dynamic_shape_infermeta_factory.h
Copy file name to clipboard
+94Lines changed: 94 additions & 0 deletions
diff --git a/‎paddle/fluid/inference/tensorrt/pir/dynamic_shape_infermeta_registry.h
Copy file name to clipboard
+21Lines changed: 21 additions & 0 deletions b/‎paddle/fluid/inference/tensorrt/pir/dynamic_shape_infermeta_registry.h
Copy file name to clipboard
+21Lines changed: 21 additions & 0 deletions
@@ -20,7 +20,6 @@ set(JSON_INCLUDE_DIR ${JSON_PREFIX_DIR}/include)
 set(SOURCE_DIR ${PADDLE_SOURCE_DIR}/third_party/nlohmann_json)
 set(SOURCE_INCLUDE_DIR ${SOURCE_DIR}/include)
 
-include_directories(${JSON_INCLUDE_DIR})
 include_directories(${SOURCE_INCLUDE_DIR})
 
 set(JSON_BuildTests
 
@@ -630,7 +630,6 @@ void TensorRTEngineInstruction::BindOutputTensor(
 
   auto *fluid_t = output_tensor;
   fluid_t->Resize(common::make_ddim(ddim));
-
   PADDLE_ENFORCE_LT(bind_index,
                     num_bindings,
                     common::errors::InvalidArgument(
@@ -710,10 +709,10 @@ void TensorRTEngineInstruction::RunTrt() {
                                         out_variable_array->at(i)->Type()));
     }
   }
-
+  VLOG(4) << "Start Runing trt engine...";
   // Execute the engine.
   trt_engine_->Execute(runtime_batch, &buffers, stream);
-
+  VLOG(4) << "End Runing trt engine and deal with output";
   for (size_t i = 0; i < out_variable_array->size(); ++i) {
     auto type = outputs_dtype_[i];
 
 
@@ -57,3 +57,4 @@ endif()
 
 add_subdirectory(plugin)
 add_subdirectory(convert)
+add_subdirectory(pir)
@@ -0,0 +1,12 @@
+list(APPEND SRCS generic_plugin.cu)
+
+nv_library(
+  dynamic_shape_infermeta
+  SRCS dynamic_shape_infermeta.cc
+  DEPS common pir)
+
+nv_library(
+  pir_tensorrt_plugin
+  SRCS ${SRCS}
+  DEPS common pir tensorrt_plugin dynamic_shape_infermeta trt_plugin
+       pir_save_load)
@@ -0,0 +1,19 @@
+// Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "paddle/common/macros.h"
+
+DECLARE_FILE_SYMBOLS(generic_plugin);
@@ -0,0 +1,177 @@
+// Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "paddle/fluid/inference/tensorrt/pir/dynamic_shape_infermeta_factory.h"
+#include "paddle/phi/core/enforce.h"
+#include "paddle/pir/include/core/builtin_attribute.h"
+
+namespace paddle::inference::tensorrt::pir {
+
+nvinfer1::DimsExprs UnchangedInferMeta(
+    int output_index,
+    const nvinfer1::DimsExprs* inputs,
+    int nb_inputs,
+    nvinfer1::IExprBuilder& expr_builder,  // NOLINT
+    const ::pir::AttributeMap& op_attributes) {
+  PADDLE_ENFORCE_EQ(nb_inputs,
+                    1,
+                    phi::errors::InvalidArgument(
+                        "inputs of UnchangedInferMeta should be equal to 1, "
+                        "But received (%s)",
+                        nb_inputs));
+  return inputs[0];
+}
+
+inline const nvinfer1::IDimensionExpr* CalcOutputSize(
+    const nvinfer1::IDimensionExpr* input_size,
+    const nvinfer1::IDimensionExpr* filter_size,
+    const nvinfer1::IDimensionExpr* dilation,
+    const nvinfer1::IDimensionExpr* padding1,
+    const nvinfer1::IDimensionExpr* padding2,
+    const nvinfer1::IDimensionExpr* stride,
+    nvinfer1::IExprBuilder& expr_builder  // NOLINT
+) {
+  // dkernel = dilation * (filter_size - 1) + 1;
+  const nvinfer1::IDimensionExpr* dkernel = expr_builder.operation(
+      nvinfer1::DimensionOperation::kSUM,
+      *expr_builder.operation(
+          nvinfer1::DimensionOperation::kPROD,
+          *dilation,
+          *expr_builder.operation(nvinfer1::DimensionOperation::kSUB,
+                                  *filter_size,
+                                  *expr_builder.constant(1))),
+      *expr_builder.constant(1));
+
+  // output_size = (input_size + padding1 + padding2 - dkernel) / stride + 1;
+  const nvinfer1::IDimensionExpr* tmp = expr_builder.operation(
+      nvinfer1::DimensionOperation::kSUB,
+      *expr_builder.operation(
+          nvinfer1::DimensionOperation::kSUM,
+          *expr_builder.operation(
+              nvinfer1::DimensionOperation::kSUM, *input_size, *padding1),
+          *padding2),
+      *dkernel);
+
+  const nvinfer1::IDimensionExpr* output_size = expr_builder.operation(
+      nvinfer1::DimensionOperation::kSUM,
+      *expr_builder.operation(
+          nvinfer1::DimensionOperation::kFLOOR_DIV, *tmp, *stride),
+      *expr_builder.constant(1));
+  return output_size;
+}
+
+nvinfer1::DimsExprs UnfoldInferMeta(
+    int output_index,
+    const nvinfer1::DimsExprs* inputs,
+    int nb_inputs,
+    nvinfer1::IExprBuilder& expr_builder,  // NOLINT
+    const ::pir::AttributeMap& op_attributes) {
+  PADDLE_ENFORCE_EQ(
+      nb_inputs,
+      1,
+      phi::errors::InvalidArgument("inputs of unfold should be equal to 1, "
+                                   "But received (%s)",
+                                   nb_inputs));
+
+  const nvinfer1::DimsExprs in_dims = inputs[0];
+  std::vector<const nvinfer1::IDimensionExpr*> out_dims;
+  out_dims.push_back(in_dims.d[0]);
+
+  std::vector<int> kernel_sizes;
+  auto kernel_sizes_attrs = op_attributes.at("kernel_sizes")
+                                .dyn_cast<::pir::ArrayAttribute>()
+                                .AsVector();
+  for (auto kernel_sizes_attr : kernel_sizes_attrs) {
+    kernel_sizes.push_back(
+        kernel_sizes_attr.dyn_cast<::pir::Int32Attribute>().data());
+  }
+
+  std::vector<int> dilations;
+  auto dilations_attrs = op_attributes.at("dilations")
+                             .dyn_cast<::pir::ArrayAttribute>()
+                             .AsVector();
+  for (auto dilations_attr : dilations_attrs) {
+    dilations.push_back(
+        dilations_attr.dyn_cast<::pir::Int32Attribute>().data());
+  }
+
+  std::vector<int> paddings;
+  auto paddings_attrs =
+      op_attributes.at("paddings").dyn_cast<::pir::ArrayAttribute>().AsVector();
+  for (auto paddings_attr : paddings_attrs) {
+    paddings.push_back(paddings_attr.dyn_cast<::pir::Int32Attribute>().data());
+  }
+
+  std::vector<int> strides;
+  auto strides_attrs =
+      op_attributes.at("strides").dyn_cast<::pir::ArrayAttribute>().AsVector();
+  for (auto strides_attr : strides_attrs) {
+    strides.push_back(strides_attr.dyn_cast<::pir::Int32Attribute>().data());
+  }
+
+  // output_channels = in_dims[1] * kernel_sizes[0] * kernel_sizes[1];
+  const nvinfer1::IDimensionExpr* output_channels = expr_builder.operation(
+      nvinfer1::DimensionOperation::kPROD,
+      *in_dims.d[1],
+      *expr_builder.operation(nvinfer1::DimensionOperation::kPROD,
+                              *expr_builder.constant(kernel_sizes[0]),
+                              *expr_builder.constant(kernel_sizes[1])));
+  out_dims.push_back(output_channels);
+
+  const nvinfer1::IDimensionExpr* output_height =
+      CalcOutputSize(in_dims.d[2],
+                     expr_builder.constant(kernel_sizes[0]),
+                     expr_builder.constant(dilations[0]),
+                     expr_builder.constant(paddings[0]),
+                     expr_builder.constant(paddings[2]),
+                     expr_builder.constant(strides[0]),
+                     expr_builder);
+  const nvinfer1::IDimensionExpr* output_width =
+      CalcOutputSize(in_dims.d[3],
+                     expr_builder.constant(kernel_sizes[1]),
+                     expr_builder.constant(dilations[1]),
+                     expr_builder.constant(paddings[1]),
+                     expr_builder.constant(paddings[3]),
+                     expr_builder.constant(strides[1]),
+                     expr_builder);
+
+  const nvinfer1::IDimensionExpr* output_col_length = expr_builder.operation(
+      nvinfer1::DimensionOperation::kPROD, *output_height, *output_width);
+
+  out_dims.push_back(output_col_length);
+  nvinfer1::DimsExprs output = {};
+  output.nbDims = out_dims.size();
+  for (size_t i = 0; i < out_dims.size(); i++) output.d[i] = out_dims[i];
+  return output;
+}
+
+nvinfer1::DimsExprs ArgsortInferMeta(
+    int output_index,
+    const nvinfer1::DimsExprs* inputs,
+    int nb_inputs,
+    nvinfer1::IExprBuilder& expr_builder,  // NOLINT
+    const ::pir::AttributeMap& op_attributes) {
+  const nvinfer1::DimsExprs input_dims = inputs[0];
+  nvinfer1::DimsExprs output = {};
+  output.nbDims = input_dims.nbDims;
+  for (int i = 0; i < input_dims.nbDims; ++i) {
+    output.d[i] = input_dims.d[i];
+  }
+  return output;
+}
+
+PD_REGISTER_DYNAMIC_INFER_META_FN(inverse, UnchangedInferMeta);
+PD_REGISTER_DYNAMIC_INFER_META_FN(unfold, UnfoldInferMeta);
+PD_REGISTER_DYNAMIC_INFER_META_FN(argsort, ArgsortInferMeta);
+}  // namespace paddle::inference::tensorrt::pir
@@ -0,0 +1,94 @@
+// Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <NvInfer.h>
+#include <string>
+
+#include "paddle/common/macros.h"
+#include "paddle/phi/core/enforce.h"
+#include "paddle/pir/include/core/operation.h"
+#include "paddle/utils/flat_hash_map.h"
+
+namespace paddle::inference::tensorrt::pir {
+
+using DynamicMetaFn =
+    nvinfer1::DimsExprs (*)(int output_index,
+                            const nvinfer1::DimsExprs* inputs,
+                            int nb_inputs,
+                            nvinfer1::IExprBuilder& expr_builder,  // NOLINT
+                            const ::pir::AttributeMap& op_attributes);
+
+class DynamicMetaFnFactory {
+ public:
+  static DynamicMetaFnFactory& Instance() {
+    static DynamicMetaFnFactory g_meta_fn_map;
+    return g_meta_fn_map;
+  }
+
+  bool Contains(const std::string& op_name) const {
+    return meta_fn_map_.count(op_name) > 0;
+  }
+
+  void Insert(std::string op_name, DynamicMetaFn infer_meta_fn) {
+    PADDLE_ENFORCE_NE(
+        Contains(op_name),
+        true,
+        phi::errors::AlreadyExists(
+            "`%s` op's DynamicInferMetaFn has been registered.", op_name));
+    meta_fn_map_.insert({std::move(op_name), std::move(infer_meta_fn)});
+  }
+
+  const DynamicMetaFn& Get(const std::string& op_name) const {
+    auto it = meta_fn_map_.find(op_name);
+    PADDLE_ENFORCE_NE(
+        it,
+        meta_fn_map_.end(),
+        phi::errors::NotFound(
+            "`%s` op's DynamicInferMetaFn has been registered.", op_name));
+    return it->second;
+  }
+
+ private:
+  DynamicMetaFnFactory() = default;
+
+  paddle::flat_hash_map<std::string, DynamicMetaFn> meta_fn_map_;
+
+  DISABLE_COPY_AND_ASSIGN(DynamicMetaFnFactory);
+};
+
+struct DynamicMetaFnRegistrar {
+  DynamicMetaFnRegistrar(const char* op_name, DynamicMetaFn infer_meta_fn) {
+    DynamicMetaFnFactory::Instance().Insert(op_name, std::move(infer_meta_fn));
+  }
+
+  static void Touch() {}
+};
+
+#define PD_REGISTER_DYNAMIC_INFER_META_FN(op_name, dynamic_infer_meta_fn) \
+  static paddle::inference::tensorrt::pir::DynamicMetaFnRegistrar         \
+      registrar_pir_dynamic_infer_meta_fn_for_##op_name(                  \
+          #op_name, dynamic_infer_meta_fn);                               \
+  int TouchPIRDynamicMetaFnRegistrar_##op_name() {                        \
+    registrar_pir_dynamic_infer_meta_fn_for_##op_name.Touch();            \
+    return 0;                                                             \
+  }
+
+#define USE_TRT_DYNAMIC_INFER_META_FN(op_name)               \
+  extern int TouchPIRDynamicMetaFnRegistrar_##op_name();     \
+  static int use_op_pir_dynamic_infer_meta##op_name UNUSED = \
+      TouchPIRDynamicMetaFnRegistrar_##op_name();
+
+}  // namespace paddle::inference::tensorrt::pir
@@ -0,0 +1,21 @@
+// Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "paddle/fluid/inference/tensorrt/pir/dynamic_shape_infermeta_factory.h"
+
+namespace paddle::inference::tensorrt::pir {
+USE_TRT_DYNAMIC_INFER_META_FN(inverse);
+}  // namespace paddle::inference::tensorrt::pir
Original file line number	Diff line number	Diff line change
`@@ -57,3 +57,4 @@ endif()`
`57`	`57`
`58`	`58`	`add_subdirectory(plugin)`
`59`	`59`	`add_subdirectory(convert)`
	`60`	`+add_subdirectory(pir)`