swappingsmart.hpp

#pragma once
 
#include <atomic>
#include <memory>
 
USERVER_NAMESPACE_BEGIN
 
namespace utils {
 
// Use a faster and more reliable rcu::Variable instead of this class!
//
// This class helps to store pointer. Pointer stored as shared_ptr.
// Whet you call Get, you will get copy of this shared pointer under read lock.
// When you call Set pointer, it will be stored under writelock.
//
// It works slower than SwappingPtr in 5 times, but readers will always have
// shared_ptr that they obtained, so it is impossible that data will be free'd.
template <typename T>
class SwappingSmart {
public:
    SwappingSmart() = default;
 
    explicit SwappingSmart(const std::shared_ptr<T>& ptr) { Set(ptr); }
 
    std::shared_ptr<T> Get() const {
        const short index = current_.load(std::memory_order_relaxed);
        return ptrs_[index];
    }
    void Set(const std::shared_ptr<T>& ptr) {
        std::shared_ptr<T> buf = ptr;
        // wait for write lock
        while (write_lock_.test_and_set(std::memory_order_acquire)) {
        }
        // read current index
        const short index = current_.load(std::memory_order_relaxed);
        // get new index
        const short new_index = 1 - index;
        // store data in new index
        std::swap(ptrs_[new_index], buf);
        // enable new index
        current_.store(new_index, std::memory_order_relaxed);
        // unlock write lock
        write_lock_.clear(std::memory_order_release);
        // old value will be cleaned here, after lock
    }
    void Set(T&& obj) { Set(std::make_shared<T>(std::move(obj))); }
    void Clear() {
        Set(std::make_shared<T>());
        Set(std::make_shared<T>());
    }
 
private:
    std::atomic<short> current_{0};
    std::atomic_flag write_lock_ ATOMIC_FLAG_INIT;
    std::shared_ptr<T> ptrs_[2];
};
 
}  // namespace utils
 
USERVER_NAMESPACE_END