diff options
Diffstat (limited to 'ml/dlib/dlib/threads/thread_pool_extension_abstract.h')
| -rw-r--r-- | ml/dlib/dlib/threads/thread_pool_extension_abstract.h | 842 |
1 files changed, 0 insertions, 842 deletions
diff --git a/ml/dlib/dlib/threads/thread_pool_extension_abstract.h b/ml/dlib/dlib/threads/thread_pool_extension_abstract.h deleted file mode 100644 index ba54a7546..000000000 --- a/ml/dlib/dlib/threads/thread_pool_extension_abstract.h +++ /dev/null @@ -1,842 +0,0 @@ -// Copyright (C) 2008 Davis E. King (davis@dlib.net) -// License: Boost Software License See LICENSE.txt for the full license. -#undef DLIB_THREAD_POOl_ABSTRACT_Hh_ -#ifdef DLIB_THREAD_POOl_ABSTRACT_Hh_ - -#include "threads_kernel_abstract.h" -#include "../uintn.h" - -namespace dlib -{ - -// ---------------------------------------------------------------------------------------- - - template < - typename T - > - class future - { - /*! - INITIAL VALUE - - is_ready() == true - - WHAT THIS OBJECT REPRESENTS - This object represents a container that allows you to safely pass objects - into the tasks performed by the thread_pool object defined below. An - example will make it clear: - - // Suppose you have a global function defined as follows - void add (int a, int b, int& result) { result = a + b; } - - // Also suppose you have a thread_pool named tp defined somewhere. - // Then you could do the following. - future<int> a, b, result; - a = 3; - b = 4; - // this function call causes another thread to execute a call to the add() function - // and passes in the int objects contained in a, b, and result - tp.add_task(add,a,b,result); - // This line will wait for the task in the thread pool to finish and then print the - // value in the result integer. So it will print a 7. - cout << result << endl; - !*/ - - public: - future ( - ); - /*! - ensures - - The object of type T contained in this future has - an initial value for its type. - - #is_ready() == true - !*/ - - future ( - const T& item - ); - /*! - ensures - - #get() == item - - #is_ready() == true - !*/ - - future ( - const future& item - ); - /*! - ensures - - if (item.is_ready() == false) then - - the call to this function blocks until the thread processing the task related - to the item future has finished. - - #is_ready() == true - - #item.is_ready() == true - - #get() == item.get() - !*/ - - ~future ( - ); - /*! - ensures - - if (is_ready() == false) then - - the call to this function blocks until the thread processing the task related - to this future has finished. - !*/ - - bool is_ready ( - ) const; - /*! - ensures - - if (the value of this future may not yet be ready to be accessed because it - is in use by a task in a thread_pool) then - - returns false - - else - - returns true - !*/ - - future& operator=( - const T& item - ); - /*! - ensures - - if (is_ready() == false) then - - the call to this function blocks until the thread processing the task related - to this future has finished. - - #is_ready() == true - - #get() == item - - returns *this - !*/ - - future& operator=( - const future& item - ); - /*! - ensures - - if (is_ready() == false || item.is_ready() == false) then - - the call to this function blocks until the threads processing the tasks related - to this future and the item future have finished. - - #is_ready() == true - - #item.is_ready() == true - - #get() == item.get() - - returns *this - !*/ - - operator T& ( - ); - /*! - ensures - - if (is_ready() == false) then - - the call to this function blocks until the thread processing the task related - to this future has finished. - - #is_ready() == true - - returns get() - !*/ - - operator const T& ( - ) const; - /*! - ensures - - if (is_ready() == false) then - - the call to this function blocks until the thread processing the task related - to this future has finished. - - #is_ready() == true - - returns get() - !*/ - - T& get ( - ); - /*! - ensures - - if (is_ready() == false) then - - the call to this function blocks until the thread processing the task related - to this future has finished. - - #is_ready() == true - - returns a non-const reference to the object of type T contained inside this future - !*/ - - const T& get ( - ) const; - /*! - ensures - - if (is_ready() == false) then - - the call to this function blocks until the thread processing the task related - to this future has finished. - - #is_ready() == true - - returns a const reference to the object of type T contained inside this future - !*/ - - }; - -// ---------------------------------------------------------------------------------------- - - template <typename T> - inline void swap ( - future<T>& a, - future<T>& b - ) { std::swap(a.get(), b.get()); } - /*! - provides a global swap function - !*/ - -// ---------------------------------------------------------------------------------------- - - -// The future object comes with overloads for all the usual comparison operators. - - template <typename T> bool operator== (const future<T>& a, const future<T>& b) { return a.get() == b.get(); } - template <typename T> bool operator!= (const future<T>& a, const future<T>& b) { return a.get() != b.get(); } - template <typename T> bool operator<= (const future<T>& a, const future<T>& b) { return a.get() <= b.get(); } - template <typename T> bool operator>= (const future<T>& a, const future<T>& b) { return a.get() >= b.get(); } - template <typename T> bool operator< (const future<T>& a, const future<T>& b) { return a.get() < b.get(); } - template <typename T> bool operator> (const future<T>& a, const future<T>& b) { return a.get() > b.get(); } - - template <typename T> bool operator== (const future<T>& a, const T& b) { return a.get() == b; } - template <typename T> bool operator== (const T& a, const future<T>& b) { return a == b.get(); } - template <typename T> bool operator!= (const future<T>& a, const T& b) { return a.get() != b; } - template <typename T> bool operator!= (const T& a, const future<T>& b) { return a != b.get(); } - template <typename T> bool operator<= (const future<T>& a, const T& b) { return a.get() <= b; } - template <typename T> bool operator<= (const T& a, const future<T>& b) { return a <= b.get(); } - template <typename T> bool operator>= (const future<T>& a, const T& b) { return a.get() >= b; } - template <typename T> bool operator>= (const T& a, const future<T>& b) { return a >= b.get(); } - template <typename T> bool operator< (const future<T>& a, const T& b) { return a.get() < b; } - template <typename T> bool operator< (const T& a, const future<T>& b) { return a < b.get(); } - template <typename T> bool operator> (const future<T>& a, const T& b) { return a.get() > b; } - template <typename T> bool operator> (const T& a, const future<T>& b) { return a > b.get(); } - -// ---------------------------------------------------------------------------------------- - - class thread_pool - { - /*! - WHAT THIS OBJECT REPRESENTS - This object represents a fixed size group of threads which you can - submit tasks to and then wait for those tasks to be completed. - - Note that setting the number of threads to 0 is a valid way to - use this object. It causes it to not contain any threads - at all. When tasks are submitted to the object in this mode - the tasks are processed within the calling thread. So in this - mode any thread that calls add_task() is considered to be - a thread_pool thread capable of executing tasks. - - This object is also implemented such that no memory allocations occur - after the thread_pool has been constructed so long as the user doesn't - call any of the add_task_by_value() routines. The future object also - doesn't perform any memory allocations or contain any system resources - such as mutex objects. - - EXCEPTIONS - Note that if an exception is thrown inside a task thread and is not caught - then the exception will be trapped inside the thread pool and rethrown at a - later time when someone calls one of the add task or wait member functions - of the thread pool. This allows exceptions to propagate out of task threads - and into the calling code where they can be handled. - !*/ - - public: - explicit thread_pool ( - unsigned long num_threads - ); - /*! - ensures - - #num_threads_in_pool() == num_threads - throws - - std::bad_alloc - - dlib::thread_error - the constructor may throw this exception if there is a problem - gathering resources to create threading objects. - !*/ - - ~thread_pool( - ); - /*! - ensures - - blocks until all tasks in the pool have finished. - - If one of the threads has generated an exception but it hasn't yet been - rethrown to the caller (e.g. by calling wait_for_all_tasks()) then the - program will be terminated. So make sure you handle all the possible - exceptions from your tasks. - !*/ - - bool is_task_thread ( - ) const; - /*! - ensures - - if (the thread calling this function is one of the threads in this - thread pool or num_threads_in_pool() == 0) then - - returns true - - else - - returns false - !*/ - - unsigned long num_threads_in_pool ( - ) const; - /*! - ensures - - returns the number of threads contained in this thread pool. That is, returns - the maximum number of tasks that this object will process concurrently. - !*/ - - template <typename F> - uint64 add_task_by_value ( - const F& function_object - ); - /*! - requires - - function_object() is a valid expression - ensures - - makes a copy of function_object, call it FCOPY. - - if (is_task_thread() == true and there aren't any free threads available) then - - calls FCOPY() within the calling thread and returns when it finishes - - else - - the call to this function blocks until there is a free thread in the pool - to process this new task. Once a free thread is available the task - is handed off to that thread which then calls FCOPY(). - - returns a task id that can be used by this->wait_for_task() to wait - for the submitted task to finish. - !*/ - - template <typename T> - uint64 add_task ( - T& obj, - void (T::*funct)() - ); - /*! - requires - - funct == a valid member function pointer for class T - - obj will not go out of scope until after the task has completed (i.e. - this function passes obj to the task by reference. If you want to avoid - this restriction then use add_task_by_value()) - ensures - - if (is_task_thread() == true and there aren't any free threads available) then - - calls (obj.*funct)() within the calling thread and returns - when it finishes. - - else - - the call to this function blocks until there is a free thread in the pool - to process this new task. Once a free thread is available the task - is handed off to that thread which then calls (obj.*funct)() - - returns a task id that can be used by this->wait_for_task() to wait - for the submitted task to finish. - !*/ - - template <typename T> - uint64 add_task_by_value ( - const T& obj, - void (T::*funct)() - ); - /*! - requires - - funct == a valid member function pointer for class T - ensures - - makes a copy of obj, call it OBJ_COPY. - - if (is_task_thread() == true and there aren't any free threads available) then - - calls (OBJ_COPY.*funct)() within the calling thread and returns - when it finishes. - - else - - the call to this function blocks until there is a free thread in the pool - to process this new task. Once a free thread is available the task - is handed off to that thread which then calls (OBJ_COPY.*funct)(). - - returns a task id that can be used by this->wait_for_task() to wait - for the submitted task to finish. - !*/ - - template <typename T> - uint64 add_task ( - T& obj, - void (T::*funct)(long), - long arg1 - ); - /*! - requires - - funct == a valid member function pointer for class T - - obj will not go out of scope until after the task has completed (i.e. - this function passes obj to the task by reference. If you want to avoid - this restriction then use add_task_by_value()) - ensures - - if (is_task_thread() == true and there aren't any free threads available) then - - calls (obj.*funct)(arg1) within the calling thread and returns - when it finishes - - else - - the call to this function blocks until there is a free thread in the pool - to process this new task. Once a free thread is available the task - is handed off to that thread which then calls (obj.*funct)(arg1) - - returns a task id that can be used by this->wait_for_task() to wait - for the submitted task to finish. - !*/ - - template <typename T> - uint64 add_task ( - T& obj, - void (T::*funct)(long,long), - long arg1, - long arg2 - ); - /*! - requires - - funct == a valid member function pointer for class T - - obj will not go out of scope until after the task has completed (i.e. - this function passes obj to the task by reference. If you want to avoid - this restriction then use add_task_by_value()) - ensures - - if (is_task_thread() == true and there aren't any free threads available) then - - calls (obj.*funct)(arg1,arg2) within the calling thread and returns - when it finishes - - else - - the call to this function blocks until there is a free thread in the pool - to process this new task. Once a free thread is available the task - is handed off to that thread which then calls (obj.*funct)(arg1,arg2) - - returns a task id that can be used by this->wait_for_task() to wait - for the submitted task to finish. - !*/ - - void wait_for_task ( - uint64 task_id - ) const; - /*! - ensures - - if (there is currently a task with the given id being executed in the thread pool) then - - the call to this function blocks until the task with the given id is complete - - else - - the call to this function returns immediately - !*/ - - void wait_for_all_tasks ( - ) const; - /*! - ensures - - the call to this function blocks until all tasks which were submitted - to the thread pool by the thread that is calling this function have - finished. - !*/ - - // -------------------- - - template <typename F, typename A1> - uint64 add_task ( - F& function_object, - future<A1>& arg1 - ); - /*! - requires - - function_object(arg1.get()) is a valid expression - (i.e. The A1 type stored in the future must be a type that can be passed into the given function object) - - function_object will not go out of scope until after the task has completed (i.e. - this function passes function_object to the task by reference. If you want to avoid - this restriction then use add_task_by_value()) - ensures - - if (is_task_thread() == true and there aren't any free threads available) then - - calls function_object(arg1.get()) within the calling thread and returns - when it finishes - - else - - the call to this function blocks until there is a free thread in the pool - to process this new task. Once a free thread is available the task - is handed off to that thread which then calls function_object(arg1.get()). - - #arg1.is_ready() == false - - returns a task id that can be used by this->wait_for_task() to wait - for the submitted task to finish. - !*/ - - template <typename F, typename A1> - uint64 add_task_by_value ( - const F& function_object, - future<A1>& arg1 - ); - /*! - requires - - function_object(arg1.get()) is a valid expression - (i.e. The A1 type stored in the future must be a type that can be passed into the given function object) - ensures - - makes a copy of function_object, call it FCOPY. - - if (is_task_thread() == true and there aren't any free threads available) then - - calls FCOPY(arg1.get()) within the calling thread and returns when it finishes - - else - - the call to this function blocks until there is a free thread in the pool - to process this new task. Once a free thread is available the task - is handed off to that thread which then calls FCOPY(arg1.get()). - - #arg1.is_ready() == false - - returns a task id that can be used by this->wait_for_task() to wait - for the submitted task to finish. - !*/ - - template <typename T, typename T1, typename A1> - uint64 add_task ( - T& obj, - void (T::*funct)(T1), - future<A1>& arg1 - ); - /*! - requires - - funct == a valid member function pointer for class T - - (obj.*funct)(arg1.get()) must be a valid expression. - (i.e. The A1 type stored in the future must be a type that can be passed into the given function) - - obj will not go out of scope until after the task has completed (i.e. - this function passes obj to the task by reference. If you want to avoid - this restriction then use add_task_by_value()) - ensures - - if (is_task_thread() == true and there aren't any free threads available) then - - calls (obj.*funct)(arg1.get()) within the calling thread and returns - when it finishes - - else - - the call to this function blocks until there is a free thread in the pool - to process this new task. Once a free thread is available the task - is handed off to that thread which then calls (obj.*funct)(arg1.get()). - - #arg1.is_ready() == false - - returns a task id that can be used by this->wait_for_task() to wait - for the submitted task to finish. - !*/ - - template <typename T, typename T1, typename A1> - uint64 add_task_by_value ( - const T& obj, - void (T::*funct)(T1), - future<A1>& arg1 - ); - /*! - requires - - funct == a valid member function pointer for class T - - (obj.*funct)(arg1.get()) must be a valid expression. - (i.e. The A1 type stored in the future must be a type that can be passed into the given function) - ensures - - makes a copy of obj, call it OBJ_COPY. - - if (is_task_thread() == true and there aren't any free threads available) then - - calls (OBJ_COPY.*funct)(arg1.get()) within the calling thread and returns - when it finishes. - - else - - the call to this function blocks until there is a free thread in the pool - to process this new task. Once a free thread is available the task - is handed off to that thread which then calls (OBJ_COPY.*funct)(arg1.get()). - - returns a task id that can be used by this->wait_for_task() to wait - for the submitted task to finish. - !*/ - - template <typename T, typename T1, typename A1> - uint64 add_task ( - const T& obj, - void (T::*funct)(T1) const, - future<A1>& arg1 - ); - /*! - requires - - funct == a valid member function pointer for class T - - (obj.*funct)(arg1.get()) must be a valid expression. - (i.e. The A1 type stored in the future must be a type that can be passed into the given function) - - obj will not go out of scope until after the task has completed (i.e. - this function passes obj to the task by reference. If you want to avoid - this restriction then use add_task_by_value()) - ensures - - if (is_task_thread() == true and there aren't any free threads available) then - - calls (obj.*funct)(arg1.get()) within the calling thread and returns - when it finishes - - else - - the call to this function blocks until there is a free thread in the pool - to process this new task. Once a free thread is available the task - is handed off to that thread which then calls (obj.*funct)(arg1.get()). - - #arg1.is_ready() == false - - returns a task id that can be used by this->wait_for_task() to wait - for the submitted task to finish. - !*/ - - template <typename T, typename T1, typename A1> - uint64 add_task_by_value ( - const T& obj, - void (T::*funct)(T1) const, - future<A1>& arg1 - ); - /*! - requires - - funct == a valid member function pointer for class T - - (obj.*funct)(arg1.get()) must be a valid expression. - (i.e. The A1 type stored in the future must be a type that can be passed into the given function) - ensures - - makes a copy of obj, call it OBJ_COPY. - - if (is_task_thread() == true and there aren't any free threads available) then - - calls (OBJ_COPY.*funct)(arg1.get()) within the calling thread and returns - when it finishes. - - else - - the call to this function blocks until there is a free thread in the pool - to process this new task. Once a free thread is available the task - is handed off to that thread which then calls (OBJ_COPY.*funct)(arg1.get()). - - returns a task id that can be used by this->wait_for_task() to wait - for the submitted task to finish. - !*/ - - template <typename T1, typename A1> - uint64 add_task ( - void (*funct)(T1), - future<A1>& arg1 - ); - /*! - requires - - funct == a valid function pointer - - (funct)(arg1.get()) must be a valid expression. - (i.e. The A1 type stored in the future must be a type that can be passed into the given function) - ensures - - if (is_task_thread() == true and there aren't any free threads available) then - - calls funct(arg1.get()) within the calling thread and returns - when it finishes - - else - - the call to this function blocks until there is a free thread in the pool - to process this new task. Once a free thread is available the task - is handed off to that thread which then calls funct(arg1.get()). - - #arg1.is_ready() == false - - returns a task id that can be used by this->wait_for_task() to wait - for the submitted task to finish. - !*/ - - // -------------------------------------------------------------------------------- - // The remainder of this class just contains overloads for add_task() and add_task_by_value() - // that take up to 4 futures (as well as 0 futures). Their behavior is identical to the above - // add_task() and add_task_by_value() functions. - // -------------------------------------------------------------------------------- - - template <typename F, typename A1, typename A2> - uint64 add_task ( - F& function_object, - future<A1>& arg1, - future<A2>& arg2 - ); - - template <typename F, typename A1, typename A2> - uint64 add_task_by_value ( - const F& function_object, - future<A1>& arg1, - future<A2>& arg2 - ); - - template <typename T, typename T1, typename A1, - typename T2, typename A2> - uint64 add_task ( - T& obj, - void (T::*funct)(T1,T2), - future<A1>& arg1, - future<A2>& arg2 - ); - - uint64 add_task_by_value ( - const T& obj, - void (T::*funct)(T1,T2), - future<A1>& arg1, - future<A2>& arg2 - ); - - template <typename T, typename T1, typename A1, - typename T2, typename A2> - uint64 add_task ( - const T& obj, - void (T::*funct)(T1,T2) const, - future<A1>& arg1, - future<A2>& arg2 - ); - - template <typename T, typename T1, typename A1, - typename T2, typename A2> - uint64 add_task_by_value ( - const T& obj, - void (T::*funct)(T1,T2) const, - future<A1>& arg1, - future<A2>& arg2 - ); - - template <typename T1, typename A1, - typename T2, typename A2> - uint64 add_task ( - void (*funct)(T1,T2), - future<A1>& arg1, - future<A2>& arg2 - ); - - // -------------------- - - template <typename F, typename A1, typename A2, typename A3> - uint64 add_task ( - F& function_object, - future<A1>& arg1, - future<A2>& arg2, - future<A3>& arg3 - ); - - template <typename F, typename A1, typename A2, typename A3> - uint64 add_task_by_value ( - const F& function_object, - future<A1>& arg1, - future<A2>& arg2, - future<A3>& arg3 - ); - - template <typename T, typename T1, typename A1, - typename T2, typename A2, - typename T3, typename A3> - uint64 add_task ( - T& obj, - void (T::*funct)(T1,T2,T3), - future<A1>& arg1, - future<A2>& arg2, - future<A3>& arg3 - ); - - template <typename T, typename T1, typename A1, - typename T2, typename A2, - typename T3, typename A3> - uint64 add_task_by_value ( - const T& obj, - void (T::*funct)(T1,T2,T3), - future<A1>& arg1, - future<A2>& arg2, - future<A3>& arg3 - ); - - template <typename T, typename T1, typename A1, - typename T2, typename A2, - typename T3, typename A3> - uint64 add_task ( - const T& obj, - void (T::*funct)(T1,T2,T3) const, - future<A1>& arg1, - future<A2>& arg2, - future<A3>& arg3 - ); - - template <typename T, typename T1, typename A1, - typename T2, typename A2, - typename T3, typename A3> - uint64 add_task_by_value ( - const T& obj, - void (T::*funct)(T1,T2,T3) const, - future<A1>& arg1, - future<A2>& arg2, - future<A3>& arg3 - ); - - template <typename T1, typename A1, - typename T2, typename A2, - typename T3, typename A3> - uint64 add_task ( - void (*funct)(T1,T2,T3), - future<A1>& arg1, - future<A2>& arg2, - future<A3>& arg3 - ); - - // -------------------- - - template <typename F, typename A1, typename A2, typename A3, typename A4> - uint64 add_task ( - F& function_object, - future<A1>& arg1, - future<A2>& arg2, - future<A3>& arg3, - future<A4>& arg4 - ); - - template <typename F, typename A1, typename A2, typename A3, typename A4> - uint64 add_task_by_value ( - const F& function_object, - future<A1>& arg1, - future<A2>& arg2, - future<A3>& arg3, - future<A4>& arg4 - ); - - template <typename T, typename T1, typename A1, - typename T2, typename A2, - typename T3, typename A3, - typename T4, typename A4> - uint64 add_task ( - T& obj, - void (T::*funct)(T1,T2,T3,T4), - future<A1>& arg1, - future<A2>& arg2, - future<A3>& arg3, - future<A4>& arg4 - ); - - template <typename T, typename T1, typename A1, - typename T2, typename A2, - typename T3, typename A3, - typename T4, typename A4> - uint64 add_task_by_value ( - const T& obj, - void (T::*funct)(T1,T2,T3,T4), - future<A1>& arg1, - future<A2>& arg2, - future<A3>& arg3, - future<A4>& arg4 - ); - - template <typename T, typename T1, typename A1, - typename T2, typename A2, - typename T3, typename A3, - typename T4, typename A4> - uint64 add_task ( - const T& obj, - void (T::*funct)(T1,T2,T3,T4) const, - future<A1>& arg1, - future<A2>& arg2, - future<A3>& arg3, - future<A4>& arg4 - ); - - template <typename T, typename T1, typename A1, - typename T2, typename A2, - typename T3, typename A3, - typename T4, typename A4> - uint64 add_task_by_value ( - const T& obj, - void (T::*funct)(T1,T2,T3,T4) const, - future<A1>& arg1, - future<A2>& arg2, - future<A3>& arg3, - future<A4>& arg4 - ); - - template <typename T1, typename A1, - typename T2, typename A2, - typename T3, typename A3, - typename T4, typename A4> - uint64 add_task ( - void (*funct)(T1,T2,T3,T4), - future<A1>& arg1, - future<A2>& arg2, - future<A3>& arg3, - future<A4>& arg4 - ); - - // -------------------- - - template <typename F> - uint64 add_task ( - F& function_object - ); - - template <typename T> - uint64 add_task ( - const T& obj, - void (T::*funct)() const, - ); - - template <typename T> - uint64 add_task_by_value ( - const T& obj, - void (T::*funct)() const - ); - - uint64 add_task ( - void (*funct)() - ); - - // -------------------- - - private: - - // restricted functions - thread_pool(thread_pool&); // copy constructor - thread_pool& operator=(thread_pool&); // assignment operator - }; - -} - -// ---------------------------------------------------------------------------------------- - -#endif // DLIB_THREAD_POOl_ABSTRACT_Hh_ - - - |