TAO/examples/Kokyu_dsrt_schedulers/EDF_Scheduler.cpp

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