8

std::atomic 类型允许对变量进行原子访问，但我有时会喜欢非原子访问，例如当访问受互斥体保护时。考虑一个允许多线程访问（通过插入）和单线程矢量化访问（通过运算符|=）的位域类：

class Bitfield
{
    const size_t size_, word_count_;
    std::atomic<size_t> * words_;
    std::mutex mutex_;

public:

    Bitfield (size_t size) :
        size_(size),
        word_count_((size + 8 * sizeof(size_t) - 1) / (8 * sizeof(size_t)))
    {
        // make sure words are 32-byte aligned
        posix_memalign(&words_, 32, word_count_ * sizeof(size_t));
        for (int i = 0; i < word_count_; ++i) {
            new(words_ + i) std::atomic<size_t>(0);
        }
    }
    ~Bitfield () { free(words_); }

private:
    void insert_one (size_t pos)
    {
        size_t mask = size_t(1) << (pos % (8 * sizeof(size_t)));
        std::atomic<size_t> * word = words_ + pos / (8 * sizeof(size_t));
        word->fetch_or(mask, std::memory_order_relaxed);
    }
public:
    void insert (const std::set<size_t> & items)
    {
        std::lock_guard<std::mutex> lock(mutex_);
        // do some sort of muti-threaded insert, with TBB or #pragma omp
        parallel_foreach(items.begin(), items.end(), insert_one);
    }

    void operator |= (const Bitfield & other)
    {
        assert(other.size_ == size_);
        std::unique_lock<std::mutex> lock1(mutex_, defer_lock);
        std::unique_lock<std::mutex> lock2(other.mutex_, defer_lock);
        std::lock(lock1, lock2); // edited to lock other_.mutex_ as well
        // allow gcc to autovectorize (256 bits at once with AVX)
        static_assert(sizeof(size_t) == sizeof(std::atomic<size_t>), "fail");
        size_t * __restrict__ words = reinterpret_cast<size_t *>(words_);
        const size_t * __restrict__ other_words
            = reinterpret_cast<const size_t *>(other.words_);
        for (size_t i = 0, end = word_count_; i < end; ++i) {
            words[i] |= other_words[i];
        }
    }
};

注意 operator|= 非常接近我的真实代码中的内容，但 insert(std::set) 只是试图捕捉人们可以

acquire lock;
make many atomic accesses in parallel;
release lock;

我的问题是：混合这种原子和非原子访问的最佳方式是什么？下面对 [1,2] 的回答表明强制转换是错误的（我同意）。但该标准肯定允许如此明显的安全访问吗？

更一般地说，是否可以使用读写锁并允许“读者”以原子方式读写，而唯一的“作者”可以非原子方式读写？

参考

  1. 如何有效地使用 std::atomic
  2. 将 C++0x 的 atomic<int> 作为非原子访问
4

3 回答 3

5

C++11 之前的标准 C++ 没有多线程内存模型。我没有看到标准中定义非原子访问的内存模型的任何变化，因此它们得到了与 C++11 之前的环境类似的保证。

实际上，它在理论上甚至比 using 更糟糕memory_order_relaxed，因为非原子访问的跨线程行为是完全未定义的，而不是多个可能的执行顺序，其中一个最终必须发生。

因此，要在混合原子和非原子访问的同时实现这样的模式，您仍然必须依赖特定于平台的非标准构造（例如，_ReadBarrier）和/或对特定硬件的深入了解。

更好的选择是熟悉memory_order枚举，并希望使用给定的代码和编译器实现最佳的汇编输出。最终结果可能是正确的、可移植的，并且不包含不需要的内存栅栏，但如果你像我一样，应该先拆解和分析几个有缺陷的版本；并且仍然无法保证在所有代码路径上使用原子访问不会导致在不同架构或不同编译器上出现一些多余的栅栏。

所以最好的实际答案是简单第一。尽可能简单地设计您的跨线程交互，而不会完全扼杀可扩展性、响应性或任何其他圣牛；几乎没有共享的可变数据结构；并尽可能少地访问它们，始终以原子方式访问它们。

于 2012-09-02T19:59:26.480 回答
4

如果你能做到这一点，你将（可能）有一个线程使用原子访问读取/写入数据对象，而另一个线程读取/写入相同的数据对象而不使用原子访问。这是一场数据竞赛，行为将是不确定的。

于 2012-09-02T19:26:15.843 回答
1

在 C++20 中有std::atomic_ref，它允许对非原子数据进行原子操作。

因此，您应该能够声明words_为非原子size_t*并std::atomic_ref<size_t>在需要时用于执行原子操作。但请注意以下要求：

虽然存在引用对象的任何 atomic_ref 实例，但必须通过这些 atomic_ref 实例以独占方式访问该对象。atomic_ref 对象引用的对象的子对象不能被任何其他 atomic_ref 对象同时引用。

upd：在这种特殊情况下，您可能还需要std::shared_mutex将原子“读者”修改与非原子“作者”修改分开。

于 2020-10-21T12:51:45.203 回答