From f9e6de5284aaacd55aa389445cd595bdcaa8339e Mon Sep 17 00:00:00 2001 From: danieldg Date: Mon, 23 Mar 2009 18:48:42 +0000 Subject: ThreadEngine: remove MutexFactory, mutexes should be constructed using their constructor git-svn-id: http://svn.inspircd.org/repository/trunk/inspircd@11250 e03df62e-2008-0410-955e-edbf42e46eb7 --- include/inspircd.h | 7 +- include/threadengine.h | 96 ---------------------------- include/threadengines/threadengine_pthread.h | 91 +++++++++++++++++--------- include/threadengines/threadengine_win32.h | 76 ++++++++++++++-------- src/inspircd.cpp | 13 +--- src/modules/extra/m_mssql.cpp | 6 +- src/modules/extra/m_mysql.cpp | 83 ++++++++++-------------- src/server.cpp | 4 +- src/testsuite.cpp | 4 +- src/threadengine.cpp | 10 --- src/threadengines/threadengine_pthread.cpp | 39 ++--------- src/threadengines/threadengine_win32.cpp | 43 +++---------- 12 files changed, 170 insertions(+), 302 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 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 ""; - } -}; - -/** 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 #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 diff --git a/src/inspircd.cpp b/src/inspircd.cpp index e6b863591..7c82b706b 100644 --- a/src/inspircd.cpp +++ b/src/inspircd.cpp @@ -151,8 +151,6 @@ void InspIRCd::Cleanup() /* Close logging */ this->Logs->CloseLogs(); DeleteZero(this->Logs); - - delete RehashFinishMutex; } void InspIRCd::Restart(const std::string &reason) @@ -391,10 +389,7 @@ InspIRCd::InspIRCd(int argc, char** argv) SE = SEF->Create(this); delete SEF; - ThreadEngineFactory* tef = new ThreadEngineFactory(); - this->Threads = tef->Create(this); - delete tef; - this->Mutexes = new MutexFactory(this); + this->Threads = new ThreadEngine(this); /* Default implementation does nothing */ this->PI = new ProtocolInterface(this); @@ -756,8 +751,6 @@ int InspIRCd::Run() Exit(0); } - RehashFinishMutex = Mutexes->CreateMutex(); - while (true) { #ifndef WIN32 @@ -769,7 +762,7 @@ int InspIRCd::Run() #endif /* Check if there is a config thread which has finished executing but has not yet been freed */ - RehashFinishMutex->Lock(); + RehashFinishMutex.Lock(); if (this->ConfigThread && this->ConfigThread->GetExitFlag()) { /* Rehash has completed */ @@ -805,7 +798,7 @@ int InspIRCd::Run() delete ConfigThread; ConfigThread = NULL; } - RehashFinishMutex->Unlock(); + RehashFinishMutex.Unlock(); /* time() seems to be a pretty expensive syscall, so avoid calling it too much. * Once per loop iteration is pleanty. diff --git a/src/modules/extra/m_mssql.cpp b/src/modules/extra/m_mssql.cpp index 7515570a9..0f1442e59 100644 --- a/src/modules/extra/m_mssql.cpp +++ b/src/modules/extra/m_mssql.cpp @@ -746,9 +746,9 @@ class ModuleMsSQL : public Module ModuleMsSQL(InspIRCd* Me) : Module(Me), currid(0) { - LoggingMutex = ServerInstance->Mutexes->CreateMutex(); - ResultsMutex = ServerInstance->Mutexes->CreateMutex(); - QueueMutex = ServerInstance->Mutexes->CreateMutex(); + LoggingMutex = new Mutex(); + ResultsMutex = new Mutex(); + QueueMutex = new Mutex(); ServerInstance->Modules->UseInterface("SQLutils"); diff --git a/src/modules/extra/m_mysql.cpp b/src/modules/extra/m_mysql.cpp index fe4e08965..eefeea74d 100644 --- a/src/modules/extra/m_mysql.cpp +++ b/src/modules/extra/m_mysql.cpp @@ -97,10 +97,10 @@ class ModuleSQL : public Module int currid; bool rehashing; DispatcherThread* Dispatcher; - Mutex* QueueMutex; - Mutex* ResultsMutex; - Mutex* LoggingMutex; - Mutex* ConnMutex; + Mutex QueueMutex; + Mutex ResultsMutex; + Mutex LoggingMutex; + Mutex ConnMutex; ModuleSQL(InspIRCd* Me); ~ModuleSQL(); @@ -452,9 +452,9 @@ class SQLConnection : public classbase *queryend = 0; - Parent->QueueMutex->Lock(); + Parent->QueueMutex.Lock(); req.query.q = query; - Parent->QueueMutex->Unlock(); + Parent->QueueMutex.Unlock(); if (!mysql_real_query(connection, req.query.q.data(), req.query.q.length())) { @@ -467,9 +467,9 @@ class SQLConnection : public classbase /* Put this new result onto the results queue. * XXX: Remember to mutex the queue! */ - Parent->ResultsMutex->Lock(); + Parent->ResultsMutex.Lock(); rq.push_back(r); - Parent->ResultsMutex->Unlock(); + Parent->ResultsMutex.Unlock(); } else { @@ -480,9 +480,9 @@ class SQLConnection : public classbase r->dbid = this->GetID(); r->query = req.query.q; - Parent->ResultsMutex->Lock(); + Parent->ResultsMutex.Lock(); rq.push_back(r); - Parent->ResultsMutex->Unlock(); + Parent->ResultsMutex.Unlock(); } /* Now signal the main thread that we've got a result to process. @@ -615,17 +615,17 @@ void ConnectDatabases(InspIRCd* ServerInstance, ModuleSQL* Parent) if (!i->second->Connect()) { /* XXX: MUTEX */ - Parent->LoggingMutex->Lock(); + Parent->LoggingMutex.Lock(); ServerInstance->Logs->Log("m_mysql",DEFAULT,"SQL: Failed to connect database "+i->second->GetHost()+": Error: "+i->second->GetError()); i->second->SetEnable(false); - Parent->LoggingMutex->Unlock(); + Parent->LoggingMutex.Unlock(); } } } void LoadDatabases(ConfigReader* conf, InspIRCd* ServerInstance, ModuleSQL* Parent) { - Parent->ConnMutex->Lock(); + Parent->ConnMutex.Lock(); ClearOldConnections(conf); for (int j =0; j < conf->Enumerate("database"); j++) { @@ -648,7 +648,7 @@ void LoadDatabases(ConfigReader* conf, InspIRCd* ServerInstance, ModuleSQL* Pare } } ConnectDatabases(ServerInstance, Parent); - Parent->ConnMutex->Unlock(); + Parent->ConnMutex.Unlock(); } char FindCharId(const std::string &id) @@ -731,21 +731,21 @@ class Notifier : public BufferedSocket if (ServerInstance->SE->Recv(this, &data, 1, 0) > 0) { - Parent->ConnMutex->Lock(); + Parent->ConnMutex.Lock(); ConnMap::iterator iter = GetCharId(data); - Parent->ConnMutex->Unlock(); + Parent->ConnMutex.Unlock(); if (iter != Connections.end()) { - Parent->ResultsMutex->Lock(); + Parent->ResultsMutex.Lock(); ResultQueue::iterator n = iter->second->rq.begin(); - Parent->ResultsMutex->Unlock(); + Parent->ResultsMutex.Unlock(); (*n)->Send(); delete (*n); - Parent->ResultsMutex->Lock(); + Parent->ResultsMutex.Lock(); iter->second->rq.pop_front(); - Parent->ResultsMutex->Unlock(); + Parent->ResultsMutex.Unlock(); return true; } @@ -809,37 +809,26 @@ ModuleSQL::ModuleSQL(InspIRCd* Me) : Module(Me), rehashing(false) MessagePipe = new MySQLListener(this, ServerInstance, 0, "127.0.0.1"); #endif - LoggingMutex = ServerInstance->Mutexes->CreateMutex(); - ConnMutex = ServerInstance->Mutexes->CreateMutex(); - if (MessagePipe->GetFd() == -1) { - delete ConnMutex; ServerInstance->Modules->DoneWithInterface("SQLutils"); throw ModuleException("m_mysql: unable to create ITC pipe"); } else { - LoggingMutex->Lock(); + LoggingMutex.Lock(); ServerInstance->Logs->Log("m_mysql", DEBUG, "MySQL: Interthread comms port is %d", MessagePipe->GetPort()); - LoggingMutex->Unlock(); + LoggingMutex.Unlock(); } Dispatcher = new DispatcherThread(ServerInstance, this); ServerInstance->Threads->Start(Dispatcher); - ResultsMutex = ServerInstance->Mutexes->CreateMutex(); - QueueMutex = ServerInstance->Mutexes->CreateMutex(); - if (!ServerInstance->Modules->PublishFeature("SQL", this)) { /* Tell worker thread to exit NOW, * Automatically joins */ delete Dispatcher; - delete LoggingMutex; - delete ResultsMutex; - delete QueueMutex; - delete ConnMutex; ServerInstance->Modules->DoneWithInterface("SQLutils"); throw ModuleException("m_mysql: Unable to publish feature 'SQL'"); } @@ -857,10 +846,6 @@ ModuleSQL::~ModuleSQL() ServerInstance->Modules->UnpublishInterface("SQL", this); ServerInstance->Modules->UnpublishFeature("SQL"); ServerInstance->Modules->DoneWithInterface("SQLutils"); - delete LoggingMutex; - delete ResultsMutex; - delete QueueMutex; - delete ConnMutex; } unsigned long ModuleSQL::NewID() @@ -877,13 +862,13 @@ const char* ModuleSQL::OnRequest(Request* request) SQLrequest* req = (SQLrequest*)request; /* XXX: Lock */ - QueueMutex->Lock(); + QueueMutex.Lock(); ConnMap::iterator iter; const char* returnval = NULL; - ConnMutex->Lock(); + ConnMutex.Lock(); if((iter = Connections.find(req->dbid)) != Connections.end()) { req->id = NewID(); @@ -895,8 +880,8 @@ const char* ModuleSQL::OnRequest(Request* request) req->error.Id(SQL_BAD_DBID); } - ConnMutex->Unlock(); - QueueMutex->Unlock(); + ConnMutex.Unlock(); + QueueMutex.Unlock(); return returnval; } @@ -951,17 +936,17 @@ void DispatcherThread::Run() if (Parent->rehashing) { /* XXX: Lock */ - Parent->QueueMutex->Lock(); + Parent->QueueMutex.Lock(); Parent->rehashing = false; LoadDatabases(Parent->Conf, Parent->PublicServerInstance, Parent); - Parent->QueueMutex->Unlock(); + Parent->QueueMutex.Unlock(); /* XXX: Unlock */ } SQLConnection* conn = NULL; /* XXX: Lock here for safety */ - Parent->QueueMutex->Lock(); - Parent->ConnMutex->Lock(); + Parent->QueueMutex.Lock(); + Parent->ConnMutex.Lock(); for (ConnMap::iterator i = Connections.begin(); i != Connections.end(); i++) { if (i->second->queue.totalsize()) @@ -970,8 +955,8 @@ void DispatcherThread::Run() break; } } - Parent->ConnMutex->Unlock(); - Parent->QueueMutex->Unlock(); + Parent->ConnMutex.Unlock(); + Parent->QueueMutex.Unlock(); /* XXX: Unlock */ /* Theres an item! */ @@ -980,9 +965,9 @@ void DispatcherThread::Run() conn->DoLeadingQuery(); /* XXX: Lock */ - Parent->QueueMutex->Lock(); + Parent->QueueMutex.Lock(); conn->queue.pop(); - Parent->QueueMutex->Unlock(); + Parent->QueueMutex.Unlock(); /* XXX: Unlock */ } diff --git a/src/server.cpp b/src/server.cpp index 3e607e032..46c17d14a 100644 --- a/src/server.cpp +++ b/src/server.cpp @@ -48,7 +48,7 @@ void InspIRCd::Exit(int status) void RehashHandler::Call(const std::string &reason) { - Server->RehashFinishMutex->Lock(); + Server->RehashFinishMutex.Lock(); Server->SNO->WriteToSnoMask('A', "Rehashing config file %s %s",ServerConfig::CleanFilename(Server->ConfigFileName), reason.c_str()); Server->RehashUsersAndChans(); FOREACH_MOD_I(Server, I_OnGarbageCollect, OnGarbageCollect()); @@ -60,7 +60,7 @@ void RehashHandler::Call(const std::string &reason) Server->ConfigThread = new ConfigReaderThread(Server, false, ""); Server->Threads->Start(Server->ConfigThread); } - Server->RehashFinishMutex->Unlock(); + Server->RehashFinishMutex.Unlock(); } void InspIRCd::RehashServer() diff --git a/src/testsuite.cpp b/src/testsuite.cpp index 5de5601cb..8f89fd65e 100644 --- a/src/testsuite.cpp +++ b/src/testsuite.cpp @@ -186,9 +186,7 @@ bool TestSuite::DoThreadTests() cout << "Creating new ThreadEngine class...\n"; try { - ThreadEngineFactory* tef = new ThreadEngineFactory(); - te = tef->Create(ServerInstance); - delete tef; + te = new ThreadEngine(ServerInstance); } catch (...) { diff --git a/src/threadengine.cpp b/src/threadengine.cpp index d15ae2f70..e7a316282 100644 --- a/src/threadengine.cpp +++ b/src/threadengine.cpp @@ -20,14 +20,4 @@ #include "inspircd.h" #include "threadengine.h" -ThreadEngine::ThreadEngine(InspIRCd* Instance) : ServerInstance(Instance) -{ -} -ThreadEngine::~ThreadEngine() -{ -} - -Mutex::Mutex() -{ -} diff --git a/src/threadengines/threadengine_pthread.cpp b/src/threadengines/threadengine_pthread.cpp index 9fc9cc4b4..f5de69a6a 100644 --- a/src/threadengines/threadengine_pthread.cpp +++ b/src/threadengines/threadengine_pthread.cpp @@ -16,7 +16,7 @@ #include #include -PThreadEngine::PThreadEngine(InspIRCd* Instance) : ThreadEngine(Instance) +ThreadEngine::ThreadEngine(InspIRCd* Instance) { } @@ -34,52 +34,25 @@ static void* entry_point(void* parameter) } -void PThreadEngine::Start(Thread* thread) +void ThreadEngine::Start(Thread* thread) { - PThreadData* data = new PThreadData; + ThreadData* data = new ThreadData; thread->state = data; if (pthread_create(&data->pthread_id, NULL, entry_point, thread) != 0) { thread->state = NULL; delete data; - throw CoreException("Unable to create new PThreadEngine: " + std::string(strerror(errno))); + throw CoreException("Unable to create new thread: " + std::string(strerror(errno))); } } -PThreadEngine::~PThreadEngine() +ThreadEngine::~ThreadEngine() { } -void PThreadData::FreeThread(Thread* thread) +void ThreadData::FreeThread(Thread* thread) { thread->SetExitFlag(true); pthread_join(pthread_id, NULL); } - -MutexFactory::MutexFactory(InspIRCd* Instance) : ServerInstance(Instance) -{ -} - -Mutex* MutexFactory::CreateMutex() -{ - return new PosixMutex(); -} - -PosixMutex::PosixMutex() : Mutex() -{ - pthread_mutex_init(&putex, NULL); -} - -PosixMutex::~PosixMutex() -{ - pthread_mutex_destroy(&putex); -} - -void PosixMutex::Enable(bool enable) -{ - if (enable) - pthread_mutex_lock(&putex); - else - pthread_mutex_unlock(&putex); -} diff --git a/src/threadengines/threadengine_win32.cpp b/src/threadengines/threadengine_win32.cpp index b32dd2441..6ebd6a10a 100644 --- a/src/threadengines/threadengine_win32.cpp +++ b/src/threadengines/threadengine_win32.cpp @@ -14,67 +14,40 @@ #include "inspircd.h" #include "threadengines/threadengine_win32.h" -Win32ThreadEngine::Win32ThreadEngine(InspIRCd* Instance) : ThreadEngine(Instance) +ThreadEngine::ThreadEngine(InspIRCd* Instance) { } -void Win32ThreadEngine::Create(Thread* thread) +void ThreadEngine::Create(Thread* thread) { - Win32ThreadData* data = new Win32ThreadData; + ThreadData* data = new ThreadData; thread->state = data; DWORD ThreadId = 0; - data->handle = CreateThread(NULL,0,Win32ThreadEngine::Entry,thread,0,&ThreadId); + data->handle = CreateThread(NULL,0,ThreadEngine::Entry,thread,0,&ThreadId); if (data->handle == NULL) { thread->state = NULL; delete data; - throw CoreException(std::string("Unable to create new Win32ThreadEngine: ") + dlerror()); + throw CoreException(std::string("Unable to create new thread: ") + dlerror()); } } -Win32ThreadEngine::~Win32ThreadEngine() +ThreadEngine::~ThreadEngine() { } -DWORD WINAPI Win32ThreadEngine::Entry(void* parameter) +DWORD WINAPI ThreadEngine::Entry(void* parameter) { Thread* pt = reinterpret_cast(parameter); pt->Run(); return 0; } -void Win32ThreadData::FreeThread(Thread* thread) +void ThreadData::FreeThread(Thread* thread) { thread->SetExitFlag(); WaitForSingleObject(handle,INFINITE); } - -MutexFactory::MutexFactory(InspIRCd* Instance) : ServerInstance(Instance) -{ -} - -Mutex* MutexFactory::CreateMutex() -{ - return new Win32Mutex(); -} - -Win32Mutex::Win32Mutex() : Mutex() -{ - InitializeCriticalSection(&wutex); -} - -Win32Mutex::~Win32Mutex() -{ - DeleteCriticalSection(&wutex); -} - -void Win32Mutex::Enable(bool enable) -{ - if (enable) - EnterCriticalSection(&wutex); - else - LeaveCriticalSection(&wutex); -} -- cgit v1.2.3