template <class ACE_LOCK, class TYPE> ACE_INLINE
ACE_Atomic_Op<ACE_LOCK, TYPE>::ACE_Atomic_Op
(const ACE_Atomic_Op<ACE_LOCK, TYPE> &rhs)
: impl_ (this->own_mutex_, rhs.value ())
{
// ACE_TRACE ("ACE_Atomic_Op<ACE_LOCK, TYPE>::ACE_Atomic_Op");
}
int
run_main (int, ACE_TCHAR *[])
{
ACE_START_TEST (ACE_TEXT ("Task_Test"));
#if defined (ACE_HAS_THREADS)
// Set the thread hook!
ACE_Thread_Hook::thread_hook (new My_Thread_Hook);
int n_threads = ACE_MAX_THREADS;
int n_iterations = ACE_MAX_ITERATIONS;
Barrier_Task barrier_task (ACE_Thread_Manager::instance (),
n_threads,
n_iterations);
ACE_Thread_Manager::instance ()->wait ();
// Only one of the threads should see a cleanup...
if (close_cleanups != 1)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%d threads saw cleanup indication; ")
ACE_TEXT ("should be 1\n"),
close_cleanups.value ()));
// Cleanup the thread hook so it doesn't leak.
delete ACE_Thread_Hook::thread_hook ();
#else
ACE_ERROR ((LM_INFO,
ACE_TEXT ("threads not supported on this platform\n")));
#endif /* ACE_HAS_THREADS */
ACE_END_TEST;
return 0;
}
int
Test_Task::handle_input (ACE_HANDLE)
{
this->handled_++;
if (this->handled_ == ACE_MAX_ITERATIONS)
{
done_count--;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t) handle_input, handled_ = %d, done_count = %d\n"),
this->handled_,
done_count.value ()));
}
ACE_OS::thr_yield ();
return -1;
}
int
Test_Task::handle_input (ACE_HANDLE)
{
ACE_DEBUG ((LM_DEBUG, "(%t) handle_input\n"));
this->handled_++;
if (this->handled_ == NUM_INVOCATIONS)
{
done_count--;
ACE_DEBUG ((LM_DEBUG,
"(%t) handle_input, handled_ = %d, done_count = %d\n",
this->handled_, done_count.value ()));
}
ACE_OS::thr_yield ();
return -1;
}
void
Filter_StructuredPushConsumer::push_structured_event
(const CosNotification::StructuredEvent & notification)
{
CORBA::Long val;
notification.remainder_of_body >>= val;
// @@ Pradeep: for your tests try to make sure that you count the
// number of expected and sent events to verify that things work
// correctly in an automatic way...
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("%C received event, %d\n"),
my_name_.fast_rep (), val));
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("event count %d\n"), g_result_count.value ()));
if (++g_result_count == EVENTS_EXPECTED_TO_RECEIVE)
this->filter_->done (); // all events received, we're done.
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
ACE_UNUSED_ARG (argc);
ACE_UNUSED_ARG (argv);
ACE_DEBUG ((LM_DEBUG,
"(%P | %t):Test starts\n"));
// = Get two POSIX_SIG_Proactors, one with SIGRTMIN and one with
// SIGRTMAX.
ACE_Proactor proactor1;
// Proactor1. SIGRTMIN Proactor. (default).
// = Proactor2. SIGRTMAX Proactor.
#if defined (ACE_HAS_AIO_CALLS) && defined (ACE_HAS_POSIX_REALTIME_SIGNALS)
ACE_DEBUG ((LM_DEBUG, "Using ACE_POSIX_SIG_Proactor\n"));
sigset_t signal_set;
// Signal set that we want to mask.
// Clear the signal set.
if (ACE_OS::sigemptyset (&signal_set) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"Error:%p\n",
"sigemptyset failed"),
1);
// Add the SIGRTMAX to the signal set.
if (ACE_OS::sigaddset (&signal_set, ACE_SIGRTMAX) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"Error:%p\n",
"sigaddset failed"),
1);
// Make the POSIX Proactor.
ACE_POSIX_SIG_Proactor posix_proactor (signal_set);
// Get the Proactor interface out of it.
ACE_Proactor proactor2 (&posix_proactor);
#else /* ACE_HAS_AIO_CALLS && ACE_HAS_POSIX_REALTIME_SIGNALS */
ACE_Proactor proactor2;
#endif /* ACE_HAS_AIO_CALLS && ACE_HAS_POSIX_REALTIME_SIGNALS */
// = Create Tasks. One pool of threads to handle completions on
// SIGRTMIN and the other one to handle completions on SIGRTMAX.
My_Task task1, task2;
task1.open (&proactor1);
task2.open (&proactor2);
// Handler for completions.
My_Handler handler;
// = Create a few MyResult objects and post them to Proactor.
const size_t NrCompletions (10);
My_Result *result_objects [NrCompletions];
int signal_number = ACE_SIGRTMAX;
size_t ri = 0;
Completions_To_Go = NrCompletions;
// Creation.
for (ri = 0; ri < NrCompletions; ri++)
{
// Use RTMIN and RTMAX proactor alternatively, to post
// completions.
if (ri % 2)
signal_number = ACE_SIGRTMIN;
else
signal_number = ACE_SIGRTMAX;
// Create the result.
ACE_NEW_RETURN (result_objects [ri],
My_Result (handler,
0,
signal_number,
ri),
1);
}
ACE_OS::sleep(5);
// Post all the result objects.
ACE_Proactor *proactor;
for (ri = 0; ri < NrCompletions; ri++)
{
// Use RTMIN and RTMAX Proactor alternatively, to post
// completions.
if (ri % 2)
proactor = &proactor1;
else
proactor = &proactor2;
if (result_objects [ri]->post_completion (proactor->implementation ())
== -1)
ACE_ERROR_RETURN ((LM_ERROR,
"Test failed\n"),
1);
}
ACE_Thread_Manager::instance ()->wait ();
int status = 0;
size_t to_go = Completions_To_Go.value ();
if (size_t (0) != to_go)
{
ACE_ERROR ((LM_ERROR,
"Fail! Expected all completions to finish but %u to go\n",
to_go));
status = 1;
}
ACE_DEBUG ((LM_DEBUG,
"(%P | %t):Test ends\n"));
return status;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
A::AMI_Test_var server;
AMI_Test_i * servant =
new AMI_Test_i(orb.in());
PortableServer::ServantBase_var safe (servant);
server = servant->_this();
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
// Activate POA to handle the call back.
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
// Main thread collects replies. It needs to collect
// <nthreads*niterations> replies.
number_of_replies = nthreads * niterations;
// Let the client perform the test in a separate thread
Client client (server.in (), niterations);
if (client.activate (THR_NEW_LWP | THR_JOINABLE,
nthreads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate client threads\n"),
1);
if (debug)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) : Entering perform_work loop to receive <%d> replies\n",
number_of_replies.value ()));
}
// ORB loop.
while (number_of_replies > 0)
{
CORBA::Boolean pending = orb->work_pending();
if (pending)
{
orb->perform_work();
}
// On some systems this loop must yield or else the other threads
// will not get a chance to run.
ACE_OS::thr_yield();
}
if (debug)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) : Exited perform_work loop Received <%d> replies\n",
(nthreads*niterations) - number_of_replies.value ()));
}
client.thr_mgr ()->wait ();
ACE_DEBUG ((LM_DEBUG, "threads finished\n"));
root_poa->destroy (1, // ethernalize objects
0 // wait for completion
);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return invalid_exception;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
A::AMI_Test_var server;
CORBA::Object_var object =
orb->string_to_object (ior);
server = A::AMI_Test::_narrow (object.in ());
if (CORBA::is_nil (server.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Object reference <%s> is nil.\n",
ior),
1);
}
// Activate POA to handle the call back.
CORBA::Object_var poa_object =
orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa =
PortableServer::POA::_narrow (poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager ();
poa_manager->activate ();
// Let the client perform the test in a separate thread
Handler handler;
PortableServer::ObjectId_var id =
root_poa->activate_object (&handler);
CORBA::Object_var hnd_object = root_poa->id_to_reference (id.in ());
A::AMI_AMI_TestHandler_var the_handler_var =
A::AMI_AMI_TestHandler::_narrow (hnd_object.in ());
handler.set_ami_test (server.in ());
Client client (server.in (), niterations, the_handler_var.in ());
if (client.activate (THR_NEW_LWP | THR_JOINABLE,
nthreads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate client threads\n"),
1);
// Main thread collects replies. It needs to collect
// <nthreads*niterations> replies.
number_of_replies = nthreads *niterations;
if (debug)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) : Entering perform_work loop to receive <%d> replies\n",
number_of_replies.value ()));
}
// ORB loop.
Worker worker (orb.in ());
if (worker.activate (THR_NEW_LWP | THR_JOINABLE,
nthreads) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate client threads\n"),
1);
worker.thr_mgr ()->wait ();
if (debug)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) : Exited perform_work loop Received <%d> replies\n",
(nthreads*niterations) - number_of_replies.value ()));
}
client.thr_mgr ()->wait ();
ACE_DEBUG ((LM_DEBUG, "threads finished\n"));
server->shutdown ();
root_poa->destroy (1, // ethernalize objects
0 // wait for completion
);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
return 1;
}
return parameter_corruption;
}