summaryrefslogtreecommitdiff
path: root/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool
diff options
context:
space:
mode:
Diffstat (limited to 'graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool')
-rw-r--r--graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/future.hpp215
-rw-r--r--graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/locking_ptr.hpp85
-rw-r--r--graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/pool_core.hpp453
-rw-r--r--graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/scope_guard.hpp65
-rw-r--r--graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/worker_thread.hpp115
-rw-r--r--graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/future.hpp144
-rw-r--r--graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/pool.hpp232
-rw-r--r--graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/pool_adaptors.hpp70
-rw-r--r--graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/scheduling_policies.hpp262
-rw-r--r--graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/shutdown_policies.hpp83
-rw-r--r--graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/size_policies.hpp99
-rw-r--r--graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/task_adaptors.hpp168
12 files changed, 0 insertions, 1991 deletions
diff --git a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/future.hpp b/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/future.hpp
deleted file mode 100644
index 4e4b35bebe..0000000000
--- a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/future.hpp
+++ /dev/null
@@ -1,215 +0,0 @@
-/*! \file
-* \brief TODO.
-*
-* TODO.
-*
-* 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_DETAIL_FUTURE_IMPL_HPP_INCLUDED
-#define THREADPOOL_DETAIL_FUTURE_IMPL_HPP_INCLUDED
-
-
-#include "locking_ptr.hpp"
-
-#include <boost/smart_ptr.hpp>
-#include <boost/optional.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/condition.hpp>
-#include <boost/thread/xtime.hpp>
-#include <boost/utility/result_of.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits.hpp>
-
-namespace boost { namespace threadpool { namespace detail
-{
-
-template<class Result>
-class future_impl
-{
-public:
- typedef Result const & result_type; //!< Indicates the functor's result type.
-
- typedef Result future_result_type; //!< Indicates the future's result type.
- typedef future_impl<future_result_type> future_type;
-
-private:
- volatile bool m_ready;
- volatile future_result_type m_result;
-
- mutable mutex m_monitor;
- mutable condition m_condition_ready;
-
- volatile bool m_is_cancelled;
- volatile bool m_executing;
-
-public:
-
-
-public:
-
- future_impl()
- : m_ready(false)
- , m_is_cancelled(false)
- {
- }
-
- bool ready() const volatile
- {
- return m_ready;
- }
-
- void wait() const volatile
- {
- const future_type* self = const_cast<const future_type*>(this);
- mutex::scoped_lock lock(self->m_monitor);
-
- while(!m_ready)
- {
- self->m_condition_ready.wait(lock);
- }
- }
-
-
- bool timed_wait(boost::xtime const & timestamp) const
- {
- const future_type* self = const_cast<const future_type*>(this);
- mutex::scoped_lock lock(self->m_monitor);
-
- while(!m_ready)
- {
- if(!self->m_condition_ready.timed_wait(lock, timestamp)) return false;
- }
-
- return true;
- }
-
-
- result_type operator()() const volatile
- {
- wait();
-/*
- if( throw_exception_ != 0 )
- {
- throw_exception_( this );
- }
-*/
-
- return *(const_cast<const future_result_type*>(&m_result));
- }
-
-
- void set_value(future_result_type const & r) volatile
- {
- locking_ptr<future_type, mutex> lockedThis(*this, m_monitor);
- if(!m_ready && !m_is_cancelled)
- {
- lockedThis->m_result = r;
- lockedThis->m_ready = true;
- lockedThis->m_condition_ready.notify_all();
- }
- }
-/*
- template<class E> void set_exception() // throw()
- {
- m_impl->template set_exception<E>();
- }
-
- template<class E> void set_exception( char const * what ) // throw()
- {
- m_impl->template set_exception<E>( what );
- }
- */
-
-
- bool cancel() volatile
- {
- if(!m_ready || m_executing)
- {
- m_is_cancelled = true;
- return true;
- }
- else
- {
- return false;
- }
- }
-
-
- bool is_cancelled() const volatile
- {
- return m_is_cancelled;
- }
-
-
- void set_execution_status(bool executing) volatile
- {
- m_executing = executing;
- }
-};
-
-
-template<
- template <typename> class Future,
- typename Function
->
-class future_impl_task_func
-{
-
-public:
- typedef void result_type; //!< Indicates the functor's result type.
-
- typedef Function function_type; //!< Indicates the function's type.
- typedef typename result_of<function_type()>::type future_result_type; //!< Indicates the future's result type.
- typedef Future<future_result_type> future_type; //!< Indicates the future's type.
-
- // The task is required to be a nullary function.
- BOOST_STATIC_ASSERT(function_traits<function_type()>::arity == 0);
-
- // The task function's result type is required not to be void.
- BOOST_STATIC_ASSERT(!is_void<future_result_type>::value);
-
-private:
- function_type m_function;
- shared_ptr<future_type> m_future;
-
-public:
- future_impl_task_func(function_type const & function, shared_ptr<future_type> const & future)
- : m_function(function)
- , m_future(future)
- {
- }
-
- void operator()()
- {
- if(m_function)
- {
- m_future->set_execution_status(true);
- if(!m_future->is_cancelled())
- {
- // TODO future exeception handling
- m_future->set_value(m_function());
- }
- m_future->set_execution_status(false); // TODO consider exceptions
- }
- }
-
-};
-
-
-
-
-
-} } } // namespace boost::threadpool::detail
-
-#endif // THREADPOOL_DETAIL_FUTURE_IMPL_HPP_INCLUDED
-
-
diff --git a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/locking_ptr.hpp b/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/locking_ptr.hpp
deleted file mode 100644
index 57ba560b5a..0000000000
--- a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/locking_ptr.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/*! \file
-* \brief The locking_ptr is smart pointer with a scoped locking mechanism.
-*
-* The class is a wrapper for a volatile pointer. It enables synchronized access to the
-* internal pointer by locking the passed mutex.
-* locking_ptr is based on Andrei Alexandrescu's LockingPtr. For more information
-* see article "volatile - Multithreaded Programmer's Best Friend" by A. Alexandrescu.
-*
-*
-* 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_DETAIL_LOCKING_PTR_HPP_INCLUDED
-#define THREADPOOL_DETAIL_LOCKING_PTR_HPP_INCLUDED
-
-#include <boost/utility.hpp>
-#include <boost/thread/mutex.hpp>
-
-
-namespace boost { namespace threadpool { namespace detail
-{
-
-/*! \brief Smart pointer with a scoped locking mechanism.
- *
- * This class is a wrapper for a volatile pointer. It enables synchronized access to the
- * internal pointer by locking the passed mutex.
- */
- template <typename T, typename Mutex>
- class locking_ptr
- : private noncopyable
- {
- T* m_obj; //!< The instance pointer.
- Mutex & m_mutex; //!< Mutex is used for scoped locking.
-
- public:
- /// Constructor.
- locking_ptr(volatile T& obj, const volatile Mutex& mtx)
- : m_obj(const_cast<T*>(&obj))
- , m_mutex(*const_cast<Mutex*>(&mtx))
- {
- // Lock mutex
- m_mutex.lock();
- }
-
-
- /// Destructor.
- ~locking_ptr()
- {
- // Unlock mutex
- m_mutex.unlock();
- }
-
-
- /*! Returns a reference to the stored instance.
- * \return The instance's reference.
- */
- T& operator*() const
- {
- return *m_obj;
- }
-
-
- /*! Returns a pointer to the stored instance.
- * \return The instance's pointer.
- */
- T* operator->() const
- {
- return m_obj;
- }
- };
-
-
-} } } // namespace boost::threadpool::detail
-
-
-#endif // THREADPOOL_DETAIL_LOCKING_PTR_HPP_INCLUDED
-
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
diff --git a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/scope_guard.hpp b/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/scope_guard.hpp
deleted file mode 100644
index 68634654ba..0000000000
--- a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/scope_guard.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-/*! \file
-* \brief TODO.
-*
-* TODO.
-*
-* 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_DETAIL_SCOPE_GUARD_HPP_INCLUDED
-#define THREADPOOL_DETAIL_SCOPE_GUARD_HPP_INCLUDED
-
-
-
-#include <boost/function.hpp>
-
-
-namespace boost { namespace threadpool { namespace detail
-{
-
-// TODO documentation
-class scope_guard
-: private boost::noncopyable
-{
- function0<void> const m_function;
- bool m_is_active;
-
-public:
- scope_guard(function0<void> const & call_on_exit)
- : m_function(call_on_exit)
- , m_is_active(true)
- {
- }
-
- ~scope_guard()
- {
- if(m_is_active && m_function)
- {
- m_function();
- }
- }
-
- void disable()
- {
- m_is_active = false;
- }
-};
-
-
-
-
-
-
-} } } // namespace boost::threadpool::detail
-
-#endif // THREADPOOL_DETAIL_SCOPE_GUARD_HPP_INCLUDED
-
-
diff --git a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/worker_thread.hpp b/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/worker_thread.hpp
deleted file mode 100644
index d33467a527..0000000000
--- a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/detail/worker_thread.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-/*! \file
-* \brief Thread pool worker.
-*
-* The worker thread instance is attached to a pool
-* and executes tasks of this pool.
-*
-* 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_DETAIL_WORKER_THREAD_HPP_INCLUDED
-#define THREADPOOL_DETAIL_WORKER_THREAD_HPP_INCLUDED
-
-
-#include "scope_guard.hpp"
-
-#include <boost/smart_ptr.hpp>
-#include <boost/thread.hpp>
-#include <boost/thread/exceptions.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/bind.hpp>
-
-
-namespace boost { namespace threadpool { namespace detail
-{
-
- /*! \brief Thread pool worker.
- *
- * A worker_thread represents a thread of execution. The worker is attached to a
- * thread pool and processes tasks of that pool. The lifetime of the worker and its
- * internal boost::thread is managed automatically.
- *
- * This class is a helper class and cannot be constructed or accessed directly.
- *
- * \see pool_core
- */
- template <typename Pool>
- class worker_thread
- : public enable_shared_from_this< worker_thread<Pool> >
- , private noncopyable
- {
- public:
- typedef Pool pool_type; //!< Indicates the pool's type.
-
- private:
- shared_ptr<pool_type> m_pool; //!< Pointer to the pool which created the worker.
- shared_ptr<boost::thread> m_thread; //!< Pointer to the thread which executes the run loop.
-
-
- /*! Constructs a new worker.
- * \param pool Pointer to it's parent pool.
- * \see function create_and_attach
- */
- worker_thread(shared_ptr<pool_type> const & pool)
- : m_pool(pool)
- {
- assert(pool);
- }
-
-
- /*! Notifies that an exception occurred in the run loop.
- */
- void died_unexpectedly()
- {
- m_pool->worker_died_unexpectedly(this->shared_from_this());
- }
-
-
- public:
- /*! Executes pool's tasks sequentially.
- */
- void run()
- {
- scope_guard notify_exception(bind(&worker_thread::died_unexpectedly, this));
-
- while(m_pool->execute_task()) {}
-
- notify_exception.disable();
- m_pool->worker_destructed(this->shared_from_this());
- }
-
-
- /*! Joins the worker's thread.
- */
- void join()
- {
- m_thread->join();
- }
-
-
- /*! Constructs a new worker thread and attaches it to the pool.
- * \param pool Pointer to the pool.
- */
- static void create_and_attach(shared_ptr<pool_type> const & pool)
- {
- shared_ptr<worker_thread> worker(new worker_thread(pool));
- if(worker)
- {
- worker->m_thread.reset(new boost::thread(bind(&worker_thread::run, worker)));
- }
- }
-
- };
-
-
-} } } // namespace boost::threadpool::detail
-
-#endif // THREADPOOL_DETAIL_WORKER_THREAD_HPP_INCLUDED
-
diff --git a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/future.hpp b/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/future.hpp
deleted file mode 100644
index f4a6e12244..0000000000
--- a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/future.hpp
+++ /dev/null
@@ -1,144 +0,0 @@
-/*! \file
-* \brief TODO.
-*
-* TODO.
-*
-* 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_FUTURE_HPP_INCLUDED
-#define THREADPOOL_FUTURE_HPP_INCLUDED
-
-
-
-#include "./detail/future.hpp"
-#include <boost/utility/enable_if.hpp>
-
-//#include "pool.hpp"
-//#include <boost/utility.hpp>
-
-//#include <boost/thread/mutex.hpp>
-
-
-namespace boost { namespace threadpool
-{
-
- /*! \brief Experimental. Do not use in production code. TODO.
- *
- * TODO Future
- *
- * \see TODO
- *
- */
-
-
-template<class Result>
-class future
-{
-private:
- shared_ptr<detail::future_impl<Result> > m_impl;
-
-public:
- typedef Result const & result_type; //!< Indicates the functor's result type.
- typedef Result future_result_type; //!< Indicates the future's result type.
-
-
-public:
-
- future()
- : m_impl(new detail::future_impl<future_result_type>()) // TODO remove this
- {
- }
-
- // only for internal usage
- future(shared_ptr<detail::future_impl<Result> > const & impl)
- : m_impl(impl)
- {
- }
-
- bool ready() const
- {
- return m_impl->ready();
- }
-
- void wait() const
- {
- m_impl->wait();
- }
-
- bool timed_wait(boost::xtime const & timestamp) const
- {
- return m_impl->timed_wait(timestamp);
- }
-
- result_type operator()() // throw( thread::cancelation_exception, ... )
- {
- return (*m_impl)();
- }
-
- result_type get() // throw( thread::cancelation_exception, ... )
- {
- return (*m_impl)();
- }
-
- bool cancel()
- {
- return m_impl->cancel();
- }
-
- bool is_cancelled() const
- {
- return m_impl->is_cancelled();
- }
-};
-
-
-
-
-
-template<class Pool, class Function>
-typename disable_if <
- is_void< typename result_of< Function() >::type >,
- future< typename result_of< Function() >::type >
->::type
-schedule(Pool& pool, const Function& task)
-{
- typedef typename result_of< Function() >::type future_result_type;
-
- // create future impl and future
- shared_ptr<detail::future_impl<future_result_type> > impl(new detail::future_impl<future_result_type>);
- future <future_result_type> res(impl);
-
- // schedule future impl
- pool.schedule(detail::future_impl_task_func<detail::future_impl, Function>(task, impl));
-
- // return future
- return res;
-
-/*
- TODO
- if(pool->schedule(bind(&Future::run, future)))
- {
- return future;
- }
- else
- {
- // construct empty future
- return error_future;
- }
- */
-}
-
-
-
-} } // namespace boost::threadpool
-
-#endif // THREADPOOL_FUTURE_HPP_INCLUDED
-
diff --git a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/pool.hpp b/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/pool.hpp
deleted file mode 100644
index a4b6676ea9..0000000000
--- a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/pool.hpp
+++ /dev/null
@@ -1,232 +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_HPP_INCLUDED
-#define THREADPOOL_POOL_HPP_INCLUDED
-
-#include <boost/ref.hpp>
-
-#include "./detail/pool_core.hpp"
-
-#include "task_adaptors.hpp"
-
-#include "./detail/locking_ptr.hpp"
-
-#include "scheduling_policies.hpp"
-#include "size_policies.hpp"
-#include "shutdown_policies.hpp"
-
-
-
-/// The namespace threadpool contains a thread pool and related utility classes.
-namespace boost { namespace threadpool
-{
-
-
-
- /*! \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 is DefaultConstructible, CopyConstructible and Assignable.
- * It has reference semantics; all copies of the same pool are equivalent and interchangeable.
- * All operations on a pool except assignment are strongly thread safe or sequentially consistent;
- * that is, the behavior of concurrent calls is as if the calls have been issued sequentially in an unspecified order.
- *
- * \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 SchedulingPolicy 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 = task_func,
- template <typename> class SchedulingPolicy = fifo_scheduler,
- template <typename> class SizePolicy = static_size,
- template <typename> class SizePolicyController = resize_controller,
- template <typename> class ShutdownPolicy = wait_for_all_tasks
- >
- class thread_pool
- {
- typedef detail::pool_core<Task,
- SchedulingPolicy,
- SizePolicy,
- SizePolicyController,
- ShutdownPolicy> pool_core_type;
- shared_ptr<pool_core_type> m_core; // pimpl idiom
- shared_ptr<void> m_shutdown_controller; // If the last pool holding a pointer to the core is deleted the controller shuts the pool down.
-
- public: // Type definitions
- typedef Task task_type; //!< Indicates the task's type.
- typedef SchedulingPolicy<task_type> scheduler_type; //!< Indicates the scheduler's type.
- /* typedef thread_pool<Task,
- SchedulingPolicy,
- SizePolicy,
- ShutdownPolicy > pool_type; //!< Indicates the thread pool's type.
- */
- typedef SizePolicy<pool_core_type> size_policy_type;
- typedef SizePolicyController<pool_core_type> size_controller_type;
-
-
- public:
- /*! Constructor.
- * \param initial_threads The pool is immediately resized to set the specified number of threads. The pool's actual number threads depends on the SizePolicy.
- */
- thread_pool(size_t initial_threads = 0)
- : m_core(new pool_core_type)
- , m_shutdown_controller(static_cast<void*>(0), bind(&pool_core_type::shutdown, m_core))
- {
- size_policy_type::init(*m_core, initial_threads);
- }
-
-
- /*! 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 m_core->size_controller();
- }
-
-
- /*! Gets the number of threads in the pool.
- * \return The number of threads.
- */
- size_t size() const
- {
- return m_core->size();
- }
-
-
- /*! 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)
- {
- return m_core->schedule(task);
- }
-
-
- /*! Returns the number of tasks which are currently executed.
- * \return The number of active tasks.
- */
- size_t active() const
- {
- return m_core->active();
- }
-
-
- /*! Returns the number of tasks which are ready for execution.
- * \return The number of pending tasks.
- */
- size_t pending() const
- {
- return m_core->pending();
- }
-
-
- /*! Removes all pending tasks from the pool's scheduler.
- */
- void clear()
- {
- m_core->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
- {
- return m_core->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 task_threshold = 0) const
- {
- m_core->wait(task_threshold);
- }
-
-
- /*! 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 task_threshold = 0) const
- {
- return m_core->wait(timestamp, task_threshold);
- }
- };
-
-
-
- /*! \brief Fifo pool.
- *
- * The pool's tasks are fifo scheduled task_func functors.
- *
- */
- typedef thread_pool<task_func, fifo_scheduler, static_size, resize_controller, wait_for_all_tasks> fifo_pool;
-
-
- /*! \brief Lifo pool.
- *
- * The pool's tasks are lifo scheduled task_func functors.
- *
- */
- typedef thread_pool<task_func, lifo_scheduler, static_size, resize_controller, wait_for_all_tasks> lifo_pool;
-
-
- /*! \brief Pool for prioritized task.
- *
- * The pool's tasks are prioritized prio_task_func functors.
- *
- */
- typedef thread_pool<prio_task_func, prio_scheduler, static_size, resize_controller, wait_for_all_tasks> prio_pool;
-
-
- /*! \brief A standard pool.
- *
- * The pool's tasks are fifo scheduled task_func functors.
- *
- */
- typedef fifo_pool pool;
-
-
-
-} } // namespace boost::threadpool
-
-#endif // THREADPOOL_POOL_HPP_INCLUDED
diff --git a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/pool_adaptors.hpp b/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/pool_adaptors.hpp
deleted file mode 100644
index 6cde152d2a..0000000000
--- a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/pool_adaptors.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-/*! \file
-* \brief Pool adaptors.
-*
-* This file contains an easy-to-use adaptor similar to a smart
-* pointer for the pool class.
-*
-* 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_ADAPTORS_HPP_INCLUDED
-#define THREADPOOL_POOL_ADAPTORS_HPP_INCLUDED
-
-#include <boost/smart_ptr.hpp>
-
-
-namespace boost { namespace threadpool
-{
-
-
-// TODO convenience scheduling function
- /*! Schedules a Runnable for asynchronous execution. A Runnable is an arbitrary class with a run()
- * member function. This a convenience shorthand for pool->schedule(bind(&Runnable::run, task_object)).
- * \param
- * \param obj The Runnable object. The member function run() will be exectued and should not throw execeptions.
- * \return true, if the task could be scheduled and false otherwise.
- */
- template<typename Pool, typename Runnable>
- bool schedule(Pool& pool, shared_ptr<Runnable> const & obj)
- {
- return pool->schedule(bind(&Runnable::run, obj));
- }
-
- /*! Schedules a task for asynchronous execution. The task will be executed once only.
- * \param task The task function object.
- */
- template<typename Pool>
- typename enable_if <
- is_void< typename result_of< typename Pool::task_type() >::type >,
- bool
- >::type
- schedule(Pool& pool, typename Pool::task_type const & task)
- {
- return pool.schedule(task);
- }
-
-
- template<typename Pool>
- typename enable_if <
- is_void< typename result_of< typename Pool::task_type() >::type >,
- bool
- >::type
- schedule(shared_ptr<Pool> const pool, typename Pool::task_type const & task)
- {
- return pool->schedule(task);
- }
-
-
-} } // namespace boost::threadpool
-
-#endif // THREADPOOL_POOL_ADAPTORS_HPP_INCLUDED
-
-
diff --git a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/scheduling_policies.hpp b/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/scheduling_policies.hpp
deleted file mode 100644
index 2d6c7c1bae..0000000000
--- a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/scheduling_policies.hpp
+++ /dev/null
@@ -1,262 +0,0 @@
-/*! \file
-* \brief Task scheduling policies.
-*
-* This file contains some fundamental scheduling policies for the pool class.
-* A scheduling policy is realized by a task container which controls the access to
-* the tasks. Fundamentally the container determines the order the tasks are processed
-* by the thread pool.
-* The task containers need not to be thread-safe because they are used by the pool
-* in thread-safe way.
-*
-* 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_SCHEDULING_POLICIES_HPP_INCLUDED
-#define THREADPOOL_SCHEDULING_POLICIES_HPP_INCLUDED
-
-
-#include <queue>
-#include <deque>
-
-#include "task_adaptors.hpp"
-
-namespace boost { namespace threadpool
-{
-
- /*! \brief SchedulingPolicy which implements FIFO ordering.
- *
- * This container implements a FIFO scheduling policy.
- * The first task to be added to the scheduler will be the first to be removed.
- * The processing proceeds sequentially in the same order.
- * FIFO stands for "first in, first out".
- *
- * \param Task A function object which implements the operator()(void).
- *
- */
- template <typename Task = task_func>
- class fifo_scheduler
- {
- public:
- typedef Task task_type; //!< Indicates the scheduler's task type.
-
- protected:
- std::deque<task_type> m_container; //!< Internal task container.
-
-
- public:
- /*! Adds a new task to the scheduler.
- * \param task The task object.
- * \return true, if the task could be scheduled and false otherwise.
- */
- bool push(task_type const & task)
- {
- m_container.push_back(task);
- return true;
- }
-
- /*! Removes the task which should be executed next.
- */
- void pop()
- {
- m_container.pop_front();
- }
-
- /*! Gets the task which should be executed next.
- * \return The task object to be executed.
- */
- task_type const & top() const
- {
- return m_container.front();
- }
-
- /*! Gets the current number of tasks in the scheduler.
- * \return The number of tasks.
- * \remarks Prefer empty() to size() == 0 to check if the scheduler is empty.
- */
- size_t size() const
- {
- return m_container.size();
- }
-
- /*! Checks if the scheduler is empty.
- * \return true if the scheduler contains no tasks, false otherwise.
- * \remarks Is more efficient than size() == 0.
- */
- bool empty() const
- {
- return m_container.empty();
- }
-
- /*! Removes all tasks from the scheduler.
- */
- void clear()
- {
- m_container.clear();
- }
- };
-
-
-
- /*! \brief SchedulingPolicy which implements LIFO ordering.
- *
- * This container implements a LIFO scheduling policy.
- * The last task to be added to the scheduler will be the first to be removed.
- * LIFO stands for "last in, first out".
- *
- * \param Task A function object which implements the operator()(void).
- *
- */
- template <typename Task = task_func>
- class lifo_scheduler
- {
- public:
- typedef Task task_type; //!< Indicates the scheduler's task type.
-
- protected:
- std::deque<task_type> m_container; //!< Internal task container.
-
- public:
- /*! Adds a new task to the scheduler.
- * \param task The task object.
- * \return true, if the task could be scheduled and false otherwise.
- */
- bool push(task_type const & task)
- {
- m_container.push_front(task);
- return true;
- }
-
- /*! Removes the task which should be executed next.
- */
- void pop()
- {
- m_container.pop_front();
- }
-
- /*! Gets the task which should be executed next.
- * \return The task object to be executed.
- */
- task_type const & top() const
- {
- return m_container.front();
- }
-
- /*! Gets the current number of tasks in the scheduler.
- * \return The number of tasks.
- * \remarks Prefer empty() to size() == 0 to check if the scheduler is empty.
- */
- size_t size() const
- {
- return m_container.size();
- }
-
- /*! Checks if the scheduler is empty.
- * \return true if the scheduler contains no tasks, false otherwise.
- * \remarks Is more efficient than size() == 0.
- */
- bool empty() const
- {
- return m_container.empty();
- }
-
- /*! Removes all tasks from the scheduler.
- */
- void clear()
- {
- m_container.clear();
- }
-
- };
-
-
-
- /*! \brief SchedulingPolicy which implements prioritized ordering.
- *
- * This container implements a scheduling policy based on task priorities.
- * The task with highest priority will be the first to be removed.
- * It must be possible to compare two tasks using operator<.
- *
- * \param Task A function object which implements the operator() and operator<. operator< must be a partial ordering.
- *
- * \see prio_thread_func
- *
- */
- template <typename Task = prio_task_func>
- class prio_scheduler
- {
- public:
- typedef Task task_type; //!< Indicates the scheduler's task type.
-
- protected:
- std::priority_queue<task_type> m_container; //!< Internal task container.
-
-
- public:
- /*! Adds a new task to the scheduler.
- * \param task The task object.
- * \return true, if the task could be scheduled and false otherwise.
- */
- bool push(task_type const & task)
- {
- m_container.push(task);
- return true;
- }
-
- /*! Removes the task which should be executed next.
- */
- void pop()
- {
- m_container.pop();
- }
-
- /*! Gets the task which should be executed next.
- * \return The task object to be executed.
- */
- task_type const & top() const
- {
- return m_container.top();
- }
-
- /*! Gets the current number of tasks in the scheduler.
- * \return The number of tasks.
- * \remarks Prefer empty() to size() == 0 to check if the scheduler is empty.
- */
- size_t size() const
- {
- return m_container.size();
- }
-
- /*! Checks if the scheduler is empty.
- * \return true if the scheduler contains no tasks, false otherwise.
- * \remarks Is more efficient than size() == 0.
- */
- bool empty() const
- {
- return m_container.empty();
- }
-
- /*! Removes all tasks from the scheduler.
- */
- void clear()
- {
- while(!m_container.empty())
- {
- m_container.pop();
- }
- }
- };
-
-
-} } // namespace boost::threadpool
-
-
-#endif // THREADPOOL_SCHEDULING_POLICIES_HPP_INCLUDED
-
diff --git a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/shutdown_policies.hpp b/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/shutdown_policies.hpp
deleted file mode 100644
index 047a6eb516..0000000000
--- a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/shutdown_policies.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/*! \file
-* \brief Shutdown policies.
-*
-* This file contains shutdown policies for thread_pool.
-* A shutdown policy controls the pool's behavior from the time
-* when the pool is not referenced any longer.
-*
-* 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_SHUTDOWN_POLICIES_HPP_INCLUDED
-#define THREADPOOL_SHUTDOWN_POLICIES_HPP_INCLUDED
-
-
-
-/// The namespace threadpool contains a thread pool and related utility classes.
-namespace boost { namespace threadpool
-{
-
-
-/*! \brief ShutdownPolicy which waits for the completion of all tasks
- * and the worker termination afterwards.
- *
- * \param Pool The pool's core type.
- */
- template<typename Pool>
- class wait_for_all_tasks
- {
- public:
- static void shutdown(Pool& pool)
- {
- pool.wait();
- pool.terminate_all_workers(true);
- }
- };
-
-
- /*! \brief ShutdownPolicy which waits for the completion of all active tasks
- * and the worker termination afterwards.
- *
- * \param Pool The pool's core type.
- */
- template<typename Pool>
- class wait_for_active_tasks
- {
- public:
- static void shutdown(Pool& pool)
- {
- pool.clear();
- pool.wait();
- pool.terminate_all_workers(true);
- }
- };
-
-
- /*! \brief ShutdownPolicy which does not wait for any tasks or worker termination.
- *
- * This policy does not wait for any tasks. Nevertheless all active tasks will be processed completely.
- *
- * \param Pool The pool's core type.
- */
- template<typename Pool>
- class immediately
- {
- public:
- static void shutdown(Pool& pool)
- {
- pool.clear();
- pool.terminate_all_workers(false);
- }
- };
-
-} } // namespace boost::threadpool
-
-#endif // THREADPOOL_SHUTDOWN_POLICIES_HPP_INCLUDED
diff --git a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/size_policies.hpp b/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/size_policies.hpp
deleted file mode 100644
index e3c08038db..0000000000
--- a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/size_policies.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-/*! \file
-* \brief Size policies.
-*
-* This file contains size policies for thread_pool. A size
-* policy controls the number of worker threads in the pool.
-*
-* 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_SIZE_POLICIES_HPP_INCLUDED
-#define THREADPOOL_SIZE_POLICIES_HPP_INCLUDED
-
-
-
-/// The namespace threadpool contains a thread pool and related utility classes.
-namespace boost { namespace threadpool
-{
-
- /*! \brief SizePolicyController which provides no functionality.
- *
- * \param Pool The pool's core type.
- */
- template<typename Pool>
- struct empty_controller
- {
- empty_controller(typename Pool::size_policy_type&, shared_ptr<Pool>) {}
- };
-
-
- /*! \brief SizePolicyController which allows resizing.
- *
- * \param Pool The pool's core type.
- */
- template< typename Pool >
- class resize_controller
- {
- typedef typename Pool::size_policy_type size_policy_type;
- reference_wrapper<size_policy_type> m_policy;
- shared_ptr<Pool> m_pool; //!< to make sure that the pool is alive (the policy pointer is valid) as long as the controller exists
-
- public:
- resize_controller(size_policy_type& policy, shared_ptr<Pool> pool)
- : m_policy(policy)
- , m_pool(pool)
- {
- }
-
- bool resize(size_t worker_count)
- {
- return m_policy.get().resize(worker_count);
- }
- };
-
-
- /*! \brief SizePolicy which preserves the thread count.
- *
- * \param Pool The pool's core type.
- */
- template<typename Pool>
- class static_size
- {
- reference_wrapper<Pool volatile> m_pool;
-
- public:
- static void init(Pool& pool, size_t const worker_count)
- {
- pool.resize(worker_count);
- }
-
- static_size(Pool volatile & pool)
- : m_pool(pool)
- {}
-
- bool resize(size_t const worker_count)
- {
- return m_pool.get().resize(worker_count);
- }
-
- void worker_died_unexpectedly(size_t const new_worker_count)
- {
- m_pool.get().resize(new_worker_count + 1);
- }
-
- // TODO this functions are not called yet
- void task_scheduled() {}
- void task_finished() {}
- };
-
-} } // namespace boost::threadpool
-
-#endif // THREADPOOL_SIZE_POLICIES_HPP_INCLUDED
diff --git a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/task_adaptors.hpp b/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/task_adaptors.hpp
deleted file mode 100644
index 6b874e3358..0000000000
--- a/graphics/asymptote/LspCpp/third_party/threadpool/boost/threadpool/task_adaptors.hpp
+++ /dev/null
@@ -1,168 +0,0 @@
-/*! \file
-* \brief Task adaptors.
-*
-* This file contains adaptors for task function objects.
-*
-* 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_TASK_ADAPTERS_HPP_INCLUDED
-#define THREADPOOL_TASK_ADAPTERS_HPP_INCLUDED
-
-
-#include <boost/smart_ptr.hpp>
-#include <boost/function.hpp>
-#include <boost/thread.hpp>
-
-
-namespace boost { namespace threadpool
-{
-
- /*! \brief Standard task function object.
- *
- * This function object wraps a nullary function which returns void.
- * The wrapped function is invoked by calling the operator ().
- *
- * \see boost function library
- *
- */
- typedef function0<void> task_func;
-
-
-
-
- /*! \brief Prioritized task function object.
- *
- * This function object wraps a task_func object and binds a priority to it.
- * prio_task_funcs can be compared using the operator < which realises a partial ordering.
- * The wrapped task function is invoked by calling the operator ().
- *
- * \see prio_scheduler
- *
- */
- class prio_task_func
- {
- private:
- unsigned int m_priority; //!< The priority of the task's function.
- task_func m_function; //!< The task's function.
-
- public:
- typedef void result_type; //!< Indicates the functor's result type.
-
- public:
- /*! Constructor.
- * \param priority The priority of the task.
- * \param function The task's function object.
- */
- prio_task_func(unsigned int const priority, task_func const & function)
- : m_priority(priority)
- , m_function(function)
- {
- }
-
- /*! Executes the task function.
- */
- void operator() (void) const
- {
- if(m_function)
- {
- m_function();
- }
- }
-
- /*! Comparison operator which realises a partial ordering based on priorities.
- * \param rhs The object to compare with.
- * \return true if the priority of *this is less than right hand side's priority, false otherwise.
- */
- bool operator< (const prio_task_func& rhs) const
- {
- return m_priority < rhs.m_priority;
- }
-
- }; // prio_task_func
-
-
-
-
-
-
-
-
- /*! \brief Looped task function object.
- *
- * This function object wraps a boolean thread function object.
- * The wrapped task function is invoked by calling the operator () and it is executed in regular
- * time intervals until false is returned. The interval length may be zero.
- * Please note that a pool's thread is engaged as long as the task is looped.
- *
- */
- class looped_task_func
- {
- private:
- function0<bool> m_function; //!< The task's function.
- unsigned int m_break_s; //!< Duration of breaks in seconds.
- unsigned int m_break_ns; //!< Duration of breaks in nano seconds.
-
- public:
- typedef void result_type; //!< Indicates the functor's result type.
-
- public:
- /*! Constructor.
- * \param function The task's function object which is looped until false is returned.
- * \param interval The minimum break time in milli seconds before the first execution of the task function and between the following ones.
- */
- looped_task_func(function0<bool> const & function, unsigned int const interval = 0)
- : m_function(function)
- {
- m_break_s = interval / 1000;
- m_break_ns = (interval - m_break_s * 1000) * 1000 * 1000;
- }
-
- /*! Executes the task function.
- */
- void operator() (void) const
- {
- if(m_function)
- {
- if(m_break_s > 0 || m_break_ns > 0)
- { // Sleep some time before first execution
- xtime xt;
- xtime_get(&xt, TIME_UTC);
- xt.nsec += m_break_ns;
- xt.sec += m_break_s;
- thread::sleep(xt);
- }
-
- while(m_function())
- {
- if(m_break_s > 0 || m_break_ns > 0)
- {
- xtime xt;
- xtime_get(&xt, TIME_UTC);
- xt.nsec += m_break_ns;
- xt.sec += m_break_s;
- thread::sleep(xt);
- }
- else
- {
- thread::yield(); // Be fair to other threads
- }
- }
- }
- }
-
- }; // looped_task_func
-
-
-} } // namespace boost::threadpool
-
-#endif // THREADPOOL_TASK_ADAPTERS_HPP_INCLUDED
-