TAO/performance-tests/Sequence_Latency/Single_Threaded/client.cpp

   1 #include "TestC.h"
   2 #include "ace/Get_Opt.h"
   3 #include "ace/High_Res_Timer.h"
   4 #include "ace/Sched_Params.h"
   5 #include "ace/Stats.h"
   6 #include "ace/Throughput_Stats.h"
   7 #include "ace/Sample_History.h"
   8 #include "ace/OS_NS_errno.h"
   9
  10 #include "tao/Strategies/advanced_resource.h"
  11
  12 const ACE_TCHAR *ior = ACE_TEXT("file://test.ior");
  13 int niterations = 100;
  14 int sz = 512;
  15 int do_dump_history = 0;
  16 int do_shutdown = 1;
  17
  18 const ACE_TCHAR *data_type = ACE_TEXT("octet");
  19
  20 int
  21 parse_args (int argc, ACE_TCHAR *argv[])
  22 {
  23   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("ht:xs:k:i:"));
  24   int c;
  25
  26   while ((c = get_opts ()) != -1)
  27     switch (c)
  28       {
  29       case 'h':
  30         do_dump_history = 1;
  31         break;
  32
  33       case 't':
  34         data_type = get_opts.opt_arg ();
  35
  36         if (ACE_OS::strcmp (data_type, ACE_TEXT("octet")) != 0 &&
  37             ACE_OS::strcmp (data_type, ACE_TEXT("char")) != 0 &&
  38             ACE_OS::strcmp (data_type, ACE_TEXT("long")) != 0 &&
  39             ACE_OS::strcmp (data_type, ACE_TEXT("short")) != 0 &&
  40             ACE_OS::strcmp (data_type, ACE_TEXT("double")) != 0 &&
  41             ACE_OS::strcmp (data_type, ACE_TEXT("longlong")) != 0)
  42           return -1;
  43         break;
  44
  45       case 'x':
  46         do_shutdown = 0;
  47         break;
  48
  49       case 'k':
  50         ior = get_opts.opt_arg ();
  51         break;
  52
  53       case 'i':
  54         niterations = ACE_OS::atoi (get_opts.opt_arg ());
  55         break;
  56
  57       case 's':
  58         sz = ACE_OS::atoi (get_opts.opt_arg ());
  59         break;
  60
  61       case '?':
  62       default:
  63         ACE_ERROR_RETURN ((LM_ERROR,
  64                            "usage:  %s "
  65                            "-k <ior> "
  66                            "-i <niterations> "
  67                            "-x (disable shutdown) "
  68                            "-h (dump history) "
  69                            "\n",
  70                            argv [0]),
  71                           -1);
  72       }
  73   // Indicates successful parsing of the command line
  74   return 0;
  75 }
  76
  77 void
  78 test_octet_seq (Test::Roundtrip_ptr roundtrip)
  79 {
  80   ACE_Sample_History history (niterations);
  81
  82   Test::octet_load ol (sz);
  83   ol.length (sz);
  84
  85   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
  86   for (int i = 0; i < niterations; ++i)
  87     {
  88       ACE_hrtime_t start = ACE_OS::gethrtime ();
  89
  90       (void) roundtrip->test_octet_method (ol,
  91                                            start);
  92
  93       ACE_hrtime_t now = ACE_OS::gethrtime ();
  94
  95       history.sample (now - start);
  96     }
  97
  98   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
  99
 100   ACE_DEBUG ((LM_DEBUG, "Octet test finished\n"));
 101
 102   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 103   ACE_High_Res_Timer::global_scale_factor_type gsf =
 104     ACE_High_Res_Timer::global_scale_factor ();
 105   ACE_DEBUG ((LM_DEBUG, "done\n"));
 106
 107   if (do_dump_history)
 108     {
 109       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 110     }
 111
 112   ACE_Basic_Stats stats;
 113   history.collect_basic_stats (stats);
 114   stats.dump_results (ACE_TEXT("Total"), gsf);
 115
 116   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 117                                          test_end - test_start,
 118                                          stats.samples_count ());
 119 }
 120
 121 void
 122 test_long_seq (Test::Roundtrip_ptr roundtrip)
 123 {
 124   ACE_Sample_History history (niterations);
 125
 126   Test::long_load ll (sz);
 127   ll.length (sz);
 128
 129   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 130   for (int i = 0; i < niterations; ++i)
 131     {
 132       ACE_hrtime_t start = ACE_OS::gethrtime ();
 133
 134       (void) roundtrip->test_long_method (ll,
 135                                           start);
 136
 137       ACE_hrtime_t now = ACE_OS::gethrtime ();
 138       history.sample (now - start);
 139     }
 140
 141   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 142
 143   ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 144
 145   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 146   ACE_High_Res_Timer::global_scale_factor_type gsf =
 147     ACE_High_Res_Timer::global_scale_factor ();
 148   ACE_DEBUG ((LM_DEBUG, "done\n"));
 149
 150   if (do_dump_history)
 151     {
 152       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 153     }
 154
 155   ACE_Basic_Stats stats;
 156   history.collect_basic_stats (stats);
 157   stats.dump_results (ACE_TEXT("Total"), gsf);
 158
 159   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 160                                          test_end - test_start,
 161                                          stats.samples_count ());
 162 }
 163
 164 void
 165 test_short_seq (Test::Roundtrip_ptr roundtrip)
 166 {
 167   ACE_Sample_History history (niterations);
 168
 169   Test::short_load sl (sz);
 170   sl.length (sz);
 171   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 172   for (int i = 0; i < niterations; ++i)
 173     {
 174       ACE_hrtime_t start = ACE_OS::gethrtime ();
 175
 176       (void) roundtrip->test_short_method (sl,
 177                                            start);
 178
 179       ACE_hrtime_t now = ACE_OS::gethrtime ();
 180       history.sample (now - start);
 181     }
 182
 183   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 184
 185   ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 186
 187   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 188   ACE_High_Res_Timer::global_scale_factor_type gsf =
 189     ACE_High_Res_Timer::global_scale_factor ();
 190   ACE_DEBUG ((LM_DEBUG, "done\n"));
 191
 192   if (do_dump_history)
 193     {
 194       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 195     }
 196
 197   ACE_Basic_Stats stats;
 198   history.collect_basic_stats (stats);
 199   stats.dump_results (ACE_TEXT("Total"), gsf);
 200
 201   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 202                                          test_end - test_start,
 203                                          stats.samples_count ());
 204 }
 205
 206 void
 207 test_char_seq (Test::Roundtrip_ptr roundtrip)
 208 {
 209   ACE_Sample_History history (niterations);
 210
 211   Test::char_load cl (sz);
 212   cl.length (sz);
 213
 214   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 215   for (int i = 0; i < niterations; ++i)
 216     {
 217       ACE_hrtime_t start = ACE_OS::gethrtime ();
 218
 219       (void) roundtrip->test_char_method (cl,
 220                                           start);
 221
 222       ACE_hrtime_t now = ACE_OS::gethrtime ();
 223       history.sample (now - start);
 224     }
 225
 226   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 227
 228   ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 229
 230   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 231   ACE_High_Res_Timer::global_scale_factor_type gsf =
 232     ACE_High_Res_Timer::global_scale_factor ();
 233   ACE_DEBUG ((LM_DEBUG, "done\n"));
 234
 235   if (do_dump_history)
 236     {
 237       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 238     }
 239
 240   ACE_Basic_Stats stats;
 241   history.collect_basic_stats (stats);
 242   stats.dump_results (ACE_TEXT("Total"), gsf);
 243
 244   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 245                                          test_end - test_start,
 246                                          stats.samples_count ());
 247 }
 248
 249 void
 250 test_longlong_seq (Test::Roundtrip_ptr roundtrip)
 251 {
 252   ACE_Sample_History history (niterations);
 253
 254   Test::longlong_load ll (sz);
 255   ll.length (sz);
 256
 257
 258   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 259   for (int i = 0; i < niterations; ++i)
 260     {
 261       ACE_hrtime_t start = ACE_OS::gethrtime ();
 262
 263       (void) roundtrip->test_longlong_method (ll,
 264                                               start);
 265
 266       ACE_hrtime_t now = ACE_OS::gethrtime ();
 267       history.sample (now - start);
 268     }
 269
 270   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 271
 272   ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 273
 274   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 275   ACE_High_Res_Timer::global_scale_factor_type gsf =
 276     ACE_High_Res_Timer::global_scale_factor ();
 277   ACE_DEBUG ((LM_DEBUG, "done\n"));
 278
 279   if (do_dump_history)
 280     {
 281       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 282     }
 283
 284   ACE_Basic_Stats stats;
 285   history.collect_basic_stats (stats);
 286   stats.dump_results (ACE_TEXT("Total"), gsf);
 287
 288   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 289                                          test_end - test_start,
 290                                          stats.samples_count ());
 291 }
 292
 293 void
 294 test_double_seq (Test::Roundtrip_ptr roundtrip)
 295 {
 296   ACE_Sample_History history (niterations);
 297
 298   Test::double_load dl (sz);
 299   dl.length (sz);
 300
 301
 302   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 303   for (int i = 0; i < niterations; ++i)
 304     {
 305       ACE_hrtime_t start = ACE_OS::gethrtime ();
 306
 307       (void) roundtrip->test_double_method (dl,
 308                                             start);
 309
 310       ACE_hrtime_t now = ACE_OS::gethrtime ();
 311       history.sample (now - start);
 312     }
 313
 314   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 315
 316   ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 317
 318   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 319   ACE_High_Res_Timer::global_scale_factor_type gsf =
 320     ACE_High_Res_Timer::global_scale_factor ();
 321   ACE_DEBUG ((LM_DEBUG, "done\n"));
 322
 323   if (do_dump_history)
 324     {
 325       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 326     }
 327
 328   ACE_Basic_Stats stats;
 329   history.collect_basic_stats (stats);
 330   stats.dump_results (ACE_TEXT("Total"), gsf);
 331
 332   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 333                                          test_end - test_start,
 334                                          stats.samples_count ());
 335 }
 336
 337 int
 338 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 339 {
 340   int priority =
 341     (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
 342      + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
 343   // Enable FIFO scheduling, e.g., RT scheduling class on Solaris.
 344
 345   if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO,
 346                                               priority,
 347                                               ACE_SCOPE_PROCESS)) != 0)
 348     {
 349       if (ACE_OS::last_error () == EPERM)
 350         {
 351           ACE_DEBUG ((LM_DEBUG,
 352                       "client (%P|%t): user is not superuser, "
 353                       "test runs in time-shared class\n"));
 354         }
 355       else
 356         ACE_ERROR ((LM_ERROR,
 357                     "client (%P|%t): sched_params failed\n"));
 358     }
 359
 360   try
 361     {
 362       CORBA::ORB_var orb =
 363         CORBA::ORB_init (argc, argv);
 364
 365       if (parse_args (argc, argv) != 0)
 366         return 1;
 367
 368       CORBA::Object_var object =
 369         orb->string_to_object (ior);
 370
 371       Test::Roundtrip_var roundtrip =
 372         Test::Roundtrip::_narrow (object.in ());
 373
 374       if (CORBA::is_nil (roundtrip.in ()))
 375         {
 376           ACE_ERROR_RETURN ((LM_ERROR,
 377                              "Nil Test::Roundtrip reference <%s>\n",
 378                              ior),
 379                             1);
 380         }
 381
 382       Test::octet_load oc;
 383
 384       for (int j = 0; j < 100; ++j)
 385         {
 386           ACE_hrtime_t start = 0;
 387           (void) roundtrip->test_octet_method (oc,
 388                                                start);
 389         }
 390
 391       if (ACE_OS::strcmp (data_type, ACE_TEXT("octet")) == 0)
 392         {
 393           test_octet_seq (roundtrip.in ());
 394         }
 395       else if (ACE_OS::strcmp (data_type, ACE_TEXT("char")) == 0)
 396         {
 397           test_char_seq (roundtrip.in ());
 398         }
 399       else if (ACE_OS::strcmp (data_type, ACE_TEXT("long")) == 0)
 400         {
 401           test_long_seq (roundtrip.in ());
 402         }
 403       else if (ACE_OS::strcmp (data_type, ACE_TEXT("short")) == 0)
 404         {
 405           test_short_seq (roundtrip.in ());
 406         }
 407       else if (ACE_OS::strcmp (data_type, ACE_TEXT("double")) == 0)
 408         {
 409           test_double_seq (roundtrip.in ());
 410         }
 411       else if (ACE_OS::strcmp (data_type, ACE_TEXT("longlong")) == 0)
 412         {
 413           test_longlong_seq (roundtrip.in ());
 414         }
 415
 416       if (do_shutdown)
 417         {
 418           roundtrip->shutdown ();
 419         }
 420     }
 421   catch (const CORBA::Exception& ex)
 422     {
 423       ex._tao_print_exception ("Exception caught:");
 424       return 1;
 425     }
 426
 427   return 0;
 428 }