TAO_EC_Kokyu_Dispatching Class Reference

Dispatching strategy that minimizes priority inversion. More...

#include <EC_Kokyu_Dispatching.h>

Inheritance diagram for TAO_EC_Kokyu_Dispatching:

[legend]Collaboration diagram for TAO_EC_Kokyu_Dispatching:

[legend]List of all members.

Public Member Functions
	TAO_EC_Kokyu_Dispatching (TAO_EC_Event_Channel_Base *ec, int sched_policy, int sched_scope)
virtual void	activate (void)
virtual void	shutdown (void)
virtual void	push (TAO_EC_ProxyPushSupplier *proxy, RtecEventComm::PushConsumer_ptr consumer, const RtecEventComm::EventSet &event, TAO_EC_QOS_Info &qos_info)
virtual void	push_nocopy (TAO_EC_ProxyPushSupplier *proxy, RtecEventComm::PushConsumer_ptr consumer, RtecEventComm::EventSet &event, TAO_EC_QOS_Info &qos_info)
Private Member Functions
void	setup_lanes (void)
Private Attributes
ACE_Allocator *	allocator_
Kokyu::Dispatcher_Auto_Ptr	dispatcher_
	The dispatcher.
RtecScheduler::Scheduler_var	scheduler_
	The scheduler.
int	lanes_setup_
int	disp_sched_policy_
int	disp_sched_scope_

---

Detailed Description

Dispatching strategy that minimizes priority inversion.

This strategy uses multiple queues, each serviced by a thread at different priority. This minimizes priority inversion because the consumers at higher priority are serviced before consumers at lower priority. It is more flexible than using the supplier thread to dispatch because it allows high-priority suppliers to push events to low-priority consumers (and vice-versa). It also isolates the supplier threads from the time spent on upcalls to the consumer objects, making the system easier to analyze and schedule.

Definition at line 55 of file EC_Kokyu_Dispatching.h.

---

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_EC_Kokyu_Dispatching::TAO_EC_Kokyu_Dispatching	(	TAO_EC_Event_Channel_Base *	ec,
		int	sched_policy,
		int	sched_scope
	)

The scheduler is used to find the range of priorities and similar info.

Definition at line 27 of file EC_Kokyu_Dispatching.cpp.

References TAO_Pseudo_Var_T< T >::in(), and ACE_Allocator::instance().

  :allocator_ (0),
   dispatcher_ (0),
   lanes_setup_ (0),
   disp_sched_policy_ (sched_policy),
   disp_sched_scope_ (sched_scope)
{
  CORBA::Object_var tmp = ec->scheduler ();
  this->scheduler_ = RtecScheduler::Scheduler::_narrow (tmp.in ());

  //@@VS - need to revisit this - should be some other allocator
  if (this->allocator_ == 0)
    {
      this->allocator_ = ACE_Allocator::instance ();
    }
}

---

Member Function Documentation

void TAO_EC_Kokyu_Dispatching::activate

(

void

)

[virtual]

Initialize all the data structures, activate any internal threads, etc.

Implements TAO_EC_Dispatching.

Definition at line 45 of file EC_Kokyu_Dispatching.cpp.

References dispatcher_, lanes_setup_, and setup_lanes().

{
  if (!lanes_setup_)
    setup_lanes ();

  this->dispatcher_->activate ();

  //ACE_DEBUG ((LM_DEBUG, "Kokyu dispatcher activated\n"));
}

void TAO_EC_Kokyu_Dispatching::push	(	TAO_EC_ProxyPushSupplier *	proxy,
		RtecEventComm::PushConsumer_ptr	consumer,
		const RtecEventComm::EventSet &	event,
		TAO_EC_QOS_Info &	qos_info
	)			[virtual]

The consumer represented by proxy should receive event. It can use the information in qos_info to determine the event priority (among other things).

Implements TAO_EC_Dispatching.

Definition at line 111 of file EC_Kokyu_Dispatching.cpp.

References push_nocopy().

{
  RtecEventComm::EventSet event_copy = event;
  this->push_nocopy (proxy, consumer, event_copy, qos_info);
}

void TAO_EC_Kokyu_Dispatching::push_nocopy	(	TAO_EC_ProxyPushSupplier *	proxy,
		RtecEventComm::PushConsumer_ptr	consumer,
		RtecEventComm::EventSet &	event,
		TAO_EC_QOS_Info &	qos_info
	)			[virtual]

Implements TAO_EC_Dispatching.

Definition at line 121 of file EC_Kokyu_Dispatching.cpp.

References allocator_, CORBA::COMPLETED_NO, dispatcher_, ACE_Allocator::malloc(), TAO_EC_QOS_Info::rt_info, scheduler_, and TAO::VMCID.

Referenced by push().

