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; }