static void post_flow_event(int x, int y, int z, const struct timeval *delay)
{
Event new_ev;
tv_now(&new_ev.base.time);
tv_add_tv(&new_ev.base.time, delay);
new_ev.base.type = EVENT_TYPE_FLOW;
new_ev.flow_event.x = x;
new_ev.flow_event.y = y;
new_ev.flow_event.z = z;
event_push(&new_ev);
}
static void post_grow_event(int x, int y, int z)
{
Event new_ev;
tv_now(&new_ev.base.time);
tv_add_s( &new_ev.base.time, GROW_DELAY_MIN_SEC +
rand()%(GROW_DELAY_MAX_SEC - GROW_DELAY_MIN_SEC + 1) );
new_ev.base.type = EVENT_TYPE_GROW;
new_ev.grow_event.x = x;
new_ev.grow_event.y = y;
new_ev.grow_event.z = z;
event_push(&new_ev);
}
int
run_main (int , ACE_TCHAR *[])
{
ACE_START_TEST (ACE_TEXT ("Monotonic_Task_Test"));
int status = 0;
# if defined (ACE_HAS_THREADS)
MyTask my_task;
if (my_task.start () == 0)
{
// shift back in time 4 sec; this would mess up timeouts if
// monotonic timer was not used
ACE_Time_Value tv_shift (4, 0);
set_system_time (ACE_OS::gettimeofday () - tv_shift);
if (my_task.put_message () == 0)
{
// task should now have finished dequeueing and started waiting for stop signal
// wait (2sec) on thread manager should timeout
// use the time policy aware gettimeofday()
// method of the task to get current time
ACE_Time_Value_T<ACE_Monotonic_Time_Policy> tv (my_task.gettimeofday ());
tv += ACE_Time_Value (2, 0);
// shift another 3 sec back in time; without monotonic timer support in
// thread manager this would mess up the timed wait
tv_shift += ACE_Time_Value (3, 0);
set_system_time (ACE_OS::gettimeofday () - ACE_Time_Value (3,0));
if (my_task.thr_mgr ()->wait (&tv) == 0)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Thread manager did not time out\n")));
status = 1;
}
else
{
ACE_Time_Value_T<ACE_Monotonic_Time_Policy> tv_now (my_task.gettimeofday ());
ACE_DEBUG ((LM_INFO, ACE_TEXT ("Thread manager timed out at %#T\n"), &tv_now));
}
}
else
status = 1;
// ok, now stop task
if (my_task.stop () != 0)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to stop task\n")));
status = 1;
}
// restore time
set_system_time (ACE_OS::gettimeofday () + tv_shift);
}
else
status = 1;
# endif /* ACE_HAS_THREADS */
ACE_END_TEST;
return status;
}
int
MyTask::svc (void)
{
ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%P|%t) MyTask::svc started\n")));
// Now (according to task time policy = monotonic time)
ACE_Time_Value_T<ACE_Monotonic_Time_Policy> tv (this->gettimeofday ());
{
ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%P|%t) MyTask::svc - signalling waiter\n")));
this->cond_.signal (); // signal waiter we have started
// waiter will shift system time back 4 sec after this which would mess
// up the first wait for a message if we were not using monotonic time
}
if (!this->msg_queue ()->is_empty ())
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("New task queue is not empty!\n")));
this->status_ = -1;
}
else
{
ACE_Message_Block *b;
tv += ACE_Time_Value (3,0); // Now + 3 sec
if (this->getq (b, &tv) != -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Dequeued before timeout elapsed!\n")));
this->status_ = -1;
}
else if (errno != EWOULDBLOCK)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("Dequeue timeout should be EWOULDBLOCK, got")));
this->status_ = -1;
}
else
{
ACE_Time_Value_T<ACE_Monotonic_Time_Policy> tv_now (this->gettimeofday ());
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("First getq timed out at %#T (timeout was %#T)\n"), &tv_now, &tv));
tv = this->gettimeofday () + ACE_Time_Value (4,0); // Now (monotonic time) + 3 sec
if (this->getq (b, &tv) != -1)
{
tv_now = tv.now ();
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("Second getq succeeded at %#T\n"), &tv_now));
delete b;
}
else
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Second getq timed out!\n")));
this->status_ = -1;
}
}
}
{
ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%P|%t) MyTask::svc - waiting for stop\n")));
if (!this->stop_)
this->cond_.wait ();
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%t) MyTask finished\n")));
return 0;
}
