diff options
Diffstat (limited to 'ACE/TAO/orbsvcs/orbsvcs/Scheduler_Factory.h')
| -rw-r--r-- | ACE/TAO/orbsvcs/orbsvcs/Scheduler_Factory.h | 286 |
1 files changed, 286 insertions, 0 deletions
diff --git a/ACE/TAO/orbsvcs/orbsvcs/Scheduler_Factory.h b/ACE/TAO/orbsvcs/orbsvcs/Scheduler_Factory.h new file mode 100644 index 00000000000..d530f84a073 --- /dev/null +++ b/ACE/TAO/orbsvcs/orbsvcs/Scheduler_Factory.h @@ -0,0 +1,286 @@ +// -*- C++ -*- + + +//============================================================================= +/** + * @file Scheduler_Factory.h + * + * $Id$ + * + * @author Chris Gill <cdgill@cs.wustl.edu> + */ +//============================================================================= + + +#ifndef ACE_SCHEDULER_FACTORY_H +#define ACE_SCHEDULER_FACTORY_H +#include /**/ "ace/pre.h" + +#include "ace/Containers_T.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "orbsvcs/CosNamingC.h" +#include "orbsvcs/RtecSchedulerC.h" +#include "orbsvcs/Sched/sched_export.h" + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +class TAO_Reconfig_Scheduler_Entry; +struct TAO_RT_Info_Tuple; +typedef ACE_Ordered_MultiSet<TAO_RT_Info_Tuple *> TUPLE_SET; +typedef ACE_Ordered_MultiSet_Iterator<TAO_RT_Info_Tuple *> TUPLE_SET_ITERATOR; + +/** + * @class ACE_Scheduler_Factory + * + * @brief Factory of scheduler services. + * + * This class acts as a factory for scheduler servers. At config + * time it will return a remote server, which will actually + * compute the scheduling parameters. At run-time it returns a + * local server, which will use the results of the config runs to + * actually do the scheduling, without incurring in RPC overheads. + */ +class TAO_RTSched_Export ACE_Scheduler_Factory +{ +public: + /* + * This type enumerates the possible states of the factory: + * uninitialized, or in a configuration, runtime, or + * reconfigurable mode of operation. + */ + enum Factory_Status + { + UNINITIALIZED, + CONFIG, + RECONFIG, + RUNTIME + }; + + /* + * @brief Plain Old Data for RT_Infos. + * + * This class provide us with a plain old data version of + * RT_Info, this is useful for implementing arrays of + * those. + */ + struct POD_RT_Info + { + + const char *entry_point; + RtecScheduler::handle_t handle; + RtecScheduler::Time worst_case_execution_time; + RtecScheduler::Time typical_execution_time; + RtecScheduler::Time cached_execution_time; + RtecScheduler::Period_t period; + CORBA::Long criticality; + CORBA::Long importance; + RtecScheduler::Quantum_t quantum; + RtecScheduler::Threads_t threads; + RtecScheduler::OS_Priority priority; + RtecScheduler::Preemption_Subpriority_t static_subpriority; + RtecScheduler::Preemption_Priority_t preemption_priority; + CORBA::Long info_type; + RtecScheduler::RT_Info_Enabled_Type_t enabled; + + }; + + + struct POD_Dependency_Info + { + // = TITLE + // Plain Old Data for RT_Info Dependencies. + // + // = DESCRIPTION + // This class provide us with a plain old data version of + // dependencies between RT_Infos. This is useful for implementing + // arrays of those. + + RtecScheduler::Dependency_Type_t dependency_type; + CORBA::Long number_of_calls; + RtecScheduler::handle_t info_that_depends; + RtecScheduler::handle_t info_depended_on; + RtecScheduler::Dependency_Enabled_Type_t enabled; + }; + + struct POD_Config_Info + { + // = TITLE + // Plain Old Data for dispatch queue configuration information. + // + // = DESCRIPTION + // This class provide us with a plain old data version of + // configuration info, which is useful for implementing static arrays + // NOTE: if used in an array, the run-time scheduler requires that the + // array index match the preemption priority stored in the config info + // at that index: this is used to detect uninitialized/corrupted schedules + RtecScheduler::Preemption_Priority_t preemption_priority; + RtecScheduler::OS_Priority thread_priority; + RtecScheduler::Dispatching_Type_t dispatching_type; + }; + + struct POD_Scheduling_Anomaly + { + // = TITLE + // Plain Old Data for scheduling anomaly information. + // + // = DESCRIPTION + // This class provide us with a plain old data version of + // scheduling anomalies, which is used to generate error + // and warning lines in the runtime scheduling header output. + + const char* description; + RtecScheduler::Anomaly_Severity severity; + }; + + /// Setup the variables needed for a config run, using the + /// NamingContext to locate a Scheduler. + static int use_config (CosNaming::NamingContext_ptr naming); + + /// Setup the variables needed for a config run, using the + /// NamingContext to locate a Scheduler. + static int use_config (CosNaming::NamingContext_ptr naming, + const char* name); + + /// Disable config runs in the Factory and sets up the precomputed + /// scheduling information. + static int use_runtime (int cc, + POD_Config_Info cfgi[], + int ec, + POD_RT_Info rti[]); + + /** + * Return the Real-time Scheduling Service used for this run. + * Must have been configured either using use_context() or use_data(). + * + * Normally use_data() is called at static elaboration time, so + * everything is automatic. On config runs use_context() is called + * from main, after resolve_initial_references. + */ + static int server (RtecScheduler::Scheduler_ptr); + static RtecScheduler::Scheduler_ptr server (void); + + /** + * This helper function will dump the schedule returned by a + * RtecScheduler::Scheduler into a file, the file can be compiled to + * create an efficient local implementation of the Scheduler. + */ + static int dump_schedule (const RtecScheduler::RT_Info_Set& infos, + const RtecScheduler::Dependency_Set& dependencies, + const RtecScheduler::Config_Info_Set& configs, + const RtecScheduler::Scheduling_Anomaly_Set& anomalies, + const ACE_TCHAR* file_name = 0, + const char* rt_info_format = 0, + const char* dependency_format = 0, + const char* config_info_format = 0, + int dump_disabled_infos = 0, + int dump_disabled_dependencies = 0); + + // TODO: How to do cleanup()? Use the ACE_Object_Manager stuff? + + /// This helper function prints out a single scheduling entry contents + static void log_scheduling_entry(TAO_Reconfig_Scheduler_Entry * entry, + FILE* file); + + /// This helper function prints out the intermediate scheduling entries + static int log_scheduling_entries(TAO_Reconfig_Scheduler_Entry ** entry_ptr_array, + long entry_ptr_array_size, + const char* file_name); + + /// This helper function prints out the arry used to create scheduling entries + /// sorted in topological order then priority order + static void log_scheduling_tuples(TAO_RT_Info_Tuple ** tuple_ptr_array, + long tuple_ptr_array_size, + const char* file_name); + + static void log_tuple_subset(TUPLE_SET & tuple_subset, + FILE* file); + + /** + * This helper function allows the application to determine whether + * the factory is uninitialized, or in a config or runtime mode of + * operation. + */ + static Factory_Status status (void); + + // = Access the (OS independent) preemption priority of the calling thread. + /// Returns (u_int) -1 if the preemption priority hadn't been set. + static RtecScheduler::Preemption_Priority_t preemption_priority (); + + // = Set the (OS independent) preemption priority of the calling thread. + /** + * The application or Event Channel is responsible for making sure + * that the preemption priority is set before any access of the + * preemption priority. + */ + static void set_preemption_priority + (const RtecScheduler::Preemption_Priority_t); + + // Accessor for obtaining the default period (Boeing Extension) + /// Method for setting the default period (Boeing Extension) + static RtecScheduler::Period_t period_default(); + static void period_default(RtecScheduler::Period_t period_default); + + // Accessor for obtaining the default threads (Boeing Extension) + /// Method for setting the default threads (Boeing Extension) + static RtecScheduler::Threads_t threads_default(); + static void threads_default(RtecScheduler::Threads_t threads_default); + + // Accessor for obtaining the default importance (VERY_LOW_IMPORTANCE to VERY_HIGH_IMPORTANCE). (Boeing Extension) + /// Method for setting the default importance (VERY_LOW_IMPORTANCE to VERY_HIGH_IMPORTANCE). (Boeing Extension) + static RtecScheduler::Importance_t importance_default(); + static void importance_default(RtecScheduler::Importance_t importance_default); + + // Accessor for obtaining the default criticality (VERY_LOW_CRITICALITY to VERY_HIGH_CRITICALITY). (Boeing Extension) + /// Method for setting the default criticality (VERY_LOW_CRITICALITY to VERY_HIGH_CRITICALITY). (Boeing Extension) + static RtecScheduler::Criticality_t criticality_default(); + static void criticality_default(RtecScheduler::Criticality_t criticality_default); + + // Accessor for obtaining the default rt_info enabled state. (RT_INFO_DISABLED, RT_INFO_ENABLED, or RT_INFO_NON_VOLATILE) + static RtecScheduler::RT_Info_Enabled_Type_t rt_info_enable_state_default(); + + // Method for setting the default rt_info enabled state. (RT_INFO_DISABLED, RT_INFO_ENABLED, or RT_INFO_NON_VOLATILE) + static void rt_info_enable_state_default(RtecScheduler::RT_Info_Enabled_Type_t rt_info_enable_state_default); + +protected: + + /** + * By default this factory assumes we are runnning a config + * run. Calling this method disables that. Since the methods + * returns an int it can be used to initialize a static variable, + * hence calling it before main(); this technique can be used in the + * code emitted for the run-time scheduler, automagically disabling + * the config_run() when that code is linked in. + */ + static int no_config_run (void); + +private: + static RtecScheduler::Scheduler_ptr server_; + + static Factory_Status status_; + /// Default period configuration. (Boeing Extension) + static RtecScheduler::Period_t period_default_; + /// Default threads configuration. (Boeing Extension) + static RtecScheduler::Threads_t threads_default_; + + /// Default importance configuration. (Boeing Extension) + static RtecScheduler::Importance_t importance_default_; + /// Default criticality. (Boeing Extension) + static RtecScheduler::Criticality_t criticality_default_; + + /// Default rt_info enabled state. (Boeing Extension) + static RtecScheduler::RT_Info_Enabled_Type_t rt_info_enable_state_default_; + +}; + +TAO_END_VERSIONED_NAMESPACE_DECL + +#if defined (__ACE_INLINE__) +#include "orbsvcs/Scheduler_Factory.inl" +#endif /* __ACE_INLINE__ */ + +#include /**/ "ace/post.h" +#endif /* ACE_SCHEDULER_FACTORY_H */ |