TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_Scheduler.cpp

   1 #include "FP_Scheduler.h"
   2 #include "tao/RTScheduling/Request_Interceptor.h"
   3 #include "test.h"
   4 #include <atomic>
   5
   6 std::atomic<long> server_guid_counter;
   7
   8 RTCORBA::Priority
   9 Segment_Sched_Param_Policy::value ()
  10 {
  11   return this->value_;
  12 }
  13
  14 void
  15 Segment_Sched_Param_Policy::value (RTCORBA::Priority value)
  16 {
  17   this->value_ = value;
  18 }
  19
  20 CORBA::Policy_ptr
  21 Segment_Sched_Param_Policy::copy ()
  22 {
  23   Segment_Sched_Param_Policy *copy = 0;
  24   ACE_NEW_THROW_EX (copy,
  25                     Segment_Sched_Param_Policy,
  26                     CORBA::NO_MEMORY ());
  27
  28   copy->value (this->value_);
  29
  30   return copy;
  31 }
  32
  33 CORBA::PolicyType
  34 Segment_Sched_Param_Policy::policy_type ()
  35 {
  36   return 0;
  37 }
  38
  39 void
  40 Segment_Sched_Param_Policy::destroy ()
  41 {
  42 }
  43
  44 Fixed_Priority_Scheduler::Fixed_Priority_Scheduler (CORBA::ORB_ptr orb)
  45 {
  46   try
  47     {
  48       CORBA::Object_var object =
  49         orb->resolve_initial_references ("RTScheduler_Current");
  50
  51       this->current_ =
  52         RTScheduling::Current::_narrow (object.in ());
  53     }
  54   catch (const CORBA::Exception& ex)
  55     {
  56       ex._tao_print_exception ("Caught exception:");
  57     }
  58 }
  59
  60 Fixed_Priority_Scheduler::~Fixed_Priority_Scheduler ()
  61 {
  62 }
  63
  64 FP_Scheduling::SegmentSchedulingParameterPolicy_ptr
  65 Fixed_Priority_Scheduler::create_segment_scheduling_parameter (RTCORBA::Priority segment_priority)
  66 {
  67   FP_Scheduling::SegmentSchedulingParameterPolicy_ptr segment_policy;
  68   ACE_NEW_THROW_EX (segment_policy,
  69                     Segment_Sched_Param_Policy,
  70                     CORBA::NO_MEMORY (
  71                                       CORBA::SystemException::_tao_minor_code (
  72                                                                                TAO::VMCID,
  73                                                                                ENOMEM),
  74                                       CORBA::COMPLETED_NO));
  75
  76   segment_policy->value (segment_priority);
  77
  78   return segment_policy;
  79 }
  80
  81
  82 void
  83 Fixed_Priority_Scheduler::begin_new_scheduling_segment (const RTScheduling::Current::IdType &,
  84                                                         const char *,
  85                                                         CORBA::Policy_ptr /*sched_policy*/,
  86                                                         CORBA::Policy_ptr)
  87 {
  88 }
  89
  90 void
  91 Fixed_Priority_Scheduler::begin_nested_scheduling_segment (const RTScheduling::Current::IdType &guid,
  92                                                            const char *name,
  93                                                            CORBA::Policy_ptr sched_param,
  94                                                            CORBA::Policy_ptr implicit_sched_param)
  95 {
  96   this->begin_new_scheduling_segment (guid,
  97                                       name,
  98                                       sched_param,
  99                                       implicit_sched_param);
 100 }
 101
 102 void
 103 Fixed_Priority_Scheduler::update_scheduling_segment (const RTScheduling::Current::IdType &guid,
 104                                                      const char *name,
 105                                                      CORBA::Policy_ptr sched_param,
 106                                                      CORBA::Policy_ptr implicit_sched_param)
 107 {
 108   this->begin_new_scheduling_segment (guid,
 109                                       name,
 110                                       sched_param,
 111                                       implicit_sched_param);
 112 }
 113
 114 void
 115 Fixed_Priority_Scheduler::end_scheduling_segment (const RTScheduling::Current::IdType &,
 116                                                   const char *)
 117 {
 118 }
 119
 120 void
 121 Fixed_Priority_Scheduler::end_nested_scheduling_segment (const RTScheduling::Current::IdType &,
 122                                                          const char *,
 123                                                          CORBA::Policy_ptr)
 124 {
 125 }
 126
 127
 128 void
 129 Fixed_Priority_Scheduler::send_request (PortableInterceptor::ClientRequestInfo_ptr request_info)
 130 {
 131   int priority;
 132   ACE_hthread_t current;
 133   ACE_Thread::self (current);
 134   if (ACE_Thread::getprio (current, priority) == -1)
 135     return;
 136
 137   ACE_DEBUG ((LM_DEBUG,
 138               "Request thread priority is %d %d\n",
 139               priority,
 140               ACE_DEFAULT_THREAD_PRIORITY));
 141
 142
 143   RTScheduling::Current::IdType_var guid = this->current_->id ();
 144   IOP::ServiceContext* srv_con = new IOP::ServiceContext;
 145   srv_con->context_id = Client_Interceptor::SchedulingInfo;
 146   srv_con->context_data.length (sizeof (size_t));
 147   ACE_OS::memcpy (srv_con->context_data.get_buffer (),
 148                   guid->get_buffer (),
 149                   sizeof (size_t));
 150   request_info->add_request_service_context (*srv_con,
 151                                              0);
 152 }
 153
 154 void
 155 Fixed_Priority_Scheduler::receive_request (PortableInterceptor::ServerRequestInfo_ptr request_info,
 156                                            RTScheduling::Current::IdType_out guid_out,
 157                                            CORBA::String_out /*name*/,
 158                                            CORBA::Policy_out /*sched_param*/,
 159                                            CORBA::Policy_out /*implicit_sched_param*/)
 160 {
 161   IOP::ServiceContext* serv_cxt =
 162     request_info->get_request_service_context (Server_Interceptor::SchedulingInfo);
 163
 164   if (serv_cxt != 0)
 165     {
 166       size_t gu_id;
 167       ACE_OS::memcpy (&gu_id,
 168                       serv_cxt->context_data.get_buffer (),
 169                       serv_cxt->context_data.length ());
 170
 171       ACE_TCHAR msg [BUFSIZ];
 172       ACE_OS::sprintf (msg,
 173                        ACE_TEXT("The Guid is ")
 174                        ACE_SIZE_T_FORMAT_SPECIFIER
 175                        ACE_TEXT("\n"), gu_id);
 176
 177       DT_TEST::instance ()->dt_creator ()->log_msg (ACE_TEXT_ALWAYS_CHAR(msg));
 178
 179       RTScheduling::Current::IdType* guid = 0;
 180       ACE_NEW (guid,
 181                RTScheduling::Current::IdType);
 182
 183
 184       // Generate GUID.
 185       guid->length (sizeof(size_t));
 186
 187       ACE_OS::memcpy (guid->get_buffer (),
 188                       &gu_id,
 189                       sizeof(size_t));
 190
 191       if (TAO_debug_level > 0)
 192         ACE_DEBUG ((LM_DEBUG,
 193                     "Receive request The Guid is %d\n",
 194                     gu_id));
 195
 196       guid_out.ptr () = guid;
 197     }
 198
 199 }
 200
 201 void
 202 Fixed_Priority_Scheduler::send_reply (PortableInterceptor::ServerRequestInfo_ptr)
 203 {
 204 }
 205
 206 void
 207 Fixed_Priority_Scheduler::send_exception (PortableInterceptor::ServerRequestInfo_ptr)
 208 {
 209 }
 210
 211 void
 212 Fixed_Priority_Scheduler::send_other (PortableInterceptor::ServerRequestInfo_ptr)
 213 {
 214 }
 215
 216 void
 217 Fixed_Priority_Scheduler::send_poll (PortableInterceptor::ClientRequestInfo_ptr)
 218 {
 219 }
 220
 221 void
 222 Fixed_Priority_Scheduler::receive_reply (PortableInterceptor::ClientRequestInfo_ptr)
 223 {
 224 }
 225
 226 void
 227 Fixed_Priority_Scheduler::receive_exception (PortableInterceptor::ClientRequestInfo_ptr)
 228 {
 229 }
 230
 231 void
 232 Fixed_Priority_Scheduler::receive_other (PortableInterceptor::ClientRequestInfo_ptr)
 233 {
 234 }
 235
 236 void
 237 Fixed_Priority_Scheduler::cancel (const RTScheduling::Current::IdType &)
 238 {
 239 }
 240
 241 CORBA::PolicyList*
 242 Fixed_Priority_Scheduler::scheduling_policies ()
 243 {
 244   return 0;
 245 }
 246
 247 void
 248 Fixed_Priority_Scheduler::scheduling_policies (const CORBA::PolicyList &)
 249 {
 250 }
 251
 252 CORBA::PolicyList*
 253 Fixed_Priority_Scheduler::poa_policies ()
 254 {
 255   return 0;
 256 }
 257
 258 char *
 259 Fixed_Priority_Scheduler::scheduling_discipline_name ()
 260 {
 261   return 0;
 262 }
 263
 264 RTScheduling::ResourceManager_ptr
 265 Fixed_Priority_Scheduler::create_resource_manager (const char *,
 266                                                    CORBA::Policy_ptr)
 267 {
 268   return 0;
 269 }
 270
 271 void
 272 Fixed_Priority_Scheduler::set_scheduling_parameter (PortableServer::Servant &,
 273                                                     const char *,
 274                                                     CORBA::Policy_ptr)
 275 {
 276 }