int Mutex_Acquire_Release_Test::svc () { #if ACE_DEBUG_CST > 0 ACE_hthread_t thread_id; ACE_Thread_Manager::instance ()->thr_self (thread_id); ACE_DEBUG ((LM_DEBUG, "Mutex_Acquire_Release_Test::svc (), thread ID is %d\n", thread_id)); #endif /* ACE_DEBUG_CST */ timer_.start (); for (ACE_UINT32 i = 0; i < iterations_; ++i) { // Block on the mutex. ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, mutex_, -1); // Release the mutex so that the low priority thread can // proceed. The ACE_GUARD_RETURN macro implicity releases the // mutex. } timer_.stop (); timer_.elapsed_time (elapsed_time_); /* nanoseconds */ #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "Mutex_Acquire_Release_Test::svc, finishing\n")); #endif /* ACE_DEBUG_CST */ return 0; }
int Suspend_Resume_Test::svc () { #if ACE_DEBUG_CST > 0 ACE_hthread_t thread_id; ACE_Thread_Manager::instance ()->thr_self (thread_id); ACE_DEBUG ((LM_DEBUG, "Suspend_Resume_Test::svc (), thread ID is %d\n", thread_id)); #endif /* ACE_DEBUG_CST */ low_.ready (); // 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 (); 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, "Suspend_Resume_Test::svc (), iteration %u\n", i)); #endif /* ACE_DEBUG_CST */ if (ACE_OS::thr_suspend (low_.thread_id ()) != 0) { ACE_ERROR ((LM_ERROR, "%p\n", "thr_suspend")); low_.done (); return -1; } if (ACE_OS::thr_continue (low_.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")); low_.done (); return -1; } } timer_.stop (); timer_.elapsed_microseconds (elapsed_time_); low_.done (); #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "Suspend_Resume_Test::svc, finishing\n")); #endif /* ACE_DEBUG_CST */ return 0; }
void seqstrseq_time_test (CORBA::ULong num_seq_loops, CORBA::ULong num_string_loops, bool use_long_str) { ACE_High_Res_Timer timer; ACE_hrtime_t time; CORBA::ULong sss_len; CORBA::ULong str_len; Sequence_Str_Sequences seqs; seqs.seq_str_seq.length(0); // start timing timer.start(); for (CORBA::ULong seq_idx = 0; seq_idx < num_seq_loops; ++seq_idx) { sss_len = seqs.seq_str_seq.length(); seqs.seq_str_seq.length(sss_len + 1); Str_Sequences & strs = seqs.seq_str_seq[sss_len]; //strs.first_str.length(0); 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; } } // end timing timer.stop(); timer.elapsed_time(time); if (use_csv) { ACE_DEBUG((LM_INFO, ACE_TEXT("2, 0, %u, %u, %s, %Q\n"), num_string_loops, num_seq_loops, use_long_str ? ACE_TEXT("long"): ACE_TEXT("short"), time )); } else { ACE_DEBUG((LM_INFO, ACE_TEXT("Sequence of string seq (%u, %u, %s) = %Q ns\n"), num_string_loops, num_seq_loops, use_long_str ? ACE_TEXT("long"): ACE_TEXT("short"), time )); } }
static int speed_test (ACE_UINT32 loops) { double tt = 0.0, ut = 0.0, utus = 0.0, speed = 0.0; ACE_Time_Value tc; void *ptr = 0; ACE_UINT32 i = loops; size_t n_chunks = 10; size_t chunk_size = 8; ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) ACE_Dynamic_Cached_Allocator ") ACE_TEXT ("speed test...\n"))); DYNAMIC_ALLOCATOR allocator (n_chunks, chunk_size); ACE_High_Res_Timer timer; timer.reset (); timer.start (); while (i--) { ptr = allocator.malloc (chunk_size); allocator.free (ptr); } timer.stop (); timer.elapsed_time (tc); ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Iterations : %d\n"), loops)); tt = tc.sec () + tc.usec ()*1.0e-6; ut = tt/loops; utus = ut*1.0e6; speed = loops/tt; ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Total time : %.6g [s]\n"), tt)); ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Unit time : %.6g [us]\n"), utus)); ACE_DEBUG ((LM_INFO, ACE_TEXT (" (%t) Speed : %.6g [1/s]\n"), speed)); return 0; }
int Synchronisers::end_synchronization (void) { // Hold the lock and increment the global variable to indicate // number of ready threads { ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1); ready_threads ++; if (ready_threads == (number_of_workers + io_threads)) { // Reset the ready_threads so that we can wait at the end of // runs ready_threads = 0; // Start the timer test_timer.stop (); // Signal all the threads this->event_.signal (); if (debug) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) Ended peacefully \n")); } // return to do our work; return 0; } // If we are not the last thread, let go off the lock } if (debug) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) Going to wait .. \n")); } // Wait blisfully till we are woken up this->event_.wait (); return 0; }
int MyTask::svc (void) { ACE_hthread_t thr_handle; ACE_Thread::self (thr_handle); ACE_DEBUG ((LM_DEBUG, "(%t|%T): task activated\n")); ACE_ASSERT (dispatcher_ != 0); (void) dispatcher_->schedule (guid_, qos_); barrier_.wait (); long prime_number = 9619899; ACE_High_Res_Timer timer; ACE_Time_Value elapsed_time; ACE_Time_Value seconds_tracker(0,0); ACE_Time_Value one_second (1,0); ACE_Time_Value compute_count_down_time (exec_duration_, 0); ACE_Countdown_Time compute_count_down (&compute_count_down_time); timer.start (); while (compute_count_down_time > ACE_Time_Value::zero) { ACE::is_prime (prime_number, 2, prime_number / 2); compute_count_down.update (); timer.stop (); timer.elapsed_time (elapsed_time); seconds_tracker += elapsed_time; if (seconds_tracker >= one_second) { seconds_tracker.set (0,0); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) Currently running guid=%d") ACE_TEXT (", qos_.importance=%d\n"), guid_, qos_.importance_)); } timer.reset (); timer.start (); } dispatcher_->cancel_schedule (this->guid_); return 0; }
static ACE_Time_Value time_interval (const ACE_Time_Value &interval, ACE_hrtime_t& nanoseconds, ACE_hrtime_t& microseconds) { ACE_High_Res_Timer timer; timer.start (); ACE_OS::sleep (interval); timer.stop (); ACE_Time_Value measured; timer.elapsed_time (measured); timer.elapsed_time (nanoseconds); timer.elapsed_microseconds (microseconds); return measured; }
int ACE_TMAIN (int argc_in, ACE_TCHAR* argv_in[]) { RPG_TRACE (ACE_TEXT ("::main")); // *PORTABILITY*: on Windows, need to 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 std::string data_path = RPG_Common_File_Tools::getConfigurationDataDirectory (ACE_TEXT_ALWAYS_CHAR (BASEDIR), false); #if defined (DEBUG_DEBUGGER) data_path = Common_File_Tools::getWorkingDirectory (); #endif // step1: init // step1a set defaults RPG_Map_FloorPlan_Configuration_t configuration; configuration.corridors = MAP_GENERATOR_DEF_CORRIDORS; configuration.doors = MAP_GENERATOR_DEF_DOORS; configuration.map_size_x = MAP_GENERATOR_DEF_DIMENSION_X; configuration.map_size_y = MAP_GENERATOR_DEF_DIMENSION_Y; configuration.max_num_doors_per_room = MAP_GENERATOR_DEF_MAX_NUMDOORS_PER_ROOM; configuration.maximize_rooms = MAP_GENERATOR_DEF_MAXIMIZE_ROOMSIZE; configuration.min_room_size = MAP_GENERATOR_DEF_MIN_ROOMSIZE; configuration.num_areas = MAP_GENERATOR_DEF_NUM_AREAS; configuration.square_rooms = MAP_GENERATOR_DEF_SQUARE_ROOMS; bool generate_level = MAP_GENERATOR_DEF_LEVEL; std::string output_file = data_path; output_file += ACE_DIRECTORY_SEPARATOR_CHAR_A; #if defined (DEBUG_DEBUGGER) output_file += ACE_TEXT_ALWAYS_CHAR("map"); output_file += ACE_DIRECTORY_SEPARATOR_CHAR_A; output_file += ACE_TEXT_ALWAYS_CHAR("data"); output_file += ACE_DIRECTORY_SEPARATOR_CHAR_A; #else output_file += ACE_TEXT_ALWAYS_CHAR(RPG_MAP_MAPS_SUB); output_file += ACE_DIRECTORY_SEPARATOR_CHAR_A; #endif std::string default_output_file = output_file; default_output_file += (MAP_GENERATOR_DEF_LEVEL ? RPG_Common_Tools::sanitize(ACE_TEXT_ALWAYS_CHAR(RPG_ENGINE_LEVEL_DEF_NAME)) : ACE_TEXT_ALWAYS_CHAR(RPG_MAP_DEF_MAP_FILE)); default_output_file += (MAP_GENERATOR_DEF_LEVEL ? ACE_TEXT_ALWAYS_CHAR(RPG_ENGINE_LEVEL_FILE_EXT) : ACE_TEXT_ALWAYS_CHAR(RPG_MAP_FILE_EXT)); output_file = default_output_file; bool dump_result = MAP_GENERATOR_DEF_DUMP; bool trace_information = false; bool print_version_and_exit = false; bool random = false; // step1ba: parse/process/validate configuration Map_Generator_Options_t set_options; if (!do_processArguments(argc_in, argv_in, configuration.min_room_size, configuration.corridors, configuration.max_num_doors_per_room, generate_level, configuration.maximize_rooms, output_file, dump_result, configuration.num_areas, configuration.square_rooms, trace_information, print_version_and_exit, configuration.map_size_x, configuration.map_size_y, random, set_options)) { // make 'em learn... do_printUsage(std::string(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_FAILURE; } // end IF if (random) { Map_Generator_OptionsIterator_t iterator = set_options.find('a'); if (iterator == set_options.end()) configuration.min_room_size = 0; // iterator = set_options.find('c'); // if (iterator == set_options.end()) // configuration.corridors = false; iterator = set_options.find('d'); if (iterator == set_options.end()) configuration.max_num_doors_per_room = 0; // iterator = set_options.find('m'); // if (iterator == set_options.end()) // configuration.maximize_rooms = false; iterator = set_options.find('r'); if (iterator == set_options.end()) configuration.num_areas = 0; // iterator = set_options.find('s'); // if (iterator == set_options.end()) // configuration.square_rooms = false; iterator = set_options.find('x'); if (iterator == set_options.end()) configuration.map_size_x = 0; iterator = set_options.find('y'); if (iterator == set_options.end()) configuration.map_size_y = 0; } // end IF // step1bb: validate arguments if ((!random && ((configuration.num_areas == 0) || (configuration.map_size_x == 0) || (configuration.map_size_y == 0))) || (configuration.max_num_doors_per_room == 1) || // cannot enforce this (yet: *TODO*) (configuration.corridors && !configuration.doors)) // cannot have corridors without doors... { ACE_DEBUG((LM_DEBUG, ACE_TEXT("invalid argument(s), aborting\n"))); // make 'em learn... do_printUsage(std::string(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_FAILURE; } // end IF // step1c: 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 // step1d: handle specific program modes if (print_version_and_exit) { do_printVersion(std::string(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(); // step2: do actual work do_work(configuration, generate_level, output_file, dump_result, random); timer.stop(); // debug info std::string working_time_string; ACE_Time_Value working_time; timer.elapsed_time(working_time); RPG_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()))); // *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
int main(int argc, char** argv) { char map_magic[16]; int thisBuild = getBuildNumber(); int iCoreNumber = getCoreNumberFromBuild(thisBuild); showBanner("Movement Map Generator", iCoreNumber); setMapMagicVersion(iCoreNumber, map_magic); showWebsiteBanner(); int mapnum = -1; float maxAngle = 60.0f; int tileX = -1, tileY = -1; bool skipLiquid = false, skipContinents = false, skipJunkMaps = true, skipBattlegrounds = false, debugOutput = false, silent = false, bigBaseUnit = false; int num_threads = 0; char* offMeshInputPath = NULL; bool validParam = handleArgs(argc, argv, mapnum, tileX, tileY, maxAngle, skipLiquid, skipContinents, skipJunkMaps, skipBattlegrounds, debugOutput, silent, bigBaseUnit, num_threads, offMeshInputPath); if (!validParam) { return silent ? -1 : finish(" You have specified invalid parameters (use -h for more help)", -1); } if (mapnum == -1 && debugOutput) { if (silent) { return -2; } printf(" You have specifed debug output, but didn't specify a map to generate.\n"); printf(" This will generate debug output for ALL maps.\n"); printf(" Are you sure you want to continue? (y/n) "); if (getchar() != 'y') { return 0; } } if (!checkDirectories(debugOutput)) { return silent ? -3 : finish(" Press any key to close...", -3); } MapBuilder builder(map_magic, maxAngle, skipLiquid, skipContinents, skipJunkMaps, skipBattlegrounds, debugOutput, bigBaseUnit, offMeshInputPath); ACE_Time_Value elapsed; ACE_High_Res_Timer timer; timer.start(); if (tileX > -1 && tileY > -1 && mapnum >= 0) { builder.buildSingleTile(mapnum, tileX, tileY); } else { if (num_threads && builder.activate(num_threads)== -1) { if (!silent) { printf(" Thread initialization was not ok. The build is single threaded\n"); } } if (builder.activated()) { printf(" Using %d thread(s) for building\n", num_threads);} if (mapnum >= 0) { builder.buildMap(uint32(mapnum), true); } else { builder.buildAllMaps(); } } timer.stop(); timer.elapsed_time(elapsed); printf(" \n Total build time: %ld seconds\n\n", elapsed.sec()); return silent ? 1 : finish(" Movemap build is complete! Press enter to exit\n", 1); }
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; }
// client main function // uses a portable form of the "main" function along with its arguments int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { // first declare the variables string server_host; // name of the server unsigned short port_num; // port number is unsigned short unsigned short proto_type = 0; // 0 is our dummy implementation size_t chunk_size = 256; // chunk size (default = 256) FileTransferClient ftpClient; // instantiate an object for file // transfer string fname; // name of file to transfer // we require the user to pass 4 arguments to the executable in that order // (1) the server host name // (2) server port number // (3) protocol to use for reliable transfer (choices are 1, 2 or 3) // (4) chunk size to use (optional) if (argc < 4) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("Usage: client <server hostname> <server port num> ") ACE_TEXT ("<proto type: 1 = RDT, ") ACE_TEXT ("2 = Go Back N, 3 = Selective Repeat> ") ACE_TEXT ("[<chunk size, default = 256>]\n"))); return -1; } // let us grab the arguments server_host = argv [1]; // note we have to convert to a number port_num = (unsigned short) atoi (argv[2]); // note we have to convert to a number proto_type = (unsigned short) atoi (argv[3]); // check if the user supplied a chunk size (the 4th argument) if (argc == 5) { chunk_size = (unsigned short) atoi (argv[4]); } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("[%P] Client - ") ACE_TEXT ("Server = %s, port = %d, proto = %d, ") ACE_TEXT ("Chunk size = %d\n"), server_host.c_str (), port_num, proto_type, chunk_size)); // ask the user to enter a file name cout << "Please enter name of the file to transfer: "; cin >> fname; /*********************** TO-DO *************************************/ // I will suggest that you upgrade the FileTransferClient class so // that it can keep a record of time taken against the chunk size and // the protocol type used. // // Moreover the following can be inserted into a loop where the server // host & port num stays same but you can vary both the proto type as // well as chunk size and find out the time it takes to send the same // file. Choose a file that is sufficiently large to show us some // variations. /*******************************************************************/ // now initialize the File Transfer object if (ftpClient.open (server_host, port_num, proto_type, chunk_size) == -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("[%P] client main - ") ACE_TEXT ("failed to open the object (%m)\n"))); return -1; } // now let us time the transfer ACE_High_Res_Timer timer; // start timing timer.start (); size_t bytesTransferred; // keeps track of how many bytes were // transferred if ((bytesTransferred = ftpClient.SendFile (fname)) == -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("[%P] client main - ") ACE_TEXT ("failed to send file (%m)\n"))); return -1; } // time the transfer and retrieve elapsed time. timer.stop (); ACE_Time_Value tv; timer.elapsed_time (tv); // since we are done, we close the ftp object so it can clean up its // underlying protocol object. if (ftpClient.close () == -1) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("[%P] client main - ") ACE_TEXT ("failed to close the object (%m)\n"))); return -1; } ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("[%P] Client main - ") ACE_TEXT ("Total time for file transfer of %d bytes ") ACE_TEXT ("is %d milli seconds\n"), bytesTransferred, tv.msec ())); // everything went smoothly return 0; }
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 ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT); //unsigned char selector = ACE_ATM_Addr::DEFAULT_SELECTOR; //int selector_specified = 0; if (argc > 2) ACE_ERROR_RETURN ((LM_ERROR, "Usage: %s [selector]\n", argv[0]), 1); // Create a server address. ACE_ATM_Addr addr; //if (selector_specified) unsigned char selector = ( argc == 2 ) ? ACE_OS::atoi( argv[ 1 ]) : ACE_ATM_Addr::DEFAULT_SELECTOR; addr.set_selector( selector ); ACE_OS::printf( "ATM_Server: selector changed to %d\n", addr.get_selector()); // Create a server, reuse the addr. ACE_ATM_Acceptor peer_acceptor; ACE_ATM_Params params; // Not sure why but reuse_addr set to true/1 causes problems for // FORE/XTI/ATM - this is now handled in ACE_ATM_Acceptor::open() ACE_HANDLE ret = peer_acceptor.open (addr, 5, params); if ( ret == ACE_INVALID_HANDLE ) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "open"), -1); ACE_ATM_Stream new_stream; ACE_ATM_Addr local_addr; local_addr.set_selector( selector ); peer_acceptor.get_local_addr( local_addr ); ACE_DEBUG ((LM_DEBUG, "starting server at address %s\n", local_addr.addr_to_string ())); // Performs the iterative server activities char buf[BUFSIZ]; ACE_High_Res_Timer timer; int total; ACE_Time_Value tv; double real_time; double actual_rate; for (;;) { // Create a new ACE_ATM_Stream endpoint (note automatic restart // if errno == EINTR). ACE_OS::printf( "ATM_Server: expecting clients\n" ); if (peer_acceptor.accept (new_stream, &addr, &timeout) == -1) { ACE_ERROR ((LM_ERROR, "%p\n", "accept")); continue; } ACE_OS::printf( "ATM_Server: got a connection\n" ); ACE_UINT16 vpi, vci; vpi = vci = 0; // This has problem on PMP connections on NT //new_stream.get_vpi_vci(vpi, vci); ACE_DEBUG ((LM_DEBUG, "connected to VPI %d VCI %d\n", vpi, vci)); ACE_OS::printf( "ATM_Server: connection accepted\n" ); ACE_DEBUG ((LM_DEBUG, "client %s connected\n", addr.addr_to_string ())); ACE_DEBUG ((LM_DEBUG, "client %s connected to host\n", new_stream.get_peer_name ())); // Read data from client (terminate on error). int recvd = 0; for ( ;; ) { total = 0; timer.start_incr(); for (int r_bytes; (r_bytes = new_stream.recv (buf, sizeof buf, 0)) > 0; ) { // ACE_OS::printf( "ATM_Server: received %dB\n", r_bytes ); // if (ACE_OS::write (ACE_STDOUT, // buf, // r_bytes) != r_bytes) // ACE_ERROR ((LM_ERROR, // "%p\n", // "ACE::send_n")); total += r_bytes; if ( total > 10000000 ) break; } timer.stop_incr(); timer.elapsed_time_incr( tv ); real_time = tv.sec() * ACE_ONE_SECOND_IN_USECS + tv.usec(); recvd += total; actual_rate = ( double )recvd * ( double )8 / real_time; ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) bytes = %d, usec = %f, rate = %0.00f Mbps\n"), recvd, real_time, actual_rate < 0 ? 0 : actual_rate )); } // Close new endpoint (listening endpoint stays open). if (new_stream.close () == -1) ACE_ERROR ((LM_ERROR, "%p\n", "close")); } /* NOTREACHED */ return 0; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { int result = parse_args (argc, argv); if (result != 0) { return result; } Synchronisers synch_forms; ACE_High_Res_Timer::calibrate (); // Leader Followers. Leader_Follower_Task **leader_followers = 0; ACE_NEW_RETURN (leader_followers, Leader_Follower_Task *[number_of_threads], -1); int priority = ACE_Sched_Params::priority_max (ACE_SCHED_FIFO); long flags = THR_SCOPE_PROCESS; // Number of messages left = Number_Of_messages number_of_messages_left = number_of_messages; size_t i = 0; // Create and activate them. for (i = 0; i < number_of_threads; ++i) { ACE_NEW_RETURN (leader_followers[i], Leader_Follower_Task (synch_forms), -1); // Activate the leader_followers. result = leader_followers[i]->activate (flags, 1, 1, priority); if (result != 0) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) - Activate failed for RT class " " - Using default priority for thread [%d]\n", i)); flags = THR_BOUND; priority = ACE_Sched_Params::priority_min (ACE_SCHED_OTHER, ACE_SCOPE_THREAD); // Activate the leader_followers. result = leader_followers[i]->activate (flags, 1, 1, priority); if (result != 0) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) - Failed again no hope\n")); return 0; } } } // Wait for all threads to terminate. result = ACE_Thread_Manager::instance ()->wait (); ACE_hrtime_t elapsed_time = 0; test_timer.elapsed_time (elapsed_time); double elapsed_time_per_invocation = static_cast<double> ( ACE_UINT64_DBLCAST_ADAPTER (elapsed_time / number_of_messages) ); ACE_DEBUG ((LM_DEBUG, "(%P|%t) Throughput is [%f]\n", 1000000000/ elapsed_time_per_invocation)); for (i = 0; i < number_of_threads; ++i) { ACE_DEBUG ((LM_DEBUG, "Message consumed in thread [%d] is [%d]\n", i, leader_followers[i]->processed ())); delete leader_followers[i]; } delete[] leader_followers; return result; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { int result = parse_args (argc, argv); if (result != 0) { return result; } ACE_High_Res_Timer::calibrate (); // Create the message queue Message_Queue input_message_queue; Message_Queue output_message_queue; // Create the datablocks. IF we use the default Message Blocks Ctor, // it is going to do an extra allocation for the data block ACE_NEW_RETURN (data_block, ACE_Locked_Data_Block<ACE_Lock_Adapter<ACE_SYNCH_MUTEX> >, -1); // Increment the reference count so that we can share the // datablock. This is donw twice the number of messages for the // input and output queues. size_t i = 0; for (i = 0; i < 2*number_of_messages; ++i) { data_block->duplicate (); } // Create the Synchronisers Synchronisers synch; // Workers. Worker_Task **workers = 0; ACE_NEW_RETURN (workers, Worker_Task *[number_of_workers], -1); // Input Task Input_Task input_task (&input_message_queue, synch); // Output Task Output_Task output_task (&output_message_queue, synch); int priority = ACE_Sched_Params::priority_max (ACE_SCHED_FIFO); long flags = THR_SCHED_FIFO | THR_SCOPE_PROCESS; // Create and activate the worker threads for (i = 0; i < number_of_workers; ++i) { ACE_NEW_RETURN (workers[i], Worker_Task (&input_message_queue, synch), -1); workers[i]->next (&output_task); // Activate the workers. result = workers[i]->activate (flags, 1, 1, priority); if (result != 0) { flags = THR_BOUND; priority = ACE_Sched_Params::priority_min (ACE_SCHED_OTHER, ACE_SCOPE_THREAD); result = workers[i]->activate (flags, 1, 1, priority); if (result != 0) { return result; } } } // Activate the input and output threads result = input_task.activate (flags, 1, 1, priority); if (result != 0) return result; // Activate the workers. result = output_task.activate (flags, 1, 1, priority); if (result != 0) return result; // Wait for all threads to terminate. result = ACE_Thread_Manager::instance ()->wait (); ACE_hrtime_t elapsed_time = 0; test_timer.elapsed_time (elapsed_time); # if !defined (ACE_WIN32) double elapsed_time_per_invocation = (double) elapsed_time / number_of_messages; ACE_DEBUG ((LM_DEBUG, "(%P|%t) Throughput is [%f] \n", elapsed_time_per_invocation)); ACE_DEBUG ((LM_DEBUG, "(%P|%t) Throughput is [%f] \n", 1000000000/ elapsed_time_per_invocation)); #endif /*ACE_WIN32 */ for (i = 0; i < number_of_workers; ++i) { ACE_DEBUG ((LM_DEBUG, "Message process for thread [%d] is [%d] \n", i, workers[i]->processed ())); delete workers[i]; } delete[] workers; return result; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { int n = 100; int low = 64; int hi = 4096; int s = 4; int quiet = 0; ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("dn:l:h:s:q")); int opt; while ((opt = get_opt ()) != EOF) { switch (opt) { case 'd': TAO_debug_level++; break; case 'n': n = ACE_OS::atoi (get_opt.opt_arg ()); break; case 'l': low = ACE_OS::atoi (get_opt.opt_arg ()); break; case 'h': hi = ACE_OS::atoi (get_opt.opt_arg ()); break; case 's': s = ACE_OS::atoi (get_opt.opt_arg ()); break; case 'q': quiet = 1; break; case '?': default: ACE_DEBUG ((LM_DEBUG, "Usage: %s " "-d debug" "-l low " "-h high " "-s step " "-n n " "\n" "Writes and then reads longs to a CDR stream " "starting from <low> up to <high> incrementing " "by <step>, at each step run <n> iterations to " "average." "\n", argv[0])); return -1; } } for (int x = low; x <= hi; x += s) { ACE_High_Res_Timer writing; ACE_High_Res_Timer reading; if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, "\nx= %d\n", x)); for (int i = 0; i < n; ++i) { writing.start_incr (); TAO_OutputCDR output; if (test_write (output, x) != 0) { return 1; } writing.stop_incr (); reading.start_incr (); TAO_InputCDR input (output); if (test_read (input, x) != 0) { return 1; } reading.stop_incr (); } double m = n * x; ACE_Time_Value wtv; writing.elapsed_time_incr (wtv); ACE_hrtime_t wusecs = wtv.sec (); wusecs *= static_cast<ACE_UINT32> (ACE_ONE_SECOND_IN_USECS); wusecs += wtv.usec (); ACE_Time_Value rtv; reading.elapsed_time_incr (rtv); ACE_hrtime_t rusecs = rtv.sec (); rusecs *= static_cast<ACE_UINT32> (ACE_ONE_SECOND_IN_USECS); rusecs += rtv.usec (); double write_average = ACE_HRTIME_CONVERSION(wusecs) / m; double read_average = ACE_HRTIME_CONVERSION(rusecs) / m; if (!quiet) ACE_OS::printf ("AVE: %d %f %f\n", x, write_average, read_average); } 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; } }
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; }
CORBA::Long Simple_Server_i::test_method (CORBA::Long exec_duration) { ACE_hthread_t thr_handle; ACE_Thread::self (thr_handle); int prio; int guid; RTScheduling::Current::IdType_var id = this->current_->id (); ACE_OS::memcpy (&guid, id->get_buffer (), sizeof (id->length ())); ACE_High_Res_Timer timer; ACE_Time_Value elapsed_time; ACE_DEBUG ((LM_DEBUG, "Request in thread %t\n")); if (ACE_Thread::getprio (thr_handle, prio) == -1) { if (errno == ENOTSUP) { ACE_DEBUG((LM_DEBUG, ACE_TEXT ("getprio not supported on this platform\n"))); return 0; } ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("getprio failed")), -1); } ACE_DEBUG ((LM_DEBUG, "Request in thread %t, prio = %d," "exec duration = %u\n", prio, exec_duration)); static CORBA::ULong prime_number = 9619899; ACE_Time_Value compute_count_down_time (exec_duration, 0); ACE_Countdown_Time compute_count_down (&compute_count_down_time); //Applicable only for CV based implementations //yield every 1 sec ACE_Time_Value yield_interval (1,0); ACE_Time_Value yield_count_down_time (yield_interval); ACE_Countdown_Time yield_count_down (&yield_count_down_time); timer.start (); int j=0; while (compute_count_down_time > ACE_Time_Value::zero) { ACE::is_prime (prime_number, 2, prime_number / 2); ++j; #ifdef KOKYU_DSRT_LOGGING if (j%1000 == 0) { ACE_DEBUG ((LM_DEBUG, "(%t|%T) loop # = %d, load = %usec\n", j, exec_duration)); } #endif if (j%1000 == 0) { ACE_Time_Value run_time = ACE_OS::gettimeofday (); task_stats_.sample (ACE_UINT32 (run_time.msec ()), guid); } compute_count_down.update (); if (enable_yield_) { yield_count_down.update (); if (yield_count_down_time <= ACE_Time_Value::zero) { CORBA::Policy_var sched_param_policy = current_->scheduling_parameter(); const char * name = 0; CORBA::Policy_ptr implicit_sched_param = 0; current_->update_scheduling_segment (name, sched_param_policy.in (), implicit_sched_param); yield_count_down_time = yield_interval; yield_count_down.start (); } } } timer.stop (); timer.elapsed_time (elapsed_time); ACE_DEBUG ((LM_DEBUG, "Request processing in thread %t done, " "prio = %d, load = %d, elapsed time = %umsec\n", prio, exec_duration, elapsed_time.msec () )); return exec_duration; }
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 ACE_TMAIN (int argc_in, ACE_TCHAR* argv_in[]) { RPG_TRACE (ACE_TEXT ("::main")); // step0: init ACE // *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 // step1a set defaults std::string configuration_path = RPG_Common_File_Tools::getConfigurationDataDirectory (ACE_TEXT_ALWAYS_CHAR (BASEDIR), true); std::string data_path = RPG_Common_File_Tools::getConfigurationDataDirectory (ACE_TEXT_ALWAYS_CHAR (BASEDIR), false); #if defined (DEBUG_DEBUGGER) configuration_path = Common_File_Tools::getWorkingDirectory (); data_path = Common_File_Tools::getWorkingDirectory (); #endif // DEBUG_DEBUGGER bool dump_dictionary = false; std::string sound_directory = data_path; sound_directory += ACE_DIRECTORY_SEPARATOR_CHAR_A; #if defined (DEBUG_DEBUGGER) sound_directory += ACE_TEXT_ALWAYS_CHAR ("sound"); sound_directory += ACE_DIRECTORY_SEPARATOR_CHAR_A; sound_directory += ACE_TEXT_ALWAYS_CHAR (RPG_COMMON_DATA_SUB); #else sound_directory += ACE_TEXT_ALWAYS_CHAR (RPG_SOUND_DATA_SUB); #endif // DEBUG_DEBUGGER bool play_random_sounds = SOUNDPARSER_DEF_PLAY_RANDOM_SOUNDS; std::string schema_repository = configuration_path; #if defined (DEBUG_DEBUGGER) schema_repository += ACE_DIRECTORY_SEPARATOR_CHAR_A; schema_repository += ACE_TEXT_ALWAYS_CHAR("engine"); #endif // DEBUG_DEBUGGER std::string filename = configuration_path; filename += ACE_DIRECTORY_SEPARATOR_CHAR_A; #if defined (DEBUG_DEBUGGER) filename += ACE_TEXT_ALWAYS_CHAR ("sound"); filename += ACE_DIRECTORY_SEPARATOR_CHAR_A; #endif // DEBUG_DEBUGGER filename += ACE_TEXT_ALWAYS_CHAR (RPG_SOUND_DICTIONARY_FILE); bool trace_information = false; bool print_version_and_exit = false; bool validate_XML = true; // RPG_Sound_SDLConfig_t audio_config; // audio_config.frequency = RPG_SOUND_DEF_AUDIO_FREQUENCY; // audio_config.format = RPG_SOUND_DEF_AUDIO_FORMAT; // audio_config.channels = RPG_SOUND_DEF_AUDIO_CHANNELS; // audio_config.chunksize = RPG_SOUND_DEF_AUDIO_CHUNKSIZE; // step1b: parse/process/validate configuration if (!do_processArguments (argc_in, argv_in, dump_dictionary, sound_directory, play_random_sounds, filename, trace_information, print_version_and_exit, validate_XML)) { // 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 // step1b: validate arguments if ((play_random_sounds && !Common_File_Tools::isDirectory (sound_directory)) || !Common_File_Tools::isReadable (filename)) { ACE_DEBUG ((LM_ERROR, ACE_TEXT ("invalid argument, aborting\n"))); // 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 // step1c: 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 RPG_Common_Tools::initLogging(), aborting\n"))); // *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"))); #endif return EXIT_FAILURE; } // end IF // step1d: handle specific program modes if (print_version_and_exit) { do_printVersion (ACE::basename (argv_in[0])); return EXIT_SUCCESS; } // end IF // step2: init SDL if (SDL_Init (SDL_INIT_TIMER | SDL_INIT_AUDIO | SDL_INIT_CDROM | SDL_INIT_NOPARACHUTE) == -1) // "...Prevents SDL from catching fatal signals..." { ACE_DEBUG ((LM_ERROR, ACE_TEXT ("failed to SDL_Init(): \"%s\", aborting\n"), ACE_TEXT (SDL_GetError ()))); // *PORTABILITY*: on Windows, we must 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 // ***** keyboard setup ***** // enable Unicode translation SDL_EnableUNICODE (1); // enable key repeat SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL); // // ignore keyboard events // SDL_EventState(SDL_KEYDOWN, SDL_IGNORE); // SDL_EventState(SDL_KEYUP, SDL_IGNORE); // // SDL event filter (filter mouse motion events and the like) // SDL_SetEventFilter(event_filter_SDL_cb); // step3: do actual work ACE_High_Res_Timer timer; timer.start (); do_work (dump_dictionary, sound_directory, play_random_sounds, schema_repository, filename, validate_XML); 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 ()))); // step4a: fini SDL SDL_Quit (); // *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
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 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; }
int ACE_TMAIN (int argc_in, ACE_TCHAR** argv_in) { RPG_TRACE (ACE_TEXT ("::main")); std::string configuration_path = RPG_Common_File_Tools::getConfigurationDataDirectory (ACE_TEXT_ALWAYS_CHAR (BASEDIR), true); std::string data_path = RPG_Common_File_Tools::getConfigurationDataDirectory (ACE_TEXT_ALWAYS_CHAR (BASEDIR), false); #if defined (DEBUG_DEBUGGER) configuration_path = Common_File_Tools::getWorkingDirectory (); data_path = Common_File_Tools::getWorkingDirectory (); #endif // step1: init // step1a set defaults bool debug_scanner = MAP_PARSER_DEF_DEBUG_SCANNER; bool debug_parser = MAP_PARSER_DEF_DEBUG_PARSER; std::string map_file = data_path; map_file += ACE_DIRECTORY_SEPARATOR_CHAR_A; #if defined (DEBUG_DEBUGGER) map_file += (MAP_GENERATOR_DEF_LEVEL ? RPG_Common_Tools::sanitize (ACE_TEXT_ALWAYS_CHAR ("engine")) : ACE_TEXT_ALWAYS_CHAR ("map")); map_file += ACE_DIRECTORY_SEPARATOR_CHAR_A; map_file += ACE_TEXT_ALWAYS_CHAR ("data"); map_file += ACE_DIRECTORY_SEPARATOR_CHAR_A; #else map_file += ACE_TEXT_ALWAYS_CHAR(RPG_MAP_DEF_MAPS_SUB); map_file += ACE_DIRECTORY_SEPARATOR_CHAR_A; #endif map_file += (MAP_GENERATOR_DEF_LEVEL ? RPG_Common_Tools::sanitize (ACE_TEXT_ALWAYS_CHAR (RPG_ENGINE_LEVEL_DEF_NAME)) : ACE_TEXT_ALWAYS_CHAR (RPG_MAP_DEF_MAP_FILE)); map_file += (MAP_GENERATOR_DEF_LEVEL ? ACE_TEXT_ALWAYS_CHAR (RPG_ENGINE_LEVEL_FILE_EXT) : ACE_TEXT_ALWAYS_CHAR (RPG_MAP_FILE_EXT)); std::string schema_directory = configuration_path; #if defined (DEBUG_DEBUGGER) schema_directory = Common_File_Tools::getWorkingDirectory (); schema_directory += ACE_DIRECTORY_SEPARATOR_CHAR_A; schema_directory += ACE_TEXT_ALWAYS_CHAR ("engine"); #endif bool trace_information = false; bool print_version_and_exit = false; // step1ba: parse/process/validate configuration if (!do_processArguments (argc_in, argv_in, debug_scanner, debug_parser, map_file, trace_information, print_version_and_exit)) { // make 'em learn... do_printUsage (ACE::basename (argv_in[0])); // clean up // *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 // step1bb: validate arguments if (!Common_File_Tools::isReadable (map_file) || !Common_File_Tools::isDirectory (schema_directory)) { // make 'em learn... do_printUsage (ACE::basename (argv_in[0])); // clean up // *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 // step1c: 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"))); // clean up // *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 // step1d: handle specific program modes if (print_version_and_exit) { do_printVersion (ACE::basename (argv_in[0])); // clean up // *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 (); // step2: do actual work do_work (schema_directory, debug_scanner, debug_parser, map_file); timer.stop (); // debug info std::string working_time_string; ACE_Time_Value working_time; timer.elapsed_time (working_time); RPG_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 ()))); // *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; }
int Synchronized_Suspend_Resume_Test::svc () { #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "Synchronized_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 */ { Mutex_Acquire_Release_Test mutex_acquire_release_test (num_iterations); mutex_acquire_release_test.svc (); mutex_acquire_release_time_ = static_cast<ACE_UINT32> (mutex_acquire_release_test.elapsed_time () / num_iterations); #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "mutex_acquire_release: %u nsec\n", mutex_acquire_release_time_)); #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, "Synchronized_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. 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, "Synchronized_Suspend_Resume_Test::svc (), iteration " "%d, continue high-priority thread %u\n", i, high_.thread_id ())); } #endif /* ACE_DEBUG_CST */ { // Acquire the mutex so that the high priority thread will // block after we signal it via the condition variable. ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, mutex_, -1); // Release the semaphore so that the high priority thread can // proceed. if (sem_.release () != 0) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "sem_.release"), -1); timer_.start (); // Release the mutex so that the high priority thread can // proceed. The ACE_GUARD_RETURN macro implicity releases // the mutex. } } high_.done (); // The high priority thread will be block on the semaphore, so // release it. if (sem_.release () != 0) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "sem_.release"), -1); #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "Synchronized_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 */; #if ACE_DEBUG_CST > 0 ACE_DEBUG ((LM_DEBUG, "Synchronized_Suspend_Resume_Test::svc, finishing\n")); #endif /* ACE_DEBUG_CST */ return 0; }
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 )); } }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { if ( argc < 2 ) ACE_ERROR_RETURN ((LM_ERROR, "Usage: %s <rate> <PDU> <session> <host> <selector> [ host sel ] ...\n" "\tUse 0 for default values\n", argv[0]), 1); int rate = ACE_OS::atoi( argv[ 1 ]); rate = ( rate != 0 ) ? rate : 170000; int pdu_size = ACE_OS::atoi( argv[ 2 ]) * 1024; pdu_size = ( pdu_size != 0 ) ? pdu_size : 8192; int session = ACE_OS::atoi( argv[ 3 ]); session = ( session != 0 ) ? session : 100; ACE_OS::printf( "ATM_Client: rate: %d c/s, PDU: %dB, session: %d pkts\n", rate, pdu_size, session ); // Record all hosts/selectors ACE_ATM_Addr hosts[ MAX_LEAVES ]; int num_leaves = argc / 2 - 2; ACE_OS::printf( "ATM_Client: Connecting to ...\n" ); for ( int i = 0; i < num_leaves; i++ ) { hosts[ i ].set( argv[ i*2 + 4 ], ( argv[ i*2 + 5 ] != 0 ) ? ACE_OS::atoi( argv[ i*2 + 5 ]) : ACE_ATM_Addr::DEFAULT_SELECTOR ); ACE_OS::printf( "ATM_Client: leaf: %s (%s), sel: %d\n", argv[ i*2 + 4 ], hosts[ i ].addr_to_string(), hosts[ i ].get_selector()); } // The timeout really gets ignored since FORE's drivers don't work when // ioctl or fcntl calls are made on the transport id/file descriptor int timeout = ACE_DEFAULT_TIMEOUT; char buf[BUFSIZ]; ACE_ATM_Stream atm_stream; char hostname[ MAXNAMELEN ]; ACE_OS::hostname( hostname, MAXNAMELEN ); ACE_ATM_Addr local_addr( hostname, hosts[ 0 ].get_selector()); ACE_OS::printf( "ATM_Client: local host: %s(%s)\n", hostname, local_addr.addr_to_string()); // In order to construct connections options the file handle is // needed. Therefore, we need to open the ATM_Stream before we // construct the options. ACE_OS::printf( "ATM_Client: to open a stream\n" ); if (atm_stream.open () == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "open failed"), 1); ACE_DEBUG ((LM_DEBUG, "ATM_Client: starting non-blocking connection\n")); // Initiate timed, non-blocking connection with server. ACE_ATM_Connector con; // Construct QoS options - currently FORE only supports bandwidth ACE_OS::printf( "ATM_Client: specify cell rate at %d c/s\n", rate ); ACE_ATM_QoS qos; qos.set_rate(atm_stream.get_handle (), rate, ACE_ATM_QoS::OPT_FLAGS_CPID); if ( num_leaves == 1 ) { // Point-to-point connection // Not sure why but reuse_addr set to true/1 causes problems for // FORE/XTI/ATM - this is now handled in ACE_ATM_Connector::connect() ACE_OS::printf( "ATM_Client: to open a connection \n" ); ACE_ATM_Params params = ACE_ATM_Params(); if (con.connect (atm_stream, hosts[ 0 ], params, qos, (ACE_Time_Value *) &ACE_Time_Value::zero, local_addr, 0, 0 ) == -1) { if (errno != EWOULDBLOCK) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ATM_Client: connection failed"), 1); ACE_DEBUG ((LM_DEBUG, "ATM_Client: starting timed connection\n")); // Check if non-blocking connection is in progress, and wait up // to timeout seconds for it to complete. ACE_Time_Value tv (timeout); ACE_OS::printf( "ATM_Client: connection completed\n" ); if (con.complete (atm_stream, &hosts[ 0 ], &tv) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ATM_Client: connection failed"), 1); else ACE_DEBUG ((LM_DEBUG, "ATM_Client: connected to %s\n", hosts[ 0 ].addr_to_string())); } } else { // Point-to-multipoint connection for ( int i = 0; i < num_leaves; i++ ) { con.add_leaf( atm_stream, hosts[ i ], i, 0 ); } } /* if num_leaves == 1 */ ACE_UINT16 vpi, vci; atm_stream.get_vpi_vci(vpi, vci); ACE_DEBUG ((LM_DEBUG, "ATM_Client: connected to VPI %d VCI %d\n", vpi, vci)); // Send data to server (correctly handles "incomplete writes"). int s_bytes; int total; int xmit = 0; ACE_High_Res_Timer timer; ACE_Time_Value elapsed; double real_time; double actual_rate; for ( ;; ) { total = 0; timer.start_incr(); for ( ;; ) { s_bytes = atm_stream.send_n( buf, BUFSIZ, 0 ); if ( s_bytes == -1 ) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "send_n"), 1); total += s_bytes; if ( total >= session * pdu_size ) break; } timer.stop_incr(); timer.elapsed_time_incr( elapsed ); real_time = elapsed.sec() * ACE_ONE_SECOND_IN_USECS + elapsed.usec(); xmit += total; actual_rate = ( double )xmit * ( double )8 / real_time; ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) bytes = %d, usec = %f, rate = %0.00f Mbps\n"), xmit, real_time, actual_rate < 0 ? 0 : actual_rate )); } // Explicitly close the connection. ACE_OS::printf( "ATM_Client: close connection\n" ); if (atm_stream.close () == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "close"), -1); 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