TAO/examples/RTScheduling/Fixed_Priority_Scheduler/test.cpp

   1 #include "test.h"
   2 #include "tao/RTScheduling/RTScheduler_Manager.h"
   3 #include "tao/ORB_Core.h"
   4 #include "ace/Arg_Shifter.h"
   5 #include "../Task_Stats.h"
   6 #include "../Synch_i.h"
   7 #include "ace/OS_NS_errno.h"
   8
   9 #include "ace/Event_Handler.h"
  10 #include "ace/Sig_Handler.h"
  11
  12 class TestShutdown : public ACE_Event_Handler
  13 {
  14 public:
  15   TestShutdown (CORBA::ORB_ptr orb)
  16     : orb_(CORBA::ORB::_duplicate (orb))
  17   {
  18 #if !defined(ACE_LACKS_UNIX_SIGNALS)
  19     this->shutdown_.register_handler (SIGTERM, this);
  20     this->shutdown_.register_handler (SIGINT, this);
  21 #elif defined(ACE_WIN32)
  22     this->shutdown_.register_handler (SIGINT, this);
  23 #endif
  24   }
  25
  26   ~TestShutdown (void)
  27   {
  28 #if !defined(ACE_LACKS_UNIX_SIGNALS)
  29     this->shutdown_.remove_handler (SIGTERM);
  30     this->shutdown_.remove_handler (SIGINT);
  31 #elif defined(ACE_WIN32)
  32     this->shutdown_.remove_handler (SIGINT);
  33 #endif
  34   }
  35
  36   virtual int handle_signal (int, siginfo_t*, ucontext_t*)
  37   {
  38     ACE_DEBUG ((LM_DEBUG, "Shutting down...\n"));
  39     this->orb_->shutdown ();
  40     return 0;
  41   }
  42
  43 private:
  44   CORBA::ORB_var orb_;
  45
  46   ACE_Sig_Handler shutdown_;
  47 };
  48
  49 DT_Test::DT_Test (void)
  50 {
  51   base_t = ACE_OS::gethrtime ();
  52 }
  53
  54 void
  55 DT_Test::check_supported_priorities (void)
  56 {
  57   // Check that we have sufficient priority range to run this
  58   // test, i.e., more than 1 priority level.
  59
  60   this->thr_sched_policy_ = orb_->orb_core ()->orb_params ()->sched_policy ();
  61   this->thr_scope_policy_ = orb_->orb_core ()->orb_params ()->scope_policy ();
  62
  63   if (thr_sched_policy_ == THR_SCHED_RR)
  64     {
  65       //if (TAO_debug_level > 0)
  66       ACE_DEBUG ((LM_DEBUG, "Sched policy = THR_SCHED_RR\n"));
  67
  68       sched_policy_ = ACE_SCHED_RR;
  69     }
  70   else
  71   if (thr_sched_policy_ == THR_SCHED_FIFO)
  72     {
  73       // if (TAO_debug_level > 0)
  74         ACE_DEBUG ((LM_DEBUG, "Sched policy = THR_SCHED_FIFO\n"));
  75
  76       sched_policy_ = ACE_SCHED_FIFO;
  77     }
  78   else
  79     {
  80       if (TAO_debug_level > 0)
  81         ACE_DEBUG ((LM_DEBUG, "Sched policy = THR_SCHED_OTHER\n"));
  82
  83       sched_policy_ = ACE_SCHED_OTHER;
  84     }
  85
  86   if (thr_sched_policy_ == THR_SCHED_RR || thr_sched_policy_ == THR_SCHED_FIFO)
  87     {
  88       max_priority_ = ACE_Sched_Params::priority_max (sched_policy_);
  89       min_priority_ = ACE_Sched_Params::priority_min (sched_policy_);
  90
  91       if (max_priority_ == min_priority_)
  92         {
  93           ACE_DEBUG ((LM_DEBUG,
  94                       "Not enough priority levels on this platform"
  95                       " to run the test, aborting\n"));
  96           ACE_OS::exit (2);
  97         }
  98       else ACE_DEBUG ((LM_DEBUG, "max_priority = %d, min_priority = %d\n",
  99                        max_priority_, min_priority_));
 100     }
 101 }
 102
 103 int
 104 DT_Test::init (int argc, ACE_TCHAR *argv [])
 105 {
 106   orb_ = CORBA::ORB_init (argc, argv);
 107
 108   this->check_supported_priorities ();
 109
 110   dt_creator_->orb (orb_.in ());
 111
 112   TASK_STATS::instance ()->init (dt_creator_->total_load ());
 113
 114   CORBA::Object_var manager_obj = orb_->resolve_initial_references ("RTSchedulerManager");
 115
 116   TAO_RTScheduler_Manager_var manager = TAO_RTScheduler_Manager::_narrow (manager_obj.in ());
 117
 118
 119   ACE_NEW_RETURN (scheduler_,
 120                   Fixed_Priority_Scheduler (orb_.in ()),
 121                   -1);
 122
 123   manager->rtscheduler (scheduler_.in ());
 124
 125   CORBA::Object_var object =
 126     orb_->resolve_initial_references ("RTScheduler_Current");
 127
 128   current_  =
 129     RTScheduling::Current::_narrow (object.in ());
 130
 131
 132   if (sched_policy_ != ACE_SCHED_OTHER)
 133     {
 134       //Set the main thread to max priority...
 135       if (ACE_OS::sched_params (ACE_Sched_Params (sched_policy_,
 136                                 55,
 137                                 ACE_SCOPE_PROCESS)) != 0)
 138         {
 139           if (ACE_OS::last_error () == EPERM)
 140             {
 141               ACE_DEBUG ((LM_DEBUG,
 142                           "(%P|%t): user is not superuser, "
 143                           "test runs in time-shared class\n"));
 144             }
 145           else
 146             ACE_ERROR ((LM_ERROR,
 147                         "(%P|%t): sched_params failed\n"));
 148         }
 149     }
 150
 151   return 0;
 152 }
 153
 154 void
 155 DT_Test::run (int argc, ACE_TCHAR* argv [])
 156 {
 157   init (argc,argv);
 158
 159   TestShutdown killer (this->orb_.in ());
 160
 161   if (this->dt_creator_->resolve_naming_service () == -1)
 162     return;
 163
 164
 165   //TASK_STATS::instance ()->init (this->dt_creator_->dt_count () * 100);
 166
 167
 168   this->dt_creator_->activate_root_poa ();
 169
 170   this->dt_creator_->activate_poa_list ();
 171   this->dt_creator_->activate_job_list ();
 172   this->dt_creator_->activate_schedule ();
 173
 174   this->dt_creator_->register_synch_obj ();
 175
 176   ACE_DEBUG ((LM_DEBUG,
 177               "Registered Synch Object\n"));
 178
 179   /*
 180   dt_creator_->create_distributable_threads (current_.in ());
 181   */
 182
 183   this->activate_task ();
 184
 185   char msg [BUFSIZ];
 186   ACE_OS::sprintf (msg, "ORB RUN\n");
 187   this->dt_creator_->log_msg (msg);
 188
 189   orb_->run ();
 190
 191   ACE_Thread_Manager::instance ()->wait ();
 192
 193   orb_->destroy ();
 194 }
 195
 196 void
 197 DT_Test::dt_creator (FP_DT_Creator* dt_creator)
 198 {
 199   this->dt_creator_ = dt_creator;
 200 }
 201
 202 FP_DT_Creator*
 203 DT_Test::dt_creator (void)
 204 {
 205   return this->dt_creator_;
 206 }
 207
 208 Fixed_Priority_Scheduler*
 209 DT_Test::scheduler (void)
 210 {
 211   return this->scheduler_.in ();
 212 }
 213
 214 int
 215 DT_Test::activate_task (void)
 216 {
 217
 218   ACE_DEBUG ((LM_DEBUG,
 219               "Test Activate Task\n"));
 220
 221   long flags;
 222   flags = THR_NEW_LWP | THR_JOINABLE;
 223   flags |=
 224     orb_->orb_core ()->orb_params ()->scope_policy () |
 225     orb_->orb_core ()->orb_params ()->sched_policy ();
 226
 227   if (this->activate (flags,
 228                       1,
 229                       0,
 230                       50) == -1)
 231     {
 232       if (ACE_OS::last_error () == EPERM)
 233         ACE_ERROR_RETURN ((LM_ERROR,
 234                            ACE_TEXT ("Insufficient privilege to run this test.\n")),
 235                           -1);
 236     }
 237
 238   return 0;
 239 }
 240
 241 int
 242 DT_Test::svc (void)
 243 {
 244   try
 245     {
 246       ACE_DEBUG ((LM_DEBUG,
 247                   "In test::svc\n"));
 248
 249       dt_creator_->create_distributable_threads (current_.in ());
 250     }
 251   catch (const CORBA::BAD_INV_ORDER &)
 252     {
 253       // This exception can occur if ORB is already shutdown.
 254     }
 255   catch (const CORBA::Exception& ex)
 256     {
 257       ex._tao_print_exception ("Caught exception:");
 258       return -1;
 259     }
 260
 261   return 0;
 262 }
 263
 264 CORBA::ORB_ptr
 265 DT_Test::orb (void)
 266 {
 267   return this->orb_.in ();
 268 }
 269
 270 int
 271 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 272 {
 273   int status = 0;
 274
 275   ACE_Service_Config::static_svcs ()->insert (&ace_svc_desc_FP_DT_Creator);
 276
 277   try
 278     {
 279       DT_TEST::instance ()->run (argc, argv);
 280     }
 281   catch (const CORBA::Exception& ex)
 282     {
 283       ex._tao_print_exception ("Caught exception:");
 284       status = 1;
 285     }
 286
 287   ACE_Service_Config::static_svcs ()->remove (ACE_TEXT ("FP_DT_Creator"));
 288
 289   return status;
 290 }
 291
 292 ACE_SINGLETON_TEMPLATE_INSTANTIATE(ACE_Singleton, DT_Test,  TAO_SYNCH_MUTEX);