【TRT】C++多线程

已于 2023-05-26 00:04:24 修改
阅读量583 收藏 4
点赞数
分类专栏： trt_infer 文章标签： c++ 开发语言
于 2023-05-24 00:09:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_30340349/article/details/130837142
版权
本文介绍了C++中多线程的基本操作，包括启动线程（join和detach）、参数传递以及类成员函数作为线程函数。接着讨论了生产者消费者模型的实现，强调了线程安全和同步机制，如互斥锁和条件变量。文章还提出了跨线程结果传输的问题，并利用future和promise解决。此外，通过RAII模式改进了资源管理，提出了接口模式以隐藏内部实现。最后，文章讨论了多batch生产者消费者的封装，包括模型加载、任务提交与结果返回，以及程序退出机制和生产者速率控制。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1. thread

1.1 启动线程

#include <stdio.h>
#include <chrono>
#include <thread>

using namespace std;

void worker(int a, std::string& output) {
    printf("hello thread!\n");
    this_thread::sleep_for(chrono::milliseconds(1000));
    output = "work output";
    printf("worker done.\n");
}

int main() {

    std::string output;
    thread t(worker, 567, std::ref(output));

    if (t.joinable()) {
        t.join();
    }
    printf("output: %s\n", output);
    printf("main done.\n");
    return 0;
}

注意点：

  • 如果主线程不join.等待子线程。在析构的时候会报错。
  • 如果join一个没有启动的线程变量，也会报错
  • 在join时判断线程变量是否可以join

1.2 detach

  • 分离线程，取消管理权，使得线程成为野线程。一般不建议使用，主要用在，不需要知道线程何时结束的场景，比如多线程拷贝文件操作时。
  • detach 过后，不需要join。

1.3 参数传递

注意传引用的时候

thread t(worker, 567, std::ref(output));

1.4 类成员函数作为线程函数

class Infer {
public:
    Infer() {
        worker_thread_ = thread(&Infer::infer_worker, this);
    }
    ~Infer() {
        if(worker_thread_.joinable()) {
            worker_thread_.join();
        }
    }
private:
    void infer_worker() {
        for (size_t i = 0; i < 100; i++)
        {
            printf("hello thread!\n");
            this_thread::sleep_for(chrono::milliseconds(2000));
        }
    }

private:
    thread worker_thread_;
};

将类成员函数作为线程函数：

worker_thread_ = thread(&Infer::infer_worker, this);

2. 生产者消费者

2.1 最简单实现

#include <stdio.h>
#include <thread>
#include <mutex>
#include <string>
#include <queue>
#include <chrono>

using namespace std;
queue<string> qjobs_;

void video_capture() {
    int pic_id = 0;
    while(true) {
        char name[100];
        sprintf(name, "PIC_%d", pic_id++);
        printf("生产了一个新图片: %s\n", name);
        qjobs_.push(name);
        this_thread::sleep_for(chrono::microseconds(1000));
    }
}

void infer_worker() {
    while (true)
    {
        if(!qjobs_.empty()) {
            auto pic = qjobs_.front();
            qjobs_.pop();
            printf("消费掉一个图片: %s\n", pic);
            this_thread::sleep_for(chrono::microseconds(1000));
        }
        // 强制当前线程交出时间片，防止一直占用cpu资源
        this_thread::yield();
    }
    
}

int main() {
    thread t1(video_capture);
    thread t2(infer_worker);
    if (t1.joinable()) {
        t1.join();
    }
    if (t2.joinable()) {
        t2.join();
    }
    printf("Done!");
    return 0;
}

因为queue 不是线程安全的，所以需要对共享资源加锁.
这里使用加锁的逻辑

#include <mutex>
mutex lock_;
{
	lock_guard l(lock_);
	/*code*/
}

#include <stdio.h>
#include <thread>
#include <mutex>
#include <string>
#include <queue>
#include <chrono>
#include <mutex>

using namespace std;
mutex lock_;
queue<string> qjobs_;

void video_capture() {
    int pic_id = 0;
    while(true) {
        {
            lock_guard lock(lock_);
            char name[100];
            sprintf(name, "PIC_%d", pic_id++);
            printf("生产了一个新图片: %s\n", name);
            qjobs_.push(name);
        }
        this_thread::sleep_for(chrono::microseconds(1000));
    }
}

