int Ping_Suspend_Resume_Test::svc () { #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test::svc (), entering")); ACE_hthread_t thread_id; ACE_Thread_Manager::instance ()->thr_self (thread_id); ACE_DEBUG ((LM_DEBUG, "; thread ID is %u\n", thread_id)); #endif /* ACE_DEBUG_CST */ high_.ready (); #if ACE_DEBUG_CST > 0 int priority, high_priority; ACE_OS::thr_getprio (thread_id, priority); ACE_OS::thr_getprio (high_.thread_id (), high_priority); ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test::svc (), priority is %d, " ", high thread priority is %d\n", priority, high_priority)); #endif /* ACE_DEBUG_CST */ // For information: the cost of the just the loop itself below, // without the suspend and resume calls, on a 166 MHz Ultrasparc // is about 12.3 nanoseconds per iteration. timer_.start (); ACE_UINT32 i; for (i = 0; i < iterations_; ++i) { #if ACE_DEBUG_CST > 0 if (i % (iterations_ >= 10 ? iterations_ / 10 : 1) == 0) { ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test::svc (), iteration " "%d, continue high-priority thread %u\n", i, high_.thread_id ())); } #endif /* ACE_DEBUG_CST */ if (ACE_OS::thr_continue (high_.thread_id ()) != 0 && errno != EINVAL) // EINVAL is OK: it just means that the thread needs to be joined. { ACE_ERROR ((LM_ERROR, "%p\n", "thr_continue")); high_.done (); return -1; } } timer_.stop (); timer_.elapsed_microseconds (elapsed_time_); high_.done (); #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test::svc: told high priority " "task to terminate\n")); #endif /* ACE_DEBUG_CST */ // Resume the thread until thr_continue fails, indicating that it has // finished. for (i = 0; i < 10000 && ! ACE_OS::thr_continue (high_.thread_id ()); ++i) /* null */; // Don't count the one iteration that was used to allow the high-priority // thread to terminate. if (high_.iterations () < iterations_) ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test: high priority task " "executed only %u iterations!\n", high_.iterations ())); #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test::svc, finishing\n")); #endif /* ACE_DEBUG_CST */ return 0; }
int Yield_Test::svc () { #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "Yield_Test::svc (), entering")); ACE_hthread_t thread_id; ACE_Thread_Manager::instance ()->thr_self (thread_id); int priority; ACE_OS::thr_getprio (thread_id, priority); ACE_DEBUG ((LM_DEBUG, "; thread ID is %u, priority is %u\n", thread_id, priority)); #endif /* ACE_DEBUG_CST */ #if defined (VXWORKS) // Start the timer, if it hasn't already been started. if (! started_) { // Double-check. ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, mutex_, -1); if (! started_) { started_ = 1; timer_.start (); } } #endif /* VXWORKS */ for (ACE_UINT32 i = 0; i < iterations_; ++i) { #if ACE_DEBUG_CST > 0 if (i % (iterations_ >= 10 ? iterations_ / 10 : 1) == 0) { ACE_DEBUG ((LM_DEBUG, "Yield_Test::svc () [%u], iteration %u\n", thread_id, i)); } #endif /* ACE_DEBUG_CST */ ACE_OS::thr_yield (); } #if defined (VXWORKS) // Stop the timer, if it hasn't already been started. if (! stopped_) { // Maybe it would be better to read the clock before grabbing // the mutex. Then, only apply the clock reading below, instead // of reading the clock after grabbing the mutex. // Double-check. ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, mutex_, -1); if (! stopped_) { stopped_ = 1; timer_.stop (); timer_.elapsed_time (elapsed_time_); /* nanoseconds */ } } #else /* ! VXWORKS */ timer_barrier_.wait (); #endif /* ! VXWORKS */ #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "Yield_Test::svc, finishing\n")); #endif /* ACE_DEBUG_CST */ return 0; }
void madara::cid::ga_naive (Settings & settings, double duration) { ACE_High_Res_Timer timer; ACE_Time_Value max_tv (0, 0); ACE_hrtime_t elapsed (0); ACE_hrtime_t maximum (0); timer.reset (); timer.start (); max_tv.set (duration); maximum = max_tv.sec () * 1000000000; maximum += max_tv.usec () * 1000; #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_EVENT_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_naive:" \ " creating an exact copy of the solution vector\n")); #endif // create an exact copy of the solution vector Deployment current; current.resize (settings.solution.size ()); std::copy (settings.solution.begin (), settings.solution.end (), current.begin ()); #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_EVENT_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_naive:" \ " calculating latency for the solution so far\n")); #endif uint64_t orig_latency = calculate_latency (settings); uint64_t new_latency; while (maximum > elapsed) { // generate some candidates for mutating unsigned int candidate1 = rand () % settings.solution.size (); unsigned int candidate2 = rand () % settings.solution.size (); #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_DETAILED_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_naive:" \ " initial candidates: %u, %u\n", candidate1, candidate2)); #endif // loop until we have two different candidates while (candidate1 == candidate2) candidate1 = rand () % settings.solution.size (); #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_DETAILED_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_naive:" \ " final candidates: %u, %u\n", candidate1, candidate2)); #endif // attempt the swap std::swap (current[candidate1], current[candidate2]); new_latency = calculate_latency ( settings.network_latencies, settings.target_deployment, current); if (new_latency < orig_latency) { #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_EVENT_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_naive:" \ " latency improvement: %Q->%Q. Copying solution.\n", orig_latency, new_latency)); #endif std::copy (current.begin (), current.end (), settings.solution.begin ()); orig_latency = new_latency; } timer.stop (); timer.elapsed_time (elapsed); } for (unsigned int i = 0; i < settings.solution.size (); ++i) { if (settings.solution_lookup[settings.solution[i]] != i) settings.solution_lookup[settings.solution[i]] = i; } }
void big_time_test (CORBA::ULong num_list_loops, CORBA::ULong num_seq_loops, CORBA::ULong num_string_loops, bool use_long_str) { ACE_High_Res_Timer timer; ACE_hrtime_t time; Seq_Structs big_list; big_list.seq.length(0); CORBA::ULong big_len; CORBA::ULong red_len; CORBA::ULong sss_len; CORBA::ULong str_len; // start timing timer.start(); for (CORBA::ULong list_idx = 0; list_idx < num_list_loops; ++list_idx) { big_len = big_list.seq.length(); big_list.seq.length(big_len + 1); Biglist_Struct & list = big_list.seq[big_len]; for (CORBA::ULong seq_idx = 0; seq_idx < num_seq_loops; ++seq_idx) { red_len = list.red_seqs.length(); list.red_seqs.length(red_len + 1); Sequence_Str_Sequences & sss = list.red_seqs[red_len]; sss_len = sss.seq_str_seq.length(); sss.seq_str_seq.length(sss_len + 1); Str_Sequences & strs = sss.seq_str_seq[sss_len]; for (CORBA::ULong str_idx = 0; str_idx < num_string_loops; ++str_idx) { str_len = strs.second_str.length(); strs.second_str.length(str_len + 1); strs.second_str[str_len] = use_long_str ? long_str : short_str; str_len = list.strs.first_str.length(); list.strs.first_str.length(str_len + 1); list.strs.first_str[str_len] = use_long_str ? long_str : short_str; } // end of str loop } // end of seq loop } // end of list loop // end timing timer.stop(); timer.elapsed_time(time); if (use_csv) { ACE_DEBUG((LM_INFO, ACE_TEXT("3, %u, %u, %u, %s, %Q\n"), num_list_loops, num_string_loops, num_seq_loops, use_long_str ? ACE_TEXT("long"): ACE_TEXT("short"), time )); } else { ACE_DEBUG((LM_INFO, ACE_TEXT("Big list test(%u, %u, %u, %s) = %Q ns\n"), num_list_loops, num_string_loops, num_seq_loops, use_long_str ? ACE_TEXT("long"): ACE_TEXT("short"), time )); } }
void madara::cid::ga_degree (Settings & settings, double duration) { if (settings.solution.size () < 2) return; ACE_High_Res_Timer timer; ACE_Time_Value max_tv (0, 0); ACE_hrtime_t elapsed (0); ACE_hrtime_t maximum (0); timer.reset (); timer.start (); max_tv.set (duration); maximum = max_tv.sec () * 1000000000; maximum += max_tv.usec () * 1000; #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_EVENT_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_degree:" \ " entering main function\n")); #endif // create an exact copy of the solution vector Deployment current; current.resize (settings.solution.size ()); std::copy (settings.solution.begin (), settings.solution.end (), current.begin ()); uint64_t orig_latency = calculate_latency (settings); unsigned int num_degreed_nodes = 0; Workflow & deployment = settings.target_deployment; SummationsMap & averages = settings.network_summations; SolutionMap solution_lookup; #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_EVENT_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_degree:" \ " copying initial solution\n")); #endif for (unsigned int i = 0; i < current.size (); ++i) { solution_lookup[current[i]] = i; } #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_EVENT_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_degree:" \ " counting the degreed nodes in the deployment\n")); #endif // count the number of degreed nodes in the deployment. for (unsigned int i = 0; i < deployment.size (); ++i) { if (deployment[i].size () == 0) break; ++num_degreed_nodes; } #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_EVENT_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_degree:" \ " Attempting up to %f seconds worth of mutations to find better solution\n", duration)); #endif while (maximum > elapsed) { /** * 1/5 times, choose a naive solution. * 4/5 times, choose to swap someone from the high degreed candidates **/ int tactic = rand () % 5; unsigned int candidate1; unsigned int candidate2; if (tactic == 4) { #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_DETAILED_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_degree:" \ " naively choosing candidates\n")); #endif // go with a naive solution candidate1 = rand () % settings.solution.size (); candidate2 = rand () % settings.solution.size (); if (settings.solution.size () > 0) { // loop until we have two different candidates while (candidate1 == candidate2) candidate1 = rand () % settings.solution.size (); } } else { #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_DETAILED_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_degree:" \ " choosing degree-informed candidates\n")); #endif unsigned int choice = rand () % num_degreed_nodes; // use degree and latency information to form ideal candidates candidate1 = deployment[choice][0].first; LatencyVector & cur_summations = settings.network_summations[deployment[choice].size ()]; /** * the other candidate can be from a range: * 0-2 : top num_degreed_nodes * 3 : top 10% * 4 : top 25% **/ int candidate_type = rand () % 5; unsigned int range; if (cur_summations.size () < 50) { range = cur_summations.size () / 10 + 1; candidate2 = solution_lookup[cur_summations[rand () % range].first]; } else if (candidate_type <= 2) { if (num_degreed_nodes < 5) { range = cur_summations.size () / 20; } else { range = num_degreed_nodes; } #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_DETAILED_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_degree:" \ " choosing from top %u candidates\n", range)); #endif candidate2 = solution_lookup[cur_summations[rand () % range].first]; } else if (candidate_type == 3) { // choose candidate2 from the top 10% range = cur_summations.size () / 10; #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_DETAILED_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_degree:" \ " choosing from top %u candidates\n", range)); #endif candidate2 = solution_lookup[cur_summations[rand () % range].first]; } else { // choose candidate2 from the top 25% range = cur_summations.size () / 4; #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_DETAILED_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_degree:" \ " choosing from top %u candidates\n", range)); #endif candidate2 = solution_lookup[cur_summations[rand () % range].first]; } #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_DETAILED_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_degree:" \ " initial candidates: %u, %u\n", candidate1, candidate2)); #endif // loop until we have two different candidates while (range >= 2 && candidate1 == candidate2) candidate2 = solution_lookup[cur_summations[rand () % range].first]; } #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_DETAILED_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_degree:" \ " final candidates: %u, %u\n", candidate1, candidate2)); #endif // attempt the swap if (candidate1 != candidate2) { std::swap (current[candidate1], current[candidate2]); solution_lookup[current[candidate1]] = candidate1; solution_lookup[current[candidate2]] = candidate2; uint64_t new_latency = calculate_latency ( settings.network_latencies, deployment, current); #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_DETAILED_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_degree:" \ " latency: %Q->%Q\n", orig_latency, new_latency)); #endif if (new_latency < orig_latency) { #ifdef ENABLE_CID_LOGGING MADARA_DEBUG (MADARA_LOG_DETAILED_TRACE, (LM_DEBUG, DLINFO "madara::cid::ga_degree:" \ " updating solution to current\n", orig_latency, new_latency)); #endif std::copy (current.begin (), current.end (), settings.solution.begin ()); for (unsigned int j = 0; j < settings.solution.size (); ++j) { if (settings.solution_lookup[settings.solution[j]] != j) settings.solution_lookup[settings.solution[j]] = j; } orig_latency = new_latency; } } timer.stop (); timer.elapsed_time (elapsed); } }
int run_domain_test () { ::DDS::ReturnCode_t ret; // create participant ::DDS::DomainParticipant_var new_dp = dpf->create_participant(MY_DOMAIN, PARTICIPANT_QOS_DEFAULT, ::DDS::DomainParticipantListener::_nil (), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); TEST_CHECK (! CORBA::is_nil (new_dp.in ())); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(! CORBA::is_nil (new_dp.in ()))") ACE_TEXT("\n") )); ::DDS::DomainId_t domain_id = new_dp->get_domain_id (); TEST_CHECK (domain_id == MY_DOMAIN); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(domain_id == MY_DOMAIN)") ACE_TEXT("\n") )); MyTypeSupport_var fts (new MyTypeSupportImpl); if (::DDS::RETCODE_OK != fts->register_type(new_dp.in (), MY_TYPE)) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Failed to register the FooTypeSupport."))); return 1; } // lookup existent participant ::DDS::DomainParticipant_var looked_dp = dpf->lookup_participant(MY_DOMAIN); OpenDDS::DCPS::DomainParticipantImpl* new_dp_servant = dynamic_cast<OpenDDS::DCPS::DomainParticipantImpl*>(new_dp.in()); OpenDDS::DCPS::DomainParticipantImpl* looked_dp_servant = dynamic_cast<OpenDDS::DCPS::DomainParticipantImpl*>(looked_dp.in ()); TEST_CHECK (looked_dp_servant == new_dp_servant); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(looked_dp_servant == new_dp_servant)") ACE_TEXT("\n") )); // create topic ::DDS::Topic_var new_topic = new_dp->create_topic(MY_TOPIC, MY_TYPE, TOPIC_QOS_DEFAULT, ::DDS::TopicListener::_nil (), ::OpenDDS::DCPS::DEFAULT_STATUS_MASK); OpenDDS::DCPS::TopicImpl* new_topic_servant = dynamic_cast<OpenDDS::DCPS::TopicImpl*>(new_topic.in ()); ::DDS::Duration_t timeout; timeout.sec = static_cast<long>(find_topic_timeout.sec ()); timeout.nanosec = find_topic_timeout.usec (); // find existent topic ::DDS::Topic_var found_topic = new_dp->find_topic(MY_TOPIC, timeout); ::OpenDDS::DCPS::TopicImpl* found_topic_servant = dynamic_cast<OpenDDS::DCPS::TopicImpl*> (found_topic.in ()); TEST_CHECK (new_topic_servant == found_topic_servant); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(new_topic_servant == found_topic_servant)") ACE_TEXT("\n") )); // find existent topicdescription ::DDS::TopicDescription_var found_topicdescription = new_dp->lookup_topicdescription(MY_TOPIC); TEST_CHECK (! CORBA::is_nil (found_topicdescription.in ())); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(! CORBA::is_nil (found_topicdescription.in ()))") ACE_TEXT("\n") )); // widen the topicdescription to topic ::DDS::Topic_var widened_topic = ::DDS::Topic::_narrow(found_topicdescription.in ()); TEST_CHECK (! CORBA::is_nil (widened_topic.in ())); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(! CORBA::is_nil (widened_topic.in ()))") ACE_TEXT("\n") )); ACE_ERROR((LM_ERROR, "We expect to see an error message from delete_participant\n")); ret = dpf->delete_participant(new_dp.in ()); TEST_CHECK (ret == ::DDS::RETCODE_PRECONDITION_NOT_MET); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(ret == ::DDS::RETCODE_PRECONDITION_NOT_MET)") ACE_TEXT("\n") )); // delete existent topic first time ret = new_dp->delete_topic(found_topic.in ()); TEST_CHECK (ret == ::DDS::RETCODE_OK); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(ret == ::DDS::RETCODE_OK)") ACE_TEXT("\n") )); // delete existent topic second time ret = new_dp->delete_topic(new_topic.in ()); TEST_CHECK (ret == ::DDS::RETCODE_OK); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(ret == ::DDS::RETCODE_OK)") ACE_TEXT("\n") )); // an extra delete existent topic ACE_ERROR((LM_ERROR, "We expect to see an error message from delete_topic\n")); ret = new_dp->delete_topic(new_topic.in ()); TEST_CHECK (ret == ::DDS::RETCODE_ERROR); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(ret == ::DDS::RETCODE_ERROR)") ACE_TEXT("\n") )); // Look up the topicdescription after the topic is deleted will // return nil. found_topicdescription = new_dp->lookup_topicdescription(MY_TOPIC); TEST_CHECK (CORBA::is_nil(found_topicdescription.in ())); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(CORBA::is_nil(found_topicdescription.in ()))") ACE_TEXT("\n") )); // find a non-existent topic - return nil ACE_High_Res_Timer timer; ACE_Time_Value elapsedTime(0, 0); timer.start (); found_topic = new_dp->find_topic(OTHER_TOPIC, timeout); timer.stop(); timer.elapsed_time(elapsedTime); ACE_Time_Value tenMillis (0, 10000); elapsedTime += tenMillis; // some systems can be short by up to 10 milliseconds ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(CORBA::is_nil(found_topic.in ()) && elapsedTime.msec() >= find_topic_timeout.msec())") ACE_TEXT("\n") )); // delete the existent participant ret = dpf->delete_participant(new_dp.in ()); TEST_CHECK (ret == ::DDS::RETCODE_OK); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(ret == ::DDS::RETCODE_OK)") ACE_TEXT("\n") )); // lookup the participant after it's deleted - return nil looked_dp = dpf->lookup_participant(MY_DOMAIN); TEST_CHECK (CORBA::is_nil(looked_dp.in ())); ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) run_domain_test: ") ACE_TEXT("(CORBA::is_nil(looked_dp.in ()))") ACE_TEXT("\n") )); return 0; }
int ACE_TMAIN (int argc_in, ACE_TCHAR* argv_in[]) { RPG_TRACE (ACE_TEXT ("::main")); // *PROCESS PROFILE* ACE_Profile_Timer process_profile; // start profile timer... process_profile.start (); // step1: initialize // // *PORTABILITY*: on Windows, init ACE... //#if defined (ACE_WIN32) || defined (ACE_WIN64) // if (ACE::init () == -1) // { // ACE_DEBUG ((LM_ERROR, // ACE_TEXT ("failed to ACE::init(): \"%m\", aborting\n"))); // return EXIT_FAILURE; // } // end IF //#endif // step1 init/validate configuration // step1a: process commandline arguments std::string configuration_path = RPG_Common_File_Tools::getConfigurationDataDirectory (ACE_TEXT_ALWAYS_CHAR (BASEDIR), true); #if defined (DEBUG_DEBUGGER) configuration_path = Common_File_Tools::getWorkingDirectory (); #endif // #ifdef DEBUG_DEBUGGER std::string configuration_file = configuration_path; configuration_file += ACE_DIRECTORY_SEPARATOR_CHAR_A; #if defined (DEBUG_DEBUGGER) configuration_file += ACE_TEXT_ALWAYS_CHAR ("protocol"); configuration_file += ACE_DIRECTORY_SEPARATOR_CHAR_A; #endif configuration_file += ACE_TEXT_ALWAYS_CHAR (IRC_CLIENT_CNF_DEF_INI_FILE); bool debug_parser = false; bool log_to_file = false; bool trace_information = false; bool print_version_and_exit = false; unsigned int num_thread_pool_threads = IRC_CLIENT_DEF_NUM_TP_THREADS; if (!do_processArguments (argc_in, argv_in, configuration_file, debug_parser, log_to_file, trace_information, print_version_and_exit, num_thread_pool_threads)) { // make 'em learn... do_printUsage (ACE::basename (argv_in[0])); // // *PORTABILITY*: on Windows, fini ACE... //#if defined (ACE_WIN32) || defined (ACE_WIN64) // if (ACE::fini () == -1) // ACE_DEBUG ((LM_ERROR, // ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n"))); //#endif return EXIT_FAILURE; } // end IF // validate argument(s) if (!Common_File_Tools::isReadable (configuration_file)) { // make 'em learn... do_printUsage (ACE::basename (argv_in[0])); // // *PORTABILITY*: on Windows, fini ACE... //#if defined (ACE_WIN32) || defined (ACE_WIN64) // if (ACE::fini () == -1) // ACE_DEBUG ((LM_ERROR, // ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n"))); //#endif return EXIT_FAILURE; } // end IF // initialize logging and/or tracing std::string log_file; if (log_to_file) log_file = RPG_Common_File_Tools::getLogFilename (ACE::basename (argv_in[0])); if (!Common_Tools::initializeLogging (ACE::basename (argv_in[0]), // program name log_file, // logfile false, // log to syslog ? false, // trace messages ? trace_information, // debug messages ? NULL)) // logger { ACE_DEBUG ((LM_ERROR, ACE_TEXT ("failed to Common_Tools::initializeLogging(), aborting\n"))); // // *PORTABILITY*: on Windows, need to fini ACE... //#if defined (ACE_WIN32) || defined (ACE_WIN64) // if (ACE::fini () == -1) // ACE_DEBUG ((LM_ERROR, // ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n"))); //#endif return EXIT_FAILURE; } // end IF // handle specific program modes if (print_version_and_exit) { do_printVersion (ACE::basename (argv_in[0])); Common_Tools::finalizeLogging (); // // *PORTABILITY*: on Windows, fini ACE... //#if defined (ACE_WIN32) || defined (ACE_WIN64) // if (ACE::fini () == -1) // ACE_DEBUG ((LM_ERROR, // ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n"))); //#endif return EXIT_SUCCESS; } // end IF // initialize configuration object Stream_AllocatorHeap heap_allocator; RPG_Net_Protocol_MessageAllocator message_allocator (RPG_NET_MAXIMUM_NUMBER_OF_INFLIGHT_MESSAGES, &heap_allocator); RPG_Net_Protocol_Module_IRCHandler_Module IRC_handler_module (std::string ("IRCHandler"), NULL); RPG_Net_Protocol_Module_IRCHandler* IRC_handler_impl = NULL; IRC_handler_impl = dynamic_cast<RPG_Net_Protocol_Module_IRCHandler*>(IRC_handler_module.writer ()); if (!IRC_handler_impl) { ACE_DEBUG ((LM_ERROR, ACE_TEXT ("dynamic_cast<RPG_Net_Protocol_Module_IRCHandler> failed, aborting\n"))); Common_Tools::finalizeLogging (); // // *PORTABILITY*: on Windows, fini ACE... //#if defined (ACE_WIN32) || defined (ACE_WIN64) // if (ACE::fini () == -1) // ACE_DEBUG ((LM_ERROR, // ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n"))); //#endif return EXIT_FAILURE; } // end IF if (!IRC_handler_impl->initialize (&message_allocator, RPG_NET_PROTOCOL_BUFFER_SIZE, true, // auto-answer "ping" as a client ?... true)) // clients print ('.') dots for received "pings"... { ACE_DEBUG ((LM_ERROR, ACE_TEXT ("failed to initialize module: \"%s\", aborting\n"), ACE_TEXT (IRC_handler_module.name ()))); Common_Tools::finalizeLogging (); // // *PORTABILITY*: on Windows, fini ACE... //#if defined (ACE_WIN32) || defined (ACE_WIN64) // if (ACE::fini () == -1) // ACE_DEBUG ((LM_ERROR, // ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n"))); //#endif return EXIT_FAILURE; } // end IF RPG_Net_Protocol_Configuration configuration; // ************ socket configuration data ************ configuration.socketConfiguration.bufferSize = RPG_NET_DEFAULT_SOCKET_RECEIVE_BUFFER_SIZE; // ************ stream configuration data **************** configuration.streamConfiguration.messageAllocator = &message_allocator; configuration.streamConfiguration.bufferSize = RPG_NET_PROTOCOL_BUFFER_SIZE; configuration.streamConfiguration.module = &IRC_handler_module; configuration.streamConfiguration.statisticReportingInterval = 0; // == off // ************ protocol configuration data ************** configuration.protocolConfiguration.streamConfiguration.crunchMessageBuffers = RPG_NET_PROTOCOL_DEF_CRUNCH_MESSAGES; configuration.protocolConfiguration.streamConfiguration.debugScanner = debug_parser; configuration.protocolConfiguration.streamConfiguration.debugParser = debug_parser; configuration.protocolConfiguration.clientPingInterval = 0; // servers only configuration.protocolConfiguration.loginOptions.nick = IRC_CLIENT_DEF_IRC_NICK; std::string hostname; Net_Common_Tools::retrieveLocalHostname (hostname); if (IRC_CLIENT_CNF_IRC_USERMSG_TRADITIONAL) { configuration.protocolConfiguration.loginOptions.user.hostname.discriminator = RPG_Net_Protocol_IRCLoginOptions::User::Hostname::STRING; configuration.protocolConfiguration.loginOptions.user.hostname.string = &hostname; } // end IF else { configuration.protocolConfiguration.loginOptions.user.hostname.discriminator = RPG_Net_Protocol_IRCLoginOptions::User::Hostname::BITMASK; // *NOTE*: hybrid-7.2.3 seems to have a bug: 4 --> +i configuration.protocolConfiguration.loginOptions.user.hostname.mode = IRC_CLIENT_DEF_IRC_USERMODE; } // end ELSE configuration.protocolConfiguration.loginOptions.user.servername = ACE_TEXT_ALWAYS_CHAR (RPG_NET_PROTOCOL_DEF_IRC_SERVERNAME); configuration.protocolConfiguration.loginOptions.channel = ACE_TEXT_ALWAYS_CHAR (IRC_CLIENT_DEF_IRC_CHANNEL); // populate user/realname Common_Tools::getCurrentUserName (configuration.protocolConfiguration.loginOptions.user.username, configuration.protocolConfiguration.loginOptions.user.realname); // step1db: parse config file (if any) std::string serverHostname = ACE_TEXT_ALWAYS_CHAR(IRC_CLIENT_DEF_SERVER_HOSTNAME); unsigned short serverPortNumber = IRC_CLIENT_DEF_SERVER_PORT; if (!configuration_file.empty ()) do_parseConfigurationFile (configuration_file, configuration.protocolConfiguration.loginOptions, serverHostname, serverPortNumber); ACE_High_Res_Timer timer; timer.start(); // step2: do actual work do_work (configuration, serverHostname, serverPortNumber, num_thread_pool_threads); // clean up IRC_handler_module.close (); timer.stop (); // debug info std::string working_time_string; ACE_Time_Value working_time; timer.elapsed_time (working_time); Common_Tools::period2String (working_time, working_time_string); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("total working time (h:m:s.us): \"%s\"...\n"), ACE_TEXT (working_time_string.c_str ()))); // stop profile timer... process_profile.stop (); // only process profile left to do... ACE_Profile_Timer::ACE_Elapsed_Time elapsed_time; elapsed_time.real_time = 0.0; elapsed_time.user_time = 0.0; elapsed_time.system_time = 0.0; if (process_profile.elapsed_time (elapsed_time) == -1) { ACE_DEBUG ((LM_ERROR, ACE_TEXT ("failed to ACE_Profile_Timer::elapsed_time: \"%m\", aborting\n"))); Common_Tools::finalizeLogging (); // // *PORTABILITY*: on Windows, fini ACE... //#if defined (ACE_WIN32) || defined (ACE_WIN64) // if (ACE::fini () == -1) // ACE_DEBUG ((LM_ERROR, // ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n"))); //#endif return EXIT_FAILURE; } // end IF ACE_Profile_Timer::Rusage elapsed_rusage; ACE_OS::memset (&elapsed_rusage, 0, sizeof (ACE_Profile_Timer::Rusage)); process_profile.elapsed_rusage(elapsed_rusage); ACE_Time_Value user_time(elapsed_rusage.ru_utime); ACE_Time_Value system_time(elapsed_rusage.ru_stime); std::string user_time_string; std::string system_time_string; Common_Tools::period2String (user_time, user_time_string); Common_Tools::period2String (system_time, system_time_string); // debug info #if !defined (ACE_WIN32) && !defined (ACE_WIN64) ACE_DEBUG((LM_DEBUG, ACE_TEXT(" --> Process Profile <--\nreal time = %A seconds\nuser time = %A seconds\nsystem time = %A seconds\n --> Resource Usage <--\nuser time used: %s\nsystem time used: %s\nmaximum resident set size = %d\nintegral shared memory size = %d\nintegral unshared data size = %d\nintegral unshared stack size = %d\npage reclaims = %d\npage faults = %d\nswaps = %d\nblock input operations = %d\nblock output operations = %d\nmessages sent = %d\nmessages received = %d\nsignals received = %d\nvoluntary context switches = %d\ninvoluntary context switches = %d\n"), elapsed_time.real_time, elapsed_time.user_time, elapsed_time.system_time, user_time_string.c_str(), system_time_string.c_str(), elapsed_rusage.ru_maxrss, elapsed_rusage.ru_ixrss, elapsed_rusage.ru_idrss, elapsed_rusage.ru_isrss, elapsed_rusage.ru_minflt, elapsed_rusage.ru_majflt, elapsed_rusage.ru_nswap, elapsed_rusage.ru_inblock, elapsed_rusage.ru_oublock, elapsed_rusage.ru_msgsnd, elapsed_rusage.ru_msgrcv, elapsed_rusage.ru_nsignals, elapsed_rusage.ru_nvcsw, elapsed_rusage.ru_nivcsw)); #else ACE_DEBUG ((LM_DEBUG, ACE_TEXT (" --> Process Profile <--\nreal time = %A seconds\nuser time = %A seconds\nsystem time = %A seconds\n --> Resource Usage <--\nuser time used: %s\nsystem time used: %s\n"), elapsed_time.real_time, elapsed_time.user_time, elapsed_time.system_time, user_time_string.c_str (), system_time_string.c_str ())); #endif Common_Tools::finalizeLogging (); // // *PORTABILITY*: on Windows, fini ACE... //#if defined (ACE_WIN32) || defined (ACE_WIN64) // if (ACE::fini () == -1) // ACE_DEBUG ((LM_ERROR, // ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n"))); //#endif return EXIT_SUCCESS; } // end main
int Client::svc (void) { try { Octet_Seq octetSeq(SIZE_BLOCK); Char_Seq charSeq(SIZE_BLOCK); ACE_High_Res_Timer timer; ACE_OS::printf("Start sending %d Msgs...\n",this->niterations_); charSeq.length(SIZE_BLOCK); octetSeq.length(SIZE_BLOCK); // This sets up the connector, so that we do not incur // the overhead on the first call in the loop. server_->sendCharSeq (charSeq); timer.start (); ACE_UINT32 client_count = 0; for (ACE_UINT32 i = 0; i < this->niterations_; ++i) { client_count++; server_->sendCharSeq (charSeq); //server_->sendOctetSeq (octetSeq); //ACE_DEBUG ((LM_DEBUG, ".")); } timer.stop (); ACE_Time_Value measured; timer.elapsed_time (measured); //ACE_DEBUG ((LM_DEBUG, "...finished\n")); time_t dur = measured.sec () * 1000000 + measured.usec (); if (dur == 0 || this->niterations_ == 0) ACE_DEBUG ((LM_DEBUG, "Time not measurable, calculation skipped\n")); else { ACE_DEBUG ((LM_DEBUG, "Time for %u Msgs: %u usec\n", this->niterations_, dur)); ACE_DEBUG ((LM_DEBUG, "Time for 1 Msg: %u usec, %u calls/sec\n", dur / this->niterations_, 1000000 / (dur / this->niterations_))); } for (int c = 0; c < 10; ++c) server_->shutdown (); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("MT_Client: exception raised"); } return 0; }
int ACE_TMAIN (int argc_in, ACE_TCHAR* argv_in[]) { RPG_TRACE (ACE_TEXT ("::main")); // step1: initialize libraries // *PORTABILITY*: on Windows, init ACE... #if defined (ACE_WIN32) || defined (ACE_WIN64) if (ACE::init () == -1) { ACE_DEBUG ((LM_ERROR, ACE_TEXT ("failed to ACE::init(): \"%m\", aborting\n"))); return EXIT_FAILURE; } // end IF #endif // step2: initialize configuration // step2a: set defaults RPG_Dice_ValueRange value_range; value_range.begin = 0; value_range.end = 0; bool print_all_results = false; bool trace_information = false; bool print_version_and_exit = false; // step2b: parse/process/validate configuration if (!process_arguments (argc_in, argv_in, print_all_results, value_range, trace_information, print_version_and_exit)) { // make 'em learn... print_usage (ACE::basename (argv_in[0])); // *PORTABILITY*: on Windows, fini ACE... #if defined (ACE_WIN32) || defined (ACE_WIN64) if (ACE::fini () == -1) { ACE_DEBUG ((LM_ERROR, ACE_TEXT ("failed to ACE::fini(): \"%m\", aborting\n"))); return EXIT_FAILURE; } // end IF #endif return EXIT_FAILURE; } // end IF // // step2c: validate arguments // if (valueRange.begin == valueRange.end == 0) // { // ACE_DEBUG((LM_DEBUG, // ACE_TEXT("invalid range: \"%s\", aborting\n"), // RPG_Chance_Dice_Common_Tools::rangeToString(valueRange).c_str())); // // // make 'em learn... // print_usage(); // // return EXIT_FAILURE; // } // end IF // step3: initialize logging and/or tracing std::string log_file; if (!Common_Tools::initializeLogging (ACE::basename (argv_in[0]), // program name log_file, // logfile false, // log to syslog ? false, // trace messages ? trace_information, // debug messages ? NULL)) // logger { ACE_DEBUG ((LM_ERROR, ACE_TEXT ("failed to Common_Tools::initializeLogging(), aborting\n"))); // *PORTABILITY*: on Windows, need to fini ACE... #if defined (ACE_WIN32) || defined (ACE_WIN64) if (ACE::fini () == -1) ACE_DEBUG ((LM_ERROR, ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n"))); #endif return EXIT_FAILURE; } // end IF // step4: handle specific program modes if (print_version_and_exit) { do_printVersion (ACE::basename (argv_in[0])); // *PORTABILITY*: on Windows, need to fini ACE... #if defined (ACE_WIN32) || defined (ACE_WIN64) if (ACE::fini () == -1) ACE_DEBUG ((LM_ERROR, ACE_TEXT ("failed to ACE::fini(): \"%m\", continuing\n"))); #endif return EXIT_SUCCESS; } // end IF ACE_High_Res_Timer timer; timer.start (); // step5: do work RPG_Dice_Rolls_t combinations; do_work (value_range, combinations); timer.stop (); // step6: print results // header line std::cout << ACE_TEXT ("results ") << RPG_Dice_Common_Tools::rangeToString (value_range) << ACE_TEXT (": ") << std::endl; std::cout << std::setw (80) << std::setfill (ACE_TEXT_ALWAYS_CHAR ('-')) << ACE_TEXT ("") << std::setfill (ACE_TEXT_ALWAYS_CHAR (' ')) << std::endl; bool perfect_match = true; int index = 1; RPG_Dice_ValueRange range; for (RPG_Dice_RollsIterator_t iterator = combinations.begin (); iterator != combinations.end (); iterator++, index++) { perfect_match = true; RPG_Dice::rollToRange (*iterator, range); if ((range.begin != value_range.begin) || (range.end != value_range.end)) { // not a perfect match... perfect_match = false; if (!print_all_results) continue; } // end IF std::cout << ACE_TEXT ("[") << index << (perfect_match ? ACE_TEXT ("*]") : ACE_TEXT ("]")) << RPG_Dice_Common_Tools::rollToString (*iterator) << ACE_TEXT (" : ") << RPG_Dice_Common_Tools::rangeToString (range) << std::endl; } // end FOR // std::string working_time_string; // ACE_Time_Value working_time; // timer.elapsed_time(working_time); // RPS_FLB_Common_Tools::Period2String(working_time, // working_time_string); // // ACE_DEBUG((LM_DEBUG, // ACE_TEXT("total working time (h:m:s.us): \"%s\"...\n"), // working_time_string.c_str())); // step7: finalize libraries // *PORTABILITY*: on Windows, fini ACE... #if defined (ACE_WIN32) || defined (ACE_WIN64) if (ACE::fini () == -1) { ACE_DEBUG ((LM_ERROR, ACE_TEXT ("failed to ACE::fini(): \"%m\", aborting\n"))); return EXIT_FAILURE; } // end IF #endif return EXIT_SUCCESS; } // end main