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

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