使非const对象成员函数可在openMP中使用

Question

我想并行化一些循环，并在代码的其他部分广泛使用openMP。我想在一个循环内使用一个对象，该对象具有一些后备存储（应在线程之间共享）和一些状态（应对每个线程专用）。

想象一下：

class P {
    public:
        // fills storage with 0, 1, 2...
        P(size_t something) {
            for(size_t i = 0; i < something; i++)
                m_storage.push_back(i);
        }

        // finds the closest value in m_storage to probe
        // the algorithm is a stupid dummy, but gets the point across
        float findClosest(float probe) {
            m_state = std::numeric_limits<float>::max();
            auto closest = std::numeric_limits<float>::quiet_NaN();

            for(const auto x: m_storage)
                if(m_state > probe - x) {
                    closest = x;
                    m_state = probe - x;
                }

             return closest;
        }

    private:
        std::vector<float> m_storage;
        float m_state;
}

// sequential access
int main(){
    P p = new P(100);
    std::vector<float> results(5);
    for(size_t i = 0; i<5; i++) {
        results[i] = p.findClosest(i);
    }
}

// parallel access with copy => p.m_storage is copied
int main(){
    P p = new P(100);
    std::vector<float> results(5);
#pragma omp parallel for firstprivate(p)
    for(size_t i = 0; i<5; i++) {
        results[i] = p.findClosest(i);
    }
}

// parallel access with share => p.m_state is altered by multiple threads
int main(){
    P p = new P(100);
    std::vector<float> results(5);
#pragma omp parallel for firstprivate(p)
    for(size_t i = 0; i<5; i++) {
        results[i] = p.findClosest(i);
    }
}

所以我浪费了很多内存和缓存空间，或者由于共享使用变量而导致实现中断。

我想我无法将对象的一部分标记为共享，将其他部分标记为私有或类似标记。对象相当复杂，并且状态在不同的地方使用。有什么神奇的方法可以使对象共享其存储，但是每个对象都有状态？

例如像

[...]
    private:
#pragma omp parallel shared
        std::vector<float> m_storage;
#pragma omp parallel private
        float m_state;

Answer 1

将您的数据分为两类：一类保存所有要在线程之间共享的数据，另一类保存每线程的私有数据。每个线程类将包含const指针或对公共数据的引用（const，因为您不想对其进行更改）。

类似：

class common {
public:
    std::vector<float> m_storage;
    // ...
};

class private_data {
public:
    private_data(const common *cstorage): storage(cstorage) { }
    const common *storage;
    float findClosest(float probe) {
        // ...
    }
};

common类将有一个实例，传递给所有private_data类。