20211221：Tensorrt部署解析模型uff模型

void createngine() //生成 engine
{
    //创建builder，第一步创建build
    IBuilder* builder = createInferBuilder(gLogger);
    builder->setMaxBatchSize(16); //设置最大batchsize
    
    //创建network,第二步创建网络
    INetworkDefinition* network = builder->createNetworkV2(0U);

    //创建parser，第三步创建解析器
    IUffParser* parser = createUffParser();

    //注册网络输入输出，第四步注册解析器并解析网络  (输入名和输出名可在.uff文件中找到)
    parser->registerInput("inputs", DimsCHW(1, 576 , 960), UffInputOrder::kNCHW);
    parser->registerOutput("generator/deconv/BiasAdd");

    //使用parser，填充network  （DataType::kFLOAT（fp32） DataType::kHALF(fp16)）
    parser->parse("/home/xxxx.uff",
                  *network,
                  nvinfer1::DataType::kHALF);

    //创建config并设置最大的工作空间，第五步配置工作空间
    IBuilderConfig* config = builder->createBuilderConfig();
    config->setMaxWorkspaceSize(1 << 30);

    //创建engine, 第六步创建引擎
    ICudaEngine* engine = builder->buildEngineWithConfig(*network,*config);

    //序列化保存engine到文件
    IHostMemory *serializedModel = engine->serialize();
    ofstream p("xxxx.engine");
    p.write(reinterpret_cast<const char*>(serializedModel->data()),             serializedModel->size());

    //释放资源
    parser->destroy();
    network->destroy();
    builder->destroy();
    engine->destroy();
    serializedModel->destroy();
    config->destroy();
    return;
}

//解析onnx手写代码

#include <iostream>
#include <fstream>
#include <string>
#include "NvOnnxParser.h"
#include "NvCaffeParser.h"
#include "NvUffParser.h"
#include "NvInfer.h"
#include "logger.h"
#include "pthread.h"

using namespace std;
using namespace nvinfer1;

#include <condition_variable>
#include <mutex>

int main()
{
    std::string modelFile = "./fd_sim_1221.onnx";
    nvinfer1::IHostMemory *modelStream(nullptr);
    nvinfer1::IBuilder *builder = nvinfer1::createInferBuilder(gLogger.getTRTLogger());
    const auto explicitBatch = 1U << static_cast<uint32_t>(nvinfer1::NetworkDefinitionCreationFlag::kEXPLICIT_BATCH);
    nvinfer1::INetworkDefinition *network = builder->createNetworkV2(explicitBatch);
    nvinfer1::IBuilderConfig *config = builder->createBuilderConfig();
    nvonnxparser::IParser *parser = nvonnxparser::createParser(*network, gLogger.getTRTLogger());
    if (!parser->parseFromFile(modelFile.c_str(), static_cast<int>(ILogger::Severity::kWARNING)))
    {
        std::cout << "Failure while parsing ONNX file" << std::endl;
        return false;
    }

    builder->setMaxWorkspaceSize(1 << 30);
    builder->setMaxBatchSize(64);
    builder->setFp16Mode(2);

    nvinfer1::ICudaEngine *engine = builder->buildCudaEngine(*network);
    const int inputIndex = engine->getBindingIndex("input0");
    const int inputIndex544 = engine->getBindingIndex("544");

    cout << "inputIndex: " << inputIndex << endl;
    cout << "inputIndex544: " << inputIndex544 << endl;

    // auto input_dims = engine->getBindingDimensions(0);
    // std::cout << "input dim: ";
    // int input_size = 1;
    // for (int i = 0; i < input_dims.nbDims; i++)
    // {
    //     std::cout << input_dims.d[i] << ",";
    //     input_size *= input_dims.d[i];
    // }
    // std::cout << std::endl;
    // auto out_dims = engine->getBindingDimensions(inputIndex544);
    // auto output_size = 12;
    // std::cout << "output dim: ";
    // for (int j = 0; j < out_dims.nbDims; j++)
    // {
    //     output_size *= out_dims.d[j];
    //     std::cout << out_dims.d[j] << ",";
    // }

    const char *input_blob_name = network->getInput(0)->getName();

    const char *output_blob_name = network->getOutput(0)->getName();
    printf("input_blob_name : %s \n", input_blob_name);
    printf("output_blob_name : %s \n", output_blob_name);

    void *buffers[2];
    //cudaMalloc(&buffers[0], 1 * 3 * 360 * 640 * sizeof(float));
    //cudaMalloc(&buffers[1], 1 * 8 * 23 * 40 * sizeof(float));

    nvinfer1::IHostMemory *trtModelStream = engine->serialize();
    // 序列化到磁盘，方便后续调用
    std::string trtModelName = "yolov3_infer.trt";
    std::ofstream ofs(trtModelName.c_str(), std::ios::out | std::ios::binary);
    ofs.write((char *)(trtModelStream->data()), trtModelStream->size());
    ofs.close();
    parser->destroy();

    engine->destroy();
    network->destroy();
    config->destroy();
    builder->destroy();
    // size_t size{0};
    // std::ifstream file(trtModelName, std::ios::binary);
    // if (file.good())
    // {
    //     file.seekg(0, file.end);
    //     size = file.tellg();
    //     file.seekg(0, file.beg);
    //     // trtModelStream = new char[size];
    //     // assert(trtModelStream);
    //     // file.read(trtModelStream, size);
    //     file.close();
    // }
    // void *buffers[2];
    // IRuntime *runtime = createInferRuntime(gLogger);
    // assert(runtime != nullptr);
    // ICudaEngine *engine = runtime->deserializeCudaEngine(trtModelStream, trtModelStream->size());
    // const int inputIndex = engine->getBindingIndex("input0");
    // const int inputIndex = engine->getBindingIndex("544");
    // cout << "input: " << inputIndex << endl;

    // const int outputIndex = engine->getBindingIndex("output0");
    // IExecutionContext* context = engine->createExecutionContext();
    return 0;
}