summaryrefslogtreecommitdiff
path: root/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/pool_core.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/pool_core.hpp')
-rw-r--r--graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/pool_core.hpp453
1 files changed, 0 insertions, 453 deletions
diff --git a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/pool_core.hpp b/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/pool_core.hpp
deleted file mode 100644
index a81df87763..0000000000
--- a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/pool_core.hpp
+++ /dev/null
@@ -1,453 +0,0 @@
-/*! \file
-* \brief Thread pool core.
-*
-* This file contains the threadpool's core class: pool<Task, SchedulingPolicy>.
-*
-* Thread pools are a mechanism for asynchronous and parallel processing
-* within the same process. The pool class provides a convenient way
-* for dispatching asynchronous tasks as functions objects. The scheduling
-* of these tasks can be easily controlled by using customized schedulers.
-*
-* Copyright (c) 2005-2007 Philipp Henkel
-*
-* Use, modification, and distribution are subject to the
-* Boost Software License, Version 1.0. (See accompanying file
-* LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-*
-* http://threadpool.sourceforge.net
-*
-*/
-
-
-#ifndef THREADPOOL_POOL_CORE_HPP_INCLUDED
-#define THREADPOOL_POOL_CORE_HPP_INCLUDED
-
-
-
-
-#include "locking_ptr.hpp"
-#include "worker_thread.hpp"
-
-#include "../task_adaptors.hpp"
-
-#include <boost/thread.hpp>
-#include <boost/thread/exceptions.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/condition.hpp>
-#include <boost/smart_ptr.hpp>
-#include <boost/bind.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits.hpp>
-
-#include <vector>
-
-
-/// The namespace threadpool contains a thread pool and related utility classes.
-namespace boost { namespace threadpool { namespace detail
-{
-
- /*! \brief Thread pool.
- *
- * Thread pools are a mechanism for asynchronous and parallel processing
- * within the same process. The pool class provides a convenient way
- * for dispatching asynchronous tasks as functions objects. The scheduling
- * of these tasks can be easily controlled by using customized schedulers.
- * A task must not throw an exception.
- *
- * A pool_impl is DefaultConstructible and NonCopyable.
- *
- * \param Task A function object which implements the operator 'void operator() (void) const'. The operator () is called by the pool to execute the task. Exceptions are ignored.
- * \param Scheduler A task container which determines how tasks are scheduled. It is guaranteed that this container is accessed only by one thread at a time. The scheduler shall not throw exceptions.
- *
- * \remarks The pool class is thread-safe.
- *
- * \see Tasks: task_func, prio_task_func
- * \see Scheduling policies: fifo_scheduler, lifo_scheduler, prio_scheduler
- */
- template <
- typename Task,
-
- template <typename> class SchedulingPolicy,
- template <typename> class SizePolicy,
- template <typename> class SizePolicyController,
- template <typename> class ShutdownPolicy
- >
- class pool_core
- : public enable_shared_from_this< pool_core<Task, SchedulingPolicy, SizePolicy, SizePolicyController, ShutdownPolicy > >
- , private noncopyable
- {
-
- public: // Type definitions
- typedef Task task_type; //!< Indicates the task's type.
- typedef SchedulingPolicy<task_type> scheduler_type; //!< Indicates the scheduler's type.
- typedef pool_core<Task,
- SchedulingPolicy,
- SizePolicy,
- SizePolicyController,
- ShutdownPolicy > pool_type; //!< Indicates the thread pool's type.
- typedef SizePolicy<pool_type> size_policy_type; //!< Indicates the sizer's type.
- //typedef typename size_policy_type::size_controller size_controller_type;
-
- typedef SizePolicyController<pool_type> size_controller_type;
-
-// typedef SizePolicy<pool_type>::size_controller size_controller_type;
- typedef ShutdownPolicy<pool_type> shutdown_policy_type;//!< Indicates the shutdown policy's type.
-
- typedef worker_thread<pool_type> worker_type;
-
- // The task is required to be a nullary function.
- BOOST_STATIC_ASSERT(function_traits<task_type()>::arity == 0);
-
- // The task function's result type is required to be void.
- BOOST_STATIC_ASSERT(is_void<typename result_of<task_type()>::type >::value);
-
-
- private: // Friends
- friend class worker_thread<pool_type>;
-
-#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x580) // Tested with CC: Sun C++ 5.8 Patch 121018-08 2006/12/06
- friend class SizePolicy;
- friend class ShutdownPolicy;
-#else
- friend class SizePolicy<pool_type>;
- friend class ShutdownPolicy<pool_type>;
-#endif
-
- private: // The following members may be accessed by _multiple_ threads at the same time:
- volatile size_t m_worker_count;
- volatile size_t m_target_worker_count;
- volatile size_t m_active_worker_count;
-
-
-
- private: // The following members are accessed only by _one_ thread at the same time:
- scheduler_type m_scheduler;
- scoped_ptr<size_policy_type> m_size_policy; // is never null
-
- bool m_terminate_all_workers; // Indicates if termination of all workers was triggered.
- std::vector<shared_ptr<worker_type> > m_terminated_workers; // List of workers which are terminated but not fully destructed.
-
- private: // The following members are implemented thread-safe:
- mutable recursive_mutex m_monitor;
- mutable condition m_worker_idle_or_terminated_event; // A worker is idle or was terminated.
- mutable condition m_task_or_terminate_workers_event; // Task is available OR total worker count should be reduced.
-
- public:
- /// Constructor.
- pool_core()
- : m_worker_count(0)
- , m_target_worker_count(0)
- , m_active_worker_count(0)
- , m_terminate_all_workers(false)
- {
- pool_type volatile & self_ref = *this;
- m_size_policy.reset(new size_policy_type(self_ref));
-
- m_scheduler.clear();
- }
-
-
- /// Destructor.
- ~pool_core()
- {
- }
-
- /*! Gets the size controller which manages the number of threads in the pool.
- * \return The size controller.
- * \see SizePolicy
- */
- size_controller_type size_controller()
- {
- return size_controller_type(*m_size_policy, this->shared_from_this());
- }
-
- /*! Gets the number of threads in the pool.
- * \return The number of threads.
- */
- size_t size() const volatile
- {
- return m_worker_count;
- }
-
-// TODO is only called once
- void shutdown()
- {
- ShutdownPolicy<pool_type>::shutdown(*this);
- }
-
- /*! Schedules a task for asynchronous execution. The task will be executed once only.
- * \param task The task function object. It should not throw execeptions.
- * \return true, if the task could be scheduled and false otherwise.
- */
- bool schedule(task_type const & task) volatile
- {
- locking_ptr<pool_type, recursive_mutex> lockedThis(*this, m_monitor);
-
- if(lockedThis->m_scheduler.push(task))
- {
- lockedThis->m_task_or_terminate_workers_event.notify_one();
- return true;
- }
- else
- {
- return false;
- }
- }
-
-
- /*! Returns the number of tasks which are currently executed.
- * \return The number of active tasks.
- */
- size_t active() const volatile
- {
- return m_active_worker_count;
- }
-
-
- /*! Returns the number of tasks which are ready for execution.
- * \return The number of pending tasks.
- */
- size_t pending() const volatile
- {
- locking_ptr<const pool_type, recursive_mutex> lockedThis(*this, m_monitor);
- return lockedThis->m_scheduler.size();
- }
-
-
- /*! Removes all pending tasks from the pool's scheduler.
- */
- void clear() volatile
- {
- locking_ptr<pool_type, recursive_mutex> lockedThis(*this, m_monitor);
- lockedThis->m_scheduler.clear();
- }
-
-
- /*! Indicates that there are no tasks pending.
- * \return true if there are no tasks ready for execution.
- * \remarks This function is more efficient that the check 'pending() == 0'.
- */
- bool empty() const volatile
- {
- locking_ptr<const pool_type, recursive_mutex> lockedThis(*this, m_monitor);
- return lockedThis->m_scheduler.empty();
- }
-
-
- /*! The current thread of execution is blocked until the sum of all active
- * and pending tasks is equal or less than a given threshold.
- * \param task_threshold The maximum number of tasks in pool and scheduler.
- */
- void wait(size_t const task_threshold = 0) const volatile
- {
- const pool_type* self = const_cast<const pool_type*>(this);
- recursive_mutex::scoped_lock lock(self->m_monitor);
-
- if(0 == task_threshold)
- {
- while(0 != self->m_active_worker_count || !self->m_scheduler.empty())
- {
- self->m_worker_idle_or_terminated_event.wait(lock);
- }
- }
- else
- {
- while(task_threshold < self->m_active_worker_count + self->m_scheduler.size())
- {
- self->m_worker_idle_or_terminated_event.wait(lock);
- }
- }
- }
-
- /*! The current thread of execution is blocked until the timestamp is met
- * or the sum of all active and pending tasks is equal or less
- * than a given threshold.
- * \param timestamp The time when function returns at the latest.
- * \param task_threshold The maximum number of tasks in pool and scheduler.
- * \return true if the task sum is equal or less than the threshold, false otherwise.
- */
- bool wait(xtime const & timestamp, size_t const task_threshold = 0) const volatile
- {
- const pool_type* self = const_cast<const pool_type*>(this);
- recursive_mutex::scoped_lock lock(self->m_monitor);
-
- if(0 == task_threshold)
- {
- while(0 != self->m_active_worker_count || !self->m_scheduler.empty())
- {
- if(!self->m_worker_idle_or_terminated_event.timed_wait(lock, timestamp)) return false;
- }
- }
- else
- {
- while(task_threshold < self->m_active_worker_count + self->m_scheduler.size())
- {
- if(!self->m_worker_idle_or_terminated_event.timed_wait(lock, timestamp)) return false;
- }
- }
-
- return true;
- }
-
-
- private:
-
-
- void terminate_all_workers(bool const wait) volatile
- {
- pool_type* self = const_cast<pool_type*>(this);
- recursive_mutex::scoped_lock lock(self->m_monitor);
-
- self->m_terminate_all_workers = true;
-
- m_target_worker_count = 0;
- self->m_task_or_terminate_workers_event.notify_all();
-
- if(wait)
- {
- while(m_active_worker_count > 0)
- {
- self->m_worker_idle_or_terminated_event.wait(lock);
- }
-
- for(typename std::vector<shared_ptr<worker_type> >::iterator it = self->m_terminated_workers.begin();
- it != self->m_terminated_workers.end();
- ++it)
- {
- (*it)->join();
- }
- self->m_terminated_workers.clear();
- }
- }
-
-
- /*! Changes the number of worker threads in the pool. The resizing
- * is handled by the SizePolicy.
- * \param threads The new number of worker threads.
- * \return true, if pool will be resized and false if not.
- */
- bool resize(size_t const worker_count) volatile
- {
- locking_ptr<pool_type, recursive_mutex> lockedThis(*this, m_monitor);
-
- if(!m_terminate_all_workers)
- {
- m_target_worker_count = worker_count;
- }
- else
- {
- return false;
- }
-
-
- if(m_worker_count <= m_target_worker_count)
- { // increase worker count
- while(m_worker_count < m_target_worker_count)
- {
- try
- {
- worker_thread<pool_type>::create_and_attach(lockedThis->shared_from_this());
- m_worker_count++;
- m_active_worker_count++;
- }
- catch(thread_resource_error&)
- {
- return false;
- }
- }
- }
- else
- { // decrease worker count
- lockedThis->m_task_or_terminate_workers_event.notify_all(); // TODO: Optimize number of notified workers
- }
-
- return true;
- }
-
-
- // worker died with unhandled exception
- void worker_died_unexpectedly(shared_ptr<worker_type> worker) volatile
- {
- locking_ptr<pool_type, recursive_mutex> lockedThis(*this, m_monitor);
-
- m_worker_count--;
- m_active_worker_count--;
- lockedThis->m_worker_idle_or_terminated_event.notify_all();
-
- if(m_terminate_all_workers)
- {
- lockedThis->m_terminated_workers.push_back(worker);
- }
- else
- {
- lockedThis->m_size_policy->worker_died_unexpectedly(m_worker_count);
- }
- }
-
- void worker_destructed(shared_ptr<worker_type> worker) volatile
- {
- locking_ptr<pool_type, recursive_mutex> lockedThis(*this, m_monitor);
- m_worker_count--;
- m_active_worker_count--;
- lockedThis->m_worker_idle_or_terminated_event.notify_all();
-
- if(m_terminate_all_workers)
- {
- lockedThis->m_terminated_workers.push_back(worker);
- }
- }
-
-
- bool execute_task() volatile
- {
- function0<void> task;
-
- { // fetch task
- pool_type* lockedThis = const_cast<pool_type*>(this);
- recursive_mutex::scoped_lock lock(lockedThis->m_monitor);
-
- // decrease number of threads if necessary
- if(m_worker_count > m_target_worker_count)
- {
- return false; // terminate worker
- }
-
-
- // wait for tasks
- while(lockedThis->m_scheduler.empty())
- {
- // decrease number of workers if necessary
- if(m_worker_count > m_target_worker_count)
- {
- return false; // terminate worker
- }
- else
- {
- m_active_worker_count--;
- lockedThis->m_worker_idle_or_terminated_event.notify_all();
- lockedThis->m_task_or_terminate_workers_event.wait(lock);
- m_active_worker_count++;
- }
- }
-
- task = lockedThis->m_scheduler.top();
- lockedThis->m_scheduler.pop();
- }
-
- // call task function
- if(task)
- {
- task();
- }
-
- //guard->disable();
- return true;
- }
- };
-
-
-
-
-} } } // namespace boost::threadpool::detail
-
-#endif // THREADPOOL_POOL_CORE_HPP_INCLUDED