void infer_worker() {
    while (true)
    {
        if(!qjobs_.empty()) {
            {
                lock_guard lock(lock_);
                auto pic = qjobs_.front();
                qjobs_.pop();
                printf("消费掉一个图片: %s\n", pic);
            }
            this_thread::sleep_for(chrono::microseconds(1000));
        }
        // 强制当前线程交出时间片，防止一直占用cpu资源
        this_thread::yield();
    }
    
}

int main() {
    thread t1(video_capture);
    thread t2(infer_worker);
    if (t1.joinable()) {
        t1.join();
    }
    if (t2.joinable()) {
        t2.join();
    }
    printf("Done!");
    return 0;
}

2.2. 队列溢出问题

当生产太快，消费太慢，如何实现溢出限制。当队列满的时候，不生产，等待队列有空间再生产。需求描述：

  • 当队列满的时候，停止生产，生产线程阻塞，并且释放对队列的锁。
  • 消费者消费后，通知生产线程，生产线程重新获得锁，继续生产。
    为了满足上述的需求，这里可以使用c++ 的 condition_variable来实现
// 生产者线程
{
   unique_lock lock(lock_);
     // cv_.wait() 
     // 当条件满足时， 继续执行， 获得锁的占有权
     // 当条件不满足时，线程阻塞等待,释放锁
     cv_.wait(lock, [&](){
         return qjobs_.size() < limit_;
     });
     char name[100];
     sprintf(name, "PIC_%d", pic_id++);
     printf("生产了一个新图片: %s qjob.size(): %d\n", name, qjobs_.size());
     qjobs_.push(name);
 }
// 消费者线程
{
   unique_lock lock(lock_);
    auto pic = qjobs_.front();
    qjobs_.pop();
    printf("消费掉一个图片: %s\n", pic);
    // 消费一个后通知 cv_ 并释放锁
    cv_.notify_one();
}
  • condition_variable 必须配合unique_lock 使用
  • cv_.wait() 当条件满足时 获得锁的占有权，继续执行
  • 当条件不满足时，释放锁，线程阻塞等待
  • cv_.notify_one() 消费完后通知生产者线程继续生产，并释放锁。

2.3. 跨线程结果传输

为了在消费者线程外拿到推理结果，需要借助一些机制来实现跨线程结果传输。
这里利用c++ 标准线程的 future 和 promise 实现
构建 Job 结构体

struct Job {
	shared_ptr<promise<string>> pro;
	string input;
}

qjobs_

struct Job {
    shared_ptr<promise<string>> pro;
    string input;
};

生产者线程

void video_capture() {
    int pic_id = 0;
    while(true) {
        Job job;
        {
            unique_lock lock(lock_);
            // cv_.wait() 当条件满足时 获得锁的占有权，继续执行
            // 当条件不满足时，释放锁，线程阻塞等待
            cv_.wait(lock, [&](){
                return qjobs_.size() < limit_;
            });
            char name[100];
            sprintf(name, "PIC_%d", pic_id++);
            printf("生产了一个新图片: %s qjob.size(): %d\n", name, qjobs_.size());
            job.pro.reset(new promise<string>());
            job.input = name;
            qjobs_.push(job);
        }
        // 等待结果
        auto result = job.pro->get_future().get();
        printf("JOB %s -> %s\n", job.input.c_str(), result);
        this_thread::sleep_for(chrono::milliseconds(2000));
    }
}

消费者

void infer_worker() {
    while (true)
    {
        if(!qjobs_.empty()) {
            {
                unique_lock lock(lock_);
                auto pjob = qjobs_.front();
                qjobs_.pop();
                printf("消费掉一个图片: %s\n", pjob.input);
                // 消费一个后通知 cv_ 并释放锁
                auto result = pjob.input + "--infer";
                // 存放值
                pjob.pro->set_value(result);
                cv_.notify_one();
            }
            this_thread::sleep_for(chrono::milliseconds(4000));
        }
        // 强制当前线程交出时间片，防止一直占用cpu资源
        this_thread::yield();
    }
    
}

3. 封装多线程Infer类

3.1 Infer类实现

#include <string>
using namespace std;

