有没有办法在 C++ 中制作无锁“计数器”随机访问迭代器？

Question

在给定系数和评估点 (x) 的情况下，我正在尝试在某个点评估多项式的​​玩具问题的执行策略。

这是我的实现：

class counter: public std::iterator<
        std::random_access_iterator_tag,   // iterator_category
        size_t,                      // value_type
        size_t,                      // difference_type
        const size_t*,               // pointer
        size_t                       // reference
>{
    size_t num = 0;
public:
    explicit counter(size_t _num) : num(_num) {}
    counter& operator++() {num += 1; return *this;}
    counter operator++(int) {counter retval = *this; ++(*this); return retval;}
    bool operator==(counter other) const {return num == other.num;}
    bool operator!=(counter other) const {return !(*this == other);}
    counter& operator+=(size_t i) { num += i; return *this; }
    counter& operator-=(size_t i) { num -= i; return *this; }
    counter operator +(counter &other) const { return counter(num + other.num);}
    counter operator -(counter &other) const { return counter(num - other.num); }
    counter operator +(size_t i) const { return counter(num + i); }
    counter operator -(size_t i) const {return counter(num - i); }
    reference operator*() const {return num;}
};


double better_algorithm_polinomials(const vector<double> & coeffs, double x) {
    return transform_reduce(execution::par, cbegin(coeffs), end(coeffs), counter(0), 0.0, plus{}, [x](double coeff, size_t index) { return coeff * pow<double>(x, index); });
}

这适用于 par 策略，但对于 par_unseq，由于竞争条件而失败。

我尝试使用 atomic_size_t 来缓解它们，但是在某些地方（例如复制构造或 ++(int) 运算符）我不是原子的，可能必须使用锁...我想知道是否有更好的办法。

这不起作用：

class counter: public std::iterator<
        std::random_access_iterator_tag,   // iterator_category
        atomic_size_t,                      // value_type
        atomic_size_t,                      // difference_type
        const atomic_size_t*,               // pointer
        atomic_size_t                       // reference
>{
    atomic_size_t num = 0;
public:
    explicit counter(size_t _num) : num(_num) {}
    counter(counter &other) {  num = other.num.load();}
    counter& operator++() {num += 1; return *this;}
    const counter operator++(int) {num += 1; return counter(num-1);}
    bool operator==(counter &other) const {return num == other.num;}
    bool operator!=(counter &other) const {return !(*this == other);}
    counter& operator+=(size_t i) { num += i; return *this; }
    counter& operator-=(size_t i) { num -= i; return *this; }
    counter operator +(counter &other) const { return counter(num + other.num);}
    difference_type operator -(counter &other) const { return num - other.num; }
    counter operator +(size_t i) const { return counter(num + i); }
    difference_type operator -(size_t i) const {return num - i; }
    size_t operator [](size_t i) const {return i;}
    reference operator*() const {return num.load();}
};

Answer 1

我尝试使用 atomic_size_t 缓解它们

请注意，您应该静态断言 std::atomic<std::size_t> 在您的平台中实际上是无锁的。

但在某些地方（例如复制构造或 ++(int) 运算符），我不是原子的，可能必须使用锁...

使用无序执行策略时，您无法获取锁！参见 [algorithms.parallel]，例如this 和 this。