← Back
Editing: scheduler.hpp
//---------------------------------------------------------------------------- /// @file scheduler.hpp /// @brief This file contains the implementation of the scheduler for /// dispatch the works stored /// /// @author Copyright (c) 2010-2015 Francisco José Tapia (fjtapia@gmail.com )\n /// Distributed under the Boost Software License, Version 1.0.\n /// ( See accompanyingfile LICENSE_1_0.txt or copy at /// http://www.boost.org/LICENSE_1_0.txt ) /// @version 0.1 /// /// @remarks //----------------------------------------------------------------------------- #ifndef __BOOST_SORT_COMMON_SCHEDULER_HPP #define __BOOST_SORT_COMMON_SCHEDULER_HPP #include <boost/sort/common/spinlock.hpp> #include <boost/sort/common/search.hpp> #include <boost/sort/common/compare_traits.hpp> #include <scoped_allocator> #include <utility> #include <vector> #include <deque> #include <iostream> #include <unordered_map> namespace boost { namespace sort { namespace common { // //########################################################################### // ## // ################################################################ ## // # # ## // # C L A S S S C H E D U L E R # ## // # # ## // ################################################################ ## // ## //########################################################################### // //--------------------------------------------------------------------------- /// @class scheduler /// @brief This class is a concurrent stack controled by a spin_lock /// @remarks //--------------------------------------------------------------------------- template<typename Func_t, typename Allocator = std::allocator<Func_t> > struct scheduler { //----------------------------------------------------------------------- // D E F I N I T I O N S //----------------------------------------------------------------------- typedef std::scoped_allocator_adaptor <Allocator> scoped_alloc; typedef std::deque <Func_t, scoped_alloc> deque_t; typedef typename deque_t::iterator it_deque; typedef std::thread::id key_t; typedef std::hash <key_t> hash_t; typedef std::equal_to <key_t> equal_t; typedef std::unique_lock <spinlock_t> lock_t; typedef std::unordered_map <key_t, deque_t, hash_t, equal_t, scoped_alloc> map_t; typedef typename map_t::iterator it_map; //----------------------------------------------------------------------- // V A R I A B L E S //----------------------------------------------------------------------- map_t mp; size_t nelem; mutable spinlock_t spl; //------------------------------------------------------------------------ // function : scheduler /// @brief constructor //------------------------------------------------------------------------ scheduler(void) : mp(), nelem(0) { }; // //----------------------------------------------------------------------- // function : scheduler /// @brief Copy & move constructor /// @param [in] VT : stack_cnc from where copy the data //----------------------------------------------------------------------- scheduler(scheduler && VT) = delete; scheduler(const scheduler & VT) = delete; // //------------------------------------------------------------------------ // function : ~scheduler /// @brief Destructor //------------------------------------------------------------------------ virtual ~scheduler(void) {mp.clear();}; // //------------------------------------------------------------------------ // function : operator = /// @brief Asignation operator /// @param [in] VT : stack_cnc from where copy the data /// @return Reference to the stack_cnc after the copy //------------------------------------------------------------------------ scheduler & operator=(const scheduler &VT) = delete; // //------------------------------------------------------------------------ // function : size /// @brief Asignation operator /// @param [in] VT : stack_cnc from where copy the data /// @return Reference to the stack_cnc after the copy //------------------------------------------------------------------------ size_t size(void) const { lock_t s(spl); return nelem; }; // //------------------------------------------------------------------------ // function : clear /// @brief Delete all the elements of the stack_cnc. //------------------------------------------------------------------------ void clear_all(void) { lock_t s(spl); mp.clear(); nelem = 0; }; // //------------------------------------------------------------------------ // function : insert /// @brief Insert one element in the back of the container /// @param [in] D : value to insert. Can ve a value, a reference or an /// rvalue /// @return iterator to the element inserted /// @remarks This operation is O ( const ) //------------------------------------------------------------------------ void insert(Func_t & f) { lock_t s(spl); key_t th_id = std::this_thread::get_id(); it_map itmp = mp.find(th_id); if (itmp == mp.end()) { auto aux = mp.emplace(th_id, deque_t()); if (aux.second == false) throw std::bad_alloc(); itmp = aux.first; }; itmp->second.emplace_back(std::move(f)); nelem++; }; // //------------------------------------------------------------------------ // function :emplace /// @brief Insert one element in the back of the container /// @param [in] args :group of arguments for to build the object to insert /// @return iterator to the element inserted /// @remarks This operation is O ( const ) //------------------------------------------------------------------------ template<class ... Args> void emplace(Args && ... args) { lock_t s(spl); key_t th_id = std::this_thread::get_id(); it_map itmp = mp.find(th_id); if (itmp == mp.end()) { auto aux = mp.emplace(th_id, deque_t()); if (aux.second == false) throw std::bad_alloc(); itmp = aux.first; }; itmp->second.emplace_back(std::forward <Args>(args) ...); nelem++; }; // //------------------------------------------------------------------------ // function : insert /// @brief Insert one element in the back of the container /// @param [in] D : value to insert. Can ve a value, a reference or an rvalue /// @return iterator to the element inserted /// @remarks This operation is O ( const ) //------------------------------------------------------------------------ template<class it_func> void insert_range(it_func first, it_func last) { //-------------------------------------------------------------------- // Metaprogramming //-------------------------------------------------------------------- typedef value_iter<it_func> value2_t; static_assert (std::is_same< Func_t, value2_t >::value, "Incompatible iterators\n"); //-------------------------------------------------------------------- // Code //-------------------------------------------------------------------- assert((last - first) > 0); lock_t s(spl); key_t th_id = std::this_thread::get_id(); it_map itmp = mp.find(th_id); if (itmp == mp.end()) { auto aux = mp.emplace(th_id, deque_t()); if (aux.second == true) throw std::bad_alloc(); itmp = aux.first; }; while (first != last) { itmp->second.emplace_back(std::move(*(first++))); nelem++; }; }; // //------------------------------------------------------------------------ // function : extract /// @brief erase the last element of the tree and return a copy /// @param [out] V : reference to a variable where copy the element /// @return code of the operation /// 0- Element erased /// 1 - Empty tree /// @remarks This operation is O(1) //------------------------------------------------------------------------ bool extract(Func_t & f) { lock_t s(spl); if (nelem == 0) return false; key_t th_id = std::this_thread::get_id(); it_map itmp = mp.find(th_id); if (itmp != mp.end() and not itmp->second.empty()) { f = std::move(itmp->second.back()); itmp->second.pop_back(); --nelem; return true; }; for (itmp = mp.begin(); itmp != mp.end(); ++itmp) { if (itmp->second.empty()) continue; f = std::move(itmp->second.back()); itmp->second.pop_back(); --nelem; return true; } return false; }; }; // end class scheduler //************************************************************************* // P R I N T F U N C T I O N S //************************************************************************ template<class ... Args> std::ostream & operator <<(std::ostream &out, const std::deque<Args ...> & dq) { for (uint32_t i = 0; i < dq.size(); ++i) out << dq[i] << " "; out << std::endl; return out; } template<typename Func_t, typename Allocator = std::allocator<Func_t> > std::ostream & operator <<(std::ostream &out, const scheduler<Func_t, Allocator> &sch) { std::unique_lock < spinlock_t > s(sch.spl); out << "Nelem :" << sch.nelem << std::endl; for (auto it = sch.mp.begin(); it != sch.mp.end(); ++it) { out << it->first << " :" << it->second << std::endl; } return out; } //*************************************************************************** };// end namespace common };// end namespace sort };// end namespace boost //*************************************************************************** #endif
Save File
Cancel