class Infer {
public:
    bool load_model(const string& file) {
        context_ = file;
        return true;
    }

    void forward() {
        if(context_.empty()) {
            printf("模型没有加载.\n");
            return;
        }
        /*forward logic*/
    }

	bool destory() {
		context_.clear();
}

private:
    string context_;
};

Infer infer;
infer.forward();

常见的Infer类将模型状态管理和模型推理放在一个Infer 类里面，这样会导致一些问题：

  • Model 没有正常加载时,推理异常判断。
  • Model 被释放了，会导致推理异常。
  • 重复load逻辑
  • 需要手动释放模型。

Note: Infer中必须考虑模型状态相关的异常情况。

  • 正常代码中存在大量异常情况的处理
  • 异常逻辑如果没有写好，后者没有考虑到，将会导致程序崩溃。

3.2 使用RAII实现Infer对象的创建

shared_ptr<Infer> create_infer(const string& file) {
    shared_ptr<Infer> instance(new Infer());
    if(!instance->load_model(file)) {
        instance.reset();
    }
    return instance;
}
  • 获取Infer 实例，立即加载模型
  • 加载模型失败，表示资源获取失败
  • 加载模型成功，则资源获取成功

调用代码

auto infer = create_infer("a");
if (infer == nullptr) {
	printf("failed.\n");
	return -1;
}
infer->forward();
  • 避免了外部执行load_model. 保证只调用一次，避免了重复调用的逻辑
  • 获取模型一定初始化成功，因此forward函数，不必判断模型是否加载成功

3.3 接口模式

解决问题：

  • 解决load_model 还能被外部看到的问题，拒绝外面调用load_model
  • 解决成员变量对外可见的问题。对于成员函数是特殊类型，比如说cudaStream_t, 那么使用者必定包含cuda_runtime.h，否则语法解析失败，造成头文件污染。

头文件接口

#ifndef __INFER_H__
#define __INFER_H__
#include <memory>
#include <string>

// 接口类，纯虚类
// 原则是： 只暴露调用者需要的函数，其他一概不暴露
// 比如load_model, 通过RAII 做定义，因此load_model不需要
// 内部如果有启动线程等，start, stop 也不需要暴露，而是初始化的时候就自动启动，都是RAII的定义
class Interface {
public:
    virtual void forward() = 0;
};

std::shared_ptr<Interface> create_infer(const std::string& file);

#endif // __INFER_H__
  • 头文件只暴露最简单的功能，避免造成头文件污染。有可能用户找不到依赖库的头文件。
  • 隐藏了内部实现。方便算法库的封装
  • 接口模式对编译友好，防止修改头文件，导致引入头文件的文件重新编译。

实现类

#include "infer.h"
using namespace std;

class InferImpl: public Interface{
public:
    bool load_model(const string& file) {
        context_ = file;
        return true;
    }

    virtual void forward() override{
        /*forward logic*/
    }

private:
    string context_;
};

shared_ptr<Interface> create_infer(const string& file) {
    shared_ptr<InferImpl> instance(new InferImpl());
    if(!instance->load_model(file)) {
        instance.reset();
    }
    return instance;
}

使用算法接口

#include "infer.h"

