josh/TCPlayerbotCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replaced Threading and SFMT access related code with std::thread and boost TSS

Browse Source 
Note: The remote access thread is currently broken due to unknown ACE fail (will be replaced at some point anyways..)
This commit is contained in:
leak
2014-06-21 19:39:16 +02:00
parent 55dee85ed8
commit 33dc72a812
16 changed files with 140 additions and 567 deletions
Download Patch File Download Diff File Expand all files Collapse all files
dep/SFMT/SFMT.h
+46 -41
View File
@@ -150,9 +150,13 @@ __m128i const &c, __m128i const &d, __m128i const &mask) {
return z2;
}
namespace boost {
template <typename T> class thread_specific_ptr;
}
// Class for SFMT generator
class SFMTRand { // Encapsulate random number generator
friend class ACE_TSS<SFMTRand>;
friend class boost::thread_specific_ptr<SFMTRand>;
public:
SFMTRand()
@@ -243,6 +247,47 @@ public:
y = ((uint32_t*)state)[ix++];
return y;
}
void* operator new(size_t size, std::nothrow_t const&)
{
return _mm_malloc(size, 16);
}
void operator delete(void* ptr, std::nothrow_t const&)
{
_mm_free(ptr);
}
void* operator new(size_t size)
{
return _mm_malloc(size, 16);
}
void operator delete(void* ptr)
{
_mm_free(ptr);
}
void* operator new[](size_t size, std::nothrow_t const&)
{
return _mm_malloc(size, 16);
}
void operator delete[](void* ptr, std::nothrow_t const&)
{
_mm_free(ptr);
}
void* operator new[](size_t size)
{
return _mm_malloc(size, 16);
}
void operator delete[](void* ptr)
{
_mm_free(ptr);
}
private:
void Init2() // Various initializations and period certification
{
@@ -307,46 +352,6 @@ private:
ix = 0;
}
void* operator new(size_t size, std::nothrow_t const&)
{
return _mm_malloc(size, 16);
}
void operator delete(void* ptr, std::nothrow_t const&)
{
_mm_free(ptr);
}
void* operator new(size_t size)
{
return _mm_malloc(size, 16);
}
void operator delete(void* ptr)
{
_mm_free(ptr);
}
void* operator new[](size_t size, std::nothrow_t const&)
{
return _mm_malloc(size, 16);
}
void operator delete[](void* ptr, std::nothrow_t const&)
{
_mm_free(ptr);
}
void* operator new[](size_t size)
{
return _mm_malloc(size, 16);
}
void operator delete[](void* ptr)
{
_mm_free(ptr);
}
__m128i mask; // AND mask
__m128i state[SFMT_N]; // State vector for SFMT generator
uint32_t ix; // Index into state array
src/server/shared/Common.h
-3
View File
@@ -82,7 +82,6 @@
#include "Debugging/Errors.h"
#include "Threading/LockedQueue.h"
#include "Threading/Threading.h"
#if PLATFORM == PLATFORM_WINDOWS
# include <ws2tcpip.h>
@@ -114,8 +113,6 @@
inline float finiteAlways(float f) { return finite(f) ? f : 0.0f; }
#define atol(a) strtoul( a, NULL, 10)
#define STRINGIZE(a) #a
enum TimeConstants
src/server/shared/Database/MySQLThreading.h
+1 -26
View File
@@ -23,31 +23,6 @@
class MySQL
{
public:
/*! Create a thread on the MySQL server to mirrior the calling thread,
initializes thread-specific variables and allows thread-specific
operations without concurrence from other threads.
This should only be called if multiple core threads are running
on the same MySQL connection. Seperate MySQL connections implicitly
create a mirror thread.
*/
static void Thread_Init()
{
mysql_thread_init();
TC_LOG_WARN("sql.sql", "Core thread with ID [" UI64FMTD "] initializing MySQL thread.",
(uint64)ACE_Based::Thread::currentId());
}
/*! Shuts down MySQL thread and frees resources, should only be called
when we terminate. MySQL threads and connections are not configurable
during runtime.
*/
static void Thread_End()
{
mysql_thread_end();
TC_LOG_WARN("sql.sql", "Core thread with ID [" UI64FMTD "] shutting down MySQL thread.",
(uint64)ACE_Based::Thread::currentId());
}
static void Library_Init()
{
mysql_library_init(-1, NULL, NULL);
@@ -59,4 +34,4 @@ class MySQL
}
};
#endif
#endif
src/server/shared/Threading/Threading.cpp
-235
View File
@@ -1,235 +0,0 @@
/*
* Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2005-2008 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, see <http://www.gnu.org/licenses/>.
*/
#include "Threading.h"
#include "Errors.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());
if (_tmp.size() >= MAXPRIORITYNUM)
{
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 pieces
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_iThreadId(0), m_hThreadHandle(0), m_task(0)
{
}
Thread::Thread(Runnable* instance): m_iThreadId(0), m_hThreadHandle(0), m_task(instance)
{
// register reference to m_task to prevent it deeltion until destructor
if (m_task)
m_task->incReference();
bool _start = start();
ASSERT (_start);
}
Thread::~Thread()
{
//Wait();
// deleted runnable object (if no other references)
if (m_task)
m_task->decReference();
}
//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;
// incRef before spawing the thread, otherwise Thread::ThreadTask() might call decRef and delete m_task
m_task->incReference();
bool res = (ACE_Thread::spawn(&Thread::ThreadTask, (void*)m_task, THREADFLAG, &m_iThreadId, &m_hThreadHandle) == 0);
if (!res)
m_task->decReference();
return res;
}
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()
{
if (!m_iThreadId || !m_task)
return;
if (ACE_Thread::kill(m_iThreadId, -1) != 0)
return;
m_iThreadId = 0;
m_hThreadHandle = 0;
// reference set at ACE_Thread::spawn
m_task->decReference();
}
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();
// task execution complete, free referecne added at
_task->decReference();
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));
}
src/server/shared/Threading/Threading.h
-108
View File
@@ -1,108 +0,0 @@
/*
* Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2005-2008 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef THREADING_H
#define THREADING_H
#include <ace/Thread.h>
#include <ace/TSS_T.h>
#include <ace/Atomic_Op.h>
#include <assert.h>
namespace ACE_Based
{
class Runnable
{
public:
virtual ~Runnable() { }
virtual void run() = 0;
void incReference() { ++m_refs; }
void decReference()
{
if (!--m_refs)
delete this;
}
private:
ACE_Atomic_Op<ACE_Thread_Mutex, long> m_refs;
};
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();
explicit 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
src/server/shared/Utilities/Util.cpp
+21 -16
View File
@@ -21,42 +21,54 @@
#include "utf8.h"
#include "SFMT.h"
#include "Errors.h" // for ASSERT
#include <ace/TSS_T.h>
#include <boost/thread/tss.hpp>
typedef ACE_TSS<SFMTRand> SFMTRandTSS;
static SFMTRandTSS sfmtRand;
static boost::thread_specific_ptr<SFMTRand> sfmtRand;
static SFMTRand* GetRng()
{
SFMTRand* rand = sfmtRand.get();
if (!rand)
{
rand = new SFMTRand();
sfmtRand.reset(rand);
}
return rand;
}
int32 irand(int32 min, int32 max)
{
ASSERT(max >= min);
return int32(sfmtRand->IRandom(min, max));
return int32(GetRng()->IRandom(min, max));
}
uint32 urand(uint32 min, uint32 max)
{
ASSERT(max >= min);
return sfmtRand->URandom(min, max);
return GetRng()->URandom(min, max);
}
float frand(float min, float max)
{
ASSERT(max >= min);
return float(sfmtRand->Random() * (max - min) + min);
return float(GetRng()->Random() * (max - min) + min);
}
int32 rand32()
{
return int32(sfmtRand->BRandom());
return int32(GetRng()->BRandom());
}
double rand_norm(void)
{
return sfmtRand->Random();
return GetRng()->Random();
}
double rand_chance(void)
{
return sfmtRand->Random() * 100.0;
return GetRng()->Random() * 100.0;
}
Tokenizer::Tokenizer(const std::string &src, const char sep, uint32 vectorReserve)
@@ -250,13 +262,6 @@ bool IsIPAddress(char const* ipaddress)
return inet_addr(ipaddress) != INADDR_NONE;
}
std::string GetAddressString(ACE_INET_Addr const& addr)
{
char buf[ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 16];
addr.addr_to_string(buf, ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 16);
return buf;
}
bool IsIPAddrInNetwork(ACE_INET_Addr const& net, ACE_INET_Addr const& addr, ACE_INET_Addr const& subnetMask)
{
uint32 mask = subnetMask.get_ip_address();
src/server/shared/Utilities/Util.h
-3
View File
@@ -351,9 +351,6 @@ bool IsIPAddress(char const* ipaddress);
/// Checks if address belongs to the a network with specified submask
bool IsIPAddrInNetwork(ACE_INET_Addr const& net, ACE_INET_Addr const& addr, ACE_INET_Addr const& subnetMask);
/// Transforms ACE_INET_Addr address into string format "dotted_ip:port"
std::string GetAddressString(ACE_INET_Addr const& addr);
uint32 CreatePIDFile(const std::string& filename);
std::string ByteArrayToHexStr(uint8 const* bytes, uint32 length, bool reverse = false);
src/server/worldserver/CommandLine/CliRunnable.cpp
+1 -1
View File
@@ -131,7 +131,7 @@ int kb_hit_return()
#endif
/// %Thread start
void CliRunnable::run()
void CliThread()
{
///- Display the list of available CLI functions then beep
//TC_LOG_INFO("server.worldserver", "");
src/server/worldserver/CommandLine/CliRunnable.h
+1 -6
View File
@@ -23,12 +23,7 @@
#ifndef __CLIRUNNABLE_H
#define __CLIRUNNABLE_H
/// Command Line Interface handling thread
class CliRunnable : public ACE_Based::Runnable
{
public:
void run() override;
};
void CliThread();
#endif
src/server/worldserver/Master.cpp
+44 -64
View File
@@ -20,6 +20,8 @@
\ingroup Trinityd
*/
#include <thread>
#include <ace/Sig_Handler.h>
#include "Common.h"
@@ -78,51 +80,35 @@ class WorldServerSignalHandler : public Trinity::SignalHandler
}
};
class FreezeDetectorRunnable : public ACE_Based::Runnable
void FreezeDetectorThread(uint32 delayTime)
{
private:
uint32 _loops;
uint32 _lastChange;
uint32 _delaytime;
public:
FreezeDetectorRunnable()
if (!delayTime)
return;
TC_LOG_INFO("server.worldserver", "Starting up anti-freeze thread (%u seconds max stuck time)...", delayTime / 1000);
uint32 loops = 0;
uint32 lastChange = 0;
while (!World::IsStopped())
{
_loops = 0;
_lastChange = 0;
_delaytime = 0;
}
void SetDelayTime(uint32 t) { _delaytime = t; }
void run() override
{
if (!_delaytime)
return;
TC_LOG_INFO("server.worldserver", "Starting up anti-freeze thread (%u seconds max stuck time)...", _delaytime/1000);
_loops = 0;
_lastChange = 0;
while (!World::IsStopped())
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
uint32 curtime = getMSTime();
// normal work
uint32 worldLoopCounter = World::m_worldLoopCounter.value();
if (loops != worldLoopCounter)
{
ACE_Based::Thread::Sleep(1000);
uint32 curtime = getMSTime();
// normal work
uint32 worldLoopCounter = World::m_worldLoopCounter.value();
if (_loops != worldLoopCounter)
{
_lastChange = curtime;
_loops = worldLoopCounter;
}
// possible freeze
else if (getMSTimeDiff(_lastChange, curtime) > _delaytime)
{
TC_LOG_ERROR("server.worldserver", "World Thread hangs, kicking out server!");
ASSERT(false);
}
lastChange = curtime;
loops = worldLoopCounter;
}
// possible freeze
else if (getMSTimeDiff(lastChange, curtime) > delayTime)
{
TC_LOG_ERROR("server.worldserver", "World Thread hangs, kicking out server!");
ASSERT(false);
}
TC_LOG_INFO("server.worldserver", "Anti-freeze thread exiting without problems.");
}
};
TC_LOG_INFO("server.worldserver", "Anti-freeze thread exiting without problems.");
}
/// Main function
int Master::Run()
@@ -182,10 +168,10 @@ int Master::Run()
#endif
///- Launch WorldRunnable thread
ACE_Based::Thread worldThread(new WorldRunnable);
worldThread.setPriority(ACE_Based::Highest);
ACE_Based::Thread* cliThread = NULL;
std::thread worldThread(WorldThread);
std::thread* cliThread = NULL;
#ifdef _WIN32
if (sConfigMgr->GetBoolDefault("Console.Enable", true) && (m_ServiceStatus == -1)/* need disable console in service mode*/)
@@ -194,10 +180,10 @@ int Master::Run()
#endif
{
///- Launch CliRunnable thread
cliThread = new ACE_Based::Thread(new CliRunnable);
cliThread = new std::thread(CliThread);
}
ACE_Based::Thread rarThread(new RARunnable);
std::thread rarThread(RemoteAccessThread);
#if defined(_WIN32) || defined(__linux__)
@@ -268,22 +254,19 @@ int Master::Run()
#endif
//Start soap serving thread
ACE_Based::Thread* soapThread = NULL;
std::thread* soapThread = nullptr;
if (sConfigMgr->GetBoolDefault("SOAP.Enabled", false))
{
TCSoapRunnable* runnable = new TCSoapRunnable();
runnable->SetListenArguments(sConfigMgr->GetStringDefault("SOAP.IP", "127.0.0.1"), uint16(sConfigMgr->GetIntDefault("SOAP.Port", 7878)));
soapThread = new ACE_Based::Thread(runnable);
soapThread = new std::thread(TCSoapThread, sConfigMgr->GetStringDefault("SOAP.IP", "127.0.0.1"), uint16(sConfigMgr->GetIntDefault("SOAP.Port", 7878)));
}
std::thread* freezeDetectorThread = nullptr;
///- Start up freeze catcher thread
if (uint32 freezeDelay = sConfigMgr->GetIntDefault("MaxCoreStuckTime", 0))
{
FreezeDetectorRunnable* fdr = new FreezeDetectorRunnable();
fdr->SetDelayTime(freezeDelay * 1000);
ACE_Based::Thread freezeThread(fdr);
freezeThread.setPriority(ACE_Based::Highest);
freezeDetectorThread = new std::thread(FreezeDetectorThread, freezeDelay);
}
///- Launch the world listener socket
@@ -304,13 +287,12 @@ int Master::Run()
// when the main thread closes the singletons get unloaded
// since worldrunnable uses them, it will crash if unloaded after master
worldThread.wait();
rarThread.wait();
worldThread.join();
//rarThread.join();
if (soapThread)
if (soapThread != nullptr)
{
soapThread->wait();
soapThread->destroy();
soapThread->join();
delete soapThread;
}
@@ -324,7 +306,7 @@ int Master::Run()
TC_LOG_INFO("server.worldserver", "Halting process...");
if (cliThread)
if (cliThread != nullptr)
{
#ifdef _WIN32
@@ -363,17 +345,15 @@ int Master::Run()
DWORD numb;
WriteConsoleInput(hStdIn, b, 4, &numb);
cliThread->wait();
#else
cliThread->destroy();
cliThread->join();
#endif
delete cliThread;
}
delete freezeDetectorThread;
// for some unknown reason, unloading scripts here and not in worldrunnable
// fixes a memory leak related to detaching threads from the module
//UnloadScriptingModule();
src/server/worldserver/RemoteAccess/RARunnable.cpp
+12 -16
View File
@@ -33,29 +33,22 @@
#include "RASocket.h"
RARunnable::RARunnable()
void RemoteAccessThread()
{
ACE_Reactor_Impl* imp;
ACE_Reactor_Impl* imp = nullptr;
#if defined (ACE_HAS_EVENT_POLL) || defined (ACE_HAS_DEV_POLL)
imp = new ACE_Dev_Poll_Reactor();
imp->max_notify_iterations (128);
imp->restart (1);
imp->max_notify_iterations(128);
imp->restart(1);
#else
imp = new ACE_TP_Reactor();
imp->max_notify_iterations (128);
imp->max_notify_iterations(128);
#endif
m_Reactor = new ACE_Reactor (imp, 1);
}
ACE_Reactor* reactor = new ACE_Reactor(imp, 1);
RARunnable::~RARunnable()
{
delete m_Reactor;
}
void RARunnable::run()
{
if (!sConfigMgr->GetBoolDefault("Ra.Enable", false))
return;
@@ -65,7 +58,7 @@ void RARunnable::run()
std::string stringIp = sConfigMgr->GetStringDefault("Ra.IP", "0.0.0.0");
ACE_INET_Addr listenAddress(raPort, stringIp.c_str());
if (acceptor.open(listenAddress, m_Reactor) == -1)
if (acceptor.open(listenAddress, reactor) == -1)
{
TC_LOG_ERROR("server.worldserver", "Trinity RA can not bind to port %d on %s", raPort, stringIp.c_str());
return;
@@ -76,9 +69,12 @@ void RARunnable::run()
while (!World::IsStopped())
{
ACE_Time_Value interval(0, 100000);
if (m_Reactor->run_reactor_event_loop(interval) == -1)
if (reactor->run_reactor_event_loop(interval) == -1)
break;
}
delete imp;
delete reactor;
TC_LOG_DEBUG("server.worldserver", "Trinity RA thread exiting");
}
src/server/worldserver/RemoteAccess/RARunnable.h
+1 -15
View File
@@ -22,21 +22,7 @@
#ifndef _TRINITY_RARUNNABLE_H_
#define _TRINITY_RARUNNABLE_H_
#include "Common.h"
#include <ace/Reactor.h>
class RARunnable : public ACE_Based::Runnable
{
public:
RARunnable();
virtual ~RARunnable();
void run() override;
private:
ACE_Reactor* m_Reactor;
};
void RemoteAccessThread();
#endif /* _TRINITY_RARUNNABLE_H_ */
src/server/worldserver/TCSoap/TCSoap.cpp
+5 -5
View File
@@ -22,7 +22,7 @@
#include "AccountMgr.h"
#include "Log.h"
void TCSoapRunnable::run()
void TCSoapThread(const std::string& host, uint16 port)
{
struct soap soap;
soap_init(&soap);
@@ -33,13 +33,13 @@ void TCSoapRunnable::run()
soap.accept_timeout = 3;
soap.recv_timeout = 5;
soap.send_timeout = 5;
if (!soap_valid_socket(soap_bind(&soap, _host.c_str(), _port, 100)))
if (!soap_valid_socket(soap_bind(&soap, host.c_str(), port, 100)))
{
TC_LOG_ERROR("network.soap", "Couldn't bind to %s:%d", _host.c_str(), _port);
TC_LOG_ERROR("network.soap", "Couldn't bind to %s:%d", host.c_str(), port);
exit(-1);
}
TC_LOG_INFO("network.soap", "Bound to http://%s:%d", _host.c_str(), _port);
TC_LOG_INFO("network.soap", "Bound to http://%s:%d", host.c_str(), port);
while (!World::IsStopped())
{
@@ -57,7 +57,7 @@ void TCSoapRunnable::run()
soap_done(&soap);
}
void TCSoapRunnable::process_message(ACE_Message_Block* mb)
void process_message(ACE_Message_Block* mb)
{
ACE_TRACE (ACE_TEXT ("SOAPWorkingThread::process_message"));
src/server/worldserver/TCSoap/TCSoap.h
+2 -20
View File
@@ -22,27 +22,9 @@
#include <ace/Semaphore.h>
#include <ace/Task.h>
#include <Threading.h>
class TCSoapRunnable : public ACE_Based::Runnable
{
public:
TCSoapRunnable() : _port(0) { }
void run() override;
void SetListenArguments(const std::string& host, uint16 port)
{
_host = host;
_port = port;
}
private:
void process_message(ACE_Message_Block* mb);
std::string _host;
uint16 _port;
};
void process_message(ACE_Message_Block* mb);
void TCSoapThread(const std::string& host, uint16 port);
class SOAPCommand
{
src/server/worldserver/WorldThread/WorldRunnable.cpp
+5 -2
View File
@@ -20,6 +20,8 @@
\ingroup Trinityd
*/
#include <thread>
#include "Common.h"
#include "ObjectAccessor.h"
#include "World.h"
@@ -40,7 +42,7 @@ extern int m_ServiceStatus;
#endif
/// Heartbeat for the World
void WorldRunnable::run()
void WorldThread()
{
uint32 realCurrTime = 0;
uint32 realPrevTime = getMSTime();
@@ -67,7 +69,8 @@ void WorldRunnable::run()
if (diff <= WORLD_SLEEP_CONST+prevSleepTime)
{
prevSleepTime = WORLD_SLEEP_CONST+prevSleepTime-diff;
ACE_Based::Thread::Sleep(prevSleepTime);
std::this_thread::sleep_for(std::chrono::milliseconds(prevSleepTime));
}
else
prevSleepTime = 0;
src/server/worldserver/WorldThread/WorldRunnable.h
+1 -6
View File
@@ -23,12 +23,7 @@
#ifndef __WORLDRUNNABLE_H
#define __WORLDRUNNABLE_H
/// Heartbeat thread for the World
class WorldRunnable : public ACE_Based::Runnable
{
public:
void run() override;
};
void WorldThread();
#endif