将阻塞函数添加到无锁队列

Question

我有一个基于循环缓冲区的无锁多生产者，单个消费者队列。 到目前为止，它只有非阻塞的push_back()和pop_front()调用。 现在我想添加这些调用的阻止版本，但我希望尽量减少这对使用非阻塞版本的代码性能的影响 - 也就是说，它不应该将它们变成“ 默认锁定 ”调用。

例如，最简单的阻塞push_back（）版本如下所示：

void push_back_Blocking(const T& pkg) {
    if (!push_back(pkg)) {
        unique_lock<mutex> ul(mux);
        while (!push_back(pkg)) {
            cv_notFull.wait(ul);
        }
    }
}

但不幸的是，这还需要将以下块放在“非阻塞” pop_front()的末尾：

{
    std::lock_guard<mutex> lg(mux);
    cv_notFull.notify_all();
}

虽然单独notify几乎没有任何性能影响（如果没有线程在等待），则锁具有。

所以我的问题是：
我如何（如果可能，使用标准的c ++ 14）将阻塞的push_back和pop_front成员函数添加到我的队列中，而不会严重阻碍non_blocking对应的性能（读取：最小化系统调用）？ 至少只要没有线程被实际阻止 - 但理想情况下即使这样。

---

作为参考，我当前的版本看起来与此类似（我省略了调试检查，数据对齐和显式内存排序）：

template<class T, size_t N>
class MPSC_queue {
    using INDEX_TYPE = unsigned long;
    struct Idx {
        INDEX_TYPE idx;
        INDEX_TYPE version_cnt;
    };
    enum class SlotState {
        EMPTY,
        FILLED
    };
    struct Slot {
        Slot() = default;               
        std::atomic<SlotState> state= SlotState::EMPTY;
        T data{};
    };
    struct Buffer_t {
        std::array<Slot, N> data{}; 
        Buffer_t() {
            data.fill(Slot{ SlotState::EMPTY, T{} });
        }
        Slot& operator[](Idx idx) {
            return this->operator[](idx.idx);
        }
        Slot& operator[](INDEX_TYPE idx) {
            return data[idx];                   
        }
    };

    Buffer_t buffer;
    std::atomic<Idx> head{};
    std::atomic<INDEX_TYPE> tail=0;

    INDEX_TYPE next(INDEX_TYPE old) { return (old + 1) % N; }

    Idx next(Idx old) {
        old.idx = next(old.idx);
        old.version_cnt++;
        return old;
    }
public:     
    bool push_back(const T& val) {
        auto tHead = head.load();
        Idx wrtIdx;
        do {
            wrtIdx = next(tHead);
            if (wrtIdx.idx == tail) {
                return false;
            }
        } while (!head.compare_exchange_strong(tHead, wrtIdx));

        buffer[wrtIdx].data = val;
        buffer[wrtIdx].state = SlotState::FILLED;
        return true;
    }

    bool pop_front(T& val) {                
        auto rIdx = next(tail);
        if (buffer[rIdx].state != SlotState::FILLED) {
            return false;
        }
        val = buffer[rIdx].data;
        buffer[rIdx].state = SlotState::EMPTY;
        tail = rIdx;
        return true;
    }
};

---

相关问题：

我问specificly有关优化的使用了类似的问题condition_variable::notify 这里 ，但问题得到了关闭的所谓复制的这个问题 。
我不同意，因为这个问题是关于为什么一般情况下需要互斥量（或者更确切地说是pthread等价物）的原因 - 关注condition_variable::wait - 而不是if /如何避免notify部分。 但显然我没有那么明确（或者人们只是不同意我的意见）。

在任何情况下，链接问题中的答案对我没有帮助，因为这无论如何都是一个XY问题 ，我决定提出另一个关于我所遇到的实际问题的问题，从而允许更广泛的可能解决方案（也许在那里）是一种完全避免条件变量的方法。

这个问题也很相似，但是

1. 它是关于Linux上的C和答案使用平台特定的结构（pthreads和futexes）
2. 那里的作者要求有效的阻止呼叫，但根本没有阻止呼叫。 另一方面，我不太关心阻塞效率，但希望尽可能快地保持非阻塞效率。

Answer 1

如果条件变量上有潜在的服务员， 则必须锁定用于notify_all调用的互斥锁。

问题是条件检查 （ !push_back(pkg) ） 在等待条件变量 之前执行（C ++ 11没有提供其他方法）。 因此，互斥是唯一可以保证这些行为之间保持一致的手段。

但是，如果不涉及潜在的服务员，则可以省略锁定（和通知）。 只需使用additinal标志：

class MPSC_queue {
    ... // Original definitions
    std::atomic<bool> has_waiters;

public:
    void push_back_Blocking(const T& pkg) {
        if (!push_back(pkg)) {
            unique_lock<mutex> ul(mux);
            has_waiters.store(true, std::memory_order_relaxed); // #1
            while (!push_back(pkg)) { // #2 inside push_back() method
                cv_notFull.wait(ul);
                // Other waiter may clean flag while we wait. Set it again. Same as #1.
                has_waiters.store(true, std::memory_order_relaxed);
            }
            has_waiters.store(false, std::memory_order_relaxed);
        }
    }

    // Method is same as original, exposed only for #2 mark.
    bool push_back(const T& val) {
        auto tHead = head.load();
        Idx wrtIdx;
        do {
            wrtIdx = next(tHead);
            if (wrtIdx.idx == tail) { // #2
                return false;
            }
        } while (!head.compare_exchange_strong(tHead, wrtIdx));

        buffer[wrtIdx].data = val;
        buffer[wrtIdx].state = SlotState::FILLED;
        return true;
    }

    bool pop_front(T& val) {
        // Main work, same as original pop_front, exposed only for #3 mark.
        auto rIdx = next(tail);
        if (buffer[rIdx].state != SlotState::FILLED) {
            return false;
        }
        val = buffer[rIdx].data;
        buffer[rIdx].state = SlotState::EMPTY;
        tail = rIdx; // #3

        // Notification part
        if(has_waiters.load(std::memory_order_relaxed)) // #4
        {
            // There are potential waiters. Need to lock.
            std::lock_guard<mutex> lg(mux);
            cv_notFull.notify_all();
        }

        return true;
    }
};

这里的关键关系是：

1. 在#1处设置标志并在#2处读取tail以检查条件。
2. 在#3处存储tail并在#4处检查标志。

这两种关系都应该暴露某种普遍秩序 。 即#1甚至其他线程也应该在#2之前观察#1 。 #3和#4 。

在这种情况下，可以保证， 如果检查标志#4发现它没有设置，那么可能的进一步条件检查#2将发现条件变化#3效果 。 因此，不锁定（和通知）是安全的，因为没有服务员是可能的。

在当前实现中，通过使用隐式memory_order_seq_cst加载tail来提供#1和#2之间的通用顺序 。 通过使用隐式memory_order_seq_cst存储tail来提供#3和#4之间的相同顺序。

在那种方法中，“如果没有服务员就不要锁定”， 普遍秩序是最棘手的部分。 在这两种关系中，它都是Read After Write命令，使用memory_order_acquire和memory_order_release的任意组合都无法实现。 所以应该使用memory_order_seq_cst 。