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