include/join.hpp - main - Ant010ff/ffpp

include/join.hpp
135 строк6 KB
Ant010ff
Version 2.11.3.
08 авг 2026, 16:44
08 авг 2026, 16:44fd187d3
/*
This header is part of a Functional Flow Processing Primitives (FFPP) library, version 2.11.3.

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 FFPP_JOIN_HPP
#define FFPP_JOIN_HPP

namespace FFPP {

	template<bool t_bNoExcept = false, Concepts::ResourcePolicy TResourcePolicy = DefaultResourcePolicy>
	using SharedGuardT = typename TResourcePolicy::template SharedT<UniqueGuard<t_bNoExcept>>;

	template<bool t_bNoExcept = false, Concepts::ResourcePolicy TResourcePolicy = DefaultResourcePolicy>
	using JoinGuardPairT = std::pair<UniqueGuard<t_bNoExcept>, SharedGuardT<t_bNoExcept, TResourcePolicy>>;

	template<bool t_bNoExcept = false, Concepts::ResourcePolicy TResourcePolicy = DefaultResourcePolicy>
	using UniqueFinalizerT = typename TResourcePolicy::template UniqueT<Finalizer<false, t_bNoExcept, TResourcePolicy>>;

	template<bool t_bExclusive = false, bool t_bNoExcept = true, Concepts::ResourcePolicy TResourcePolicy = DefaultResourcePolicy>
	using SharedFinalizerT = typename TResourcePolicy::template SharedT<Finalizer<t_bExclusive, t_bNoExcept, TResourcePolicy>>;

	template<bool t_bExclusive = false, bool t_bNoExcept = true, Concepts::ResourcePolicy TResourcePolicy = DefaultResourcePolicy>
	using JoinListPairT = std::pair<
		UniqueFinalizerT<t_bNoExcept, TResourcePolicy>, 
		SharedFinalizerT<t_bExclusive, t_bNoExcept, TResourcePolicy>
	>;

	namespace dtl {

		struct AtomicFlag {
			alignas(sizeof(CompatibleCounterT)) std::atomic_flag flag;
		};

	}//dtl

	//BeginJoin, prepares for multiple thread join operation. Shared guard, returned as a second element, must be passed into another 
	//thread(s). Unique guard, the first element, performs atomic wait in calling thread. 
	template<bool t_bNoExcept = false, Concepts::ResourcePolicy TPolicy = DefaultResourcePolicy>
	FFPP_ATTR_INLINE
	inline JoinGuardPairT<t_bNoExcept, TPolicy> BeginJoin() {
		auto safComplete = TPolicy::template AllocateShared<dtl::AtomicFlag>();
		return { 
			[safComplete] () { 
				safComplete->flag.wait(false, std::memory_order::acquire); 
			}, 
			TPolicy::template AllocateShared<UniqueGuard<t_bNoExcept>>([safComplete] () { 
				safComplete->flag.test_and_set(std::memory_order::release); 
				safComplete->flag.notify_one();
			})
		};
	}//BeginJoin

	template<bool t_bNoExcept = false, Concepts::ResourcePolicy TPolicy = DefaultResourcePolicy>
	FFPP_ATTR_INLINE
	inline JoinGuardPairT<t_bNoExcept, TPolicy> BeginJoin(std::invocable auto&& onComplete) {
		auto safComplete = TPolicy::template AllocateShared<dtl::AtomicFlag>();
		return { 
			[safComplete] () { 
				safComplete->flag.wait(false, std::memory_order::acquire); 
			}, 
			TPolicy::template AllocateShared<UniqueGuard<t_bNoExcept>>([safComplete, onComplete = std::move(onComplete)] () mutable { 
				std::invoke(std::move(onComplete));
				safComplete->flag.test_and_set(std::memory_order::release); 
				safComplete->flag.notify_one();
			})
		};
	}//BeginJoin

	template<bool t_bNoExcept = false, Concepts::ResourcePolicy TPolicy = DefaultResourcePolicy>
	FFPP_ATTR_INLINE
	inline JoinGuardPairT<t_bNoExcept, TPolicy> BeginJoin(std::invocable auto&& onJoin, std::invocable auto&& onComplete) {
		auto safComplete = TPolicy::template AllocateShared<dtl::AtomicFlag>();
		return { 
			[safComplete, onJoin = std::move(onJoin)] () mutable { 
				safComplete->flag.wait(false, std::memory_order::acquire); 
				std::invoke(std::move(onJoin));
			}, 
			TPolicy::template AllocateShared<UniqueGuard<t_bNoExcept>>([safComplete, onComplete = std::move(onComplete)] () mutable { 
				std::invoke(std::move(onComplete));
				safComplete->flag.test_and_set(std::memory_order::release); 
				safComplete->flag.notify_one();
			})
		};
	}//BeginJoin

	//BeginJoinList, prepares for multiple thread join operation with finalization lists (finalizers). Shared finalizer, returned 
	//as a second element, must be passed into another thread(s). Unique finalizer, the first element, performs atomic wait in 
	//calling thread. 
	//t_bExclusive template parameter allows to create thread safe shared finalizer, which could be appended from multiple threads 
	//in case finalization order is irrelevant.
	template<bool t_bExclusive = false, bool t_bNoExcept = true, Concepts::ResourcePolicy TPolicy = DefaultResourcePolicy>
	FFPP_ATTR_INLINE
	inline JoinListPairT<t_bExclusive, t_bNoExcept, TPolicy> BeginJoinList() {
		auto safComplete = TPolicy::template AllocateShared<dtl::AtomicFlag>();
		return { 
			TPolicy::template AllocateUnique<Finalizer<false, t_bNoExcept, TPolicy>>([safComplete] () { 
				safComplete->flag.wait(false, std::memory_order::acquire); 
			}), 
			TPolicy::template AllocateShared<Finalizer<t_bExclusive, t_bNoExcept, TPolicy>>([safComplete] () { 
				safComplete->flag.test_and_set(std::memory_order::release); 
				safComplete->flag.notify_one();
			})
		};
	}//BeginJoinList

	//FinishJoin, finishes multiple thread join operation in calling thread, guarantees correct order of finalization.
	template<typename TComplete, typename TJoin>
	requires (
		std::same_as<TJoin, typename TJoin::element_type::ResourcePolicyT::template UniqueT<typename TJoin::element_type>>
		|| std::same_as<TJoin, UniqueGuard<true>>
		|| std::same_as<TJoin, UniqueGuard<false>>
	)
	FFPP_ATTR_INLINE
	inline void FinishJoin(TComplete& fnlComplete, TJoin& fnlJoin) {
		fnlComplete = { };
		fnlJoin = { };
	}//FinishJoin

	template<typename TJoinPair>
	requires Concepts::Specialization<TJoinPair, std::pair>
	FFPP_ATTR_INLINE
	inline void FinishJoin(TJoinPair& prJoin) {
		prJoin.second = { };
		prJoin.first = { };
	}//FinishJoin

}//FFPP

#endif//FFPP_JOIN_HPP