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

   1 #include "tao/DynamicInterface/Request.h"  /* This must come first for
   2                                               G++ 3.4 or better */
   3
   4 #include "TestC.h"
   5
   6 #include "tao/AnyTypeCode/TypeCode_Constants.h"
   7
   8 #include "tao/Strategies/advanced_resource.h"
   9
  10 #include "ace/Get_Opt.h"
  11 #include "ace/Sched_Params.h"
  12 #include "ace/High_Res_Timer.h"
  13 #include "ace/Sched_Params.h"
  14 #include "ace/Stats.h"
  15 #include "ace/Throughput_Stats.h"
  16 #include "ace/Sample_History.h"
  17 #include "ace/OS_NS_errno.h"
  18
  19 const ACE_TCHAR *ior = ACE_TEXT("file://test.ior");
  20 int niterations = 1000;
  21 int burst = 10;
  22 int do_shutdown = 1;
  23 int do_dump_history = 0;
  24
  25 int
  26 parse_args (int argc, ACE_TCHAR *argv[])
  27 {
  28   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("hxk:i:b:"));
  29   int c;
  30
  31   while ((c = get_opts ()) != -1)
  32     switch (c)
  33       {
  34       case 'h':
  35         do_dump_history = 1;
  36         break;
  37
  38       case 'x':
  39         do_shutdown = 0;
  40         break;
  41
  42       case 'k':
  43         ior = get_opts.opt_arg ();
  44         break;
  45
  46       case 'i':
  47         niterations = ACE_OS::atoi (get_opts.opt_arg ());
  48         break;
  49
  50       case 'b':
  51         burst = ACE_OS::atoi (get_opts.opt_arg ());
  52         break;
  53
  54       case '?':
  55       default:
  56         ACE_ERROR_RETURN ((LM_ERROR,
  57                            "usage:  %s "
  58                            "-k <ior> "
  59                            "-i <niterations> "
  60                            "-b <burst> "
  61                            "-x (disable shutdown) "
  62                            "-h (dump history) "
  63                            "\n",
  64                            argv [0]),
  65                           -1);
  66       }
  67   // Indicates successful parsing of the command line
  68   return 0;
  69 }
  70
  71 int
  72 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
  73 {
  74   int priority =
  75     (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
  76      + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
  77   // Enable FIFO scheduling
  78
  79   if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO,
  80                                               priority,
  81                                               ACE_SCOPE_PROCESS)) != 0)
  82     {
  83       if (ACE_OS::last_error () == EPERM)
  84         {
  85           ACE_DEBUG ((LM_DEBUG,
  86                       "client (%P|%t): user is not superuser, "
  87                       "test runs in time-shared class\n"));
  88         }
  89       else
  90         ACE_ERROR ((LM_ERROR,
  91                     "client (%P|%t): sched_params failed\n"));
  92     }
  93
  94   try
  95     {
  96       CORBA::ORB_var orb =
  97         CORBA::ORB_init (argc, argv);
  98
  99       if (parse_args (argc, argv) != 0)
 100         return 1;
 101
 102       CORBA::Object_var object =
 103         orb->string_to_object (ior);
 104
 105       Test::Roundtrip_var roundtrip =
 106         Test::Roundtrip::_narrow (object.in ());
 107
 108       if (CORBA::is_nil (roundtrip.in ()))
 109         {
 110           ACE_ERROR_RETURN ((LM_ERROR,
 111                              "Nil Test::Roundtrip reference <%s>\n",
 112                              ior),
 113                             1);
 114         }
 115
 116       for (int j = 0; j < 100; ++j)
 117         {
 118           ACE_hrtime_t start = 0;
 119           (void) roundtrip->test_method (start);
 120         }
 121
 122       ACE_Sample_History history (niterations);
 123
 124       ACE_hrtime_t test_start = ACE_OS::gethrtime ();
 125
 126       CORBA::Request_var *request;
 127       ACE_NEW_RETURN (request, CORBA::Request_var[burst], 1);
 128
 129       for (int i = 0; i < niterations; ++i)
 130         {
 131           int j;
 132
 133           for (j = 0; j != burst; ++j)
 134             {
 135               CORBA::ULongLong start = ACE_OS::gethrtime ();
 136
 137               request[j] =
 138                 roundtrip->_request ("test_method");
 139
 140               request[j]->add_in_arg () <<= start;
 141               request[j]->set_return_type (CORBA::_tc_ulonglong);
 142
 143               request[j]->send_deferred ();
 144             }
 145
 146           for (j = 0; j != burst; ++j)
 147             {
 148               request[j]->get_response ();
 149
 150               CORBA::ULongLong retval;
 151               if ((request[j]->return_value () >>= retval) == 1)
 152                 {
 153                   ACE_hrtime_t now = ACE_OS::gethrtime ();
 154                   history.sample (ACE_HRTIME_TO_U64(now) - retval);
 155                 }
 156             }
 157         }
 158       delete[] request;
 159
 160       ACE_hrtime_t test_end = ACE_OS::gethrtime ();
 161
 162       ACE_DEBUG ((LM_DEBUG, "test finished\n"));
 163
 164       ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
 165       ACE_High_Res_Timer::global_scale_factor_type gsf =
 166         ACE_High_Res_Timer::global_scale_factor ();
 167       ACE_DEBUG ((LM_DEBUG, "done\n"));
 168
 169       if (do_dump_history)
 170         {
 171           history.dump_samples (ACE_TEXT("HISTORY"), gsf);
 172         }
 173
 174       ACE_Basic_Stats stats;
 175       history.collect_basic_stats (stats);
 176       stats.dump_results (ACE_TEXT("Total"), gsf);
 177
 178       ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Total"), gsf,
 179                                              test_end - test_start,
 180                                              stats.samples_count ());
 181
 182       if (do_shutdown)
 183         {
 184           roundtrip->shutdown ();
 185         }
 186     }
 187   catch (const CORBA::Exception& ex)
 188     {
 189       ex._tao_print_exception ("Caught exception:");
 190       return 1;
 191     }
 192
 193   return 0;
 194 }