TAO/tests/Portable_Interceptors/Benchmark/client.cpp

   1 #include "testC.h"
   2 #include "marker.h"
   3 #include "Client_ORBInitializer.h"
   4 #include "Interceptor_Type.h"
   5
   6 #include "tao/debug.h"
   7 #include "tao/ORBInitializer_Registry.h"
   8
   9 #include "ace/Get_Opt.h"
  10 #include "ace/OS_NS_errno.h"
  11
  12 const ACE_TCHAR *ior = ACE_TEXT ("file://test.ior");
  13 int niterations = 5;
  14 int register_interceptor = 1;
  15
  16 int
  17 parse_args (int argc, ACE_TCHAR *argv[])
  18 {
  19   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("ef:n:"));
  20   int c;
  21
  22   while ((c = get_opts ()) != -1)
  23     switch (c)
  24       {
  25       case 'e':
  26         break;
  27       case 'f':
  28         ior = get_opts.opt_arg ();
  29         break;
  30       case 'n':
  31         niterations = ACE_OS::atoi (get_opts.opt_arg ());
  32         break;
  33       case '?':
  34       default:
  35         ACE_ERROR_RETURN ((LM_ERROR,
  36                            "usage:  %s "
  37                            "-v -r <register_interceptor> "
  38                            "\n",
  39                            argv [0]),
  40                           -1);
  41       }
  42   return 0;
  43 }
  44
  45
  46 void
  47 run_test (Test_Interceptors::Secure_Vault_ptr server)
  48 {
  49   int i = 0;
  50   const char user[] = "root";
  51   Marker marker;
  52   ACE_Throughput_Stats throughput;
  53
  54   ACE_DEBUG ((LM_DEBUG, "High res. timer calibration...."));
  55   ACE_High_Res_Timer::global_scale_factor_type gsf =
  56     ACE_High_Res_Timer::global_scale_factor ();
  57   ACE_DEBUG ((LM_DEBUG, "done\n"));
  58
  59   marker.accumulate_into (throughput, 1);
  60   ACE_hrtime_t throughput_base = ACE_OS::gethrtime ();
  61   for (i = 0; i < niterations ; ++i)
  62     {
  63       // Record current time.
  64       ACE_hrtime_t latency_base = ACE_OS::gethrtime ();
  65
  66       server->ready ();
  67
  68       // Grab timestamp again.
  69       ACE_hrtime_t now = ACE_OS::gethrtime ();
  70
  71       // Record statistics.
  72       marker.sample (now - throughput_base,
  73                      now - latency_base,
  74                      1);
  75
  76       if (TAO_debug_level > 0 && i % 100 == 0)
  77         ACE_DEBUG ((LM_DEBUG, "(%P|%t) iteration = %d\n", i));
  78     }
  79
  80   marker.dump_stats (ACE_TEXT ("Ready method  "), gsf, 1);
  81
  82   try
  83     {
  84       marker.accumulate_into (throughput, 2);
  85       throughput_base = ACE_OS::gethrtime ();
  86
  87       for (i = 0; i < niterations ; ++i)
  88         {
  89           // Record current time.
  90           ACE_hrtime_t latency_base = ACE_OS::gethrtime ();
  91
  92           server->authenticate (user);
  93
  94           // Grab timestamp again.
  95           ACE_hrtime_t now = ACE_OS::gethrtime ();
  96
  97           // Record statistics.
  98           marker.sample (now - throughput_base,
  99                          now - latency_base,
 100                          2);
 101
 102           if (TAO_debug_level > 0 && i % 100 == 0)
 103             ACE_DEBUG ((LM_DEBUG, "(%P|%t) iteration = %d\n", i));
 104         }
 105       marker.dump_stats (ACE_TEXT ("Authenticate method  "), gsf, 2);
 106     }
 107   catch (const Test_Interceptors::Invalid&)
 108     {
 109       ACE_DEBUG ((LM_DEBUG, "Invalid user\n"));
 110     }
 111
 112   Test_Interceptors::Secure_Vault::Record record;
 113   record.check_num = 1;
 114   record.amount = 1000;
 115   CORBA::Long id = 1;
 116
 117   marker.accumulate_into (throughput, 3);
 118   throughput_base = ACE_OS::gethrtime ();
 119
 120   for (i = 0; i < niterations ; ++i)
 121     {
 122       // Record current time.
 123       ACE_hrtime_t latency_base = ACE_OS::gethrtime ();
 124
 125       server->update_records (id,
 126                               record);
 127
 128       // Grab timestamp again.
 129       ACE_hrtime_t now = ACE_OS::gethrtime ();
 130
 131       // Record statistics.
 132       marker.sample (now - throughput_base,
 133                      now - latency_base,
 134                      3);
 135
 136       if (TAO_debug_level > 0 && i % 100 == 0)
 137         ACE_DEBUG ((LM_DEBUG, "(%P|%t) iteration = %d\n", i));
 138     }
 139
 140   marker.dump_stats (ACE_TEXT ("update records  method  "), gsf, 3);
 141 }
 142
 143
 144 int
 145 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 146 {
 147   int priority =
 148     (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
 149      + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
 150   // Enable FIFO scheduling
 151
 152   if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO,
 153                                               priority,
 154                                               ACE_SCOPE_PROCESS)) != 0)
 155     {
 156       if (ACE_OS::last_error () == EPERM)
 157         {
 158           ACE_DEBUG ((LM_DEBUG,
 159                       "client (%P|%t): user is not superuser, "
 160                       "test runs in time-shared class\n"));
 161         }
 162       else
 163         ACE_ERROR ((LM_ERROR,
 164                     "client (%P|%t): sched_params failed\n"));
 165     }
 166
 167   int interceptor_type;
 168   get_interceptor_type (argc, argv, interceptor_type);
 169
 170   try
 171     {
 172       PortableInterceptor::ORBInitializer_ptr temp_initializer;
 173
 174       ACE_NEW_RETURN (temp_initializer,
 175                       Client_ORBInitializer (interceptor_type),
 176                       -1);  // No exceptions yet!
 177       PortableInterceptor::ORBInitializer_var initializer =
 178         temp_initializer;
 179
 180       PortableInterceptor::register_orb_initializer (initializer.in ());
 181
 182       CORBA::ORB_var orb =
 183         CORBA::ORB_init (argc, argv);
 184
 185       if (parse_args (argc, argv) != 0)
 186         return 1;
 187
 188       CORBA::Object_var object =
 189         orb->string_to_object (ior);
 190
 191       Test_Interceptors::Secure_Vault_var server =
 192         Test_Interceptors::Secure_Vault::_narrow (object.in ());
 193
 194       if (CORBA::is_nil (server.in ()))
 195         {
 196           ACE_ERROR_RETURN ((LM_ERROR,
 197                              "Object reference <%s> is nil.\n",
 198                              ior),
 199                             1);
 200         }
 201
 202       ACE_DEBUG ((LM_DEBUG, "\nFunctionality test begins now...\n"));
 203
 204       // This test is useful for  benchmarking the differences when
 205       // the same method is intercepted by different interceptors
 206       // wanting to achieve different functionality.
 207       run_test (server.in ());
 208
 209       server->shutdown ();
 210     }
 211   catch (const CORBA::Exception& ex)
 212     {
 213       ex._tao_print_exception ("Caught exception:");
 214      return 1;
 215     }
 216
 217   return 0;
 218 }