X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fthreadengine.h;h=0c2d26ce6e14f4546cb8b5a952c3ac40372838b4;hb=635cb9d65f6d7f6758ae8ed874da00c8d94b6e39;hp=eb831ea46c40b256afea7b18189b62812b56d81d;hpb=b6dbd6caab62bc2c0d11ce5a45d511611eb9c2ef;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/threadengine.h b/include/threadengine.h index eb831ea46..0c2d26ce6 100644 --- a/include/threadengine.h +++ b/include/threadengine.h @@ -1,214 +1,172 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd: (C) 2002-2009 InspIRCd Development Team - * See: http://wiki.inspircd.org/Credits + * Copyright (C) 2014 Attila Molnar + * Copyright (C) 2013, 2017 Sadie Powell + * Copyright (C) 2012 Robby + * Copyright (C) 2009-2010 Daniel De Graaf + * Copyright (C) 2008 Craig Edwards * - * This program is free but copyrighted software; see - * the file COPYING for details. + * This file is part of InspIRCd. InspIRCd is free software: you can + * redistribute it and/or modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation, version 2. * - * --------------------------------------------------- + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . */ -#ifndef __THREADENGINE__ -#define __THREADENGINE__ -#include -#include -#include -#include "inspircd_config.h" -#include "base.h" +#pragma once -class InspIRCd; -class Thread; +#include "base.h" -/** 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. +/** 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 ThreadEngine : public Extensible +class CoreExport Thread { - protected: - - /** Creator instance - */ - InspIRCd* ServerInstance; - - /** New Thread being created. - */ - Thread* NewThread; - - /** Enable or disable system-wide mutex for threading. - * Remember that if you toggle the mutex you MUST UNSET - * IT LATER otherwise the program will DEADLOCK! - * It is recommended that you AVOID USE OF THIS METHOD - * and use your own Mutex class, this function is mainly - * reserved for use by the core and by the Thread engine - * itself. - * @param enable True to lock the mutex. - */ - virtual bool Mutex(bool enable) = 0; - public: - - /** Constructor. - * @param Instance Creator object + private: + /** Set to true when the thread is to exit */ - ThreadEngine(InspIRCd* Instance); + bool ExitFlag; - /** Destructor + /** Opaque thread state managed by the ThreadEngine */ - virtual ~ThreadEngine(); + ThreadEngine::ThreadState state; - /** Lock the system wide mutex. See the documentation for - * ThreadEngine::Mutex(). + /** ThreadEngine manages Thread::state */ - void Lock() { this->Mutex(true); } + friend class ThreadEngine; - /** Unlock the system wide mutex. See the documentation for - * ThreadEngine::Mutex() + protected: + /** Get thread's current exit status. + * (are we being asked to exit?) */ - void Unlock() { this->Mutex(false); } - - /** Run the newly created thread. + bool GetExitFlag() + { + return ExitFlag; + } + public: + /** Set Creator to NULL at this point */ - virtual void Run() = 0; + Thread() : ExitFlag(false) + { + } - /** 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. + /** Override this method to put your actual + * threaded code here. */ - virtual void Create(Thread* thread_to_init) = 0; + virtual void Run() = 0; - /** This is called by the default destructor of the Thread - * class to ensure that the thread engine which created the thread - * is responsible for destroying it. - * @param thread Existing and active thread to delete. + /** Signal the thread to exit gracefully. */ - virtual void FreeThread(Thread* thread) = 0; + virtual void SetExitFlag(); - /** Returns the thread engine's name for display purposes - * @return The thread engine name + /** Join the thread (calls SetExitFlag and waits for exit) */ - virtual const std::string GetName() - { - return ""; - } + void join(); }; -/** 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 : public Extensible + +class CoreExport QueuedThread : public Thread { + ThreadQueueData queue; protected: - - /** Creator object + /** 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 */ - InspIRCd* ServerInstance; - - /** 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; + void WaitForQueue() + { + queue.Wait(); + } public: - - /** Constructor. - * @param Instance Creator object - */ - Mutex(InspIRCd* Instance); - - /** Enter/enable the mutex lock. + /** Lock queue. */ - void Lock() { Enable(true); } - - /** Leave/disable the mutex lock. + void LockQueue() + { + queue.Lock(); + } + /** Unlock queue. */ - void Unlock() { Enable(false); } - - /** Destructor + void UnlockQueue() + { + queue.Unlock(); + } + /** Unlock queue and wake up worker */ - ~Mutex() { } + void UnlockQueueWakeup() + { + queue.Wakeup(); + queue.Unlock(); + } + void SetExitFlag() CXX11_OVERRIDE + { + queue.Lock(); + Thread::SetExitFlag(); + queue.Wakeup(); + queue.Unlock(); + } }; -/** 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 SocketThread : public Thread { - private: - /** Set to true when the thread is to exit + 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 ExitFlag; + void WaitForQueue() + { + queue.Wait(); + } public: - - /** Creator thread engine + /** Notifies parent by making the SignalFD ready to read + * No requirements on locking */ - ThreadEngine* Creator; - - /** Set Creator to NULL at this point + void NotifyParent(); + SocketThread(); + virtual ~SocketThread(); + /** Lock queue. */ - Thread() : ExitFlag(false), Creator(NULL) + void LockQueue() { + queue.Lock(); } - - /** If this thread has a Creator set, call it to - * free the thread + /** Unlock queue. */ - virtual ~Thread() + void UnlockQueue() { - if (Creator) - Creator->FreeThread(this); + queue.Unlock(); } - - /** Override this method to put your actual - * threaded code here. + /** Unlock queue and send wakeup to worker */ - virtual void Run() = 0; - - /** Signal the thread to exit gracefully. - */ - void SetExitFlag() + void UnlockQueueWakeup() { - ExitFlag = true; + queue.Wakeup(); + queue.Unlock(); } - - /** Cancel an exit state. - */ - void ClearExitFlag() + void SetExitFlag() CXX11_OVERRIDE { - ExitFlag = false; + queue.Lock(); + Thread::SetExitFlag(); + queue.Wakeup(); + queue.Unlock(); } - /** Get thread's current exit status. - * (are we being asked to exit?) + /** + * Called in the context of the parent thread after a notification + * has passed through the socket */ - bool GetExitFlag() - { - return ExitFlag; - } + virtual void OnNotify() = 0; }; - - - -#endif -