diff options
Diffstat (limited to 'ACE/ace/Sched_Params.cpp')
| -rw-r--r-- | ACE/ace/Sched_Params.cpp | 337 |
1 files changed, 337 insertions, 0 deletions
diff --git a/ACE/ace/Sched_Params.cpp b/ACE/ace/Sched_Params.cpp new file mode 100644 index 00000000000..80a89a1abc1 --- /dev/null +++ b/ACE/ace/Sched_Params.cpp @@ -0,0 +1,337 @@ + +//============================================================================= +/** + * @file Sched_Params.cpp + * + * $Id$ + * + * @author David Levine + */ +//============================================================================= + + +#include "ace/Sched_Params.h" + +#if !defined (__ACE_INLINE__) +#include "ace/Sched_Params.inl" +#endif /* __ACE_INLINE__ */ + +#if defined (ACE_HAS_PRIOCNTL) && defined (ACE_HAS_STHREADS) +# include "ace/OS_NS_string.h" +# include /**/ <sys/priocntl.h> +#endif /* ACE_HAS_PRIOCNTL && ACE_HAS_THREADS */ + + + +ACE_BEGIN_VERSIONED_NAMESPACE_DECL + +int +ACE_Sched_Params::priority_min (const Policy policy, + const int scope) +{ +#if defined (ACE_HAS_PRIOCNTL) && defined (ACE_HAS_STHREADS) + ACE_UNUSED_ARG (scope); + + // Assume that ACE_SCHED_OTHER indicates TS class, and that other + // policies indicate RT class. + + // Call ACE_OS::priority_control only for processes (lightweight + // or otherwise). Calling ACE_OS::priority_control for thread + // priorities gives incorrect results. + if (scope == ACE_SCOPE_PROCESS || scope == ACE_SCOPE_LWP) + { + if (policy == ACE_SCHED_OTHER) + { + // Get the priority class ID and attributes. + pcinfo_t pcinfo; + // The following is just to avoid Purify warnings about unitialized + // memory reads. + ACE_OS::memset (&pcinfo, 0, sizeof pcinfo); + ACE_OS::strcpy (pcinfo.pc_clname, "TS"); + + if (ACE_OS::priority_control (P_ALL /* ignored */, + P_MYID /* ignored */, + PC_GETCID, + (char *) &pcinfo) == -1) + // Just hope that priority range wasn't configured from -1 + // .. 1 + return -1; + + // OK, now we've got the class ID in pcinfo.pc_cid. In + // addition, the maximum configured time-share priority is in + // ((tsinfo_t *) pcinfo.pc_clinfo)->ts_maxupri. The minimum + // priority is just the negative of that. + + return -((tsinfo_t *) pcinfo.pc_clinfo)->ts_maxupri; + } + else + return 0; + } + else + { + // Here we handle the case for ACE_SCOPE_THREAD. Calling + // ACE_OS::priority_control for thread scope gives incorrect + // results. + switch (policy) + { + case ACE_SCHED_FIFO: + return ACE_THR_PRI_FIFO_MIN; + case ACE_SCHED_RR: + return ACE_THR_PRI_RR_MIN; + case ACE_SCHED_OTHER: + default: + return ACE_THR_PRI_OTHER_MIN; + } + } +#elif defined(ACE_HAS_PTHREADS) && \ + (!defined(ACE_LACKS_SETSCHED) || defined (ACE_TANDEM_T1248_PTHREADS) || \ + defined (ACE_HAS_PTHREAD_SCHEDPARAM)) + + switch (scope) + { + case ACE_SCOPE_THREAD: + switch (policy) + { + case ACE_SCHED_FIFO: + return ACE_THR_PRI_FIFO_MIN; + case ACE_SCHED_RR: + return ACE_THR_PRI_RR_MIN; + case ACE_SCHED_OTHER: + default: + return ACE_THR_PRI_OTHER_MIN; + } + + case ACE_SCOPE_PROCESS: + default: + switch (policy) + { + case ACE_SCHED_FIFO: + return ACE_PROC_PRI_FIFO_MIN; + case ACE_SCHED_RR: + return ACE_PROC_PRI_RR_MIN; + case ACE_SCHED_OTHER: + default: + return ACE_PROC_PRI_OTHER_MIN; + } + } + +#elif defined (ACE_HAS_WTHREADS) && !defined (ACE_HAS_WINCE) + ACE_UNUSED_ARG (policy); + ACE_UNUSED_ARG (scope); + return THREAD_PRIORITY_IDLE; +#elif defined (ACE_HAS_WTHREADS) && defined (ACE_HAS_WINCE) + ACE_UNUSED_ARG (policy); + ACE_UNUSED_ARG (scope); + return 255; +#elif defined (ACE_VXWORKS) + ACE_UNUSED_ARG (policy); + ACE_UNUSED_ARG (scope); +# if defined (VX_TASK_PRIORITY_MAX) + return VX_TASK_PRIORITY_MAX; +# else + return 255; +# endif +#else + ACE_UNUSED_ARG (policy); + ACE_UNUSED_ARG (scope); + ACE_NOTSUP_RETURN (-1); +#endif /* ACE_HAS_PRIOCNTL && defined (ACE_HAS_STHREADS) */ +} + +int +ACE_Sched_Params::priority_max (const Policy policy, + const int scope) +{ +#if defined (ACE_HAS_PRIOCNTL) && defined (ACE_HAS_STHREADS) + ACE_UNUSED_ARG (scope); + + // Call ACE_OS::priority_control only for processes (lightweight + // or otherwise). Calling ACE_OS::priority_control for thread + // priorities gives incorrect results. + if (scope == ACE_SCOPE_PROCESS || scope == ACE_SCOPE_LWP) + { + // Assume that ACE_SCHED_OTHER indicates TS class, and that other + // policies indicate RT class. + + // Get the priority class ID and attributes. + pcinfo_t pcinfo; + // The following is just to avoid Purify warnings about unitialized + // memory reads. + ACE_OS::memset (&pcinfo, 0, sizeof pcinfo); + ACE_OS::strcpy (pcinfo.pc_clname, + policy == ACE_SCHED_OTHER ? "TS" : "RT"); + + if (ACE_OS::priority_control (P_ALL /* ignored */, + P_MYID /* ignored */, + PC_GETCID, + (char *) &pcinfo) == -1) + return -1; + + // OK, now we've got the class ID in pcinfo.pc_cid. In addition, + // the maximum configured real-time priority is in ((rtinfo_t *) + // pcinfo.pc_clinfo)->rt_maxpri, or similarly for the TS class. + + return policy == ACE_SCHED_OTHER + ? ((tsinfo_t *) pcinfo.pc_clinfo)->ts_maxupri + : ((rtinfo_t *) pcinfo.pc_clinfo)->rt_maxpri; + } + else + { + // Here we handle the case for ACE_SCOPE_THREAD. Calling + // ACE_OS::priority_control for thread scope gives incorrect + // results. + switch (policy) + { + case ACE_SCHED_FIFO: + return ACE_THR_PRI_FIFO_MAX; + case ACE_SCHED_RR: + return ACE_THR_PRI_RR_MAX; + case ACE_SCHED_OTHER: + default: + return ACE_THR_PRI_OTHER_MAX; + } + } +#elif defined(ACE_HAS_PTHREADS) && \ + (!defined(ACE_LACKS_SETSCHED) || defined (ACE_TANDEM_T1248_PTHREADS) || \ + defined (ACE_HAS_PTHREAD_SCHEDPARAM)) + + switch (scope) + { + case ACE_SCOPE_THREAD: + switch (policy) + { + case ACE_SCHED_FIFO: + return ACE_THR_PRI_FIFO_MAX; + case ACE_SCHED_RR: + return ACE_THR_PRI_RR_MAX; + case ACE_SCHED_OTHER: + default: + return ACE_THR_PRI_OTHER_MAX; + } + + case ACE_SCOPE_PROCESS: + default: + switch (policy) + { + case ACE_SCHED_FIFO: + return ACE_PROC_PRI_FIFO_MAX; + case ACE_SCHED_RR: + return ACE_PROC_PRI_RR_MAX; + case ACE_SCHED_OTHER: + default: + return ACE_PROC_PRI_OTHER_MAX; + } + } + +#elif defined (ACE_HAS_WTHREADS) && !defined (ACE_HAS_WINCE) + ACE_UNUSED_ARG (policy); + ACE_UNUSED_ARG (scope); + return THREAD_PRIORITY_TIME_CRITICAL; +#elif defined (ACE_HAS_WTHREADS) && defined (ACE_HAS_WINCE) + ACE_UNUSED_ARG (policy); + ACE_UNUSED_ARG (scope); + return 0; +#elif defined (ACE_VXWORKS) + ACE_UNUSED_ARG (policy); + ACE_UNUSED_ARG (scope); +# if defined (VX_TASK_PRIORITY_MIN) + return VX_TASK_PRIORITY_MIN; +# else + return 0; +# endif +#else + ACE_UNUSED_ARG (policy); + ACE_UNUSED_ARG (scope); + ACE_NOTSUP_RETURN (-1); +#endif /* ACE_HAS_PRIOCNTL && defined (ACE_HAS_STHREADS) */ +} + +int +ACE_Sched_Params::next_priority (const Policy policy, + const int priority, + const int scope) +{ +#if defined (ACE_HAS_WTHREADS) && !defined (ACE_HAS_WINCE) + ACE_UNUSED_ARG (policy); + ACE_UNUSED_ARG (scope); + switch (priority) + { + case THREAD_PRIORITY_IDLE: + return THREAD_PRIORITY_LOWEST; + case THREAD_PRIORITY_LOWEST: + return THREAD_PRIORITY_BELOW_NORMAL; + case THREAD_PRIORITY_BELOW_NORMAL: + return THREAD_PRIORITY_NORMAL; + case THREAD_PRIORITY_NORMAL: + return THREAD_PRIORITY_ABOVE_NORMAL; + case THREAD_PRIORITY_ABOVE_NORMAL: + return THREAD_PRIORITY_HIGHEST; + case THREAD_PRIORITY_HIGHEST: + return THREAD_PRIORITY_TIME_CRITICAL; + case THREAD_PRIORITY_TIME_CRITICAL: + return THREAD_PRIORITY_TIME_CRITICAL; + default: + return priority; // unknown priority: should never get here + } +#elif defined(ACE_HAS_THREADS) && \ + (!defined(ACE_LACKS_SETSCHED) || defined (ACE_TANDEM_T1248_PTHREADS) || \ + defined (ACE_HAS_PTHREAD_SCHEDPARAM)) + // including STHREADS, and PTHREADS + int const max = priority_max (policy, scope); + return priority < max ? priority + 1 : max; +#elif defined (ACE_VXWORKS) || defined (ACE_HAS_WINCE) + int const max = priority_max (policy, scope); + return priority > max ? priority - 1 : max; +#else + ACE_UNUSED_ARG (policy); + ACE_UNUSED_ARG (scope); + ACE_UNUSED_ARG (priority); + ACE_NOTSUP_RETURN (-1); +#endif /* ACE_HAS_THREADS */ +} + +int +ACE_Sched_Params::previous_priority (const Policy policy, + const int priority, + const int scope) +{ +#if defined (ACE_HAS_WTHREADS) && !defined (ACE_HAS_WINCE) + ACE_UNUSED_ARG (policy); + ACE_UNUSED_ARG (scope); + switch (priority) + { + case THREAD_PRIORITY_IDLE: + return THREAD_PRIORITY_IDLE; + case THREAD_PRIORITY_LOWEST: + return THREAD_PRIORITY_IDLE; + case THREAD_PRIORITY_BELOW_NORMAL: + return THREAD_PRIORITY_LOWEST; + case THREAD_PRIORITY_NORMAL: + return THREAD_PRIORITY_BELOW_NORMAL; + case THREAD_PRIORITY_ABOVE_NORMAL: + return THREAD_PRIORITY_NORMAL; + case THREAD_PRIORITY_HIGHEST: + return THREAD_PRIORITY_ABOVE_NORMAL; + case THREAD_PRIORITY_TIME_CRITICAL: + return THREAD_PRIORITY_HIGHEST; + default: + return priority; // unknown priority: should never get here + } +#elif defined(ACE_HAS_THREADS) && \ + (!defined(ACE_LACKS_SETSCHED) || defined (ACE_TANDEM_T1248_PTHREADS) || \ + defined (ACE_HAS_PTHREAD_SCHEDPARAM)) + // including STHREADS and PTHREADS + int const min = priority_min (policy, scope); + return priority > min ? priority - 1 : min; +#elif defined (ACE_VXWORKS) || defined (ACE_HAS_WINCE) + int const min = priority_min (policy, scope); + return priority < min ? priority + 1 : min; +#else + ACE_UNUSED_ARG (policy); + ACE_UNUSED_ARG (scope); + ACE_UNUSED_ARG (priority); + ACE_NOTSUP_RETURN (-1); +#endif /* ACE_HAS_THREADS */ +} + +ACE_END_VERSIONED_NAMESPACE_DECL |