ACE/ace/Thread.inl

   1 // -*- C++ -*-
   2 #include "ace/OS_NS_string.h"
   3
   4 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   5
   6 /// Allocates a @a keyp that is used to identify data that is specific
   7 /// to each thread in the process.  The key is global to all threads in
   8 /// the process.
   9 ACE_INLINE int
  10 ACE_Thread::keycreate (ACE_thread_key_t *keyp,
  11 #if defined (ACE_HAS_THR_C_DEST)
  12                        ACE_THR_C_DEST destructor
  13 #else
  14                        ACE_THR_DEST destructor
  15 #endif /* ACE_HAS_THR_C_DEST */
  16                        )
  17 {
  18   // ACE_TRACE ("ACE_Thread::keycreate");
  19   return ACE_OS::thr_keycreate (keyp, destructor);
  20 }
  21
  22 /// Free up the key so that other threads can reuse it.
  23 ACE_INLINE int
  24 ACE_Thread::keyfree (ACE_thread_key_t key)
  25 {
  26   ACE_TRACE ("ACE_Thread::keyfree");
  27   return ACE_OS::thr_keyfree (key);
  28 }
  29
  30 /// Bind value to the thread-specific data key, @a key, for the calling
  31 /// thread.
  32 ACE_INLINE int
  33 ACE_Thread::setspecific (ACE_thread_key_t key, void *value)
  34 {
  35   // ACE_TRACE ("ACE_Thread::setspecific");
  36   return ACE_OS::thr_setspecific (key, value);
  37 }
  38
  39 /// Stores the current value bound to @a key> for the calling thread
  40 /// into the location pointed to by @a valuep.
  41 ACE_INLINE int
  42 ACE_Thread::getspecific (ACE_thread_key_t key, void **valuep)
  43 {
  44   // ACE_TRACE ("ACE_Thread::getspecific");
  45   return ACE_OS::thr_getspecific (key, valuep);
  46 }
  47
  48 ACE_INLINE ACE_thread_t
  49 ACE_Thread::self ()
  50 {
  51 //  ACE_TRACE ("ACE_Thread::self");
  52   return ACE_OS::thr_self ();
  53 }
  54
  55 ACE_INLINE void
  56 ACE_Thread::exit (ACE_THR_FUNC_RETURN status)
  57 {
  58   ACE_TRACE ("ACE_Thread::exit");
  59   ACE_OS::thr_exit (status);
  60 }
  61
  62 ACE_INLINE void
  63 ACE_Thread::yield ()
  64 {
  65   ACE_TRACE ("ACE_Thread::yield");
  66   ACE_OS::thr_yield ();
  67 }
  68
  69 ACE_INLINE int
  70 ACE_Thread::spawn (ACE_THR_FUNC func,
  71                    void *arg,
  72                    long flags,
  73                    ACE_thread_t *t_id,
  74                    ACE_hthread_t *t_handle,
  75                    long priority,
  76                    void *thr_stack,
  77                    size_t thr_stack_size,
  78                    ACE_Thread_Adapter *thread_adapter,
  79                    const char** thr_name)
  80 {
  81   ACE_TRACE ("ACE_Thread::spawn");
  82
  83   return ACE_OS::thr_create (func,
  84                              arg,
  85                              flags,
  86                              t_id,
  87                              t_handle,
  88                              priority,
  89                              thr_stack,
  90                              thr_stack_size,
  91                              thread_adapter,
  92                              thr_name);
  93 }
  94
  95 ACE_INLINE int
  96 ACE_Thread::resume (ACE_hthread_t t_id)
  97 {
  98   ACE_TRACE ("ACE_Thread::resume");
  99   return ACE_OS::thr_continue (t_id);
 100 }
 101
 102 ACE_INLINE int
 103 ACE_Thread::suspend (ACE_hthread_t t_id)
 104 {
 105   ACE_TRACE ("ACE_Thread::suspend");
 106   return ACE_OS::thr_suspend (t_id);
 107 }
 108
 109 ACE_INLINE int
 110 ACE_Thread::kill (ACE_thread_t t_id, int signum)
 111 {
 112   ACE_TRACE ("ACE_Thread::kill");
 113   return ACE_OS::thr_kill (t_id, signum);
 114 }
 115
 116 ACE_INLINE int
 117 ACE_Thread::join (ACE_thread_t wait_for,
 118                   ACE_thread_t *departed,
 119                   ACE_THR_FUNC_RETURN *status)
 120 {
 121   ACE_TRACE ("ACE_Thread::join");
 122   return ACE_OS::thr_join (wait_for, departed, status);
 123 }
 124
 125 ACE_INLINE int
 126 ACE_Thread::join (ACE_hthread_t wait_for,
 127                   ACE_THR_FUNC_RETURN *status)
 128 {
 129   ACE_TRACE ("ACE_Thread::join");
 130   return ACE_OS::thr_join (wait_for, status);
 131 }
 132
 133 ACE_INLINE int
 134 ACE_Thread::getconcurrency ()
 135 {
 136   ACE_TRACE ("ACE_Thread::getconcurrency");
 137   return ACE_OS::thr_getconcurrency ();
 138 }
 139
 140 ACE_INLINE int
 141 ACE_Thread::setconcurrency (int new_level)
 142 {
 143   ACE_TRACE ("ACE_Thread::setconcurrency");
 144   return ACE_OS::thr_setconcurrency (new_level);
 145 }
 146
 147 ACE_INLINE int
 148 ACE_Thread::sigsetmask (int how,
 149                         const sigset_t *sigset,
 150                         sigset_t *osigset)
 151 {
 152   ACE_TRACE ("ACE_Thread::sigsetmask");
 153   return ACE_OS::thr_sigsetmask (how, sigset, osigset);
 154 }
 155
 156 ACE_INLINE int
 157 ACE_Thread::disablecancel (struct cancel_state *old_state)
 158 {
 159   ACE_TRACE ("ACE_Thread::disablecancel");
 160   int old_cstate = 0;
 161   int result = ACE_OS::thr_setcancelstate (THR_CANCEL_DISABLE,
 162                                            &old_cstate);
 163   if (result == 0 && old_state != 0)
 164     {
 165       ACE_OS::memset (old_state,
 166                       0,
 167                       sizeof (*old_state));
 168       old_state->cancelstate = old_cstate;
 169     }
 170
 171   return result;
 172 }
 173
 174 ACE_INLINE int
 175 ACE_Thread::enablecancel (struct cancel_state *old_state,
 176                           int flag)
 177 {
 178   ACE_TRACE ("ACE_Thread::enablecancel");
 179   int old_cstate = 0;
 180   int old_ctype = 0;
 181   int result;
 182
 183   result = ACE_OS::thr_setcancelstate (THR_CANCEL_ENABLE,
 184                                        &old_cstate);
 185   if (result != 0)
 186     return result;
 187
 188   result = ACE_OS::thr_setcanceltype (flag,
 189                                       &old_ctype);
 190   if (result != 0)
 191     return result;
 192
 193   if (old_state != 0)
 194     {
 195       old_state->cancelstate = old_cstate;
 196       old_state->canceltype = old_ctype;
 197     }
 198
 199   return 0;
 200 }
 201
 202 ACE_INLINE int
 203 ACE_Thread::setcancelstate (struct cancel_state &new_state,
 204                             struct cancel_state *old_state)
 205 {
 206   ACE_TRACE ("ACE_Thread::setcancelstate");
 207   int old_cstate = 0;
 208   int old_ctype = 0;
 209
 210   if (new_state.cancelstate != 0
 211       && ACE_OS::thr_setcancelstate (new_state.cancelstate,
 212                                      &old_cstate) != 0)
 213     return -1;
 214
 215   if (new_state.canceltype != 0
 216       && ACE_OS::thr_setcanceltype (new_state.canceltype,
 217                                     &old_ctype) != 0)
 218     {
 219       int o_cstate;
 220
 221       ACE_OS::thr_setcancelstate (old_cstate,
 222                                   &o_cstate);
 223       return -1;
 224     }
 225
 226   if (old_state != 0)
 227     {
 228       old_state->cancelstate = old_cstate;
 229       old_state->canceltype = old_ctype;
 230     }
 231
 232   return 0;
 233 }
 234
 235 ACE_INLINE int
 236 ACE_Thread::cancel (ACE_thread_t t_id)
 237 {
 238   ACE_TRACE ("ACE_Thread::cancel");
 239
 240   return ACE_OS::thr_cancel (t_id);
 241 }
 242
 243 ACE_INLINE void
 244 ACE_Thread::testcancel ()
 245 {
 246   ACE_TRACE ("ACE_Thread::testcancel");
 247
 248   ACE_OS::thr_testcancel ();
 249 }
 250
 251 ACE_INLINE void
 252 ACE_Thread::self (ACE_hthread_t &t_id)
 253 {
 254 //  ACE_TRACE ("ACE_Thread::self");
 255   ACE_OS::thr_self (t_id);
 256 }
 257
 258 ACE_INLINE int
 259 ACE_Thread::getprio (ACE_hthread_t ht_id, int &priority)
 260 {
 261   ACE_TRACE ("ACE_Thread::getprio");
 262   return ACE_OS::thr_getprio (ht_id, priority);
 263 }
 264
 265 ACE_INLINE int
 266 ACE_Thread::getprio (ACE_hthread_t ht_id, int &priority, int &policy)
 267 {
 268   ACE_TRACE ("ACE_Thread::getprio");
 269   return ACE_OS::thr_getprio (ht_id, priority, policy);
 270 }
 271
 272 ACE_INLINE int
 273 ACE_Thread::setprio (ACE_hthread_t ht_id, int priority, int policy)
 274 {
 275   ACE_TRACE ("ACE_Thread::setprio");
 276   return ACE_OS::thr_setprio (ht_id, priority, policy);
 277 }
 278
 279 ACE_END_VERSIONED_NAMESPACE_DECL