如何用OpenACC并行化含多类访问的C++循环及外部类适配

一、先搞定GPU的数据访问权限 #

你当前的Person、Cat、Toy类成员都是private的，GPU线程根本访问不到。要么把这些成员改成public，要么给每个类加public的getter方法，比如：

改成public的版本：

class Toy {
public:
    std::string brand;
    double price;
};

class Cat {
public:
    std::string name;
    std::vector<Toy> toys;
};

class Person {
public:
    std::string name;
    std::string surname;
    std::vector<Cat> cats;
};

或者用getter（适合不想暴露私有成员的场景）：

class Cat {
private:
    std::string name;
    std::vector<Toy> toys;
public:
    const std::string& get_name() const { return name; }
    const std::vector<Toy>& get_toys() const { return toys; }
};

不管哪种方式，得保证GPU能拿到循环里要用的name、toys、brand这些数据。

二、嵌套循环的并行化实现 #

针对你的猫咪-玩具遍历循环，要解决三个核心问题：数据复制到GPU、循环并行化、共享数据写入的线程安全。

基础并行代码示例 #

// 先把Person对象和嵌套的vector都复制到GPU
#pragma acc enter data copyin(person)
// 递归复制每个Cat的toys向量
for (size_t i = 0; i < person.cats.size(); ++i) {
    const Cat& cat = person.cats[i];
    #pragma acc enter data copyin(cat.toys[0:cat.toys.size()])
}

// 并行化外层猫咪循环
#pragma acc parallel loop present(person)
for (size_t i = 0; i < person.cats.size(); ++i) {
    const Cat& cat = person.cats[i];
    // 如果insert_cat是写入共享数据结构（比如全局统计容器），必须加同步
    #pragma acc critical
    insert_cat(cat.name);

    // 内层玩具循环在每个GPU线程里串行跑就行
    for (size_t j = 0; j < cat.toys.size(); ++j) {
        const Toy& toy = cat.toys[j];
        #pragma acc critical
        insert_brand(toy.brand);
        // 如果是数值累加，用atomic更高效
        #pragma acc atomic update
        insert_price(toy.price);
    }
}

// 用完GPU数据后记得释放
for (size_t i = 0; i < person.cats.size(); ++i) {
    const Cat& cat = person.cats[i];
    #pragma acc exit data delete(cat.toys)
}
#pragma acc exit data delete(person.cats)
#pragma acc exit data delete(person)

关键细节解释 #

• 显式数据管理：嵌套的std::vector是动态分配的内存，编译器自动复制容易出问题，所以用#pragma acc enter data手动把主机数据拷到GPU，exit data释放GPU内存，能精准控制内存生命周期。
• present关键字：告诉编译器person已经在GPU上了，不用重复复制，节省时间。
• 线程安全：insert_*如果是操作共享数据（比如全局的std::map、计数器），必须加critical（复杂操作）或atomic（简单数值操作），不然多个GPU线程同时写会把数据搞乱。

三、外部类成员函数的处理 #

如果insert_brand是brands_analysis.hpp里某个类的成员函数，比如：

// brands_analysis.hpp
class BrandAnalyzer {
public:
    void insert_brand(const std::string& brand);
};

要做两个修改：

1. 标记函数为GPU可调用 #

在BrandAnalyzer的成员函数前加#pragma acc routine，告诉编译器把这个函数编译成GPU能跑的代码：

class BrandAnalyzer {
public:
    // seq表示函数在单个GPU线程内串行执行，函数内部可并行的话换成parallel
    #pragma acc routine seq
    void insert_brand(const std::string& brand) {
        // 你的函数实现
    }
};

2. 把外部类实例放到GPU上 #

如果BrandAnalyzer的实例是在主机端创建的，得把它也复制到GPU，然后在并行循环里用present声明：

BrandAnalyzer analyzer;
// 把analyzer复制到GPU
#pragma acc enter data copyin(analyzer)

// 并行循环里加上analyzer的present声明
#pragma acc parallel loop present(person, analyzer)
for (size_t i = 0; i < person.cats.size(); ++i) {
    const Cat& cat = person.cats[i];
    #pragma acc critical
    insert_cat(cat.name);

    for (size_t j = 0; j < cat.toys.size(); ++j) {
        const Toy& toy = cat.toys[j];
        #pragma acc critical
        analyzer.insert_brand(toy.brand);  // 直接调用外部类的成员函数
        #pragma acc atomic update
        insert_price(toy.price);
    }
}

// 释放GPU上的analyzer
#pragma acc exit data delete(analyzer)

四、踩坑提醒 #

• std::string兼容性：不同编译器对std::string的OpenACC支持不一样，比如nvc++支持得好，GCC可能有问题。如果遇到编译错误，可以换成C风格的char*试试。
• 数据依赖：要是insert_*函数之间有依赖（比如insert_brand的结果影响insert_price），那并行化就得调整，不然结果会错。
• 隐式vs显式数据管理：虽然用#pragma acc parallel loop copy(person)能让编译器自动复制数据，但嵌套复杂结构下，显式管理更靠谱，能避免不必要的复制和内存泄漏。

内容的提问来源于stack exchange，提问作者sadsquirrel88