*Backed out changeset 3be01fb200a5

--HG--
branch : trunk

src/shared/Threading.cpp

@@ -15,27 +15,36 @@
  * 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 "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();
@@ -49,6 +58,7 @@ ThreadPriority::ThreadPriority()
                 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]
@@ -57,103 +67,140 @@ ThreadPriority::ThreadPriority()
         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)
 {
     // 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;
+
     bool res = (ACE_Thread::spawn(&Thread::ThreadTask, (void*)m_task, THREADFLAG, &m_iThreadId, &m_hThreadHandle) == 0);
+
     if (res)
         m_task->incReference();
+
     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 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();
@@ -162,12 +209,15 @@ Thread * Thread::current()
         _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);
@@ -175,6 +225,7 @@ void Thread::setPriority(Priority type)
     //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));