mangos-mirror/server
0
0
Fork 0
mirror of https://github.com/mangosfour/server.git synced 2025-12-27 10:37:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge commit 'origin/master' into 310

Browse source
This commit is contained in:
tomrus88 2009-05-11 15:11:02 +04:00
commit c86290fa50
183 changed files with 689 additions and 21043 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/shared/Common.h
View file

@ -79,6 +79,7 @@
#include <math.h>
#include <errno.h>
#include <signal.h>
#include <assert.h>
#if PLATFORM == PLATFORM_WINDOWS
#define STRCASECMP stricmp
@ -94,10 +95,13 @@
#include <sstream>
#include <algorithm>
#include <zthread/FastMutex.h>
#include <zthread/LockedQueue.h>
#include <zthread/Runnable.h>
#include <zthread/Thread.h>
#include "LockedQueue.h"
#include "Threading.h"
#include <ace/Guard_T.h>
#include <ace/RW_Thread_Mutex.h>
#include <ace/Thread_Mutex.h>
#if PLATFORM == PLATFORM_WINDOWS
# define FD_SETSIZE 4096

3
src/shared/Database/Database.cpp
View file

@ -108,7 +108,8 @@ bool Database::PExecuteLog(const char * format,...)
void Database::SetResultQueue(SqlResultQueue * queue)
{
m_queryQueues[ZThread::ThreadImpl::current()] = queue;
m_queryQueues[ACE_Based::Thread::current()] = queue;
}
QueryResult* Database::PQuery(const char *format,...)

9
src/shared/Database/Database.h
View file

@ -19,8 +19,7 @@
#ifndef DATABASE_H
#define DATABASE_H
#include "zthread/Thread.h"
#include "../src/zthread/ThreadImpl.h"
#include "Threading.h"
#include "Utilities/UnorderedMap.h"
#include "Database/SqlDelayThread.h"
@ -28,8 +27,8 @@ class SqlTransaction;
class SqlResultQueue;
class SqlQueryHolder;
typedef UNORDERED_MAP<ZThread::ThreadImpl*, SqlTransaction*> TransactionQueues;
typedef UNORDERED_MAP<ZThread::ThreadImpl*, SqlResultQueue*> QueryQueues;
typedef UNORDERED_MAP<ACE_Based::Thread* , SqlTransaction*> TransactionQueues;
typedef UNORDERED_MAP<ACE_Based::Thread* , SqlResultQueue*> QueryQueues;
#define MAX_QUERY_LEN 32*1024
@ -41,7 +40,7 @@ class MANGOS_DLL_SPEC Database
TransactionQueues m_tranQueues; ///< Transaction queues from diff. threads
QueryQueues m_queryQueues; ///< Query queues from diff threads
SqlDelayThread* m_threadBody; ///< Pointer to delay sql executer
ZThread::Thread* m_delayThread; ///< Pointer to executer thread
ACE_Based::Thread* m_delayThread; ///< Pointer to executer thread
public:

4
src/shared/Database/DatabaseImpl.h
View file

@ -27,7 +27,7 @@
QueryQueues::iterator queue_itr; \
\
{ \
ZThread::ThreadImpl * queryThread = ZThread::ThreadImpl::current(); \
ACE_Based::Thread * queryThread = ACE_Based::Thread::current(); \
queue_itr = m_queryQueues.find(queryThread); \
if (queue_itr == m_queryQueues.end()) return false; \
}
@ -57,7 +57,7 @@
QueryQueues::iterator queue_itr; \
\
{ \
ZThread::ThreadImpl * queryThread = ZThread::ThreadImpl::current(); \
ACE_Based::Thread * queryThread = ACE_Based::Thread::current(); \
queue_itr = m_queryQueues.find(queryThread); \
if (queue_itr == m_queryQueues.end()) return false; \
}

25
src/shared/Database/DatabaseMysql.cpp
View file

