TAO/tests/RTCORBA/Bug_3643_Regression/client.cpp

   1 #include "ace/Get_Opt.h"
   2 #include "testC.h"
   3 #include "tao/RTCORBA/RTCORBA.h"
   4 #include "tao/ORB_Core.h"
   5 #include "ace/Task.h"
   6 #include "ace/OS_NS_unistd.h"
   7 #include "ace/OS_NS_time.h"
   8
   9 const ACE_TCHAR *ior = ACE_TEXT ("file://ior_1");
  10 int iterations = 1000;
  11 int shutdown_server = 0;
  12 bool decreased = false;
  13
  14 const char *
  15 sched_policy_name (int sched_policy)
  16 {
  17   const char *name = 0;
  18
  19   switch (sched_policy)
  20     {
  21     case ACE_SCHED_OTHER:
  22       name = "SCHED_OTHER";
  23       break;
  24     case ACE_SCHED_RR:
  25       name = "SCHED_RR";
  26       break;
  27     case ACE_SCHED_FIFO:
  28       name = "SCHED_FIFO";
  29       break;
  30     }
  31
  32   return name;
  33 }
  34
  35 int
  36 parse_args (int argc, ACE_TCHAR *argv[])
  37 {
  38   ACE_Get_Opt get_opts (argc, argv, "xk:i:");
  39   int c;
  40
  41   while ((c = get_opts ()) != -1)
  42     switch (c)
  43       {
  44       case 'x':
  45         shutdown_server = 1;
  46         break;
  47
  48       case 'k':
  49         ior = get_opts.opt_arg ();
  50         break;
  51
  52       case 'i':
  53         iterations = ACE_OS::atoi (get_opts.opt_arg ());
  54         break;
  55
  56       case '?':
  57       default:
  58         ACE_ERROR_RETURN ((LM_ERROR,
  59                            "usage:  %s "
  60                            "-k <ior> "
  61                            "-i <iterations> "
  62                            "-x [shutdown server] "
  63                            "\n",
  64                            argv [0]),
  65                           -1);
  66       }
  67
  68   // Indicates successful parsing of the command line
  69   return 0;
  70 }
  71
  72 class Task : public ACE_Task_Base
  73 {
  74 public:
  75   Task (ACE_Thread_Manager &thread_manager,
  76         CORBA::ORB_ptr orb);
  77
  78   int svc ();
  79
  80   CORBA::ORB_var orb_;
  81 };
  82
  83 Task::Task (ACE_Thread_Manager &thread_manager,
  84             CORBA::ORB_ptr orb)
  85   : ACE_Task_Base (&thread_manager),
  86     orb_ (CORBA::ORB::_duplicate (orb))
  87 {
  88 }
  89
  90 int
  91 Task::svc ()
  92 {
  93   try
  94     {
  95       CORBA::Object_var object =
  96         this->orb_->string_to_object (ior);
  97
  98       test_var test =
  99         test::_narrow (object.in ());
 100
 101       pid_t pid =
 102         ACE_OS::getpid ();
 103
 104       CORBA::Long tc = 0;
 105
 106       struct timespec millis;
 107       millis.tv_sec  = 0L;
 108       millis.tv_nsec = 50 * 1000000L; // 1e6 nanos per milli
 109
 110       ACE_hrtime_t start = ACE_OS::gethrtime();
 111
 112       for (int i = 0; i != iterations; ++i)
 113         {
 114           // ~20 req/sec means to sleep 50 millis between each
 115           ACE_OS::nanosleep(&millis); // ignore signals
 116
 117           CORBA::Long mtc = 0;
 118           CORBA::Long r =
 119             test->method (pid,
 120                           i,
 121                           mtc);
 122
 123           ACE_ASSERT (r == i);
 124           // Assert disappears on with optimizations on.
 125           ACE_UNUSED_ARG (r);
 126
 127           if (mtc > tc)
 128             {
 129               // Number of threads increased, so store this.
 130               ACE_DEBUG ((LM_DEBUG, "Thread count increased to %d\n", mtc));
 131               tc = mtc;
 132             }
 133           else if (mtc < tc)
 134             {
 135               // Number of threads decreased!
 136               ACE_DEBUG ((LM_DEBUG, "Thread count decreased to %d\n", mtc));
 137               decreased = true;
 138               tc = mtc;
 139             }
 140         }
 141       ACE_hrtime_t duration = ACE_OS::gethrtime() - start;
 142       double tp = ((double) iterations) / (duration / 1000000);
 143       tp *= 1000.0;
 144       ACE_DEBUG ((LM_DEBUG, "Throughput: %d\n", tp));
 145
 146       ACE_OS::sleep (10);
 147
 148       CORBA::Long end = 0;
 149       CORBA::Long re =
 150         test->method (pid,
 151                       0,
 152                       end);
 153
 154       ACE_ASSERT (re == 0);
 155       // Assert disappears on with optimizations on.
 156       ACE_UNUSED_ARG (re);
 157
 158       if (end != 0)
 159         {
 160           ACE_ERROR ((LM_ERROR, "Dynamic thread count should be 0, not %d\n", end));
 161         }
 162
 163       if (shutdown_server)
 164         {
 165           test->shutdown ();
 166         }
 167     }
 168   catch (const CORBA::Exception& ex)
 169     {
 170       ex._tao_print_exception ("Exception caught:");
 171       return -1;
 172     }
 173
 174   return 0;
 175 }
 176
 177 int
 178 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 179 {
 180   try
 181     {
 182       CORBA::ORB_var orb =
 183         CORBA::ORB_init (argc, argv);
 184
 185       int result =
 186         parse_args (argc, argv);
 187       if (result != 0)
 188         return result;
 189
 190       // Thread Manager for managing task.
 191       ACE_Thread_Manager thread_manager;
 192
 193       // Create task.
 194       Task task (thread_manager,
 195                  orb.in ());
 196
 197       // Task activation flags.
 198       long flags =
 199         THR_NEW_LWP |
 200         THR_JOINABLE |
 201         orb->orb_core ()->orb_params ()->thread_creation_flags ();
 202
 203       // Activate task.
 204       result = task.activate (flags);
 205
 206       if (result == -1)
 207         {
 208           if (errno == EPERM)
 209             {
 210               ACE_ERROR_RETURN ((LM_ERROR,
 211                                  "Cannot create thread with scheduling policy %s\n"
 212                                  "because the user does not have the appropriate privileges, terminating program....\n"
 213                                  "Check svc.conf options and/or run as root\n",
 214                                  sched_policy_name (orb->orb_core ()->orb_params ()->ace_sched_policy ())),
 215                                 2);
 216             }
 217           else
 218             // Unexpected error.
 219             ACE_ASSERT (0);
 220         }
 221
 222       // Wait for task to exit.
 223       result =
 224         thread_manager.wait ();
 225       ACE_ASSERT (result != -1);
 226
 227       if (decreased == false)
 228         {
 229           ACE_ERROR_RETURN ((LM_ERROR, "ERROR: Number of threads didn't decrease\n"), -1);
 230         }
 231     }
 232   catch (const CORBA::Exception& ex)
 233     {
 234       ex._tao_print_exception ("Exception caught");
 235       return -1;
 236     }
 237
 238   return 0;
 239 }