diff options
Diffstat (limited to 'fastos/src/vespa/fastos/thread.h')
-rw-r--r-- | fastos/src/vespa/fastos/thread.h | 467 |
1 files changed, 0 insertions, 467 deletions
diff --git a/fastos/src/vespa/fastos/thread.h b/fastos/src/vespa/fastos/thread.h deleted file mode 100644 index 2fb717403f2..00000000000 --- a/fastos/src/vespa/fastos/thread.h +++ /dev/null @@ -1,467 +0,0 @@ -// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -//************************************************************************ -/** - * @file - * Class definitions for FastOS_ThreadPool, FastOS_ThreadInterface and - * FastOS_Runnable. - * - * @author Oivind H. Danielsen - */ - -#pragma once - - -#include "types.h" -#include <atomic> -#include <mutex> -#include <condition_variable> - -typedef pthread_t FastOS_ThreadId; - -class FastOS_Runnable; -class FastOS_ThreadInterface; - - -/** - * This class implements an initially empty pool of threads. - * - * As threads are allocated with @ref NewThread() the number of - * threads in the pool increases. A maximum number of threads - * contained in the pool can be set using the constructor - * FastOS_ThreadPool(int maxThreads). - * - * Threads are automatically returned to the pool when they - * terminate. - */ -class FastOS_ThreadPool -{ - friend class FastOS_ThreadInterface; - -private: - int _startedThreadsCount; - std::mutex _closeFlagMutex; - bool _closeCalledFlag; - - // Always lock in this order - mutable std::mutex _freeMutex; - std::mutex _liveMutex; - std::condition_variable _liveCond; - /** - * List of free (available) threads. - */ - FastOS_ThreadInterface *_freeThreads; - - /** - * List of active (allocated) threads. - */ - FastOS_ThreadInterface *_activeThreads; - - /** - * Number of available threads in the threadpool. - * Total number of threads = free + active - */ - int _numFree; - - /** - * Number of active threads in the threadpool. - * Total number of threads = free + active - */ - int _numActive; - - /** - * Number of threads that have terminated - */ - int _numTerminated; - - /** - * Number of threads that have not been terminated - */ - int _numLive; - - /** - * Maximum number of threads in the threadpool. A value of - * zero means that there is no limit. - */ - int _maxThreads; - - /** - * Put this thread on the @ref _activeThreads list. - */ - void ActivateThread (FastOS_ThreadInterface *thread); - - /** - * Return previously active thread to the list of free thread. - */ - void FreeThread (FastOS_ThreadInterface *thread); - - /** - * A thread is informing the thread pool that it is about to - * terminate. - */ - void ThreadIsAboutToTerminate(FastOS_ThreadInterface *thread); - - /** - * Set the break flag on all threads. - */ - void BreakThreads (); - - /** - * Wait for all threads to finish. - */ - void JoinThreads (); - - /** - * Delete all threads in threadpool. - */ - void DeleteThreads (); - - /** - * Remove a thread from a list. - */ - void LinkOutThread (FastOS_ThreadInterface *thread, - FastOS_ThreadInterface **listHead); - - /** - * Add a thread to a list. Notice that a thread can be on only one - * list at a time. - */ - void LinkInThread (FastOS_ThreadInterface *thread, - FastOS_ThreadInterface **listHead); - -public: - FastOS_ThreadPool(const FastOS_ThreadPool&) = delete; - FastOS_ThreadPool& operator=(const FastOS_ThreadPool&) = delete; - FastOS_ThreadPool(int maxThreads); - /// Unlimited threads - FastOS_ThreadPool(); - - /** - * Destructor. Closes pool if necessary. - */ - virtual ~FastOS_ThreadPool(); - - - /** - * Allocate a new thread, and make this thread invoke the Run() method - * of the @ref FastOS_Runnable object [owner] with parameters [arg]. - * The thread is automatically freed (returned to the treadpool) - * when Run() returns. - * - * @param owner Instance to be invoked by new thread. - * @param arg Arguments to be passed to new thread. - * - * @return Pointer to newly created thread or nullptr on failure. - */ - FastOS_ThreadInterface *NewThread (FastOS_Runnable *owner, void *arg=nullptr); - - /** - * Close the threadpool. This involves setting the break flag on - * all active threads, and waiting for them to finish. Once Close - * is called, no more threads can be allocated from the thread - * pool. There exists no way to reopen a closed threadpool. - */ - void Close (); - - /** - * This will tell if the pool has been closed. - */ - bool isClosed(); - - /** - * Get the number of currently active threads. - * The total number of actual allocated threads is the sum of - * @ref GetNumActiveThreads() and @ref GetNumInactiveThreads(). - * @return Number of currently active threads - */ - int GetNumActiveThreads () const { - std::lock_guard<std::mutex> guard(_freeMutex); - return _numActive; - } - - /** - * Get the number of currently inactive threads. - * The total number of actual allocated threads is the sum of - * @ref GetNumActiveThreads() and @ref GetNumInactiveThreads(). - * @return Number of currently inactive threads - */ - int GetNumInactiveThreads () const { - std::lock_guard<std::mutex> guard(_freeMutex); - return _numFree; - } - - /** - * Get the number of started threads since instantiation of the thread pool. - * @return Number of threads started - */ - int GetNumStartedThreads () const { return _startedThreadsCount; } -}; - - -// Operating system thread entry point -extern "C" { - void *FastOS_ThreadHook (void *arg); -} - -/** - * This class controls each operating system thread. - * - * In most cases you would not want to create objects of this class - * directly. Use @ref FastOS_ThreadPool::NewThread() instead. - */ -class FastOS_ThreadInterface -{ - friend class FastOS_ThreadPool; - friend void *FastOS_ThreadHook (void *arg); - -private: - FastOS_ThreadInterface(const FastOS_ThreadInterface&); - FastOS_ThreadInterface& operator=(const FastOS_ThreadInterface&); - -protected: - /** - * The thread does not start (call @ref FastOS_Runnable::Run()) - * until this event has been triggered. - */ - std::mutex _dispatchedMutex; - std::condition_variable _dispatchedCond; - - FastOS_ThreadInterface *_next; - FastOS_ThreadInterface *_prev; - - /** - * A pointer to the instance which implements the interface - * @ref FastOS_Runnable. - */ - FastOS_Runnable *_owner; - - /** - * A pointer to the originating @ref FastOS_ThreadPool - */ - FastOS_ThreadPool *_pool; - - /** - * Entry point for the OS thread. The thread will sleep here - * until dispatched. - */ - void Hook (); - - /** - * Signals that thread should be dispatched. - * @param owner Instance of @ref FastOS_Runnable. - * @param arg Thread invocation arguments. - */ - void Dispatch (FastOS_Runnable *owner, void *arg); - - /** - * Initializes a thread. This includes creating the operating system - * thread handle and setting it up and making it ready to be dispatched. - * @return Boolean success/failure - */ - virtual bool Initialize ()=0; - - /** - * Used to store thread invocation arguments. These are passed along - * to @ref FastOS_Runnable::Run() when the thread is dispatched. - */ - void *_startArg; - - /** - * Create an operating system thread. In most cases you would want - * to create threads using @ref FastOS_ThreadPool::NewThread() instead. - * @param pool The threadpool which is about to contain the new thread. - * @return A new @ref FastOS_Thread or nullptr on failure. - */ - static FastOS_ThreadInterface *CreateThread(FastOS_ThreadPool *pool); - - /** - * Break flag. If true, the thread should exit. - */ - std::atomic<bool> _breakFlag; - - /** - * Is this thread active or free in the threadpool? - */ - bool _active; - - /** - * Is the thread running? This is used by @ref Join(), to wait for threads - * to finish. - */ - std::mutex _runningMutex; - std::condition_variable _runningCond; - bool _runningFlag; - -public: - /** - * Constructor. Resets internal attributes. - */ - FastOS_ThreadInterface (FastOS_ThreadPool *pool) - : _dispatchedMutex(), - _dispatchedCond(), - _next(nullptr), - _prev(nullptr), - _owner(nullptr), - _pool(pool), - _startArg(nullptr), - _breakFlag(false), - _active(false), - _runningMutex(), - _runningCond(), - _runningFlag(false) - { - } - - /** - * Destructor. - */ - virtual ~FastOS_ThreadInterface () {} - - /** - * Instruct a thread to exit. This could be used in conjunction with - * @ref GetBreakFlag() in a worker thread, to have cooperative thread - * termination. When a threadpool closes, all threads in the pool will - * have their break flag set. - */ - void SetBreakFlag (); - - /** - * Return the status of this thread's break flag. If the break flag - * is set, someone wants the thread to terminate. It is up to the - * implementor of the thread to decide whether the break flag - * should be used. - * - * In scenarios where a worker thread loops "forever" waiting for - * new jobs, the break flag should be polled in order to eventually - * exit from the loop and terminate the thread. - * - * In scenarios where a worker thread performs a task which - * always should run to completion, the break flag could be ignored - * as the thread sooner or later will terminate. - * - * When a threadpool is closed, the break flag is set on all - * threads in the pool. If a thread loops forever and chooses to - * ignore the break flag, a @ref FastOS_ThreadPool::Close() will - * never finish. (see @ref SetBreakFlag) - */ - bool GetBreakFlag () const - { - return _breakFlag.load(std::memory_order_relaxed); - } - - /** - * Wait for a thread to finish. - */ - void Join (); - - /** - * Returns the id of this thread. - */ - virtual FastOS_ThreadId GetThreadId () const noexcept = 0; -}; - - -/** - * This class gives a generic interface for invoking new threads with an object. - * - * The thread object should inherit this interface (class), and implement - * the @ref Run() method. When @ref FastOS_ThreadPool::NewThread() is - * called, the @ref Run() method of the passed instance will be invoked. - * - * Arguments could be supplied via @ref FastOS_ThreadPool::NewThread(), but - * it is also possible to supply arguments to the new thread through the - * worker thread object constructor or some other attribute-setting method - * prior to creating the thread. Choose whichever method works best for you. - * - * Example: - * @code - * // Arguments passed to the new thread. - * struct MyThreadArgs - * { - * int _something; - * char _tenChars[10]; - * }; - * - * class MyWorkerThread : public FastOS_Runnable - * { - * public: - * - * // Delete this instance upon completion - * virtual bool DeleteOnCompletion() const { return true; } - * - * virtual void Run (FastOS_ThreadInterface *thread, void *arguments) - * { - * MyThreadArgs *args = static_cast<MyThreadArgs *>(arguments); - * - * // Do some computation... - * Foo(args->_something); - * - * for(int i=0; i<30000; i++) - * { - * ... - * ... - * - * if(thread->GetBreakFlag()) - * break; - * ... - * ... - * - * } - * - * // Thread terminates... - * } - * }; - * - * - * // Example on how to create a thread using the above classes. - * void SomeClass::SomeMethod (FastOS_ThreadPool *pool) - * { - * MyWorkerThread *workerThread = new MyWorkerThread(); - * static MyThreadArgs arguments; - * - * arguments._something = 123456; - * - * // the workerThread instance will be deleted when Run completes - * // see the DeleteOnCompletion doc - * pool->NewThread(workerThread, &arguments); - * } - * @endcode - */ -class FastOS_Runnable -{ -private: - friend class FastOS_ThreadInterface; - std::atomic<FastOS_ThreadInterface*> _thread; - -public: - FastOS_Runnable(const FastOS_Runnable&) = delete; - FastOS_Runnable& operator=(const FastOS_Runnable&) = delete; - FastOS_Runnable(); - virtual ~FastOS_Runnable(); - - /** - * The DeleteOnCompletion method should be overridden to return true - * if the runnable instance should be deleted when run completes - * - * @author Nils Sandoy - * @return true iff this runnable instance should be deleted on completion - */ - virtual bool DeleteOnCompletion() const { return false; } - - /** - * When an object implementing interface @ref FastOS_Runnable is used to - * create a thread, starting the thread causes the object's @ref Run() - * method to be called in that separately executing thread. The thread - * terminates when @ref Run() returns. - * @param thisThread A thread object. - * @param arguments Supplied to @ref FastOS_ThreadPool::NewThread - */ - virtual void Run(FastOS_ThreadInterface *thisThread, void *arguments)=0; - - FastOS_ThreadInterface *GetThread() noexcept { return _thread.load(std::memory_order_acquire); } - const FastOS_ThreadInterface *GetThread() const noexcept { return _thread.load(std::memory_order_acquire); } - bool HasThread() const noexcept { return GetThread() != nullptr; } -}; - -#include <vespa/fastos/unix_thread.h> -typedef FastOS_UNIX_Thread FASTOS_PREFIX(Thread); - |