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