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

   1 #include "tao/DynamicInterface/Request.h"  /* Must come first for G++
   2                                               3.4 or better */
   3
   4 #include "TestC.h"
   5
   6 #include "tao/Strategies/advanced_resource.h"
   7 #include "tao/AnyTypeCode/TypeCode_Constants.h"
   8
   9 #include "ace/Get_Opt.h"
  10 #include "ace/Sched_Params.h"
  11 #include "ace/High_Res_Timer.h"
  12 #include "ace/Sched_Params.h"
  13 #include "ace/Stats.h"
  14 #include "ace/Throughput_Stats.h"
  15 #include "ace/Sample_History.h"
  16 #include "ace/OS_NS_errno.h"
  17
  18 const ACE_TCHAR *ior = ACE_TEXT("file://test.ior");
  19 int niterations = 1000;
  20 int burst = 10;
  21 int do_shutdown = 1;
  22 int do_dump_history = 0;
  23 int sz = 512;
  24
  25 const ACE_TCHAR *data_type = ACE_TEXT("octet");
  26
  27 int
  28 parse_args (int argc, ACE_TCHAR *argv[])
  29 {
  30   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("t:s:hxk:i:b:"));
  31   int c;
  32
  33   while ((c = get_opts ()) != -1)
  34     switch (c)
  35       {
  36       case 't':
  37         data_type = get_opts.opt_arg ();
  38
  39         if (ACE_OS::strcmp (data_type, ACE_TEXT("octet")) != 0 &&
  40             ACE_OS::strcmp (data_type, ACE_TEXT("char")) != 0 &&
  41             ACE_OS::strcmp (data_type, ACE_TEXT("long")) != 0 &&
  42             ACE_OS::strcmp (data_type, ACE_TEXT("short")) != 0 &&
  43             ACE_OS::strcmp (data_type, ACE_TEXT("double")) != 0 &&
  44             ACE_OS::strcmp (data_type, ACE_TEXT("longlong")) != 0)
  45           return -1;
  46         break;
  47
  48           case 's':
  49         sz = ACE_OS::atoi (get_opts.opt_arg ());
  50         break;
  51
  52       case 'h':
  53         do_dump_history = 1;
  54         break;
  55
  56       case 'x':
  57         do_shutdown = 0;
  58         break;
  59
  60       case 'k':
  61         ior = get_opts.opt_arg ();
  62         break;
  63
  64       case 'i':
  65         niterations = ACE_OS::atoi (get_opts.opt_arg ());
  66         break;
  67
  68       case 'b':
  69         burst = ACE_OS::atoi (get_opts.opt_arg ());
  70         break;
  71
  72       case '?':
  73       default:
  74         ACE_ERROR_RETURN ((LM_ERROR,
  75                            "usage:  %s "
  76                            "-t <datatype> "
  77                                                    "-s <size> "
  78                                                    "-k <ior> "
  79                            "-i <niterations> "
  80                            "-b <burst> "
  81                            "-x (disable shutdown) "
  82                            "-h (dump history) "
  83                            "\n",
  84                            argv [0]),
  85                           -1);
  86       }
  87   // Indicates successful parsing of the command line
  88   return 0;
  89 }
  90
  91
  92 int
  93 test_octet_seq (Test::Roundtrip_ptr roundtrip)
  94 {
  95   ACE_Sample_History history (niterations);
  96
  97   Test::octet_load ol (sz);
  98   ol.length (sz);
  99
 100   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 101
 102   CORBA::Request_var *request;
 103   ACE_NEW_RETURN (request, CORBA::Request_var[burst], 1);
 104
 105   for (int i = 0; i < niterations; ++i)
 106     {
 107       int j;
 108
 109       for (j = 0; j != burst; ++j)
 110         {
 111           CORBA::ULongLong start = ACE_OS::gethrtime ();
 112
 113           request[j] =
 114             roundtrip->_request ("test_octet_method");
 115
 116           request[j]->add_in_arg ("octet_load") <<= ol;
 117           request[j]->add_in_arg ("send_time") <<= start;
 118                   request[j]->set_return_type (CORBA::_tc_ulonglong);
 119
 120           request[j]->send_deferred ();
 121         }
 122
 123       for (j = 0; j != burst; ++j)
 124         {
 125           request[j]->get_response ();
 126
 127           CORBA::ULongLong retval;
 128           if ((request[j]->return_value () >>= retval) == 1)
 129             {
 130               ACE_hrtime_t now = ACE_OS::gethrtime ();
 131               history.sample (ACE_HRTIME_TO_U64(now) - retval);
 132             }
 133         }
 134     }
 135   delete[] request;
 136
 137   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 138
 139   ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 140
 141   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 142   ACE_High_Res_Timer::global_scale_factor_type gsf =
 143     ACE_High_Res_Timer::global_scale_factor ();
 144   ACE_DEBUG ((LM_DEBUG, "done\n"));
 145
 146   if (do_dump_history)
 147     {
 148       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 149     }
 150
 151   ACE_Basic_Stats stats;
 152   history.collect_basic_stats (stats);
 153   stats.dump_results (ACE_TEXT("Total"), gsf);
 154
 155   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 156                                          test_end - test_start,
 157                                          stats.samples_count ());
 158   return 0;
 159 }
 160
 161
 162 int
 163 test_long_seq (Test::Roundtrip_ptr roundtrip)
 164 {
 165   ACE_Sample_History history (niterations);
 166
 167   Test::long_load ll (sz);
 168   ll.length (sz);
 169
 170   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 171
 172   CORBA::Request_var *request;
 173   ACE_NEW_RETURN (request, CORBA::Request_var[burst], 1);
 174
 175   for (int i = 0; i < niterations; ++i)
 176     {
 177       int j;
 178
 179       for (j = 0; j != burst; ++j)
 180         {
 181           CORBA::ULongLong start = ACE_OS::gethrtime ();
 182
 183           request[j] =
 184             roundtrip->_request ("test_long_method");
 185
 186           request[j]->add_in_arg ("long_load") <<= ll;
 187           request[j]->add_in_arg ("send_time") <<= start;
 188                                         request[j]->set_return_type (CORBA::_tc_ulonglong);
 189
 190           request[j]->send_deferred ();
 191         }
 192
 193       for (j = 0; j != burst; ++j)
 194         {
 195           request[j]->get_response ();
 196
 197           CORBA::ULongLong retval;
 198           if ((request[j]->return_value () >>= retval) == 1)
 199             {
 200               ACE_hrtime_t now = ACE_OS::gethrtime ();
 201               history.sample (ACE_HRTIME_TO_U64(now) - retval);
 202             }
 203         }
 204     }
 205   delete[] request;
 206
 207   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 208
 209   ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 210
 211   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 212   ACE_High_Res_Timer::global_scale_factor_type gsf =
 213     ACE_High_Res_Timer::global_scale_factor ();
 214   ACE_DEBUG ((LM_DEBUG, "done\n"));
 215
 216   if (do_dump_history)
 217     {
 218       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 219     }
 220
 221   ACE_Basic_Stats stats;
 222   history.collect_basic_stats (stats);
 223   stats.dump_results (ACE_TEXT("Total"), gsf);
 224
 225   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 226                                          test_end - test_start,
 227                                          stats.samples_count ());
 228   return 0;
 229 }
 230
 231
 232 int
 233 test_short_seq (Test::Roundtrip_ptr roundtrip)
 234 {
 235   ACE_Sample_History history (niterations);
 236
 237   Test::short_load sl (sz);
 238   sl.length (sz);
 239
 240   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 241
 242   CORBA::Request_var *request;
 243   ACE_NEW_RETURN (request, CORBA::Request_var[burst], 1);
 244
 245   for (int i = 0; i < niterations; ++i)
 246     {
 247       int j;
 248
 249       for (j = 0; j != burst; ++j)
 250         {
 251           CORBA::ULongLong start = ACE_OS::gethrtime ();
 252
 253           request[j] =
 254             roundtrip->_request ("test_short_method");
 255
 256           request[j]->add_in_arg ("short_load") <<= sl;
 257           request[j]->add_in_arg ("send_time") <<= start;
 258                                         request[j]->set_return_type (CORBA::_tc_ulonglong);
 259
 260           request[j]->send_deferred ();
 261         }
 262
 263       for (j = 0; j != burst; ++j)
 264         {
 265           request[j]->get_response ();
 266
 267           CORBA::ULongLong retval;
 268           if ((request[j]->return_value () >>= retval) == 1)
 269             {
 270               ACE_hrtime_t now = ACE_OS::gethrtime ();
 271               history.sample (ACE_HRTIME_TO_U64(now) - retval);
 272             }
 273         }
 274     }
 275   delete[] request;
 276
 277   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 278
 279   ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 280
 281   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 282   ACE_High_Res_Timer::global_scale_factor_type gsf =
 283     ACE_High_Res_Timer::global_scale_factor ();
 284   ACE_DEBUG ((LM_DEBUG, "done\n"));
 285
 286   if (do_dump_history)
 287     {
 288       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 289     }
 290
 291   ACE_Basic_Stats stats;
 292   history.collect_basic_stats (stats);
 293   stats.dump_results (ACE_TEXT("Total"), gsf);
 294
 295   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 296                                          test_end - test_start,
 297                                          stats.samples_count ());
 298   return 0;
 299 }
 300
 301
 302 int
 303 test_char_seq (Test::Roundtrip_ptr roundtrip)
 304 {
 305   ACE_Sample_History history (niterations);
 306
 307   Test::char_load cl (sz);
 308   cl.length (sz);
 309
 310   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 311
 312   CORBA::Request_var *request;
 313   ACE_NEW_RETURN (request, CORBA::Request_var[burst], 1);
 314
 315   for (int i = 0; i < niterations; ++i)
 316     {
 317       int j;
 318
 319       for (j = 0; j != burst; ++j)
 320         {
 321           CORBA::ULongLong start = ACE_OS::gethrtime ();
 322
 323           request[j] =
 324             roundtrip->_request ("test_char_method");
 325
 326           request[j]->add_in_arg ("char_load") <<= cl;
 327           request[j]->add_in_arg ("send_time") <<= start;
 328                                         request[j]->set_return_type (CORBA::_tc_ulonglong);
 329
 330           request[j]->send_deferred ();
 331         }
 332
 333       for (j = 0; j != burst; ++j)
 334         {
 335           request[j]->get_response ();
 336
 337           CORBA::ULongLong retval;
 338           if ((request[j]->return_value () >>= retval) == 1)
 339             {
 340               ACE_hrtime_t now = ACE_OS::gethrtime ();
 341               history.sample (ACE_HRTIME_TO_U64(now) - retval);
 342             }
 343         }
 344     }
 345   delete[] request;
 346
 347   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 348
 349   ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 350
 351   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 352   ACE_High_Res_Timer::global_scale_factor_type gsf =
 353     ACE_High_Res_Timer::global_scale_factor ();
 354   ACE_DEBUG ((LM_DEBUG, "done\n"));
 355
 356   if (do_dump_history)
 357     {
 358       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 359     }
 360
 361   ACE_Basic_Stats stats;
 362   history.collect_basic_stats (stats);
 363   stats.dump_results (ACE_TEXT("Total"), gsf);
 364
 365   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 366                                          test_end - test_start,
 367                                          stats.samples_count ());
 368   return 0;
 369 }
 370
 371
 372 int
 373 test_longlong_seq (Test::Roundtrip_ptr roundtrip)
 374 {
 375   ACE_Sample_History history (niterations);
 376
 377   Test::longlong_load ll (sz);
 378   ll.length (sz);
 379
 380   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 381
 382   CORBA::Request_var *request;
 383   ACE_NEW_RETURN (request, CORBA::Request_var[burst], 1);
 384
 385   for (int i = 0; i < niterations; ++i)
 386     {
 387       int j;
 388
 389       for (j = 0; j != burst; ++j)
 390         {
 391           CORBA::ULongLong start = ACE_OS::gethrtime ();
 392
 393           request[j] =
 394             roundtrip->_request ("test_longlong_method");
 395
 396           request[j]->add_in_arg ("longlong_load") <<= ll;
 397           request[j]->add_in_arg ("send_time") <<= start;
 398                                         request[j]->set_return_type (CORBA::_tc_ulonglong);
 399
 400           request[j]->send_deferred ();
 401         }
 402
 403       for (j = 0; j != burst; ++j)
 404         {
 405           request[j]->get_response ();
 406
 407           CORBA::ULongLong retval;
 408           if ((request[j]->return_value () >>= retval) == 1)
 409             {
 410               ACE_hrtime_t now = ACE_OS::gethrtime ();
 411               history.sample (ACE_HRTIME_TO_U64(now) - retval);
 412             }
 413         }
 414     }
 415   delete[] request;
 416
 417   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 418
 419   ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 420
 421   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 422   ACE_High_Res_Timer::global_scale_factor_type gsf =
 423     ACE_High_Res_Timer::global_scale_factor ();
 424   ACE_DEBUG ((LM_DEBUG, "done\n"));
 425
 426   if (do_dump_history)
 427     {
 428       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 429     }
 430
 431   ACE_Basic_Stats stats;
 432   history.collect_basic_stats (stats);
 433   stats.dump_results (ACE_TEXT("Total"), gsf);
 434
 435   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 436                                          test_end - test_start,
 437                                          stats.samples_count ());
 438   return 0;
 439 }
 440
 441
 442 int
 443 test_double_seq (Test::Roundtrip_ptr roundtrip)
 444 {
 445   ACE_Sample_History history (niterations);
 446
 447   Test::double_load dl (sz);
 448   dl.length (sz);
 449
 450   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 451
 452   CORBA::Request_var *request;
 453   ACE_NEW_RETURN (request, CORBA::Request_var[burst], 1);
 454
 455   for (int i = 0; i < niterations; ++i)
 456     {
 457       int j;
 458
 459       for (j = 0; j != burst; ++j)
 460         {
 461           CORBA::ULongLong start = ACE_OS::gethrtime ();
 462
 463           request[j] =
 464             roundtrip->_request ("test_double_method");
 465
 466           request[j]->add_in_arg ("double_load") <<= dl;
 467           request[j]->add_in_arg ("send_time") <<= start;
 468                                         request[j]->set_return_type (CORBA::_tc_ulonglong);
 469
 470           request[j]->send_deferred ();
 471         }
 472
 473       for (j = 0; j != burst; ++j)
 474         {
 475           request[j]->get_response ();
 476
 477           CORBA::ULongLong retval;
 478           if ((request[j]->return_value () >>= retval) == 1)
 479             {
 480               ACE_hrtime_t now = ACE_OS::gethrtime ();
 481               history.sample (ACE_HRTIME_TO_U64(now) - retval);
 482             }
 483         }
 484     }
 485   delete[] request;
 486
 487   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 488
 489   ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 490
 491   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 492   ACE_High_Res_Timer::global_scale_factor_type gsf =
 493     ACE_High_Res_Timer::global_scale_factor ();
 494   ACE_DEBUG ((LM_DEBUG, "done\n"));
 495
 496   if (do_dump_history)
 497     {
 498       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 499     }
 500
 501   ACE_Basic_Stats stats;
 502   history.collect_basic_stats (stats);
 503   stats.dump_results (ACE_TEXT("Total"), gsf);
 504
 505   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 506                                          test_end - test_start,
 507                                          stats.samples_count ());
 508   return 0;
 509 }
 510
 511
 512 // The main() function starts here
 513
 514 int
 515 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 516 {
 517   int priority =
 518     (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
 519      + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
 520   // Enable FIFO scheduling
 521
 522   if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO,
 523                                               priority,
 524                                               ACE_SCOPE_PROCESS)) != 0)
 525     {
 526       if (ACE_OS::last_error () == EPERM)
 527         {
 528           ACE_DEBUG ((LM_DEBUG,
 529                       "client (%P|%t): user is not superuser, "
 530                       "test runs in time-shared class\n"));
 531         }
 532       else
 533         ACE_ERROR ((LM_ERROR,
 534                     "client (%P|%t): sched_params failed\n"));
 535     }
 536
 537   try
 538     {
 539       CORBA::ORB_var orb =
 540         CORBA::ORB_init (argc, argv);
 541
 542       if (parse_args (argc, argv) != 0)
 543         return 1;
 544
 545       CORBA::Object_var object =
 546         orb->string_to_object (ior);
 547
 548       Test::Roundtrip_var roundtrip =
 549         Test::Roundtrip::_narrow (object.in ());
 550
 551       if (CORBA::is_nil (roundtrip.in ()))
 552         {
 553           ACE_ERROR_RETURN ((LM_ERROR,
 554                              "Nil Test::Roundtrip reference <%s>\n",
 555                              ior),
 556                             1);
 557         }
 558
 559           Test::octet_load oc;
 560
 561       for (int j = 0; j < 100; ++j)
 562         {
 563           ACE_hrtime_t start = 0;
 564           (void) roundtrip->test_octet_method (oc,
 565                                                start);
 566         }
 567
 568
 569           // Test various sequence types
 570
 571       if (ACE_OS::strcmp (data_type, ACE_TEXT("octet")) == 0)
 572         {
 573           test_octet_seq (roundtrip.in ());
 574         }
 575       else if (ACE_OS::strcmp (data_type, ACE_TEXT("char")) == 0)
 576         {
 577           test_char_seq (roundtrip.in ());
 578         }
 579       else if (ACE_OS::strcmp (data_type, ACE_TEXT("long")) == 0)
 580         {
 581           test_long_seq (roundtrip.in ());
 582         }
 583       else if (ACE_OS::strcmp (data_type, ACE_TEXT("short")) == 0)
 584         {
 585           test_short_seq (roundtrip.in ());
 586         }
 587       else if (ACE_OS::strcmp (data_type, ACE_TEXT("double")) == 0)
 588         {
 589           test_double_seq (roundtrip.in ());
 590         }
 591       else if (ACE_OS::strcmp (data_type, ACE_TEXT("longlong")) == 0)
 592         {
 593           test_longlong_seq (roundtrip.in ());
 594         }
 595
 596       if (do_shutdown)
 597         {
 598           roundtrip->shutdown ();
 599         }
 600     }
 601   catch (const CORBA::Exception& ex)
 602     {
 603       ex._tao_print_exception ("Caught exception:");
 604       return 1;
 605     }
 606
 607   return 0;
 608 }