TAO/performance-tests/Sequence_Latency/AMH_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 do_dump_history = 0;
  15 int do_shutdown = 1;
  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:hxk: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 'h':
  46         do_dump_history = 1;
  47         break;
  48
  49       case 'x':
  50         do_shutdown = 0;
  51         break;
  52
  53       case 'k':
  54         ior = get_opts.opt_arg ();
  55         break;
  56
  57       case 'i':
  58         niterations = ACE_OS::atoi (get_opts.opt_arg ());
  59         break;
  60
  61       case '?':
  62       default:
  63         ACE_ERROR_RETURN ((LM_ERROR,
  64                            "usage:  %s "
  65                            "-t <datatype> "
  66                            "-s <size> "
  67                            "-k <ior> "
  68                            "-i <niterations> "
  69                            "-x (disable shutdown) "
  70                            "-h (dump history) "
  71                            "\n",
  72                            argv [0]),
  73                           -1);
  74       }
  75   // Indicates successful parsing of the command line
  76   return 0;
  77 }
  78
  79
  80 void
  81 test_octet_seq (Test::Roundtrip_ptr roundtrip)
  82 {
  83   ACE_Sample_History history (niterations);
  84
  85   Test::octet_load ol (sz);
  86   ol.length (sz);
  87
  88   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
  89   for (int i = 0; i < niterations; ++i)
  90     {
  91       ACE_hrtime_t start = ACE_OS::gethrtime ();
  92
  93       (void) roundtrip->test_octet_method (ol, start);
  94
  95       ACE_hrtime_t now = ACE_OS::gethrtime ();
  96       history.sample (now - start);
  97     }
  98
  99   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 100
 101   ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 102
 103   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 104   ACE_High_Res_Timer::global_scale_factor_type gsf =
 105     ACE_High_Res_Timer::global_scale_factor ();
 106   ACE_DEBUG ((LM_DEBUG, "done\n"));
 107
 108   if (do_dump_history)
 109     {
 110       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 111     }
 112
 113   ACE_Basic_Stats stats;
 114   history.collect_basic_stats (stats);
 115   stats.dump_results (ACE_TEXT("Total"), gsf);
 116
 117   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 118                                          test_end - test_start,
 119                                          stats.samples_count ());
 120 }
 121
 122
 123 void
 124 test_long_seq (Test::Roundtrip_ptr roundtrip)
 125 {
 126   ACE_Sample_History history (niterations);
 127
 128   Test::long_load ll (sz);
 129   ll.length (sz);
 130
 131   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 132   for (int i = 0; i < niterations; ++i)
 133     {
 134       ACE_hrtime_t start = ACE_OS::gethrtime ();
 135
 136       (void) roundtrip->test_long_method (ll, start);
 137
 138       ACE_hrtime_t now = ACE_OS::gethrtime ();
 139       history.sample (now - start);
 140     }
 141
 142   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 143
 144   ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 145
 146   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 147   ACE_High_Res_Timer::global_scale_factor_type gsf =
 148     ACE_High_Res_Timer::global_scale_factor ();
 149   ACE_DEBUG ((LM_DEBUG, "done\n"));
 150
 151   if (do_dump_history)
 152     {
 153       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 154     }
 155
 156   ACE_Basic_Stats stats;
 157   history.collect_basic_stats (stats);
 158   stats.dump_results (ACE_TEXT("Total"), gsf);
 159
 160   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 161                                          test_end - test_start,
 162                                          stats.samples_count ());
 163 }
 164
 165
 166 void
 167 test_short_seq (Test::Roundtrip_ptr roundtrip)
 168 {
 169   ACE_Sample_History history (niterations);
 170
 171   Test::short_load sl (sz);
 172   sl.length (sz);
 173
 174   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 175   for (int i = 0; i < niterations; ++i)
 176     {
 177       ACE_hrtime_t start = ACE_OS::gethrtime ();
 178
 179       (void) roundtrip->test_short_method (sl, start);
 180
 181       ACE_hrtime_t now = ACE_OS::gethrtime ();
 182       history.sample (now - start);
 183     }
 184
 185   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 186
 187   ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 188
 189   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 190   ACE_High_Res_Timer::global_scale_factor_type gsf =
 191     ACE_High_Res_Timer::global_scale_factor ();
 192   ACE_DEBUG ((LM_DEBUG, "done\n"));
 193
 194   if (do_dump_history)
 195     {
 196       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 197     }
 198
 199   ACE_Basic_Stats stats;
 200   history.collect_basic_stats (stats);
 201   stats.dump_results (ACE_TEXT("Total"), gsf);
 202
 203   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 204                                          test_end - test_start,
 205                                          stats.samples_count ());
 206 }
 207
 208
 209 void
 210 test_char_seq (Test::Roundtrip_ptr roundtrip)
 211 {
 212   ACE_Sample_History history (niterations);
 213
 214   Test::char_load cl (sz);
 215   cl.length (sz);
 216
 217   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 218   for (int i = 0; i < niterations; ++i)
 219     {
 220       ACE_hrtime_t start = ACE_OS::gethrtime ();
 221
 222       (void) roundtrip->test_char_method (cl, 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, start);
 266
 267       ACE_hrtime_t now = ACE_OS::gethrtime ();
 268       history.sample (now - start);
 269     }
 270
 271   ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 272
 273   ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 274
 275   ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 276   ACE_High_Res_Timer::global_scale_factor_type gsf =
 277     ACE_High_Res_Timer::global_scale_factor ();
 278   ACE_DEBUG ((LM_DEBUG, "done\n"));
 279
 280   if (do_dump_history)
 281     {
 282       history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 283     }
 284
 285   ACE_Basic_Stats stats;
 286   history.collect_basic_stats (stats);
 287   stats.dump_results (ACE_TEXT("Total"), gsf);
 288
 289   ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 290                                          test_end - test_start,
 291                                          stats.samples_count ());
 292 }
 293
 294
 295 void
 296 test_double_seq (Test::Roundtrip_ptr roundtrip)
 297 {
 298   ACE_Sample_History history (niterations);
 299
 300   Test::double_load dl (sz);
 301   dl.length (sz);
 302
 303   ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 304   for (int i = 0; i < niterations; ++i)
 305     {
 306       ACE_hrtime_t start = ACE_OS::gethrtime ();
 307
 308       (void) roundtrip->test_double_method (dl, 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
 338 int
 339 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 340 {
 341   int priority =
 342     (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
 343      + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
 344   // Enable FIFO scheduling
 345
 346   if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO,
 347                                               priority,
 348                                               ACE_SCOPE_PROCESS)) != 0)
 349     {
 350       if (ACE_OS::last_error () == EPERM)
 351         {
 352           ACE_DEBUG ((LM_DEBUG,
 353                       "client (%P|%t): user is not superuser, "
 354                       "test runs in time-shared class\n"));
 355         }
 356       else
 357         ACE_ERROR ((LM_ERROR,
 358                     "client (%P|%t): sched_params failed\n"));
 359     }
 360
 361   try
 362     {
 363       CORBA::ORB_var orb =
 364         CORBA::ORB_init (argc, argv);
 365
 366       if (parse_args (argc, argv) != 0)
 367         return 1;
 368
 369       CORBA::Object_var object =
 370         orb->string_to_object (ior);
 371
 372       Test::Roundtrip_var roundtrip =
 373         Test::Roundtrip::_narrow (object.in ());
 374
 375       if (CORBA::is_nil (roundtrip.in ()))
 376         {
 377           ACE_ERROR_RETURN ((LM_ERROR,
 378                              "Nil Test::Roundtrip reference <%s>\n",
 379                              ior),
 380                             1);
 381         }
 382
 383       Test::octet_load oc;
 384
 385       for (int j = 0; j < 100; ++j)
 386         {
 387           ACE_hrtime_t start = 0;
 388           (void) roundtrip->test_octet_method (oc,
 389                                                start);
 390         }
 391
 392       if (ACE_OS::strcmp (data_type, ACE_TEXT("octet")) == 0)
 393         {
 394           test_octet_seq (roundtrip.in ());
 395         }
 396       else if (ACE_OS::strcmp (data_type, ACE_TEXT("char")) == 0)
 397         {
 398           test_char_seq (roundtrip.in ());
 399         }
 400       else if (ACE_OS::strcmp (data_type, ACE_TEXT("long")) == 0)
 401         {
 402           test_long_seq (roundtrip.in ());
 403         }
 404       else if (ACE_OS::strcmp (data_type, ACE_TEXT("short")) == 0)
 405         {
 406           test_short_seq (roundtrip.in ());
 407         }
 408       else if (ACE_OS::strcmp (data_type, ACE_TEXT("double")) == 0)
 409         {
 410           test_double_seq (roundtrip.in ());
 411         }
 412       else if (ACE_OS::strcmp (data_type, ACE_TEXT("longlong")) == 0)
 413         {
 414           test_longlong_seq (roundtrip.in ());
 415         }
 416
 417       if (do_shutdown)
 418         {
 419           roundtrip->shutdown ();
 420         }
 421     }
 422   catch (const CORBA::Exception& ex)
 423     {
 424       ex._tao_print_exception ("Exception caught:");
 425       return 1;
 426     }
 427
 428   return 0;
 429 }