@ -21,7 +21,7 @@
#include "Util.h"
#include "Policies/SingletonImp.h"
#include "Platform/Define.h"
#include "../src/zthread/ThreadImpl.h"
#include "Threading.h"
#include "DatabaseEnv.h"
#include "Database/MySQLDelayThread.h"
#include "Database/SqlOperations.h"
@ -187,7 +187,7 @@ QueryResult* DatabaseMysql::Query(const char *sql)
{
// guarded block for thread-safe mySQL request
ZThread::Guard<ZThread::FastMutex> query_connection_guard(mMutex);
ACE_Guard<ACE_Thread_Mutex> query_connection_guard(mMutex);
#ifdef MANGOS_DEBUG
uint32 _s = getMSTime();
#endif
@ -235,7 +235,7 @@ bool DatabaseMysql::Execute(const char *sql)
// don't use queued execution if it has not been initialized
if (!m_threadBody) return DirectExecute(sql);
tranThread = ZThread::ThreadImpl::current(); // owner of this transaction
tranThread = ACE_Based::Thread::current(); // owner of this transaction
TransactionQueues::iterator i = m_tranQueues.find(tranThread);
if (i != m_tranQueues.end() && i->second != NULL)
{ // Statement for transaction
@ -257,7 +257,8 @@ bool DatabaseMysql::DirectExecute(const char* sql)
{
// guarded block for thread-safe mySQL request
ZThread::Guard<ZThread::FastMutex> query_connection_guard(mMutex);
ACE_Guard<ACE_Thread_Mutex> query_connection_guard(mMutex);
#ifdef MANGOS_DEBUG
uint32 _s = getMSTime();
#endif
@ -302,8 +303,9 @@ bool DatabaseMysql::BeginTransaction()
// don't use queued execution if it has not been initialized
if (!m_threadBody)
{
if (tranThread==ZThread::ThreadImpl::current())
if (tranThread == ACE_Based::Thread::current())
return false; // huh? this thread already started transaction
mMutex.acquire();
if (!_TransactionCmd("START TRANSACTION"))
{
@ -313,7 +315,7 @@ bool DatabaseMysql::BeginTransaction()
return true; // transaction started
}
tranThread = ZThread::ThreadImpl::current(); // owner of this transaction
tranThread = ACE_Based::Thread::current(); // owner of this transaction
TransactionQueues::iterator i = m_tranQueues.find(tranThread);
if (i != m_tranQueues.end() && i->second != NULL)
// If for thread exists queue and also contains transaction
@ -333,7 +335,7 @@ bool DatabaseMysql::CommitTransaction()
// don't use queued execution if it has not been initialized
if (!m_threadBody)
{
if (tranThread!=ZThread::ThreadImpl::current())
if (tranThread != ACE_Based::Thread::current())
return false;
bool _res = _TransactionCmd("COMMIT");
tranThread = NULL;
@ -341,7 +343,7 @@ bool DatabaseMysql::CommitTransaction()
return _res;
}
tranThread = ZThread::ThreadImpl::current();
tranThread = ACE_Based::Thread::current();
TransactionQueues::iterator i = m_tranQueues.find(tranThread);
if (i != m_tranQueues.end() && i->second != NULL)
{
@ -361,7 +363,7 @@ bool DatabaseMysql::RollbackTransaction()
// don't use queued execution if it has not been initialized
if (!m_threadBody)
{
if (tranThread!=ZThread::ThreadImpl::current())
if (tranThread != ACE_Based::Thread::current())
return false;
bool _res = _TransactionCmd("ROLLBACK");
tranThread = NULL;
@ -369,7 +371,7 @@ bool DatabaseMysql::RollbackTransaction()
return _res;
}
tranThread = ZThread::ThreadImpl::current();
tranThread = ACE_Based::Thread::current();
TransactionQueues::iterator i = m_tranQueues.find(tranThread);
if (i != m_tranQueues.end() && i->second != NULL)
{
@ -392,7 +394,8 @@ void DatabaseMysql::InitDelayThread()
assert(!m_delayThread);
//New delay thread for delay execute
m_delayThread = new ZThread::Thread(m_threadBody = new MySQLDelayThread(this));
m_threadBody = new MySQLDelayThread(this);
m_delayThread = new ACE_Based::Thread(*m_threadBody);
}
void DatabaseMysql::HaltDelayThread()

7
src/shared/Database/DatabaseMysql.h
View file

@ -23,7 +23,8 @@
#include "Database.h"
#include "Policies/Singleton.h"
#include "zthread/FastMutex.h"
#include "ace/Thread_Mutex.h"
#include "ace/Guard_T.h"
#ifdef WIN32
#define FD_SETSIZE 1024
@ -63,9 +64,9 @@ class MANGOS_DLL_SPEC DatabaseMysql : public Database
// must be call before finish thread run
void ThreadEnd();
private:
ZThread::FastMutex mMutex;
ACE_Thread_Mutex mMutex;
ZThread::ThreadImpl* tranThread;
ACE_Based::Thread * tranThread;
MYSQL *mMysql;

26
src/shared/Database/DatabasePostgre.cpp
View file

@ -21,7 +21,7 @@
#include "Util.h"
#include "Policies/SingletonImp.h"
#include "Platform/Define.h"
#include "../src/zthread/ThreadImpl.h"
#include "Threading.h"
#include "DatabaseEnv.h"
#include "Database/PGSQLDelayThread.h"
#include "Database/SqlOperations.h"
@ -124,7 +124,7 @@ QueryResult* DatabasePostgre::Query(const char *sql)
uint32 fieldCount = 0;
// guarded block for thread-safe request
ZThread::Guard<ZThread::FastMutex> query_connection_guard(mMutex);
ACE_Guard<ACE_Thread_Mutex> query_connection_guard(mMutex);
#ifdef MANGOS_DEBUG
uint32 _s = getMSTime();
#endif
@ -172,9 +172,10 @@ bool DatabasePostgre::Execute(const char *sql)
return false;
// don't use queued execution if it has not been initialized
if (!m_threadBody) return DirectExecute(sql);
if (!m_threadBody)
return DirectExecute(sql);
tranThread = ZThread::ThreadImpl::current(); // owner of this transaction
tranThread = ACE_Based::Thread::current(); // owner of this transaction
TransactionQueues::iterator i = m_tranQueues.find(tranThread);
if (i != m_tranQueues.end() && i->second != NULL)
{ // Statement for transaction
@ -195,7 +196,7 @@ bool DatabasePostgre::DirectExecute(const char* sql)
return false;
{
// guarded block for thread-safe request
ZThread::Guard<ZThread::FastMutex> query_connection_guard(mMutex);
ACE_Guard<ACE_Thread_Mutex> query_connection_guard(mMutex);
#ifdef MANGOS_DEBUG
uint32 _s = getMSTime();
#endif
@ -245,7 +246,7 @@ bool DatabasePostgre::BeginTransaction()
// don't use queued execution if it has not been initialized
if (!m_threadBody)
{
if (tranThread==ZThread::ThreadImpl::current())
if (tranThread == ACE_Based::Thread::current())
return false; // huh? this thread already started transaction
mMutex.acquire();
if (!_TransactionCmd("START TRANSACTION"))
@ -256,7 +257,7 @@ bool DatabasePostgre::BeginTransaction()
return true;
}
// transaction started
tranThread = ZThread::ThreadImpl::current(); // owner of this transaction
tranThread = ACE_Based::Thread::current(); // owner of this transaction
TransactionQueues::iterator i = m_tranQueues.find(tranThread);
if (i != m_tranQueues.end() && i->second != NULL)
// If for thread exists queue and also contains transaction
@ -276,14 +277,14 @@ bool DatabasePostgre::CommitTransaction()
// don't use queued execution if it has not been initialized
if (!m_threadBody)
{
if (tranThread!=ZThread::ThreadImpl::current())
if (tranThread != ACE_Based::Thread::current())
return false;
bool _res = _TransactionCmd("COMMIT");
tranThread = NULL;
mMutex.release();
return _res;
}
tranThread = ZThread::ThreadImpl::current();
tranThread = ACE_Based::Thread::current();
TransactionQueues::iterator i = m_tranQueues.find(tranThread);
if (i != m_tranQueues.end() && i->second != NULL)
{
@ -302,14 +303,14 @@ bool DatabasePostgre::RollbackTransaction()
// don't use queued execution if it has not been initialized
if (!m_threadBody)
{
if (tranThread!=ZThread::ThreadImpl::current())
if (tranThread != ACE_Based::Thread::current())
return false;
bool _res = _TransactionCmd("ROLLBACK");
tranThread = NULL;
mMutex.release();
return _res;
}
tranThread = ZThread::ThreadImpl::current();
tranThread = ACE_Based::Thread::current();
TransactionQueues::iterator i = m_tranQueues.find(tranThread);
if (i != m_tranQueues.end() && i->second != NULL)
{
@ -332,7 +333,8 @@ void DatabasePostgre::InitDelayThread()
assert(!m_delayThread);
//New delay thread for delay execute
m_delayThread = new ZThread::Thread(m_threadBody = new PGSQLDelayThread(this));
m_threadBody = new PGSQLDelayThread(this);
m_delayThread = new ACE_Based::Thread(*m_threadBody);
}
void DatabasePostgre::HaltDelayThread()

7
src/shared/Database/DatabasePostgre.h
View file

@ -20,7 +20,6 @@
#define _DatabasePostgre_H
#include "Policies/Singleton.h"
#include "zthread/FastMutex.h"
#include <stdarg.h>
#ifdef WIN32
@ -61,10 +60,8 @@ class DatabasePostgre : public Database
// must be call before finish thread run
void ThreadEnd();
private:
ZThread::FastMutex mMutex;
ZThread::FastMutex tranMutex;
ZThread::ThreadImpl* tranThread;
ACE_Thread_Mutex mMutex;
ACE_Based::Thread * tranThread;
PGconn *mPGconn;

2
src/shared/Database/QueryResult.h
View file

@ -38,7 +38,7 @@ class MANGOS_DLL_SPEC QueryResult
if(iter->second == name)
return iter->first;
}
assert(false && "unknown field name");
ASSERT(false && "unknown field name");
return uint32(-1);
}

2
src/shared/Database/SqlDelayThread.cpp
View file

@ -35,7 +35,7 @@ void SqlDelayThread::run()
{
// if the running state gets turned off while sleeping
// empty the queue before exiting
ZThread::Thread::sleep(10);
ACE_Based::Thread::Sleep(10);
while (!m_sqlQueue.empty())
{
s = m_sqlQueue.next();

15
src/shared/Database/SqlDelayThread.h
View file

@ -19,21 +19,22 @@
#ifndef __SQLDELAYTHREAD_H
#define __SQLDELAYTHREAD_H
#include "zthread/Thread.h"
#include "zthread/Runnable.h"
#include "zthread/FastMutex.h"
#include "zthread/LockedQueue.h"
#include "ace/Thread_Mutex.h"
#include "LockedQueue.h"
#include "Threading.h"
class Database;
class SqlOperation;
class SqlDelayThread : public ZThread::Runnable
class SqlDelayThread : public ACE_Based::Runnable
{
typedef ZThread::LockedQueue<SqlOperation*, ZThread::FastMutex> SqlQueue;
typedef ACE_Based::LockedQueue<SqlOperation*, ACE_Thread_Mutex> SqlQueue;
private:
SqlQueue m_sqlQueue; ///< Queue of SQL statements
Database* m_dbEngine; ///< Pointer to used Database engine
bool m_running;
volatile bool m_running;
SqlDelayThread();
public:

7
src/shared/Database/SqlOperations.h
View file

@ -21,9 +21,8 @@
#include "Common.h"
#include "zthread/LockedQueue.h"
#include "zthread/FastMutex.h"
#include "zthread/Thread.h"
#include "ace/Thread_Mutex.h"
#include "LockedQueue.h"
#include <queue>
#include "Utilities/Callback.h"
@ -70,7 +69,7 @@ class SqlResultQueue; /// queue for thread
class SqlQueryHolder; /// groups several async quries
class SqlQueryHolderEx; /// points to a holder, added to the delay thread
class SqlResultQueue : public ZThread::LockedQueue<MaNGOS::IQueryCallback*, ZThread::FastMutex>
class SqlResultQueue : public ACE_Based::LockedQueue<MaNGOS::IQueryCallback* , ACE_Thread_Mutex>
{
public:
SqlResultQueue() {}

144
src/shared/LockedQueue.h Normal file
View file

@ -0,0 +1,144 @@
/*
* Copyright (C) 2009 MaNGOS <http://getmangos.com/>
*
* This program 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef LOCKEDQUEUE_H
#define LOCKEDQUEUE_H
#include <ace/Guard_T.h>
#include <ace/Thread_Mutex.h>
#include <deque>
#include <assert.h>
#include "Errors.h"
namespace ACE_Based
{
template <class T, class LockType, typename StorageType=std::deque<T> >
class LockedQueue
{
//! Serialize access to the Queue
LockType _lock;
//! Storage backing the queue
StorageType _queue;
//! Cancellation flag
volatile bool _canceled;
public:
//! Create a LockedQueue
LockedQueue() : _canceled(false) {}
//! Destroy a LockedQueue
virtual ~LockedQueue() { }
/**
* @see Queue::add(const T& item)
*/
void add(const T& item)
{
ACE_Guard<LockType> g(_lock);
ASSERT(!_canceled);
// throw Cancellation_Exception();
_queue.push_back(item);
}
/**
* @see Queue::next()
*/
T next()
{
ACE_Guard<LockType> g(_lock);
ASSERT (!_queue.empty() || !_canceled);
// throw Cancellation_Exception();
T item = _queue.front();
_queue.pop_front();
return item;
}
T front()
{
ACE_Guard<LockType> g(_lock);
ASSERT (!_queue.empty());
// throw NoSuchElement_Exception();
return _queue.front();
}
/**
* @see Queue::cancel()
*/
void cancel()
{
ACE_Guard<LockType> g(_lock);
_canceled = true;
}
/**
* @see Queue::isCanceled()
*/
bool isCanceled()
{
// Faster check since the queue will not become un-canceled
if(_canceled)
return true;
ACE_Guard<LockType> g(_lock);
return _canceled;
}
/**
* @see Queue::size()
*/
size_t size()
{
ACE_Guard<LockType> g(_lock);
return _queue.size();
}
bool empty()
{
ACE_Guard<LockType> g(_lock);
return _queue.empty();
}
};
}
#endif

2
src/shared/Log.h
View file

@ -54,7 +54,7 @@ enum Color
const int Color_count = int(WHITE)+1;
class Log : public MaNGOS::Singleton<Log, MaNGOS::ClassLevelLockable<Log, ZThread::FastMutex> >
class Log : public MaNGOS::Singleton<Log, MaNGOS::ClassLevelLockable<Log, ACE_Thread_Mutex> >
{
friend class MaNGOS::OperatorNew<Log>;
Log();

3
src/shared/Makefile.am
View file

@ -36,6 +36,7 @@ libmangosshared_a_SOURCES = \
Common.cpp \
Common.h \
Errors.h \
LockedQueue.h \
Log.cpp \
Log.h \
MemoryLeaks.cpp \
@ -43,6 +44,8 @@ libmangosshared_a_SOURCES = \
ProgressBar.cpp \
ProgressBar.h \
Timer.h \
Threading.cpp \
Threading.h \
Util.cpp \
Util.h \
WorldPacket.h \

202
src/shared/Threading.cpp Normal file
View file

@ -0,0 +1,202 @@
/*
* Copyright (C) 2009 MaNGOS <http://getmangos.com/>
*
* This program 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "Threading.h"
#include <ace/OS_NS_unistd.h>
#include <ace/Sched_Params.h>
#include <vector>
using namespace ACE_Based;
ThreadPriority::ThreadPriority()
{
for (int i = Idle; i < MAXPRIORITYNUM; ++i)
m_priority[i] = ACE_THR_PRI_OTHER_DEF;
m_priority[Idle] = ACE_Sched_Params::priority_min(ACE_SCHED_OTHER);
m_priority[Realtime] = ACE_Sched_Params::priority_max(ACE_SCHED_OTHER);
std::vector<int> _tmp;
ACE_Sched_Params::Policy _policy = ACE_SCHED_OTHER;
ACE_Sched_Priority_Iterator pr_iter(_policy);
while (pr_iter.more())
{
_tmp.push_back(pr_iter.priority());
pr_iter.next();
}
ASSERT (!_tmp.empty());
const size_t max_pos = _tmp.size();
size_t min_pos = 1;
size_t norm_pos = 0;
for (size_t i = 0; i < max_pos; ++i)
{
if(_tmp[i] == ACE_THR_PRI_OTHER_DEF)
{
norm_pos = i + 1;
break;
}
}
//since we have only 7(seven) values in enum Priority
//and 3 we know already (Idle, Normal, Realtime) so
//we need to split each list [Idle...Normal] and [Normal...Realtime]
//into ¹ piesces
const size_t _divider = 4;
size_t _div = (norm_pos - min_pos) / _divider;
if(_div == 0)
_div = 1;
min_pos = (norm_pos - 1);
m_priority[Low] = _tmp[min_pos -= _div];
m_priority[Lowest] = _tmp[min_pos -= _div ];
_div = (max_pos - norm_pos) / _divider;
if(_div == 0)
_div = 1;
min_pos = norm_pos - 1;
m_priority[High] = _tmp[min_pos += _div];
m_priority[Highest] = _tmp[min_pos += _div];
}
int ThreadPriority::getPriority(Priority p) const
{
if(p < Idle)
p = Idle;
if(p > Realtime)
p = Realtime;
return m_priority[p];
}
#define THREADFLAG (THR_NEW_LWP | THR_SCHED_DEFAULT| THR_JOINABLE)
Thread::Thread() : m_task(0), m_iThreadId(0), m_hThreadHandle(0)
{
}
Thread::Thread(Runnable& instance) : m_task(&instance), m_iThreadId(0), m_hThreadHandle(0)
{
bool _start = start();
ASSERT (_start);
}
Thread::~Thread()
{
//Wait();
}
//initialize Thread's class static member
Thread::ThreadStorage Thread::m_ThreadStorage;
ThreadPriority Thread::m_TpEnum;
bool Thread::start()
{
if(m_task == 0 || m_iThreadId != 0)
return false;
return (ACE_Thread::spawn(&Thread::ThreadTask, (void*)m_task, THREADFLAG, &m_iThreadId, &m_hThreadHandle) == 0);
}
bool Thread::wait()
{
if(!m_hThreadHandle || !m_task)
return false;
ACE_THR_FUNC_RETURN _value = ACE_THR_FUNC_RETURN(-1);
int _res = ACE_Thread::join(m_hThreadHandle, &_value);
m_iThreadId = 0;
m_hThreadHandle = 0;
return (_res == 0);
}
void Thread::destroy()
{
ACE_Thread::kill(m_iThreadId, -1);
}
void Thread::suspend()
{
ACE_Thread::suspend(m_hThreadHandle);
}
void Thread::resume()
{
ACE_Thread::resume(m_hThreadHandle);
}
ACE_THR_FUNC_RETURN Thread::ThreadTask(void * param)
{
Runnable * _task = (Runnable*)param;
_task->run();
return (ACE_THR_FUNC_RETURN)0;
}
ACE_thread_t Thread::currentId()
{
return ACE_Thread::self();
}
ACE_hthread_t Thread::currentHandle()
{
ACE_hthread_t _handle;
ACE_Thread::self(_handle);
return _handle;
}
Thread * Thread::current()
{
Thread * _thread = m_ThreadStorage.ts_object();
if(!_thread)
{
_thread = new Thread();
_thread->m_iThreadId = Thread::currentId();
_thread->m_hThreadHandle = Thread::currentHandle();
Thread * _oldValue = m_ThreadStorage.ts_object(_thread);
if(_oldValue)
delete _oldValue;
}
return _thread;
}
void Thread::setPriority(Priority type)
{
int _priority = m_TpEnum.getPriority(type);
int _ok = ACE_Thread::setprio(m_hThreadHandle, _priority);
//remove this ASSERT in case you don't want to know is thread priority change was successful or not
ASSERT (_ok == 0);
}
void Thread::Sleep(unsigned long msecs)
{
ACE_OS::sleep(ACE_Time_Value(0, 1000 * msecs));
}

99
src/shared/Threading.h Normal file
View file

@ -0,0 +1,99 @@
/*
* Copyright (C) 2009 MaNGOS <http://getmangos.com/>
*
* This program 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; either version 2 of the License, or
* (at your option) any later version.
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef THREADING_H
#define THREADING_H
#include <ace/Thread.h>
#include <ace/TSS_T.h>
#include <assert.h>
#include "Errors.h"
namespace ACE_Based
{
class Runnable
{
public:
virtual ~Runnable() {}
virtual void run() = 0;
};
enum Priority
{
Idle,
Lowest,
Low,
Normal,
High,
Highest,
Realtime,
};
#define MAXPRIORITYNUM (Realtime + 1)
class ThreadPriority
{
public:
ThreadPriority();
int getPriority(Priority p) const;
private:
int m_priority[MAXPRIORITYNUM];
};
class Thread
{
public:
Thread();
Thread(Runnable& instance);
~Thread();
bool start();
bool wait();
void destroy();
void suspend();
void resume();
void setPriority(Priority type);
static void Sleep(unsigned long msecs);
static ACE_thread_t currentId();
static ACE_hthread_t currentHandle();
static Thread * current();
private:
Thread(const Thread&);
Thread& operator=(const Thread&);
static ACE_THR_FUNC_RETURN ThreadTask(void * param);
ACE_thread_t m_iThreadId;
ACE_hthread_t m_hThreadHandle;
Runnable * m_task;
typedef ACE_TSS<Thread> ThreadStorage;
//global object - container for Thread class representation of every thread
static ThreadStorage m_ThreadStorage;
//use this object to determine current OS thread priority values mapped to enum Priority{}
static ThreadPriority m_TpEnum;
};
}
#endif

20
src/shared/Util.cpp
View file

@ -21,40 +21,34 @@
#include "sockets/socket_include.h"
#include "utf8cpp/utf8.h"
#include "mersennetwister/MersenneTwister.h"
#include "zthread/ThreadLocal.h"
#include <ace/TSS_T.h>
typedef ZThread::ThreadLocal<MTRand> MTRandTSS;
/* NOTE: Not sure if static initialization is ok for TSS objects ,
* as I see zthread uses custom implementation of the TSS
* ,and in the consturctor there is no code ,so I suppose its ok
* If its not ok ,change it to use singleton.
*/
typedef ACE_TSS<MTRand> MTRandTSS;
static MTRandTSS mtRand;
int32 irand (int32 min, int32 max)
{
return int32 (mtRand.get ().randInt (max - min)) + min;
return int32 (mtRand->randInt (max - min)) + min;
}
uint32 urand (uint32 min, uint32 max)
{
return mtRand.get ().randInt (max - min) + min;
return mtRand->randInt (max - min) + min;
}
int32 rand32 ()
{
return mtRand.get ().randInt ();
return mtRand->randInt ();
}
double rand_norm(void)
{
return mtRand.get ().randExc ();
return mtRand->randExc ();
}
double rand_chance (void)
{
return mtRand.get ().randExc (100.0);
return mtRand->randExc (100.0);
}
Tokens StrSplit(const std::string &src, const std::string &sep)

2
src/shared/revision_nr.h
View file

@ -1,4 +1,4 @@
#ifndef __REVISION_NR_H__
#define __REVISION_NR_H__
#define REVISION_NR "7809"
#define REVISION_NR "7811"
#endif // __REVISION_NR_H__