ACE/ace/Thread.inl

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