int
Suspend_Resume_Test::svc ()
{
#if ACE_DEBUG_CST > 0
ACE_hthread_t thread_id;
ACE_Thread_Manager::instance ()->thr_self (thread_id);
ACE_DEBUG ((LM_DEBUG, "Suspend_Resume_Test::svc (), thread ID is %d\n",
thread_id));
#endif /* ACE_DEBUG_CST */
low_.ready ();
// For information: the cost of the just the loop itself below,
// without the suspend and resume calls, on a 166 MHz Ultrasparc
// is about 12.3 nanoseconds per iteration.
timer_.start ();
for (ACE_UINT32 i = 0; i < iterations_; ++i)
{
#if ACE_DEBUG_CST > 0
if (i % (iterations_ >= 10 ? iterations_ / 10 : 1) == 0)
ACE_DEBUG ((LM_DEBUG, "Suspend_Resume_Test::svc (), iteration %u\n",
i));
#endif /* ACE_DEBUG_CST */
if (ACE_OS::thr_suspend (low_.thread_id ()) != 0)
{
ACE_ERROR ((LM_ERROR, "%p\n", "thr_suspend"));
low_.done ();
return -1;
}
if (ACE_OS::thr_continue (low_.thread_id ()) != 0 &&
errno != EINVAL)
// EINVAL is OK: it just means that the thread needs to be joined.
{
ACE_ERROR ((LM_ERROR, "%p\n", "thr_continue"));
low_.done ();
return -1;
}
}
timer_.stop ();
timer_.elapsed_microseconds (elapsed_time_);
low_.done ();
#if ACE_DEBUG_CST > 0
ACE_DEBUG ((LM_DEBUG, "Suspend_Resume_Test::svc, finishing\n"));
#endif /* ACE_DEBUG_CST */
return 0;
}
static
ACE_Time_Value
time_interval (const ACE_Time_Value &interval,
ACE_hrtime_t& nanoseconds,
ACE_hrtime_t& microseconds)
{
ACE_High_Res_Timer timer;
timer.start ();
ACE_OS::sleep (interval);
timer.stop ();
ACE_Time_Value measured;
timer.elapsed_time (measured);
timer.elapsed_time (nanoseconds);
timer.elapsed_microseconds (microseconds);
return measured;
}
int
Ping_Suspend_Resume_Test::svc ()
{
#if ACE_DEBUG_CST > 0
ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test::svc (), entering"));
ACE_hthread_t thread_id;
ACE_Thread_Manager::instance ()->thr_self (thread_id);
ACE_DEBUG ((LM_DEBUG, "; thread ID is %u\n", thread_id));
#endif /* ACE_DEBUG_CST */
high_.ready ();
#if ACE_DEBUG_CST > 0
int priority, high_priority;
ACE_OS::thr_getprio (thread_id, priority);
ACE_OS::thr_getprio (high_.thread_id (), high_priority);
ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test::svc (), priority is %d, "
", high thread priority is %d\n",
priority, high_priority));
#endif /* ACE_DEBUG_CST */
// For information: the cost of the just the loop itself below,
// without the suspend and resume calls, on a 166 MHz Ultrasparc
// is about 12.3 nanoseconds per iteration.
timer_.start ();
ACE_UINT32 i;
for (i = 0; i < iterations_; ++i)
{
#if ACE_DEBUG_CST > 0
if (i % (iterations_ >= 10 ? iterations_ / 10 : 1) == 0)
{
ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test::svc (), iteration "
"%d, continue high-priority thread %u\n",
i, high_.thread_id ()));
}
#endif /* ACE_DEBUG_CST */
if (ACE_OS::thr_continue (high_.thread_id ()) != 0 &&
errno != EINVAL)
// EINVAL is OK: it just means that the thread needs to be joined.
{
ACE_ERROR ((LM_ERROR, "%p\n", "thr_continue"));
high_.done ();
return -1;
}
}
timer_.stop ();
timer_.elapsed_microseconds (elapsed_time_);
high_.done ();
#if ACE_DEBUG_CST > 0
ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test::svc: told high priority "
"task to terminate\n"));
#endif /* ACE_DEBUG_CST */
// Resume the thread until thr_continue fails, indicating that it has
// finished.
for (i = 0; i < 10000 && ! ACE_OS::thr_continue (high_.thread_id ());
++i) /* null */;
// Don't count the one iteration that was used to allow the high-priority
// thread to terminate.
if (high_.iterations () < iterations_)
ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test: high priority task "
"executed only %u iterations!\n",
high_.iterations ()));
#if ACE_DEBUG_CST > 0
ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test::svc, finishing\n"));
#endif /* ACE_DEBUG_CST */
return 0;
}
