X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fthreadengines%2Fthreadengine_win32.h;h=1b88179b60b29bf060c2d3210af5ccbe7833b39a;hb=b4a174ee9c32d62ea6bf010e837e8c5b1c3d36a3;hp=3388cead08fb3bc8f8741dccd8b340fadb7a1a5e;hpb=7b6eae36661bc798f69b22393b85a4f06d533cf6;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/threadengines/threadengine_win32.h b/include/threadengines/threadengine_win32.h index 3388cead0..1b88179b6 100644 --- a/include/threadengines/threadengine_win32.h +++ b/include/threadengines/threadengine_win32.h @@ -1,77 +1,142 @@ -/* +------------------------------------+ - * | 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 Sadie Powell + * Copyright (C) 2012 Robby + * Copyright (C) 2012 ChrisTX + * Copyright (C) 2009 Daniel De Graaf + * Copyright (C) 2008-2010 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_WIN32THREAD__ -#define __THREADENGINE_WIN32THREAD__ -#include "inspircd_config.h" +#pragma once + #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: - - Win32ThreadEngine(InspIRCd* Instance); - - virtual ~Win32ThreadEngine(); + /** Per-thread state, present in each Thread object, managed by the ThreadEngine + */ + struct ThreadState + { + HANDLE handle; + }; 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); - const std::string GetName() - { - return "windows-thread"; - } + /** Stop a thread gracefully. + * First, this function asks the thread to terminate by calling Thread::SetExitFlag(). + * Next, it waits until the thread terminates (on the operating system level). Finally, + * all OS-level resources associated with the thread are released. The Thread instance + * passed to the function is NOT freed. + * When this function returns, the thread is stopped and you can destroy it or restart it + * at a later point. + * Stopping a thread that is not running is a bug. + * @param thread The thread to stop. + */ + void Stop(Thread* thread); }; -class CoreExport ThreadEngineFactory : public classbase +/** 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 + * necessary. 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: - ThreadEngine* Create(InspIRCd* ServerInstance) + Mutex() { - return new Win32ThreadEngine(ServerInstance); + InitializeCriticalSection(&wutex); + } + void Lock() + { + EnterCriticalSection(&wutex); + } + void Unlock() + { + LeaveCriticalSection(&wutex); + } + ~Mutex() + { + DeleteCriticalSection(&wutex); } }; -class CoreExport Win32ThreadData : public ThreadData +class ThreadQueueData : public Mutex { + HANDLE event; public: - HANDLE handle; - void FreeThread(Thread* toFree); -}; + ThreadQueueData() + { + event = CreateEvent(NULL, false, false, NULL); + if (event == NULL) + throw CoreException("CreateEvent() failed in ThreadQueueData::ThreadQueueData()!"); + } -class CoreExport Win32Mutex : public Mutex -{ - private: - CRITICAL_SECTION wutex; - public: - Win32Mutex(); - virtual void Enable(bool enable); - ~Win32Mutex(); + ~ThreadQueueData() + { + CloseHandle(event); + } + + void Wakeup() + { + PulseEvent(event); + } + + void Wait() + { + Unlock(); + WaitForSingleObject(event, INFINITE); + Lock(); + } }; -class CoreExport MutexFactory : public Extensible +class ThreadSignalData { - protected: - InspIRCd* ServerInstance; public: - MutexFactory(InspIRCd* Instance); - virtual Mutex* CreateMutex(); + int connFD; + ThreadSignalData() + { + connFD = -1; + } }; - -#endif -