apollo::prediction::SemanticLstmPedestrianTensorrt类 参考

#include <semantic_lstm_pedestrian_tensorrt.h>

类 apollo::prediction::SemanticLstmPedestrianTensorrt 继承关系图:

apollo::prediction::SemanticLstmPedestrianTensorrt 的协作图:

Public 成员函数
	SemanticLstmPedestrianTensorrt ()
	~SemanticLstmPedestrianTensorrt ()
virtual bool	Init ()
	parse model description class and load the model
virtual bool	Inference (const std::vector< void * > &input_buffer, unsigned int input_size, std::vector< void * > *output_buffer, unsigned int output_size)
	performing network inference
virtual bool	LoadModel ()
	load the model from file
virtual void	Destory ()
	free all memory requested, gpu or cpu
Public 成员函数 继承自 apollo::prediction::ModelBase
	ModelBase ()
	~ModelBase ()

额外继承的成员函数
Public 属性 继承自 apollo::prediction::ModelBase
std::string	model_path_
uint8_t	init_ = 0

详细描述

在文件 semantic_lstm_pedestrian_tensorrt.h 第 35 行定义.

构造及析构函数说明

SemanticLstmPedestrianTensorrt()

apollo::prediction::SemanticLstmPedestrianTensorrt::SemanticLstmPedestrianTensorrt ( )

inline

在文件 semantic_lstm_pedestrian_tensorrt.h 第 37 行定义.

{}

~SemanticLstmPedestrianTensorrt()

apollo::prediction::SemanticLstmPedestrianTensorrt::~SemanticLstmPedestrianTensorrt ( )

inline

在文件 semantic_lstm_pedestrian_tensorrt.h 第 38 行定义.

                                      {
        Destory();
    }

成员函数说明

Destory()

void apollo::prediction::SemanticLstmPedestrianTensorrt::Destory ( )

virtual

free all memory requested, gpu or cpu

返回

memory release result, true for success

实现了 apollo::prediction::ModelBase.

在文件 semantic_lstm_pedestrian_tensorrt.cc 第 122 行定义.

                                             {
    cudaStreamDestroy(stream_);
    cudaFree(buffers_[input_image_index_]);
    cudaFree(buffers_[input_obstacle_pos_index_]);
    cudaFree(buffers_[input_obstacle_pos_step_index_]);
    cudaFree(buffers_[output_index_]);
}

Inference()

bool apollo::prediction::SemanticLstmPedestrianTensorrt::Inference ( const std::vector< void * > &  input_buffer, unsigned int  input_size, std::vector< void * > *  output_buffer, unsigned int  output_size  )

virtual

performing network inference

参数

input_buffer	vector of input tensor
input_size	size of input_buffer
output_buffer	vector of output tensor
output_size	size of output_buffer

返回

init result, true for success

实现了 apollo::prediction::ModelBase.

在文件 semantic_lstm_pedestrian_tensorrt.cc 第 80 行定义.

                                  {
    ACHECK(input_size == input_buffer.size() && input_size == 3);
    ACHECK(output_size == output_buffer->size() && output_size == 1);
 
    if (init_ == 0) {
        Init();
    }
 
    // ensure thread safe for inference
    std::lock_guard<std::mutex> lck(mtx);
 
    cudaMemcpyAsync(
            buffers_[input_image_index_],
            input_buffer[0],
            1 * 3 * 224 * 224 * sizeof(float),
            cudaMemcpyHostToDevice,
            stream_);
    cudaMemcpyAsync(
            buffers_[input_obstacle_pos_index_],
            input_buffer[1],
            1 * 20 * 2 * sizeof(float),
            cudaMemcpyHostToDevice,
            stream_);
    cudaMemcpyAsync(
            buffers_[input_obstacle_pos_step_index_],
            input_buffer[2],
            1 * 20 * 2 * sizeof(float),
            cudaMemcpyHostToDevice,
            stream_);
    if (!context_->enqueueV2(buffers_.data(), stream_, nullptr)) {
        return false;
    }
    cudaMemcpyAsync(
            (*output_buffer)[0], buffers_[output_index_], 1 * 30 * 2 * sizeof(float), cudaMemcpyDeviceToHost, stream_);
    cudaStreamSynchronize(stream_);
    return true;
}

