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

   1 #include "Roundtrip_Handler.h"
   2 #include "tao/debug.h"
   3 #include "ace/Get_Opt.h"
   4 #include "ace/High_Res_Timer.h"
   5 #include "ace/Sched_Params.h"
   6 #include "ace/Stats.h"
   7 #include "ace/Throughput_Stats.h"
   8 #include "ace/OS_NS_errno.h"
   9 #include "ace/OS_NS_string.h"
  10
  11 const ACE_TCHAR *ior = ACE_TEXT("file://test.ior");
  12
  13 ACE_hrtime_t throughput_base;
  14
  15 int niterations = 1000;
  16 int sz = 512;
  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("t:s:k:i:"));
  24   int c;
  25
  26   while ((c = get_opts ()) != -1)
  27     switch (c)
  28       {
  29       case 't':
  30         data_type = get_opts.opt_arg ();
  31
  32         if (ACE_OS::strcmp (data_type, ACE_TEXT("octet")) != 0 &&
  33             ACE_OS::strcmp (data_type, ACE_TEXT("char")) != 0 &&
  34             ACE_OS::strcmp (data_type, ACE_TEXT("long")) != 0 &&
  35             ACE_OS::strcmp (data_type, ACE_TEXT("short")) != 0 &&
  36             ACE_OS::strcmp (data_type, ACE_TEXT("double")) != 0 &&
  37             ACE_OS::strcmp (data_type, ACE_TEXT("longlong")) != 0)
  38           return -1;
  39         break;
  40
  41           case 's':
  42         sz = ACE_OS::atoi (get_opts.opt_arg ());
  43         break;
  44
  45           case 'k':
  46         ior = get_opts.opt_arg ();
  47         break;
  48
  49       case 'i':
  50         niterations = ACE_OS::atoi (get_opts.opt_arg ());
  51         break;
  52
  53       case '?':
  54       default:
  55         ACE_ERROR_RETURN ((LM_ERROR,
  56                            "usage:  %s "
  57                            "-t <datatype> "
  58                            "-s <size> "
  59                            "-k <ior> "
  60                            "-i <niterations> "
  61                            "-p <period (msecs)> "
  62                            "-b <burst size> "
  63                            "\n",
  64                            argv [0]),
  65                           -1);
  66       }
  67   // Indicates successful parsing of the command line
  68   return 0;
  69 }
  70
  71
  72 void test_octet_seq (Test::Roundtrip_ptr roundtrip,
  73                      CORBA::ORB_ptr orb,
  74                      Test::AMI_RoundtripHandler_ptr roundtrip_handler,
  75                      Roundtrip_Handler *roundtrip_handler_impl)
  76 {
  77   Test::octet_load ol (sz);
  78   ol.length (sz);
  79
  80   Test::AMI_RoundtripHandler_var rth =
  81           Test::AMI_RoundtripHandler::_duplicate (roundtrip_handler);
  82
  83   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
  84
  85   for (int i = 0; i != niterations; ++i)
  86          {
  87            // Invoke asynchronous operation....
  88            roundtrip->sendc_test_octet_method (rth.in (),
  89                                                ol,
  90                                                ACE_OS::gethrtime ());
  91            if (orb->work_pending ())
  92                   orb->perform_work ();
  93          }
  94
  95   ACE_Time_Value tv (0, 2000);
  96
  97   while (roundtrip_handler_impl->pending_callbacks ())
  98          {
  99            orb->perform_work (tv);
 100          }
 101
 102   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 103
 104   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 105   ACE_High_Res_Timer::global_scale_factor_type gsf =
 106     ACE_High_Res_Timer::global_scale_factor ();
 107   ACE_DEBUG ((LM_DEBUG, "done\n"));
 108
 109   roundtrip_handler_impl->dump_results (gsf);
 110
 111   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 112                                          test_end - test_start,
 113                                          niterations);
 114 }
 115
 116
 117 void test_char_seq  (Test::Roundtrip_ptr roundtrip,
 118                      CORBA::ORB_ptr orb,
 119                      Test::AMI_RoundtripHandler_ptr roundtrip_handler,
 120                      Roundtrip_Handler *roundtrip_handler_impl)
 121 {
 122   Test::char_load cl (sz);
 123   cl.length (sz);
 124
 125   Test::AMI_RoundtripHandler_var rth =
 126           Test::AMI_RoundtripHandler::_duplicate (roundtrip_handler);
 127
 128   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 129
 130   for (int i = 0; i != niterations; ++i)
 131          {
 132            // Invoke asynchronous operation....
 133            roundtrip->sendc_test_char_method  (rth.in (),
 134                                                cl,
 135                                                ACE_OS::gethrtime ());
 136            if (orb->work_pending ())
 137                   orb->perform_work ();
 138          }
 139
 140   ACE_Time_Value tv (0, 2000);
 141
 142   while (roundtrip_handler_impl->pending_callbacks ())
 143          {
 144            orb->perform_work (tv);
 145          }
 146
 147   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 148
 149   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 150   ACE_High_Res_Timer::global_scale_factor_type gsf =
 151     ACE_High_Res_Timer::global_scale_factor ();
 152   ACE_DEBUG ((LM_DEBUG, "done\n"));
 153
 154   roundtrip_handler_impl->dump_results (gsf);
 155
 156   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 157                                          test_end - test_start,
 158                                          niterations);
 159 }
 160
 161
 162 void test_long_seq  (Test::Roundtrip_ptr roundtrip,
 163                      CORBA::ORB_ptr orb,
 164                      Test::AMI_RoundtripHandler_ptr roundtrip_handler,
 165                      Roundtrip_Handler *roundtrip_handler_impl)
 166 {
 167   Test::long_load ll (sz);
 168   ll.length (sz);
 169
 170   Test::AMI_RoundtripHandler_var rth =
 171           Test::AMI_RoundtripHandler::_duplicate (roundtrip_handler);
 172
 173   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 174
 175   for (int i = 0; i != niterations; ++i)
 176          {
 177            // Invoke asynchronous operation....
 178            roundtrip->sendc_test_long_method (rth.in (),
 179                                               ll,
 180                                               ACE_OS::gethrtime ());
 181            if (orb->work_pending ())
 182                   orb->perform_work ();
 183          }
 184
 185   ACE_Time_Value tv (0, 2000);
 186
 187   while (roundtrip_handler_impl->pending_callbacks ())
 188          {
 189            orb->perform_work (tv);
 190          }
 191
 192   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 193
 194   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 195   ACE_High_Res_Timer::global_scale_factor_type gsf =
 196     ACE_High_Res_Timer::global_scale_factor ();
 197   ACE_DEBUG ((LM_DEBUG, "done\n"));
 198
 199   roundtrip_handler_impl->dump_results (gsf);
 200
 201   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 202                                          test_end - test_start,
 203                                          niterations);
 204 }
 205
 206
 207 void test_short_seq (Test::Roundtrip_ptr roundtrip,
 208                      CORBA::ORB_ptr orb,
 209                      Test::AMI_RoundtripHandler_ptr roundtrip_handler,
 210                      Roundtrip_Handler *roundtrip_handler_impl)
 211 {
 212   Test::short_load sl (sz);
 213   sl.length (sz);
 214
 215   Test::AMI_RoundtripHandler_var rth =
 216           Test::AMI_RoundtripHandler::_duplicate (roundtrip_handler);
 217
 218   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 219
 220   for (int i = 0; i != niterations; ++i)
 221          {
 222            // Invoke asynchronous operation....
 223            roundtrip->sendc_test_short_method (rth.in (),
 224                                                sl,
 225                                                ACE_OS::gethrtime ());
 226            if (orb->work_pending ())
 227                   orb->perform_work ();
 228          }
 229
 230   ACE_Time_Value tv (0, 2000);
 231
 232   while (roundtrip_handler_impl->pending_callbacks ())
 233          {
 234            orb->perform_work (tv);
 235          }
 236
 237   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 238
 239   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 240   ACE_High_Res_Timer::global_scale_factor_type gsf =
 241     ACE_High_Res_Timer::global_scale_factor ();
 242   ACE_DEBUG ((LM_DEBUG, "done\n"));
 243
 244   roundtrip_handler_impl->dump_results (gsf);
 245
 246   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 247                                          test_end - test_start,
 248                                          niterations);
 249 }
 250
 251
 252 void test_double_seq (Test::Roundtrip_ptr roundtrip,
 253                       CORBA::ORB_ptr orb,
 254                       Test::AMI_RoundtripHandler_ptr roundtrip_handler,
 255                       Roundtrip_Handler *roundtrip_handler_impl)
 256 {
 257   Test::double_load dl (sz);
 258   dl.length (sz);
 259
 260   Test::AMI_RoundtripHandler_var rth =
 261           Test::AMI_RoundtripHandler::_duplicate (roundtrip_handler);
 262
 263   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 264
 265   for (int i = 0; i != niterations; ++i)
 266          {
 267            // Invoke asynchronous operation....
 268            roundtrip->sendc_test_double_method (rth.in (),
 269                                                 dl,
 270                                                 ACE_OS::gethrtime ());
 271            if (orb->work_pending ())
 272                   orb->perform_work ();
 273          }
 274
 275   ACE_Time_Value tv (0, 2000);
 276
 277   while (roundtrip_handler_impl->pending_callbacks ())
 278          {
 279            orb->perform_work (tv);
 280          }
 281
 282   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 283
 284   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 285   ACE_High_Res_Timer::global_scale_factor_type gsf =
 286     ACE_High_Res_Timer::global_scale_factor ();
 287   ACE_DEBUG ((LM_DEBUG, "done\n"));
 288
 289   roundtrip_handler_impl->dump_results (gsf);
 290
 291   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 292                                          test_end - test_start,
 293                                          niterations);
 294 }
 295
 296
 297 void test_longlong_seq (Test::Roundtrip_ptr roundtrip,
 298                         CORBA::ORB_ptr orb,
 299                         Test::AMI_RoundtripHandler_ptr roundtrip_handler,
 300                         Roundtrip_Handler *roundtrip_handler_impl)
 301 {
 302   Test::longlong_load ll (sz);
 303   ll.length (sz);
 304
 305   Test::AMI_RoundtripHandler_var rth =
 306           Test::AMI_RoundtripHandler::_duplicate (roundtrip_handler);
 307
 308   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 309
 310   for (int i = 0; i != niterations; ++i)
 311          {
 312            // Invoke asynchronous operation....
 313            roundtrip->sendc_test_longlong_method (rth.in (),
 314                                                   ll,
 315                                                   ACE_OS::gethrtime ());
 316            if (orb->work_pending ())
 317                   orb->perform_work ();
 318          }
 319
 320   ACE_Time_Value tv (0, 2000);
 321
 322   while (roundtrip_handler_impl->pending_callbacks ())
 323          {
 324            orb->perform_work (tv);
 325          }
 326
 327   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 328
 329   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 330   ACE_High_Res_Timer::global_scale_factor_type gsf =
 331     ACE_High_Res_Timer::global_scale_factor ();
 332   ACE_DEBUG ((LM_DEBUG, "done\n"));
 333
 334   roundtrip_handler_impl->dump_results (gsf);
 335
 336   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 337                                          test_end - test_start,
 338                                          niterations);
 339 }
 340
 341
 342 // Main function starts below
 343
 344 int
 345 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 346 {
 347   int priority =
 348     (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
 349      + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
 350   // Enable FIFO scheduling
 351
 352   if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO,
 353                                               priority,
 354                                               ACE_SCOPE_PROCESS)) != 0)
 355     {
 356       if (ACE_OS::last_error () == EPERM)
 357         {
 358           ACE_DEBUG ((LM_DEBUG,
 359                       "client (%P|%t): user is not superuser, "
 360                       "test runs in time-shared class\n"));
 361         }
 362       else
 363         ACE_ERROR ((LM_ERROR,
 364                     "client (%P|%t): sched_params failed\n"));
 365     }
 366
 367   try
 368     {
 369       CORBA::ORB_var orb =
 370         CORBA::ORB_init (argc, argv);
 371
 372       CORBA::Object_var poa_object =
 373         orb->resolve_initial_references("RootPOA");
 374
 375       if (CORBA::is_nil (poa_object.in ()))
 376         ACE_ERROR_RETURN ((LM_ERROR,
 377                            " (%P|%t) Unable to initialize the POA.\n"),
 378                           1);
 379
 380       PortableServer::POA_var root_poa =
 381         PortableServer::POA::_narrow (poa_object.in ());
 382
 383       PortableServer::POAManager_var poa_manager =
 384         root_poa->the_POAManager ();
 385
 386       if (parse_args (argc, argv) != 0)
 387         return 1;
 388
 389       CORBA::Object_var object =
 390         orb->string_to_object (ior);
 391
 392       Test::Roundtrip_var roundtrip =
 393         Test::Roundtrip::_narrow (object.in ());
 394
 395       if (CORBA::is_nil (roundtrip.in ()))
 396         ACE_ERROR_RETURN ((LM_ERROR,
 397                            "Nil Test::Roundtrip reference <%s>\n",
 398                            ior),
 399                           1);
 400
 401           Test::octet_load oc;
 402
 403       for (int j = 0; j < 100; ++j)
 404         {
 405           ACE_hrtime_t start = 0;
 406           (void) roundtrip->test_octet_method (oc,
 407                                                start);
 408         }
 409
 410       Roundtrip_Handler *roundtrip_handler_impl;
 411       ACE_NEW_RETURN (roundtrip_handler_impl,
 412                       Roundtrip_Handler (niterations),
 413                       1);
 414       PortableServer::ServantBase_var owner_transfer(roundtrip_handler_impl);
 415
 416       Test::AMI_RoundtripHandler_var roundtrip_handler =
 417         roundtrip_handler_impl->_this ();
 418
 419       poa_manager->activate ();
 420
 421       if (ACE_OS::strcmp (data_type, ACE_TEXT("octet")) == 0 )
 422         {
 423           test_octet_seq (roundtrip.in (),
 424                           orb.in (),
 425                           roundtrip_handler.in (),
 426                           roundtrip_handler_impl);
 427         }
 428       else if (ACE_OS::strcmp (data_type, ACE_TEXT("char")) == 0)
 429         {
 430           test_char_seq (roundtrip.in (),
 431                          orb.in (),
 432                          roundtrip_handler.in (),
 433                          roundtrip_handler_impl);
 434         }
 435       else if (ACE_OS::strcmp (data_type, ACE_TEXT("long")) == 0)
 436         {
 437           test_long_seq (roundtrip.in (),
 438                          orb.in (),
 439                          roundtrip_handler.in (),
 440                          roundtrip_handler_impl);
 441         }
 442       else if (ACE_OS::strcmp (data_type, ACE_TEXT("short")) == 0)
 443         {
 444           test_short_seq (roundtrip.in (),
 445                           orb.in (),
 446                           roundtrip_handler.in (),
 447                           roundtrip_handler_impl);
 448         }
 449       else if (ACE_OS::strcmp (data_type, ACE_TEXT("double")) == 0)
 450         {
 451           test_double_seq (roundtrip.in (),
 452                            orb.in (),
 453                            roundtrip_handler.in (),
 454                            roundtrip_handler_impl);
 455         }
 456       else if (ACE_OS::strcmp (data_type, ACE_TEXT("longlong")) == 0)
 457         {
 458           test_longlong_seq (roundtrip.in (),
 459                              orb.in (),
 460                              roundtrip_handler.in (),
 461                              roundtrip_handler_impl);
 462         }
 463
 464       roundtrip->shutdown ();
 465
 466       root_poa->destroy (true, true);
 467
 468       orb->destroy ();
 469     }
 470   catch (const CORBA::Exception& ex)
 471     {
 472       ex._tao_print_exception ("Exception caught: ");
 473       return 1;
 474     }
 475
 476   return 0;
 477 }