src/shared/Threading.cpp

   1 /*
   2  * Copyright (C) 2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "Threading.h"
  20 #include <ace/OS_NS_unistd.h>
  21 #include <ace/Sched_Params.h>
  22 #include <vector>
  23
  24 using namespace ACE_Based;
  25
  26 ThreadPriority::ThreadPriority()
  27 {
  28     for (int i = Idle; i < MAXPRIORITYNUM; ++i)
  29         m_priority[i] = ACE_THR_PRI_OTHER_DEF;
  30
  31     m_priority[Idle] = ACE_Sched_Params::priority_min(ACE_SCHED_OTHER);
  32     m_priority[Realtime] = ACE_Sched_Params::priority_max(ACE_SCHED_OTHER);
  33
  34     std::vector<int> _tmp;
  35
  36     ACE_Sched_Params::Policy _policy = ACE_SCHED_OTHER;
  37     ACE_Sched_Priority_Iterator pr_iter(_policy);
  38
  39     while (pr_iter.more())
  40     {
  41         _tmp.push_back(pr_iter.priority());
  42         pr_iter.next();
  43     }
  44
  45     ASSERT (!_tmp.empty());
  46
  47     if(_tmp.size() >= MAXPRIORITYNUM)
  48     {
  49         const size_t max_pos = _tmp.size();
  50         size_t min_pos = 1;
  51         size_t norm_pos = 0;
  52         for (size_t i = 0; i < max_pos; ++i)
  53         {
  54             if(_tmp[i] == ACE_THR_PRI_OTHER_DEF)
  55             {
  56                 norm_pos = i + 1;
  57                 break;
  58             }
  59         }
  60
  61         //since we have only 7(seven) values in enum Priority
  62         //and 3 we know already (Idle, Normal, Realtime) so
  63         //we need to split each list [Idle...Normal] and [Normal...Realtime]
  64         //into ¹ piesces
  65         const size_t _divider = 4;
  66         size_t _div = (norm_pos - min_pos) / _divider;
  67         if(_div == 0)
  68             _div = 1;
  69
  70         min_pos = (norm_pos - 1);
  71
  72         m_priority[Low] = _tmp[min_pos -= _div];
  73         m_priority[Lowest] = _tmp[min_pos -= _div ];
  74
  75         _div = (max_pos - norm_pos) / _divider;
  76         if(_div == 0)
  77             _div = 1;
  78
  79         min_pos = norm_pos - 1;
  80
  81         m_priority[High] = _tmp[min_pos += _div];
  82         m_priority[Highest] = _tmp[min_pos += _div];
  83     }
  84 }
  85
  86 int ThreadPriority::getPriority(Priority p) const
  87 {
  88     if(p < Idle)
  89         p = Idle;
  90
  91     if(p > Realtime)
  92         p = Realtime;
  93
  94     return m_priority[p];
  95 }
  96
  97 #define THREADFLAG (THR_NEW_LWP | THR_SCHED_DEFAULT| THR_JOINABLE)
  98
  99 Thread::Thread() : m_task(0), m_iThreadId(0), m_hThreadHandle(0)
 100 {
 101
 102 }
 103
 104 Thread::Thread(Runnable& instance) : m_task(&instance), m_iThreadId(0), m_hThreadHandle(0)
 105 {
 106     bool _start = start();
 107     ASSERT (_start);
 108 }
 109
 110 Thread::~Thread()
 111 {
 112     //Wait();
 113 }
 114
 115 //initialize Thread's class static member
 116 Thread::ThreadStorage Thread::m_ThreadStorage;
 117 ThreadPriority Thread::m_TpEnum;
 118
 119 bool Thread::start()
 120 {
 121     if(m_task == 0 || m_iThreadId != 0)
 122         return false;
 123
 124     return (ACE_Thread::spawn(&Thread::ThreadTask, (void*)m_task, THREADFLAG, &m_iThreadId, &m_hThreadHandle) == 0);
 125 }
 126
 127 bool Thread::wait()
 128 {
 129     if(!m_hThreadHandle || !m_task)
 130         return false;
 131
 132     ACE_THR_FUNC_RETURN _value = ACE_THR_FUNC_RETURN(-1);
 133     int _res = ACE_Thread::join(m_hThreadHandle, &_value);
 134
 135     m_iThreadId = 0;
 136     m_hThreadHandle = 0;
 137
 138     return (_res == 0);
 139 }
 140
 141 void Thread::destroy()
 142 {
 143     ACE_Thread::kill(m_iThreadId, -1);
 144 }
 145
 146 void Thread::suspend()
 147 {
 148     ACE_Thread::suspend(m_hThreadHandle);
 149 }
 150
 151 void Thread::resume()
 152 {
 153     ACE_Thread::resume(m_hThreadHandle);
 154 }
 155
 156 ACE_THR_FUNC_RETURN Thread::ThreadTask(void * param)
 157 {
 158     Runnable * _task = (Runnable*)param;
 159     _task->run();
 160
 161     return (ACE_THR_FUNC_RETURN)0;
 162 }
 163
 164 ACE_thread_t Thread::currentId()
 165 {
 166     return ACE_Thread::self();
 167 }
 168
 169 ACE_hthread_t Thread::currentHandle()
 170 {
 171     ACE_hthread_t _handle;
 172     ACE_Thread::self(_handle);
 173
 174     return _handle;
 175 }
 176
 177 Thread * Thread::current()
 178 {
 179     Thread * _thread = m_ThreadStorage.ts_object();
 180     if(!_thread)
 181     {
 182         _thread = new Thread();
 183         _thread->m_iThreadId = Thread::currentId();
 184         _thread->m_hThreadHandle = Thread::currentHandle();
 185
 186         Thread * _oldValue = m_ThreadStorage.ts_object(_thread);
 187         if(_oldValue)
 188             delete _oldValue;
 189     }
 190
 191     return _thread;
 192 }
 193
 194 void Thread::setPriority(Priority type)
 195 {
 196     int _priority = m_TpEnum.getPriority(type);
 197     int _ok = ACE_Thread::setprio(m_hThreadHandle, _priority);
 198     //remove this ASSERT in case you don't want to know is thread priority change was successful or not
 199     ASSERT (_ok == 0);
 200 }
 201
 202 void Thread::Sleep(unsigned long msecs)
 203 {
 204     ACE_OS::sleep(ACE_Time_Value(0, 1000 * msecs));
 205 }