TAO/examples/Kokyu_dsrt_schedulers/MUF_Scheduler.cpp

   1 #include "MUF_Scheduler.h"
   2 #include "Kokyu_qosC.h"
   3 #include "utils.h"
   4 #include "tao/RTScheduling/Request_Interceptor.h"
   5 #include "tao/CodecFactory/CodecFactory.h"
   6 #include "tao/ORB_Constants.h"
   7
   8 MUF_Sched_Param_Policy::MUF_Sched_Param_Policy ()
   9 {
  10 }
  11
  12 MUF_Sched_Param_Policy::MUF_Sched_Param_Policy (
  13     const MUF_Sched_Param_Policy &rhs
  14   )
  15   : CORBA::Object (),
  16   CORBA::Policy (),
  17   MUF_Scheduling::SchedulingParameterPolicy (),
  18   CORBA::LocalObject (),
  19   value_ (rhs.value_)
  20 {
  21 }
  22
  23 MUF_Scheduling::SchedulingParameter
  24 MUF_Sched_Param_Policy::value ()
  25 {
  26   return this->value_;
  27 }
  28
  29 void
  30 MUF_Sched_Param_Policy::value (const MUF_Scheduling::SchedulingParameter& value)
  31 {
  32   this->value_ = value;
  33 }
  34
  35 CORBA::Policy_ptr
  36 MUF_Sched_Param_Policy::copy ()
  37 {
  38   MUF_Sched_Param_Policy* tmp = 0;
  39   ACE_NEW_THROW_EX (tmp,
  40                     MUF_Sched_Param_Policy (*this),
  41                     CORBA::NO_MEMORY (TAO::VMCID,
  42                                       CORBA::COMPLETED_NO));
  43
  44   return tmp;
  45 }
  46
  47 CORBA::PolicyType
  48 MUF_Sched_Param_Policy::policy_type ()
  49 {
  50   return 0;
  51 }
  52
  53 void
  54 MUF_Sched_Param_Policy::destroy ()
  55 {
  56 }
  57
  58 MUF_Scheduler::MUF_Scheduler (CORBA::ORB_ptr orb,
  59                               Kokyu::DSRT_Dispatcher_Impl_t disp_impl_type,
  60                               int ace_sched_policy,
  61                               int ace_sched_scope)
  62   : orb_ (CORBA::ORB::_duplicate (orb)),
  63     disp_impl_type_ (disp_impl_type),
  64     ace_sched_policy_ (ace_sched_policy),
  65     ace_sched_scope_ (ace_sched_scope)
  66 {
  67   Kokyu::DSRT_ConfigInfo config;
  68
  69   config.impl_type_ = this->disp_impl_type_;
  70   config.sched_policy_ = ace_sched_policy_;
  71   config.sched_scope_ = ace_sched_scope_;
  72
  73   Kokyu::DSRT_Dispatcher_Factory<MUF_Scheduler_Traits>::DSRT_Dispatcher_Auto_Ptr
  74     tmp( Kokyu::DSRT_Dispatcher_Factory<MUF_Scheduler_Traits>::
  75          create_DSRT_dispatcher (config) );
  76   kokyu_dispatcher_ = std::move(tmp);
  77
  78   CORBA::Object_var object =
  79     orb->resolve_initial_references ("RTScheduler_Current");
  80
  81   this->current_ =
  82     RTScheduling::Current::_narrow (object.in ());
  83
  84   IOP::CodecFactory_var codec_factory;
  85   CORBA::Object_var obj =
  86     orb->resolve_initial_references ("CodecFactory");
  87
  88   if (CORBA::is_nil(obj.in ()))
  89     {
  90       ACE_ERROR ((LM_ERROR, "Nil Codec factory\n"));
  91     }
  92   else
  93     {
  94       codec_factory = IOP::CodecFactory::_narrow (obj.in ());
  95     }
  96
  97   IOP::Encoding encoding;
  98   encoding.format = IOP::ENCODING_CDR_ENCAPS;
  99   encoding.major_version = 1;
 100   encoding.minor_version = 2;
 101
 102   codec_ = codec_factory->create_codec (encoding);
 103 }
 104
 105 MUF_Scheduler::~MUF_Scheduler ()
 106 {
 107 }
 108
 109 void
 110 MUF_Scheduler::shutdown ()
 111 {
 112   kokyu_dispatcher_->shutdown ();
 113   ACE_DEBUG ((LM_DEBUG, "kokyu DSRT dispatcher shutdown\n"));
 114 }
 115
 116 MUF_Scheduling::SchedulingParameterPolicy_ptr
 117 MUF_Scheduler::create_scheduling_parameter (const MUF_Scheduling::SchedulingParameter & value)
 118 {
 119   MUF_Scheduling::SchedulingParameterPolicy_ptr sched_param_policy;
 120   ACE_NEW_THROW_EX (sched_param_policy,
 121                     MUF_Sched_Param_Policy,
 122                     CORBA::NO_MEMORY (
 123                                       CORBA::SystemException::_tao_minor_code (
 124                                        TAO::VMCID,
 125                                        ENOMEM),
 126                                       CORBA::COMPLETED_NO));
 127
 128   sched_param_policy->value (value);
 129
 130   return sched_param_policy;
 131 }
 132
 133
 134 void
 135 MUF_Scheduler::begin_new_scheduling_segment (const RTScheduling::Current::IdType &guid,
 136                                              const char *,
 137                                              CORBA::Policy_ptr sched_policy,
 138                                              CORBA::Policy_ptr)
 139 {
 140 #ifdef KOKYU_DSRT_LOGGING
 141   ACE_DEBUG ((LM_DEBUG,
 142               "(%t|%T):MUF_Scheduler::begin_new_scheduling_segment enter\n"));
 143 #endif
 144
 145 #ifdef KOKYU_DSRT_LOGGING
 146   int int_guid;
 147   ACE_OS::memcpy (&int_guid,
 148                   guid.get_buffer (),
 149                   guid.length ());
 150   ACE_DEBUG ((LM_DEBUG, "(%t|%T): guid is %d\n", int_guid));
 151 #endif
 152
 153   MUF_Scheduler_Traits::QoSDescriptor_t qos;
 154   MUF_Scheduling::SchedulingParameterPolicy_var sched_param_policy =
 155     MUF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy);
 156
 157   MUF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value ();
 158
 159   qos.deadline_ = sched_param->deadline;
 160   qos.exec_time_ = sched_param->estimated_initial_execution_time;
 161   qos.criticality_ = sched_param->criticality;
 162
 163   kokyu_dispatcher_->schedule (guid, qos);
 164
 165 #ifdef KOKYU_DSRT_LOGGING
 166   ACE_DEBUG ((LM_DEBUG,
 167               "(%t|%T):MUF_Scheduler::begin_new_scheduling_segment exit\n"));
 168 #endif
 169 }
 170
 171
 172 void
 173 MUF_Scheduler::begin_nested_scheduling_segment (const RTScheduling::Current::IdType &guid,
 174                                                            const char *name,
 175                                                            CORBA::Policy_ptr sched_param,
 176                                                            CORBA::Policy_ptr implicit_sched_param)
 177 {
 178   this->begin_new_scheduling_segment (guid,
 179                                       name,
 180                                       sched_param,
 181                                       implicit_sched_param);
 182 }
 183
 184 void
 185 MUF_Scheduler::update_scheduling_segment (const RTScheduling::Current::IdType& guid,
 186                                           const char* name,
 187                                           CORBA::Policy_ptr sched_policy,
 188                                           CORBA::Policy_ptr implicit_sched_param)
 189 {
 190   ACE_UNUSED_ARG ((name));
 191   ACE_UNUSED_ARG ((implicit_sched_param));
 192
 193 #ifdef KOKYU_DSRT_LOGGING
 194   int int_guid ;
 195   ACE_OS::memcpy (&int_guid,
 196                   guid.get_buffer (),
 197                   guid.length ());
 198   ACE_DEBUG ((LM_DEBUG, "(%t|%T): update_sched_seg::guid is %d\n", int_guid));
 199 #endif
 200
 201   MUF_Scheduling::SchedulingParameterPolicy_var sched_param_policy =
 202     MUF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy);
 203
 204   MUF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value ();
 205   MUF_Scheduler_Traits::QoSDescriptor_t qos;
 206
 207   qos.deadline_ = sched_param->deadline;
 208   qos.exec_time_ = sched_param->estimated_initial_execution_time;
 209   qos.criticality_ = sched_param->criticality;
 210
 211   kokyu_dispatcher_->update_schedule (guid, qos);
 212 }
 213
 214 void
 215 MUF_Scheduler::end_scheduling_segment (const RTScheduling::Current::IdType &guid,
 216                                        const char *)
 217 {
 218 #ifdef KOKYU_DSRT_LOGGING
 219   int int_guid;
 220   ACE_OS::memcpy (&int_guid,
 221                   guid.get_buffer (),
 222                   guid.length ());
 223   ACE_DEBUG ((LM_DEBUG, "(%t|%T) call to end_sched_segment for guid %d\n", int_guid));
 224 #endif
 225
 226   kokyu_dispatcher_->cancel_schedule (guid);
 227 }
 228
 229 void
 230 MUF_Scheduler::end_nested_scheduling_segment (const RTScheduling::Current::IdType &,
 231                                                          const char *,
 232                                                          CORBA::Policy_ptr)
 233 {
 234 }
 235
 236
 237 void
 238 MUF_Scheduler::send_request (PortableInterceptor::ClientRequestInfo_ptr ri)
 239 {
 240   Kokyu::Svc_Ctxt_DSRT_QoS sc_qos;
 241
 242   CORBA::String_var operation = ri->operation ();
 243
 244 #ifdef KOKYU_DSRT_LOGGING
 245   ACE_DEBUG ((LM_DEBUG,
 246               "(%t|%T): send_request "
 247               "from \"%s\"\n",
 248               operation.in ()));
 249 #endif
 250
 251   // Make the context to send the context to the target
 252   IOP::ServiceContext sc;
 253   sc.context_id = Client_Interceptor::SchedulingInfo;
 254
 255   CORBA::Policy_var sched_policy =
 256     this->current_->scheduling_parameter();
 257
 258   RTScheduling::Current::IdType_var guid = this->current_->id ();
 259
 260   /*
 261   ACE_OS::memcpy (&guid,
 262                   guid->get_buffer (),
 263                   guid->length ());
 264   */
 265
 266   CORBA::Long criticality;
 267   TimeBase::TimeT deadline,exec_time;
 268
 269   if (CORBA::is_nil (sched_policy.in ()))
 270     {
 271       //24 hrs from now - infinity
 272       ACE_Time_Value deadline_tv = ACE_OS::gettimeofday () + ACE_Time_Value (24*60*60,0);
 273       deadline = deadline_tv.sec () * 1000000 + deadline_tv.usec () * 10; //100s of nanoseconds for TimeBase::TimeT
 274       exec_time = 0;
 275       criticality = 0;
 276     }
 277   else
 278     {
 279       MUF_Scheduling::SchedulingParameterPolicy_var sched_param_policy =
 280         MUF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy.in ());
 281
 282       MUF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value ();
 283       deadline = sched_param->deadline;
 284       exec_time = sched_param->estimated_initial_execution_time;
 285       criticality = sched_param->criticality;
 286
 287 #ifdef KOKYU_DSRT_LOGGING
 288       int int_guid;
 289       ACE_OS::memcpy (&int_guid,
 290                       guid->get_buffer (),
 291                       guid->length ());
 292       ACE_DEBUG ((LM_DEBUG,
 293                   "(%t|%T): send_request guid = %d\n",
 294                   int_guid));
 295 #endif
 296
 297       //Fill the guid in the SC Qos struct
 298       sc_qos.guid.length (guid->length ());
 299       guid_copy (sc_qos.guid, guid.in ());
 300       sc_qos.deadline = deadline;
 301       sc_qos.estimated_initial_execution_time = exec_time;
 302       sc_qos.criticality = criticality;
 303       CORBA::Any sc_qos_as_any;
 304       sc_qos_as_any <<= sc_qos;
 305
 306       CORBA::OctetSeq_var cdtmp = codec_->encode (sc_qos_as_any);
 307       sc.context_data = cdtmp.in ();
 308
 309 #ifdef KOKYU_DSRT_LOGGING
 310       ACE_DEBUG ((LM_DEBUG,
 311                   ACE_TEXT ("(%t|%T): send_request : about to add sched SC\n")));
 312 #endif
 313
 314       // Add this context to the service context list.
 315       ri->add_request_service_context (sc, 0);
 316     }
 317
 318
 319 #ifdef KOKYU_DSRT_LOGGING
 320   ACE_DEBUG ((LM_DEBUG,
 321               ACE_TEXT ("(%t|%T): send_request : ")
 322               ACE_TEXT ("about to call scheduler to inform block\n")));
 323 #endif
 324
 325   kokyu_dispatcher_->update_schedule (guid.in (),
 326                                       Kokyu::BLOCK);
 327
 328 #ifdef KOKYU_DSRT_LOGGING
 329   ACE_DEBUG ((LM_DEBUG,
 330               ACE_TEXT ("(%t|%T): send_request interceptor done\n")));
 331 #endif
 332 }
 333
 334 void
 335 MUF_Scheduler::receive_request (PortableInterceptor::ServerRequestInfo_ptr ri,
 336                                 RTScheduling::Current::IdType_out guid_out,
 337                                 CORBA::String_out /*name*/,
 338                                 CORBA::Policy_out sched_param_out,
 339                                 CORBA::Policy_out /*implicit_sched_param_out*/)
 340 {
 341   const Kokyu::Svc_Ctxt_DSRT_QoS* sc_qos_ptr = 0;
 342
 343 #ifdef KOKYU_DSRT_LOGGING
 344   ACE_DEBUG ((LM_DEBUG, "(%t|%T):entered MUF_Scheduler::receive_request\n"));
 345 #endif
 346
 347   RTScheduling::Current::IdType guid;
 348
 349   CORBA::String_var operation = ri->operation ();
 350
 351 #ifdef KOKYU_DSRT_LOGGING
 352   ACE_DEBUG ((LM_DEBUG,
 353               "(%t|%T): receive_request from "
 354               "\"%s\"\n",
 355               operation.in ()));
 356 #endif
 357
 358   // Ignore the "_is_a" operation since it may have been invoked
 359   // locally on the server side as a side effect of another call,
 360   // meaning that the client hasn't added the service context yet.
 361   if (ACE_OS::strcmp ("_is_a", operation.in ()) == 0)
 362     return;
 363
 364   IOP::ServiceContext_var sc =
 365     ri->get_request_service_context (Server_Interceptor::SchedulingInfo);
 366
 367   CORBA::Long criticality;
 368   TimeBase::TimeT deadline,exec_time;
 369
 370   if (sc.ptr () == 0)
 371     {
 372       //24 hrs from now - infinity
 373       ACE_Time_Value deadline_tv = ACE_OS::gettimeofday () + ACE_Time_Value (24*60*60,0);
 374       deadline = deadline_tv.sec ()*1000000 + deadline_tv.usec ()*10; //100s of nanoseconds for TimeBase::TimeT
 375       exec_time = 0;
 376       criticality = 0;
 377     }
 378   else
 379     {
 380       CORBA::OctetSeq oc_seq = CORBA::OctetSeq (sc->context_data.length (),
 381                                                  sc->context_data.length (),
 382                                                  sc->context_data.get_buffer (),
 383                                                  0);
 384       CORBA::Any sc_qos_as_any;
 385       CORBA::Any_var scqostmp = codec_->decode (oc_seq);
 386       sc_qos_as_any = scqostmp.in ();
 387       //Don't store in a _var, since >>= returns a pointer to an
 388       //internal buffer and we are not supposed to free it.
 389       sc_qos_as_any >>= sc_qos_ptr;
 390
 391       deadline  = sc_qos_ptr->deadline;
 392       criticality = sc_qos_ptr->criticality;
 393       exec_time = sc_qos_ptr->estimated_initial_execution_time;
 394
 395       guid.length (sc_qos_ptr->guid.length ());
 396       guid_copy (guid, sc_qos_ptr->guid);
 397
 398       ACE_NEW (guid_out.ptr (),
 399                RTScheduling::Current::IdType);
 400       guid_out.ptr ()->length (guid.length ());
 401       *(guid_out.ptr ()) = guid;
 402
 403 #ifdef KOKYU_DSRT_LOGGING
 404       int int_guid;
 405       ACE_OS::memcpy (&int_guid,
 406                       guid.get_buffer (),
 407                       guid.length ());
 408       ACE_DEBUG ((LM_DEBUG,
 409                   "(%t|%T): Criticality = %d, guid = %d "
 410                   "in recvd service context\n",
 411                   criticality,
 412                   int_guid));
 413 #endif
 414       MUF_Scheduling::SchedulingParameter sched_param;
 415       sched_param.criticality = criticality;
 416       sched_param.deadline = deadline;
 417       sched_param_out = this->create_scheduling_parameter (sched_param);
 418     }
 419
 420   MUF_Scheduler_Traits::QoSDescriptor_t qos;
 421   qos.criticality_ = criticality;
 422   qos.deadline_ = deadline;
 423   qos.exec_time_ = exec_time;
 424
 425   this->kokyu_dispatcher_->schedule (guid, qos);
 426
 427 #ifdef KOKYU_DSRT_LOGGING
 428   ACE_DEBUG ((LM_DEBUG, "(%t|%T): receive_request interceptor done\n"));
 429 #endif
 430
 431 }
 432
 433 void
 434 MUF_Scheduler::send_poll (PortableInterceptor::ClientRequestInfo_ptr)
 435 {
 436 }
 437
 438 void
 439 MUF_Scheduler::send_reply (PortableInterceptor::ServerRequestInfo_ptr ri)
 440 {
 441   Kokyu::Svc_Ctxt_DSRT_QoS sc_qos;
 442
 443   CORBA::String_var operation = ri->operation ();
 444
 445 #ifdef KOKYU_DSRT_LOGGING
 446   ACE_DEBUG ((LM_DEBUG,
 447               "(%t|%T): send_reply from \"%s\"\n",
 448               ri->operation ()));
 449 #endif
 450
 451   // Make the context to send the context to the target
 452   IOP::ServiceContext sc;
 453   sc.context_id = Server_Interceptor::SchedulingInfo;
 454
 455
 456   CORBA::Long criticality;
 457   TimeBase::TimeT deadline,exec_time;
 458
 459   CORBA::Policy_var sched_policy =
 460     this->current_->scheduling_parameter();
 461
 462   RTScheduling::Current::IdType_var guid = this->current_->id ();
 463
 464   if (CORBA::is_nil (sched_policy.in ()))
 465   {
 466 #ifdef KOKYU_DSRT_LOGGING
 467     ACE_DEBUG ((LM_DEBUG,
 468                 "(%t|%T): sched_policy nil.\n"));
 469 #endif
 470     //24 hrs from now - infinity
 471     ACE_Time_Value deadline_tv = ACE_OS::gettimeofday () + ACE_Time_Value (24*60*60,0);
 472     deadline = deadline_tv.sec ()*1000000 + deadline_tv.usec ()*10; //100s of nanoseconds for TimeBase::TimeT
 473     exec_time = 0;
 474     criticality = 0;
 475   }
 476   else
 477     {
 478 #ifdef KOKYU_DSRT_LOGGING
 479       ACE_DEBUG ((LM_DEBUG,
 480                   "(%t|%T):sched_policy not nil. ",
 481                   "sched params set\n"));
 482 #endif
 483       MUF_Scheduling::SchedulingParameterPolicy_var sched_param_policy =
 484         MUF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy.in ());
 485       MUF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value ();
 486
 487
 488       sc_qos.guid.length (guid->length ());
 489       guid_copy (sc_qos.guid, guid.in ());
 490
 491       deadline = sched_param->deadline;
 492       exec_time = sched_param->estimated_initial_execution_time;
 493       criticality = sched_param->criticality;
 494       sc_qos.deadline = deadline;
 495       sc_qos.estimated_initial_execution_time = exec_time;
 496       sc_qos.criticality = criticality;
 497
 498       CORBA::Any sc_qos_as_any;
 499       sc_qos_as_any <<= sc_qos;
 500
 501       CORBA::OctetSeq_var cdtmp = codec_->encode (sc_qos_as_any);
 502       sc.context_data = cdtmp.in ();
 503
 504       // Add this context to the service context list.
 505       ri->add_reply_service_context (sc, 1);
 506
 507 #ifdef KOKYU_DSRT_LOGGING
 508       ACE_DEBUG ((LM_DEBUG, "(%t|%T):reply sc added\n"));
 509 #endif
 510     }
 511
 512   kokyu_dispatcher_->update_schedule (guid.in (),
 513                                       Kokyu::BLOCK);
 514
 515 #ifdef KOKYU_DSRT_LOGGING
 516   ACE_DEBUG ((LM_DEBUG, "(%t|%T): send_reply interceptor done\n"));
 517 #endif
 518 }
 519
 520 void
 521 MUF_Scheduler::send_exception (PortableInterceptor::ServerRequestInfo_ptr ri)
 522 {
 523   send_reply (ri);
 524 }
 525
 526 void
 527 MUF_Scheduler::send_other (PortableInterceptor::ServerRequestInfo_ptr ri)
 528 {
 529   send_reply (ri);
 530 }
 531
 532 void
 533 MUF_Scheduler::receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri)
 534 {
 535   RTScheduling::Current::IdType guid;
 536
 537   CORBA::String_var operation = ri->operation ();
 538
 539   CORBA::Object_var target = ri->target ();
 540
 541   ACE_CString opname = operation.in ();
 542 #ifdef KOKYU_DSRT_LOGGING
 543   ACE_DEBUG ((LM_DEBUG,
 544               "(%t|%T):receive_reply from "
 545               "\"%s\"\n",
 546               opname.c_str ()));
 547 #endif
 548
 549   // Check that the reply service context was received as
 550   // expected.
 551   IOP::ServiceContext_var sc =
 552     ri->get_reply_service_context (Client_Interceptor::SchedulingInfo);
 553
 554   CORBA::Long criticality;
 555   TimeBase::TimeT deadline,exec_time;
 556
 557   if (sc.ptr () == 0)
 558     {
 559       ACE_DEBUG ((LM_DEBUG, "service context was not filled\n"));
 560       //24 hrs from now - infinity
 561       ACE_Time_Value deadline_tv = ACE_OS::gettimeofday () + ACE_Time_Value (24*60*60,0);
 562       deadline = deadline_tv.sec ()*1000000 + deadline_tv.usec ()*10; //100s of nanoseconds for TimeBase::TimeT
 563       exec_time = 0;
 564       criticality = 0;
 565     }
 566   else
 567     {
 568       CORBA::OctetSeq oc_seq = CORBA::OctetSeq (sc->context_data.length (),
 569                                                 sc->context_data.length (),
 570                                                 sc->context_data.get_buffer (),
 571                                                 0);
 572
 573       //Don't store in a _var, since >>= returns a pointer to an internal buffer
 574       //and we are not supposed to free it.
 575       const Kokyu::Svc_Ctxt_DSRT_QoS* sc_qos_ptr = 0;
 576       CORBA::Any sc_qos_as_any;
 577       CORBA::Any_var scqostmp = codec_->decode (oc_seq);
 578       sc_qos_as_any = scqostmp.in ();
 579       sc_qos_as_any >>= sc_qos_ptr;
 580
 581       deadline  = sc_qos_ptr->deadline;
 582       criticality = sc_qos_ptr->criticality;
 583       exec_time = sc_qos_ptr->estimated_initial_execution_time;
 584
 585       guid.length (sc_qos_ptr->guid.length ());
 586       guid_copy (guid, sc_qos_ptr->guid);
 587
 588       ACE_DEBUG ((LM_DEBUG,
 589                   "(%t|%T): Criticality = %d in recvd service context\n",
 590                   criticality));
 591     }
 592
 593   MUF_Scheduler_Traits::QoSDescriptor_t qos;
 594   qos.deadline_ =   qos.criticality_ = criticality;
 595   qos.deadline_ = deadline;
 596   qos.exec_time_ = exec_time;
 597   this->kokyu_dispatcher_->schedule (guid, qos);
 598 }
 599
 600 void
 601 MUF_Scheduler::receive_exception (PortableInterceptor::ClientRequestInfo_ptr ri)
 602 {
 603   receive_reply (ri);
 604 }
 605
 606 void
 607 MUF_Scheduler::receive_other (PortableInterceptor::ClientRequestInfo_ptr ri)
 608 {
 609   receive_reply (ri);
 610 }
 611
 612 void
 613 MUF_Scheduler::cancel (const RTScheduling::Current::IdType &)
 614 {
 615   throw CORBA::NO_IMPLEMENT ();
 616 }
 617
 618 CORBA::PolicyList*
 619 MUF_Scheduler::scheduling_policies ()
 620 {
 621   throw CORBA::NO_IMPLEMENT ();
 622 }
 623
 624 void
 625 MUF_Scheduler::scheduling_policies (const CORBA::PolicyList &)
 626 {
 627   throw CORBA::NO_IMPLEMENT ();
 628 }
 629
 630 CORBA::PolicyList*
 631 MUF_Scheduler::poa_policies ()
 632 {
 633   throw CORBA::NO_IMPLEMENT ();
 634 }
 635
 636 char *
 637 MUF_Scheduler::scheduling_discipline_name ()
 638 {
 639   throw CORBA::NO_IMPLEMENT ();
 640 }
 641
 642 RTScheduling::ResourceManager_ptr
 643 MUF_Scheduler::create_resource_manager (const char *,
 644                                         CORBA::Policy_ptr)
 645 {
 646   throw CORBA::NO_IMPLEMENT ();
 647 }
 648
 649 void
 650 MUF_Scheduler::set_scheduling_parameter (PortableServer::Servant &,
 651                                          const char *,
 652                                          CORBA::Policy_ptr)
 653 {
 654   throw CORBA::NO_IMPLEMENT ();
 655 }
 656