共享内存下高效并行化模拟系统能量计算的问题咨询

我正在运行一个计算系统能量的模拟程序，系统包含两类粒子。串行版本通过遍历两类粒子计算能量，我将其改写为双线程并行版本（分别处理Polymers和Cosolvent循环）后，并行版本反而比串行版本慢约25%。我怀疑是共享的LATTICE内存导致的问题，想确认这是否属于并行处理中的共享内存问题，以及有哪些解决办法。

串行版本代码 #

double CalculateEnergy(std::vector<Polymer>* Polymers, std::vector<Particle*>* Cosolvent, std::vector<Particle*>* LATTICE, std::array<double,8>* E, std::array<double,8>* contacts, int x, int y, int z) {
    
    double Energy {0.0};
    (*contacts) = {0,0,0,0,0,0,0,0}; 

    // 遍历所有聚合物粒子
    for (Polymer& pmer: (*Polymers)) {
        for (Particle*& p: pmer.chain){
            // 能量计算
            Energy += (*LATTICE)[f(*p)]; // f是利用p的属性计算下标的任意函数
        }
    }
    // 遍历所有共溶剂粒子
    for (Particle*& p: *Cosolvent ){
        // 能量计算
        Energy += (*LATTICE)[g(*p)]; // g是利用p的属性计算下标的任意函数
    }
    
    return Energy; 
}

并行版本代码 #

double CalculateEnergy_parallelized(std::vector<Polymer>* Polymers, std::vector<Particle*>* Cosolvent, std::vector<Particle*>* LATTICE, std::array<double,8>* E, std::array<double,8>* contacts, int x, int y, int z) {
    
    double Energy {0.0};
    (*contacts) = {0,0,0,0,0,0,0,0}; 
    double E1;
    double E2; 

    std::thread t1(PolymerEnergyLoop, Polymers, LATTICE, E, &E1, contacts, x, y, z);
    std::thread t2(CosolventEnergyLoop, Cosolvent, LATTICE, E, &E2, contacts, x, y, z); 

    t1.join();
    t2.join();

    Energy = E1 + E2; 

    return Energy; 
}

void PolymerEnergyLoop(std::vector<Polymer>* Polymers, std::vector<Particle*>* LATTICE, std::array<double,8>* E, double* Ea, std::array<double,8>* contacts, int x, int y, int z){

    double Energy {0.0};
    (*contacts) = {0,0,0,0,0,0,0,0}; 

    // 遍历所有聚合物粒子
    for (Polymer& pmer: (*Polymers)) {
        for (Particle*& p: pmer.chain){
            // 能量计算
            Energy += (*LATTICE)[f(*p)]; // f是利用p的属性计算下标的任意函数
        }
    }

    *Ea = Energy; 
    return; 
}

void CosolventEnergyLoop(std::vector<Particle*>* Cosolvent, std::vector<Particle*>* LATTICE, std::array<double,8>* E, double* Ea, std::array<double,8>* contacts, int x, int y, int z){

    double Energy {0}; 

    std::array<std::array<int,3>, 26> ne_list; 

    for (Particle*& p: *Cosolvent ){
        // 能量计算
        Energy += (*LATTICE)[g(*p)]; // g是利用p的属性计算下标的任意函数
    }
    
    *Ea = Energy; 
    return; 
}

确认：这确实是共享内存相关的性能问题 #

并行版本变慢的核心原因包括：

1. 缓存一致性开销：两个线程都频繁读取共享的LATTICE向量，即使是只读操作，CPU的缓存一致性协议（如MESI）需要在多核间同步缓存行状态，产生额外的总线开销。
2. 伪共享风险：如果LATTICE的元素访问落在同一个缓存行，线程间的缓存行无效/同步操作会大幅拖慢速度。
3. 不必要的共享变量竞争：PolymerEnergyLoop中重复初始化共享的contacts，属于无意义的写操作，会触发缓存同步，同时存在潜在的竞态风险。
4. 线程创建销毁开销：每次调用都创建新线程，线程的初始化和销毁成本会抵消并行收益，尤其当计算任务粒度较小时。

解决方法 #

1. 优化共享内存的缓存行为 #

• 拆分只读共享数据：如果Polymers和Cosolvent访问的LATTICE区域无重叠，将LATTICE拆分为两个独立的子数组，让每个线程只访问自己专属的部分，彻底避免缓存同步开销。
• 缓存行对齐：将LATTICE的元素或整个容器对齐到CPU缓存行大小（通常64字节），可以通过alignas(64)关键字实现，避免不同线程的访问落在同一个缓存行。
• 标记只读数据：将LATTICE声明为const，让编译器和CPU明确这是只读数据，跳过不必要的缓存一致性检查。

2. 消除无意义的共享变量操作 #

• 移除线程函数中对contacts的初始化操作，该操作只需要在主线程执行一次，避免多线程对共享变量的写竞争和缓存同步。

3. 减少线程管理开销 #

• 使用线程池：提前创建固定数量的线程，重复利用执行任务，避免每次调用都创建销毁线程的开销。
• 改用高阶并行API：比如使用std::async（配合std::launch::async）或OpenMP的#pragma omp parallel sections，这类API会自动优化线程管理，比手动创建std::thread更高效。

4. 调整并行任务粒度 #

• 如果其中一类粒子的计算量远小于另一类，比如Cosolvent的循环耗时只有Polymers的10%，可以只并行处理计算量大的任务，把小任务留在主线程执行，避免线程开销盖过并行收益。

5. 提升缓存命中率 #

• 对LATTICE的访问使用预取指令，比如__builtin_prefetch(&(*LATTICE)[next_index])，提前将需要的数据加载到CPU缓存，减少缓存 miss 带来的等待时间。

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