src/shared/Threading.cpp

   1 /*
   2  * Copyright (C) 2009-2010 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 "Errors.h"
  21 #include <ace/OS_NS_unistd.h>
  22 #include <ace/Sched_Params.h>
  23 #include <vector>
  24
  25 using namespace ACE_Based;
  26
  27 ThreadPriority::ThreadPriority()
  28 {
  29     for (int i = Idle; i < MAXPRIORITYNUM; ++i)
  30         m_priority[i] = ACE_THR_PRI_OTHER_DEF;
  31
  32     m_priority[Idle] = ACE_Sched_Params::priority_min(ACE_SCHED_OTHER);
  33     m_priority[Realtime] = ACE_Sched_Params::priority_max(ACE_SCHED_OTHER);
  34
  35     std::vector<int> _tmp;
  36
  37     ACE_Sched_Params::Policy _policy = ACE_SCHED_OTHER;
  38     ACE_Sched_Priority_Iterator pr_iter(_policy);
  39
  40     while (pr_iter.more())
  41     {
  42         _tmp.push_back(pr_iter.priority());
  43         pr_iter.next();
  44     }
  45
  46     ASSERT (!_tmp.empty());
  47
  48     if(_tmp.size() >= MAXPRIORITYNUM)
  49     {
  50         const size_t max_pos = _tmp.size();
  51         size_t min_pos = 1;
  52         size_t norm_pos = 0;
  53         for (size_t i = 0; i < max_pos; ++i)
  54         {
  55             if(_tmp[i] == ACE_THR_PRI_OTHER_DEF)
  56             {
  57                 norm_pos = i + 1;
  58                 break;
  59             }
  60         }
  61
  62         //since we have only 7(seven) values in enum Priority
  63         //and 3 we know already (Idle, Normal, Realtime) so
  64         //we need to split each list [Idle...Normal] and [Normal...Realtime]
  65         //into ¹ piesces
  66         const size_t _divider = 4;
  67         size_t _div = (norm_pos - min_pos) / _divider;
  68         if(_div == 0)
  69             _div = 1;
  70
  71         min_pos = (norm_pos - 1);
  72
  73         m_priority[Low] = _tmp[min_pos -= _div];
  74         m_priority[Lowest] = _tmp[min_pos -= _div ];
  75
  76         _div = (max_pos - norm_pos) / _divider;
  77         if(_div == 0)
  78             _div = 1;
  79
  80         min_pos = norm_pos - 1;
  81
  82         m_priority[High] = _tmp[min_pos += _div];
  83         m_priority[Highest] = _tmp[min_pos += _div];
  84     }
  85 }
  86
  87 int ThreadPriority::getPriority(Priority p) const
  88 {
  89     if(p < Idle)
  90         p = Idle;
  91
  92     if(p > Realtime)
  93         p = Realtime;
  94
  95     return m_priority[p];
  96 }
  97
  98 #ifndef __sun__
  99 # define THREADFLAG (THR_NEW_LWP | THR_JOINABLE | THR_SCHED_DEFAULT)
 100 #else
 101 # define THREADFLAG (THR_NEW_LWP | THR_JOINABLE)
 102 #endif
 103
 104 Thread::Thread() : m_task(0), m_iThreadId(0), m_hThreadHandle(0)
 105 {
 106
 107 }
 108
 109 Thread::Thread(Runnable* instance) : m_task(instance), m_iThreadId(0), m_hThreadHandle(0)
 110 {
 111     // register reference to m_task to prevent it deeltion until destructor
 112     if (m_task)
 113         m_task->incReference();
 114
 115     bool _start = start();
 116     ASSERT (_start);
 117 }
 118
 119 Thread::~Thread()
 120 {
 121     //Wait();
 122
 123     // deleted runnable object (if no other references)
 124     if (m_task)
 125         m_task->decReference();
 126 }
 127
 128 //initialize Thread's class static member
 129 Thread::ThreadStorage Thread::m_ThreadStorage;
 130 ThreadPriority Thread::m_TpEnum;
 131
 132 bool Thread::start()
 133 {
 134     if (m_task == 0 || m_iThreadId != 0)
 135         return false;
 136
 137     bool res = (ACE_Thread::spawn(&Thread::ThreadTask, (void*)m_task, THREADFLAG, &m_iThreadId, &m_hThreadHandle) == 0);
 138
 139     if (res)
 140         m_task->incReference();
 141
 142     return res;
 143 }
 144
 145 bool Thread::wait()
 146 {
 147     if (!m_hThreadHandle || !m_task)
 148         return false;
 149
 150     ACE_THR_FUNC_RETURN _value = ACE_THR_FUNC_RETURN(-1);
 151     int _res = ACE_Thread::join(m_hThreadHandle, &_value);
 152
 153     m_iThreadId = 0;
 154     m_hThreadHandle = 0;
 155
 156     return (_res == 0);
 157 }
 158
 159 void Thread::destroy()
 160 {
 161     if (!m_iThreadId || !m_task)
 162         return;
 163
 164     if (ACE_Thread::kill(m_iThreadId, -1) != 0)
 165         return;
 166
 167     m_iThreadId = 0;
 168     m_hThreadHandle = 0;
 169
 170     // reference set at ACE_Thread::spawn
 171     m_task->decReference();
 172 }
 173
 174 void Thread::suspend()
 175 {
 176     ACE_Thread::suspend(m_hThreadHandle);
 177 }
 178
 179 void Thread::resume()
 180 {
 181     ACE_Thread::resume(m_hThreadHandle);
 182 }
 183
 184 ACE_THR_FUNC_RETURN Thread::ThreadTask(void * param)
 185 {
 186     Runnable * _task = (Runnable*)param;
 187     _task->run();
 188
 189     // task execution complete, free referecne added at
 190     _task->decReference();
 191
 192     return (ACE_THR_FUNC_RETURN)0;
 193 }
 194
 195 ACE_thread_t Thread::currentId()
 196 {
 197     return ACE_Thread::self();
 198 }
 199
 200 ACE_hthread_t Thread::currentHandle()
 201 {
 202     ACE_hthread_t _handle;
 203     ACE_Thread::self(_handle);
 204
 205     return _handle;
 206 }
 207
 208 Thread * Thread::current()
 209 {
 210     Thread * _thread = m_ThreadStorage.ts_object();
 211     if(!_thread)
 212     {
 213         _thread = new Thread();
 214         _thread->m_iThreadId = Thread::currentId();
 215         _thread->m_hThreadHandle = Thread::currentHandle();
 216
 217         Thread * _oldValue = m_ThreadStorage.ts_object(_thread);
 218         if(_oldValue)
 219             delete _oldValue;
 220     }
 221
 222     return _thread;
 223 }
 224
 225 void Thread::setPriority(Priority type)
 226 {
 227 #ifndef __sun__
 228     int _priority = m_TpEnum.getPriority(type);
 229     int _ok = ACE_Thread::setprio(m_hThreadHandle, _priority);
 230     //remove this ASSERT in case you don't want to know is thread priority change was successful or not
 231     ASSERT (_ok == 0);
 232 #endif
 233 }
 234
 235 void Thread::Sleep(unsigned long msecs)
 236 {
 237     ACE_OS::sleep(ACE_Time_Value(0, 1000 * msecs));
 238 }