Replace std::deque with std::vector in spanningtree and related modules

[user/henk/code/inspircd.git] / include / threadengine.h

diff --git a/include/threadengine.h b/include/threadengine.h
index 27060ebe9e5a4d0b18977a85ed21738c8ea43cbc..10f3fed13b5fa6684397f105deace4386244e65e 100644 (file)
--- a/include/threadengine.h
+++ b/include/threadengine.h
@@ -20,16 +20,30 @@
 #include "inspircd_config.h"
 #include "base.h"
 
+#ifdef WINDOWS
+#include "threadengines/threadengine_win32.h"
+#endif
+
+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
         */
@@ -41,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.
@@ -60,18 +65,109 @@ 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()
+       {
+               queue.Wait();
+       }
+ public:
+       /** Lock queue.
+        */
+       void LockQueue()
+       {
+               queue.Lock();
+       }
+       /** Unlock queue.
+        */
+       void UnlockQueue()
        {
-               ExitFlag = value;
+               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();
+       }
+};
 
-       /** Get thread's current exit status.
-        * (are we being asked to exit?)
+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
         */
-       bool GetExitFlag()
+       void WaitForQueue()
        {
-               return ExitFlag;
+               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