Rewritten Threading system using c++11 std instead of ACE
It also allow full compilation with clang under all supported platforms Need tests
This commit is contained in:
Yehonal
parent
3761e9d843
commit
ea286f7332
14 changed files with 104 additions and 249 deletions
|
|
@ -6,218 +6,100 @@
|
|||
|
||||
#include "Threading.h"
|
||||
#include "Errors.h"
|
||||
#include <ace/OS_NS_unistd.h>
|
||||
#include <ace/Sched_Params.h>
|
||||
#include <vector>
|
||||
|
||||
using namespace ACE_Based;
|
||||
#include <chrono>
|
||||
#include <system_error>
|
||||
|
||||
ThreadPriority::ThreadPriority()
|
||||
using namespace ACORE;
|
||||
|
||||
Thread::Thread() : m_task(nullptr), m_iThreadId(), m_ThreadImp()
|
||||
{
|
||||
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
|
||||
Thread::Thread(Runnable* instance) : m_task(instance), m_ThreadImp(&Thread::ThreadTask, (void*)m_task)
|
||||
{
|
||||
if (p < Idle)
|
||||
p = Idle;
|
||||
m_iThreadId = m_ThreadImp.get_id();
|
||||
|
||||
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();
|
||||
// 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()
|
||||
bool Thread::wait()
|
||||
{
|
||||
if (m_task == 0 || m_iThreadId != 0)
|
||||
if (m_iThreadId == std::thread::id() || !m_task)
|
||||
return false;
|
||||
|
||||
// incRef before spawing the thread, otherwise Thread::ThreadTask() might call decRef and delete m_task
|
||||
m_task->incReference();
|
||||
bool res = true;
|
||||
|
||||
bool res = (ACE_Thread::spawn(&Thread::ThreadTask, (void*)m_task, THREADFLAG, &m_iThreadId, &m_hThreadHandle) == 0);
|
||||
try
|
||||
{
|
||||
m_ThreadImp.join();
|
||||
}
|
||||
catch (std::system_error&)
|
||||
{
|
||||
res = false;
|
||||
}
|
||||
|
||||
if (!res)
|
||||
m_task->decReference();
|
||||
m_iThreadId = std::thread::id();
|
||||
|
||||
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)
|
||||
if (m_iThreadId == std::thread::id() || !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();
|
||||
// FIXME: We need to make sure that all threads can be trusted to
|
||||
// halt execution on their own as this is not an interrupt
|
||||
m_ThreadImp.join();
|
||||
m_iThreadId = std::thread::id();
|
||||
}
|
||||
|
||||
void Thread::suspend()
|
||||
{
|
||||
ACE_Thread::suspend(m_hThreadHandle);
|
||||
}
|
||||
|
||||
void Thread::resume()
|
||||
{
|
||||
ACE_Thread::resume(m_hThreadHandle);
|
||||
}
|
||||
|
||||
ACE_THR_FUNC_RETURN Thread::ThreadTask(void * param)
|
||||
void 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()
|
||||
std::thread::id Thread::currentId()
|
||||
{
|
||||
return ACE_Thread::self();
|
||||
return std::this_thread::get_id();
|
||||
}
|
||||
|
||||
ACE_hthread_t Thread::currentHandle()
|
||||
void Thread::setPriority(Priority priority)
|
||||
{
|
||||
ACE_hthread_t _handle;
|
||||
ACE_Thread::self(_handle);
|
||||
std::thread::native_handle_type handle = m_ThreadImp.native_handle();
|
||||
bool _ok = true;
|
||||
#ifdef WIN32
|
||||
|
||||
return _handle;
|
||||
}
|
||||
|
||||
Thread * Thread::current()
|
||||
{
|
||||
Thread * _thread = m_ThreadStorage.ts_object();
|
||||
if (!_thread)
|
||||
switch (priority)
|
||||
{
|
||||
_thread = new Thread();
|
||||
_thread->m_iThreadId = Thread::currentId();
|
||||
_thread->m_hThreadHandle = Thread::currentHandle();
|
||||
|
||||
Thread * _oldValue = m_ThreadStorage.ts_object(_thread);
|
||||
if (_oldValue)
|
||||
delete _oldValue;
|
||||
case Priority_Realtime: _ok = SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL); break;
|
||||
case Priority_Highest: _ok = SetThreadPriority(handle, THREAD_PRIORITY_HIGHEST); break;
|
||||
case Priority_High: _ok = SetThreadPriority(handle, THREAD_PRIORITY_ABOVE_NORMAL); break;
|
||||
case Priority_Normal: _ok = SetThreadPriority(handle, THREAD_PRIORITY_NORMAL); break;
|
||||
case Priority_Low: _ok = SetThreadPriority(handle, THREAD_PRIORITY_BELOW_NORMAL); break;
|
||||
case Priority_Lowest: _ok = SetThreadPriority(handle, THREAD_PRIORITY_LOWEST); break;
|
||||
case Priority_Idle: _ok = SetThreadPriority(handle, THREAD_PRIORITY_IDLE); break;
|
||||
}
|
||||
#endif
|
||||
|
||||
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);
|
||||
// remove this ASSERT in case you don't want to know is thread priority change was successful or not
|
||||
ASSERT(_ok);
|
||||
}
|
||||
|
||||
void Thread::Sleep(unsigned long msecs)
|
||||
{
|
||||
ACE_OS::sleep(ACE_Time_Value(0, 1000 * msecs));
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(msecs));
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue