int run_main (int argc, ACE_TCHAR *argv[])
{
ACE_START_TEST (ACE_TEXT ("Manual_Event_Test"));
#if defined (ACE_HAS_THREADS)
parse_args (argc, argv);
if (ACE_Thread_Manager::instance ()->spawn_n
(static_cast<size_t> (n_workers),
ACE_THR_FUNC (worker),
0,
THR_NEW_LWP) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("spawn_n")),
1);
// gives all workers chance to start
ACE_OS::sleep (5);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("sending pulse ()\n")));
// Release the all workers.
if (evt.pulse () == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("pulse")),
1);
// Wait 2 sec
ACE_OS::sleep (2);
//FUZZ: disable check_for_lack_ACE_OS
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("sending signal ()\n")));
//FUZZ: enable check_for_lack_ACE_OS
// Signal
if (evt.signal () == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("signal")),
1);
ACE_Thread_Manager::instance ()->wait ();
#else
ACE_UNUSED_ARG (argc);
ACE_UNUSED_ARG (argv);
ACE_ERROR ((LM_INFO,
ACE_TEXT ("Threads not supported on this platform\n")));
#endif /* ACE_HAS_THREADS */
ACE_END_TEST;
return test_result;
}
void
MyTask::create_proactor (void)
{
ACE_Guard<ACE_Recursive_Thread_Mutex> locker (mutex_);
if (threads_ == 0)
{
#if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)
ACE_WIN32_Proactor *proactor = new ACE_WIN32_Proactor;
ACE_DEBUG ((LM_DEBUG,"(%t) Create Proactor Type=WIN32"));
#elif defined (ACE_HAS_AIO_CALLS)
ACE_POSIX_Proactor *proactor = 0;
switch (proactor_type)
{
case 1: proactor = new ACE_POSIX_AIOCB_Proactor (max_aio_operations);
ACE_DEBUG ((LM_DEBUG,"(%t) Create Proactor Type=AIOCB\n"));
break;
case 2: proactor = new ACE_POSIX_SIG_Proactor;
ACE_DEBUG ((LM_DEBUG,"(%t) Create Proactor Type=SIG\n"));
break;
# if defined (sun)
case 3: proactor = new ACE_SUN_Proactor (max_aio_operations);
ACE_DEBUG ((LM_DEBUG,"(%t) Create Proactor Type=SUN\n"));
break;
# endif /* sun */
default:proactor = new ACE_POSIX_SIG_Proactor;
ACE_DEBUG ((LM_DEBUG,"(%t) Create Proactor Type=SIG\n"));
break;
}
#endif
proactor_ = new ACE_Proactor (proactor, 1);
ACE_Proactor::instance(proactor_);
event_.signal ();
}
threads_++;
}
virtual int handle_close (ACE_HANDLE, ACE_Reactor_Mask) {
quit_seen_.signal ();
return 0;
}
static void *
worker (void *)
{
if (evt.wait () == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT (" (%P|%t) %p\n"),
ACE_TEXT ("Failed waiting for pulse ()")),
0);
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT (" (%P|%t) awake\n")));
if (++n_awoken < n_workers)
{
//FUZZ: disable check_for_lack_ACE_OS
ACE_Time_Value wait (1, 0); // Wait 10 sec
//FUZZ: enable check_for_lack_ACE_OS
ACE_Time_Value tv = ACE_OS::gettimeofday () + wait;
if (evt.wait (&tv) == -1)
{
// verify that we have ETIME
if (ACE_OS::last_error () == ETIME)
ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%P|%t) timeout\n")));
else
ACE_ERROR ((LM_ERROR,
ACE_TEXT (" (%P|%t) wait failed %p\n"),
ACE_TEXT ("but not with ETIME")));
}
else
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT (" (%P|%t) awake in time\n")));
if (++n_awoken2 >= (n_workers/2))
evt.reset (); // reset signal (rest times out)
}
// Check to ensure that an "infinite timeout" will work.
if (evt.wait (0) == -1)
{
//FUZZ: disable check_for_lack_ACE_OS
ACE_ERROR ((LM_ERROR,
ACE_TEXT (" (%P|%t) %p\n"),
ACE_TEXT ("Failed waiting for signal ()\n")));
//FUZZ: enable check_for_lack_ACE_OS
}
}
else
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT (" (%P|%t) last awake; send signal\n")));
// last one wakes others
if (evt.signal () == -1)
ACE_ERROR ((LM_ERROR, ACE_TEXT (" (%P|%t) %p\n"), ACE_TEXT ("signal")));
ACE_OS::sleep (ACE_Time_Value (0, 200 * 1000 * 100)); // 200 msec
}
if (evt.wait () == -1)
{
//FUZZ: disable check_for_lack_ACE_OS
ACE_ERROR ((LM_ERROR,
ACE_TEXT (" (%P|%t) %p\n"),
ACE_TEXT ("Failed waiting for signal ()\n")));
//FUZZ: enable check_for_lack_ACE_OS
}
ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" (%P|%t) worker finished\n")));
return 0;
}
