TAO/tests/RTScheduling/Current/Thread_Task.cpp

   1 #include "Thread_Task.h"
   2 #include "ace/OS_NS_errno.h"
   3 #include "ace/OS_NS_unistd.h"
   4
   5 Thread_Task::Thread_Task (CORBA::ORB_ptr orb)
   6  : orb_ (CORBA::ORB::_duplicate (orb))
   7 {
   8 }
   9
  10 int
  11 Thread_Task::activate_task (int thr_count)
  12 {
  13   try
  14     {
  15       ACE_NEW_RETURN (shutdown_lock_,
  16                       TAO_SYNCH_MUTEX,
  17                       -1);
  18
  19       ACE_NEW_RETURN (lock_,
  20                       TAO_SYNCH_MUTEX,
  21                       -1);
  22
  23       active_thread_count_ = thr_count;
  24
  25       CORBA::Object_var current_obj = this->orb_->resolve_initial_references ("RTScheduler_Current");
  26
  27       this->current_ = RTScheduling::Current::_narrow (current_obj.in ());
  28
  29       const char * name = 0;
  30       CORBA::Policy_ptr sched_param = 0;
  31       CORBA::Policy_ptr implicit_sched_param = 0;
  32
  33       try
  34         {
  35           ACE_DEBUG ((LM_DEBUG,
  36                       "Making an end_scheduling_segment call without first calling begin_scheduling_segment\n"));
  37           this->current_->end_scheduling_segment (name);
  38         }
  39       catch (const CORBA::BAD_INV_ORDER& )
  40         {
  41           ACE_DEBUG ((LM_DEBUG,
  42             "End Scheduling Segment is out of context - Expected Exception\n"));
  43         }
  44       catch (const CORBA::Exception& ex)
  45         {
  46           ex._tao_print_exception ("\n");
  47         }
  48
  49       try
  50         {
  51           ACE_DEBUG ((LM_DEBUG,
  52                       "Making an update_scheduling_segment call without first calling begin_scheduling_segment\n"));
  53
  54           this->current_->update_scheduling_segment (name,
  55                                                      sched_param,
  56                                                      implicit_sched_param);
  57         }
  58       catch (const CORBA::BAD_INV_ORDER& )
  59         {
  60         ACE_DEBUG ((LM_DEBUG,
  61               "Update Scheduling Segment is out of context - Expected Exception\n"));
  62         }
  63       catch (const CORBA::Exception& ex)
  64         {
  65           ex._tao_print_exception (
  66             "Update Scheduling Segment is out of context:");
  67         }
  68     }
  69   catch (const CORBA::Exception& ex)
  70     {
  71       ex._tao_print_exception ("Exception:");
  72     }
  73
  74   long flags = THR_NEW_LWP | THR_JOINABLE;
  75   if (this->activate (flags,
  76                       thr_count) == -1)
  77     {
  78       if (ACE_OS::last_error () == EPERM)
  79         ACE_ERROR_RETURN ((LM_ERROR,
  80                            ACE_TEXT ("Insufficient privilege to run this test.\n")),
  81                           -1);
  82     }
  83   return 0;
  84 }
  85
  86 int
  87 Thread_Task::svc ()
  88 {
  89   try
  90     {
  91       const char * name = 0;
  92       CORBA::Policy_ptr sched_param = 0;
  93       CORBA::Policy_ptr implicit_sched_param = 0;
  94
  95       this->current_->begin_scheduling_segment ("Fellowship of the Rings",
  96                                                 sched_param,
  97                                                 implicit_sched_param);
  98
  99       size_t count = 0;
 100       RTScheduling::Current::IdType_var id = this->current_->id ();
 101       ACE_OS::memcpy (&count,
 102                       id->get_buffer (),
 103                       id->length ());
 104
 105       ACE_DEBUG ((LM_DEBUG,
 106                   "Starting Distributable Thread %d with 3 nested scheduling segments....\n",
 107                   count));
 108
 109       //Start - Nested Scheduling Segment
 110       this->current_->begin_scheduling_segment ("Two Towers",
 111                                                 sched_param,
 112                                                 implicit_sched_param);
 113
 114       //Start - Nested Scheduling Segment
 115       this->current_->begin_scheduling_segment ("The Return of the King",
 116                                                 sched_param,
 117                                                 implicit_sched_param);
 118
 119
 120       RTScheduling::Current::NameList_var segment_name_list =
 121         this->current_->current_scheduling_segment_names ();
 122
 123       {
 124         ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, *lock_, -1);
 125         ACE_DEBUG ((LM_DEBUG,
 126                     "Segment Names for DT %d :\n",
 127                     count));
 128
 129         for (unsigned int i = 0; i < segment_name_list->length (); i ++)
 130           {
 131             ACE_DEBUG ((LM_DEBUG,
 132                         "%C\n",
 133                         (*segment_name_list)[i].in ()));
 134           }
 135       }
 136
 137       this->current_->end_scheduling_segment (name);
 138       //End - Nested Scheduling Segment
 139
 140       this->current_->end_scheduling_segment (name);
 141
 142       this->current_->end_scheduling_segment (name);
 143       //End - Nested Scheduling Segment
 144
 145       ACE_DEBUG ((LM_DEBUG,
 146                   "DT %d terminated ...\n",
 147                   count));
 148
 149       {
 150         ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, *shutdown_lock_,-1);
 151         --active_thread_count_;
 152         if (active_thread_count_ == 0)
 153           {
 154             // Without this sleep, we will occasionally get BAD_INV_ORDER
 155             // exceptions on fast dual processor machines.
 156             ACE_OS::sleep (1);
 157
 158             orb_->shutdown (false);
 159           }
 160       }
 161     }
 162   catch (const CORBA::Exception& ex)
 163     {
 164       ex._tao_print_exception ("Caught exception:");
 165       return -1;
 166     }
 167
 168   return 0;
 169 }
 170
 171 Thread_Task::~Thread_Task ()
 172 {
 173   delete shutdown_lock_;
 174   delete lock_;
 175 }