{
    if (this->dispatcher_.get () == 0)
        this->setup_lanes ();

    void* buf =
      this->allocator_->malloc (sizeof (TAO_EC_Kokyu_Push_Command ));

    if (buf == 0)
      throw CORBA::NO_MEMORY (TAO::VMCID, CORBA::COMPLETED_NO);

  // Create Dispatch_Command
  TAO_EC_Kokyu_Push_Command *cmd =
    new (buf) TAO_EC_Kokyu_Push_Command (proxy,
                                         consumer,
                                         event, this->allocator_);

  /*
  TAO_EC_Kokyu_Push_Command *cmd =
    new TAO_EC_Kokyu_Push_Command (proxy,
                                   consumer,
                                 event, 0);
  */

  // Convert TAO_EC_QOS_Info to QoSDescriptor
  RtecScheduler::RT_Info *rt_info =
    this->scheduler_->get(qos_info.rt_info);

  Kokyu::QoSDescriptor qosd;
  qosd.preemption_priority_ = rt_info->preemption_priority;
  qosd.deadline_ = rt_info->period;
  ORBSVCS_Time::TimeT_to_Time_Value (qosd.execution_time_,
                                     rt_info->worst_case_execution_time);

  this->dispatcher_->dispatch(cmd,qosd);
}

void TAO_EC_Kokyu_Dispatching::setup_lanes

(

void

)

[private]

Definition at line 56 of file EC_Kokyu_Dispatching.cpp.

References disp_sched_policy_, disp_sched_scope_, dispatcher_, lanes_setup_, and scheduler_.

Referenced by activate().

{
  // Query the scheduler togetConfig_Infos
  RtecScheduler::Config_Info_Set_var configs;
  try
    {
      this->scheduler_->get_config_infos(configs.out());
    }
  catch (const CORBA::Exception&)
    {
      // Ignore exceptions..
    }

  //might be no Config_Infos in the set (if none passed to scheduler_)

  // Convert RtecScheduler::Config_Info_Set     to Kokyu::ConfigInfoSet
  // OK to assume exact correspondence betwen Config_Info and ConfigInfo?
  Kokyu::ConfigInfoSet kconfigs(configs->length());
  for(CORBA::ULong i=0; i<configs->length(); ++i) {
        kconfigs[i].preemption_priority_ = configs[i].preemption_priority;
        kconfigs[i].thread_priority_ = configs[i].thread_priority;
        switch (configs[i].dispatching_type) {
                case RtecScheduler::STATIC_DISPATCHING:
                        kconfigs[i].dispatching_type_ = Kokyu::FIFO_DISPATCHING;
                        break;
                case RtecScheduler::DEADLINE_DISPATCHING:
                        kconfigs[i].dispatching_type_ = Kokyu::DEADLINE_DISPATCHING;
                        break;
                case RtecScheduler::LAXITY_DISPATCHING:
                        kconfigs[i].dispatching_type_ = Kokyu::LAXITY_DISPATCHING;
                        break;
        }
  }

  Kokyu::Dispatcher_Attributes attrs;
  attrs.config_info_set_ = kconfigs;
  attrs.sched_policy (disp_sched_policy_);
  attrs.sched_scope (disp_sched_scope_);

  // Create Kokyu::Dispatcher using factory
  Kokyu::Dispatcher_Auto_Ptr
    tmp(Kokyu::Dispatcher_Factory::create_dispatcher(attrs));
  this->dispatcher_ = tmp;
  this->lanes_setup_ = 1;

  //ACE_DEBUG ((LM_DEBUG, "Kokyu dispatcher setup\n"));
}

void TAO_EC_Kokyu_Dispatching::shutdown

(

void

)

[virtual]

Deactivate any internal threads and cleanup internal data structures, it should only return once the threads have finished their jobs.

Implements TAO_EC_Dispatching.

Definition at line 105 of file EC_Kokyu_Dispatching.cpp.

References dispatcher_.

{
  this->dispatcher_->shutdown();
}

---

Member Data Documentation

ACE_Allocator* TAO_EC_Kokyu_Dispatching::allocator_ [private]

Definition at line 77 of file EC_Kokyu_Dispatching.h.

Referenced by push_nocopy().

int TAO_EC_Kokyu_Dispatching::disp_sched_policy_ [private]

Definition at line 88 of file EC_Kokyu_Dispatching.h.

Referenced by setup_lanes().

int TAO_EC_Kokyu_Dispatching::disp_sched_scope_ [private]

Definition at line 89 of file EC_Kokyu_Dispatching.h.

Referenced by setup_lanes().

Kokyu::Dispatcher_Auto_Ptr TAO_EC_Kokyu_Dispatching::dispatcher_ [private]

The dispatcher.

Definition at line 82 of file EC_Kokyu_Dispatching.h.

Referenced by activate(), push_nocopy(), setup_lanes(), and shutdown().

int TAO_EC_Kokyu_Dispatching::lanes_setup_ [private]

Definition at line 87 of file EC_Kokyu_Dispatching.h.

Referenced by activate(), and setup_lanes().

RtecScheduler::Scheduler_var TAO_EC_Kokyu_Dispatching::scheduler_ [private]

The scheduler.

Definition at line 85 of file EC_Kokyu_Dispatching.h.

Referenced by push_nocopy(), and setup_lanes().

---

The documentation for this class was generated from the following files:

• EC_Kokyu_Dispatching.h
• EC_Kokyu_Dispatching.cpp

---