void
MIF_Scheduler::send_other (PortableInterceptor::ServerRequestInfo_ptr)
{
if (TAO_debug_level > 0)
{
RTScheduling::Current::IdType_var guid = current_->id ();
size_t count;
ACE_OS::memcpy (&count,
guid->get_buffer (),
guid->length ());
ACE_DEBUG ((LM_DEBUG,
"MIF_Scheduler::send_other %d\n",
count));
}
if (ready_que_.message_count () > 0)
{
DT* run_dt;
ACE_Message_Block* msg;
ready_que_.dequeue_head (msg);
run_dt = dynamic_cast<DT*> (msg);
lock_.acquire ();
run_dt->resume ();
lock_.release ();
free_que_.enqueue_prio (run_dt);
}
}
void
EDF_Scheduler::send_poll (PortableInterceptor::ClientRequestInfo_ptr)
{
int int_guid;
RTScheduling::Current::IdType_var guid = this->current_->id ();
ACE_OS::memcpy (&int_guid,
guid->get_buffer (),
guid->length ());
DSUI_EVENT_LOG (EDF_SCHED_FAM, SEND_POLL, int_guid, 0, 0);
}
void
MIF_Scheduler::update_scheduling_segment (const RTScheduling::Current::IdType &/*guid*/,
const char* /*name*/,
CORBA::Policy_ptr sched_policy,
CORBA::Policy_ptr /*implicit_sched_param*/)
{
size_t count = 0;
RTScheduling::Current::IdType_var guid = this->current_->id ();
ACE_OS::memcpy (&count,
guid->get_buffer (),
guid->length ());
MIF_Scheduling::SegmentSchedulingParameterPolicy_var sched_param =
MIF_Scheduling::SegmentSchedulingParameterPolicy::_narrow (sched_policy);
CORBA::Short desired_priority = sched_param->importance ();
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"%t MIF_Scheduler::update_scheduling_segment - Importance %d\n",
desired_priority));
DT* new_dt = 0;
ACE_NEW (new_dt,
DT (this->lock_,
count));
new_dt->msg_priority (desired_priority);
if (ready_que_.message_count () > 0)
{
DT* run_dt;
ACE_Message_Block* msg = 0;
ready_que_.dequeue_head (msg);
run_dt = dynamic_cast<DT*> (msg);
if ((desired_priority == 100) || run_dt->msg_priority () >= (unsigned int)desired_priority)
{
ready_que_.enqueue_prio (new_dt);
lock_.acquire ();
run_dt->resume ();
new_dt->suspend ();
lock_.release ();
free_que_.enqueue_prio (run_dt);
}
else
{
ready_que_.enqueue_prio (run_dt);
delete new_dt;
}
}
else delete new_dt;
}
void
EDF_Scheduler::send_other (PortableInterceptor::ServerRequestInfo_ptr ri)
{
int int_guid;
RTScheduling::Current::IdType_var guid = this->current_->id ();
ACE_OS::memcpy (&int_guid,
guid->get_buffer (),
guid->length ());
DSUI_EVENT_LOG (EDF_SCHED_FAM, SEND_OTHER, int_guid, 0, 0);
send_reply (ri);
}
void
TAO_Scheduler::send_request (PortableInterceptor::ClientRequestInfo_ptr request_info)
{
IOP::ServiceContext srv_con;
srv_con.context_id = Client_Interceptor::SchedulingInfo;
srv_con.context_data.length (sizeof (size_t));
RTScheduling::Current::IdType_var id = this->current_->id ();
ACE_OS::memcpy (srv_con.context_data.get_buffer (),
id->get_buffer (),
sizeof (size_t));
request_info->add_request_service_context (srv_con,
0);
}
void
MIF_Scheduler::receive_reply (PortableInterceptor::ClientRequestInfo_ptr)
{
CORBA::Policy_var sched_param = current_->scheduling_parameter ();
MIF_Scheduling::SegmentSchedulingParameterPolicy_var sched_param_var =
MIF_Scheduling::SegmentSchedulingParameterPolicy::_narrow (sched_param.in ());
int importance = sched_param_var->importance ();
RTScheduling::Current::IdType_var guid = current_->id ();
size_t gu_id;
ACE_OS::memcpy (&gu_id,
guid->get_buffer (),
guid->length ());
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"MIF_Scheduler::receive_reply Guid = %d Imp = %d\n",
gu_id,
importance));
DT* new_dt;
ACE_NEW (new_dt,
DT (this->lock_,
gu_id));
new_dt->msg_priority (importance);
lock_.acquire ();
ready_que_.enqueue_prio (new_dt);
int priority;
ACE_hthread_t current;
ACE_Thread::self (current);
if (ACE_Thread::getprio (current, priority) == -1)
return;
RTCORBA::Priority rtpriority;
RTCORBA::PriorityMapping* pm = this->mapping_manager_->mapping ();
if (pm->to_CORBA(priority - 1, rtpriority))
{
current_->the_priority (rtpriority);
}
new_dt->suspend ();
lock_.release ();
}
void
MIF_Scheduler::begin_new_scheduling_segment (const RTScheduling::Current::IdType &/*guid*/,
const char *,
CORBA::Policy_ptr sched_policy,
CORBA::Policy_ptr)
{
size_t count = 0;
RTScheduling::Current::IdType_var guid = this->current_->id ();
ACE_OS::memcpy (&count,
guid->get_buffer (),
guid->length ());
MIF_Scheduling::SegmentSchedulingParameterPolicy_var sched_param =
MIF_Scheduling::SegmentSchedulingParameterPolicy::_narrow (sched_policy);
CORBA::Short desired_priority = sched_param->importance ();
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"%t MIF_Scheduler::begin_scheduling_segment - Importance %d\n",
desired_priority));
if (desired_priority != 100)
{
//NOT Main Thread
DT* new_dt = 0;
ACE_NEW (new_dt,
DT (this->lock_,
count));
new_dt->msg_priority (desired_priority);
lock_.acquire ();
ready_que_.enqueue_prio (new_dt);
resume_main ();
new_dt->suspend ();
lock_.release ();
}
}
void
MIF_Scheduler::send_request (PortableInterceptor::ClientRequestInfo_ptr request_info)
{
CORBA::Policy_var sched_param = current_->scheduling_parameter ();
MIF_Scheduling::SegmentSchedulingParameterPolicy_var sched_param_var =
MIF_Scheduling::SegmentSchedulingParameterPolicy::_narrow (sched_param.in ());
IOP::ServiceContext srv_con;
srv_con.context_id = Client_Interceptor::SchedulingInfo;
RTScheduling::Current::IdType_var guid = current_->id ();
int guid_length = guid->length ();
CORBA::OctetSeq seq_buf (guid_length);
seq_buf.length (seq_buf.maximum ());
ACE_OS::memcpy (seq_buf.get_buffer (),
guid->get_buffer (),
guid_length);
int cxt_data_length = sizeof (int) + guid_length;
srv_con.context_data.length (cxt_data_length);
int i = 0;
for (;i < guid_length;i++)
{
srv_con.context_data [i] = seq_buf [i];
}
int importance = sched_param_var->importance ();
CORBA::OctetSeq int_buf (sizeof (importance));
int_buf.length (int_buf.maximum ());
ACE_OS::memcpy (int_buf.get_buffer (),
&importance,
sizeof (importance));
int j = 0;
for (;i < cxt_data_length;i++)
{
srv_con.context_data [i] = int_buf [j++];
}
request_info->add_request_service_context (srv_con,
0);
lock_.acquire ();
if (ready_que_.message_count () > 0)
{
int priority;
ACE_hthread_t current;
ACE_Thread::self (current);
if (ACE_Thread::getprio (current, priority) == -1)
return;
ACE_DEBUG ((LM_DEBUG,
"Initial thread priority is %d %d\n",
priority,
ACE_DEFAULT_THREAD_PRIORITY));
RTCORBA::Priority rtpriority;
RTCORBA::PriorityMapping* pm = this->mapping_manager_->mapping ();
if (pm->to_CORBA(priority + 1, rtpriority))
{
current_->the_priority (rtpriority);
ACE_Thread::self (current);
if (ACE_Thread::getprio (current, priority) == -1)
return;
ACE_DEBUG ((LM_DEBUG,
"Bumped thread priority is %d\n",
priority));
}
DT* run_dt = 0;
ACE_Message_Block* msg = 0;
ready_que_.dequeue_head (msg);
run_dt = dynamic_cast<DT*> (msg);
run_dt->resume ();
free_que_.enqueue_prio (run_dt);
}
lock_.release ();
}
void
EDF_Scheduler::send_reply (PortableInterceptor::ServerRequestInfo_ptr ri)
{
int int_guid;
RTScheduling::Current::IdType_var guid = this->current_->id ();
ACE_OS::memcpy (&int_guid,
guid->get_buffer (),
guid->length ());
DSUI_EVENT_LOG (EDF_SCHED_FAM, ENTER_SEND_REPLY, int_guid, 0, 0);
Kokyu::Svc_Ctxt_DSRT_QoS sc_qos;
CORBA::String_var operation = ri->operation ();
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): send_reply from \"%s\"\n",
ri->operation ()));
#endif
// Make the context to send the context to the target
IOP::ServiceContext sc;
sc.context_id = Server_Interceptor::SchedulingInfo;
CORBA::Long importance;
TimeBase::TimeT deadline;
CORBA::Policy_var sched_policy =
this->current_->scheduling_parameter();
if (CORBA::is_nil (sched_policy))
{
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): sched_policy nil.\n"));
#endif
//24 hrs from now - infinity
ACE_Time_Value deadline_tv = ACE_OS::gettimeofday () + ACE_Time_Value (24*60*60,0);
deadline = deadline_tv.sec ()*1000000 + deadline_tv.usec ()*10; //100s of nanoseconds for TimeBase::TimeT
importance = 0;
}
else
{
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T):sched_policy not nil. ",
"sched params set\n"));
#endif
EDF_Scheduling::SchedulingParameterPolicy_var sched_param_policy =
EDF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy);
EDF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value ();
sc_qos.guid.length (guid->length ());
guid_copy (sc_qos.guid, guid.in ());
deadline = sched_param->deadline;
importance = sched_param->importance;
sc_qos.deadline = deadline;
sc_qos.importance = importance;
CORBA::Any sc_qos_as_any;
sc_qos_as_any <<= sc_qos;
CORBA::OctetSeq_var cdtmp = codec_->encode (sc_qos_as_any);
sc.context_data = cdtmp.in ();
// Add this context to the service context list.
ri->add_reply_service_context (sc, 1);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T):reply sc added\n"));
#endif
}
kokyu_dispatcher_->update_schedule (guid.in (),
Kokyu::BLOCK);
DSUI_EVENT_LOG (EDF_SCHED_FAM, EXIT_SEND_REPLY, int_guid, 0, 0);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T): send_reply interceptor done\n"));
#endif
}
void
EDF_Scheduler::send_request (PortableInterceptor::ClientRequestInfo_ptr ri)
{
int int_guid;
RTScheduling::Current::IdType_var guid = this->current_->id ();
ACE_OS::memcpy (&int_guid,
guid->get_buffer (),
guid->length ());
DSUI_EVENT_LOG (EDF_SCHED_FAM, ENTER_CLIENT_SCHED_TIME, int_guid, 0, 0);
Kokyu::Svc_Ctxt_DSRT_QoS sc_qos;
CORBA::String_var operation = ri->operation ();
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): send_request "
"from \"%s\"\n",
operation.in ()));
#endif
// Make the context to send the context to the target
IOP::ServiceContext sc;
sc.context_id = Client_Interceptor::SchedulingInfo;
CORBA::Policy_var sched_policy =
this->current_->scheduling_parameter();
CORBA::Long importance;
TimeBase::TimeT deadline;
TimeBase::TimeT period;
int task_id=-1;
if (CORBA::is_nil (sched_policy))
{
//24 hrs from now - infinity
ACE_Time_Value deadline_tv = ACE_OS::gettimeofday () + ACE_Time_Value (24*60*60,0);
deadline = deadline_tv.sec () * 10000000 + deadline_tv.usec () * 10; //100s of nanoseconds for TimeBase::TimeT
importance = 0;
period = 0; //set period 0 as default.
// task_id = ID_BEGIN ++;
}
else
{
EDF_Scheduling::SchedulingParameterPolicy_var sched_param_policy =
EDF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy);
EDF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value ();
deadline = sched_param->deadline;
importance = sched_param->importance;
period = sched_param->period;
task_id = sched_param->task_id;
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): send_request guid = %d\n",
int_guid));
#endif
}
//Fill the guid in the SC Qos struct
sc_qos.guid.length (guid->length ());
guid_copy (sc_qos.guid, guid.in ());
sc_qos.deadline = deadline;
sc_qos.importance = importance;
sc_qos.task_id = task_id;
sc_qos.period = period;
CORBA::Any sc_qos_as_any;
sc_qos_as_any <<= sc_qos;
CORBA::OctetSeq_var cdtmp = codec_->encode (sc_qos_as_any);
sc.context_data = cdtmp.in ();
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t|%T): send_request : about to add sched SC\n")));
#endif
// Add this context to the service context list.
ri->add_request_service_context (sc, 0);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t|%T): send_request : ")
ACE_TEXT ("about to call scheduler to inform block\n")
));
#endif
DSUI_EVENT_LOG (EDF_SCHED_FAM, CALL_KOKYU_DISPATCH_UPDATE_SCHEDULE,
int_guid, 0, 0);
kokyu_dispatcher_->update_schedule (guid.in (),
Kokyu::BLOCK);
DSUI_EVENT_LOG (EDF_SCHED_FAM, LEAVE_KOKYU_DISPATCH_UPDATE_SCHEDULE,
int_guid,0,0);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t|%T): send_request interceptor done\n")));
#endif
DSUI_EVENT_LOG (EDF_SCHED_FAM, LEAVE_CLIENT_SCHED_TIME, int_guid, 0, 0);
}
void
Job_i::work (CORBA::ULong work,
CORBA::Short importance)
{
static CORBA::ULong prime_number = 9619;
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"Job_i::work: %d units of work\n",
work));
CORBA::Object_var object =
this->dt_creator_->orb ()->resolve_initial_references (
"RTScheduler_Current");
RTScheduling::Current_var current =
RTScheduling::Current::_narrow (object.in ());
RTScheduling::Current::IdType_var guid = current->id ();
if (guid_ == 0)
ACE_OS::memcpy (&guid_,
guid->get_buffer (),
sizeof (guid->length ()));
if (TAO_debug_level > 0)
ACE_DEBUG ((LM_DEBUG,
"%t Guid is %d, Importance is %d\n",
guid_,
importance));
ACE_TCHAR msg [BUFSIZ];
ACE_OS::sprintf (msg,
ACE_TEXT("Guid is ")
ACE_SIZE_T_FORMAT_SPECIFIER
ACE_TEXT("\n"), guid_);
dt_creator_->log_msg (ACE_TEXT_ALWAYS_CHAR(msg));
for (; work != 0; work--)
{
// ACE_hrtime_t now = ACE_OS::gethrtime ();
ACE_Time_Value *base_time = dt_creator_->base_time ();
if (base_time == 0)
return;
ACE_Time_Value run_time = ACE_OS::gettimeofday () - *(base_time);
TASK_STATS::instance ()->sample (run_time.sec (), guid_);
ACE_Time_Value count_down_time (1);
ACE_Countdown_Time count_down (&count_down_time);
while (count_down_time > ACE_Time_Value::zero)
{
ACE::is_prime (prime_number,
2,
prime_number / 2);
count_down.update ();
}
run_time = ACE_OS::gettimeofday () - *(dt_creator_->base_time ());
TASK_STATS::instance ()->sample (run_time.sec (), guid_);
CORBA::Policy_var sched_param;
sched_param = dt_creator_->sched_param (importance);
const char * name = 0;
current->update_scheduling_segment (name,
sched_param.in (),
sched_param.in ());
}
}
CORBA::Long
Simple_Server_i::test_method (CORBA::Long exec_duration)
{
ACE_hthread_t thr_handle;
ACE_Thread::self (thr_handle);
int prio;
int guid;
RTScheduling::Current::IdType_var id = this->current_->id ();
ACE_OS::memcpy (&guid,
id->get_buffer (),
sizeof (id->length ()));
ACE_High_Res_Timer timer;
ACE_Time_Value elapsed_time;
ACE_DEBUG ((LM_DEBUG, "Request in thread %t\n"));
if (ACE_Thread::getprio (thr_handle, prio) == -1)
{
if (errno == ENOTSUP)
{
ACE_DEBUG((LM_DEBUG,
ACE_TEXT ("getprio not supported on this platform\n")));
return 0;
}
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("getprio failed")),
-1);
}
ACE_DEBUG ((LM_DEBUG,
"Request in thread %t, prio = %d,"
"exec duration = %u\n", prio, exec_duration));
static CORBA::ULong prime_number = 9619899;
ACE_Time_Value compute_count_down_time (exec_duration, 0);
ACE_Countdown_Time compute_count_down (&compute_count_down_time);
//Applicable only for CV based implementations
//yield every 1 sec
ACE_Time_Value yield_interval (1,0);
ACE_Time_Value yield_count_down_time (yield_interval);
ACE_Countdown_Time yield_count_down (&yield_count_down_time);
timer.start ();
int j=0;
while (compute_count_down_time > ACE_Time_Value::zero)
{
ACE::is_prime (prime_number,
2,
prime_number / 2);
++j;
#ifdef KOKYU_DSRT_LOGGING
if (j%1000 == 0)
{
ACE_DEBUG ((LM_DEBUG,
"(%t|%T) loop # = %d, load = %usec\n", j, exec_duration));
}
#endif
if (j%1000 == 0)
{
ACE_Time_Value run_time = ACE_OS::gettimeofday ();
task_stats_.sample (ACE_UINT32 (run_time.msec ()), guid);
}
compute_count_down.update ();
if (enable_yield_)
{
yield_count_down.update ();
if (yield_count_down_time <= ACE_Time_Value::zero)
{
CORBA::Policy_var sched_param_policy =
current_->scheduling_parameter();
const char * name = 0;
CORBA::Policy_ptr implicit_sched_param = 0;
current_->update_scheduling_segment (name,
sched_param_policy.in (),
implicit_sched_param);
yield_count_down_time = yield_interval;
yield_count_down.start ();
}
}
}
timer.stop ();
timer.elapsed_time (elapsed_time);
ACE_DEBUG ((LM_DEBUG,
"Request processing in thread %t done, "
"prio = %d, load = %d, elapsed time = %umsec\n",
prio, exec_duration, elapsed_time.msec () ));
return exec_duration;
}
int
Thread_Task::svc (void)
{
try
{
const char * name = 0;
CORBA::Policy_ptr sched_param = 0;
CORBA::Policy_ptr implicit_sched_param = 0;
//Start - Nested Scheduling Segment
this->current_->begin_scheduling_segment ("Chamber of Secrets",
sched_param,
implicit_sched_param);
size_t count = 0;
RTScheduling::Current::IdType_var id = this->current_->id ();
ACE_OS::memcpy (&count,
id->get_buffer (),
id->length ());
this->current_->begin_scheduling_segment ("Potter",
sched_param,
implicit_sched_param);
this->guid_[guid_index++] = id.in ();
//Start - Nested Scheduling Segment
this->current_->begin_scheduling_segment ("Harry",
sched_param,
implicit_sched_param);
{
ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->mutex_, -1);
RTScheduling::Current::NameList_var name_list = this->current_->current_scheduling_segment_names ();
ACE_DEBUG ((LM_DEBUG,
"Scheduling Segments for DT %d :\n",
count));
for (unsigned int i = 0; i < name_list->length (); ++i)
{
ACE_DEBUG ((LM_DEBUG,
"Scheduling Segment Name - %C\n",
(*name_list) [i].in ()));
}
}
ACE_OS::sleep (10);
this->current_->end_scheduling_segment (name);
// End - Nested Scheduling Segment
this->current_->end_scheduling_segment (name);
// End - Nested Scheduling Segment
this->current_->end_scheduling_segment (name);
}
catch (const CORBA::THREAD_CANCELLED& )
{
ACE_DEBUG ((LM_DEBUG,
"Distributable Thread Cancelled - Expected Exception\n"));
{
ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->mutex_, -1);
--active_thread_count_;
if (active_thread_count_ == 0)
orb_->shutdown ();
}
return 0;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Caught exception:");
}
return 0;
}
void
MIF_Scheduler::send_reply (PortableInterceptor::ServerRequestInfo_ptr ri)
{
CORBA::Short importance = 0;
Kokyu::Svc_Ctxt_DSRT_QoS sc_qos;
CORBA::String_var operation = ri->operation ();
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): send_reply from \"%s\"\n",
ri->operation ()));
#endif
// Make the context to send the context to the target
IOP::ServiceContext sc;
sc.context_id = Server_Interceptor::SchedulingInfo;
CORBA::Policy_var sched_policy =
this->current_->scheduling_parameter();
RTScheduling::Current::IdType_var guid = this->current_->id ();
if (CORBA::is_nil (sched_policy.in ()))
{
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): sched_policy nil. ",
"importance not set in sched params\n"));
#endif
importance = 0;
}
else
{
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T):sched_policy not nil. ",
"importance set in sched params\n"));
#endif
MIF_Scheduling::SchedulingParameterPolicy_var sched_param_policy =
MIF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy.in ());
MIF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value ();
importance = sched_param->importance;
//Fill the guid in the SC Qos struct
sc_qos.guid.length (guid->length ());
guid_copy (sc_qos.guid, guid.in ());
sc_qos.importance = importance;
CORBA::Any sc_qos_as_any;
sc_qos_as_any <<= sc_qos;
CORBA::OctetSeq_var cdtmp = codec_->encode (sc_qos_as_any);
sc.context_data = cdtmp.in ();
// Add this context to the service context list.
ri->add_reply_service_context (sc, 1);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T):reply sc added\n"));
#endif
}
kokyu_dispatcher_->update_schedule (guid.in (),
Kokyu::BLOCK);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG, "(%t|%T): send_reply interceptor done\n"));
#endif
}
void
MIF_Scheduler::send_request (PortableInterceptor::ClientRequestInfo_ptr ri)
{
Kokyu::Svc_Ctxt_DSRT_QoS sc_qos;
CORBA::String_var operation = ri->operation ();
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): send_request "
"from \"%s\"\n",
operation.in ()));
#endif
// Make the context to send the context to the target
IOP::ServiceContext sc;
sc.context_id = Client_Interceptor::SchedulingInfo;
CORBA::Policy_var sched_policy =
this->current_->scheduling_parameter();
RTScheduling::Current::IdType_var guid = this->current_->id ();
/*
ACE_OS::memcpy (&guid,
guid->get_buffer (),
guid->length ());
*/
CORBA::Short importance;
if (CORBA::is_nil (sched_policy.in ()))
{
importance = 0;
}
else
{
MIF_Scheduling::SchedulingParameterPolicy_var sched_param_policy =
MIF_Scheduling::SchedulingParameterPolicy::_narrow (sched_policy.in ());
MIF_Scheduling::SchedulingParameter_var sched_param = sched_param_policy->value ();
importance = sched_param->importance;
#ifdef KOKYU_DSRT_LOGGING
int int_guid;
ACE_OS::memcpy (&int_guid,
guid->get_buffer (),
guid->length ());
ACE_DEBUG ((LM_DEBUG,
"(%t|%T): send_request importance from current = %d, guid = %d\n",
importance, int_guid));
#endif
//Fill the guid in the SC Qos struct
sc_qos.guid.length (guid->length ());
guid_copy (sc_qos.guid, guid.in ());
sc_qos.importance = importance;
CORBA::Any sc_qos_as_any;
sc_qos_as_any <<= sc_qos;
CORBA::OctetSeq_var cdtmp = codec_->encode (sc_qos_as_any);
sc.context_data = cdtmp.in ();
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t|%T): send_request : about to add sched SC\n")));
#endif
// Add this context to the service context list.
ri->add_request_service_context (sc, 0);
}
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t|%T): send_request : ")
ACE_TEXT ("about to call scheduler to inform block\n")
));
#endif
kokyu_dispatcher_->update_schedule (guid.in (),
Kokyu::BLOCK);
#ifdef KOKYU_DSRT_LOGGING
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%t|%T): send_request interceptor done\n")));
#endif
}