ACE/ace/Sched_Params.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    Sched_Params.cpp
   5  *
   6  *  @author David Levine
   7  */
   8 //=============================================================================
   9
  10
  11 #include "ace/Sched_Params.h"
  12
  13 #if !defined (__ACE_INLINE__)
  14 #include "ace/Sched_Params.inl"
  15 #endif /* __ACE_INLINE__ */
  16
  17 #if defined (ACE_HAS_PRIOCNTL) && defined (ACE_HAS_STHREADS)
  18 #  include "ace/OS_NS_string.h"
  19 #  include /**/ <sys/priocntl.h>
  20 #endif /* ACE_HAS_PRIOCNTL && ACE_HAS_THREADS */
  21
  22
  23
  24 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  25
  26 int
  27 ACE_Sched_Params::priority_min (const Policy policy,
  28                                 const int scope)
  29 {
  30 #if defined (ACE_HAS_PRIOCNTL) && defined (ACE_HAS_STHREADS)
  31   ACE_UNUSED_ARG (scope);
  32
  33   // Assume that ACE_SCHED_OTHER indicates TS class, and that other
  34   // policies indicate RT class.
  35
  36   // Call ACE_OS::priority_control only for processes (lightweight
  37   // or otherwise). Calling ACE_OS::priority_control for thread
  38   // priorities gives incorrect results.
  39   if (scope == ACE_SCOPE_PROCESS || scope == ACE_SCOPE_LWP)
  40     {
  41       if (policy == ACE_SCHED_OTHER)
  42         {
  43           // Get the priority class ID and attributes.
  44           pcinfo_t pcinfo;
  45           // The following is just to avoid Purify warnings about unitialized
  46           // memory reads.
  47           ACE_OS::memset (&pcinfo, 0, sizeof pcinfo);
  48           ACE_OS::strcpy (pcinfo.pc_clname, "TS");
  49
  50           if (ACE_OS::priority_control (P_ALL /* ignored */,
  51                                         P_MYID /* ignored */,
  52                                         PC_GETCID,
  53                                         (char *) &pcinfo) == -1)
  54             // Just hope that priority range wasn't configured from -1
  55             // .. 1
  56             return -1;
  57
  58           // OK, now we've got the class ID in pcinfo.pc_cid.  In
  59           // addition, the maximum configured time-share priority is in
  60           // ((tsinfo_t *) pcinfo.pc_clinfo)->ts_maxupri.  The minimum
  61           // priority is just the negative of that.
  62
  63           return -((tsinfo_t *) pcinfo.pc_clinfo)->ts_maxupri;
  64         }
  65       else
  66         return 0;
  67     }
  68   else
  69     {
  70       // Here we handle the case for ACE_SCOPE_THREAD. Calling
  71       // ACE_OS::priority_control for thread scope gives incorrect
  72       // results.
  73       switch (policy)
  74         {
  75         case ACE_SCHED_FIFO:
  76           return ACE_THR_PRI_FIFO_MIN;
  77         case ACE_SCHED_RR:
  78           return ACE_THR_PRI_RR_MIN;
  79         case ACE_SCHED_OTHER:
  80         default:
  81           return ACE_THR_PRI_OTHER_MIN;
  82         }
  83     }
  84 #elif defined(ACE_HAS_PTHREADS) && \
  85       (!defined(ACE_LACKS_SETSCHED))
  86   switch (scope)
  87     {
  88     case ACE_SCOPE_THREAD:
  89       switch (policy)
  90         {
  91           case ACE_SCHED_FIFO:
  92             return ACE_THR_PRI_FIFO_MIN;
  93           case ACE_SCHED_RR:
  94             return ACE_THR_PRI_RR_MIN;
  95           case ACE_SCHED_OTHER:
  96           default:
  97             return ACE_THR_PRI_OTHER_MIN;
  98         }
  99
 100     case ACE_SCOPE_PROCESS:
 101     default:
 102       switch (policy)
 103         {
 104           case ACE_SCHED_FIFO:
 105             return ACE_PROC_PRI_FIFO_MIN;
 106           case ACE_SCHED_RR:
 107             return ACE_PROC_PRI_RR_MIN;
 108           case ACE_SCHED_OTHER:
 109           default:
 110             return ACE_PROC_PRI_OTHER_MIN;
 111         }
 112     }
 113
 114 #elif defined (ACE_HAS_WTHREADS) && !defined (ACE_HAS_WINCE)
 115   ACE_UNUSED_ARG (policy);
 116   ACE_UNUSED_ARG (scope);
 117   return THREAD_PRIORITY_IDLE;
 118 #elif defined (ACE_HAS_WTHREADS) && defined (ACE_HAS_WINCE)
 119   ACE_UNUSED_ARG (policy);
 120   ACE_UNUSED_ARG (scope);
 121   return 255;
 122 #elif defined (ACE_VXWORKS)
 123   ACE_UNUSED_ARG (policy);
 124   ACE_UNUSED_ARG (scope);
 125 # if defined (VX_TASK_PRIORITY_MAX)
 126   return VX_TASK_PRIORITY_MAX;
 127 # else
 128   return 255;
 129 # endif
 130 #else
 131   ACE_UNUSED_ARG (policy);
 132   ACE_UNUSED_ARG (scope);
 133   ACE_NOTSUP_RETURN (-1);
 134 #endif /* ACE_HAS_PRIOCNTL && defined (ACE_HAS_STHREADS) */
 135 }
 136
 137 int
 138 ACE_Sched_Params::priority_max (const Policy policy,
 139                                 const int scope)
 140 {
 141 #if defined (ACE_HAS_PRIOCNTL) && defined (ACE_HAS_STHREADS)
 142   ACE_UNUSED_ARG (scope);
 143
 144   // Call ACE_OS::priority_control only for processes (lightweight
 145   // or otherwise). Calling ACE_OS::priority_control for thread
 146   // priorities gives incorrect results.
 147   if (scope == ACE_SCOPE_PROCESS || scope == ACE_SCOPE_LWP)
 148     {
 149       // Assume that ACE_SCHED_OTHER indicates TS class, and that other
 150       // policies indicate RT class.
 151
 152       // Get the priority class ID and attributes.
 153       pcinfo_t pcinfo;
 154       // The following is just to avoid Purify warnings about unitialized
 155       // memory reads.
 156       ACE_OS::memset (&pcinfo, 0, sizeof pcinfo);
 157       ACE_OS::strcpy (pcinfo.pc_clname,
 158                       policy == ACE_SCHED_OTHER  ?  "TS"  :  "RT");
 159
 160       if (ACE_OS::priority_control (P_ALL /* ignored */,
 161                                     P_MYID /* ignored */,
 162                                     PC_GETCID,
 163                                     (char *) &pcinfo) == -1)
 164         return -1;
 165
 166       // OK, now we've got the class ID in pcinfo.pc_cid.  In addition,
 167       // the maximum configured real-time priority is in ((rtinfo_t *)
 168       // pcinfo.pc_clinfo)->rt_maxpri, or similarly for the TS class.
 169
 170       return policy == ACE_SCHED_OTHER
 171         ? ((tsinfo_t *) pcinfo.pc_clinfo)->ts_maxupri
 172         : ((rtinfo_t *) pcinfo.pc_clinfo)->rt_maxpri;
 173     }
 174   else
 175     {
 176       // Here we handle the case for ACE_SCOPE_THREAD. Calling
 177       // ACE_OS::priority_control for thread scope gives incorrect
 178       // results.
 179       switch (policy)
 180         {
 181         case ACE_SCHED_FIFO:
 182           return ACE_THR_PRI_FIFO_MAX;
 183         case ACE_SCHED_RR:
 184           return ACE_THR_PRI_RR_MAX;
 185         case ACE_SCHED_OTHER:
 186         default:
 187           return ACE_THR_PRI_OTHER_MAX;
 188         }
 189     }
 190 #elif defined(ACE_HAS_PTHREADS) && \
 191       (!defined(ACE_LACKS_SETSCHED) || \
 192        defined (ACE_HAS_PTHREAD_SCHEDPARAM))
 193
 194   switch (scope)
 195     {
 196     case ACE_SCOPE_THREAD:
 197       switch (policy)
 198         {
 199           case ACE_SCHED_FIFO:
 200             return ACE_THR_PRI_FIFO_MAX;
 201           case ACE_SCHED_RR:
 202             return ACE_THR_PRI_RR_MAX;
 203           case ACE_SCHED_OTHER:
 204           default:
 205             return ACE_THR_PRI_OTHER_MAX;
 206         }
 207
 208     case ACE_SCOPE_PROCESS:
 209     default:
 210       switch (policy)
 211         {
 212           case ACE_SCHED_FIFO:
 213             return ACE_PROC_PRI_FIFO_MAX;
 214           case ACE_SCHED_RR:
 215             return ACE_PROC_PRI_RR_MAX;
 216           case ACE_SCHED_OTHER:
 217           default:
 218             return ACE_PROC_PRI_OTHER_MAX;
 219         }
 220     }
 221
 222 #elif defined (ACE_HAS_WTHREADS) && !defined (ACE_HAS_WINCE)
 223   ACE_UNUSED_ARG (policy);
 224   ACE_UNUSED_ARG (scope);
 225   return THREAD_PRIORITY_TIME_CRITICAL;
 226 #elif defined (ACE_HAS_WTHREADS) && defined (ACE_HAS_WINCE)
 227   ACE_UNUSED_ARG (policy);
 228   ACE_UNUSED_ARG (scope);
 229   return 0;
 230 #elif defined (ACE_VXWORKS)
 231   ACE_UNUSED_ARG (policy);
 232   ACE_UNUSED_ARG (scope);
 233 # if defined (VX_TASK_PRIORITY_MIN)
 234   return VX_TASK_PRIORITY_MIN;
 235 # else
 236   return 0;
 237 # endif
 238 #else
 239   ACE_UNUSED_ARG (policy);
 240   ACE_UNUSED_ARG (scope);
 241   ACE_NOTSUP_RETURN (-1);
 242 #endif /* ACE_HAS_PRIOCNTL && defined (ACE_HAS_STHREADS) */
 243 }
 244
 245 int
 246 ACE_Sched_Params::next_priority (const Policy policy,
 247                                  const int priority,
 248                                  const int scope)
 249 {
 250 #if defined (ACE_HAS_WTHREADS) && !defined (ACE_HAS_WINCE)
 251   ACE_UNUSED_ARG (policy);
 252   ACE_UNUSED_ARG (scope);
 253   switch (priority)
 254     {
 255       case THREAD_PRIORITY_IDLE:
 256         return THREAD_PRIORITY_LOWEST;
 257       case THREAD_PRIORITY_LOWEST:
 258         return THREAD_PRIORITY_BELOW_NORMAL;
 259       case THREAD_PRIORITY_BELOW_NORMAL:
 260         return THREAD_PRIORITY_NORMAL;
 261       case THREAD_PRIORITY_NORMAL:
 262         return THREAD_PRIORITY_ABOVE_NORMAL;
 263       case THREAD_PRIORITY_ABOVE_NORMAL:
 264         return THREAD_PRIORITY_HIGHEST;
 265       case THREAD_PRIORITY_HIGHEST:
 266         return THREAD_PRIORITY_TIME_CRITICAL;
 267       case THREAD_PRIORITY_TIME_CRITICAL:
 268         return THREAD_PRIORITY_TIME_CRITICAL;
 269       default:
 270         return priority;  // unknown priority:  should never get here
 271     }
 272 #elif defined(ACE_HAS_THREADS) && \
 273       (!defined(ACE_LACKS_SETSCHED) || \
 274        defined (ACE_HAS_PTHREAD_SCHEDPARAM))
 275   // including STHREADS, and PTHREADS
 276   int const max = priority_max (policy, scope);
 277   return priority < max  ?  priority + 1  :  max;
 278 #elif defined (ACE_VXWORKS) || defined (ACE_HAS_WINCE)
 279   int const max = priority_max (policy, scope);
 280   return priority > max ?  priority - 1 :  max;
 281 #else
 282   ACE_UNUSED_ARG (policy);
 283   ACE_UNUSED_ARG (scope);
 284   ACE_UNUSED_ARG (priority);
 285   ACE_NOTSUP_RETURN (-1);
 286 #endif /* ACE_HAS_THREADS */
 287 }
 288
 289 int
 290 ACE_Sched_Params::previous_priority (const Policy policy,
 291                                      const int priority,
 292                                      const int scope)
 293 {
 294 #if defined (ACE_HAS_WTHREADS) && !defined (ACE_HAS_WINCE)
 295   ACE_UNUSED_ARG (policy);
 296   ACE_UNUSED_ARG (scope);
 297   switch (priority)
 298     {
 299       case THREAD_PRIORITY_IDLE:
 300         return THREAD_PRIORITY_IDLE;
 301       case THREAD_PRIORITY_LOWEST:
 302         return THREAD_PRIORITY_IDLE;
 303       case THREAD_PRIORITY_BELOW_NORMAL:
 304         return THREAD_PRIORITY_LOWEST;
 305       case THREAD_PRIORITY_NORMAL:
 306         return THREAD_PRIORITY_BELOW_NORMAL;
 307       case THREAD_PRIORITY_ABOVE_NORMAL:
 308         return THREAD_PRIORITY_NORMAL;
 309       case THREAD_PRIORITY_HIGHEST:
 310         return THREAD_PRIORITY_ABOVE_NORMAL;
 311       case THREAD_PRIORITY_TIME_CRITICAL:
 312         return THREAD_PRIORITY_HIGHEST;
 313       default:
 314         return priority;  // unknown priority:  should never get here
 315     }
 316 #elif defined(ACE_HAS_THREADS) && \
 317       (!defined(ACE_LACKS_SETSCHED) || \
 318        defined (ACE_HAS_PTHREAD_SCHEDPARAM))
 319   // including STHREADS and PTHREADS
 320   int const min = priority_min (policy, scope);
 321   return priority > min ? priority - 1 : min;
 322 #elif defined (ACE_VXWORKS) || defined (ACE_HAS_WINCE)
 323   int const min = priority_min (policy, scope);
 324   return priority < min ?  priority + 1 :  min;
 325 #else
 326   ACE_UNUSED_ARG (policy);
 327   ACE_UNUSED_ARG (scope);
 328   ACE_UNUSED_ARG (priority);
 329   ACE_NOTSUP_RETURN (-1);
 330 #endif /* ACE_HAS_THREADS */
 331 }
 332
 333 ACE_END_VERSIONED_NAMESPACE_DECL