TAO/tests/MT_Timeout/Client_Task.cpp

   1
   2 #include "Client_Task.h"
   3 #include "ace/OS_NS_unistd.h"
   4 #include "tao/TimeBaseC.h"
   5 #include "tao/Messaging/Messaging.h"
   6 #include "tao/AnyTypeCode/Any.h"
   7
   8 Client_Task::Client_Task (CORBA::ORB_ptr orb,
   9                           Test::Sleep_Service_ptr sleep_service,
  10                           int iterations,
  11                           CORBA::ULong sleep_time,
  12                           CORBA::ULong timeout)
  13   : orb_ (CORBA::ORB::_duplicate (orb))
  14   , sleep_service_ (Test::Sleep_Service::_duplicate (sleep_service))
  15   , iterations_ (iterations)
  16   , sleep_time_ (sleep_time)
  17   , timeout_ (timeout)
  18   , successful_calls_ (0)
  19   , timed_out_calls_ (0)
  20   , too_big_difference_ (0)
  21 {
  22 }
  23
  24 int
  25 Client_Task::successful_calls (void) const
  26 {
  27   return this->successful_calls_;
  28 }
  29
  30 int
  31 Client_Task::timed_out_calls (void) const
  32 {
  33   return this->timed_out_calls_;
  34 }
  35
  36 int
  37 Client_Task::too_big_difference_calls (void) const
  38 {
  39   return this->too_big_difference_;
  40 }
  41
  42 int
  43 Client_Task::svc (void)
  44 {
  45
  46   int successful_calls = 0;
  47   int timed_out_calls = 0;
  48
  49   try
  50     {
  51       this->validate_connection ();
  52
  53       CORBA::Object_var object =
  54         this->orb_->resolve_initial_references ("PolicyCurrent");
  55       CORBA::PolicyCurrent_var policy_current =
  56         CORBA::PolicyCurrent::_narrow (object.in ());
  57
  58       TimeBase::TimeT timeout_period = 10 * this->timeout_;
  59
  60       CORBA::Any timeout_as_any;
  61       timeout_as_any <<= timeout_period;
  62
  63       CORBA::PolicyList policy_list (1);
  64       policy_list.length (1);
  65       policy_list[0] =
  66         this->orb_->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
  67                                    timeout_as_any);
  68
  69       policy_current->set_policy_overrides (policy_list,
  70                                             CORBA::ADD_OVERRIDE);
  71
  72       for (int i = 0; i != this->iterations_; ++i)
  73         {
  74           int retval = this->one_iteration ();
  75
  76           if (retval == 1)
  77             ++successful_calls;
  78           else if (retval == 0)
  79             ++timed_out_calls;
  80
  81 #if 0
  82           if (i % 50 == 0)
  83             {
  84               ACE_DEBUG ((LM_DEBUG,
  85                           "(%P|%t) - Client_Task::svc %d / %d iterations\n",
  86                           i, this->iterations_));
  87             }
  88 #endif /* 0 */
  89         }
  90     }
  91   catch (const CORBA::Exception& ex)
  92     {
  93       ex._tao_print_exception ("Exception caught:");
  94       return -1;
  95     }
  96
  97   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->mutex_, -1);
  98   this->successful_calls_ += successful_calls;
  99   this->timed_out_calls_  += timed_out_calls;
 100
 101   return 0;
 102 }
 103
 104 void
 105 Client_Task::validate_connection (void)
 106 {
 107   try
 108     {
 109       for (int i = 0; i != 100; ++i)
 110         {
 111           (void) this->sleep_service_->go_to_sleep (0);
 112         }
 113     }
 114   catch (const CORBA::TRANSIENT& )
 115     {
 116       // Ignore transient exceptions
 117     }
 118 }
 119
 120 int
 121 Client_Task::one_iteration (void)
 122 {
 123   try
 124     {
 125       ACE_Time_Value start = ACE_OS::gettimeofday ();
 126
 127       this->sleep_service_->go_to_sleep (this->sleep_time_);
 128
 129       ACE_Time_Value end = ACE_OS::gettimeofday ();
 130
 131       if (this->sleep_time_ > this->timeout_)
 132         {
 133           // If we don't sleep then the next request will also
 134           // timeout:
 135           // The server is already sleeping, the client sends a new
 136           // request, but the server cannot process it until the
 137           // previous sleep completes. The sleep times for multiple
 138           // requests accumulate, and the client always fails.
 139           CORBA::ULong remainder =
 140             this->sleep_time_ - this->timeout_;
 141           ACE_Time_Value tv (0, remainder);
 142           ACE_OS::sleep (tv);
 143         }
 144
 145       if (this->timeout_ > 0)
 146         {
 147           CORBA::ULong max_milliseconds = this->timeout_ / 1000;
 148
 149           ACE_Time_Value elapsed = end - start;
 150           CORBA::ULong elapsed_milliseconds = elapsed.msec ();
 151
 152           if (elapsed_milliseconds > max_milliseconds)
 153             {
 154               CORBA::ULong difference =
 155                 elapsed_milliseconds - max_milliseconds;
 156
 157               // If the different is more than 10 milliseconds we are
 158               // *way* off, this is an error.
 159               if (difference > 10)
 160                 {
 161                   this->too_big_difference_++;
 162                   ACE_ERROR ((LM_ERROR,
 163                               "(%P|%t) Elapsed time = %d, expected %d\n",
 164                               elapsed_milliseconds, max_milliseconds));
 165                 }
 166             }
 167         }
 168
 169       return 1;
 170     }
 171   catch (const CORBA::TIMEOUT& )
 172     {
 173       // Ignore this exception, it is usually caused by a transient
 174       // condition
 175       return 0;
 176     }
 177   catch (const CORBA::Exception& ex)
 178     {
 179       ex._tao_print_exception ("Exception caught:");
 180     }
 181
 182   return -1;
 183 }