diff options
| author | yamuna <yamuna@ae88bc3d-4319-0410-8dbf-d08b4c9d3795> | 2003-07-24 07:10:39 +0000 |
|---|---|---|
| committer | yamuna <yamuna@ae88bc3d-4319-0410-8dbf-d08b4c9d3795> | 2003-07-24 07:10:39 +0000 |
| commit | 21453632c6beea5462fff5e7e5eeeee4900ebb1d (patch) | |
| tree | 9c27babd7e7f30f6dfe881ea8fca9981b971bb35 | |
| parent | d1661833e329ace9d633f4262c6fde20612248d9 (diff) | |
| download | ATCD-21453632c6beea5462fff5e7e5eeeee4900ebb1d.tar.gz | |
ChangelogTag: Thu Jul 24 03:03:20 2003 Yamuna Krishnamurthy <yamuna@oomworks.com>
52 files changed, 8989 insertions, 0 deletions
diff --git a/TAO/examples/RTScheduling/DT_Creator.cpp b/TAO/examples/RTScheduling/DT_Creator.cpp new file mode 100644 index 00000000000..0609cddf0b7 --- /dev/null +++ b/TAO/examples/RTScheduling/DT_Creator.cpp @@ -0,0 +1,678 @@ +//$Id$ + + +#include "DT_Creator.h" +#include "Thread_Task.h" +#include "tao/ORB_Core.h" +#include "Task_Stats.h" +#include "ace/High_Res_Timer.h" +#include "Task.h" +#include "DT_Creator.h" +#include "tao/RTScheduling/Current.h" + +ACE_Atomic_Op<TAO_SYNCH_MUTEX, long> guid_counter; + +int +DT_Creator::dt_task_init (ACE_Arg_Shifter& arg_shifter) +{ + static int dt_index = 0; + int start_time = 0; + int load = 0; + int iter = 0; + int importance = 0; + char *job_name = 0; + int dist = 0; + const ACE_TCHAR* current_arg = 0; + if (arg_shifter.cur_arg_strncasecmp ("-Importance") == 0) + { + arg_shifter.consume_arg (); + current_arg = arg_shifter.get_current (); + importance = ACE_OS::atoi (current_arg); + arg_shifter.consume_arg (); + } + if ((current_arg = arg_shifter.get_the_parameter ("-Start_Time"))) + { + start_time = ACE_OS::atoi (current_arg); + arg_shifter.consume_arg (); + } + if ((current_arg = arg_shifter.get_the_parameter ("-Iter"))) + { + iter = ACE_OS::atoi (current_arg); + arg_shifter.consume_arg (); + } + if ((current_arg = arg_shifter.get_the_parameter ("-Load"))) + { + load = ACE_OS::atoi (current_arg); + arg_shifter.consume_arg (); + } + if ((current_arg = arg_shifter.get_the_parameter ("-JobName"))) + { + job_name = (char *)current_arg; + dist = 1; + arg_shifter.consume_arg (); + } + dt_list_ [dt_index++] = this->create_thr_task (importance, + start_time, + load, + iter, + dist, + job_name); + return 0; + +} + +int log_index = 0; +int +DT_Creator::init (int argc, char *argv []) +{ + gsf_ = ACE_High_Res_Timer::global_scale_factor (); + state_lock_ = new ACE_Lock_Adapter <TAO_SYNCH_MUTEX>; + shutdown_lock_ = new ACE_Lock_Adapter <TAO_SYNCH_MUTEX>; + active_dt_count_ = 0; + active_job_count_ = 0; + ACE_NEW_RETURN (log, char*[BUFSIZ * 100],-1); + + ACE_Arg_Shifter arg_shifter (argc, argv); + + const ACE_TCHAR* current_arg = 0; + + dt_count_ = 0; + poa_count_ = 0; + int poa_count = 0; + job_count_ = 0; + int job_count = 0; + while (arg_shifter.is_anything_left ()) + { + if ((current_arg = arg_shifter.get_the_parameter ("-GuidSeed"))) + { + guid_counter = (long) ACE_OS::atoi (current_arg); + arg_shifter.consume_arg (); + } + else if ((current_arg = arg_shifter.get_the_parameter ("-DT_Count"))) + { + dt_count_ = ACE_OS::atoi (current_arg); + ACE_NEW_RETURN (dt_list_, Thread_Task*[dt_count_], -1); + active_dt_count_ = dt_count_; + arg_shifter.consume_arg (); + } + else if ((current_arg = arg_shifter.get_the_parameter ("-POA_Count"))) + { + poa_count_ = ACE_OS::atoi (current_arg); + ACE_NEW_RETURN (poa_list_, POA_Holder*[poa_count_], -1); + arg_shifter.consume_arg (); + } + else if ((current_arg = arg_shifter.get_the_parameter ("-JOB_Count"))) + { + job_count_ = ACE_OS::atoi (current_arg); + active_job_count_ = job_count_; + ACE_NEW_RETURN (job_list_, Job_i*[job_count_], -1); + arg_shifter.consume_arg (); + } + else if (arg_shifter.cur_arg_strncasecmp ("-DT_Task") == 0) + { + arg_shifter.consume_arg (); + dt_task_init (arg_shifter); + } + else if (arg_shifter.cur_arg_strncasecmp ("-POA") == 0) + { + arg_shifter.consume_arg (); + + ACE_NEW_RETURN (this->poa_list_[poa_count], POA_Holder (), -1); + + if (this->poa_list_[poa_count]->init (arg_shifter) == -1) + { + delete this->poa_list_[poa_count]; + return -1; + } + else + poa_count++; + } + else if (arg_shifter.cur_arg_strncasecmp ("-Job") == 0) + { + arg_shifter.consume_arg (); + + ACE_NEW_RETURN (this->job_list_[job_count], Job_i (this), -1); + + if (this->job_list_[job_count]->init (arg_shifter) == -1) + { + delete this->job_list_[job_count]; + return -1; + } + else + job_count++; + } + else if ((current_arg = arg_shifter.get_the_parameter ("-OutFile"))) + { + file_name_ = CORBA::string_dup (current_arg); + arg_shifter.consume_arg (); + } + else if ((current_arg = arg_shifter.get_the_parameter ("-LogFile"))) + { + log_file_name_ = CORBA::string_dup (current_arg); + arg_shifter.consume_arg (); + } + else + { + arg_shifter.ignore_arg (); + } + } + + return 0; +} + +void +DT_Creator::register_synch_obj (ACE_ENV_SINGLE_ARG_DECL) +{ + CosNaming::Name name (1); + name.length (1); + + CosNaming::NamingContext_var synch_context; + + ACE_TRY + { + // Try binding the sender context in the NS + name [0].id = + CORBA::string_dup ("Synch"); + + synch_context = this->naming_->bind_new_context (name + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + // + // We reach here if there was no exception raised in + // <bind_new_context>. We then create a receiver context. + // + + } + ACE_CATCH (CosNaming::NamingContext::AlreadyBound, al_ex) + { + // + // The synch context already exists, probably created by the + // receiver(s). + // + + // Get the synch context. + name [0].id = + CORBA::string_dup ("Synch"); + + CORBA::Object_var object = + this->naming_->resolve (name + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + synch_context = CosNaming::NamingContext::_narrow (object.in ()); + + } + ACE_ENDTRY; + ACE_CHECK; + + ACE_CString synch_name ("Synch"); + ACE_Time_Value timestamp = ACE_OS::gettimeofday (); + + char buf [BUFSIZ]; + synch_name += CORBA::string_dup (ACE_OS::itoa (timestamp.sec (), buf, 10)); + + name [0].id = + CORBA::string_dup (synch_name.c_str ()); + + ACE_DEBUG ((LM_DEBUG, + "Synch Name %s\n", + synch_name.c_str ())); + + ACE_NEW (synch_, + Synch_i); + + Synch_var synch = synch_->_this (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + // Register the synch object with the Synch context. + synch_context->rebind (name, + synch.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + +} + + +int +DT_Creator::activate_root_poa (ACE_ENV_SINGLE_ARG_DECL) +{ + CORBA::Object_var object = + orb_->resolve_initial_references ("RootPOA" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + root_poa_ = + PortableServer::POA::_narrow (object.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + PortableServer::POAManager_var poa_manager = + root_poa_->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + return 0; +} + +void +DT_Creator::activate_poa_list (ACE_ENV_SINGLE_ARG_DECL) +{ + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "DT_Creator::activate_poa_list\n")); + + if (poa_count_ > 0) + { + CORBA::Object_var object = + orb_->resolve_initial_references ("RTORB" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + this->rt_orb_ = + RTCORBA::RTORB::_narrow (object.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + + for (int i = 0; i < poa_count_; ++i) + { + poa_list_[i]->activate (this->rt_orb_.in(), this->root_poa_.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } +} + +void +DT_Creator::activate_job_list (ACE_ENV_SINGLE_ARG_DECL) +{ + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "DT_Creator::activate_job_list\n")); + + Job_i* job; + + for (int i = 0; i < job_count_; ++i) + { + job = job_list_[i]; + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "Activating job:%s\n", job->name ().c_str ())); + + // find your poa + PortableServer::POA_var host_poa = + root_poa_->find_POA (job->poa ().c_str (), 0 + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + PortableServer::ServantBase_var servant_var (job); + + // Register with poa. + PortableServer::ObjectId_var id; + + id = host_poa->activate_object (job + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + CORBA::Object_var server = + host_poa->id_to_reference (id.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + CORBA::String_var ior = + orb_->object_to_string (server.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + const ACE_CString &job_name = job->name (); + + CosNaming::Name_var name = + this->naming_->to_name (job_name.c_str () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + this->naming_->rebind (name.in (), + server.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + + } /* while */ + + ACE_DEBUG ((LM_DEBUG, + "Activated Job List\n")); +} + +void +DT_Creator::activate_schedule (ACE_ENV_SINGLE_ARG_DECL) +{ + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "Activating schedule, task count = %d\n", + dt_count_)); + + Thread_Task* task; + + for (int i = 0; i < dt_count_; ++i) + { + task = dt_list_[i]; + + if (task->dist ()) + { + // resolve the object from the naming service + CosNaming::Name name (1); + name.length (1); + name[0].id = CORBA::string_dup (task->job ()); + + CORBA::Object_var obj = + this->naming_->resolve (name ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + Job_var job = Job::_narrow (obj.in () ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + // if (TAO_debug_level > 0) + // { + // Check that the object is configured with some + // PriorityModelPolicy. + CORBA::Policy_var policy = + job->_get_policy (RTCORBA::PRIORITY_MODEL_POLICY_TYPE + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + RTCORBA::PriorityModelPolicy_var priority_policy = + RTCORBA::PriorityModelPolicy::_narrow (policy.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + if (CORBA::is_nil (priority_policy.in ())) + ACE_DEBUG ((LM_DEBUG, + "ERROR: Priority Model Policy not exposed!\n")); + else + { + /* + RTCORBA::PriorityModel priority_model = + priority_policy->priority_model (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + if (priority_model == RTCORBA::CLIENT_PROPAGATED) + ACE_DEBUG ((LM_DEBUG, + "%s priority_model = RTCORBA::CLIENT_PROPAGATED\n", task->job ())); + else + ACE_DEBUG ((LM_DEBUG, + "%s priority_model = RTCORBA::SERVER_DECLARED\n", task->job ())); + */ + } + //} /* if (TAO_debug_level > 0) */ + + task->job (job.in ()); + } + } + if (TAO_debug_level > 0 && dt_count_ > 0) + ACE_DEBUG ((LM_DEBUG, + "Activated schedule, task count = %d\n", + dt_count_)); + +} + +int +DT_Creator::resolve_naming_service (ACE_ENV_SINGLE_ARG_DECL) +{ + CORBA::Object_var naming_obj = + this->orb_->resolve_initial_references ("NameService" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Need to check return value for errors. + if (CORBA::is_nil (naming_obj.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Unable to resolve the Naming Service.\n"), + -1); + + this->naming_ = + CosNaming::NamingContextExt::_narrow (naming_obj.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + //@@tmp hack, otherwise crashes on exit!..?? + CosNaming::NamingContextExt::_duplicate (this->naming_.in()); + return 0; +} + +void +DT_Creator::create_distributable_threads (RTScheduling::Current_ptr current + ACE_ENV_ARG_DECL) +{ + current_ = RTScheduling::Current::_duplicate (current); + + long flags; + flags = THR_NEW_LWP | THR_JOINABLE; + flags |= + orb_->orb_core ()->orb_params ()->scope_policy () | + orb_->orb_core ()->orb_params ()->sched_policy (); + + ACE_DEBUG ((LM_DEBUG, + "Waiting to Synch\n")); + + while (!this->synch ()->synched ()) + { + this->orb_->perform_work (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + } + + CORBA::Policy_var sched_param; + sched_param = CORBA::Policy::_duplicate (this->sched_param (100)); + const char * name = 0; + current_->begin_scheduling_segment (name, + sched_param.in (), + sched_param.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + ACE_NEW (base_time_, + ACE_Time_Value (*(this->synch ()->base_time ()))); + + for (int i = 0; i < this->dt_count_; i++) + { + ACE_Time_Value now (ACE_OS::gettimeofday ()); + + ACE_Time_Value elapsed_time = now - *base_time_; + + char buf [BUFSIZ]; + ACE_OS::sprintf (buf, "elapsed time = %d\n now = %d\n base_time_ = %d\n", + (int) elapsed_time.sec (), + (int) now.sec (), + (int) base_time_->sec()); + + log [log_index++] = ACE_OS::strdup (buf) ; + + ACE_hthread_t curr_thr; + ACE_Thread::self (curr_thr); + + if (dt_list_ [i]->start_time () != 0 && (elapsed_time.sec () < dt_list_[i]->start_time ())) + { + int suspension_time = dt_list_[i]->start_time () - elapsed_time.sec (); + ACE_OS::sprintf (buf,"suspension_tome = %d\n", + suspension_time); + log [log_index++] = ACE_OS::strdup (buf); + yield (suspension_time, + dt_list_[i]); + } + + sched_param = CORBA::Policy::_duplicate (this->sched_param (dt_list_ [i]->importance ())); + dt_list_ [i]->activate_task (current, + sched_param.in (), + flags, + base_time_ + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + } + + this->wait (); + + current_->end_scheduling_segment (name + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + this->check_ifexit (); +} + +void +DT_Creator::dt_ended (void) +{ + { + ACE_GUARD (ACE_Lock, ace_mon, *state_lock_); + --active_dt_count_; + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "Active dt count = %d\n",active_dt_count_)); + char buf [BUFSIZ]; + ACE_OS::sprintf (buf,"Active dt count = %d\n",active_dt_count_); + log [log_index++] = ACE_OS::strdup (buf); + } + this->check_ifexit (); +} + +void +DT_Creator::job_ended (void) +{ + { + ACE_GUARD (ACE_Lock, ace_mon, *state_lock_); + --active_job_count_; + char buf [BUFSIZ]; + ACE_OS::sprintf (buf,"Active job count = %d\n",active_job_count_); + log [log_index++] = ACE_OS::strdup (buf); + } + + this->check_ifexit (); +} + +void +DT_Creator::check_ifexit (void) +{ + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "Checking exit status Job# = %d DT# = %d\n", + active_job_count_, + active_dt_count_)); + + static int shutdown = 0; + + { + ACE_GUARD (ACE_Lock, ace_mon, *shutdown_lock_); + + if (!shutdown) + { + // All tasks have finished and all jobs have been shutdown. + if (active_dt_count_ == 0 && active_job_count_ == 0) + { + + ACE_DEBUG ((LM_DEBUG, "Shutdown in progress ...\n")); + + /* + for (int i = 0; i < dt_count_; i++) + { + dt_list_[i]->dump_stats (); + } + + for (int i = 0; i < job_count_; i ++) + { + job_list_[i]->dump_stats (); + } + */ + TASK_STATS::instance ()->dump_samples (file_name_, + "#Schedule Output", + ACE_High_Res_Timer::global_scale_factor ()); + + shutdown = 1; + + FILE* log_file = ACE_OS::fopen (log_file_name_, "w"); + + if (log_file != NULL) + { + // first dump what the caller has to say. + ACE_OS::fprintf (log_file, "Log File\n"); + + for (int i = 0; i < log_index; i++) + { + ACE_OS::fprintf (log_file, "%s\n", log [i]); + } + + ACE_OS::fclose (log_file); + } + ACE_DEBUG ((LM_DEBUG, + "Log File Ready\n")); + + } + } + } +} + +int +DT_Creator::dt_count (void) +{ + return dt_count_; +} + +DT_Creator::~DT_Creator (void) +{ + // for (int i = 0; i < (BUFSIZ * 100); i++) + delete[] log; + + delete[] dt_list_; + delete[] poa_list_; + delete[] job_list_; + + delete base_time_; + + delete state_lock_; + delete shutdown_lock_; +} + + +void +DT_Creator::log_msg (char* msg) +{ + log [log_index++] = ACE_OS::strdup (msg); +} + +CORBA::ORB_ptr +DT_Creator::orb (void) +{ + return this->orb_.in (); +} + +void +DT_Creator::orb (CORBA::ORB_ptr orb) +{ + this->orb_ = CORBA::ORB::_duplicate (orb); +} + +ACE_Time_Value* +DT_Creator::base_time (void) +{ + return this->base_time_; +} + +void +DT_Creator::base_time (ACE_Time_Value* base_time) +{ + this->base_time_ = base_time; +} + + +RTScheduling::Current_ptr +DT_Creator::current (void) +{ + return current_.in (); +} + + +Synch_i* +DT_Creator::synch (void) +{ + return this->synch_; +} diff --git a/TAO/examples/RTScheduling/FP_Scheduling.pidl b/TAO/examples/RTScheduling/FP_Scheduling.pidl new file mode 100644 index 00000000000..8868d9e4808 --- /dev/null +++ b/TAO/examples/RTScheduling/FP_Scheduling.pidl @@ -0,0 +1,19 @@ +//$Id$ +#include <tao/RTScheduling/RTScheduler.pidl> +#include <tao/RTCORBA/RTCORBA.pidl> + +module FP_Scheduling +{ + local interface SegmentSchedulingParameterPolicy + : CORBA::Policy + { + attribute RTCORBA::Priority value; + }; + + local interface FP_Scheduler : RTScheduling::Scheduler + { + SegmentSchedulingParameterPolicy + create_segment_scheduling_parameter + (in RTCORBA::Priority segment_priority); + }; +}; diff --git a/TAO/examples/RTScheduling/FP_SchedulingC.cpp b/TAO/examples/RTScheduling/FP_SchedulingC.cpp new file mode 100644 index 00000000000..5c18e2722b8 --- /dev/null +++ b/TAO/examples/RTScheduling/FP_SchedulingC.cpp @@ -0,0 +1,637 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be/be_codegen.cpp:351 + + +#include "FP_SchedulingC.h" +#include "tao/Stub.h" +#include "tao/Invocation.h" +#include "tao/PortableInterceptor.h" + +#if TAO_HAS_INTERCEPTORS == 1 +#include "tao/RequestInfo_Util.h" +#include "tao/ClientRequestInfo_i.h" +#include "tao/ClientInterceptorAdapter.h" +#endif /* TAO_HAS_INTERCEPTORS == 1 */ + + +#if defined (__BORLANDC__) +#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig +#endif /* __BORLANDC__ */ + +#if !defined (__ACE_INLINE__) +#include "FP_SchedulingC.i" +#endif /* !defined INLINE */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:63 + +int FP_Scheduling::SegmentSchedulingParameterPolicy::_tao_class_id = 0; + +FP_Scheduling::SegmentSchedulingParameterPolicy_ptr +FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life::tao_duplicate ( + SegmentSchedulingParameterPolicy_ptr p + ) +{ + return SegmentSchedulingParameterPolicy::_duplicate (p); +} + +void +FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life::tao_release ( + SegmentSchedulingParameterPolicy_ptr p + ) +{ + CORBA::release (p); +} + +FP_Scheduling::SegmentSchedulingParameterPolicy_ptr +FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life::tao_nil ( + void + ) +{ + return SegmentSchedulingParameterPolicy::_nil (); +} + +CORBA::Boolean +FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life::tao_marshal ( + SegmentSchedulingParameterPolicy_ptr p, + TAO_OutputCDR &cdr + ) +{ + return p->marshal (cdr); +} + +FP_Scheduling::SegmentSchedulingParameterPolicy_ptr +FP_Scheduling::tao_SegmentSchedulingParameterPolicy_cast::tao_narrow ( + CORBA::Object *p + ACE_ENV_ARG_DECL + ) +{ + return SegmentSchedulingParameterPolicy::_narrow (p ACE_ENV_ARG_PARAMETER); +} + +CORBA::Object * +FP_Scheduling::tao_SegmentSchedulingParameterPolicy_cast::tao_upcast ( + void *src + ) +{ + SegmentSchedulingParameterPolicy **tmp = + ACE_static_cast (SegmentSchedulingParameterPolicy **, src); + return *tmp; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + template class + TAO_Objref_Var_T< + FP_Scheduling::SegmentSchedulingParameterPolicy, + FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life + >; + template class + TAO_Objref_Out_T< + FP_Scheduling::SegmentSchedulingParameterPolicy, + FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life + >; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate \ + TAO_Objref_Var_T< \ + FP_Scheduling::SegmentSchedulingParameterPolicy, \ + FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life \ + > +# pragma instantiate \ + TAO_Objref_Out_T< \ + FP_Scheduling::SegmentSchedulingParameterPolicy, \ + FP_Scheduling::tao_SegmentSchedulingParameterPolicy_life \ + > +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:245 + +FP_Scheduling::SegmentSchedulingParameterPolicy::SegmentSchedulingParameterPolicy (void) +{} + +FP_Scheduling::SegmentSchedulingParameterPolicy::~SegmentSchedulingParameterPolicy (void) +{} + +void +FP_Scheduling::SegmentSchedulingParameterPolicy::_tao_any_destructor (void *_tao_void_pointer) +{ + SegmentSchedulingParameterPolicy *tmp = ACE_static_cast (SegmentSchedulingParameterPolicy *, _tao_void_pointer); + CORBA::release (tmp); +} + +FP_Scheduling::SegmentSchedulingParameterPolicy_ptr +FP_Scheduling::SegmentSchedulingParameterPolicy::_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) +{ + return SegmentSchedulingParameterPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER); +} + +FP_Scheduling::SegmentSchedulingParameterPolicy_ptr +FP_Scheduling::SegmentSchedulingParameterPolicy::_unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if (CORBA::is_nil (obj)) + { + return SegmentSchedulingParameterPolicy::_nil (); + } + + return + ACE_reinterpret_cast ( + SegmentSchedulingParameterPolicy_ptr, + obj->_tao_QueryInterface ( + ACE_reinterpret_cast ( + ptrdiff_t, + &SegmentSchedulingParameterPolicy::_tao_class_id + ) + ) + ); +} + +FP_Scheduling::SegmentSchedulingParameterPolicy_ptr +FP_Scheduling::SegmentSchedulingParameterPolicy::_duplicate (SegmentSchedulingParameterPolicy_ptr obj) +{ + if (! CORBA::is_nil (obj)) + { + obj->_add_ref (); + } + + return obj; +} + +void *FP_Scheduling::SegmentSchedulingParameterPolicy::_tao_QueryInterface (ptrdiff_t type) +{ + void *retv = 0; + + if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &ACE_NESTED_CLASS (::FP_Scheduling, SegmentSchedulingParameterPolicy)::_tao_class_id) + ) + { + retv = ACE_reinterpret_cast (void*, this); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &::CORBA::Policy::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast ( + CORBA::Policy_ptr, + this + ) + ); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &CORBA::Object::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast (CORBA::Object_ptr, this) + ); + } + + if (retv != 0) + { + this->_add_ref (); + } + + return retv; +} + +const char* FP_Scheduling::SegmentSchedulingParameterPolicy::_interface_repository_id (void) const +{ + return "IDL:FP_Scheduling/SegmentSchedulingParameterPolicy:1.0"; +} + +CORBA::Boolean +FP_Scheduling::SegmentSchedulingParameterPolicy::marshal (TAO_OutputCDR &) +{ + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_FP_Scheduling_SegmentSchedulingParameterPolicy[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 55, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x46505f53), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c696e), + ACE_NTOHL (0x672f5365), + ACE_NTOHL (0x676d656e), + ACE_NTOHL (0x74536368), + ACE_NTOHL (0x6564756c), + ACE_NTOHL (0x696e6750), + ACE_NTOHL (0x6172616d), + ACE_NTOHL (0x65746572), + ACE_NTOHL (0x506f6c69), + ACE_NTOHL (0x63793a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:FP_Scheduling/SegmentSchedulingParameterPolicy:1.0 + 33, + ACE_NTOHL (0x5365676d), + ACE_NTOHL (0x656e7453), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c696e), + ACE_NTOHL (0x67506172), + ACE_NTOHL (0x616d6574), + ACE_NTOHL (0x6572506f), + ACE_NTOHL (0x6c696379), + ACE_NTOHL (0x0), // name = SegmentSchedulingParameterPolicy + }; + +static CORBA::TypeCode _tc_TAO_tc_FP_Scheduling_SegmentSchedulingParameterPolicy ( + CORBA::tk_objref, + sizeof (_oc_FP_Scheduling_SegmentSchedulingParameterPolicy), + (char *) &_oc_FP_Scheduling_SegmentSchedulingParameterPolicy, + 0, + sizeof (FP_Scheduling::SegmentSchedulingParameterPolicy) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FP_Scheduling) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_SegmentSchedulingParameterPolicy, + &_tc_TAO_tc_FP_Scheduling_SegmentSchedulingParameterPolicy + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:63 + +int FP_Scheduling::FP_Scheduler::_tao_class_id = 0; + +FP_Scheduling::FP_Scheduler_ptr +FP_Scheduling::tao_FP_Scheduler_life::tao_duplicate ( + FP_Scheduler_ptr p + ) +{ + return FP_Scheduler::_duplicate (p); +} + +void +FP_Scheduling::tao_FP_Scheduler_life::tao_release ( + FP_Scheduler_ptr p + ) +{ + CORBA::release (p); +} + +FP_Scheduling::FP_Scheduler_ptr +FP_Scheduling::tao_FP_Scheduler_life::tao_nil ( + void + ) +{ + return FP_Scheduler::_nil (); +} + +CORBA::Boolean +FP_Scheduling::tao_FP_Scheduler_life::tao_marshal ( + FP_Scheduler_ptr p, + TAO_OutputCDR &cdr + ) +{ + return p->marshal (cdr); +} + +FP_Scheduling::FP_Scheduler_ptr +FP_Scheduling::tao_FP_Scheduler_cast::tao_narrow ( + CORBA::Object *p + ACE_ENV_ARG_DECL + ) +{ + return FP_Scheduler::_narrow (p ACE_ENV_ARG_PARAMETER); +} + +CORBA::Object * +FP_Scheduling::tao_FP_Scheduler_cast::tao_upcast ( + void *src + ) +{ + FP_Scheduler **tmp = + ACE_static_cast (FP_Scheduler **, src); + return *tmp; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + template class + TAO_Objref_Var_T< + FP_Scheduling::FP_Scheduler, + FP_Scheduling::tao_FP_Scheduler_life + >; + template class + TAO_Objref_Out_T< + FP_Scheduling::FP_Scheduler, + FP_Scheduling::tao_FP_Scheduler_life + >; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate \ + TAO_Objref_Var_T< \ + FP_Scheduling::FP_Scheduler, \ + FP_Scheduling::tao_FP_Scheduler_life \ + > +# pragma instantiate \ + TAO_Objref_Out_T< \ + FP_Scheduling::FP_Scheduler, \ + FP_Scheduling::tao_FP_Scheduler_life \ + > +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:245 + +FP_Scheduling::FP_Scheduler::FP_Scheduler (void) +{} + +FP_Scheduling::FP_Scheduler::~FP_Scheduler (void) +{} + +void +FP_Scheduling::FP_Scheduler::_tao_any_destructor (void *_tao_void_pointer) +{ + FP_Scheduler *tmp = ACE_static_cast (FP_Scheduler *, _tao_void_pointer); + CORBA::release (tmp); +} + +FP_Scheduling::FP_Scheduler_ptr +FP_Scheduling::FP_Scheduler::_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) +{ + return FP_Scheduler::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER); +} + +FP_Scheduling::FP_Scheduler_ptr +FP_Scheduling::FP_Scheduler::_unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if (CORBA::is_nil (obj)) + { + return FP_Scheduler::_nil (); + } + + return + ACE_reinterpret_cast ( + FP_Scheduler_ptr, + obj->_tao_QueryInterface ( + ACE_reinterpret_cast ( + ptrdiff_t, + &FP_Scheduler::_tao_class_id + ) + ) + ); +} + +FP_Scheduling::FP_Scheduler_ptr +FP_Scheduling::FP_Scheduler::_duplicate (FP_Scheduler_ptr obj) +{ + if (! CORBA::is_nil (obj)) + { + obj->_add_ref (); + } + + return obj; +} + +void *FP_Scheduling::FP_Scheduler::_tao_QueryInterface (ptrdiff_t type) +{ + void *retv = 0; + + if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &ACE_NESTED_CLASS (::FP_Scheduling, FP_Scheduler)::_tao_class_id) + ) + { + retv = ACE_reinterpret_cast (void*, this); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &::RTScheduling::Scheduler::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast ( + RTScheduling::Scheduler_ptr, + this + ) + ); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &CORBA::Object::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast (CORBA::Object_ptr, this) + ); + } + + if (retv != 0) + { + this->_add_ref (); + } + + return retv; +} + +const char* FP_Scheduling::FP_Scheduler::_interface_repository_id (void) const +{ + return "IDL:FP_Scheduling/FP_Scheduler:1.0"; +} + +CORBA::Boolean +FP_Scheduling::FP_Scheduler::marshal (TAO_OutputCDR &) +{ + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_FP_Scheduling_FP_Scheduler[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 35, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x46505f53), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c696e), + ACE_NTOHL (0x672f4650), + ACE_NTOHL (0x5f536368), + ACE_NTOHL (0x6564756c), + ACE_NTOHL (0x65723a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:FP_Scheduling/FP_Scheduler:1.0 + 13, + ACE_NTOHL (0x46505f53), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c6572), + ACE_NTOHL (0x0), // name = FP_Scheduler + }; + +static CORBA::TypeCode _tc_TAO_tc_FP_Scheduling_FP_Scheduler ( + CORBA::tk_objref, + sizeof (_oc_FP_Scheduling_FP_Scheduler), + (char *) &_oc_FP_Scheduling_FP_Scheduler, + 0, + sizeof (FP_Scheduling::FP_Scheduler) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FP_Scheduling) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_FP_Scheduler, + &_tc_TAO_tc_FP_Scheduling_FP_Scheduler + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_cs.cpp:50 + +// Copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + FP_Scheduling::SegmentSchedulingParameterPolicy_ptr _tao_elem + ) +{ + FP_Scheduling::SegmentSchedulingParameterPolicy_ptr _tao_objptr = + FP_Scheduling::SegmentSchedulingParameterPolicy::_duplicate (_tao_elem); + _tao_any <<= &_tao_objptr; +} + +// Non-copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + FP_Scheduling::SegmentSchedulingParameterPolicy_ptr *_tao_elem + ) +{ + TAO::Any_Impl_T<FP_Scheduling::SegmentSchedulingParameterPolicy>::insert ( + _tao_any, + FP_Scheduling::SegmentSchedulingParameterPolicy::_tao_any_destructor, + FP_Scheduling::_tc_SegmentSchedulingParameterPolicy, + *_tao_elem + ); +} + +CORBA::Boolean +operator>>= ( + const CORBA::Any &_tao_any, + FP_Scheduling::SegmentSchedulingParameterPolicy_ptr &_tao_elem + ) +{ + return + TAO::Any_Impl_T<FP_Scheduling::SegmentSchedulingParameterPolicy>::extract ( + _tao_any, + FP_Scheduling::SegmentSchedulingParameterPolicy::_tao_any_destructor, + FP_Scheduling::_tc_SegmentSchedulingParameterPolicy, + _tao_elem + ); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO::Any_Impl_T<FP_Scheduling::SegmentSchedulingParameterPolicy>; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate TAO::Any_Impl_T<FP_Scheduling::SegmentSchedulingParameterPolicy> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_cs.cpp:50 + +// Copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + FP_Scheduling::FP_Scheduler_ptr _tao_elem + ) +{ + FP_Scheduling::FP_Scheduler_ptr _tao_objptr = + FP_Scheduling::FP_Scheduler::_duplicate (_tao_elem); + _tao_any <<= &_tao_objptr; +} + +// Non-copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + FP_Scheduling::FP_Scheduler_ptr *_tao_elem + ) +{ + TAO::Any_Impl_T<FP_Scheduling::FP_Scheduler>::insert ( + _tao_any, + FP_Scheduling::FP_Scheduler::_tao_any_destructor, + FP_Scheduling::_tc_FP_Scheduler, + *_tao_elem + ); +} + +CORBA::Boolean +operator>>= ( + const CORBA::Any &_tao_any, + FP_Scheduling::FP_Scheduler_ptr &_tao_elem + ) +{ + return + TAO::Any_Impl_T<FP_Scheduling::FP_Scheduler>::extract ( + _tao_any, + FP_Scheduling::FP_Scheduler::_tao_any_destructor, + FP_Scheduling::_tc_FP_Scheduler, + _tao_elem + ); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO::Any_Impl_T<FP_Scheduling::FP_Scheduler>; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate TAO::Any_Impl_T<FP_Scheduling::FP_Scheduler> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + diff --git a/TAO/examples/RTScheduling/FP_SchedulingC.h b/TAO/examples/RTScheduling/FP_SchedulingC.h new file mode 100644 index 00000000000..890981b491c --- /dev/null +++ b/TAO/examples/RTScheduling/FP_SchedulingC.h @@ -0,0 +1,358 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be/be_codegen.cpp:151 + +#ifndef _TAO_IDL_____FP_SCHEDULINGC_H_ +#define _TAO_IDL_____FP_SCHEDULINGC_H_ + + +#include "tao/corba.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +#include "tao/RTScheduling/RTSchedulerC.h" +#include "tao/RTCORBA/RTCORBAC.h" + +#if defined (TAO_EXPORT_MACRO) +#undef TAO_EXPORT_MACRO +#endif +#define TAO_EXPORT_MACRO + +#if defined (TAO_EXPORT_NESTED_CLASSES) +# if defined (TAO_EXPORT_NESTED_MACRO) +# undef TAO_EXPORT_NESTED_MACRO +# endif /* defined (TAO_EXPORT_NESTED_MACRO) */ +# define TAO_EXPORT_NESTED_MACRO +#endif /* TAO_EXPORT_NESTED_CLASSES */ + +#if defined(_MSC_VER) +#if (_MSC_VER >= 1200) +#pragma warning(push) +#endif /* _MSC_VER >= 1200 */ +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option push -w-rvl -w-rch -w-ccc -w-inl +#endif /* __BORLANDC__ */ + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:48 + +TAO_NAMESPACE FP_Scheduling +{ + + // TAO_IDL - Generated from + // be/be_interface.cpp:584 + +#if !defined (_FP_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY__ODDS_N_ENDS_CH_) +#define _FP_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY__ODDS_N_ENDS_CH_ + + class SegmentSchedulingParameterPolicy; + typedef SegmentSchedulingParameterPolicy *SegmentSchedulingParameterPolicy_ptr; + struct tao_SegmentSchedulingParameterPolicy_life; + + typedef + TAO_Objref_Var_T< + SegmentSchedulingParameterPolicy, + tao_SegmentSchedulingParameterPolicy_life + > + SegmentSchedulingParameterPolicy_var; + + typedef + TAO_Objref_Out_T< + SegmentSchedulingParameterPolicy, + tao_SegmentSchedulingParameterPolicy_life + > + SegmentSchedulingParameterPolicy_out; + + struct tao_SegmentSchedulingParameterPolicy_life + { + static SegmentSchedulingParameterPolicy_ptr tao_duplicate (SegmentSchedulingParameterPolicy_ptr); + static void tao_release (SegmentSchedulingParameterPolicy_ptr); + static SegmentSchedulingParameterPolicy_ptr tao_nil (void); + static CORBA::Boolean tao_marshal ( + SegmentSchedulingParameterPolicy_ptr, + TAO_OutputCDR & + ); + }; + + struct tao_SegmentSchedulingParameterPolicy_cast + { + static SegmentSchedulingParameterPolicy_ptr tao_narrow ( + CORBA::Object_ptr + ACE_ENV_ARG_DECL + ); + static CORBA::Object_ptr tao_upcast (void *); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:53 + +#if !defined (_FP_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY_CH_) +#define _FP_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY_CH_ + + class SegmentSchedulingParameterPolicy + : public virtual CORBA::Policy + { + public: + typedef SegmentSchedulingParameterPolicy_ptr _ptr_type; + typedef SegmentSchedulingParameterPolicy_var _var_type; + static int _tao_class_id; + + // The static operations. + static SegmentSchedulingParameterPolicy_ptr _duplicate (SegmentSchedulingParameterPolicy_ptr obj); + + static SegmentSchedulingParameterPolicy_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static SegmentSchedulingParameterPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static SegmentSchedulingParameterPolicy_ptr _nil (void) + { + return (SegmentSchedulingParameterPolicy_ptr)0; + } + + static void _tao_any_destructor (void *); + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual RTCORBA::Priority value ( + + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void value ( + RTCORBA::Priority value + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:210 + + virtual void *_tao_QueryInterface (ptrdiff_t type); + + virtual const char* _interface_repository_id (void) const; + virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr); + + protected: + SegmentSchedulingParameterPolicy (void); + virtual ~SegmentSchedulingParameterPolicy (void); + + private: + SegmentSchedulingParameterPolicy (const SegmentSchedulingParameterPolicy &); + void operator= (const SegmentSchedulingParameterPolicy &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_SegmentSchedulingParameterPolicy; + + // TAO_IDL - Generated from + // be/be_interface.cpp:584 + +#if !defined (_FP_SCHEDULING_FP_SCHEDULER__ODDS_N_ENDS_CH_) +#define _FP_SCHEDULING_FP_SCHEDULER__ODDS_N_ENDS_CH_ + + class FP_Scheduler; + typedef FP_Scheduler *FP_Scheduler_ptr; + struct tao_FP_Scheduler_life; + + typedef + TAO_Objref_Var_T< + FP_Scheduler, + tao_FP_Scheduler_life + > + FP_Scheduler_var; + + typedef + TAO_Objref_Out_T< + FP_Scheduler, + tao_FP_Scheduler_life + > + FP_Scheduler_out; + + struct tao_FP_Scheduler_life + { + static FP_Scheduler_ptr tao_duplicate (FP_Scheduler_ptr); + static void tao_release (FP_Scheduler_ptr); + static FP_Scheduler_ptr tao_nil (void); + static CORBA::Boolean tao_marshal ( + FP_Scheduler_ptr, + TAO_OutputCDR & + ); + }; + + struct tao_FP_Scheduler_cast + { + static FP_Scheduler_ptr tao_narrow ( + CORBA::Object_ptr + ACE_ENV_ARG_DECL + ); + static CORBA::Object_ptr tao_upcast (void *); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:53 + +#if !defined (_FP_SCHEDULING_FP_SCHEDULER_CH_) +#define _FP_SCHEDULING_FP_SCHEDULER_CH_ + + class FP_Scheduler + : public virtual RTScheduling::Scheduler + { + public: + typedef FP_Scheduler_ptr _ptr_type; + typedef FP_Scheduler_var _var_type; + static int _tao_class_id; + + // The static operations. + static FP_Scheduler_ptr _duplicate (FP_Scheduler_ptr obj); + + static FP_Scheduler_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static FP_Scheduler_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static FP_Scheduler_ptr _nil (void) + { + return (FP_Scheduler_ptr)0; + } + + static void _tao_any_destructor (void *); + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual ::FP_Scheduling::SegmentSchedulingParameterPolicy_ptr create_segment_scheduling_parameter ( + RTCORBA::Priority segment_priority + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:210 + + virtual void *_tao_QueryInterface (ptrdiff_t type); + + virtual const char* _interface_repository_id (void) const; + virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr); + + protected: + FP_Scheduler (void); + virtual ~FP_Scheduler (void); + + private: + FP_Scheduler (const FP_Scheduler &); + void operator= (const FP_Scheduler &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_FP_Scheduler; + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:67 + +} +TAO_NAMESPACE_CLOSE // module FP_Scheduling + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, FP_Scheduling::SegmentSchedulingParameterPolicy_ptr); // copying + void operator<<= (CORBA::Any &, FP_Scheduling::SegmentSchedulingParameterPolicy_ptr *); // non-copying + CORBA::Boolean operator>>= (const CORBA::Any &, FP_Scheduling::SegmentSchedulingParameterPolicy_ptr &); + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, FP_Scheduling::FP_Scheduler_ptr); // copying + void operator<<= (CORBA::Any &, FP_Scheduling::FP_Scheduler_ptr *); // non-copying + CORBA::Boolean operator>>= (const CORBA::Any &, FP_Scheduling::FP_Scheduler_ptr &); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:48 + +#ifndef __ACE_INLINE__ + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:64 + +#endif /* __ACE_INLINE__ */ + +// TAO_IDL - Generated from +// be/be_codegen.cpp:1055 + +#if defined (__ACE_INLINE__) +#include "FP_SchedulingC.i" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option pop +#endif /* __BORLANDC__ */ + +#endif /* ifndef */ + diff --git a/TAO/examples/RTScheduling/FP_SchedulingC.i b/TAO/examples/RTScheduling/FP_SchedulingC.i new file mode 100644 index 00000000000..4772052c0f0 --- /dev/null +++ b/TAO/examples/RTScheduling/FP_SchedulingC.i @@ -0,0 +1,98 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_ci.cpp:63 + +#if !defined (_FP_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY___CI_) +#define _FP_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY___CI_ + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T<FP_Scheduling::SegmentSchedulingParameterPolicy>::to_object ( + CORBA::Object_ptr &_tao_elem + ) const +{ + _tao_elem = CORBA::Object::_duplicate (this->value_); + return 1; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T<FP_Scheduling::SegmentSchedulingParameterPolicy>::marshal_value (TAO_OutputCDR &) +{ + return 0; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T<FP_Scheduling::SegmentSchedulingParameterPolicy>::demarshal_value (TAO_InputCDR &) +{ + return 0; +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_ci.cpp:63 + +#if !defined (_FP_SCHEDULING_FP_SCHEDULER___CI_) +#define _FP_SCHEDULING_FP_SCHEDULER___CI_ + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T<FP_Scheduling::FP_Scheduler>::to_object ( + CORBA::Object_ptr &_tao_elem + ) const +{ + _tao_elem = CORBA::Object::_duplicate (this->value_); + return 1; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T<FP_Scheduling::FP_Scheduler>::marshal_value (TAO_OutputCDR &) +{ + return 0; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T<FP_Scheduling::FP_Scheduler>::demarshal_value (TAO_InputCDR &) +{ + return 0; +} + +#endif /* end #if !defined */ + diff --git a/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_DT_Creator.cpp b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_DT_Creator.cpp new file mode 100644 index 00000000000..440a9bb9b8b --- /dev/null +++ b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_DT_Creator.cpp @@ -0,0 +1,68 @@ +//$Id$ + +#include "FP_DT_Creator.h" +#include "test.h" +#include "FP_Task.h" + +FP_DT_Creator::FP_DT_Creator (void) +{ + DT_TEST::instance ()->dt_creator (this); + +} + +Thread_Task* +FP_DT_Creator::create_thr_task (int importance, + int start_time, + int load, + int iter, + int dist, + char *job_name) +{ + FP_Task* task; + ACE_NEW_RETURN (task, + FP_Task (importance, + start_time, + load, + iter, + dist, + job_name, + this), + 0); + return task; +} + +CORBA::Policy_ptr +FP_DT_Creator::sched_param (int importance) +{ + return DT_TEST::instance ()->scheduler ()->create_segment_scheduling_parameter (importance); +} + + +void +FP_DT_Creator::yield (int suspend_time, + Thread_Task*) +{ + ACE_OS::sleep (suspend_time); +} + +int +FP_DT_Creator::total_load (void) +{ + return BUFSIZ; +} + +void +FP_DT_Creator::wait (void) +{ +} + +ACE_STATIC_SVC_DEFINE(FP_DT_Creator, + ACE_TEXT ("FP_DT_Creator"), + ACE_SVC_OBJ_T, + &ACE_SVC_NAME (FP_DT_Creator), + ACE_Service_Type::DELETE_THIS | ACE_Service_Type::DELETE_OBJ, + 0) + +ACE_FACTORY_DEFINE (FP_DT_Creator, FP_DT_Creator) + + diff --git a/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_DT_Creator.h b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_DT_Creator.h new file mode 100644 index 00000000000..ad5d5e5e09b --- /dev/null +++ b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_DT_Creator.h @@ -0,0 +1,37 @@ +//$Id$ + +#ifndef FP_DT_CREATOR_H +#define FP_DT_CREATOR_H + +#include "../DT_Creator.h" +#include "fp_dt_creator_export.h" +#include "../Task.h" + +class FP_DT_Creator_Export FP_DT_Creator: public DT_Creator +{ +public: + FP_DT_Creator (void); + + virtual CORBA::Policy_ptr sched_param (int importance); + + //virtual Task* task (void); + virtual Thread_Task* create_thr_task (int importance, + int start_time, + int load, + int iter, + int dist, + char *job_name); + + virtual void yield (int suspend_time, + Thread_Task* task); + + virtual void wait (void); + virtual int total_load (void); + +}; + + +ACE_STATIC_SVC_DECLARE_EXPORT (FP_DT_Creator, FP_DT_Creator) +ACE_FACTORY_DECLARE (FP_DT_Creator, FP_DT_Creator) + +#endif /*FP_DT_CREATOR_H*/ diff --git a/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_Scheduler.cpp b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_Scheduler.cpp new file mode 100644 index 00000000000..6d2001efadb --- /dev/null +++ b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_Scheduler.cpp @@ -0,0 +1,302 @@ +//$Id$ + +#include "FP_Scheduler.h" +#include "ace/Atomic_Op.h" +#include "tao/RTScheduling/Request_Interceptor.h" +#include "test.h" + +ACE_Atomic_Op<TAO_SYNCH_MUTEX, long> server_guid_counter; + +RTCORBA::Priority +Segment_Sched_Param_Policy::value (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->value_; +} + +void +Segment_Sched_Param_Policy::value (RTCORBA::Priority value + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->value_ = value; +} + +Fixed_Priority_Scheduler::Fixed_Priority_Scheduler (CORBA::ORB_ptr orb) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var object = + orb->resolve_initial_references ("RTScheduler_Current" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + this->current_ = + RTScheduling::Current::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Caught exception:"); + } + ACE_ENDTRY; +} + +Fixed_Priority_Scheduler::~Fixed_Priority_Scheduler (void) +{ +} + +FP_Scheduling::SegmentSchedulingParameterPolicy_ptr +Fixed_Priority_Scheduler::create_segment_scheduling_parameter (RTCORBA::Priority segment_priority + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + FP_Scheduling::SegmentSchedulingParameterPolicy_ptr segment_policy; + ACE_NEW_THROW_EX (segment_policy, + Segment_Sched_Param_Policy, + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOMEM), + CORBA::COMPLETED_NO)); + + segment_policy->value (segment_priority); + + return segment_policy; + +} + + +void +Fixed_Priority_Scheduler::begin_new_scheduling_segment (const RTScheduling::Current::IdType &, + const char *, + CORBA::Policy_ptr /*sched_policy*/, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)) +{ +} + +void +Fixed_Priority_Scheduler::begin_nested_scheduling_segment (const RTScheduling::Current::IdType &guid, + const char *name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)) +{ + this->begin_new_scheduling_segment (guid, + name, + sched_param, + implicit_sched_param + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} + +void +Fixed_Priority_Scheduler::update_scheduling_segment (const RTScheduling::Current::IdType &guid, + const char *name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)) +{ + this->begin_new_scheduling_segment (guid, + name, + sched_param, + implicit_sched_param + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + +} + +void +Fixed_Priority_Scheduler::end_scheduling_segment (const RTScheduling::Current::IdType &, + const char * + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +void +Fixed_Priority_Scheduler::end_nested_scheduling_segment (const RTScheduling::Current::IdType &, + const char *, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + +} + + +void +Fixed_Priority_Scheduler::send_request (PortableInterceptor::ClientRequestInfo_ptr request_info + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ + + IOP::ServiceContext* srv_con = new IOP::ServiceContext; + srv_con->context_id = Client_Interceptor::SchedulingInfo; + srv_con->context_data.length (sizeof (long)); + ACE_OS::memcpy (srv_con->context_data.get_buffer (), + current_->id (ACE_ENV_SINGLE_ARG_PARAMETER)->get_buffer (), + sizeof (long)); + ACE_CHECK; + request_info->add_request_service_context (*srv_con, + 0 + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + +} + +void +Fixed_Priority_Scheduler::receive_request (PortableInterceptor::ServerRequestInfo_ptr request_info, + RTScheduling::Current::IdType_out guid_out, + CORBA::String_out /*name*/, + CORBA::Policy_out /*sched_param*/, + CORBA::Policy_out /*implicit_sched_param*/ + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ + IOP::ServiceContext* serv_cxt = + request_info->get_request_service_context (Server_Interceptor::SchedulingInfo + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + if (serv_cxt != 0) + { + int gu_id; + ACE_OS::memcpy (&gu_id, + serv_cxt->context_data.get_buffer (), + serv_cxt->context_data.length ()); + + char msg [BUFSIZ]; + ACE_OS::sprintf (msg,"The Guid is %d\n", gu_id); + DT_TEST::instance ()->dt_creator ()->log_msg (msg); + + RTScheduling::Current::IdType* guid; + ACE_NEW (guid, + RTScheduling::Current::IdType); + + + // Generate GUID. + guid->length (sizeof(long)); + + ACE_OS::memcpy (guid->get_buffer (), + &gu_id, + sizeof(long)); + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "Receive request The Guid is %d\n", + gu_id)); + + guid_out.ptr () = guid; + } + +} + +void +Fixed_Priority_Scheduler::send_reply (PortableInterceptor::ServerRequestInfo_ptr + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +void +Fixed_Priority_Scheduler::send_exception (PortableInterceptor::ServerRequestInfo_ptr + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +Fixed_Priority_Scheduler::send_other (PortableInterceptor::ServerRequestInfo_ptr + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +Fixed_Priority_Scheduler::receive_reply (PortableInterceptor::ClientRequestInfo_ptr + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +void +Fixed_Priority_Scheduler::receive_exception (PortableInterceptor::ClientRequestInfo_ptr + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +Fixed_Priority_Scheduler::receive_other (PortableInterceptor::ClientRequestInfo_ptr + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ +} + +void +Fixed_Priority_Scheduler::cancel (const RTScheduling::Current::IdType & + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +CORBA::PolicyList* +Fixed_Priority_Scheduler::scheduling_policies (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +void +Fixed_Priority_Scheduler::scheduling_policies (const CORBA::PolicyList & + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +CORBA::PolicyList* +Fixed_Priority_Scheduler::poa_policies (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +char * +Fixed_Priority_Scheduler::scheduling_discipline_name (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +RTScheduling::ResourceManager_ptr +Fixed_Priority_Scheduler::create_resource_manager (const char *, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +void +Fixed_Priority_Scheduler::set_scheduling_parameter (PortableServer::Servant &, + const char *, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} diff --git a/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_Scheduler.h b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_Scheduler.h new file mode 100644 index 00000000000..340a58968c4 --- /dev/null +++ b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_Scheduler.h @@ -0,0 +1,150 @@ +//$Id$ + +#ifndef FIXED_PRIORITY_SCHEDULER_H +#define FIXED_PRIORITY_SCHEDULER_H + +#include "tao/RTScheduling/RTScheduler.h" +#include "../FP_SchedulingC.h" + +class Segment_Sched_Param_Policy: +public FP_Scheduling::SegmentSchedulingParameterPolicy, + public TAO_Local_RefCounted_Object +{ + public: + virtual RTCORBA::Priority value (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void value (RTCORBA::Priority value + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + private: + RTCORBA::Priority value_; +}; + +class Fixed_Priority_Scheduler: +public FP_Scheduling::FP_Scheduler, +public TAO_Local_RefCounted_Object +{ + public: + + Fixed_Priority_Scheduler (CORBA::ORB_ptr orb); + + ~Fixed_Priority_Scheduler (void); + + virtual FP_Scheduling::SegmentSchedulingParameterPolicy_ptr + create_segment_scheduling_parameter (RTCORBA::Priority segment_priority + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void begin_new_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)); + + virtual void begin_nested_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)); + + virtual void update_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)); + + virtual void end_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void end_nested_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr outer_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void send_request (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void receive_request (PortableInterceptor::ServerRequestInfo_ptr ri, + RTScheduling::Current::IdType_out guid, + CORBA::String_out name, + CORBA::Policy_out sched_param, + CORBA::Policy_out implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void send_reply (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void send_exception (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void send_other (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void receive_exception (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void receive_other (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void cancel (const RTScheduling::Current::IdType & guid + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::PolicyList * scheduling_policies (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void scheduling_policies (const CORBA::PolicyList & scheduling_policies + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::PolicyList * poa_policies (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * scheduling_discipline_name (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual RTScheduling::ResourceManager_ptr create_resource_manager (const char * name, + CORBA::Policy_ptr scheduling_parameter + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void set_scheduling_parameter (PortableServer::Servant & resource, + const char * name, + CORBA::Policy_ptr scheduling_parameter + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + private: + RTScheduling::Current_var current_; + RTCORBA::PriorityMapping* pm_; + +}; + +#endif //FIXED_PRIORITY_SCHEDULER_H diff --git a/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_Task.cpp b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_Task.cpp new file mode 100644 index 00000000000..caa71cdc51e --- /dev/null +++ b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_Task.cpp @@ -0,0 +1,174 @@ +//$Id$ +#include "FP_Task.h" +#include "test.h" +#include "tao/RTCORBA/Priority_Mapping_Manager.h" +#include "tao/RTCORBA/Priority_Mapping.h" +#include "ace/High_Res_Timer.h" + + +FP_Task::FP_Task (int importance, + int start_time, + int load, + int iter, + int dist, + char *job_name, + DT_Creator *dt_creator) +{ + this->load_ = load; + this->iter_ = iter; + this->start_time_ = start_time; + this->importance_ = importance; + this->dt_creator_ = dt_creator; + this->dist_ = dist; + this->job_name_ = CORBA::string_dup (job_name); + +} + +int +FP_Task::activate_task (RTScheduling::Current_ptr current, + CORBA::Policy_ptr sched_param, + long flags, + ACE_Time_Value* base_time + ACE_ENV_ARG_DECL) +{ + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "Thread_Task::activate %d\n", + importance_)); + + char msg [BUFSIZ]; + ACE_OS::sprintf (msg, "Thread_Task::activate task\n"); + dt_creator_->log_msg (msg); + + base_time_ = base_time; + + current_ = RTScheduling::Current::_narrow (current + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + sched_param_ = CORBA::Policy::_duplicate (sched_param); + + pre_activate (); + + if (this->activate (flags, + 1, + 0, + this->importance_) == -1) + { + if (ACE_OS::last_error () == EPERM) + ACE_ERROR_RETURN ((LM_ERROR, + ACE_TEXT ("Insufficient privilege to run this test.\n")), + -1); + } + + return 0; +} + +void +FP_Task::pre_activate (void) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var object = DT_TEST::instance ()->orb ()->resolve_initial_references ("PriorityMappingManager" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + RTCORBA::PriorityMappingManager_var mapping_manager = + RTCORBA::PriorityMappingManager::_narrow (object.in () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + RTCORBA::PriorityMapping *pm = + mapping_manager->mapping (); + + CORBA::Short native_priority; + if (pm->to_native (this->importance_, native_priority) == 0) + ACE_ERROR ((LM_ERROR, + "Cannot convert native priority %d to corba priority\n", + native_priority)); + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "Native Priority = %d\n", + native_priority)); + char msg [BUFSIZ]; + ACE_OS::sprintf (msg, "Native Priority %d\n", + native_priority); + dt_creator_->log_msg (msg); + + this->importance_ = native_priority; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Caught exception:"); + } + ACE_ENDTRY; +} + +int +FP_Task::perform_task (void) +{ + static CORBA::ULong prime_number = 9619; + + for (int j = 0; j < this->iter_; j++) + { + ACE_Time_Value run_time = ACE_OS::gettimeofday () - *base_time_; + TASK_STATS::instance ()->sample (ACE_UINT64 (run_time.sec ()), + count_); + + 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 (); + } + } + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "%d\n", + count_)); + + if (this->dist_) + { + job_->work (this->load_, this->importance_); + + + for (int j = 0; j < this->iter_; j++) + { + ACE_Time_Value run_time = ACE_OS::gettimeofday () - *base_time_; + TASK_STATS::instance ()->sample (ACE_UINT64 (run_time.sec ()), + count_); + + ACE_Time_Value count_down_time (1); + ACE_Countdown_Time count_down (&count_down_time); + + while (count_down_time > ACE_Time_Value::zero) + { + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "Waiting on count down\n")); + + + ACE::is_prime (prime_number, + 2, + prime_number / 2); + count_down.update (); + } + } + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "%d\n", + count_)); + } + + if (dist_) + job_->shutdown (); + return 0; +} diff --git a/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_Task.h b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_Task.h new file mode 100644 index 00000000000..1a231b1eb9a --- /dev/null +++ b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/FP_Task.h @@ -0,0 +1,30 @@ +//$Id$ +#ifndef FP_TASK_H +#define FP_TASK_H + +#include "../Thread_Task.h" + +class FP_Task : public Thread_Task +{ +public: + FP_Task (int importance, + int start_time, + int load, + int iter, + int dist, + char *job_name, + DT_Creator *dt_creator); + + virtual int activate_task (RTScheduling::Current_ptr current, + CORBA::Policy_ptr sched_param, + long flags, + ACE_Time_Value* base_time + ACE_ENV_ARG_DECL_WITH_DEFAULTS); + + virtual int perform_task (void); + + virtual void pre_activate (void); + +}; + +#endif /*FP_TASK_H*/ diff --git a/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/Makefile b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/Makefile new file mode 100644 index 00000000000..b459f1cf2d7 --- /dev/null +++ b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/Makefile @@ -0,0 +1,834 @@ +#---------------------------------------------------------------------------- +# +# $Id$ +# +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +ifndef TAO_ROOT + TAO_ROOT = $(ACE_ROOT)/TAO +endif # ! TAO_ROOT + +LIBS = -lTAO_RTScheduler -lTAO_PortableServer -lTAO_CosNaming +BIN_UNCHECKED = test Starter + +IDL_FILES = ../FP_Scheduling \ + ../Synch \ + ../Job + +SRC = $(addsuffix .cpp, test ../Starter) + + +FP_TEST_OBJS = test.o FP_DT_Creator.o FP_Task.o FP_Scheduler.o ../FP_SchedulingC.o ../Thread_Task.o ../DT_Creator.o ../JobC.o ../JobS.o ../Job_i.o ../POA_Holder.o ../Task_Stats.o ../SynchC.o ../SynchS.o ../Synch_i.o + +STARTER_OBJS = ../Starter.o ../SynchS.o ../SynchC.o ../Synch_i.o + +BUILD = $(BIN) +VBIN = $(BIN:%=%$(VAR)) + +CPPFLAGS += -I$(TAO_ROOT)/orbsvcs -I$(TAO_ROOT)/tao/RTScheduling -I$(TAO_ROOT)/tao/RTCORBA + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(TAO_ROOT)/rules.tao.GNU + +ifeq ($(rt_corba),1) +BIN=$(BIN_UNCHECKED) +endif # rt_corba + +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU +include $(TAO_ROOT)/taoconfig.mk + +override TAO_IDLFLAGS += -o ../ \ + -I$(TAO_ROOT) + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +.PRECIOUS: $(foreach ext, $(IDL_EXT), ../FP_Scheduling$(ext) ../Job$(ext) ../Synch$(ext)) + +test: $(addprefix $(VDIR),$(FP_TEST_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(RT_TAO_CLNT_LIBS) $(POSTLINK) + +Starter: $(addprefix $(VDIR),$(STARTER_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(RT_TAO_CLNT_LIBS) $(POSTLINK) + +realclean: clean + -$(RM) $(foreach ext, $(IDL_EXT), Job$(ext)) + +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + + +.obj/test.o .obj/test.so .shobj/test.o .shobj/test.so: test.cpp test.h \ + $(ACE_ROOT)/ace/pre.h FP_Scheduler.h \ + $(TAO_ROOT)/tao/RTScheduling/RTScheduler.h \ + $(TAO_ROOT)/tao/RTScheduling/rtscheduler_export.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/os_include/os_limits.h \ + $(ACE_ROOT)/ace/os_include/os_unistd.h \ + $(ACE_ROOT)/ace/os_include/sys/os_types.h \ + $(ACE_ROOT)/ace/os_include/os_stddef.h \ + $(ACE_ROOT)/ace/os_include/os_inttypes.h \ + $(ACE_ROOT)/ace/os_include/os_stdint.h \ + $(ACE_ROOT)/ace/os_include/os_stdio.h \ + $(ACE_ROOT)/ace/os_include/os_stdarg.h \ + $(ACE_ROOT)/ace/os_include/os_float.h \ + $(ACE_ROOT)/ace/os_include/os_stdlib.h \ + $(ACE_ROOT)/ace/os_include/sys/os_wait.h \ + $(ACE_ROOT)/ace/os_include/os_signal.h \ + $(ACE_ROOT)/ace/os_include/os_time.h \ + $(ACE_ROOT)/ace/os_include/os_ucontext.h \ + $(ACE_ROOT)/ace/os_include/sys/os_resource.h \ + $(ACE_ROOT)/ace/os_include/sys/os_time.h \ + $(ACE_ROOT)/ace/os_include/sys/os_select.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/os_include/os_errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/os_include/os_dirent.h \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/os_include/os_string.h \ + $(ACE_ROOT)/ace/os_include/os_strings.h \ + $(ACE_ROOT)/ace/os_include/os_ctype.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/os_include/os_dlfcn.h \ + $(ACE_ROOT)/ace/os_include/sys/os_mman.h \ + $(ACE_ROOT)/ace/os_include/os_netdb.h \ + $(ACE_ROOT)/ace/os_include/netinet/os_in.h \ + $(ACE_ROOT)/ace/os_include/sys/os_socket.h \ + $(ACE_ROOT)/ace/os_include/sys/os_uio.h \ + $(ACE_ROOT)/ace/os_include/net/os_if.h \ + $(ACE_ROOT)/ace/os_include/sys/os_sem.h \ + $(ACE_ROOT)/ace/os_include/sys/os_ipc.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/os_include/os_pthread.h \ + $(ACE_ROOT)/ace/os_include/os_assert.h \ + $(ACE_ROOT)/ace/os_include/os_fcntl.h \ + $(ACE_ROOT)/ace/os_include/sys/os_stat.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/os_include/arpa/os_inet.h \ + $(ACE_ROOT)/ace/os_include/netinet/os_tcp.h \ + $(ACE_ROOT)/ace/os_include/sys/os_shm.h \ + $(ACE_ROOT)/ace/os_include/os_pwd.h \ + $(ACE_ROOT)/ace/os_include/os_stropts.h \ + $(ACE_ROOT)/ace/os_include/os_termios.h \ + $(ACE_ROOT)/ace/os_include/os_aio.h \ + $(ACE_ROOT)/ace/os_include/sys/os_un.h \ + $(ACE_ROOT)/ace/os_include/os_poll.h \ + $(ACE_ROOT)/ace/os_include/sys/os_msg.h \ + $(ACE_ROOT)/ace/os_include/sys/os_utsname.h \ + $(ACE_ROOT)/ace/os_include/os_syslog.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SStringfwd.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(ACE_ROOT)/ace/iosfwd.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Pseudo_VarOut_T.h \ + $(TAO_ROOT)/tao/Pseudo_VarOut_T.inl \ + $(TAO_ROOT)/tao/Pseudo_VarOut_T.cpp \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any_Impl_T.h \ + $(TAO_ROOT)/tao/Any.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Objref_VarOut_T.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/Objref_VarOut_T.inl \ + $(TAO_ROOT)/tao/Objref_VarOut_T.cpp \ + $(TAO_ROOT)/tao/Seq_Var_T.h \ + $(TAO_ROOT)/tao/Seq_Var_T.inl \ + $(TAO_ROOT)/tao/Seq_Var_T.cpp \ + $(TAO_ROOT)/tao/Seq_Out_T.h \ + $(TAO_ROOT)/tao/Seq_Out_T.inl \ + $(TAO_ROOT)/tao/Seq_Out_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/IOP_IORC.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/VarOut_T.h \ + $(TAO_ROOT)/tao/VarOut_T.inl \ + $(TAO_ROOT)/tao/VarOut_T.cpp \ + $(TAO_ROOT)/tao/IOP_IORC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/Any_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Impl_T.cpp \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Any_Basic_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Basic_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Basic_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Special_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Special_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Special_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Special_Basic_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Special_Basic_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Special_Basic_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Array_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Array_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Array_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Dual_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Dual_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Dual_Impl_T.cpp \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/ServicesC.h \ + $(TAO_ROOT)/tao/ServicesC.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/ObjectIdListC.h \ + $(TAO_ROOT)/tao/ObjectIdListC.i \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Array_VarOut_T.h \ + $(TAO_ROOT)/tao/Array_VarOut_T.inl \ + $(TAO_ROOT)/tao/Array_VarOut_T.cpp \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/PI_ForwardC.h \ + $(TAO_ROOT)/tao/PI_ForwardC.i \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOP_CodecC.h \ + $(TAO_ROOT)/tao/IOP_CodecC.i \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBA.h \ + $(TAO_ROOT)/tao/RTCORBA/rtcorba_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.i \ + ../FP_SchedulingC.h ../FP_SchedulingC.i \ + $(ACE_ROOT)/ace/Sched_Params.h \ + $(ACE_ROOT)/ace/Sched_Params.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Set.h \ + $(TAO_ROOT)/tao/Policy_Set.i \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/DLL.h \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.i \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/ObjectKey_Table.h \ + $(ACE_ROOT)/ace/RB_Tree.h \ + $(ACE_ROOT)/ace/RB_Tree.i \ + $(ACE_ROOT)/ace/RB_Tree.cpp \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/PICurrent.h \ + $(TAO_ROOT)/tao/PICurrent.inl \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Exit.h \ + $(ACE_ROOT)/ace/Thread_Control.h \ + $(ACE_ROOT)/ace/Thread_Control.inl \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Framework_Component.h \ + $(ACE_ROOT)/ace/Framework_Component.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.h \ + $(ACE_ROOT)/ace/Framework_Component_T.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Notification_Strategy.h \ + $(ACE_ROOT)/ace/Notification_Strategy.inl \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + FP_DT_Creator.h ../DT_Creator.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/naming_export.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.i \ + $(ACE_ROOT)/ace/Arg_Shifter.h \ + ../POA_Holder.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + ../Job_i.h ../JobS.h ../JobC.h ../JobC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(ACE_ROOT)/ace/Atomic_Op.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.i \ + $(ACE_ROOT)/ace/Atomic_Op_T.cpp \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + ../JobS_T.h ../JobS_T.i ../JobS_T.cpp ../JobS.i ../Task_Stats.h \ + ../Task_Stats.inl ../Synch_i.h ../SynchS.h ../SynchC.h ../SynchC.i \ + ../SynchS_T.h ../SynchS_T.i ../SynchS_T.cpp ../SynchS.i \ + fp_dt_creator_export.h ../Task.h \ + $(TAO_ROOT)/tao/RTScheduling/RTScheduler_Manager.h \ + $(TAO_ROOT)/tao/RTScheduling/RTScheduler_Manager.i \ + ../Thread_Task.h + +.obj/Starter.o .obj/Starter.so .shobj/Starter.o .shobj/Starter.so: ../Starter.cpp ../Starter.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Naming_Utils.h \ + $(ACE_ROOT)/ace/pre.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/os_include/os_limits.h \ + $(ACE_ROOT)/ace/os_include/os_unistd.h \ + $(ACE_ROOT)/ace/os_include/sys/os_types.h \ + $(ACE_ROOT)/ace/os_include/os_stddef.h \ + $(ACE_ROOT)/ace/os_include/os_inttypes.h \ + $(ACE_ROOT)/ace/os_include/os_stdint.h \ + $(ACE_ROOT)/ace/os_include/os_stdio.h \ + $(ACE_ROOT)/ace/os_include/os_stdarg.h \ + $(ACE_ROOT)/ace/os_include/os_float.h \ + $(ACE_ROOT)/ace/os_include/os_stdlib.h \ + $(ACE_ROOT)/ace/os_include/sys/os_wait.h \ + $(ACE_ROOT)/ace/os_include/os_signal.h \ + $(ACE_ROOT)/ace/os_include/os_time.h \ + $(ACE_ROOT)/ace/os_include/os_ucontext.h \ + $(ACE_ROOT)/ace/os_include/sys/os_resource.h \ + $(ACE_ROOT)/ace/os_include/sys/os_time.h \ + $(ACE_ROOT)/ace/os_include/sys/os_select.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/os_include/os_errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/os_include/os_dirent.h \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/os_include/os_string.h \ + $(ACE_ROOT)/ace/os_include/os_strings.h \ + $(ACE_ROOT)/ace/os_include/os_ctype.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/os_include/os_dlfcn.h \ + $(ACE_ROOT)/ace/os_include/sys/os_mman.h \ + $(ACE_ROOT)/ace/os_include/os_netdb.h \ + $(ACE_ROOT)/ace/os_include/netinet/os_in.h \ + $(ACE_ROOT)/ace/os_include/sys/os_socket.h \ + $(ACE_ROOT)/ace/os_include/sys/os_uio.h \ + $(ACE_ROOT)/ace/os_include/net/os_if.h \ + $(ACE_ROOT)/ace/os_include/sys/os_sem.h \ + $(ACE_ROOT)/ace/os_include/sys/os_ipc.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/os_include/os_pthread.h \ + $(ACE_ROOT)/ace/os_include/os_assert.h \ + $(ACE_ROOT)/ace/os_include/os_fcntl.h \ + $(ACE_ROOT)/ace/os_include/sys/os_stat.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/os_include/arpa/os_inet.h \ + $(ACE_ROOT)/ace/os_include/netinet/os_tcp.h \ + $(ACE_ROOT)/ace/os_include/sys/os_shm.h \ + $(ACE_ROOT)/ace/os_include/os_pwd.h \ + $(ACE_ROOT)/ace/os_include/os_stropts.h \ + $(ACE_ROOT)/ace/os_include/os_termios.h \ + $(ACE_ROOT)/ace/os_include/os_aio.h \ + $(ACE_ROOT)/ace/os_include/sys/os_un.h \ + $(ACE_ROOT)/ace/os_include/os_poll.h \ + $(ACE_ROOT)/ace/os_include/sys/os_msg.h \ + $(ACE_ROOT)/ace/os_include/sys/os_utsname.h \ + $(ACE_ROOT)/ace/os_include/os_syslog.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SStringfwd.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(ACE_ROOT)/ace/iosfwd.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Pseudo_VarOut_T.h \ + $(TAO_ROOT)/tao/Pseudo_VarOut_T.inl \ + $(TAO_ROOT)/tao/Pseudo_VarOut_T.cpp \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any_Impl_T.h \ + $(TAO_ROOT)/tao/Any.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Objref_VarOut_T.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/Objref_VarOut_T.inl \ + $(TAO_ROOT)/tao/Objref_VarOut_T.cpp \ + $(TAO_ROOT)/tao/Seq_Var_T.h \ + $(TAO_ROOT)/tao/Seq_Var_T.inl \ + $(TAO_ROOT)/tao/Seq_Var_T.cpp \ + $(TAO_ROOT)/tao/Seq_Out_T.h \ + $(TAO_ROOT)/tao/Seq_Out_T.inl \ + $(TAO_ROOT)/tao/Seq_Out_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/IOP_IORC.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/VarOut_T.h \ + $(TAO_ROOT)/tao/VarOut_T.inl \ + $(TAO_ROOT)/tao/VarOut_T.cpp \ + $(TAO_ROOT)/tao/IOP_IORC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/Any_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Impl_T.cpp \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Any_Basic_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Basic_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Basic_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Special_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Special_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Special_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Special_Basic_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Special_Basic_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Special_Basic_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Array_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Array_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Array_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Dual_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Dual_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Dual_Impl_T.cpp \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/ServicesC.h \ + $(TAO_ROOT)/tao/ServicesC.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/ObjectIdListC.h \ + $(TAO_ROOT)/tao/ObjectIdListC.i \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Array_VarOut_T.h \ + $(TAO_ROOT)/tao/Array_VarOut_T.inl \ + $(TAO_ROOT)/tao/Array_VarOut_T.cpp \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/PI_ForwardC.h \ + $(TAO_ROOT)/tao/PI_ForwardC.i \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOP_CodecC.h \ + $(TAO_ROOT)/tao/IOP_CodecC.i \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/naming_export.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/IOR_Multicast.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/svc_utils_export.h \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_Dgram.i \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Naming_Context_Interface.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(ACE_ROOT)/ace/Atomic_Op.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.i \ + $(ACE_ROOT)/ace/Atomic_Op_T.cpp \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.cpp \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/nsconf.h \ + ../SynchC.h ../SynchC.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/README b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/README new file mode 100644 index 00000000000..41ea051f14d --- /dev/null +++ b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/README @@ -0,0 +1,155 @@ +Fixed Priority Scheduler +======================== + +Table of contents +----------------- +1. Introduction +2. Conf file parameters +3. Running the example. + +1. Introduction +--------------- + +This scheduler uses the OS scheduler to schedule the Distributable +Threads (DTs) in the system. The DTs are scheduled according to their +importance. The scheduler maps the importance of the DT to native +thread priorities so the OS scheduler can schedule the DTs. + +In this experiment we show how dynamic scheduling is done using the +Dynamic Scheduling framework with the Fixed Priority Scheduler as the +pluggable scheduler. At any given instance the DT of highest priority +is running on a given host. + +The experiment consists of the following participants: +Job: A CORBA servant object that performs CPU intensive work. The +amount of work depends on a load factor that is conveyed to the object +per invocation as an argument. + +DT_Task: The distributable thread is a scheduling segment spanning one +or more hosts. + +test: The test consists of a collection of Jobs and DTs hosted in +a single process. The test reads a configuration file that can be used +to initialize DTs and Jobs. + +Starter: The starter initiates the start of DTs on each host that the +test is running on. This is to ensure that the experiment starts at +the same time on all hosts. + +2. Conf file parameters +----------------------- + +POA OPTIONS +========== +To specify POA options the format is: + +-POACount <count> -POA <name> -PriorityModel <CLIENT|SERVER> <priority> -Lanes <count> (-Lane <priority> ,<static_threads> <dynamic_threads>)* -Bands <count> (-Band <low> <high>)* + +e.g. +-POACount 2 -POA poa1 -PriorityModel CLIENT 10 -Bands 2 -Band 1 20 -Band 30 85 -Lanes 2 -Lane 10 1 0 -Lane 80 1 0 + +specifes a POA with: + +POA Count - Specifies the number of POAs that need to be activated. The following characteristics of each POA needs to be specified. + +Name - poa1 + +Priority model - client propogated, def. priority = 10 + +Bands - 2 Bands with Band values as follows - + Band 1 : low priority = 1, high priority = 20 + Band 2 : low priority = 30, high priority = 85 + +Lanes - 2 Lanes with Lane values as follows - + Lane 1 : priority = 10, 1 static thread, 0 dynamic threads + Lane 2 : priority = 80, 1 static thread, 0 dynamic threads + + +Distributable Thread Task Options +================================= + +The format to specify a DT Task is: + +-DT_Count <count> -DT_Task Importance <imp> -Start_Time <time> -Iter <local_work> -Load <remote_work> -JobName <name> + +where, +-DT_Count = Total number of DT_Tasks +-DT_Task = Specifies a Distributable Thread +-Importance = The priority of the DT +-Start_Time = Time at which the DT enters the system +-Iter = The number of secs of work to be done on the local host. For a +distributed DT it defines the number of secs of local work to be done +before and after a remote method call is made. +-Load = The number of secs of work to be done on the remote host when +a two-way method call is made by a distributed DT +-JobName <name> = Name of the Job object that this DT will make a +remote method call on to do some 'Load' number of secs of work on the +remote host + +e.g. +-DT_Count 1 -DT_Task -Importance 5 -Start_Time 0 -Iter 3 -Load 5 -JobName job_1 + +specifes a DT Task in which, +Importance = 5 +Start Time = 0 +Iter = 3 +Load = 5 +JobName = job_1 + +Job Options +=========== +The format for specify a Job is: +-Job_Count <count> -Job <name> <poa_name> + +where, poa_name is the POA that this object is activated in. + +Job Count - Specifies the number of jobs that are activated. + +e.g. +-Job job_10 poa1 + +specifies a Job with, + +Name - job_10 +POA Name - poa1 + +Misc +===== + +-GuidSeed <guid> + +This specifies the guid number with which the guid counter will get +initialized. This is to ensure that unique guids are used. This will +be removed when the ACE UUID generator is integrated with TAO. + +-OutFile <filename> + +This specifies the data file in which the schedule of the DT"s running +on the host will be output. + +-LogFile <filenmae> + +This speficies the log file + +3. Running the example +---------------------- + +a) The activated Jobs and Synch objects are registered with a Naming +service, so we need an NS running + +e.g. ./Naming_Service -o naming_ior + +b) Start one or more instances of ./test depending on the test +configuration that you have designed. + +e.g. ./test -ORBInitRef NameService=file://naming_ior -ORBSvcConf svc.conf.whatever -ORBDebugLevel 1 + +c) Execute the Starter that initiates the creation of DTs on all the +hosts that the experiment is running + +eg. ./Starter -ORBInitRef NameService=file://naming.ior + +c) Once all the instances exit, the test will generate schedule files +as specified by the user with the -OutFile option file + + diff --git a/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/fp_dt_creator_export.h b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/fp_dt_creator_export.h new file mode 100644 index 00000000000..fb76d92387c --- /dev/null +++ b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/fp_dt_creator_export.h @@ -0,0 +1,50 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl FP_DT_Creator +// ------------------------------ +#ifndef FP_DT_CREATOR_EXPORT_H +#define FP_DT_CREATOR_EXPORT_H + +#include "ace/config-all.h" + +#if !defined (FP_DT_CREATOR_HAS_DLL) +# define FP_DT_CREATOR_HAS_DLL 1 +#endif /* ! FP_DT_CREATOR_HAS_DLL */ + +#if defined (FP_DT_CREATOR_HAS_DLL) && (FP_DT_CREATOR_HAS_DLL == 1) +# if defined (FP_DT_CREATOR_BUILD_DLL) +# define FP_DT_Creator_Export ACE_Proper_Export_Flag +# define FP_DT_CREATOR_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define FP_DT_CREATOR_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* FP_DT_CREATOR_BUILD_DLL */ +# define FP_DT_Creator_Export ACE_Proper_Import_Flag +# define FP_DT_CREATOR_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define FP_DT_CREATOR_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* FP_DT_CREATOR_BUILD_DLL */ +#else /* FP_DT_CREATOR_HAS_DLL == 1 */ +# define FP_DT_Creator_Export +# define FP_DT_CREATOR_SINGLETON_DECLARATION(T) +# define FP_DT_CREATOR_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* FP_DT_CREATOR_HAS_DLL == 1 */ + +// Set FP_DT_CREATOR_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (FP_DT_CREATOR_NTRACE) +# if (ACE_NTRACE == 1) +# define FP_DT_CREATOR_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define FP_DT_CREATOR_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !FP_DT_CREATOR_NTRACE */ + +#if (FP_DT_CREATOR_NTRACE == 1) +# define FP_DT_CREATOR_TRACE(X) +#else /* (FP_DT_CREATOR_NTRACE == 1) */ +# define FP_DT_CREATOR_TRACE(X) ACE_TRACE_IMPL(X) +#endif /* (FP_DT_CREATOR_NTRACE == 1) */ + +#endif /* FP_DT_CREATOR_EXPORT_H */ + +// End of auto generated file. diff --git a/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/svc.conf.client b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/svc.conf.client new file mode 100644 index 00000000000..f16ccd6fcd0 --- /dev/null +++ b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/svc.conf.client @@ -0,0 +1,10 @@ +# -- E X A M P L E conf. file -- + +# Note! priority values are for Linux + +static RT_ORB_Loader "-ORBSchedPolicy SCHED_FIFO -ORBScopePolicy PROCESS -ORBPriorityMapping direct" + +static FP_DT_Creator "-GuidSeed 0 -DT_Count 4 -DT_Task -Importance 5 -Start_Time 0 -Iter 3 -Load 5 -JobName job_1 -DT_Task -Importance 8 -Start_Time 0 -Iter 5 -Load 5 -DT_Task -Importance 10 -Start_Time 0 -Iter 3 -Load 5 -DT_Task -Importance 4 -Start_Time 2 -Iter 5 -Load 5 -JobName job_2 -OutFile schedule_client.dat -LogFile log_client" + + + diff --git a/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/svc.conf.server b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/svc.conf.server new file mode 100644 index 00000000000..baee8854a83 --- /dev/null +++ b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/svc.conf.server @@ -0,0 +1,7 @@ +# -- E X A M P L E conf. file -- + +# Note! priority values are for Linux + +static RT_ORB_Loader "-ORBSchedPolicy SCHED_RR -ORBScopePolicy PROCESS -ORBPriorityMapping direct" + +static FP_DT_Creator "-GuidSeed 9 -POA_Count 1 -POA poa1 -PriorityModel CLIENT 55 -Band 1 4 -Band 5 85 -Lanes 2 -Lane 5 1 0 -Lane 4 1 0 -Job_Count 2 -Job job_1 poa1 -Job job_2 poa1 -DT_Count 2 -DT_Task -Importance 15 -Start_Time 0 -Iter 10 -Load 0 -DT_Task -Importance 2 -Start_Time 5 -Iter 15 -Load 0 -OutFile schedule_server.dat -LogFile log_server" diff --git a/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/test.cpp b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/test.cpp new file mode 100644 index 00000000000..d68f937cd5b --- /dev/null +++ b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/test.cpp @@ -0,0 +1,294 @@ +//$Id$ + +#include "test.h" +#include "tao/RTScheduling/RTScheduler_Manager.h" +#include "tao/ORB_Core.h" +#include "ace/Arg_Shifter.h" +//#include "FP_DT_Creator.h" +#include "../Thread_Task.h" +#include "../Task_Stats.h" +#include "../Synch_i.h" + +DT_Test::DT_Test (void) +{ + base_t = ACE_OS::gethrtime (); +} + +void +DT_Test::check_supported_priorities (void) +{ + // Check that we have sufficient priority range to run this + // test, i.e., more than 1 priority level. + + this->thr_sched_policy_ = orb_->orb_core ()->orb_params ()->sched_policy (); + this->thr_scope_policy_ = orb_->orb_core ()->orb_params ()->scope_policy (); + + if (thr_sched_policy_ == THR_SCHED_RR) + { + //if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "Sched policy = THR_SCHED_RR\n")); + + sched_policy_ = ACE_SCHED_RR; + } + else + if (thr_sched_policy_ == THR_SCHED_FIFO) + { + // if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "Sched policy = THR_SCHED_FIFO\n")); + + sched_policy_ = ACE_SCHED_FIFO; + } + else + { + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "Sched policy = THR_SCHED_OTHER\n")); + + sched_policy_ = ACE_SCHED_OTHER; + } + + if (thr_sched_policy_ == THR_SCHED_RR || thr_sched_policy_ == THR_SCHED_FIFO) + { + max_priority_ = ACE_Sched_Params::priority_max (sched_policy_); + min_priority_ = ACE_Sched_Params::priority_min (sched_policy_); + + if (max_priority_ == min_priority_) + { + ACE_DEBUG ((LM_DEBUG, + "Not enough priority levels on this platform" + " to run the test, aborting \n")); + ACE_OS::exit (2); + } + else ACE_DEBUG ((LM_DEBUG, "max_priority = %d, min_priority = %d\n", + max_priority_, min_priority_)); + } +} + +int +DT_Test::init (int argc, char *argv [] + ACE_ENV_ARG_DECL) +{ + orb_ = CORBA::ORB_init (argc, + argv, + "" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + this->check_supported_priorities (); + + dt_creator_->orb (orb_.in ()); + + TASK_STATS::instance ()->init (dt_creator_->total_load ()); + + CORBA::Object_ptr manager_obj = orb_->resolve_initial_references ("RTSchedulerManager" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + TAO_RTScheduler_Manager_var manager = TAO_RTScheduler_Manager::_narrow (manager_obj + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + + ACE_NEW_RETURN (scheduler_, + Fixed_Priority_Scheduler (orb_.in ()), + -1); + + manager->rtscheduler (scheduler_); + + CORBA::Object_var object = + orb_->resolve_initial_references ("RTScheduler_Current" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + current_ = + RTScheduling::Current::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + + if (sched_policy_ != ACE_SCHED_OTHER) + { + + //Set the main thread to max priority... + if (ACE_OS::sched_params (ACE_Sched_Params (sched_policy_, + 55, + ACE_SCOPE_PROCESS)) != 0) + { + if (ACE_OS::last_error () == EPERM) + { + ACE_DEBUG ((LM_DEBUG, + "(%P|%t): user is not superuser, " + "test runs in time-shared class\n")); + } + else + ACE_ERROR ((LM_ERROR, + "(%P|%t): sched_params failed\n")); + } + } + + return 0; +} + +void +DT_Test::run (int argc, char* argv [] + ACE_ENV_ARG_DECL) +{ + init (argc,argv + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + if (this->dt_creator_->resolve_naming_service (ACE_ENV_SINGLE_ARG_PARAMETER) == -1) + return; + ACE_CHECK; + + + //TASK_STATS::instance ()->init (this->dt_creator_->dt_count () * 100); + + + this->dt_creator_->activate_root_poa (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + this->dt_creator_->activate_poa_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + this->dt_creator_->activate_job_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + this->dt_creator_->activate_schedule (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + DT_Creator* dt_creator = this->dt_creator_; + dt_creator->register_synch_obj (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "Registered Synch Object\n")); + + /* + dt_creator_->create_distributable_threads (current_.in () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + */ + + this->activate_task (); + + char msg [BUFSIZ]; + ACE_OS::sprintf (msg, "ORB RUN\n"); + dt_creator_->log_msg (msg); + + //ACE_Thread_Manager::instance ()->wait (); + orb_->run (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + +} + + +void +DT_Test::dt_creator (FP_DT_Creator* dt_creator) +{ + this->dt_creator_ = dt_creator; +} + +FP_DT_Creator* +DT_Test::dt_creator (void) +{ + return this->dt_creator_; +} + + +Fixed_Priority_Scheduler* +DT_Test::scheduler (void) +{ + return this->scheduler_; +} + +int +DT_Test::activate_task (void) +{ + + ACE_DEBUG ((LM_DEBUG, + "Test Activate Task\n")); + + long flags; + flags = THR_NEW_LWP | THR_JOINABLE; + flags |= + orb_->orb_core ()->orb_params ()->scope_policy () | + orb_->orb_core ()->orb_params ()->sched_policy (); + + if (this->activate (flags, + 1, + 0, + 50) == -1) + { + if (ACE_OS::last_error () == EPERM) + ACE_ERROR_RETURN ((LM_ERROR, + ACE_TEXT ("Insufficient privilege to run this test.\n")), + -1); + + } + return 0; +} + +int +DT_Test::svc (void) +{ + ACE_TRY_NEW_ENV + { + ACE_DEBUG ((LM_DEBUG, + "In test::svc\n")); + + dt_creator_->create_distributable_threads (current_.in () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Caught exception:"); + return -1; + } + ACE_ENDTRY; + + return 0; +} + + +CORBA::ORB_ptr +DT_Test::orb (void) +{ + return this->orb_.in (); +} + +int +main (int argc, char* argv []) +{ + ACE_TRY_NEW_ENV + { + ACE_Service_Config::static_svcs ()->insert (&ace_svc_desc_FP_DT_Creator); + + DT_TEST::instance ()->run (argc, argv + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Caught exception:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} + + + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + +template class ACE_Singleton<DT_Test, TAO_SYNCH_MUTEX>; + +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + +#pragma instantiate ACE_Singleton<DT_Test, TAO_SYNCH_MUTEX> + +#endif /*ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/test.h b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/test.h new file mode 100644 index 00000000000..f06674c6ee2 --- /dev/null +++ b/TAO/examples/RTScheduling/Fixed_Priority_Scheduler/test.h @@ -0,0 +1,69 @@ +//$Id$ +#ifndef TEST_H +#define TEST_H +#include "ace/pre.h" + + +#include "FP_Scheduler.h" +#include "ace/Sched_Params.h" +#include "tao/ORB_Core.h" +#include "ace/Synch.h" +#include "ace/Task.h" +#include "FP_DT_Creator.h" + +class Task_Stats; + +class DT_Test :public ACE_Task <ACE_SYNCH> +{ + public: + + DT_Test (void); + + void check_supported_priorities (void); + + int init (int argc, char *argv [] + ACE_ENV_ARG_DECL_WITH_DEFAULTS); + + void run (int argc, char *argv [] + ACE_ENV_ARG_DECL_WITH_DEFAULTS); + + void dt_creator (FP_DT_Creator* dt_creator); + FP_DT_Creator* dt_creator (void); + + Fixed_Priority_Scheduler* scheduler (void); + + int activate_task (void); + + CORBA::ORB_ptr orb (void); + + ACE_hrtime_t base_t; + + void register_synch_obj (ACE_ENV_SINGLE_ARG_DECL); + + protected: + /// task svc + virtual int svc (void); + + + + private: + /// = Policies + long thr_sched_policy_; + long thr_scope_policy_; + ACE_Sched_Params::Policy sched_policy_; + CORBA::ORB_var orb_; + int max_priority_; + int min_priority_; + RTScheduling::Current_var current_; + FP_DT_Creator* dt_creator_; + Fixed_Priority_Scheduler* scheduler_; + RTCORBA::RTORB_var rt_orb_; + /// Reference to the root poa. + PortableServer::POA_var root_poa_; + +}; + +typedef ACE_Singleton <DT_Test, TAO_SYNCH_MUTEX> DT_TEST; + +#include "ace/post.h" +#endif /*TEST_H*/ diff --git a/TAO/examples/RTScheduling/Job.idl b/TAO/examples/RTScheduling/Job.idl new file mode 100644 index 00000000000..f1ba4b5cff2 --- /dev/null +++ b/TAO/examples/RTScheduling/Job.idl @@ -0,0 +1,11 @@ +// +// $Id$ +// + +interface Job +{ + void work (in unsigned long work, + in short importance); + + void shutdown (); +}; diff --git a/TAO/examples/RTScheduling/Job_i.cpp b/TAO/examples/RTScheduling/Job_i.cpp new file mode 100644 index 00000000000..d8d5b05fac4 --- /dev/null +++ b/TAO/examples/RTScheduling/Job_i.cpp @@ -0,0 +1,149 @@ +//$Id$ +#include "Job_i.h" + +#include "tao/debug.h" +#include "ace/Arg_Shifter.h" +#include "DT_Creator.h" +#include "Task_Stats.h" +#include "ace/High_Res_Timer.h" + +Job_i::Job_i (DT_Creator* dt_creator) + : dt_creator_ (dt_creator), + guid_ (0) +{ + // create the stat object. + ACE_NEW (task_stats_, Task_Stats); + task_stats_->init (100); + +} + +Job_i::~Job_i (void) +{ + delete task_stats_; +} + +const ACE_CString& +Job_i::name (void) +{ + return job_name_; +} + +const ACE_CString& +Job_i::poa (void) +{ + return POA_name_; +} + +int +Job_i::init (ACE_Arg_Shifter& arg_shifter) +{ + job_name_ = arg_shifter.get_current (); // Read the name of the Job + arg_shifter.consume_arg (); + + POA_name_ = arg_shifter.get_current (); // Read the name of the POA + arg_shifter.consume_arg (); + + return 0; +} + +void +Job_i::work (CORBA::ULong work, + CORBA::Short importance + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + static CORBA::ULong prime_number = 9619; + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "test_i::method: %d units of work\n", + work)); + + if (guid_ == 0) + ACE_OS::memcpy (&guid_, + dt_creator_->current ()->id (ACE_ENV_SINGLE_ARG_PARAMETER)->get_buffer (), + sizeof (dt_creator_->current ()->id (ACE_ENV_SINGLE_ARG_PARAMETER)->length ())); + + + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "%t Guid is %d, Importance is %d\n", + guid_, + importance)); + + char msg [BUFSIZ]; + ACE_OS::sprintf (msg,"Guid is %d\n", guid_); + dt_creator_->log_msg (msg); + + for (; work != 0; work--) + { + // ACE_hrtime_t now = ACE_OS::gethrtime (); + + ACE_Time_Value run_time = ACE_OS::gettimeofday () - *(dt_creator_->base_time ()); + TASK_STATS::instance ()->sample (ACE_UINT64 (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 (ACE_UINT64 (run_time.sec ()), + guid_); + + CORBA::Policy_var sched_param; + sched_param = CORBA::Policy::_duplicate (dt_creator_->sched_param (importance)); + const char * name = 0; + dt_creator_->current ()->update_scheduling_segment (name, + sched_param.in (), + sched_param.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } +} + +void +Job_i::post_work (int /*guid*/, + int /*importance*/) +{ +} + +int +Job_i::guid (void) +{ + return this->guid_; +} + +void +Job_i::shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + dt_creator_->job_ended (); +} + +void +Job_i::dump_stats (void) +{ + char fname [BUFSIZ]; + ACE_OS::sprintf (fname, "Job_%d.dat",guid_); + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "File name %s\n", + fname)); + + + char msg [BUFSIZ]; + ACE_OS::sprintf (msg, "#Schedule Output for DT %d", guid_); + + task_stats_->dump_samples (fname, + msg, + ACE_High_Res_Timer::global_scale_factor ()); +} diff --git a/TAO/examples/RTScheduling/Job_i.h b/TAO/examples/RTScheduling/Job_i.h new file mode 100644 index 00000000000..5964a55ce8b --- /dev/null +++ b/TAO/examples/RTScheduling/Job_i.h @@ -0,0 +1,77 @@ +/* -*- C++ -*- */ +//============================================================================= +/** + * @file Job_i.h + * + * $Id$ + * + * This file defines the servant for the Job.idl interface + * + * @author Pradeep Gore <pradeep@cs.wustl.edu> + */ +//============================================================================= +#ifndef JOB_I_H +#define JOB_I_H + +#include "JobS.h" +#include "Task_Stats.h" + +class ACE_Arg_Shifter; +class DT_Creator; + +/** + * @class Job_i + * + * @brief Implements a Job that performs some cpu bound work. + * + */ +class Job_i : public POA_Job, public virtual PortableServer::RefCountServantBase +{ + public: + /// Constructor + Job_i (DT_Creator* dt_creator); + + ~Job_i (void); + + /// Init the state of this object. + int init (ACE_Arg_Shifter& arg_shifter); + + /// = Accessors + const ACE_CString& name (void); + const ACE_CString& poa (void); + + /// = inteface Job method implementation. + virtual void work (CORBA::ULong work, + CORBA::Short importance + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual void post_work (int guid, + int importance); + + void dump_stats (void); + + virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + int guid (void); + + protected: + /// The name of this Job + ACE_CString job_name_; + + /// The name of the POA that we live in. + ACE_CString POA_name_; + + DT_Creator* dt_creator_; + + Task_Stats *task_stats_; + + int guid_; +}; + +#endif /* JOB_I_H */ diff --git a/TAO/examples/RTScheduling/MIF_Scheduler/MIF_DT_Creator.cpp b/TAO/examples/RTScheduling/MIF_Scheduler/MIF_DT_Creator.cpp new file mode 100644 index 00000000000..7d0e47ef15e --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_Scheduler/MIF_DT_Creator.cpp @@ -0,0 +1,93 @@ +//$Id$ + +#include "MIF_DT_Creator.h" +#include "test.h" +#include "MIF_Task.h" + +MIF_DT_Creator::MIF_DT_Creator (void) +{ + DT_TEST::instance ()->dt_creator (this); +} + +Thread_Task* +MIF_DT_Creator::create_thr_task (int importance, + int start_time, + int load, + int iter, + int dist, + char *job_name) +{ + MIF_Task* task; + ACE_NEW_RETURN (task, + MIF_Task (importance, + start_time, + load, + iter, + dist, + job_name, + this), + 0); + return task; +} + +CORBA::Policy_ptr +MIF_DT_Creator::sched_param (int importance) +{ + return DT_TEST::instance ()->scheduler ()->create_segment_scheduling_parameter (importance); +} + +void +MIF_DT_Creator::yield (int suspend_time, + Thread_Task*) +{ + ACE_TRY_NEW_ENV + { + ACE_Time_Value now (ACE_OS::gettimeofday ()); + while (((now - *base_time_) < suspend_time) || (suspend_time == 1)) + { + + ACE_OS::sleep (1); + CORBA::Policy_var sched_param; + sched_param = CORBA::Policy::_duplicate (this->sched_param (100)); + const char * name = 0; + current_->update_scheduling_segment (name, + sched_param.in (), + sched_param.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + now = ACE_OS::gettimeofday (); + if (suspend_time == 1) + break; + } + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Caught exception:"); + } + ACE_ENDTRY; +} + +int +MIF_DT_Creator::total_load (void) +{ + return 1000; +} + +void +MIF_DT_Creator::wait (void) +{ + while (active_dt_count_ > 0 || active_job_count_ > 0) + { + yield(1,0); + } +} + +ACE_STATIC_SVC_DEFINE(MIF_DT_Creator, + ACE_TEXT ("MIF_DT_Creator"), + ACE_SVC_OBJ_T, + &ACE_SVC_NAME (MIF_DT_Creator), + ACE_Service_Type::DELETE_THIS | ACE_Service_Type::DELETE_OBJ, + 0) + +ACE_FACTORY_DEFINE (MIF_DT_Creator, MIF_DT_Creator) diff --git a/TAO/examples/RTScheduling/MIF_Scheduler/MIF_DT_Creator.h b/TAO/examples/RTScheduling/MIF_Scheduler/MIF_DT_Creator.h new file mode 100644 index 00000000000..1490f8f4b8f --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_Scheduler/MIF_DT_Creator.h @@ -0,0 +1,37 @@ +//$Id$ + +#ifndef MIF_DT_CREATOR_H +#define MIF_DT_CREATOR_H + +#include "../DT_Creator.h" +#include "mif_dt_creator_export.h" +#include "../Task.h" + +class MIF_DT_Creator_Export MIF_DT_Creator: public DT_Creator +{ +public: + MIF_DT_Creator (void); + + virtual CORBA::Policy_ptr sched_param (int importance); + + //virtual Task* task (void); + virtual Thread_Task* create_thr_task (int importance, + int start_time, + int load, + int iter, + int dist, + char *job_name); + + virtual void yield (int suspend_time, + Thread_Task* task); + + virtual void wait (void); + virtual int total_load (void); +}; + + +ACE_STATIC_SVC_DECLARE_EXPORT (MIF_DT_Creator, MIF_DT_Creator) +ACE_FACTORY_DECLARE (MIF_DT_Creator, MIF_DT_Creator) + +#endif /*MIF_DT_CREATOR_H*/ + diff --git a/TAO/examples/RTScheduling/MIF_Scheduler/MIF_Scheduler.cpp b/TAO/examples/RTScheduling/MIF_Scheduler/MIF_Scheduler.cpp new file mode 100644 index 00000000000..a587529398b --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_Scheduler/MIF_Scheduler.cpp @@ -0,0 +1,716 @@ +//$Id$ + +#include "MIF_Scheduler.h" +#include "ace/Atomic_Op.h" +#include "tao/RTScheduling/Request_Interceptor.h" +#include "test.h" + +ACE_Atomic_Op<TAO_SYNCH_MUTEX, long> server_guid_counter; + +DT::DT (TAO_SYNCH_MUTEX &lock, + int guid) + : dt_cond_ (lock), + guid_ (guid), + eligible_ (0) +{ +} + +void +DT::suspend (void) +{ + eligible_ = 0; + while (!eligible_) + this->dt_cond_.wait (); +} + +void +DT::resume (void) +{ + eligible_ = 1; + this->dt_cond_.signal (); +} + +CORBA::Short +Segment_Sched_Param_Policy::importance (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->importance_; +} + +void +Segment_Sched_Param_Policy::importance (CORBA::Short importance + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->importance_ = importance; +} + +MIF_Scheduler::MIF_Scheduler (CORBA::ORB_ptr orb) + : wait_cond_ (lock_), + wait_ (0) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var object = + orb->resolve_initial_references ("RTScheduler_Current" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + this->current_ = + RTScheduling::Current::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + wait_ = 0; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Caught exception:"); + } + ACE_ENDTRY; +} + +MIF_Scheduler::~MIF_Scheduler (void) +{ +} + +void +MIF_Scheduler::incr_thr_count (void) +{ + lock_.acquire (); + wait_++; + lock_.release (); +} + +void +MIF_Scheduler::wait (void) +{ + lock_.acquire (); + while (wait_ > 0) + wait_cond_.wait (); + + ACE_DEBUG ((LM_DEBUG, + "After Wait %d\n", + wait_)); + + lock_.release (); +} + +void +MIF_Scheduler::resume_main (void) +{ + wait_--; + wait_cond_.signal (); +} + +MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr +MIF_Scheduler::create_segment_scheduling_parameter (CORBA::Short importance + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr segment_policy; + ACE_NEW_THROW_EX (segment_policy, + Segment_Sched_Param_Policy, + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOMEM), + CORBA::COMPLETED_NO)); + + segment_policy->importance (importance); + + return segment_policy; +} + + +void +MIF_Scheduler::begin_new_scheduling_segment (const RTScheduling::Current::IdType &/*guid*/, + const char *, + CORBA::Policy_ptr sched_policy, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)) +{ + int count; + ACE_OS::memcpy (&count, + this->current_->id ()->get_buffer (), + this->current_->id ()->length ()); + + + MIF_Scheduling::SegmentSchedulingParameterPolicy_var sched_param = + MIF_Scheduling::SegmentSchedulingParameterPolicy::_narrow (sched_policy); + + CORBA::Short desired_priority = sched_param->importance (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + 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; + 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::begin_nested_scheduling_segment (const RTScheduling::Current::IdType &guid, + const char *name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)) +{ + this->begin_new_scheduling_segment (guid, + name, + sched_param, + implicit_sched_param + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} + +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*/ + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)) +{ + int count; + ACE_OS::memcpy (&count, + this->current_->id ()->get_buffer (), + this->current_->id ()->length ()); + + MIF_Scheduling::SegmentSchedulingParameterPolicy_var sched_param = + MIF_Scheduling::SegmentSchedulingParameterPolicy::_narrow (sched_policy); + + CORBA::Short desired_priority = sched_param->importance (ACE_ENV_SINGLE_ARG_PARAMETER); + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "%t MIF_Scheduler::update_scheduling_segment - Importance %d\n", + desired_priority)); + + DT* new_dt; + 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; + ready_que_.dequeue_head (msg); + run_dt = ACE_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 (); + } + else + { + ready_que_.enqueue_prio (run_dt); + delete new_dt; + } + } + else delete new_dt; +} + +void +MIF_Scheduler::end_scheduling_segment (const RTScheduling::Current::IdType &guid, + const char * + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + int count; + ACE_OS::memcpy (&count, + guid.get_buffer (), + guid.length ()); + + ACE_DEBUG ((LM_DEBUG, + "MIF_Scheduler::end_scheduling_segment %d\n", + count)); + + if (ready_que_.message_count () > 0) + { + DT* run_dt; + ACE_Message_Block* msg; + ready_que_.dequeue_head (msg); + run_dt = ACE_dynamic_cast (DT*, msg); + lock_.acquire (); + run_dt->resume (); + lock_.release (); + } +} + +void +MIF_Scheduler::end_nested_scheduling_segment (const RTScheduling::Current::IdType &, + const char *, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +void +MIF_Scheduler::send_request (PortableInterceptor::ClientRequestInfo_ptr request_info + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ + MIF_Scheduling::SegmentSchedulingParameterPolicy_var sched_param_var = + MIF_Scheduling::SegmentSchedulingParameterPolicy::_narrow (current_->scheduling_parameter (ACE_ENV_SINGLE_ARG_PARAMETER)); + ACE_CHECK; + + IOP::ServiceContext* srv_con = new IOP::ServiceContext; + srv_con->context_id = Client_Interceptor::SchedulingInfo; + + int guid_length = current_->id (ACE_ENV_SINGLE_ARG_PARAMETER)->length (); + ACE_CHECK; + + RTScheduling::Current::IdType* guid = current_->id (ACE_ENV_SINGLE_ARG_PARAMETER); + + CORBA::Octet *seq_buf = CORBA::OctetSeq::allocbuf (sizeof (guid_length)); + ACE_OS::memcpy (seq_buf, + 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::Octet *int_buf = CORBA::OctetSeq::allocbuf (sizeof (int)); + ACE_OS::memcpy (int_buf, + &importance, + sizeof (int)); + + 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 + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + 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)); + + current_->the_priority (priority + 1 + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + 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; + ACE_Message_Block* msg; + ready_que_.dequeue_head (msg); + run_dt = ACE_dynamic_cast (DT*, msg); + run_dt->resume (); + } + lock_.release (); + +} + +void +MIF_Scheduler::receive_request (PortableInterceptor::ServerRequestInfo_ptr request_info, + RTScheduling::Current::IdType_out guid_out, + CORBA::String_out, + CORBA::Policy_out sched_param_out, + CORBA::Policy_out /*implicit_sched_param*/ + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "MIF_Scheduler::receive_request\n")); + + IOP::ServiceContext* serv_cxt = + request_info->get_request_service_context (Server_Interceptor::SchedulingInfo); + + if (serv_cxt != 0) + { + ACE_DEBUG ((LM_DEBUG, + "Got scheduling info\n")); + + RTScheduling::Current::IdType* guid; + ACE_NEW (guid, + RTScheduling::Current::IdType); + + guid->length (sizeof(long)); + ACE_OS::memcpy (guid->get_buffer (), + serv_cxt->context_data.get_buffer (), + sizeof (long)); + + int gu_id; + ACE_OS::memcpy (&gu_id, + guid->get_buffer (), + guid->length ()); + + ACE_DEBUG ((LM_DEBUG, + "MIF_Scheduler::receive_request %d\n", + gu_id)); + + + CORBA::Octet *int_buf = CORBA::OctetSeq::allocbuf (sizeof (long)); + int i = sizeof (long); + for (unsigned int j = 0;j < sizeof (int);j++) + { + int_buf [j] = serv_cxt->context_data [i++]; + } + + int importance; + ACE_OS::memcpy (&importance, + int_buf, + sizeof (int)); + + guid_out.ptr () = guid; + sched_param_out.ptr () = DT_TEST::instance ()->scheduler ()->create_segment_scheduling_parameter (importance); + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "%t The Guid is %d Importance is %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); + new_dt->suspend (); + lock_.release (); + } +} + +void +MIF_Scheduler::send_reply (PortableInterceptor::ServerRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + + RTScheduling::Current::IdType* guid = current_->id (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + int count; + ACE_OS::memcpy (&count, + guid->get_buffer (), + guid->length ()); + + ACE_DEBUG ((LM_DEBUG, + "MIF_Scheduler::send_reply %d\n", + count)); + + if (ready_que_.message_count () > 0) + { + DT* run_dt; + ACE_Message_Block* msg; + ready_que_.dequeue_head (msg); + run_dt = ACE_dynamic_cast (DT*, msg); + lock_.acquire (); + run_dt->resume (); + lock_.release (); + } +} + +void +MIF_Scheduler::send_exception (PortableInterceptor::ServerRequestInfo_ptr + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ + if (ready_que_.message_count () > 0) + { + DT* run_dt; + ACE_Message_Block* msg; + ready_que_.dequeue_head (msg); + run_dt = ACE_dynamic_cast (DT*, msg); + lock_.acquire (); + run_dt->resume (); + lock_.release (); + } +} + +void +MIF_Scheduler::send_other (PortableInterceptor::ServerRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ + if (TAO_debug_level > 0) + { + RTScheduling::Current::IdType* guid = current_->id (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + int 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 = ACE_dynamic_cast (DT*, msg); + lock_.acquire (); + run_dt->resume (); + lock_.release (); + } +} + +void +MIF_Scheduler::receive_reply (PortableInterceptor::ClientRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + + MIF_Scheduling::SegmentSchedulingParameterPolicy_var sched_param_var = + MIF_Scheduling::SegmentSchedulingParameterPolicy::_narrow (current_->scheduling_parameter (ACE_ENV_SINGLE_ARG_PARAMETER)); + ACE_CHECK; + + int importance = sched_param_var->importance (); + CORBA::Octet *int_buf = CORBA::OctetSeq::allocbuf (sizeof (int)); + ACE_OS::memcpy (int_buf, + &importance, + sizeof (int)); + + RTScheduling::Current::IdType* guid = current_->id (ACE_ENV_SINGLE_ARG_PARAMETER); + + int 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; + + current_->the_priority (priority - 1 + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + new_dt->suspend (); + lock_.release (); +} + +void +MIF_Scheduler::receive_exception (PortableInterceptor::ClientRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ + MIF_Scheduling::SegmentSchedulingParameterPolicy_var sched_param_var = + MIF_Scheduling::SegmentSchedulingParameterPolicy::_narrow (current_->scheduling_parameter (ACE_ENV_SINGLE_ARG_PARAMETER)); + ACE_CHECK; + + int importance = sched_param_var->importance (); + CORBA::Octet *int_buf = CORBA::OctetSeq::allocbuf (sizeof (int)); + ACE_OS::memcpy (int_buf, + &importance, + sizeof (int)); + + RTScheduling::Current::IdType* guid = current_->id (ACE_ENV_SINGLE_ARG_PARAMETER); + + int gu_id; + ACE_OS::memcpy (&gu_id, + guid->get_buffer (), + guid->length ()); + + 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; + + current_->the_priority (priority - 1 + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + new_dt->suspend (); + lock_.release (); +} + +void +MIF_Scheduler::receive_other (PortableInterceptor::ClientRequestInfo_ptr + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)) +{ + MIF_Scheduling::SegmentSchedulingParameterPolicy_var sched_param_var = + MIF_Scheduling::SegmentSchedulingParameterPolicy::_narrow (current_->scheduling_parameter (ACE_ENV_SINGLE_ARG_PARAMETER)); + ACE_CHECK; + + int importance = sched_param_var->importance (); + CORBA::Octet *int_buf = CORBA::OctetSeq::allocbuf (sizeof (int)); + ACE_OS::memcpy (int_buf, + &importance, + sizeof (int)); + + RTScheduling::Current::IdType* guid = current_->id (ACE_ENV_SINGLE_ARG_PARAMETER); + + int gu_id; + ACE_OS::memcpy (&gu_id, + guid->get_buffer (), + guid->length ()); + + 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; + + current_->the_priority (priority - 1 + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + new_dt->suspend (); + lock_.release (); +} + +void +MIF_Scheduler::cancel (const RTScheduling::Current::IdType & + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +CORBA::PolicyList* +MIF_Scheduler::scheduling_policies (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +void +MIF_Scheduler::scheduling_policies (const CORBA::PolicyList & + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +CORBA::PolicyList* +MIF_Scheduler::poa_policies (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +char * +MIF_Scheduler::scheduling_discipline_name (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +RTScheduling::ResourceManager_ptr +MIF_Scheduler::create_resource_manager (const char *, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return 0; +} + +void +MIF_Scheduler::set_scheduling_parameter (PortableServer::Servant &, + const char *, + CORBA::Policy_ptr + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} diff --git a/TAO/examples/RTScheduling/MIF_Scheduler/MIF_Scheduler.h b/TAO/examples/RTScheduling/MIF_Scheduler/MIF_Scheduler.h new file mode 100644 index 00000000000..0490da8db7b --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_Scheduler/MIF_Scheduler.h @@ -0,0 +1,181 @@ +//$Id$ + +#ifndef MIF_SCHEDULER_H +#define MIF_SCHEDULER_H + +#include "tao/RTScheduling/RTScheduler.h" +#include "../MIF_SchedulingC.h" +#include "ace/Message_Queue.h" +#include "ace/Atomic_Op.h" + +class DT : public ACE_Message_Block +{ + public: + DT (TAO_SYNCH_MUTEX &lock, + int guid); + + void suspend (void); + void resume (void); + + private: + TAO_SYNCH_CONDITION dt_cond_; + int guid_; + int eligible_; +}; + +class Segment_Sched_Param_Policy: +public MIF_Scheduling::SegmentSchedulingParameterPolicy, + public TAO_Local_RefCounted_Object +{ + public: + virtual CORBA::Short importance (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void importance (CORBA::Short importance + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)); + + private: + CORBA::Short importance_; +}; + +typedef ACE_Message_Queue<ACE_NULL_SYNCH> DT_Message_Queue; + +class MIF_Scheduler: +public MIF_Scheduling::MIF_Scheduler, +public TAO_Local_RefCounted_Object +{ + public: + + MIF_Scheduler (CORBA::ORB_ptr orb); + + ~MIF_Scheduler (void); + + + virtual MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr + create_segment_scheduling_parameter (CORBA::Short segment_priority + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void wait (void); + + void resume_main (void); + + void incr_thr_count (void); + + virtual void begin_new_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)); + + virtual void begin_nested_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)); + + virtual void update_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr sched_param, + CORBA::Policy_ptr implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + RTScheduling::Current::UNSUPPORTED_SCHEDULING_DISCIPLINE)); + + virtual void end_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void end_nested_scheduling_segment (const RTScheduling::Current::IdType & guid, + const char * name, + CORBA::Policy_ptr outer_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void send_request (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void receive_request (PortableInterceptor::ServerRequestInfo_ptr ri, + RTScheduling::Current::IdType_out guid, + CORBA::String_out name, + CORBA::Policy_out sched_param, + CORBA::Policy_out implicit_sched_param + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void send_reply (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void send_exception (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void send_other (PortableInterceptor::ServerRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void receive_reply (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void receive_exception (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void receive_other (PortableInterceptor::ClientRequestInfo_ptr ri + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException, + PortableInterceptor::ForwardRequest)); + + virtual void cancel (const RTScheduling::Current::IdType & guid + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::PolicyList * scheduling_policies (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void scheduling_policies (const CORBA::PolicyList & scheduling_policies + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::PolicyList * poa_policies (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual char * scheduling_discipline_name (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual RTScheduling::ResourceManager_ptr create_resource_manager (const char * name, + CORBA::Policy_ptr scheduling_parameter + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void set_scheduling_parameter (PortableServer::Servant & resource, + const char * name, + CORBA::Policy_ptr scheduling_parameter + ACE_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_THROW_SPEC ((CORBA::SystemException)); + + private: + RTScheduling::Current_var current_; + TAO_SYNCH_MUTEX lock_; + TAO_SYNCH_MUTEX wait_lock_; + TAO_SYNCH_CONDITION wait_cond_; + DT_Message_Queue ready_que_; + DT_Message_Queue wait_que_; + int wait_; +}; + +#endif //MIF_SCHEDULER_H diff --git a/TAO/examples/RTScheduling/MIF_Scheduler/MIF_Task.cpp b/TAO/examples/RTScheduling/MIF_Scheduler/MIF_Task.cpp new file mode 100644 index 00000000000..10e4418d557 --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_Scheduler/MIF_Task.cpp @@ -0,0 +1,175 @@ +//$Id$ +#include "MIF_Task.h" +#include "test.h" + +MIF_Task::MIF_Task (int importance, + int start_time, + int load, + int iter, + int dist, + char *job_name, + DT_Creator *dt_creator) +{ + this->load_ = load; + this->iter_ = iter; + this->start_time_ = start_time; + this->importance_ = importance; + this->dt_creator_ = dt_creator; + this->dist_ = dist; + this->job_name_ = CORBA::string_dup (job_name); + + // create the stat object. + ACE_NEW (task_stats_, Task_Stats); + task_stats_->init (iter_); + +} + +MIF_Task::~MIF_Task (void) +{ + delete task_stats_; +} + +void +MIF_Task::pre_activate (void) +{ + DT_TEST::instance ()->scheduler ()->incr_thr_count (); +} + +void +MIF_Task::post_activate (void) +{ + DT_TEST::instance ()->scheduler ()->wait (); +} + +int +MIF_Task::activate_task (RTScheduling::Current_ptr current, + CORBA::Policy_ptr sched_param, + long flags, + ACE_Time_Value* base_time + ACE_ENV_ARG_DECL) +{ + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "Thread_Task::activate %d\n", + importance_)); + + char msg [BUFSIZ]; + ACE_OS::sprintf (msg, "Thread_Task::activate task\n"); + dt_creator_->log_msg (msg); + + base_time_ = base_time; + + current_ = RTScheduling::Current::_narrow (current + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + sched_param_ = CORBA::Policy::_duplicate (sched_param); + + pre_activate (); + + if (this->activate (flags, + 1) == -1) + { + if (ACE_OS::last_error () == EPERM) + ACE_ERROR_RETURN ((LM_ERROR, + ACE_TEXT ("Insufficient privilege to run this test.\n")), + -1); + } + + post_activate (); + return 0; +} + +int +MIF_Task::perform_task (void) +{ + ACE_TRY_NEW_ENV + { + + char msg [BUFSIZ]; + ACE_OS::sprintf (msg, "MIF_Task::perform_task %d\n", count_); + dt_creator_->log_msg (msg); + + static CORBA::ULong prime_number = 9619; + CORBA::Policy_var sched_param; + sched_param = CORBA::Policy::_duplicate (dt_creator_->sched_param (this->importance_)); + const char * name = 0; + + for (int i = 0; i < this->iter_; i++) + { + ACE_Time_Value run_time = ACE_OS::gettimeofday () - *base_time_; + TASK_STATS::instance ()->sample (ACE_UINT64 (run_time.sec ()), + count_); + + 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 (); + } + + current_->update_scheduling_segment (name, + sched_param.in (), + sched_param.in () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + + if (this->dist_) + { + this->job_->work (this->load_, + this->importance_); + + for (int j = 0; j < this->iter_; j++) + { + ACE_Time_Value run_time = ACE_OS::gettimeofday () - *base_time_; + TASK_STATS::instance ()->sample (ACE_UINT64 (run_time.sec ()), + count_); + + 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 (); + } + + current_->update_scheduling_segment (name, + sched_param.in (), + sched_param.in () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + } + + } + + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Caught exception:"); + return -1; + } + ACE_ENDTRY; + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "Thread %d\n", + this->count_)); + + if (dist_) + job_->shutdown (); + + return 0; +} diff --git a/TAO/examples/RTScheduling/MIF_Scheduler/MIF_Task.h b/TAO/examples/RTScheduling/MIF_Scheduler/MIF_Task.h new file mode 100644 index 00000000000..a4cfcf11993 --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_Scheduler/MIF_Task.h @@ -0,0 +1,33 @@ +//$Id$ +#ifndef MIF_TASK_H +#define MIF_TASK_H + +#include "../Thread_Task.h" + +class MIF_Task : public Thread_Task +{ + public: + MIF_Task (int importance, + int start_time, + int load, + int iter, + int dist, + char *job_name, + DT_Creator *dt_creator); + + ~MIF_Task (void); + + virtual int activate_task (RTScheduling::Current_ptr current, + CORBA::Policy_ptr sched_param, + long flags, + ACE_Time_Value* base_time + ACE_ENV_ARG_DECL_WITH_DEFAULTS); + + virtual int perform_task (void); + + private: + void pre_activate (void); + void post_activate (void); +}; + +#endif /*MIF_TASK_H*/ diff --git a/TAO/examples/RTScheduling/MIF_Scheduler/Makefile b/TAO/examples/RTScheduling/MIF_Scheduler/Makefile new file mode 100644 index 00000000000..5815b542952 --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_Scheduler/Makefile @@ -0,0 +1,836 @@ +#---------------------------------------------------------------------------- +# +# $Id$ +# +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +ifndef TAO_ROOT + TAO_ROOT = $(ACE_ROOT)/TAO +endif # ! TAO_ROOT + +LIBS = -lTAO_RTScheduler -lTAO_PortableServer -lTAO_CosNaming +BIN_UNCHECKED = test Starter + +IDL_FILES = ../MIF_Scheduling \ + ../Synch \ + ../Job + +SRC = $(addsuffix .cpp, test ../Starter) + + +MIF_TEST_OBJS = test.o MIF_DT_Creator.o MIF_Task.o MIF_Scheduler.o ../MIF_SchedulingC.o ../Thread_Task.o ../DT_Creator.o ../JobC.o ../JobS.o ../Job_i.o ../POA_Holder.o ../Task_Stats.o ../SynchC.o ../SynchS.o ../Synch_i.o + +STARTER_OBJS = ../Starter.o ../SynchS.o ../SynchC.o ../Synch_i.o + +BUILD = $(BIN) +VBIN = $(BIN:%=%$(VAR)) + +CPPFLAGS += -I$(TAO_ROOT)/orbsvcs -I$(TAO_ROOT)/tao/RTScheduling -I$(TAO_ROOT)/tao/RTCORBA + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(TAO_ROOT)/rules.tao.GNU + +ifeq ($(rt_corba),1) +BIN=$(BIN_UNCHECKED) +endif # rt_corba + +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU +include $(TAO_ROOT)/taoconfig.mk + +override TAO_IDLFLAGS += -o ../ \ + -I$(TAO_ROOT) + + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +.PRECIOUS: $(foreach ext, $(IDL_EXT), ../MIF_Scheduling$(ext) ../Job$(ext) ../Synch$(ext)) + +test: $(addprefix $(VDIR),$(MIF_TEST_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(RT_TAO_CLNT_LIBS) $(POSTLINK) + +Starter: $(addprefix $(VDIR),$(STARTER_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(RT_TAO_CLNT_LIBS) $(POSTLINK) + +realclean: clean + -$(RM) $(foreach ext, $(IDL_EXT), Job$(ext)) + +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + + +.obj/test.o .obj/test.so .shobj/test.o .shobj/test.so: test.cpp test.h \ + $(ACE_ROOT)/ace/pre.h \ + MIF_Scheduler.h \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/os_include/os_limits.h \ + $(ACE_ROOT)/ace/os_include/os_unistd.h \ + $(ACE_ROOT)/ace/os_include/sys/os_types.h \ + $(ACE_ROOT)/ace/os_include/os_stddef.h \ + $(ACE_ROOT)/ace/os_include/os_inttypes.h \ + $(ACE_ROOT)/ace/os_include/os_stdint.h \ + $(ACE_ROOT)/ace/os_include/os_stdio.h \ + $(ACE_ROOT)/ace/os_include/os_stdarg.h \ + $(ACE_ROOT)/ace/os_include/os_float.h \ + $(ACE_ROOT)/ace/os_include/os_stdlib.h \ + $(ACE_ROOT)/ace/os_include/sys/os_wait.h \ + $(ACE_ROOT)/ace/os_include/os_signal.h \ + $(ACE_ROOT)/ace/os_include/os_time.h \ + $(ACE_ROOT)/ace/os_include/os_ucontext.h \ + $(ACE_ROOT)/ace/os_include/sys/os_resource.h \ + $(ACE_ROOT)/ace/os_include/sys/os_time.h \ + $(ACE_ROOT)/ace/os_include/sys/os_select.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/os_include/os_errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/os_include/os_dirent.h \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/os_include/os_string.h \ + $(ACE_ROOT)/ace/os_include/os_strings.h \ + $(ACE_ROOT)/ace/os_include/os_ctype.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/os_include/os_dlfcn.h \ + $(ACE_ROOT)/ace/os_include/sys/os_mman.h \ + $(ACE_ROOT)/ace/os_include/os_netdb.h \ + $(ACE_ROOT)/ace/os_include/netinet/os_in.h \ + $(ACE_ROOT)/ace/os_include/sys/os_socket.h \ + $(ACE_ROOT)/ace/os_include/sys/os_uio.h \ + $(ACE_ROOT)/ace/os_include/net/os_if.h \ + $(ACE_ROOT)/ace/os_include/sys/os_sem.h \ + $(ACE_ROOT)/ace/os_include/sys/os_ipc.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/os_include/os_pthread.h \ + $(ACE_ROOT)/ace/os_include/os_assert.h \ + $(ACE_ROOT)/ace/os_include/os_fcntl.h \ + $(ACE_ROOT)/ace/os_include/sys/os_stat.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/os_include/arpa/os_inet.h \ + $(ACE_ROOT)/ace/os_include/netinet/os_tcp.h \ + $(ACE_ROOT)/ace/os_include/sys/os_shm.h \ + $(ACE_ROOT)/ace/os_include/os_pwd.h \ + $(ACE_ROOT)/ace/os_include/os_stropts.h \ + $(ACE_ROOT)/ace/os_include/os_termios.h \ + $(ACE_ROOT)/ace/os_include/os_aio.h \ + $(ACE_ROOT)/ace/os_include/sys/os_un.h \ + $(ACE_ROOT)/ace/os_include/os_poll.h \ + $(ACE_ROOT)/ace/os_include/sys/os_msg.h \ + $(ACE_ROOT)/ace/os_include/sys/os_utsname.h \ + $(ACE_ROOT)/ace/os_include/os_syslog.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SStringfwd.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(ACE_ROOT)/ace/iosfwd.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Pseudo_VarOut_T.h \ + $(TAO_ROOT)/tao/Pseudo_VarOut_T.inl \ + $(TAO_ROOT)/tao/Pseudo_VarOut_T.cpp \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any_Impl_T.h \ + $(TAO_ROOT)/tao/Any.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Objref_VarOut_T.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/Objref_VarOut_T.inl \ + $(TAO_ROOT)/tao/Objref_VarOut_T.cpp \ + $(TAO_ROOT)/tao/Seq_Var_T.h \ + $(TAO_ROOT)/tao/Seq_Var_T.inl \ + $(TAO_ROOT)/tao/Seq_Var_T.cpp \ + $(TAO_ROOT)/tao/Seq_Out_T.h \ + $(TAO_ROOT)/tao/Seq_Out_T.inl \ + $(TAO_ROOT)/tao/Seq_Out_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/IOP_IORC.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/VarOut_T.h \ + $(TAO_ROOT)/tao/VarOut_T.inl \ + $(TAO_ROOT)/tao/VarOut_T.cpp \ + $(TAO_ROOT)/tao/IOP_IORC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/Any_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Impl_T.cpp \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Any_Basic_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Basic_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Basic_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Special_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Special_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Special_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Special_Basic_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Special_Basic_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Special_Basic_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Array_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Array_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Array_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Dual_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Dual_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Dual_Impl_T.cpp \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/ServicesC.h \ + $(TAO_ROOT)/tao/ServicesC.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/ObjectIdListC.h \ + $(TAO_ROOT)/tao/ObjectIdListC.i \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Array_VarOut_T.h \ + $(TAO_ROOT)/tao/Array_VarOut_T.inl \ + $(TAO_ROOT)/tao/Array_VarOut_T.cpp \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/PI_ForwardC.h \ + $(TAO_ROOT)/tao/PI_ForwardC.i \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOP_CodecC.h \ + $(TAO_ROOT)/tao/IOP_CodecC.i \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(TAO_ROOT)/tao/RTScheduling/rtscheduler_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBA.h \ + $(TAO_ROOT)/tao/RTCORBA/rtcorba_export.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/RTCORBA/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTSchedulerC.i \ + ../MIF_SchedulingC.h ../MIF_SchedulingC.i \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Notification_Strategy.h \ + $(ACE_ROOT)/ace/Notification_Strategy.inl \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Atomic_Op.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.i \ + $(ACE_ROOT)/ace/Atomic_Op_T.cpp \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Sched_Params.h \ + $(ACE_ROOT)/ace/Sched_Params.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Set.h \ + $(TAO_ROOT)/tao/Policy_Set.i \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/DLL.h \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.i \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/ObjectKey_Table.h \ + $(ACE_ROOT)/ace/RB_Tree.h \ + $(ACE_ROOT)/ace/RB_Tree.i \ + $(ACE_ROOT)/ace/RB_Tree.cpp \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/PICurrent.h \ + $(TAO_ROOT)/tao/PICurrent.inl \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Exit.h \ + $(ACE_ROOT)/ace/Thread_Control.h \ + $(ACE_ROOT)/ace/Thread_Control.inl \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Framework_Component.h \ + $(ACE_ROOT)/ace/Framework_Component.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.h \ + $(ACE_ROOT)/ace/Framework_Component_T.inl \ + $(ACE_ROOT)/ace/Framework_Component_T.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + MIF_DT_Creator.h ../DT_Creator.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/naming_export.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.i \ + $(TAO_ROOT)/tao/RTScheduling/RTScheduler.h \ + $(ACE_ROOT)/ace/Arg_Shifter.h \ + ../POA_Holder.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + ../Job_i.h ../JobS.h ../JobC.h ../JobC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + ../JobS_T.h ../JobS_T.i ../JobS_T.cpp ../JobS.i ../Task_Stats.h \ + ../Task_Stats.inl ../Synch_i.h ../SynchS.h ../SynchC.h ../SynchC.i \ + ../SynchS_T.h ../SynchS_T.i ../SynchS_T.cpp ../SynchS.i \ + mif_dt_creator_export.h ../Task.h \ + $(TAO_ROOT)/tao/RTScheduling/RTScheduler_Manager.h \ + $(TAO_ROOT)/tao/RTScheduling/RTScheduler_Manager.i \ + ../Thread_Task.h + +.obj/Starter.o .obj/Starter.so .shobj/Starter.o .shobj/Starter.so: ../Starter.cpp ../Starter.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Naming_Utils.h \ + $(ACE_ROOT)/ace/pre.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/os_include/os_limits.h \ + $(ACE_ROOT)/ace/os_include/os_unistd.h \ + $(ACE_ROOT)/ace/os_include/sys/os_types.h \ + $(ACE_ROOT)/ace/os_include/os_stddef.h \ + $(ACE_ROOT)/ace/os_include/os_inttypes.h \ + $(ACE_ROOT)/ace/os_include/os_stdint.h \ + $(ACE_ROOT)/ace/os_include/os_stdio.h \ + $(ACE_ROOT)/ace/os_include/os_stdarg.h \ + $(ACE_ROOT)/ace/os_include/os_float.h \ + $(ACE_ROOT)/ace/os_include/os_stdlib.h \ + $(ACE_ROOT)/ace/os_include/sys/os_wait.h \ + $(ACE_ROOT)/ace/os_include/os_signal.h \ + $(ACE_ROOT)/ace/os_include/os_time.h \ + $(ACE_ROOT)/ace/os_include/os_ucontext.h \ + $(ACE_ROOT)/ace/os_include/sys/os_resource.h \ + $(ACE_ROOT)/ace/os_include/sys/os_time.h \ + $(ACE_ROOT)/ace/os_include/sys/os_select.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Default_Constants.h \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/Global_Macros.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/os_include/os_errno.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/os_include/os_dirent.h \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/os_include/os_string.h \ + $(ACE_ROOT)/ace/os_include/os_strings.h \ + $(ACE_ROOT)/ace/os_include/os_ctype.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/os_include/os_dlfcn.h \ + $(ACE_ROOT)/ace/os_include/sys/os_mman.h \ + $(ACE_ROOT)/ace/os_include/os_netdb.h \ + $(ACE_ROOT)/ace/os_include/netinet/os_in.h \ + $(ACE_ROOT)/ace/os_include/sys/os_socket.h \ + $(ACE_ROOT)/ace/os_include/sys/os_uio.h \ + $(ACE_ROOT)/ace/os_include/net/os_if.h \ + $(ACE_ROOT)/ace/os_include/sys/os_sem.h \ + $(ACE_ROOT)/ace/os_include/sys/os_ipc.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Time_Value.inl \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/os_include/os_pthread.h \ + $(ACE_ROOT)/ace/os_include/os_assert.h \ + $(ACE_ROOT)/ace/os_include/os_fcntl.h \ + $(ACE_ROOT)/ace/os_include/sys/os_stat.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/os_include/arpa/os_inet.h \ + $(ACE_ROOT)/ace/os_include/netinet/os_tcp.h \ + $(ACE_ROOT)/ace/os_include/sys/os_shm.h \ + $(ACE_ROOT)/ace/os_include/os_pwd.h \ + $(ACE_ROOT)/ace/os_include/os_stropts.h \ + $(ACE_ROOT)/ace/os_include/os_termios.h \ + $(ACE_ROOT)/ace/os_include/os_aio.h \ + $(ACE_ROOT)/ace/os_include/sys/os_un.h \ + $(ACE_ROOT)/ace/os_include/os_poll.h \ + $(ACE_ROOT)/ace/os_include/sys/os_msg.h \ + $(ACE_ROOT)/ace/os_include/sys/os_utsname.h \ + $(ACE_ROOT)/ace/os_include/os_syslog.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SStringfwd.h \ + $(ACE_ROOT)/ace/String_Base.h \ + $(ACE_ROOT)/ace/String_Base_Const.h \ + $(ACE_ROOT)/ace/String_Base.i \ + $(ACE_ROOT)/ace/String_Base.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/XML_Svc_Conf.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(ACE_ROOT)/ace/Exception_Macros.h \ + $(ACE_ROOT)/ace/iosfwd.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Pseudo_VarOut_T.h \ + $(TAO_ROOT)/tao/Pseudo_VarOut_T.inl \ + $(TAO_ROOT)/tao/Pseudo_VarOut_T.cpp \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any_Impl_T.h \ + $(TAO_ROOT)/tao/Any.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Policy_ForwardC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Objref_VarOut_T.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/Objref_VarOut_T.inl \ + $(TAO_ROOT)/tao/Objref_VarOut_T.cpp \ + $(TAO_ROOT)/tao/Seq_Var_T.h \ + $(TAO_ROOT)/tao/Seq_Var_T.inl \ + $(TAO_ROOT)/tao/Seq_Var_T.cpp \ + $(TAO_ROOT)/tao/Seq_Out_T.h \ + $(TAO_ROOT)/tao/Seq_Out_T.inl \ + $(TAO_ROOT)/tao/Seq_Out_T.cpp \ + $(TAO_ROOT)/tao/Policy_ForwardC.i \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/IOP_IORC.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/VarOut_T.h \ + $(TAO_ROOT)/tao/VarOut_T.inl \ + $(TAO_ROOT)/tao/VarOut_T.cpp \ + $(TAO_ROOT)/tao/IOP_IORC.i \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/Any_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Impl_T.cpp \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Any_Basic_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Basic_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Basic_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Special_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Special_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Special_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Special_Basic_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Special_Basic_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Special_Basic_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Array_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Array_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Array_Impl_T.cpp \ + $(TAO_ROOT)/tao/Any_Dual_Impl_T.h \ + $(TAO_ROOT)/tao/Any_Dual_Impl_T.inl \ + $(TAO_ROOT)/tao/Any_Dual_Impl_T.cpp \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/ServicesC.h \ + $(TAO_ROOT)/tao/ServicesC.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/ObjectIdListC.h \ + $(TAO_ROOT)/tao/ObjectIdListC.i \ + $(TAO_ROOT)/tao/objectid.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.i \ + $(TAO_ROOT)/tao/Array_VarOut_T.h \ + $(TAO_ROOT)/tao/Array_VarOut_T.inl \ + $(TAO_ROOT)/tao/Array_VarOut_T.cpp \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/PI_ForwardC.h \ + $(TAO_ROOT)/tao/PI_ForwardC.i \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.h \ + $(TAO_ROOT)/tao/Messaging_SyncScopeC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOP_CodecC.h \ + $(TAO_ROOT)/tao/IOP_CodecC.i \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/naming_export.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/IOR_Multicast.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/svc_utils_export.h \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_Dgram.i \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Naming_Context_Interface.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(ACE_ROOT)/ace/Atomic_Op.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.h \ + $(ACE_ROOT)/ace/Atomic_Op_T.i \ + $(ACE_ROOT)/ace/Atomic_Op_T.cpp \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.cpp \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/nsconf.h \ + ../SynchC.h ../SynchC.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/examples/RTScheduling/MIF_Scheduler/README b/TAO/examples/RTScheduling/MIF_Scheduler/README new file mode 100644 index 00000000000..f01d0702f54 --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_Scheduler/README @@ -0,0 +1,158 @@ +Most Important First (MIF) Scheduler +==================================== + +Table of contents +----------------- +1. Introduction +2. Conf file parameters +3. Running the example. + +1. Introduction +--------------- + +This scheduler manages a ready queue of Distributable Threads (DTs) +ordered by their importance and suspended on a condition variable. AT +any given time the scheduler dequeues the DT at the head of the queue, +that corresponds to the most important thread, and signals the thread +to activate it. The service context is used to send the importance and +GUID of the DT across hosts it spans so the DT can be scheduled +accordingly on the remote host. + +In this experiment we show how dynamic scheduling is done using the +Dynamic Scheduling framework with the MIF Scheduler as the pluggable +scheduler. At any given instance the DT of highest priority is running +on a given host. + +The experiment consists of the following participants: +Job: A CORBA servant object that performs CPU intensive work. The +amount of work depends on a load factor that is conveyed to the object +per invocation as an argument. + +DT_Task: The distributable thread is a scheduling segment spanning one +or more hosts. + +test: The test consists of a collection of Jobs and DTs hosted in +a single process. The test reads a configuration file that can be used +to initialize DTs and Jobs. + +Starter: The starter initiates the start of DTs on each host that the +test is running on. This is to ensure that the experiment starts at +the same time on all hosts. + +2. Conf file parameters +-------------------- + +POA OPTIONS +========== +To specify POA options the format is: + +-POACount <count> -POA <name> -PriorityModel <CLIENT|SERVER> <priority> -Lanes <count> (-Lane <priority> ,<static_threads> <dynamic_threads>)* -Bands <count> (-Band <low> <high>)* + +e.g. +-POACount 2 -POA poa1 -PriorityModel CLIENT 10 -Bands 2 -Band 1 20 -Band 30 85 -Lanes 2 -Lane 10 1 0 -Lane 80 1 0 + +specifes a POA with: + +POA Count - Specifies the number of POAs that need to be activated. The following characteristics of each POA needs to be specified. + +Name - poa1 + +Priority model - client propogated, def. priority = 10 + +Bands - 2 Bands with Band values as follows - + Band 1 : low priority = 1, high priority = 20 + Band 2 : low priority = 30, high priority = 85 + +Lanes - 2 Lanes with Lane values as follows - + Lane 1 : priority = 10, 1 static thread, 0 dynamic threads + Lane 2 : priority = 80, 1 static thread, 0 dynamic threads + + +Distributable Thread Task Options +================================= + +The format to specify a DT Task is: + +-DT_Count <count> -DT_Task Importance <imp> -Start_Time <time> -Iter <local_work> -Load <remote_work> -JobName <name> + +where, +-DT_Count = Total number of DT_Tasks +-DT_Task = Specifies a Distributable Thread +-Importance = The priority of the DT +-Start_Time = Time at which the DT enters the system +-Iter = The number of secs of work to be done on the local host. For a +distributed DT it defines the number of secs of local work to be done +before and after a remote method call is made. +-Load = The number of secs of work to be done on the remote host when +a two-way method call is made by a distributed DT +-JobName <name> = Name of the Job object that this DT will make a +remote method call on to do some 'Load' number of secs of work on the +remote host + +e.g. +-DT_Count 1 -DT_Task -Importance 5 -Start_Time 0 -Iter 3 -Load 5 -JobName job_1 + +specifes a DT Task in which, +Importance = 5 +Start Time = 0 +Iter = 3 +Load = 5 +JobName = job_1 + +Job Options +=========== +The format for specify a Job is: +-Job_Count <count> -Job <name> <poa_name> + +where, poa_name is the POA that this object is activated in. + +Job Count - Specifies the number of jobs that are activated. + +e.g. +-Job job_10 poa1 + +specifies a Job with, + +Name - job_10 +POA Name - poa1 + +Misc +===== + +-GuidSeed <guid> + +This specifies the guid number with which the guid counter will get +initialized. This is to ensure that unique guids are used. This will +be removed when the ACE UUID generator is integrated with TAO. + +-OutFile <filename> + +This specifies the data file in which the schedule of the DT"s running +on the host will be output. + +-LogFile <filenmae> + +This speficies the log file + +3. Running the example +---------------------- + +a) The activated Jobs and Synch objects are registered with a Naming +service, so we need an NS running + +e.g. ./Naming_Service -o naming_ior + +b) Start one or more instances of ./test depending on the test +configuration that you have designed. + +e.g. ./test -ORBInitRef NameService=file://naming_ior -ORBSvcConf svc.conf.whatever -ORBDebugLevel 1 + +c) Execute the Starter that initiates the creation of DTs on all the +hosts that the experiment is running + +eg. ./Starter -ORBInitRef NameService=file://naming.ior + +c) Once all the instances exit, the test will generate schedule files +as specified by the user with the -OutFile option file + + diff --git a/TAO/examples/RTScheduling/MIF_Scheduler/mif_dt_creator_export.h b/TAO/examples/RTScheduling/MIF_Scheduler/mif_dt_creator_export.h new file mode 100644 index 00000000000..58ef8f81839 --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_Scheduler/mif_dt_creator_export.h @@ -0,0 +1,50 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl MIF_DT_Creator +// ------------------------------ +#ifndef MIF_DT_CREATOR_EXPORT_H +#define MIF_DT_CREATOR_EXPORT_H + +#include "ace/config-all.h" + +#if !defined (MIF_DT_CREATOR_HAS_DLL) +# define MIF_DT_CREATOR_HAS_DLL 1 +#endif /* ! MIF_DT_CREATOR_HAS_DLL */ + +#if defined (MIF_DT_CREATOR_HAS_DLL) && (MIF_DT_CREATOR_HAS_DLL == 1) +# if defined (MIF_DT_CREATOR_BUILD_DLL) +# define MIF_DT_Creator_Export ACE_Proper_Export_Flag +# define MIF_DT_CREATOR_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define MIF_DT_CREATOR_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* MIF_DT_CREATOR_BUILD_DLL */ +# define MIF_DT_Creator_Export ACE_Proper_Import_Flag +# define MIF_DT_CREATOR_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define MIF_DT_CREATOR_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* MIF_DT_CREATOR_BUILD_DLL */ +#else /* MIF_DT_CREATOR_HAS_DLL == 1 */ +# define MIF_DT_Creator_Export +# define MIF_DT_CREATOR_SINGLETON_DECLARATION(T) +# define MIF_DT_CREATOR_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* MIF_DT_CREATOR_HAS_DLL == 1 */ + +// Set MIF_DT_CREATOR_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (MIF_DT_CREATOR_NTRACE) +# if (ACE_NTRACE == 1) +# define MIF_DT_CREATOR_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define MIF_DT_CREATOR_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !MIF_DT_CREATOR_NTRACE */ + +#if (MIF_DT_CREATOR_NTRACE == 1) +# define MIF_DT_CREATOR_TRACE(X) +#else /* (MIF_DT_CREATOR_NTRACE == 1) */ +# define MIF_DT_CREATOR_TRACE(X) ACE_TRACE_IMPL(X) +#endif /* (MIF_DT_CREATOR_NTRACE == 1) */ + +#endif /* MIF_DT_CREATOR_EXPORT_H */ + +// End of auto generated file. diff --git a/TAO/examples/RTScheduling/MIF_Scheduler/svc.conf.client b/TAO/examples/RTScheduling/MIF_Scheduler/svc.conf.client new file mode 100644 index 00000000000..8ecfba1b6ac --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_Scheduler/svc.conf.client @@ -0,0 +1,11 @@ +# -- E X A M P L E conf. file -- + +# Note! priority values are for Linux + +static RT_ORB_Loader "-ORBSchedPolicy SCHED_FIFO -ORBScopePolicy PROCESS -ORBPriorityMapping direct" + +static RTScheduler_Loader "" + +static MIF_DT_Creator "-GuidSeed 1 -DT_Count 4 -DT_Task -Importance 5 -Start_Time 0 -Iter 3 -Load 5 -JobName job_10 -DT_Task -Importance 8 -Start_Time 0 -Iter 3 -Load 50 -DT_Task -Importance 4 -Start_Time 0 -Iter 3 -Load 5 -JobName job_80 -DT_Task -Importance 10 -Start_Time 5 -Iter 3 -Load 50 -OutFile schedule_client.dat -LogFile log_file_client" + +#static MIF_DT_Creator "-GuidSeed 1 -DT_Count 2 -DT_Task -Importance 4 -Start_Time 0 -Iter 3 -Load 0 -DT_Task -Importance 10 -Start_Time 0 -Iter 3 -Load 0 -OutFile schedule_client.dat -LogFile log_file_client" diff --git a/TAO/examples/RTScheduling/MIF_Scheduler/svc.conf.server b/TAO/examples/RTScheduling/MIF_Scheduler/svc.conf.server new file mode 100644 index 00000000000..0c5429ea100 --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_Scheduler/svc.conf.server @@ -0,0 +1,10 @@ +# -- E X A M P L E conf. file -- + +# Note! priority values are for Linux + +static RT_ORB_Loader "-ORBSchedPolicy SCHED_OTHER -ORBScopePolicy PROCESS -ORBPriorityMapping direct" + +#static MIF_DT_Creator "-DT_Count 4 -DT_Task -Importance 4 -Start_Time 0 -Load 1000 -DT_Task -Importance 5 -Start_Time 20 -Load 100 -DT_Task -Importance 8 -Start_Time 60 -Load 1000 -DT_Task -Importance 10 -Start_Time 100 -Load 100" + +static MIF_DT_Creator "-GuidSeed 10 -POA_Count 1 -POA poa1 -PriorityModel SERVER_DECLARED 0 -ThreadPool 2 0 0 -Job_Count 2 -Job job_10 poa1 -Job job_80 poa1 -DT_Count 2 -DT_Task -Importance 2 -Start_Time 0 -Iter 15 -Load 50 -DT_Task -Importance 15 -Start_Time 0 -Iter 10 -Load 50 -OutFile schedule_server.dat -LogFile log_file_server" + diff --git a/TAO/examples/RTScheduling/MIF_Scheduler/test.cpp b/TAO/examples/RTScheduling/MIF_Scheduler/test.cpp new file mode 100644 index 00000000000..c8ca9947be4 --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_Scheduler/test.cpp @@ -0,0 +1,191 @@ +//$Id$ + +#include "test.h" +#include "tao/RTScheduling/RTScheduler_Manager.h" +#include "tao/ORB_Core.h" +#include "ace/Arg_Shifter.h" +//#include "MIF_DT_Creator.h" +#include "../Thread_Task.h" +#include "../Task_Stats.h" +#include "../Synch_i.h" + +DT_Test::DT_Test (void) +{ +} + +int +DT_Test::init (int argc, char *argv [] + ACE_ENV_ARG_DECL) +{ + orb_ = CORBA::ORB_init (argc, + argv, + "" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + dt_creator_->orb (orb_.in ()); + + CORBA::Object_ptr manager_obj = orb_->resolve_initial_references ("RTSchedulerManager" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + TAO_RTScheduler_Manager_var manager = TAO_RTScheduler_Manager::_narrow (manager_obj + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + + ACE_NEW_RETURN (scheduler_, + MIF_Scheduler (orb_.in ()), -1); + + manager->rtscheduler (scheduler_); + + CORBA::Object_var object = + orb_->resolve_initial_references ("RTScheduler_Current" + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + current_ = + RTScheduling::Current::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + return 0; +} + +void +DT_Test::run (int argc, char* argv [] + ACE_ENV_ARG_DECL) +{ + init (argc,argv + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + TASK_STATS::instance ()->init (this->dt_creator_->total_load ()); + if (this->dt_creator_->resolve_naming_service (ACE_ENV_SINGLE_ARG_PARAMETER) == -1) + return; + ACE_CHECK; + + this->dt_creator_->activate_root_poa (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + this->dt_creator_->activate_poa_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + this->dt_creator_->activate_job_list (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + this->dt_creator_->activate_schedule (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + DT_Creator* dt_creator = this->dt_creator_; + dt_creator->register_synch_obj (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "Registered Synch Object\n")); + + dt_creator_->create_distributable_threads (current_.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + orb_->destroy (); + + ACE_DEBUG ((LM_DEBUG, + "Test Terminating......\n")); +} + + +void +DT_Test::dt_creator (MIF_DT_Creator* dt_creator) +{ + this->dt_creator_ = dt_creator; +} + + +MIF_Scheduler* +DT_Test::scheduler (void) +{ + return this->scheduler_; +} +/* +int +DT_Test::activate_task (void) +{ + +long flags; + flags = THR_NEW_LWP | THR_JOINABLE; + flags |= + orb_->orb_core ()->orb_params ()->scope_policy () | + orb_->orb_core ()->orb_params ()->sched_policy (); + + if (this->activate (flags, + 1) == -1) + { + if (ACE_OS::last_error () == EPERM) + ACE_ERROR_RETURN ((LM_ERROR, + ACE_TEXT ("Insufficient privilege to run this test.\n")), + -1); + } + return 0; +} + +int +DT_Test::svc (void) +{ + ACE_TRY_NEW_ENV + { + dt_creator_->create_distributable_threads (current_.in () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Caught exception:"); + return -1; + } + ACE_ENDTRY; + + return 0; +} +*/ + +RTScheduling::Current_ptr +DT_Test::current (void) +{ + return this->current_.in (); +} + +int +main (int argc, char* argv []) +{ + ACE_TRY_NEW_ENV + { + ACE_Service_Config::static_svcs ()->insert (&ace_svc_desc_MIF_DT_Creator); + + ACE_DEBUG ((LM_DEBUG, + "%t\n")); + DT_TEST::instance ()->run (argc, argv + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Caught exception:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} + + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + +template class ACE_Singleton<DT_Test, TAO_SYNCH_MUTEX>; + +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + +#pragma instantiate ACE_Singleton<DT_Test, TAO_SYNCH_MUTEX> + +#endif /*ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/examples/RTScheduling/MIF_Scheduler/test.h b/TAO/examples/RTScheduling/MIF_Scheduler/test.h new file mode 100644 index 00000000000..63e1377e076 --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_Scheduler/test.h @@ -0,0 +1,57 @@ +//$Id$ +#ifndef TEST_H +#define TEST_H +#include "ace/pre.h" + + +#include "MIF_Scheduler.h" +#include "ace/Sched_Params.h" +#include "tao/ORB_Core.h" +#include "ace/Synch.h" +#include "ace/Task.h" +#include "MIF_DT_Creator.h" + +class Task_Stats; + +class DT_Test //:public ACE_Task <ACE_SYNCH> +{ + public: + + DT_Test (void); + + int init (int argc, char *argv [] + ACE_ENV_ARG_DECL_WITH_DEFAULTS); + + void run (int argc, char *argv [] + ACE_ENV_ARG_DECL_WITH_DEFAULTS); + + void dt_creator (MIF_DT_Creator* dt_creator); + + MIF_Scheduler* scheduler (void); + + int activate_task (void); + + RTScheduling::Current_ptr current (void); + +/* protected: */ +/* /// task svc */ +/* virtual int svc (void); */ + + + private: + /// = Policies + long thr_sched_policy_; + long thr_scope_policy_; + ACE_Sched_Params::Policy sched_policy_; + CORBA::ORB_var orb_; + int max_priority_; + int min_priority_; + RTScheduling::Current_var current_; + MIF_DT_Creator* dt_creator_; + MIF_Scheduler* scheduler_; +}; + +typedef ACE_Singleton <DT_Test, TAO_SYNCH_MUTEX> DT_TEST; + +#include "ace/post.h" +#endif /*TEST_H*/ diff --git a/TAO/examples/RTScheduling/MIF_Scheduling.pidl b/TAO/examples/RTScheduling/MIF_Scheduling.pidl new file mode 100644 index 00000000000..f855284edc7 --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_Scheduling.pidl @@ -0,0 +1,19 @@ +//$Id$ +#include <tao/RTScheduling/RTScheduler.pidl> +#include <tao/RTCORBA/RTCORBA.pidl> + +module MIF_Scheduling +{ + local interface SegmentSchedulingParameterPolicy + : CORBA::Policy + { + attribute short importance; + }; + + local interface MIF_Scheduler : RTScheduling::Scheduler + { + SegmentSchedulingParameterPolicy + create_segment_scheduling_parameter + (in short segment_importance); + }; +}; diff --git a/TAO/examples/RTScheduling/MIF_SchedulingC.cpp b/TAO/examples/RTScheduling/MIF_SchedulingC.cpp new file mode 100644 index 00000000000..adb9fd52867 --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_SchedulingC.cpp @@ -0,0 +1,638 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be/be_codegen.cpp:351 + + +#include "MIF_SchedulingC.h" +#include "tao/Stub.h" +#include "tao/Invocation.h" +#include "tao/PortableInterceptor.h" + +#if TAO_HAS_INTERCEPTORS == 1 +#include "tao/RequestInfo_Util.h" +#include "tao/ClientRequestInfo_i.h" +#include "tao/ClientInterceptorAdapter.h" +#endif /* TAO_HAS_INTERCEPTORS == 1 */ + + +#if defined (__BORLANDC__) +#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig +#endif /* __BORLANDC__ */ + +#if !defined (__ACE_INLINE__) +#include "MIF_SchedulingC.i" +#endif /* !defined INLINE */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:63 + +int MIF_Scheduling::SegmentSchedulingParameterPolicy::_tao_class_id = 0; + +MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr +MIF_Scheduling::tao_SegmentSchedulingParameterPolicy_life::tao_duplicate ( + SegmentSchedulingParameterPolicy_ptr p + ) +{ + return SegmentSchedulingParameterPolicy::_duplicate (p); +} + +void +MIF_Scheduling::tao_SegmentSchedulingParameterPolicy_life::tao_release ( + SegmentSchedulingParameterPolicy_ptr p + ) +{ + CORBA::release (p); +} + +MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr +MIF_Scheduling::tao_SegmentSchedulingParameterPolicy_life::tao_nil ( + void + ) +{ + return SegmentSchedulingParameterPolicy::_nil (); +} + +CORBA::Boolean +MIF_Scheduling::tao_SegmentSchedulingParameterPolicy_life::tao_marshal ( + SegmentSchedulingParameterPolicy_ptr p, + TAO_OutputCDR &cdr + ) +{ + return p->marshal (cdr); +} + +MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr +MIF_Scheduling::tao_SegmentSchedulingParameterPolicy_cast::tao_narrow ( + CORBA::Object *p + ACE_ENV_ARG_DECL + ) +{ + return SegmentSchedulingParameterPolicy::_narrow (p ACE_ENV_ARG_PARAMETER); +} + +CORBA::Object * +MIF_Scheduling::tao_SegmentSchedulingParameterPolicy_cast::tao_upcast ( + void *src + ) +{ + SegmentSchedulingParameterPolicy **tmp = + ACE_static_cast (SegmentSchedulingParameterPolicy **, src); + return *tmp; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + template class + TAO_Objref_Var_T< + MIF_Scheduling::SegmentSchedulingParameterPolicy, + MIF_Scheduling::tao_SegmentSchedulingParameterPolicy_life + >; + template class + TAO_Objref_Out_T< + MIF_Scheduling::SegmentSchedulingParameterPolicy, + MIF_Scheduling::tao_SegmentSchedulingParameterPolicy_life + >; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate \ + TAO_Objref_Var_T< \ + MIF_Scheduling::SegmentSchedulingParameterPolicy, \ + MIF_Scheduling::tao_SegmentSchedulingParameterPolicy_life \ + > +# pragma instantiate \ + TAO_Objref_Out_T< \ + MIF_Scheduling::SegmentSchedulingParameterPolicy, \ + MIF_Scheduling::tao_SegmentSchedulingParameterPolicy_life \ + > +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:245 + +MIF_Scheduling::SegmentSchedulingParameterPolicy::SegmentSchedulingParameterPolicy (void) +{} + +MIF_Scheduling::SegmentSchedulingParameterPolicy::~SegmentSchedulingParameterPolicy (void) +{} + +void +MIF_Scheduling::SegmentSchedulingParameterPolicy::_tao_any_destructor (void *_tao_void_pointer) +{ + SegmentSchedulingParameterPolicy *tmp = ACE_static_cast (SegmentSchedulingParameterPolicy *, _tao_void_pointer); + CORBA::release (tmp); +} + +MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr +MIF_Scheduling::SegmentSchedulingParameterPolicy::_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) +{ + return SegmentSchedulingParameterPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER); +} + +MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr +MIF_Scheduling::SegmentSchedulingParameterPolicy::_unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if (CORBA::is_nil (obj)) + { + return SegmentSchedulingParameterPolicy::_nil (); + } + + return + ACE_reinterpret_cast ( + SegmentSchedulingParameterPolicy_ptr, + obj->_tao_QueryInterface ( + ACE_reinterpret_cast ( + ptrdiff_t, + &SegmentSchedulingParameterPolicy::_tao_class_id + ) + ) + ); +} + +MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr +MIF_Scheduling::SegmentSchedulingParameterPolicy::_duplicate (SegmentSchedulingParameterPolicy_ptr obj) +{ + if (! CORBA::is_nil (obj)) + { + obj->_add_ref (); + } + + return obj; +} + +void *MIF_Scheduling::SegmentSchedulingParameterPolicy::_tao_QueryInterface (ptrdiff_t type) +{ + void *retv = 0; + + if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &ACE_NESTED_CLASS (::MIF_Scheduling, SegmentSchedulingParameterPolicy)::_tao_class_id) + ) + { + retv = ACE_reinterpret_cast (void*, this); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &::CORBA::Policy::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast ( + CORBA::Policy_ptr, + this + ) + ); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &CORBA::Object::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast (CORBA::Object_ptr, this) + ); + } + + if (retv != 0) + { + this->_add_ref (); + } + + return retv; +} + +const char* MIF_Scheduling::SegmentSchedulingParameterPolicy::_interface_repository_id (void) const +{ + return "IDL:MIF_Scheduling/SegmentSchedulingParameterPolicy:1.0"; +} + +CORBA::Boolean +MIF_Scheduling::SegmentSchedulingParameterPolicy::marshal (TAO_OutputCDR &) +{ + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_MIF_Scheduling_SegmentSchedulingParameterPolicy[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 56, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x4d49465f), + ACE_NTOHL (0x53636865), + ACE_NTOHL (0x64756c69), + ACE_NTOHL (0x6e672f53), + ACE_NTOHL (0x65676d65), + ACE_NTOHL (0x6e745363), + ACE_NTOHL (0x68656475), + ACE_NTOHL (0x6c696e67), + ACE_NTOHL (0x50617261), + ACE_NTOHL (0x6d657465), + ACE_NTOHL (0x72506f6c), + ACE_NTOHL (0x6963793a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:MIF_Scheduling/SegmentSchedulingParameterPolicy:1.0 + 33, + ACE_NTOHL (0x5365676d), + ACE_NTOHL (0x656e7453), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c696e), + ACE_NTOHL (0x67506172), + ACE_NTOHL (0x616d6574), + ACE_NTOHL (0x6572506f), + ACE_NTOHL (0x6c696379), + ACE_NTOHL (0x0), // name = SegmentSchedulingParameterPolicy + }; + +static CORBA::TypeCode _tc_TAO_tc_MIF_Scheduling_SegmentSchedulingParameterPolicy ( + CORBA::tk_objref, + sizeof (_oc_MIF_Scheduling_SegmentSchedulingParameterPolicy), + (char *) &_oc_MIF_Scheduling_SegmentSchedulingParameterPolicy, + 0, + sizeof (MIF_Scheduling::SegmentSchedulingParameterPolicy) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (MIF_Scheduling) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_SegmentSchedulingParameterPolicy, + &_tc_TAO_tc_MIF_Scheduling_SegmentSchedulingParameterPolicy + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:63 + +int MIF_Scheduling::MIF_Scheduler::_tao_class_id = 0; + +MIF_Scheduling::MIF_Scheduler_ptr +MIF_Scheduling::tao_MIF_Scheduler_life::tao_duplicate ( + MIF_Scheduler_ptr p + ) +{ + return MIF_Scheduler::_duplicate (p); +} + +void +MIF_Scheduling::tao_MIF_Scheduler_life::tao_release ( + MIF_Scheduler_ptr p + ) +{ + CORBA::release (p); +} + +MIF_Scheduling::MIF_Scheduler_ptr +MIF_Scheduling::tao_MIF_Scheduler_life::tao_nil ( + void + ) +{ + return MIF_Scheduler::_nil (); +} + +CORBA::Boolean +MIF_Scheduling::tao_MIF_Scheduler_life::tao_marshal ( + MIF_Scheduler_ptr p, + TAO_OutputCDR &cdr + ) +{ + return p->marshal (cdr); +} + +MIF_Scheduling::MIF_Scheduler_ptr +MIF_Scheduling::tao_MIF_Scheduler_cast::tao_narrow ( + CORBA::Object *p + ACE_ENV_ARG_DECL + ) +{ + return MIF_Scheduler::_narrow (p ACE_ENV_ARG_PARAMETER); +} + +CORBA::Object * +MIF_Scheduling::tao_MIF_Scheduler_cast::tao_upcast ( + void *src + ) +{ + MIF_Scheduler **tmp = + ACE_static_cast (MIF_Scheduler **, src); + return *tmp; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + template class + TAO_Objref_Var_T< + MIF_Scheduling::MIF_Scheduler, + MIF_Scheduling::tao_MIF_Scheduler_life + >; + template class + TAO_Objref_Out_T< + MIF_Scheduling::MIF_Scheduler, + MIF_Scheduling::tao_MIF_Scheduler_life + >; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate \ + TAO_Objref_Var_T< \ + MIF_Scheduling::MIF_Scheduler, \ + MIF_Scheduling::tao_MIF_Scheduler_life \ + > +# pragma instantiate \ + TAO_Objref_Out_T< \ + MIF_Scheduling::MIF_Scheduler, \ + MIF_Scheduling::tao_MIF_Scheduler_life \ + > +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_cs.cpp:245 + +MIF_Scheduling::MIF_Scheduler::MIF_Scheduler (void) +{} + +MIF_Scheduling::MIF_Scheduler::~MIF_Scheduler (void) +{} + +void +MIF_Scheduling::MIF_Scheduler::_tao_any_destructor (void *_tao_void_pointer) +{ + MIF_Scheduler *tmp = ACE_static_cast (MIF_Scheduler *, _tao_void_pointer); + CORBA::release (tmp); +} + +MIF_Scheduling::MIF_Scheduler_ptr +MIF_Scheduling::MIF_Scheduler::_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL + ) +{ + return MIF_Scheduler::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER); +} + +MIF_Scheduling::MIF_Scheduler_ptr +MIF_Scheduling::MIF_Scheduler::_unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_NOT_USED + ) +{ + if (CORBA::is_nil (obj)) + { + return MIF_Scheduler::_nil (); + } + + return + ACE_reinterpret_cast ( + MIF_Scheduler_ptr, + obj->_tao_QueryInterface ( + ACE_reinterpret_cast ( + ptrdiff_t, + &MIF_Scheduler::_tao_class_id + ) + ) + ); +} + +MIF_Scheduling::MIF_Scheduler_ptr +MIF_Scheduling::MIF_Scheduler::_duplicate (MIF_Scheduler_ptr obj) +{ + if (! CORBA::is_nil (obj)) + { + obj->_add_ref (); + } + + return obj; +} + +void *MIF_Scheduling::MIF_Scheduler::_tao_QueryInterface (ptrdiff_t type) +{ + void *retv = 0; + + if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &ACE_NESTED_CLASS (::MIF_Scheduling, MIF_Scheduler)::_tao_class_id) + ) + { + retv = ACE_reinterpret_cast (void*, this); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &::RTScheduling::Scheduler::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast ( + RTScheduling::Scheduler_ptr, + this + ) + ); + } + else if (type == ACE_reinterpret_cast ( + ptrdiff_t, + &CORBA::Object::_tao_class_id) + ) + { + retv = + ACE_reinterpret_cast ( + void *, + ACE_static_cast (CORBA::Object_ptr, this) + ); + } + + if (retv != 0) + { + this->_add_ref (); + } + + return retv; +} + +const char* MIF_Scheduling::MIF_Scheduler::_interface_repository_id (void) const +{ + return "IDL:MIF_Scheduling/MIF_Scheduler:1.0"; +} + +CORBA::Boolean +MIF_Scheduling::MIF_Scheduler::marshal (TAO_OutputCDR &) +{ + return 0; +} + +// TAO_IDL - Generated from +// be/be_visitor_typecode/typecode_defn.cpp:284 + +static const CORBA::Long _oc_MIF_Scheduling_MIF_Scheduler[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 37, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x4d49465f), + ACE_NTOHL (0x53636865), + ACE_NTOHL (0x64756c69), + ACE_NTOHL (0x6e672f4d), + ACE_NTOHL (0x49465f53), + ACE_NTOHL (0x63686564), + ACE_NTOHL (0x756c6572), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:MIF_Scheduling/MIF_Scheduler:1.0 + 14, + ACE_NTOHL (0x4d49465f), + ACE_NTOHL (0x53636865), + ACE_NTOHL (0x64756c65), + ACE_NTOHL (0x72000000), // name = MIF_Scheduler + }; + +static CORBA::TypeCode _tc_TAO_tc_MIF_Scheduling_MIF_Scheduler ( + CORBA::tk_objref, + sizeof (_oc_MIF_Scheduling_MIF_Scheduler), + (char *) &_oc_MIF_Scheduling_MIF_Scheduler, + 0, + sizeof (MIF_Scheduling::MIF_Scheduler) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (MIF_Scheduling) +TAO_NAMESPACE_DEFINE ( + ::CORBA::TypeCode_ptr, + _tc_MIF_Scheduler, + &_tc_TAO_tc_MIF_Scheduling_MIF_Scheduler + ) +TAO_NAMESPACE_END + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_cs.cpp:50 + +// Copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr _tao_elem + ) +{ + MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr _tao_objptr = + MIF_Scheduling::SegmentSchedulingParameterPolicy::_duplicate (_tao_elem); + _tao_any <<= &_tao_objptr; +} + +// Non-copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr *_tao_elem + ) +{ + TAO::Any_Impl_T<MIF_Scheduling::SegmentSchedulingParameterPolicy>::insert ( + _tao_any, + MIF_Scheduling::SegmentSchedulingParameterPolicy::_tao_any_destructor, + MIF_Scheduling::_tc_SegmentSchedulingParameterPolicy, + *_tao_elem + ); +} + +CORBA::Boolean +operator>>= ( + const CORBA::Any &_tao_any, + MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr &_tao_elem + ) +{ + return + TAO::Any_Impl_T<MIF_Scheduling::SegmentSchedulingParameterPolicy>::extract ( + _tao_any, + MIF_Scheduling::SegmentSchedulingParameterPolicy::_tao_any_destructor, + MIF_Scheduling::_tc_SegmentSchedulingParameterPolicy, + _tao_elem + ); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO::Any_Impl_T<MIF_Scheduling::SegmentSchedulingParameterPolicy>; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate TAO::Any_Impl_T<MIF_Scheduling::SegmentSchedulingParameterPolicy> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_cs.cpp:50 + +// Copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + MIF_Scheduling::MIF_Scheduler_ptr _tao_elem + ) +{ + MIF_Scheduling::MIF_Scheduler_ptr _tao_objptr = + MIF_Scheduling::MIF_Scheduler::_duplicate (_tao_elem); + _tao_any <<= &_tao_objptr; +} + +// Non-copying insertion. +void +operator<<= ( + CORBA::Any &_tao_any, + MIF_Scheduling::MIF_Scheduler_ptr *_tao_elem + ) +{ + TAO::Any_Impl_T<MIF_Scheduling::MIF_Scheduler>::insert ( + _tao_any, + MIF_Scheduling::MIF_Scheduler::_tao_any_destructor, + MIF_Scheduling::_tc_MIF_Scheduler, + *_tao_elem + ); +} + +CORBA::Boolean +operator>>= ( + const CORBA::Any &_tao_any, + MIF_Scheduling::MIF_Scheduler_ptr &_tao_elem + ) +{ + return + TAO::Any_Impl_T<MIF_Scheduling::MIF_Scheduler>::extract ( + _tao_any, + MIF_Scheduling::MIF_Scheduler::_tao_any_destructor, + MIF_Scheduling::_tc_MIF_Scheduler, + _tao_elem + ); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO::Any_Impl_T<MIF_Scheduling::MIF_Scheduler>; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +# pragma instantiate TAO::Any_Impl_T<MIF_Scheduling::MIF_Scheduler> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + diff --git a/TAO/examples/RTScheduling/MIF_SchedulingC.h b/TAO/examples/RTScheduling/MIF_SchedulingC.h new file mode 100644 index 00000000000..fdda5d03a4b --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_SchedulingC.h @@ -0,0 +1,358 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// TAO_IDL - Generated from +// be/be_codegen.cpp:151 + +#ifndef _TAO_IDL_____MIF_SCHEDULINGC_H_ +#define _TAO_IDL_____MIF_SCHEDULINGC_H_ + + +#include "tao/corba.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + + +#include "tao/RTScheduling/RTSchedulerC.h" +#include "tao/RTCORBA/RTCORBAC.h" + +#if defined (TAO_EXPORT_MACRO) +#undef TAO_EXPORT_MACRO +#endif +#define TAO_EXPORT_MACRO + +#if defined (TAO_EXPORT_NESTED_CLASSES) +# if defined (TAO_EXPORT_NESTED_MACRO) +# undef TAO_EXPORT_NESTED_MACRO +# endif /* defined (TAO_EXPORT_NESTED_MACRO) */ +# define TAO_EXPORT_NESTED_MACRO +#endif /* TAO_EXPORT_NESTED_CLASSES */ + +#if defined(_MSC_VER) +#if (_MSC_VER >= 1200) +#pragma warning(push) +#endif /* _MSC_VER >= 1200 */ +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option push -w-rvl -w-rch -w-ccc -w-inl +#endif /* __BORLANDC__ */ + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:48 + +TAO_NAMESPACE MIF_Scheduling +{ + + // TAO_IDL - Generated from + // be/be_interface.cpp:584 + +#if !defined (_MIF_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY__ODDS_N_ENDS_CH_) +#define _MIF_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY__ODDS_N_ENDS_CH_ + + class SegmentSchedulingParameterPolicy; + typedef SegmentSchedulingParameterPolicy *SegmentSchedulingParameterPolicy_ptr; + struct tao_SegmentSchedulingParameterPolicy_life; + + typedef + TAO_Objref_Var_T< + SegmentSchedulingParameterPolicy, + tao_SegmentSchedulingParameterPolicy_life + > + SegmentSchedulingParameterPolicy_var; + + typedef + TAO_Objref_Out_T< + SegmentSchedulingParameterPolicy, + tao_SegmentSchedulingParameterPolicy_life + > + SegmentSchedulingParameterPolicy_out; + + struct tao_SegmentSchedulingParameterPolicy_life + { + static SegmentSchedulingParameterPolicy_ptr tao_duplicate (SegmentSchedulingParameterPolicy_ptr); + static void tao_release (SegmentSchedulingParameterPolicy_ptr); + static SegmentSchedulingParameterPolicy_ptr tao_nil (void); + static CORBA::Boolean tao_marshal ( + SegmentSchedulingParameterPolicy_ptr, + TAO_OutputCDR & + ); + }; + + struct tao_SegmentSchedulingParameterPolicy_cast + { + static SegmentSchedulingParameterPolicy_ptr tao_narrow ( + CORBA::Object_ptr + ACE_ENV_ARG_DECL + ); + static CORBA::Object_ptr tao_upcast (void *); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:53 + +#if !defined (_MIF_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY_CH_) +#define _MIF_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY_CH_ + + class SegmentSchedulingParameterPolicy + : public virtual CORBA::Policy + { + public: + typedef SegmentSchedulingParameterPolicy_ptr _ptr_type; + typedef SegmentSchedulingParameterPolicy_var _var_type; + static int _tao_class_id; + + // The static operations. + static SegmentSchedulingParameterPolicy_ptr _duplicate (SegmentSchedulingParameterPolicy_ptr obj); + + static SegmentSchedulingParameterPolicy_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static SegmentSchedulingParameterPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static SegmentSchedulingParameterPolicy_ptr _nil (void) + { + return (SegmentSchedulingParameterPolicy_ptr)0; + } + + static void _tao_any_destructor (void *); + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual CORBA::Short importance ( + + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual void importance ( + CORBA::Short importance + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:210 + + virtual void *_tao_QueryInterface (ptrdiff_t type); + + virtual const char* _interface_repository_id (void) const; + virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr); + + protected: + SegmentSchedulingParameterPolicy (void); + virtual ~SegmentSchedulingParameterPolicy (void); + + private: + SegmentSchedulingParameterPolicy (const SegmentSchedulingParameterPolicy &); + void operator= (const SegmentSchedulingParameterPolicy &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_SegmentSchedulingParameterPolicy; + + // TAO_IDL - Generated from + // be/be_interface.cpp:584 + +#if !defined (_MIF_SCHEDULING_MIF_SCHEDULER__ODDS_N_ENDS_CH_) +#define _MIF_SCHEDULING_MIF_SCHEDULER__ODDS_N_ENDS_CH_ + + class MIF_Scheduler; + typedef MIF_Scheduler *MIF_Scheduler_ptr; + struct tao_MIF_Scheduler_life; + + typedef + TAO_Objref_Var_T< + MIF_Scheduler, + tao_MIF_Scheduler_life + > + MIF_Scheduler_var; + + typedef + TAO_Objref_Out_T< + MIF_Scheduler, + tao_MIF_Scheduler_life + > + MIF_Scheduler_out; + + struct tao_MIF_Scheduler_life + { + static MIF_Scheduler_ptr tao_duplicate (MIF_Scheduler_ptr); + static void tao_release (MIF_Scheduler_ptr); + static MIF_Scheduler_ptr tao_nil (void); + static CORBA::Boolean tao_marshal ( + MIF_Scheduler_ptr, + TAO_OutputCDR & + ); + }; + + struct tao_MIF_Scheduler_cast + { + static MIF_Scheduler_ptr tao_narrow ( + CORBA::Object_ptr + ACE_ENV_ARG_DECL + ); + static CORBA::Object_ptr tao_upcast (void *); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:53 + +#if !defined (_MIF_SCHEDULING_MIF_SCHEDULER_CH_) +#define _MIF_SCHEDULING_MIF_SCHEDULER_CH_ + + class MIF_Scheduler + : public virtual RTScheduling::Scheduler + { + public: + typedef MIF_Scheduler_ptr _ptr_type; + typedef MIF_Scheduler_var _var_type; + static int _tao_class_id; + + // The static operations. + static MIF_Scheduler_ptr _duplicate (MIF_Scheduler_ptr obj); + + static MIF_Scheduler_ptr _narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static MIF_Scheduler_ptr _unchecked_narrow ( + CORBA::Object_ptr obj + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + + static MIF_Scheduler_ptr _nil (void) + { + return (MIF_Scheduler_ptr)0; + } + + static void _tao_any_destructor (void *); + + // TAO_IDL - Generated from + // be/be_visitor_operation/operation_ch.cpp:46 + + virtual ::MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr create_segment_scheduling_parameter ( + CORBA::Short segment_importance + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + + // TAO_IDL - Generated from + // be/be_visitor_interface/interface_ch.cpp:210 + + virtual void *_tao_QueryInterface (ptrdiff_t type); + + virtual const char* _interface_repository_id (void) const; + virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr); + + protected: + MIF_Scheduler (void); + virtual ~MIF_Scheduler (void); + + private: + MIF_Scheduler (const MIF_Scheduler &); + void operator= (const MIF_Scheduler &); + }; + +#endif /* end #if !defined */ + + // TAO_IDL - Generated from + // be/be_visitor_typecode/typecode_decl.cpp:44 + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_MIF_Scheduler; + +// TAO_IDL - Generated from +// be/be_visitor_module/module_ch.cpp:67 + +} +TAO_NAMESPACE_CLOSE // module MIF_Scheduling + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr); // copying + void operator<<= (CORBA::Any &, MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr *); // non-copying + CORBA::Boolean operator>>= (const CORBA::Any &, MIF_Scheduling::SegmentSchedulingParameterPolicy_ptr &); + +// TAO_IDL - Generated from +// be/be_visitor_interface/any_op_ch.cpp:52 + + void operator<<= (CORBA::Any &, MIF_Scheduling::MIF_Scheduler_ptr); // copying + void operator<<= (CORBA::Any &, MIF_Scheduling::MIF_Scheduler_ptr *); // non-copying + CORBA::Boolean operator>>= (const CORBA::Any &, MIF_Scheduling::MIF_Scheduler_ptr &); + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:48 + +#ifndef __ACE_INLINE__ + +// TAO_IDL - Generated from +// be/be_visitor_root/cdr_op.cpp:64 + +#endif /* __ACE_INLINE__ */ + +// TAO_IDL - Generated from +// be/be_codegen.cpp:1055 + +#if defined (__ACE_INLINE__) +#include "MIF_SchedulingC.i" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option pop +#endif /* __BORLANDC__ */ + +#endif /* ifndef */ + diff --git a/TAO/examples/RTScheduling/MIF_SchedulingC.i b/TAO/examples/RTScheduling/MIF_SchedulingC.i new file mode 100644 index 00000000000..3e459a756eb --- /dev/null +++ b/TAO/examples/RTScheduling/MIF_SchedulingC.i @@ -0,0 +1,98 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// and +// Institute for Software Integrated Systems +// Vanderbilt University +// Nashville, TN +// USA +// http://www.isis.vanderbilt.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_ci.cpp:63 + +#if !defined (_MIF_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY___CI_) +#define _MIF_SCHEDULING_SEGMENTSCHEDULINGPARAMETERPOLICY___CI_ + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T<MIF_Scheduling::SegmentSchedulingParameterPolicy>::to_object ( + CORBA::Object_ptr &_tao_elem + ) const +{ + _tao_elem = CORBA::Object::_duplicate (this->value_); + return 1; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T<MIF_Scheduling::SegmentSchedulingParameterPolicy>::marshal_value (TAO_OutputCDR &) +{ + return 0; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T<MIF_Scheduling::SegmentSchedulingParameterPolicy>::demarshal_value (TAO_InputCDR &) +{ + return 0; +} + +#endif /* end #if !defined */ + +// TAO_IDL - Generated from +// be/be_visitor_interface/interface_ci.cpp:63 + +#if !defined (_MIF_SCHEDULING_MIF_SCHEDULER___CI_) +#define _MIF_SCHEDULING_MIF_SCHEDULER___CI_ + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T<MIF_Scheduling::MIF_Scheduler>::to_object ( + CORBA::Object_ptr &_tao_elem + ) const +{ + _tao_elem = CORBA::Object::_duplicate (this->value_); + return 1; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T<MIF_Scheduling::MIF_Scheduler>::marshal_value (TAO_OutputCDR &) +{ + return 0; +} + +template<> +ACE_INLINE +CORBA::Boolean +TAO::Any_Impl_T<MIF_Scheduling::MIF_Scheduler>::demarshal_value (TAO_InputCDR &) +{ + return 0; +} + +#endif /* end #if !defined */ + diff --git a/TAO/examples/RTScheduling/Makefile b/TAO/examples/RTScheduling/Makefile new file mode 100644 index 00000000000..e3533728a62 --- /dev/null +++ b/TAO/examples/RTScheduling/Makefile @@ -0,0 +1,30 @@ +#---------------------------------------------------------------------------- +# +# $Id$ +# +# Makefile for RTScheduling examples +# +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +DIRS = \ + Fixed_Priority_Scheduler \ + MIF_Scheduler + +ifndef TAO_ROOT + TAO_ROOT = $(ACE_ROOT)/TAO +endif + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(TAO_ROOT)/rules.tao.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nolocal.GNU diff --git a/TAO/examples/RTScheduling/POA_Holder.cpp b/TAO/examples/RTScheduling/POA_Holder.cpp new file mode 100644 index 00000000000..c30f050987d --- /dev/null +++ b/TAO/examples/RTScheduling/POA_Holder.cpp @@ -0,0 +1,313 @@ +//$Id$ +#include "POA_Holder.h" +#include "ace/Arg_Shifter.h" +#include "tao/debug.h" + +POA_Holder::POA_Holder (void) + :priority_model_ (RTCORBA::CLIENT_PROPAGATED), + server_priority_ (0), + thread_pool_ (0) + { + } + +int +POA_Holder::init (ACE_Arg_Shifter& arg_shifter) +{ + ACE_DEBUG ((LM_DEBUG, + "Init POA\n")); + + const ACE_TCHAR *current_arg = 0; + + POA_name_ = arg_shifter.get_current (); // Read the name of the POA + arg_shifter.consume_arg (); + + while (arg_shifter.is_anything_left ()) + { + if ((current_arg = arg_shifter.get_the_parameter ("-PriorityModel"))) + { + if (arg_shifter.cur_arg_strncasecmp ("CLIENT") == 0) + priority_model_ = RTCORBA::CLIENT_PROPAGATED; + else + priority_model_ = RTCORBA::SERVER_DECLARED; + arg_shifter.consume_arg (); + + server_priority_ = ACE_OS::atoi (current_arg); + arg_shifter.consume_arg (); + } + else if ((current_arg = arg_shifter.get_the_parameter ("-Lanes"))) + { + int lanecount = ACE_OS::atoi (current_arg); + lanes_.length (lanecount); + arg_shifter.consume_arg (); + + int l_index = 0; + //parse lane values ... + while (arg_shifter.is_anything_left ()) + { + if (arg_shifter.cur_arg_strncasecmp ("-Lane") == 0) + { + arg_shifter.consume_arg (); + + // read priority + lanes_[l_index].lane_priority = ACE_OS::atoi (arg_shifter.get_current ()); + arg_shifter.consume_arg (); + + // static thread count + lanes_[l_index].static_threads = ACE_OS::atoi (arg_shifter.get_current ()); + arg_shifter.consume_arg (); + + // dynamic thread count + lanes_[l_index].dynamic_threads = ACE_OS::atoi (arg_shifter.get_current ()); + arg_shifter.consume_arg (); + + //if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "lane parsed - %d, %d, %d\n", + lanes_[l_index].lane_priority, lanes_[l_index].static_threads, lanes_[l_index].dynamic_threads)); + l_index++; + } + else + break; + } /* while -- lane values */ + + } /* if -Lanes */ + else if (arg_shifter.cur_arg_strncasecmp ("-ThreadPool") == 0) + { + ACE_DEBUG ((LM_DEBUG, + "Thread Pool\n")); + + arg_shifter.consume_arg (); + thread_pool_ = 1; + // read priority + tp_static_threads_ = ACE_OS::atoi (arg_shifter.get_current ()); + arg_shifter.consume_arg (); + + tp_dynamic_threads_ = ACE_OS::atoi (arg_shifter.get_current ()); + arg_shifter.consume_arg (); + + tp_priority_ = ACE_OS::atoi (arg_shifter.get_current ()); + arg_shifter.consume_arg (); + ACE_DEBUG ((LM_DEBUG, + "Thread Pool Initialized\n")); + + } + else if ((current_arg = arg_shifter.get_the_parameter ("-Bands"))) + { + ACE_DEBUG ((LM_DEBUG, + "Initializing Bands\n")); + + int bandcount = ACE_OS::atoi (current_arg); + bands_.length (bandcount); + arg_shifter.consume_arg (); + + int b_index = 0; + //parse band values ... + while (arg_shifter.is_anything_left ()) + { + if (arg_shifter.cur_arg_strncasecmp ("-Band") == 0) + { + arg_shifter.consume_arg (); + + // read low + bands_[b_index].low = ACE_OS::atoi (arg_shifter.get_current ()); + arg_shifter.consume_arg (); + + // read high + bands_[b_index].high = ACE_OS::atoi (arg_shifter.get_current ()); + arg_shifter.consume_arg (); + + //if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "band parsed - %d, %d \n", + bands_[b_index].low, bands_[b_index].high)); + b_index++; + } + else + break; + } /* while -- Band values */ + ACE_DEBUG ((LM_DEBUG, + "Bands Initialized\n")); + + } /* if -Bands */ + else // something else is showing up ... + { + ACE_DEBUG ((LM_DEBUG, + "Finish Init POA\n")); + + return 0; + } + } + ACE_DEBUG ((LM_DEBUG, + "Finish Init POA\n")); + return 0; +} + +void +POA_Holder::activate (RTCORBA::RTORB_ptr rt_orb, PortableServer::POA_ptr parent_poa ACE_ENV_ARG_DECL) +{ + CORBA::Policy_var priority_model_policy; + CORBA::Policy_var lanes_policy; + CORBA::Policy_var bands_policy; + CORBA::Policy_var thread_pool_policy; + + // Create a priority model policy. + priority_model_policy = + rt_orb->create_priority_model_policy (priority_model_, + server_priority_ + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + if (lanes_.length () != 0) + { + // Create a thread-pool. + CORBA::ULong stacksize = 0; + CORBA::Boolean allow_request_buffering = 0; + CORBA::ULong max_buffered_requests = 0; + CORBA::ULong max_request_buffer_size = 0; + CORBA::Boolean allow_borrowing = 0; + + // Create the thread-pool. + RTCORBA::ThreadpoolId threadpool_id = + rt_orb->create_threadpool_with_lanes (stacksize, + lanes_, + allow_borrowing, + allow_request_buffering, + max_buffered_requests, + max_request_buffer_size + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + // Create a thread-pool policy. + lanes_policy = + rt_orb->create_threadpool_policy (threadpool_id + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "Activated Lanes\n")); + + } + + if (thread_pool_) + { + CORBA::ULong stacksize = 0; + CORBA::Boolean allow_request_buffering = 0; + CORBA::ULong max_buffered_requests = 0; + CORBA::ULong max_request_buffer_size = 0; + + RTCORBA::ThreadpoolId threadpool_id_1 = + rt_orb->create_threadpool (stacksize, + tp_static_threads_, + tp_dynamic_threads_, + tp_priority_, + allow_request_buffering, + max_buffered_requests, + max_request_buffer_size + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + + thread_pool_policy = rt_orb->create_threadpool_policy (threadpool_id_1 + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + ACE_DEBUG ((LM_DEBUG, + "Activated thread pool\n")); + + + } + + if (bands_.length () != 0) + { + // Create a bands policy. + bands_policy = + rt_orb->create_priority_banded_connection_policy (this->bands_ + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + ACE_DEBUG ((LM_DEBUG, + "Activated Bands\n")); + + } + + CORBA::PolicyList poa_policy_list; + + if (lanes_.length () == 0 && bands_.length () == 0) + { + if (thread_pool_) + { + poa_policy_list.length (2); + poa_policy_list[0] = priority_model_policy; + poa_policy_list[1] = thread_pool_policy; + } + else + { + poa_policy_list.length (1); + poa_policy_list[0] = priority_model_policy; + } + } + else if (lanes_.length () != 0 && bands_.length () == 0) + { + if (thread_pool_) + { + poa_policy_list.length (3); + poa_policy_list[0] = priority_model_policy; + poa_policy_list[1] = lanes_policy; + poa_policy_list[2] = thread_pool_policy; + } + else + { + poa_policy_list.length (2); + poa_policy_list[0] = priority_model_policy; + poa_policy_list[1] = lanes_policy; + } + } + else if (lanes_.length () == 0 && bands_.length () != 0) + { + if (thread_pool_) + { + poa_policy_list.length (3); + poa_policy_list[0] = priority_model_policy; + poa_policy_list[1] = bands_policy; + poa_policy_list[2] = thread_pool_policy; + } + else + { + poa_policy_list.length (2); + poa_policy_list[0] = priority_model_policy; + poa_policy_list[1] = bands_policy; + } + } + else + { + if (thread_pool_) + { + poa_policy_list.length (4); + poa_policy_list[0] = priority_model_policy; + poa_policy_list[1] = lanes_policy; + poa_policy_list[2] = bands_policy; + poa_policy_list[3] = thread_pool_policy; + } + else + { + poa_policy_list.length (3); + poa_policy_list[0] = priority_model_policy; + poa_policy_list[1] = lanes_policy; + poa_policy_list[2] = bands_policy; + } + } + + ACE_DEBUG ((LM_DEBUG, + "Initialized POA Policy\n")); + + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "creating POA %s\n", POA_name_.c_str ())); + + // Get the POA Manager. + PortableServer::POAManager_var poa_manager = + parent_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + parent_poa->create_POA (POA_name_.c_str (), + poa_manager.in (), + poa_policy_list + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} diff --git a/TAO/examples/RTScheduling/POA_Holder.h b/TAO/examples/RTScheduling/POA_Holder.h new file mode 100644 index 00000000000..2f1b0515ac8 --- /dev/null +++ b/TAO/examples/RTScheduling/POA_Holder.h @@ -0,0 +1,57 @@ +//$Id$ + +/* -*- C++ -*- */ +//============================================================================= +/** + * @file POA_Holder.h + * + * $Id$ + * + * A helper to hold options for creating a POA. + * + * @author Pradeep Gore <pradeep@cs.wustl.edu> + */ +//============================================================================= +#ifndef POA_HOLDER_H +#define POA_HOLDER_H + +#include "tao/RTCORBA/RTCORBA.h" +#include "tao/PortableServer/PortableServer.h" +//#include "activity_export.h" + +class ACE_Arg_Shifter; + +/** + * @class POA_Holder + * + * @brief An options holder for parameters to creating a poa. + * + */ +class POA_Holder +{ +public: + /// Constructor + POA_Holder (void); + + /// The arg_shifter options are read in the following manner: + ///-POA <name> -PriorityModel <CLIENT|SERVER> <priority> -Lanes <count> (-Lane <priority> ,<static_threads> <dynamic_threads>)* -Bands <count> (-Band <low> <high>)* + int init (ACE_Arg_Shifter& arg_shifter); + + /// Activate the new POA using the parameters initialized before. + void activate (RTCORBA::RTORB_ptr rt_orb, PortableServer::POA_ptr parent_poa + ACE_ENV_ARG_DECL); + + protected: + /// = POA create options. + ACE_CString POA_name_; + RTCORBA::PriorityModel priority_model_; + RTCORBA::Priority server_priority_; + RTCORBA::ThreadpoolLanes lanes_; + RTCORBA::PriorityBands bands_; + int thread_pool_; + CORBA::ULong tp_static_threads_; + CORBA::ULong tp_dynamic_threads_; + RTCORBA::Priority tp_priority_; +}; + +#endif /* POA_HOLDER_H */ diff --git a/TAO/examples/RTScheduling/README b/TAO/examples/RTScheduling/README new file mode 100644 index 00000000000..a60f9938819 --- /dev/null +++ b/TAO/examples/RTScheduling/README @@ -0,0 +1,27 @@ +Pluggable Schedulers +===================== + +The Real-Time CORBA 2.0 specification provides interfaces for a framework that facilitates dynamic scheduling in distributed real-time systems. The specification introduces the following concepts: + +* Scheduling Segment - A sequence of code, on a single host, with +specific scheduling requirements +* Distributable Thread (DT) - A programming model abstraction for a +distributed task +* Pluggable Scheduler - Facilitate the use of multiple scheduling +disciplines +* Scheduling Points - To interact with the scheduler at the +application and ORB level + +This dir contains two pluggable schedulers: + +Fixed Priority Scheduler - This scheduler uses the OS scheduler to +schedule the various DTs dynamically entering and leaving the +system. The DTs are scheduled based on their importance. + +Most Important First (MIF) Scheduler - This scheduler uses a custom +MIF scheduler to schedule the DTs in the system. The tasks are +scheduled according to their importance. The scheduler maintains a +ready queue of DTs. When a DT enters the system it puts the DT in the +ready queue in order of its importance. It then activates the DT +of highest importance in the ready queue. So at any given time the +DT with the highest importance is running. diff --git a/TAO/examples/RTScheduling/Starter.cpp b/TAO/examples/RTScheduling/Starter.cpp new file mode 100644 index 00000000000..e7ac393bc92 --- /dev/null +++ b/TAO/examples/RTScheduling/Starter.cpp @@ -0,0 +1,180 @@ +//$Id$ + +#include "Starter.h" + + +Starter::Starter (CORBA::ORB_ptr orb) +{ + // Initialize the naming service + if (this->naming_client_.init (orb) != 0) + ACE_ERROR ((LM_ERROR, + " (%P|%t) Unable to initialize " + "the TAO_Naming_Client. \n")); +} + +void +Starter::init (ACE_ENV_SINGLE_ARG_DECL) +{ + this->resolve_synch_objs (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK; + + this->fire (); +} + +void +Starter::fire (void) +{ + ACE_Time_Value base_time = ACE_OS::gettimeofday (); + for (Synchs::iterator iterator = this->synchs_.begin (); + iterator != this->synchs_.end (); + ++iterator) + { + (*iterator).int_id_.in ()->go (base_time.sec ()); + } +} + +void +Starter::resolve_synch_objs (ACE_ENV_SINGLE_ARG_DECL) +{ + CosNaming::Name name (1); + name.length (1); + + // Get the sender context. + name [0].id = + CORBA::string_dup ("Synch"); + + CORBA::Object_var object = + this->naming_client_->resolve (name + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + this->synch_context_ = + CosNaming::NamingContext::_narrow (object.in ()); + + + CosNaming::BindingIterator_var iterator; + CosNaming::BindingList_var binding_list; + const CORBA::ULong chunk = 100; + + // Get the list of synchs registered for this sender. + this->synch_context_->list (chunk, + binding_list, + iterator + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + // Add the receivers found in the bindinglist to the <receivers>. + this->add_to_synchs (binding_list + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + if (!CORBA::is_nil (iterator.in ())) + { + CORBA::Boolean more = 1; + + // Check to see if there are more receivers listed. + while (more) + { + more = iterator->next_n (chunk, + binding_list + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + this->add_to_synchs (binding_list + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + } + } + +} + + +void +Starter::add_to_synchs (CosNaming::BindingList &binding_list + ACE_ENV_ARG_DECL) +{ + ACE_Time_Value base_time = ACE_OS::gettimeofday (); + for (CORBA::ULong i = 0; + i < binding_list.length (); + i++) + { + // Get the receiver name from the binding list. + ACE_CString synch_name = + binding_list [i].binding_name [0].id.in (); + + ACE_DEBUG ((LM_DEBUG, + "Synch Name %s\n", + synch_name.c_str ())); + + CosNaming::Name name (1); + name.length (1); + name [0].id = + CORBA::string_dup (synch_name.c_str ()); + + // Resolve the reference of the receiver from the receiver + // context. + CORBA::Object_var obj = + this->synch_context_->resolve (name + ACE_ENV_ARG_PARAMETER); + + Synch_var synch_obj = + Synch::_narrow (obj.in ()); + + + synch_obj->go (base_time.sec ()); + +// // Add this receiver to the receiver map. +// this->synchs_.bind (synch_name, +// synch_obj); + } +} + + +int +main (int argc, char** argv) +{ + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = CORBA::ORB_init (argc, + argv, + "" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + Starter starter (orb.in ()); + + starter.init (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Caught exception:"); + return 1; + } + ACE_ENDTRY; +return 0; +} + + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + +template class ACE_Hash_Map_Entry<ACE_CString, Synch_var>; +template class ACE_Hash_Map_Manager<ACE_CString, Synch_var, ACE_Null_Mutex>; +template class ACE_Hash_Map_Manager_Ex<ACE_CString, Synch_var, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex>; +template class ACE_Hash_Map_Iterator_Base_Ex<ACE_CString, Synch_var, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex>; +template class ACE_Hash_Map_Iterator_Ex<ACE_CString, Synch_var, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex>; +template class ACE_Hash_Map_Reverse_Iterator_Ex<ACE_CString, Synch_var, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex>; + +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + +#pragma instantiate ACE_Hash_Map_Entry<ACE_CString, Synch_var> +#pragma instantiate ACE_Hash_Map_Manager<ACE_CString, Synch_var, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Manager_Ex<ACE_CString, Synch_var, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<ACE_CString, Synch_var, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Iterator_Ex<ACE_CString, Synch_var, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex> +#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<ACE_CString, Synch_var, ACE_Hash<ACE_CString>, ACE_Equal_To<ACE_CString>, ACE_Null_Mutex> + + +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/examples/RTScheduling/Starter.h b/TAO/examples/RTScheduling/Starter.h new file mode 100644 index 00000000000..2c499cfda05 --- /dev/null +++ b/TAO/examples/RTScheduling/Starter.h @@ -0,0 +1,39 @@ +//$Id$ +#ifndef STARTER_H +#define STARTER_H + +#include "orbsvcs/Naming/Naming_Utils.h" +#include "SynchC.h" +#include "ace/SString.h" +#include "ace/Hash_Map_Manager.h" + +class Starter +{ + public: + + Starter (CORBA::ORB_ptr orb); + + void init (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); + + void fire (void); + + typedef ACE_Hash_Map_Manager <ACE_CString, + Synch_var, + ACE_Null_Mutex> Synchs; + + + private: + void resolve_synch_objs (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); + + void add_to_synchs (CosNaming::BindingList &binding_list + ACE_ENV_ARG_DECL_WITH_DEFAULTS); + + + /// A naming context. + CosNaming::NamingContext_var synch_context_; + TAO_Naming_Client naming_client_; + + Synchs synchs_; +}; + +#endif /*STARTER_H*/ diff --git a/TAO/examples/RTScheduling/Synch.idl b/TAO/examples/RTScheduling/Synch.idl new file mode 100644 index 00000000000..45ccc7b49c2 --- /dev/null +++ b/TAO/examples/RTScheduling/Synch.idl @@ -0,0 +1,6 @@ +//$Id$ + +interface Synch +{ + oneway void go (in long base_time); +}; diff --git a/TAO/examples/RTScheduling/Synch_i.cpp b/TAO/examples/RTScheduling/Synch_i.cpp new file mode 100644 index 00000000000..a9b20909662 --- /dev/null +++ b/TAO/examples/RTScheduling/Synch_i.cpp @@ -0,0 +1,31 @@ +//$Id$ + +#include "Synch_i.h" + +Synch_i::Synch_i (void) +{ + this->synched_ = 0; +} + +void +Synch_i::go (CORBA::Long base_time + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + ACE_DEBUG ((LM_DEBUG, + "GO\n")); + this->synched_ = 1; + this->base_time_.set (base_time, 0); +} + +int +Synch_i::synched (void) +{ + return this->synched_; +} + +ACE_Time_Value* +Synch_i::base_time (void) +{ + return &this->base_time_; +} diff --git a/TAO/examples/RTScheduling/Synch_i.h b/TAO/examples/RTScheduling/Synch_i.h new file mode 100644 index 00000000000..9a262536c97 --- /dev/null +++ b/TAO/examples/RTScheduling/Synch_i.h @@ -0,0 +1,26 @@ +//$Id$ + +#ifndef SYNCH_I_H +#define SYNCH_I_H + +#include "SynchS.h" + +class Synch_i : public POA_Synch +{ + public: + + Synch_i (void); + virtual void go (CORBA::Long base_time + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)); + + int synched (void); + + ACE_Time_Value* base_time (void); + + private: + int synched_; + ACE_Time_Value base_time_; +}; + +#endif /*SYNCH_I_H*/ diff --git a/TAO/examples/RTScheduling/Task_Stats.cpp b/TAO/examples/RTScheduling/Task_Stats.cpp new file mode 100644 index 00000000000..225ba2fe893 --- /dev/null +++ b/TAO/examples/RTScheduling/Task_Stats.cpp @@ -0,0 +1,112 @@ +//$Id$ +#include "Task_Stats.h" +#include "ace/OS.h" +#include "ace/Log_Msg.h" +#include "ace/OS_String.h" + +#if !defined (__ACE_INLINE__) +#include "Task_Stats.inl" +#endif /* __ACE_INLINE__ */ + +Base_Time::Base_Time (void) +{ + base_time_ = ACE_OS::gethrtime (); +} + +Task_Stats::Task_Stats (void) + : base_time_(0), + end_time_ (0), + max_samples_ (0), + samples_count_ (0), + thr_run_time_ (0), + thr_count_ (0), + exec_time_min_ (0), + exec_time_min_at_ (0), + exec_time_max_ (0), + exec_time_max_at_(0), + sum_ (0), + sum2_ (0) +{ +} + +Task_Stats::~Task_Stats (void) +{ + delete[] this->thr_run_time_; + delete[] this->thr_count_; +} + +int +Task_Stats::init (size_t max_samples) +{ + max_samples_ = max_samples; + ACE_NEW_RETURN (this->thr_run_time_, ACE_UINT32[this->max_samples_], -1); + ACE_NEW_RETURN (this->thr_count_, int[this->max_samples_], -1); + return 0; +} + +void +Task_Stats::base_time (ACE_hrtime_t time) +{ + base_time_ = time; +} + +void +Task_Stats::end_time (ACE_hrtime_t time) +{ + end_time_ = time; +} + +void +Task_Stats::dump_samples (const ACE_TCHAR *file_name, const ACE_TCHAR *msg, + ACE_UINT32) +{ + + FILE* output_file = ACE_OS::fopen (file_name, "w"); + + if (output_file == 0) + { + ACE_ERROR ((LM_ERROR, + "%s cannot be opened \n", + file_name)); + } + + // first dump what the caller has to say. + ACE_OS::fprintf (output_file, "%s\n",msg); + + // next, compose and dump what we want to say. + ACE_UINT32 val_1; + int val_2; + ACE_UINT64 x; + + x = this->thr_run_time_[0];// scale_factor; + val_1 = ACE_CU64_TO_CU32 (x); + + ACE_OS::fprintf (output_file, "%u \t %d\n",val_1,thr_count_[0]); + + // dump the samples recorded. + for (size_t i = 1; i != this->samples_count_; ++i) + { + x = this->thr_run_time_[i]; + val_1 = ACE_CU64_TO_CU32 (x); + val_2 = this->thr_count_[i]; + ACE_OS::fprintf (output_file, "%u \t %d\n",val_1,val_2); + } + + ACE_OS::fclose (output_file); + + ACE_DEBUG ((LM_DEBUG, + "Samples are ready to view\n")); +} + + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + +template class ACE_Singleton<Base_Time, TAO_SYNCH_MUTEX>; +template class ACE_Singleton<Task_Stats, TAO_SYNCH_MUTEX>; + +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + +#pragma instantiate ACE_Singleton<Base_Time, TAO_SYNCH_MUTEX> +#pragma instantiate ACE_Singleton<Task_Stats, TAO_SYNCH_MUTEX> + +#endif /*ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/examples/RTScheduling/Task_Stats.h b/TAO/examples/RTScheduling/Task_Stats.h new file mode 100644 index 00000000000..7759a2b6783 --- /dev/null +++ b/TAO/examples/RTScheduling/Task_Stats.h @@ -0,0 +1,107 @@ +/* -*- C++ -*- */ +//============================================================================= +/** + * @file Task_Stats.h + * + * $Id$ + * + * Utility Stats class that maintains the readings. + * + * @author Pradeep Gore <pradeep@cs.wustl.edu> + */ +//============================================================================= +#ifndef TASK_STATS_H +#define TASK_STATS_H + +#include "ace/OS.h" +#include "ace/Singleton.h" +#include "tao/orbconf.h" +#include "tao/debug.h" + +/** + * @class Base_Time + * + * @brief maintains readings recorded by tasks. + * + */ +class Base_Time +{ + public: + Base_Time (void); + ACE_hrtime_t base_time_; +}; + +typedef ACE_Singleton<Base_Time, TAO_SYNCH_MUTEX> BASE_TIME; + +/** + * @class Task_Stats + * + * @brief maintains readings recorded by tasks. + * + */ +class Task_Stats +{ + public: + /// Constructor + Task_Stats (void); + + /// Destructor + ~Task_Stats (void); + + /// Init + int init (size_t max_samples); + + /// Set the base time value. + void base_time (ACE_hrtime_t time); + + /// Set the end time value. + void end_time (ACE_hrtime_t time); + + /// Record a sample + int sample (ACE_UINT32 thr_run_time, int thr_count); + + void dump_samples (const ACE_TCHAR *file_name, const ACE_TCHAR *msg, + ACE_UINT32 scale_factor); + protected: + void dump_latency_stats (ACE_TCHAR *out_msg, ACE_UINT32 sf); + + /// Base and end times + ACE_hrtime_t base_time_; + ACE_hrtime_t end_time_; + + /// The maximum number of samples + ACE_UINT32 max_samples_; + + /// The number of samples + ACE_UINT32 samples_count_; + + /// The samples : the time of execution. and the recorded exec. time . + ACE_UINT32 *thr_run_time_; + int *thr_count_; + + /// The minimum value + ACE_UINT64 exec_time_min_; + + /// The number of the sample that had the minimum value + ACE_UINT32 exec_time_min_at_; + + /// The maximum value + ACE_UINT64 exec_time_max_; + + /// The number of the sample that had the maximum value + ACE_UINT32 exec_time_max_at_; + + /// The sum of all the values + ACE_UINT64 sum_; + + /// The sum of the square of all the values + ACE_UINT64 sum2_; +}; + +typedef ACE_Singleton<Task_Stats, TAO_SYNCH_MUTEX> TASK_STATS; + +#if defined (__ACE_INLINE__) +#include "Task_Stats.inl" +#endif /* __ACE_INLINE__ */ + +#endif /* TASK_STATS_H */ diff --git a/TAO/examples/RTScheduling/Task_Stats.inl b/TAO/examples/RTScheduling/Task_Stats.inl new file mode 100644 index 00000000000..3b50f8c52a4 --- /dev/null +++ b/TAO/examples/RTScheduling/Task_Stats.inl @@ -0,0 +1,17 @@ +//$Id$ + +ACE_INLINE int +Task_Stats::sample (ACE_UINT32 thr_run_time, int thr_count) +{ + if (this->samples_count_ >= this->max_samples_) + { + ACE_DEBUG ((LM_DEBUG, "Task_Stats::sample ret -1\n")); + return -1; + } + + this->thr_run_time_[this->samples_count_] = thr_run_time; + this->thr_count_[this->samples_count_] = thr_count; + + this->samples_count_++; + return 0; +} diff --git a/TAO/examples/RTScheduling/Thread_Task.cpp b/TAO/examples/RTScheduling/Thread_Task.cpp new file mode 100644 index 00000000000..0eaa9e3fc75 --- /dev/null +++ b/TAO/examples/RTScheduling/Thread_Task.cpp @@ -0,0 +1,109 @@ +//$Id$ + +#include "Thread_Task.h" +#include "ace/Atomic_Op.h" +#include "Task_Stats.h" +#include "tao/ORB_Core.h" +#include "ace/High_Res_Timer.h" + +Thread_Task::Thread_Task (void) +{ +} + +int +Thread_Task::svc (void) +{ + ACE_TRY_NEW_ENV + { + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "Thread_Task::svc %d\n", + importance_)); + + const char * name = 0; + CORBA::Policy_var implicit_sched_param = CORBA::Policy::_duplicate (sched_param_.in ());; + this->current_->begin_scheduling_segment (name, + sched_param_.in (), + implicit_sched_param.in () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_OS::memcpy (&count_, + this->current_->id ()->get_buffer (), + this->current_->id ()->length ()); + + char msg [BUFSIZ]; + ACE_OS::sprintf (msg, "Thread_Task::svc Imp=%d Guid=%d\n", importance_, count_); + dt_creator_->log_msg (msg); + + this->perform_task (); + + this->current_->end_scheduling_segment (name + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + dt_creator_->dt_ended () ; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Caught exception:"); + } + ACE_ENDTRY; + return 0; +} + +int +Thread_Task::importance (void) +{ + return this->importance_; +} + +int +Thread_Task::start_time (void) +{ + return this->start_time_; +} + +int +Thread_Task::perform_task (void) +{ + return 0; +} + + +const char* +Thread_Task::job (void) +{ + return job_name_; +} + +void +Thread_Task::job (Job_ptr job) +{ + job_ = Job::_duplicate (job); +} + +int +Thread_Task::dist (void) +{ + return this->dist_; +} + +void +Thread_Task::dump_stats (void) +{ + char fname [BUFSIZ]; + ACE_OS::sprintf (fname, "DT_%d.dat",count_); + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + "File name %s\n", + fname)); + + char msg [BUFSIZ]; + ACE_OS::sprintf (msg, "#Schedule Output for DT %d", count_); + + task_stats_->dump_samples (fname, + msg, + ACE_High_Res_Timer::global_scale_factor ()); +} diff --git a/TAO/examples/RTScheduling/Thread_Task.h b/TAO/examples/RTScheduling/Thread_Task.h new file mode 100644 index 00000000000..53172c59f89 --- /dev/null +++ b/TAO/examples/RTScheduling/Thread_Task.h @@ -0,0 +1,67 @@ +//$Id$ +#ifndef THREAD_TASK_H +#define THREAD_TASK_H + +#include "tao/RTScheduling/RTScheduler.h" +//#include "FP_Scheduler.h" +#include "ace/Task.h" +#include "DT_Creator.h" +#include "Task.h" + +class Task_Stats; +class DT_Creator; + +class Thread_Task : public ACE_Task <ACE_SYNCH> +{ + public: + +/* Thread_Task (int importance, */ +/* int start_time, */ +/* int load, */ +/* DT_Creator *dt_creator); */ + + Thread_Task (void); + + virtual int activate_task (RTScheduling::Current_ptr current, + CORBA::Policy_ptr sched_param, + long flags, + ACE_Time_Value* base_time + ACE_ENV_ARG_DECL_WITH_DEFAULTS) = 0; + + virtual int perform_task (void); + + int importance (void); + + int start_time (void); + + /// = Job get/set + /// Returns the name of the Job exec'ed by this Task. + const char* job (void); + + /// Sets the Job to exec. + void job (Job_ptr job); + + int dist (void); + + void dump_stats (void); + + protected: + /// task svc + virtual int svc (void); + RTScheduling::Current_var current_; + CORBA::Policy_var sched_param_; + int start_time_; + int load_; + int iter_; + int count_; + int importance_; + DT_Creator *dt_creator_; + //Task *task_; + ACE_Time_Value* base_time_; + int dist_; + char *job_name_; + Job_var job_; + Task_Stats *task_stats_; +}; + +#endif /* THREAD_TASK_H */ |