test/common/xenium/msqueueadaptor.hpp - main - Ant010ff/ffpp

test/common/xenium/msqueueadaptor.hpp
104 строки4 KB
Ant010ff
Demo code update, 2026.
08 фев 2026, 14:26
08 фев 2026, 14:261a5a363
/*
xenium::michael_scott_queue (https://github.com/mpoeter/xenium) adaptor for FFPP library.

Official repository: https://gitlab.com/ant010ff/ffpp

Licensed under the MIT License <http://opensource.org/licenses/MIT>.
SPDX-License-Identifier: MIT
Copyright (c) 2021 - 2026 Anton Nasonov <ant010fff @ gmail . com>.
*/

#ifndef XENIUM_MS_QUEUE_ADAPTOR_HPP
#define XENIUM_MS_QUEUE_ADAPTOR_HPP

#include "xenium/michael_scott_queue.hpp"
#include <xenium/reclamation/stamp_it.hpp>
#include <xenium/reclamation/generic_epoch_based.hpp>
#include <xenium/reclamation/hazard_eras.hpp>
#include <xenium/reclamation/hazard_pointer.hpp>
#include <xenium/reclamation/lock_free_ref_count.hpp>
#include <xenium/reclamation/quiescent_state_based.hpp>

////MichaelScottQueuePolicy///////////////////////////////////////////////////////////////////////////////////////////////////////

struct MichaelScottQueuePolicy { 
	using ResourcePolicyT = ffpp::DefaultResourcePolicy;
	using LockableT = ffpp::Lockable<ffpp::TicketMutex<>>;
};

////MichaelScottQueueAdaptor//////////////////////////////////////////////////////////////////////////////////////////////////////

template<std::movable TValue, ffpp::Concepts::QueuePolicy TPolicy = MichaelScottQueuePolicy>
class MichaelScottQueueAdaptor : public TPolicy::LockableT {
public:
	using ValueT = TValue;
	using PolicyT = TPolicy;
	using ResourcePolicyT = PolicyT::ResourcePolicyT;        
	using LockableT = PolicyT::LockableT;
	using UniqueLockT = LockableT::UniqueLockT;
	using SharedLockT = LockableT::SharedLockT;
	template<typename T> using AllocatorT = typename ResourcePolicyT::template AllocatorT<T>;
	
	static size_t constexpr c_nInvalidLimit = ResourcePolicyT::template InvalidValue<size_t>();

	MichaelScottQueueAdaptor(size_t nLimit = c_nInvalidLimit) 
	: nLimit_(nLimit)
	{ }

	MichaelScottQueueAdaptor(MichaelScottQueueAdaptor const&) = delete;
	MichaelScottQueueAdaptor(MichaelScottQueueAdaptor&&) = delete;

	MichaelScottQueueAdaptor& operator = (MichaelScottQueueAdaptor const&) = delete;
	MichaelScottQueueAdaptor& operator = (MichaelScottQueueAdaptor&&) = delete;

	bool Enqueue(ValueT&& vEnqueue, bool bObligate) {
		if(!bObligate && Limit() <= Size()) return false;
		uqEnqueued_->push(std::move(vEnqueue));
		nSize_.fetch_add(1, std::memory_order::acq_rel);
		return true;
	}

	bool Dequeue(ValueT& vDequeued) {
		auto br = uqEnqueued_->try_pop(vDequeued);
		if(br) nSize_.fetch_sub(1, std::memory_order::acq_rel);
		return br;
	}
	
	size_t Size() const { return nSize_.load(std::memory_order::acquire); }

	bool Empty() const { return Size() == 0; }

	size_t Limit(size_t nLimit) { return nLimit_.exchange(nLimit, std::memory_order::acq_rel); }

	size_t Limit() { return nLimit_.load(std::memory_order::acquire); }

private:   
	using ReclamationPolicyT = xenium::policy::reclaimer<
		xenium::reclamation::hazard_pointer<>::with<
			xenium::policy::allocation_strategy<
				xenium::reclamation::hp_allocation::dynamic_strategy<2>
			>
		>
	>;
	// using ReclamationPolicyT = xenium::policy::reclaimer<xenium::reclamation::debra<>::with<xenium::policy::scan_frequency<10>>>;
	// using ReclamationPolicyT = xenium::policy::reclaimer<xenium::reclamation::new_epoch_based<>::with<xenium::policy::scan_frequency<10>>>;
	// using ReclamationPolicyT = xenium::policy::reclaimer<
	// 	xenium::reclamation::hazard_eras<>::with<
	// 		xenium::policy::allocation_strategy<
	// 			xenium::reclamation::he_allocation::static_strategy<2>
	// 		>
	// 	>
	// >;
	using QueueT = xenium::michael_scott_queue<ValueT, ReclamationPolicyT>;
	using UniqueQueueT = ResourcePolicyT::template UniqueT<QueueT>;

	UniqueQueueT
		uqEnqueued_ = MakeQueue();
	std::atomic<size_t>
		nLimit_ = c_nInvalidLimit,
		nSize_ = 0;

	static UniqueQueueT MakeQueue() { return ResourcePolicyT::template AllocateUnique<QueueT>(); }
};//MichaelScottQueueAdaptor

#endif//XENIUM_MS_QUEUE_ADAPTOR_HPP