diff --git a/paddle/fluid/inference/tensorrt/convert/CMakeLists.txt b/paddle/fluid/inference/tensorrt/convert/CMakeLists.txt index c35d61ef057a5fc4bf7876277fce0561c29488a9..cd51fd609c02b483bc289c513584855aed6a3f0b 100644 --- a/paddle/fluid/inference/tensorrt/convert/CMakeLists.txt +++ b/paddle/fluid/inference/tensorrt/convert/CMakeLists.txt @@ -1,2 +1,2 @@ nv_library(tensorrt_convert SRCS convert.cc DEPS dynload_cuda) -nv_test(tensorrt_convert_test SRCS convert_test.cc DEPS tensorrt paddle_fluid) +nv_test(test_tensorrt_convert SRCS test_convert.cc DEPS tensorrt paddle_fluid) diff --git a/paddle/fluid/inference/tensorrt/convert/convert.cc b/paddle/fluid/inference/tensorrt/convert/convert.cc index be813cf93a8a984de93ecfbf1c827cbccacb0960..bf6f1cd2c1c943128ff0c84570bda2b0d638b6e2 100644 --- a/paddle/fluid/inference/tensorrt/convert/convert.cc +++ b/paddle/fluid/inference/tensorrt/convert/convert.cc @@ -13,39 +13,23 @@ See the License for the specific language governing permissions and limitations under the License. */ #include "paddle/fluid/inference/tensorrt/convert/convert.h" +#include "paddle/fluid/inference/tensorrt/convert/convert_conv2d.h" +#include "paddle/fluid/inference/tensorrt/convert/convert_mul.h" namespace paddle { namespace inference { namespace tensorrt { -void TensorRTConverter::ConvertOp(const framework::OpDesc& op) { - std::string type = op.Type(); - PADDLE_ENFORCE(op_registry_.count(type), "No converter registered for op: %s", - type); - std::function op_converter = - op_registry_.at(type); - op_converter(op); -} - void TensorRTConverter::ConvertBlock(const framework::BlockDesc& block) { for (auto op : block.AllOps()) { - ConvertOp(*op); + std::string type = op->Type(); + PADDLE_ENFORCE(GetOpConverter().count(type), + "No converter registered for op: %s", type); + auto op_converter = GetOpConverter()[type]; + op_converter->Convert(*op); } } -void TensorRTConverter::RegisterOpConverters() { - op_registry_["mul"] = ConvertMul; - op_registry_["conv2d"] = ConvertConv2D; -} - -void TensorRTConverter::ConvertMul(const framework::OpDesc& op) { - LOG(INFO) << "convert a fluid mul op to tensorrt fc layer without bias"; -} - -void TensorRTConverter::ConvertConv2D(const framework::OpDesc& op) { - LOG(INFO) << "convert a fluid Conv2d op to tensorrt conv layer without bias"; -} - } // namespace tensorrt } // namespace inference } // namespace paddle diff --git a/paddle/fluid/inference/tensorrt/convert/convert.h b/paddle/fluid/inference/tensorrt/convert/convert.h index a029152031609ef8e62dc1249ebd6ffb34e1f846..4f9523305737b4ac70a839b64657b4af032beefd 100644 --- a/paddle/fluid/inference/tensorrt/convert/convert.h +++ b/paddle/fluid/inference/tensorrt/convert/convert.h @@ -26,37 +26,46 @@ namespace paddle { namespace inference { namespace tensorrt { -class TensorRTConverter { +class ConverterBase { public: - explicit TensorRTConverter(const framework::Scope& scope) : scope_(scope) { - this->RegisterOpConverters(); - } + ConverterBase() {} - // convert fluid op to tensorrt layer - void ConvertOp(const framework::OpDesc& op); - - // convert fluid block to tensorrt network - void ConvertBlock(const framework::BlockDesc& block); - - private: - // convert op registry, whose key is the fluid op type, and value is the - // convert tensorrt function name - std::unordered_map> - op_registry_; // fluid inference scope - const framework::Scope& scope_; + framework::Scope* scope_; // tensorrt input/output tensor list, whose key is the fluid variable name, // and value is the pointer position of tensorrt tensor std::unordered_map tr_tensors_; +}; - // register different op converters - void RegisterOpConverters(); +class OpConverter : public ConverterBase { + public: + OpConverter() {} + virtual ~OpConverter() {} - // convert a fluid Mul op to tensorrt fc layer without bias - static void ConvertMul(const framework::OpDesc& op); + // convert fluid op to tensorrt layer + virtual void Convert(const framework::OpDesc& op) = 0; +}; + +static std::unordered_map& GetOpConverter() { + static std::unordered_map register_op_converter; + return register_op_converter; +} - // convert a fluid Conv2d op to tensorrt conv layer without bias - static void ConvertConv2D(const framework::OpDesc& op); +#define REGISTER_TRT_OP_CONVETER(op_type, convert_class) \ + class convert_class##Register { \ + public: \ + convert_class##Register() { \ + GetOpConverter()[#op_type] = new convert_class; \ + } \ + }; \ + convert_class##Register convert_class##reg; + +class TensorRTConverter : public ConverterBase { + public: + TensorRTConverter() {} + + // convert fluid block to tensorrt network + void ConvertBlock(const framework::BlockDesc& block); }; } // namespace tensorrt diff --git a/paddle/fluid/inference/tensorrt/convert/convert_conv2d.h b/paddle/fluid/inference/tensorrt/convert/convert_conv2d.h new file mode 100644 index 0000000000000000000000000000000000000000..34622f92a492b725e65a3e5121de6c47a6aa3a91 --- /dev/null +++ b/paddle/fluid/inference/tensorrt/convert/convert_conv2d.h @@ -0,0 +1,36 @@ +/* Copyright (c) 2018 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 + + http://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/convert/convert.h" + +namespace paddle { +namespace inference { +namespace tensorrt { + +class Conv2dOpConverter : public OpConverter { + public: + Conv2dOpConverter() {} + void Convert(const framework::OpDesc& op); +}; + +void Conv2dOpConverter::Convert(const framework::OpDesc& op) { + LOG(INFO) << "convert a fluid conv2d op to tensorrt conv layer without bias"; +} + +REGISTER_TRT_OP_CONVETER(conv2d, Conv2dOpConverter); + +} // namespace tensorrt +} // namespace inference +} // namespace paddle diff --git a/paddle/fluid/inference/tensorrt/convert/convert_mul.h b/paddle/fluid/inference/tensorrt/convert/convert_mul.h new file mode 100644 index 0000000000000000000000000000000000000000..a626300cf32e440ec77cd193c67be8174802c8d5 --- /dev/null +++ b/paddle/fluid/inference/tensorrt/convert/convert_mul.h @@ -0,0 +1,35 @@ +/* Copyright (c) 2018 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 + + http://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/convert/convert.h" + +namespace paddle { +namespace inference { +namespace tensorrt { + +class MulOpConverter : public OpConverter { + public: + MulOpConverter() {} + void Convert(const framework::OpDesc& op); +}; + +REGISTER_TRT_OP_CONVETER(mul, MulOpConverter); +void MulOpConverter::Convert(const framework::OpDesc& op) { + LOG(INFO) << "convert a fluid mul op to tensorrt fc layer without bias"; +} + +} // namespace tensorrt +} // namespace inference +} // namespace paddle diff --git a/paddle/fluid/inference/tensorrt/convert/convert_test.cc b/paddle/fluid/inference/tensorrt/convert/test_convert.cc similarity index 94% rename from paddle/fluid/inference/tensorrt/convert/convert_test.cc rename to paddle/fluid/inference/tensorrt/convert/test_convert.cc index dd1526b783d0b7d0fa0932fdee10113eeca987f1..d761b4eb7f60d156e785d9ac6cbbae63cee48f30 100644 --- a/paddle/fluid/inference/tensorrt/convert/convert_test.cc +++ b/paddle/fluid/inference/tensorrt/convert/test_convert.cc @@ -12,9 +12,9 @@ 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/convert/convert.h" #include #include "paddle/fluid/framework/program_desc.h" +#include "paddle/fluid/inference/tensorrt/convert/convert.h" namespace paddle { namespace inference { @@ -28,8 +28,7 @@ TEST(tensorrt, ConvertBlock) { auto* conv2d_op = block->AppendOp(); conv2d_op->SetType("conv2d"); - framework::Scope scope; - TensorRTConverter converter(scope); + TensorRTConverter converter; converter.ConvertBlock(*block); }