diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/inspircd.h | 7 | ||||
| -rw-r--r-- | include/threadengine.h | 96 | ||||
| -rw-r--r-- | include/threadengines/threadengine_pthread.h | 91 | ||||
| -rw-r--r-- | include/threadengines/threadengine_win32.h | 76 |
4 files changed, 113 insertions, 157 deletions
diff --git a/include/inspircd.h b/include/inspircd.h index 469d3a3b6..f32a67644 100644 --- a/include/inspircd.h +++ b/include/inspircd.h @@ -95,6 +95,7 @@ typedef std::multimap< std::string, KeyValList > ConfigDataHash; #include "configreader.h" #include "inspstring.h" #include "protocol.h" +#include "threadengine.h" #ifndef PATH_MAX #warning Potentially broken system, PATH_MAX undefined @@ -396,7 +397,7 @@ class CoreExport InspIRCd : public classbase */ std::map<BufferedSocket*,BufferedSocket*> SocketCull; - Mutex* RehashFinishMutex; + Mutex RehashFinishMutex; /** Globally accessible fake user record. This is used to force mode changes etc across s2s, etc.. bit ugly, but.. better than how this was done in 1.1 * Reason for it: @@ -456,10 +457,6 @@ class CoreExport InspIRCd : public classbase */ ThreadEngine* Threads; - /** Mutex engine, handles mutexes for threading where required - */ - MutexFactory* Mutexes; - /** The thread/class used to read config files in REHASH and on startup */ ConfigReaderThread* ConfigThread; diff --git a/include/threadengine.h b/include/threadengine.h index 228f817ca..27060ebe9 100644 --- a/include/threadengine.h +++ b/include/threadengine.h @@ -20,100 +20,6 @@ #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 "<pure-virtual>"; - } -}; - -/** 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() { } -}; - -class CoreExport ThreadData -{ - public: - virtual void FreeThread(Thread* thread) { } -}; - /** 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! @@ -168,7 +74,5 @@ class CoreExport Thread : public Extensible } }; - - #endif diff --git a/include/threadengines/threadengine_pthread.h b/include/threadengines/threadengine_pthread.h index 72fa1d219..2aba4cb15 100644 --- a/include/threadengines/threadengine_pthread.h +++ b/include/threadengines/threadengine_pthread.h @@ -17,61 +17,94 @@ #include <pthread.h> #include "inspircd_config.h" #include "base.h" -#include "threadengine.h" class InspIRCd; +class Thread; -class CoreExport PThreadEngine : public ThreadEngine +/** 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 { public: - PThreadEngine(InspIRCd* Instance); + /** Constructor. + * @param Instance Creator object + */ + ThreadEngine(InspIRCd* Instance); - virtual ~PThreadEngine(); + /** 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. + */ void Start(Thread* thread_to_init); - void FreeThread(Thread* thread); - + /** Returns the thread engine's name for display purposes + * @return The thread engine name + */ const std::string GetName() { return "posix-thread"; } }; -class CoreExport ThreadEngineFactory : public classbase -{ - public: - ThreadEngine* Create(InspIRCd* ServerInstance) - { - return new PThreadEngine(ServerInstance); - } -}; - -class CoreExport PThreadData : public ThreadData +class CoreExport ThreadData { public: pthread_t pthread_id; void FreeThread(Thread* toFree); }; -class CoreExport PosixMutex : public Mutex +/** 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 { private: pthread_mutex_t putex; public: - PosixMutex(); - virtual void Enable(bool enable); - ~PosixMutex(); -}; - -class CoreExport MutexFactory : public Extensible -{ - protected: - InspIRCd* ServerInstance; - public: - MutexFactory(InspIRCd* Instance); - Mutex* CreateMutex(); + /** Constructor. + */ + Mutex() + { + pthread_mutex_init(&putex, NULL); + } + /** Enter/enable the mutex lock. + */ + void Lock() + { + pthread_mutex_lock(&putex); + } + /** Leave/disable the mutex lock. + */ + void Unlock() + { + pthread_mutex_unlock(&putex); + } + /** Destructor + */ + ~Mutex() + { + pthread_mutex_destroy(&putex); + } }; #endif diff --git a/include/threadengines/threadengine_win32.h b/include/threadengines/threadengine_win32.h index 3388cead0..c1f9f2cce 100644 --- a/include/threadengines/threadengine_win32.h +++ b/include/threadengines/threadengine_win32.h @@ -16,61 +16,83 @@ #include "inspircd_config.h" #include "base.h" -#include "threadengine.h" class InspIRCd; +class Thread; -class CoreExport Win32ThreadEngine : public ThreadEngine +/** 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 { public: - Win32ThreadEngine(InspIRCd* Instance); + ThreadEngine(InspIRCd* Instance); - virtual ~Win32ThreadEngine(); + virtual ~ThreadEngine(); static DWORD WINAPI Entry(void* parameter); + /** 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. + */ void Start(Thread* thread_to_init); + /** Returns the thread engine's name for display purposes + * @return The thread engine name + */ const std::string GetName() { return "windows-thread"; } }; -class CoreExport ThreadEngineFactory : public classbase -{ - public: - ThreadEngine* Create(InspIRCd* ServerInstance) - { - return new Win32ThreadEngine(ServerInstance); - } -}; - -class CoreExport Win32ThreadData : public ThreadData +class CoreExport ThreadData { public: HANDLE handle; void FreeThread(Thread* toFree); }; -class CoreExport Win32Mutex : public Mutex +/** 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 { private: CRITICAL_SECTION wutex; public: - Win32Mutex(); - virtual void Enable(bool enable); - ~Win32Mutex(); -}; - -class CoreExport MutexFactory : public Extensible -{ - protected: - InspIRCd* ServerInstance; - public: - MutexFactory(InspIRCd* Instance); - virtual Mutex* CreateMutex(); + Win32Mutex() + { + InitializeCriticalSection(&wutex); + } + void Lock() + { + EnterCriticalSection(&wutex); + } + void Unlock() + { + LeaveCriticalSection(&wutex); + } + ~Win32Mutex() + { + DeleteCriticalSection(&wutex); + } }; #endif |