int run_main (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("MT_Reference_Counted_Event_Handler_Test")); // Validate options. int result = parse_args (argc, argv); if (result != 0) return result; disable_signal (SIGPIPE, SIGPIPE); int ignore_nested_upcalls = 1; int perform_nested_upcalls = 0; int event_loop_thread_required = 1; int event_loop_thread_not_required = 0; if (test_select_reactor) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n\n(%t) Testing Select Reactor....\n\n"))); test<ACE_Select_Reactor> test (ignore_nested_upcalls, event_loop_thread_not_required); ACE_UNUSED_ARG (test); } if (test_tp_reactor) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n\n(%t) Testing TP Reactor....\n\n"))); test<ACE_TP_Reactor> test (perform_nested_upcalls, event_loop_thread_not_required); ACE_UNUSED_ARG (test); } #if defined (ACE_HAS_EVENT_POLL) if (test_dev_poll_reactor) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n\n(%t) Testing Dev Poll Reactor....\n\n"))); test<ACE_Dev_Poll_Reactor> test (perform_nested_upcalls, event_loop_thread_not_required); ACE_UNUSED_ARG (test); } #endif #if defined (ACE_WIN32) if (test_wfmo_reactor) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n\n(%t) Testing WFMO Reactor....\n\n"))); test<ACE_WFMO_Reactor> test (ignore_nested_upcalls, event_loop_thread_required); ACE_UNUSED_ARG (test); } #else /* ACE_WIN32 */ ACE_UNUSED_ARG (event_loop_thread_required); #endif /* ACE_WIN32 */ ACE_END_TEST; return 0; }
int Invocation_Thread::svc (void) { int connection_counter = 0; ACE_DEBUG ((LM_DEBUG, ACE_TEXT("(%t) Invocation_Thread::svc commencing\n"))); disable_signal (SIGPIPE, SIGPIPE); for (int message_counter = 1;; ++message_counter) { // Get a connection from the cache. Sender *sender = this->connection_cache_.acquire_connection (); // If no connection is available in the cache, create a new one. if (sender == 0) { if (connection_counter < number_of_connections) { sender = this->create_connection (); // This lets the Close_Socket_Thread know that the new // connection has been created. int result = this->new_connection_event_.signal (); ACE_TEST_ASSERT (result == 0); ACE_UNUSED_ARG (result); ++connection_counter; message_counter = 1; } else // Stop the thread, if the maximum number of connections // for the test has been reached. break; } // The reference count on the sender was increased by the cache // before it was returned to us. ACE_Event_Handler_var safe_sender (sender); // If the test does not require making invocations, immediately // release the connection. if (!this->make_invocations_) { this->connection_cache_.release_connection (sender); // Sleep for a short while ACE_OS::sleep (ACE_Time_Value (0, 10 * 1000)); } else { // Make invocation. ssize_t result = sender->send_message (); // If successful, release connection. if (result == message_size) { if (debug) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) Message %d:%d delivered on handle %d\n"), connection_counter, message_counter, sender->handle_)); this->connection_cache_.release_connection (sender); } else { // If failure in making invocation, close the sender. if (debug) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) /*** Problem in delivering message ") ACE_TEXT ("%d:%d on handle %d: shutting down ") ACE_TEXT ("invocation thread ***/\n"), connection_counter, message_counter, sender->handle_)); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) Invocation thread calling ") ACE_TEXT ("Sender::close() for handle %d\n"), sender->handle_)); sender->close (); } } } ACE_DEBUG ((LM_DEBUG, ACE_TEXT("(%t) Invocation_Thread::svc calling end_reactor_event_loop\n"))); // Close the Reactor event loop. this->reactor_.end_reactor_event_loop (); ACE_DEBUG ((LM_DEBUG, ACE_TEXT("(%t) Invocation_Thread::svc terminating\n"))); return 0; }
int run_main (int, ACE_TCHAR *[]) { ACE_START_TEST (ACE_TEXT ("Bug_2912_Regression_Test")); // SSL_CTX_set_cipher_list, etc. init_ssl (); // Keep RT signals on POSIX from killing us. disable_signal (ACE_SIGRTMIN, ACE_SIGRTMAX); int ret = 0; Client_Service_Handler client_handler; Server_Service_Handler server_handler; ACE_Time_Value wait_time (10, 0); // Client and Server will utilize different proactors since this test // depends on SSL thread error state behavior. CLIENT_PROACTOR_TASK->activate (); SERVER_PROACTOR_TASK->activate (); // Open server acceptor and client connector if (0 == ret) { ret = ACCEPTOR->open ( ACE_INET_Addr (ACE_DEFAULT_SERVER_PORT), 0, 0, ACE_DEFAULT_ASYNCH_BACKLOG, 1, SERVER_PROACTOR, 1); if (-1 == ret) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ( "ACE_Asynch_Acceptor::open failed, %d\n"), (int)errno)); } } if (0 == ret) { ret = CONNECTOR->open (0, CLIENT_PROACTOR, 1); if (-1 == ret) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ( "ACE_Asynch_Connector::open failed, %d\n"), (int)errno)); } } // Supply server_handler and client_handler to acceptor and connector and // connect client to the server. if (0 == ret) { ACCEPTOR->prepare_for_connection (&server_handler); CONNECTOR->prepare_for_connection (&client_handler); ret = CONNECTOR->connect ( ACE_INET_Addr (ACE_DEFAULT_SERVER_PORT, ACE_LOCALHOST)); if (-1 == ret) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ( "ACE_Asynch_Connector::connect failed, %d\n"), (int)errno)); } } if (0 == ret) { ret = client_handler.wait_for_external_write_queue (&wait_time); if (-1 == ret) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ( "Timed out waiting for client's write readiness\n"))); } } // Client sends data to server if (0 == ret) { ret = client_handler.write_data (); } // Client waits for echo reply from server if (0 == ret) { ret = client_handler.wait_for_read_completed (&wait_time); if (-1 == ret) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ( "Timed out waiting for client's read to complete\n"))); } } if (0 == ret) { if (client_handler.read_successful () == 1) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Success\n"))); ret = 0; } else { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Client's read failed\n"))); ret = -1; } } // Cleanup and shutdown ACCEPTOR->cancel (); while (!ACCEPTOR->safe_to_delete ()) ACE_OS::sleep (ACE_Time_Value (0, 500000)); CONNECTOR->cancel (); while (!CONNECTOR->safe_to_delete ()) ACE_OS::sleep (ACE_Time_Value (0, 500000)); client_handler.cancel_and_close (); while (!client_handler.safe_to_delete ()) ACE_OS::sleep (ACE_Time_Value (0, 500000)); server_handler.cancel_and_close (); while (!server_handler.safe_to_delete ()) ACE_OS::sleep (ACE_Time_Value (0, 500000)); CLIENT_PROACTOR->proactor_end_event_loop (); CLIENT_PROACTOR_TASK->wait (); SERVER_PROACTOR->proactor_end_event_loop (); SERVER_PROACTOR_TASK->wait (); ACE_END_TEST; return 0; }
int Close_Socket_Thread::svc (void) { unsigned int seed = (unsigned int) ACE_OS::time (); ACE_Time_Value timeout (0, close_timeout * 1000); ACE_DEBUG ((LM_DEBUG, ACE_TEXT("(%t) Close_Socket_Thread::svc commencing\n"))); disable_signal (SIGPIPE, SIGPIPE); for (; !this->reactor_.reactor_event_loop_done ();) { // Wait for the new connection to be established. int result = this->new_connection_event_.wait (&timeout, 0); ACE_TEST_ASSERT (result == 0 || (result == -1 && errno == ETIME)); if (result == -1 && errno == ETIME) continue; // Sleep for half a second. ACE_OS::sleep (timeout); int close_client = 0; // If the invocation thread is making invocations and if the // receiver is threaded, either socket can be closed. if (this->make_invocations_ && this->run_receiver_thread_) // Randomize which socket to close. close_client = ACE_OS::rand_r (&seed) % 2; // If the invocation thread is making invocations, only close // the client socket. else if (this->make_invocations_) close_client = 1; else // If the receiver is threaded, only close the server socket. close_client = 0; if (close_client) { // Close the client socket. if (debug) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) Close socket thread closing client ") ACE_TEXT ("handle %d\n"), client_handle)); ACE_OS::shutdown (client_handle, ACE_SHUTDOWN_BOTH); ACE_OS::closesocket (client_handle); } else { // Close the server socket. if (debug) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) Close socket thread closing server ") ACE_TEXT ("handle %d\n"), server_handle)); ACE_OS::shutdown (server_handle, ACE_SHUTDOWN_BOTH); ACE_OS::closesocket (server_handle); } } ACE_DEBUG ((LM_DEBUG, ACE_TEXT("(%t) Close_Socket_Thread::svc terminating\n"))); return 0; }
// ************************************************************* // Configuration helpers // ************************************************************* int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("PSSL_Test")); if (cfg.parse_args (argc, argv) < 0) return -1; disable_signal (ACE_SIGRTMIN, ACE_SIGRTMAX); disable_signal (SIGPIPE, SIGPIPE); disable_signal (SIGIO, SIGIO); //ACE_DEBUG ((LM_DEBUG, // ACE_TEXT ("FD_SETSIZE=%d ACE_FDSETSIZE=%d\n"), // FD_SETSIZE, // ACE_FD_SETSIZE)); ACE_DEBUG ((LM_DEBUG, "s_blksize=%u r_blksize=%u win_size=%u\n", cfg.s_blksize(), cfg.r_blksize(), cfg.w_size())); ACE_SSL_Context *context = ACE_SSL_Context::instance (); // Note - the next two strings are naked on purpose... the arguments to // the ACE_SSL_Context methods are const char *, not ACE_TCHAR *. context->certificate ("dummy.pem", SSL_FILETYPE_PEM); context->private_key ("key.pem", SSL_FILETYPE_PEM); { int rc = 0; ProactorTask task1(cfg); RecvFactory r_factory; SendFactory s_factory; PSessionManager r_manager (task1, r_factory,"R_Manager"); PSessionManager s_manager (task1, s_factory,"S_Manager"); Acceptor acceptor (r_manager); Connector connector (s_manager); ACE_Time_Value time_begin = ACE_OS::gettimeofday (); ACE_Time_Value time_end = ACE_OS::gettimeofday (); ACE_Time_Value time_run; if (task1.start () == 0) { ACE_Time_Value timeout (cfg.timeout(), 0); r_manager.set_timeout (timeout); s_manager.set_timeout (timeout); if (cfg.both() != 0 || cfg.connections () == 0) // Acceptor { // Simplify, initial read with zero size if (acceptor.start (ACE_INET_Addr (cfg.listen_port())) == 0) rc = 1; } if (cfg.both() != 0 || cfg.connections () > 0) // Connector { ACE_INET_Addr addr; addr.set (cfg.connect_port(), cfg.connect_host()); rc += connector.start (addr, cfg.connections ()); } time_begin = ACE_OS::gettimeofday (); if (rc > 0) { task1.enable_event_loop(); ACE_Time_Value sleep_time (cfg.seconds()); while ( sleep_time != ACE_Time_Value::zero) { ACE_Countdown_Time countdown ( & sleep_time ); ACE_OS::sleep (sleep_time ); } if (cfg.seconds () == 0) { // comment this later char c; cout << "Press any key to stop=>" << flush; cin.clear (); cin >> c; } }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("TM_Test")); if (cfg.parse_args (argc, argv) < 0) return -1; disable_signal (ACE_SIGRTMIN, ACE_SIGRTMAX); disable_signal (SIGPIPE, SIGPIPE); disable_signal (SIGIO, SIGIO); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("FD_SETSIZE=%d ACE_FDSETSIZE=%d\n"), FD_SETSIZE, ACE_FD_SETSIZE)); ACE_DEBUG ((LM_DEBUG, "s_blksize=%u r_blksize=%u win_size=%u\n", cfg.s_blksize(), cfg.r_blksize(), cfg.w_size())); int rc = 0; TP_ReactorTask task1(cfg); RecvFactory r_factory; SendFactory s_factory; TConnectionManager r_mgr (task1, "RManager"); TConnectionManager s_mgr (task1, "SManager"); TAcceptor acceptor (r_factory, r_mgr); TConnector connector(s_factory, s_mgr); ACE_Time_Value time_begin = ACE_OS::gettimeofday (); ACE_Time_Value time_end = ACE_OS::gettimeofday (); ACE_Time_Value time_run; if (task1.start () == 0) { if (cfg.both() != 0 || cfg.connections () == 0) // Acceptor { if (acceptor.start (ACE_INET_Addr (cfg.listen_port())) == 0) rc = 1; } if (cfg.both() != 0 || cfg.connections () > 0) // Connector { ACE_INET_Addr addr; addr.set (cfg.connect_port(), cfg.connect_host()); rc += connector.start (addr, cfg.connections ()); } time_begin = ACE_OS::gettimeofday (); if (rc > 0) { task1.enable_event_loop(); ACE_Time_Value sleep_time (cfg.seconds()); while ( sleep_time != ACE_Time_Value::zero) { ACE_Countdown_Time countdown ( & sleep_time ); ACE_OS::sleep (sleep_time ); } if (cfg.seconds() == 0) { // comment this later char c; cout << "Press any key to stop=>" << flush; cin.clear (); cin >> c; } }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("W_Test")); if (cfg.parse_args (argc, argv) < 0) return -1; disable_signal (ACE_SIGRTMIN, ACE_SIGRTMAX); disable_signal (SIGPIPE, SIGPIPE); disable_signal (SIGIO, SIGIO); //ACE_DEBUG ((LM_DEBUG, // ACE_TEXT ("FD_SETSIZE=%d ACE_FDSETSIZE=%d\n"), // FD_SETSIZE, // ACE_FD_SETSIZE)); ACE_DEBUG ((LM_DEBUG, "s_blksize=%u r_blksize=%u win_size=%u\n", cfg.s_blksize(), cfg.r_blksize(), cfg.w_size())); ACE_SSL_Context *context = ACE_SSL_Context::instance (); // Note - the next two strings are naked on purpose... the arguments to // the ACE_SSL_Context methods are const char *, not ACE_TCHAR *. context->certificate ("dummy.pem", SSL_FILETYPE_PEM); context->private_key ("key.pem", SSL_FILETYPE_PEM); { int rc = 0; ProactorTask task1(cfg); RecvFactory r_factory; RecvFactorySSL r_ssl_factory; PConnectionManager r_manager (task1, r_factory,"R_Manager"); PConnectionManager r_ssl_manager (task1, r_ssl_factory,"R_SSL_Manager"); Acceptor acceptor (r_manager); Acceptor acceptor_ssl (r_ssl_manager); ACE_Time_Value time_begin = ACE_OS::gettimeofday (); ACE_Time_Value time_end = ACE_OS::gettimeofday (); ACE_Time_Value time_run; if (task1.start () == 0) { ACE_Time_Value timeout (cfg.timeout(), 0); r_manager.set_timeout (timeout); // Simplify, initial read with zero size if (acceptor.start (ACE_INET_Addr (cfg.listen_port())) == 0) rc = 1; if (acceptor_ssl.start (ACE_INET_Addr (cfg.listen_port()+1)) == 0) rc = 1; time_begin = ACE_OS::gettimeofday (); if (rc > 0) { task1.enable_event_loop(); char c; cout << "Press any key to stop=>" << flush; cin.clear (); cin >> c; } }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("U_Test")); if (cfg.parse_args (argc, argv) < 0) return -1; disable_signal (ACE_SIGRTMIN, ACE_SIGRTMAX); disable_signal (SIGPIPE, SIGPIPE); disable_signal (SIGIO, SIGIO); // ACE_DEBUG ((LM_DEBUG, // ACE_TEXT ("FD_SETSIZE=%d ACE_FDSETSIZE=%d\n"), // FD_SETSIZE, // ACE_FD_SETSIZE)); ACE_DEBUG ((LM_DEBUG, "s_blksize=%u r_blksize=%u win_size=%u\n", cfg.s_blksize(), cfg.r_blksize(), cfg.w_size())); { int rc = 0; ProactorTask task1(cfg); DOwner acceptor(task1); DOwner connector(task1); ACE_Time_Value time_begin = ACE_OS::gettimeofday (); ACE_Time_Value time_end = ACE_OS::gettimeofday (); ACE_Time_Value time_run; if (task1.start () == 0) { if (cfg.both() != 0 || cfg.connections () == 0) // Acceptor { // Simplify, initial read with zero size if (acceptor.start_receiver(ACE_INET_Addr (cfg.listen_port())) == 0) rc = 1; } if (cfg.both() != 0 || cfg.connections () > 0) // Connector { ACE_INET_Addr addr; addr.set (cfg.connect_port(), cfg.connect_host()); for (u_int i=0; i < cfg.connections (); ++i, ++rc) { if (connector.start_sender (addr) != 0) break; } } time_begin = ACE_OS::gettimeofday (); if (rc > 0) { task1.enable_event_loop(); ACE_Time_Value sleep_time (cfg.seconds()); while ( sleep_time != ACE_Time_Value::zero) { ACE_Countdown_Time countdown ( & sleep_time ); ACE_OS::sleep (sleep_time ); } if (cfg.seconds () == 0) { // comment this later char c[80]; for (;;) { cout << "Press any key to stop=>" << flush; cin.clear (); cin.getline(c, 80); switch (tolower(c[0])) { case 'p': connector.post_all (); acceptor.post_all (); continue; default: break; } break; } } } } u_int num_ssn_s = connector.get_number_connections (); u_int num_ssn_r = acceptor.get_number_connections (); // Cancel all pending AIO on Connector and Senders ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t)******* Cancel Connector/Senders: connections_=%d\n"), connector.get_number_connections ())); connector.cancel_all (); //Cancel all pending AIO on Acceptor And Receivers ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t)******* Cancel Acceptor/Receivers:connections_=%d\n"), acceptor.get_number_connections () )); acceptor.cancel_all (); while ( connector.get_number_connections () > 0 || acceptor.get_number_connections () > 0 ) { task1.wait_signal (); } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) Stop Thread Pool Task\n"))); task1.stop (); // As Proactor event loop now is inactive it is safe to destroy all // Senders ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t)******** Stop Connector/Senders: connections_=%d\n"), connector.get_number_connections ())); connector.stop (); // As Proactor event loop now is inactive it is safe to destroy all // Receivers ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t)******** Stop Acceptor/Receivers:connections_=%d\n"), acceptor.get_number_connections ())); acceptor.stop (); time_end = ACE_OS::gettimeofday (); time_run = time_end - time_begin; u_long snd_bytes_s = connector.get_total_snd(); u_long rcv_bytes_s = connector.get_total_rcv(); u_long snd_op_s = connector.get_total_w(); u_long rcv_op_s = connector.get_total_r(); u_long snd_bytes_r = acceptor.get_total_snd(); u_long rcv_bytes_r = acceptor.get_total_rcv(); u_long snd_op_r = acceptor.get_total_w(); u_long rcv_op_r = acceptor.get_total_r(); //Print statistic ACE_TCHAR bufs [256]; ACE_TCHAR bufr [256]; ACE_OS::sprintf (bufs, ACE_TEXT ("%lu(%lu)"), snd_bytes_s, snd_op_s); ACE_OS::sprintf (bufr, ACE_TEXT ("%lu(%lu)"), rcv_bytes_s, rcv_op_s); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Connector/Senders total bytes: snd=%s rcv=%s\n"), bufs, bufr)); ACE_OS::sprintf (bufs, ACE_TEXT ("%lu(%lu)"), snd_bytes_r, snd_op_r); ACE_OS::sprintf (bufr, ACE_TEXT ("%lu(%lu)"), rcv_bytes_r, rcv_op_r); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Acceptor/Receivers total bytes: snd=%s rcv=%s\n"), bufs, bufr)); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Threads = %d BlkSize=%d\n"), cfg.threads(), cfg.blksize())); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Sessions = %d (%d) \n"), rc-1, cfg.connections ())); float fsec = (float)(time_run.msec()/1000); double fspeed = ((float) snd_bytes_s +(float) snd_bytes_r +(float) rcv_bytes_s +(float) rcv_bytes_r ); if ( fsec > 0.1 ) fspeed /= fsec; ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Effective run time = %f sec\n"), fsec)); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Effective bytes/sec = %f\n"), fspeed)); } // ProactorTask ACE_END_TEST; return 0; }
int run_main (int argc, ACE_TCHAR *argv[]) { ACE_START_TEST (ACE_TEXT ("TP_Reactor_Test")); #if defined(ACE_HAS_THREADS) if (::parse_args (argc, argv) == -1) return -1; disable_signal (SIGPIPE, SIGPIPE); MyTask task1; Acceptor acceptor; Connector connector; if (task1.start (threads) == 0) { int rc = 0; ACE_INET_Addr addr (port); if (both != 0 || host == 0) // Acceptor rc += acceptor.start (addr); if (both != 0 || host != 0) { if (host == 0) host = ACE_LOCALHOST; if (addr.set (port, host, 1, addr.get_type ()) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), host)); rc += connector.start (addr, senders); } if (rc > 0) ACE_OS::sleep (seconds); } task1.stop (); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nNumber of Receivers objects = %d\n") ACE_TEXT ("\nNumber of Sender objects = %d\n"), acceptor.get_number_sessions (), connector.get_number_sessions ())); // As Reactor event loop now is inactive it is safe to destroy all // senders connector.stop (); acceptor.stop (); //Print statistic ACE_TCHAR bufs [256]; ACE_TCHAR bufr [256]; ACE_OS::sprintf ( bufs , ACE_TEXT ("%ld(%ld)"), connector.get_total_snd(), connector.get_total_w() ); ACE_OS::sprintf ( bufr , ACE_TEXT ("%ld(%ld)"), connector.get_total_rcv(), connector.get_total_r() ); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Connector/Senders total bytes: snd=%s rcv=%s\n"), bufs, bufr )); ACE_OS::sprintf ( bufs , ACE_TEXT ("%ld(%ld)"), acceptor.get_total_snd(), acceptor.get_total_w() ); ACE_OS::sprintf ( bufr , ACE_TEXT ("%ld(%ld)"), acceptor.get_total_rcv(), acceptor.get_total_r() ); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Acceptor/Receivers total bytes: snd=%s rcv=%s\n"), bufs, bufr )); #else /* ACE_HAS_THREADS */ ACE_UNUSED_ARG( argc ); ACE_UNUSED_ARG( argv ); #endif /* ACE_HAS_THREADS */ ACE_END_TEST; return 0; }