Init()

bool apollo::prediction::SemanticLstmPedestrianTensorrt::Init ( )

virtual

parse model description class and load the model

参数

model_config

class to describe model

返回

init result, true for success

实现了 apollo::prediction::ModelBase.

在文件 semantic_lstm_pedestrian_tensorrt.cc 第 130 行定义.

                                          {
    // hook: Apollo License Verification: v_apollo_park
    ModelConf model_config;
    int status = 0;
 
    if (init_ != 0) {
        return true;
    }
 
    std::string class_name = abi::__cxa_demangle(typeid(*this).name(), 0, 0, &status);
    std::string default_config_path
            = apollo::cyber::plugin_manager::PluginManager::Instance()->GetPluginConfPath<ModelBase>(
                    class_name, "conf/default_conf.pb.txt");
 
    if (!cyber::common::GetProtoFromFile(default_config_path, &model_config)) {
        AERROR << "Unable to load model conf file: " << default_config_path;
        return false;
    }
    model_path_ = model_config.model_path();
    init_ = 1;
 
    return LoadModel();
}

LoadModel()

bool apollo::prediction::SemanticLstmPedestrianTensorrt::LoadModel ( )

virtual

load the model from file

返回

loading result, true for success

实现了 apollo::prediction::ModelBase.

在文件 semantic_lstm_pedestrian_tensorrt.cc 第 32 行定义.

                                               {
    std::ifstream engine_file(model_path_, std::ios::binary);
    engine_file.seekg(0, std::ifstream::end);
    int64_t engine_size = engine_file.tellg();
    ACHECK(engine_size > 0);
    engine_file.seekg(0, std::ifstream::beg);
 
    void* engine_blob = malloc(engine_size);
    engine_file.read(reinterpret_cast<char*>(engine_blob), engine_size);
 
    runtime_ = nvinfer1::createInferRuntime(rt_gLogger);
    if (!runtime_) {
        AERROR << "create runtime failed";
        return false;
    }
 
    engine_ = runtime_->deserializeCudaEngine(engine_blob, engine_size);
    if (!engine_) {
        AERROR << "create engine failed";
        return false;
    }
 
    context_ = engine_->createExecutionContext();
    if (!context_) {
        AERROR << "create context failed";
        return false;
    }
    // check model input output
    ACHECK(engine_->getNbBindings() == 4);
 
    input_image_index_ = engine_->getBindingIndex(INPUT_IMAGE_NAME);
    input_obstacle_pos_index_ = engine_->getBindingIndex(INPUT_OBSTACLE_POS_NAME);
    input_obstacle_pos_step_index_ = engine_->getBindingIndex(INPUT_OBSTACLE_POS_STEP_NAME);
    output_index_ = engine_->getBindingIndex(OUTPUT_NAME);
 
    buffers_ = std::vector<void*>{nullptr, nullptr, nullptr, nullptr};
 
    // size based on the shape of model input and output
    cudaMalloc(&buffers_[input_image_index_], 1 * 3 * 224 * 224 * sizeof(float));
    cudaMalloc(&buffers_[input_obstacle_pos_index_], 1 * 20 * 2 * sizeof(float));
    cudaMalloc(&buffers_[input_obstacle_pos_step_index_], 1 * 20 * 2 * sizeof(float));
    cudaMalloc(&buffers_[output_index_], 1 * 30 * 2 * sizeof(float));
 
    cudaStreamCreate(&stream_);
 
    return true;
}

---

该类的文档由以下文件生成:

• modules/prediction_plugin/semantic_lstm_pedestrian_tensorrt/semantic_lstm_pedestrian_tensorrt.h
• modules/prediction_plugin/semantic_lstm_pedestrian_tensorrt/semantic_lstm_pedestrian_tensorrt.cc