auto infer = create_infer("a");
if (infer == nullptr) {
	printf("Create infer failed!\n"）;
	return -1;
}
auto result = infer->forward("xxx");
return 0;

4. 多batch生产者消费者类的封装

4.1 封装

class InferImpl: public Interface{
public:
    bool load_model(const string& file) {
        // 尽量保证资源哪里分配哪里释放，哪里使用。这样使得程序足够简单
        context_ = file;
        worker_thread_ = thread(&InferImpl::worker, this);
        return true;
    }

    virtual void forward() override{
        /*forward logic*/
    }
private:
    void worker() {

    }
private:
    thread worker_thread_;
    string context_;
};

  bool load_model(const string& file) {
       // 尽量保证资源哪里分配哪里释放，哪里使用。这样使得程序足够简单
       context_ = file;
       worker_thread_ = thread(&InferImpl::worker, this);
       return true;
   }

在这个代码里，context 在load_model中分配，但是在worker线程中使用。这样不够好，应该保证资源在同一个地方分配，统一个地方释放，同一个地方使用。这样做得目的是保证程序足够简单，并且防止资源泄露。

4.2 修改模型加载

修改：

class InferImpl: public Interface{
public:
    bool load_model(const string& file) {
        worker_thread_ = thread(&InferImpl::worker, this, file);
        return true;
    }

    virtual void forward() override{
        /*forward logic*/
    }
private:
    void worker(string f) {
        context_ = f;
    }
private:
    thread worker_thread_;
    string context_;
};

这样将模型的context_ 加载放在了worker线程里面，解决了模型和推理模块不在同一个线程的问题。但是这个代码也有如下问题：

  • 不知道最后模型加载的状态
    这里使用 future 和 promise 拉解决获取模型加载状态获取的问题。
class InferImpl: public Interface{
public:
    bool load_model(const string& file) {
        // 尽量保证资源哪里分配哪里释放，哪里使用。这样使得程序足够简单
        promise<bool> pro;
        worker_thread_ = thread(&InferImpl::worker, this, file, std::ref(pro));
        return pro.get_future().get();
    }

    virtual void forward() override{
        /*forward logic*/
    }
private:
    void worker(string f, promise<bool>& pro) {
        string context = f;
        pro.set_value(context_.empty());
        while(true) {
			/*customer*/
		}
    }
private:
    thread worker_thread_;
    //string context_;
};

由于contex_只在worker内部使用，所以也就不需要context_的成员变量了，context_的生命周期只在 worker() 线程内。

4.3 任务提交与结果返回

4.3.1 直接返回结果

 virtual string forward(string& input) override{
     /*forward logic
         往队列丢任务
     */
     Job job;
     job.pro.reset(new promise<string>());
     job.input = input;
     qjobs_.push(job);

     /*如何返回结果？*/
     return job.pro->get_future().get();
 }

外部调用代码：

string result1 = infer->forward(input1);
string result2 = infer->forward(input2);
string result3 = infer->forward(input3);

4.3.2 使用shared_future 返回结果

上述方式可以解决结果获取的问题，但是每次提交任务后，必须等待任务处理过后才能提价下一个任务，这本质上还是串行的所以可以使用 shared_future 直接返回 一个 future 让调用方决定什么时候去等待结果。代码如下：

 virtual shared_future<string> forward(string& input) override{
    Job job;
	job.pro.reset(new std::promise<std::string>);
	job.input = input;
	//std::this_thread::sleep_for(std::chrono::milliseconds(100));

	std::shared_future<std::string> fut = job.pro->get_future();
	{
		std::lock_guard<std::mutex> l(lock_);
		qjobs_.emplace(job);
	}
	// 被动通知，有任务发送给worker
	cv_.notify_one();
	return fut;
 }

调用代码：

/*提交任务*/
auto rst_future1 = infer->forward(input1);
auto rst_future2 = infer->forward(input2);
auto rst_future3 = infer->forward(input3);

/*在需要的时候获取结果*/
rst_future1.get();
rst_future2.get();
rst_future3.get()

4.4 多batch 推理

void worker(std::string file, std::promise<bool>& pro) {

		//std::string file = "aaa";
		// worker 内实现，模型的加载、使用、释放
		std::string context_ = file;
		if (context_.empty()) {
			pro.set_value(false);
			return;
		}
		else {
			is_running_ = true;
			pro.set_value(true);
		}
		int max_batch_size = 5;
		std::vector<Job> jobs;
		int batch_ids = 0;
		while (true) {
			//  在队列取任务并执行的过程
			{
				std::unique_lock<std::mutex> l(lock_);
				cv_.wait(l, [&]() {
					return !qjobs_.empty();
				});
				while (jobs.size() < max_batch_size && !qjobs_.empty()) {
					jobs.emplace_back(std::move(qjobs_.front()));
					qjobs_.pop();
				}

				// batch process
				for (auto& job : jobs) {
					char buff[100];
					sprintf_s(buff, "%s ---processed[%d]", job.input.c_str(), batch_ids);
					job.pro->set_value(buff);
				}
				std::this_thread::sleep_for(std::chrono::milliseconds(1500));
				batch_ids++;
				jobs.clear();

			} // end unique_lock
		}
		printf("[%s] Infer worker done. \n", file.c_str());
	}

一次从队列中取出多个任务，组成一个batch进行推理。

4.5 程序推出机制

在上面的程序中，并没有程序推出的机制即：
当进程终止时，worker()线程仍然在运行，这会导致程序推出而子线程没有推出，导致报错。这里设置一个标示线程是否退出的变量 ** atomic is_running_**。

std::atomic<bool>			is_running_{false};
void stop() {
	if (is_running_) {
		is_running_ = false;
		// 退出worker线程的等待
		cv_.notify_one();
	}

	//  保证推理线程结束，防止成为孤儿线程
	if (this->worker_thread_.joinable()) {
		worker_thread_.join();
	}
}

析构时或者在需要停止推理时调用

virtual ~InferImpl() {
	stop();
}

消费者逻辑修改

void worker(std::string file, std::promise<bool>& pro) {

	//std::string file = "aaa";
	// worker 内实现，模型的加载、使用、释放
	std::string context_ = file;
	if (context_.empty()) {
		pro.set_value(false);
		return;
	}
	else {
		is_running_ = true;
		pro.set_value(true);
	}
	int max_batch_size = 5;
	std::vector<Job> jobs;
	int batch_ids = 0;
	while (is_running_) {
		//  在队列取任务并执行的过程
		{
			std::unique_lock<std::mutex> l(lock_);
			cv_.wait(l, [&]() {
				return !is_running_ || !qjobs_.empty();
			});

			if (!is_running_) break;
			while (jobs.size() < max_batch_size && !qjobs_.empty()) {
				jobs.emplace_back(std::move(qjobs_.front()));
				qjobs_.pop();
			}

			// batch process
			for (auto& job : jobs) {
				char buff[100];
				sprintf_s(buff, "%s ---processed[%d]", job.input.c_str(), batch_ids);
				job.pro->set_value(buff);
			}
			std::this_thread::sleep_for(std::chrono::milliseconds(1500));
			batch_ids++;
			jobs.clear();

		} // end unique_lock

		
	}
	printf("[%s] Infer worker done. \n", file.c_str());

}
  • while(true) 变成 while(is_running_)
  • 信号量等待退出条件变成如下，即当不再运行时，结束等待，并且退出推理线程。
cv_.wait(l, [&]() {
	return !is_running_ || !qjobs_.empty();
});

if (!is_running_) break;

5. 生产者上限控制

问题提出：生产频率太高，commit 频率太高，而消费频率太低。导致内存占用太大，程序无法长时间运行。缺少队列上限限制的机制。使用独占分配器解决：

  • tensor 复用

  • 队列上限限制

  • 向tensor_alloctor_ 申请一个 tensor

  • 预先分配固定数量的tensor, 比如10个

  • 如果申请的时候，有空闲的tensor没有被分配出去，则把这个空闲给申请者

  • 如果申请的时候，没有空闲的tensor,此时，让申请者等待。

  • 如果使用者使用完毕了，通知tensor_allocator_, 告诉他这个tensor不用了，可以分配给别人了。

  • 这样实现了tensor复用，并且控制了队列的上限。

内存复用类,申请固定数量的内存池，完成内存复用。当内存池中的内存块消耗完后，则不能申请新的内存，需要等待，若等待超时，则返回空。

#ifndef __MONOPOLY_ALLOCATOR_H__
#define __MONOPOLY_ALLOCATOR_H__

#include <condition_variable>
#include <vector>
#include <mutex>
#include <memory>

template<class _ItemType>
class MonopolyAllocator {
public:
    class MonopolyData {
    public:
        std::shared_ptr<_ItemType>& data() { return data_; }
        void release() { manager_->release_one(this); }

    private:
        MonopolyData(MonopolyAllocator* pmanager) { manager_ = pmanager; }

    private:
        friend class MonopolyAllocator;
        MonopolyAllocator* manager_ = nullptr;
        std::shared_ptr<_ItemType> data_;
        bool available_ = true;
    };
    typedef std::shared_ptr<MonopolyData> MonopolyDataPointer;

    MonopolyAllocator(int size) {
        capacity_ = size;
        num_available_ = size;
        datas_.resize(size);

        for (int i = 0; i < size; ++i)
            datas_[i] = std::shared_ptr<MonopolyData>(new MonopolyData(this));
    }

    virtual ~MonopolyAllocator() {
        run_ = false;
        cv_.notify_all();

        std::unique_lock<std::mutex> l(lock_);
        cv_exit_.wait(l, [&]() {
            return num_wait_thread_ == 0;
            });
    }

    MonopolyDataPointer query(int timeout = 10000) {

        std::unique_lock<std::mutex> l(lock_);
        if (!run_) return nullptr;

        if (num_available_ == 0) {
            num_wait_thread_++;

            auto state = cv_.wait_for(l, std::chrono::milliseconds(timeout), [&]() {
                return num_available_ > 0 || !run_;
                });

            num_wait_thread_--;
            cv_exit_.notify_one();

            // timeout, no available, exit program
            if (!state || num_available_ == 0 || !run_)
                return nullptr;
        }

        auto item = std::find_if(datas_.begin(), datas_.end(), [](MonopolyDataPointer& item) {return item->available_; });
        if (item == datas_.end())
            return nullptr;

        (*item)->available_ = false;
        num_available_--;
        return *item;
    }

    int num_available() {
        return num_available_;
    }

    int capacity() {
        return capacity_;
    }

private:
    void release_one(MonopolyData* prq) {
        std::unique_lock<std::mutex> l(lock_);
        if (!prq->available_) {
            prq->available_ = true;
            num_available_++;
            cv_.notify_one();
        }
    }

private:
    std::mutex lock_;
    std::condition_variable cv_;
    std::condition_variable cv_exit_;
    std::vector<MonopolyDataPointer> datas_;
    int capacity_ = 0;
    volatile int num_available_ = 0;
    volatile int num_wait_thread_ = 0;
    volatile bool run_ = true;
};

#endif // __MONOPOLY_ALLOCATOR_H__

完整代码参考

https://github.com/JilinLi4/trt_infer/tree/master/test/ThreadTest

c++ TensorRT TRT::Tensor 用法学习笔记
jacke121的专栏
08-09 1676
c++ TensorRT TRT::Tensor 用法学习笔记
trt多流、多batch、多context
deep_love1314的博客
12-02 2101
trt
转ONNX模型 通过TRT 实现C++的简单案例。
Vertira的博客
02-25 2310
虽然实例是python，可以把python代码封装成dll，在c++环境中进行调用。 下面这个链接值得参考： TensorRT学习与paddle-TRT实践（一）_飞得更高-优快云博客_paddle tensorrtgithub 源码地址：https://github.com/NVIDIA/TensorRThttps://github.com/NVIDIA/TensorRT官方手册地址：NVIDIA Deep Learning TensorRT Documentationhttps://docs.nv
c++部署trt文件
zqt726的博客
02-08 930
c++部署trt文件中遇到的问题
torch转ONNX模型转TensorRT C++推理
MAX的专栏
04-21 2450
训练好的模型（如.pt）转成onnx形式，ONNX定义了一组与环境和平台无关的标准格式。ONNX文件不仅存储了神经网络模型的权重，还存储了模型的结构信息、网络中各层的输入输出等一些信息。ONNX的推理可以用ONNX Runtime官方库，如果在英伟达平台上，可以转TensorRT后运行。本文主要介绍转TRT格式后如何C++部署运行。
c++的onnx trt部署学习
anny_jra的博客
07-06 395
输入申请内存，输出申请内存，推理完成，代码文章1和文章2都有。创建runtime engine context。文章1的makefile, 文章2的cmake。检查输入输出数量是否一致。
C++中用TensorRT与多线程进行模型推理
heyiqiunet的博客
10-05 1794
用C++与TensorRT及多线程对模型进行高效推理
推理引擎TensorRT安装与多线程推理（Python）
heyiqiunet的博客
09-19 1052
TensorRT 是由 Nvidia 发布的一个机器学习框架，用于在其硬件上运行机器学习推理。它能针对 Nvidia 系列硬件进行优化加速，实现最大程度的利用 GPU 资源，提升推理性能。在训练了神经网络之后，TensorRT 可以对网络进行压缩、优化以及运行时部署，支持当前多种深度学习框架（TensorFlow, Pytrch,Mxnet,Caffe2,Theano, PaddlePaddle）。
face_trt.zip
01-07
TensorRT通过解析模型的计算图，然后进行静态图优化，如层融合、量化和多线程调度，以提高GPU上的运算速度。这对于处理复杂模型，如GANs，尤其有价值，因为它们通常包含大量的计算。 **GAN（生成对抗网络）** GAN是...
c++ tensorrt 推理yolov5 (opencv-gpu、nms-cuda
WSNjiang的博客
05-29 1588
@[TOC](c++ tensorrt 推理yolov5 (opencv-gpu、nms-cuda))yolov5_trt.h yolov5_trt.cpp postprocess.cuh postprocess.cu main.cpp 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的
TensorRT C++推理代码示例(smoke单目3D检测为例）
mayeight的博客
01-08 905
相关相关其他的标准库。
C++调用TensorFlow和TensorRT进行加速
xiangxianghehe的博客
07-03 8687
本文系转载，出处：如何用CPP调用TensorFlow&&TensorRT 环境 tensorflow r.1.13 + tensorrt-5.0.2.6 cuda10 cudnn 7.6.1 初步接触 最近训练了一个人脸的landmark regression&& confidence output的model( based Tensorflow)。因为模型中...
tensorrt基础知识+torch版lenet转c++ trt
智障变智能
01-15 2182
1.优化流程: 制作engine:大概就是c++api写的网络结构或者其他第三方格式，经过NetworkDefinition进行定义，采用builder加载模型权重，进行一些参数的优化，然后再用engine序列化成模型　。 推理:采用engine反序列化，创建运行环境，在进行推理即可。 参考：https://docs.nvidia.com/deeplearning/tensorrt/developer-guide/index.html#fit__fit1 ...
【TensorRT】记一次使用C++接口TensorRT部署yolov5 v6.1模型的过程
ChunjieShan的博客
08-02 7025
使用C++接口的TensorRT部署YOLOv5 v6.1模型
NVIDIA TensorRT----Quick Start Guide | NVIDIA Docs
fanre的专栏
04-09 1629
一、引言 tensorRT是一个高性能深度学习推理库。tensorrt包含推理优化器和运行时。TensorRT能够以更高的吞吐量和更低的延迟运行。 本指南包含tensorrt基本的安装、转换、运行时选择以及最佳运用。 二、安装tensorrt 包含：容器、Debian、pip安装方式。 2.1、容器中安装 公有云上部署参照：NGC Certified Public Clouds Documentation 2.2、Debian安装 1、下载tensorRT 2、安装 os="ubu
只依赖Tensorrt和opencv的yolov5源代码
qq_44089890的博客
04-07 1282
这是一个简单的yolo接口的头文件，提供了一些用于创建和使用yolo模型的函数和结构体。Type和Mode是用于指定yolo模型类型和推理模式的枚举类型。Box结构体表示检测到的物体的边界框、置信度和类别标签。Infer类是一个抽象类，它提供了一个commit函数，用于执行单个图像的推理，以及一个commits函数，用于执行多个图像的推理。trt_version、type_name、mode_string和set_device是一些辅助函数，用于获取TensorRT版本、yolo模型类型和推理模式的名称，并
TensorRT的使用流程c++和python
qq_39333636的博客
08-14 1741
tensorrt的粗知识
pytorch 2.0 多线程并行，导致GPU利用100%，卡住
weixin_40755306的博客
05-14 792
拷贝的内容包括torch、torch-1.9.1+cu111.dist-info、 torchvision、torchvision-0.10.1+cu111.dist-info。最近发现，多线程ThreadPoolExecutor(max_workers=2)调用的时候，即单个进程内处理一张图像，依次是yolov5--->crnn模型，会导致GPU利用100%，卡住。具体换的方式是：直接把别的环境里装好的torch对应的库，拷贝现在的环境。之前无论是pth格式，还是TRT格式，并行的都没有问题。
Tensorflow 模型 C++部署实战2-高级部分
05-27
因公司要求个人不得授课和兼职原因，麻烦请把我的课程全部下架，联系不到你们的客服，谢谢！
pointnet模型trt推理
最新发布
05-07
引用[4]展示了多线程初始化的代码，可能涉及推理时的性能优化。 首先，用户想了解TensorRT推理PointNet的步骤。我应该从模型准备开始，比如将PyTorch模型转换为ONNX格式。然后需要考虑输入输出的设置，特别是动态...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值