X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fthreadengine.h;h=10f3fed13b5fa6684397f105deace4386244e65e;hb=219993bc9018d9f0d9568330d7a972b68b785d27;hp=228f817cadd89f07ace5508e9920302a7e13fbd5;hpb=7b6eae36661bc798f69b22393b85a4f06d533cf6;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/threadengine.h b/include/threadengine.h index 228f817ca..10f3fed13 100644 --- a/include/threadengine.h +++ b/include/threadengine.h @@ -20,110 +20,30 @@ #include "inspircd_config.h" #include "base.h" -class InspIRCd; -class Thread; - -/** The ThreadEngine class has the responsibility of initialising - * Thread derived classes. It does this by creating operating system - * level threads which are then associated with the class transparently. - * This allows Thread classes to be derived without needing to know how - * the OS implements threads. You should ensure that any sections of code - * that use threads are threadsafe and do not interact with any other - * parts of the code which are NOT known threadsafe! If you really MUST - * access non-threadsafe code from a Thread, use the Mutex class to wrap - * access to the code carefully. - */ -class CoreExport ThreadEngine : public Extensible -{ - protected: - - /** Creator instance - */ - InspIRCd* ServerInstance; - - public: - - /** Constructor. - * @param Instance Creator object - */ - ThreadEngine(InspIRCd* Instance); - - /** Destructor - */ - virtual ~ThreadEngine(); - - /** Create a new thread. This takes an already allocated - * Thread* pointer and initializes it to use this threading - * engine. On failure, this function may throw a CoreException. - * @param thread_to_init Pointer to a newly allocated Thread - * derived object. - */ - virtual void Start(Thread* thread_to_init) = 0; - - /** Returns the thread engine's name for display purposes - * @return The thread engine name - */ - virtual const std::string GetName() - { - return ""; - } -}; - -/** The Mutex class represents a mutex, which can be used to keep threads - * properly synchronised. Use mutexes sparingly, as they are a good source - * of thread deadlocks etc, and should be avoided except where absolutely - * neccessary. Note that the internal behaviour of the mutex varies from OS - * to OS depending on the thread engine, for example in windows a Mutex - * in InspIRCd uses critical sections, as they are faster and simpler to - * manage. - */ -class CoreExport Mutex -{ - protected: - /** Enable or disable the Mutex. This method has somewhat confusing - * wording (e.g. the function name and parameters) so it is protected - * in preference of the Lock() and Unlock() methods which are user- - * accessible. - * - * @param enable True to enable the mutex (enter it) and false to - * disable the mutex (leave it). - */ - virtual void Enable(bool enable) = 0; - public: - - /** Constructor. - */ - Mutex(); - - /** Enter/enable the mutex lock. - */ - void Lock() { Enable(true); } - - /** Leave/disable the mutex lock. - */ - void Unlock() { Enable(false); } - - /** Destructor - */ - ~Mutex() { } -}; +#ifdef WINDOWS +#include "threadengines/threadengine_win32.h" +#endif -class CoreExport ThreadData -{ - public: - virtual void FreeThread(Thread* thread) { } -}; +class ThreadData; /** Derive from this class to implement your own threaded sections of * code. Be sure to keep your code thread-safe and not prone to deadlocks * and race conditions if you MUST use threading! */ -class CoreExport Thread : public Extensible +class CoreExport Thread { private: /** Set to true when the thread is to exit */ bool ExitFlag; + protected: + /** Get thread's current exit status. + * (are we being asked to exit?) + */ + bool GetExitFlag() + { + return ExitFlag; + } public: /** Opaque thread state managed by threading engine */ @@ -135,17 +55,8 @@ class CoreExport Thread : public Extensible { } - /** If this thread has a Creator set, call it to - * free the thread - */ - virtual ~Thread() - { - if (state) - { - state->FreeThread(this); - delete state; - } - } + /* If the thread is running, you MUST join BEFORE deletion */ + virtual ~Thread(); /** Override this method to put your actual * threaded code here. @@ -154,21 +65,110 @@ class CoreExport Thread : public Extensible /** Signal the thread to exit gracefully. */ - void SetExitFlag(bool value) + virtual void SetExitFlag(); + + /** Join the thread (calls SetExitFlag and waits for exit) + */ + void join(); +}; + + +class CoreExport QueuedThread : public Thread +{ + ThreadQueueData queue; + protected: + /** Waits for an enqueue operation to complete + * You MUST hold the queue lock when you call this. + * It will be unlocked while you wait, and will be relocked + * before the function returns + */ + void WaitForQueue() { - ExitFlag = value; + queue.Wait(); } - - /** Get thread's current exit status. - * (are we being asked to exit?) + public: + /** Lock queue. */ - bool GetExitFlag() + void LockQueue() { - return ExitFlag; + queue.Lock(); + } + /** Unlock queue. + */ + void UnlockQueue() + { + queue.Unlock(); + } + /** Unlock queue and wake up worker + */ + void UnlockQueueWakeup() + { + queue.Wakeup(); + queue.Unlock(); + } + virtual void SetExitFlag() + { + queue.Lock(); + Thread::SetExitFlag(); + queue.Wakeup(); + queue.Unlock(); } }; +class CoreExport SocketThread : public Thread +{ + ThreadQueueData queue; + ThreadSignalData signal; + protected: + /** Waits for an enqueue operation to complete + * You MUST hold the queue lock when you call this. + * It will be unlocked while you wait, and will be relocked + * before the function returns + */ + void WaitForQueue() + { + queue.Wait(); + } + /** Notifies parent by making the SignalFD ready to read + * No requirements on locking + */ + void NotifyParent(); + public: + SocketThread(InspIRCd* SI); + virtual ~SocketThread(); + /** Lock queue. + */ + void LockQueue() + { + queue.Lock(); + } + /** Unlock queue. + */ + void UnlockQueue() + { + queue.Unlock(); + } + /** Unlock queue and send wakeup to worker + */ + void UnlockQueueWakeup() + { + queue.Wakeup(); + queue.Unlock(); + } + virtual void SetExitFlag() + { + queue.Lock(); + Thread::SetExitFlag(); + queue.Wakeup(); + queue.Unlock(); + } + /** + * Called in the context of the parent thread after a notification + * has passed through the socket + */ + virtual void OnNotify() = 0; +}; #endif