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

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