Question

我的程序首先从HDD中读取2个图像（具有c ++ file.read功能），然后在这些图像上执行GPU和CPU（一堆CUDA内核与简单的CPU计算混合）的计算。我有大约2000对图像要处理。阅读和计算时间几乎相等。是否有相对简单的读取和处理并行化实现？

我知道，使用CUDA流我可以相对于主机（CPU）异步评估内核，但在这里我的计算是混合和复杂的。那么，可能是可以使用某种CPU多线程吗？

我想要的是：

readfromHDD(im-1);
readfromHDD(im-2);

for(int i=3;i<1998;i=i+2){
     readfromHDD(im-i);                  |  functions inside the
     readfromHDD(im-(i+1));              |  for loop are evaluated
     ProcessGPU&CPU(im-(i-2),im-(i-1));  |  concurrently
     Synchronize_Reading_and_processing;
end

我认为，没有必要发布我的实际代码。我之前从未做过多线程，所以我不知道它如何与CUDA内核一起工作。任何提示都表示赞赏。

由于

Answer 1

可能存在数千种不同的可能解决方案。这就是我要开始的，看看它是如何运作的：

成分</ P>

阅读帖子，
某种消息队列
处理线程

方法：

启动读取线程和处理线程。
读取线程一次读取两个图像，并将它们作为包发送到消息队列中。重复，直到读完所有图像。
处理线程读取消息队列并处理这两个图像。重复，直到处理完所有图像。
停止主题并报告结果（如适用）

为消息队列提供一些“背压”可能会有所帮助，这样当你已经加载了4,6或10个图像时，阅读器线程会停止读取图像，直到队列中再有空间为止。

以这种方式使用消息队列的优点是在线程之间有合理的自由，消息队列排列线程之间的所有同步。

Answer 2

我非常偏爱pthreads并在读取器上实现异步包装器，当您请求下一组数据时，它会同步。

这是我能想到的最容易实现的方法。我已经包含了一些应该易于编译并完全演示实现的内容。祝你好运。

main.cpp演示了如何使用。

#include "Reader.h"
#include "Reader_Async_Wrapper.h"

using namespace std;

int main() {
    Reader *reader = new Reader("test");
    Reader_Async_Wrapper async_reader(reader);
    int img_index=0;
    char* data;
    data = async_reader.get_data();
    while(((int*)data)[0]!=-1){

        cout<<"processing image "<<img_index<<endl;
        sleep(2);
        cout<<"processed image "<<img_index++<<endl;
        delete[] data;
        data = async_reader.get_data();
    }
    return 0;
}

Reader.h是一个简单的串行实现的文件i / o类

#include <iostream>
#include <fstream>
#include <unistd.h>

using namespace std;
class Reader{
public:

    bool isFinished(){return finished;}

    Reader(string file_name){
        open_file(file_name);
        finished=false;
        img_index=0;
    }

    char* read_data(){
        cout<<"Reading img: "<<img_index<<endl;
        sleep(1);
        cout<<"Read img: "<<img_index++<<endl;
        if(img_index==10)finished=true;
        return new char[1000];
    }

private:
    bool finished;
    int img_index;
    void open_file(string name){
        // TODO
    }
};

Reader_Async_Wrapper.h是Reader.h的一个简单包装器，可以让它以异步方式运行

#include "Reader.h"
#include <pthread.h>

using namespace std;

class Reader_Async_Wrapper{
public:

    pthread_t thread;
    pthread_attr_t attr;
    Reader* reader;
    pthread_barrier_t barrier;
    Reader_Async_Wrapper(Reader* reader):reader(reader){

        pthread_attr_init(&attr);
        pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
        pthread_barrier_init (&barrier, NULL, 2);
        pthread_create(&thread, &attr, &Reader_Async_Wrapper::threadHelper, this);
        finished=false;
        image_data=NULL;
    }

    void finish(){
        pthread_attr_destroy(&attr);
        void *status;
        pthread_join(thread, &status);
    }

    char* get_data(){
        pthread_barrier_wait (&barrier);
        return image_data;
    }
    void clear_buffer(char* old_image){
        delete[] old_image;
    }

private:
    char* image_data;

    static void *threadHelper(void * contx){
        return ((Reader_Async_Wrapper *)contx)->async_loop();
    }

    bool finished;
    void *async_loop(){
        while(!finished){
            if(reader->isFinished()){
                finished=true;
                image_data=new char[sizeof(int)];
                ((int*)image_data)[0]=-1;
            }else
                image_data=reader->read_data();
            pthread_barrier_wait(&barrier);
        }
        pthread_exit(NULL);
        return NULL;
    }

};

我建议改进与检测文件结尾相关联的处理（假设您正在从单个长文件中读取）。否则，我认为您可以轻松地将其扩展到您的应用程序。

只要您不打算同时处理多个案例，并且您主要使用此方法来隐藏与读取文件相关的延迟，此方法就足够了。

如果要同时处理多个案例，可以使用包装器来包装文件的读取和处理。关于CUDA，我认为他们都应该共享CUDA背景。

如果您希望能够在GPU上并行处理，我会推荐一些内容：创建包装类的多个副本，每个副本对应一个您喜欢的并行实例。为类构造函数中的每个async实例分配足够的内存一次。为每个线程指定一个GPU线程，以便内核可以并行运行。在GPU线程上执行所有内存副本和内核执行。

异步CPU读取和GPU + CPU计算

2 个答案: