c++ - 使用shared_ptr实现RCU(读取-复制-更新)？

Question

我对用户空间 RCU(读取-复制-更新)非常感兴趣，并尝试通过 tr1::shared_ptr 模拟一个，这是代码，虽然我真的是并发编程的新手，但会有高手帮我review吗？

基本思路是，reader 调用 get_reading_copy() 以获得当前 protected 数据的指针(假设它是第一代，或 G1)。 writer 调用 get_updating_copy() 以获得 G1 的拷贝(假设它是 G2)，并且只允许一个 writer 进入临界区。更新完成后，writer 调用 update() 进行交换，使 m_data_ptr 指向 G2 数据。正在进行的读者和作者现在持有 G1 的 shared_ptr(s)，并且读者或作者最终将释放 G1 数据。

任何新的读者都将获得指向 G2 的指针，而新的作者将获得 G2 的拷贝(假设它是 G3)。可能G1还没有发布，多代数据可能并存。

template <typename T>
class rcu_protected
{
public:
    typedef T                                   type;
    typedef const T                             const_type;
    typedef std::tr1::shared_ptr<type>          rcu_pointer;
    typedef std::tr1::shared_ptr<const_type>    rcu_const_pointer;

    rcu_protected() : m_is_writing(0),
                      m_is_swapping(0),
                      m_data_ptr (new type())
    {}

    rcu_const_pointer get_reading_copy ()
    {
        spin_until_eq (m_is_swapping, 0);

        return m_data_ptr;
    }

    rcu_pointer get_updating_copy ()
    {
        spin_until_eq (m_is_swapping, 0);

        while (!CAS (m_is_writing, 0, 1))
        {/* do sleep for back-off when exceeding maximum retry times */}

        rcu_pointer new_data_ptr(new type(*m_data_ptr));

        // as spin_until_eq does not have memory barrier protection,
        // we need to place a read barrier to protect the loading of
        // new_data_ptr not to be re-ordered before its construction
        _ReadBarrier();

        return new_data_ptr;
    }

    void update (rcu_pointer new_data_ptr)
    {
        while (!CAS (m_is_swapping, 0, 1))
        {}

        m_data_ptr.swap (new_data_ptr);

        // as spin_until_eq does not have memory barrier protection,
        // we need to place a write barrier to protect the assignments of
        // m_is_writing/m_is_swapping be re-ordered bofore the swapping
        _WriteBarrier();

        m_is_writing = 0;
        m_is_swapping = 0;
    }

private:
    volatile long m_is_writing;
    volatile long m_is_swapping;
    rcu_pointer m_data_ptr;
};

Answer 1

乍一看，我会将 spin_until_eq 调用和关联的自旋锁交换为互斥体。如果在关键部分允许不止一个作者，那么我会使用信号量。这些并发机制的实现可能依赖于操作系统，因此还应考虑性能因素；通常，他们比忙碌的等待更好。