diff options
Diffstat (limited to 'ACE/TAO/tao/RTCORBA/RT_ORB.h')
| -rw-r--r-- | ACE/TAO/tao/RTCORBA/RT_ORB.h | 289 |
1 files changed, 289 insertions, 0 deletions
diff --git a/ACE/TAO/tao/RTCORBA/RT_ORB.h b/ACE/TAO/tao/RTCORBA/RT_ORB.h new file mode 100644 index 00000000000..8f07b73774a --- /dev/null +++ b/ACE/TAO/tao/RTCORBA/RT_ORB.h @@ -0,0 +1,289 @@ +/* -*- C++ -*- */ +//============================================================================= +/** + * @file RT_ORB.h + * + * $Id$ + * + * @author Marina Spivak <marina@cs.wustl.edu> + */ +//============================================================================= + +#ifndef TAO_RT_ORB_H +#define TAO_RT_ORB_H +#include /**/ "ace/pre.h" + +#include "tao/orbconf.h" + +#if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0 + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/RTCORBA/RTCORBA_includeC.h" +#include "tao/RTCORBA/RT_ORBInitializer.h" +#include "tao/LocalObject.h" +#include "ace/Hash_Map_Manager_T.h" + +#if (TAO_HAS_NAMED_RT_MUTEXES == 1) +# include "ace/Null_Mutex.h" +#endif + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +// Forward reference for TAO_Named_RT_Mutex_Manager +class TAO_RT_Mutex; +class TAO_Thread_Pool_Manager; + +/** + * @class TAO_Named_RT_Mutex_Manager + * + * @brief Manages the names of named and unnamed RT Mutexes + * + */ +class TAO_RTCORBA_Export TAO_Named_RT_Mutex_Manager +{ + +public: + /// Constructor. + TAO_Named_RT_Mutex_Manager (void); + + /// Destructor. + ~TAO_Named_RT_Mutex_Manager (void); + + RTCORBA::Mutex_ptr create_mutex (void); + + void destroy_mutex (RTCORBA::Mutex_ptr the_mutex); + + RTCORBA::Mutex_ptr create_named_mutex (const char *name, + CORBA::Boolean_out created_flag); + + RTCORBA::Mutex_ptr open_named_mutex (const char * name); + +private: + +#if (TAO_HAS_NAMED_RT_MUTEXES == 1) + /// Hash map for named RT Mutexes + ACE_Hash_Map_Manager_Ex< + ACE_CString, + RTCORBA::Mutex_var, + ACE_Hash<ACE_CString>, + ACE_Equal_To<ACE_CString>, + ACE_Null_Mutex> map_; + + TAO_SYNCH_MUTEX lock_; +#endif /* TAO_HAS_NAMED_RT_MUTEXES == 1 */ +}; + + +/** + * @class TAO_RT_ORB + * + * @brief RTCORBA::RTORB implementation + * + * Creates and destroys RT CORBA objects, i.e., policies, + * threadpools, mutexes. + */ +class TAO_RTCORBA_Export TAO_RT_ORB + : public RTCORBA::RTORB, + public ::CORBA::LocalObject +{ +public: + + /// Constructor. + TAO_RT_ORB (TAO_ORB_Core *orb_core, + TAO_RT_ORBInitializer::TAO_RTCORBA_DT_LifeSpan lifespan, + ACE_Time_Value const &dynamic_thread_time); + + /** + * Create a new mutex. Mutexes returned by this method + * are the same as those used internally by the ORB, so that + * consistant priority inheritance/piority ceiling semantics + * can be guaranteed. + */ + virtual RTCORBA::Mutex_ptr create_mutex (void); + + /** + * Destroy a mutex. Currently this is a no-op since RTCORBA::Mutex + * instances are destroyed as soon as their reference counts go to + * 0. + */ + virtual void destroy_mutex (RTCORBA::Mutex_ptr the_mutex); + + /** + * Create a mutex and assign a name to it. If the + * mutex already exists, it is returned and the created_flag + * is set to 0. + */ + virtual RTCORBA::Mutex_ptr create_named_mutex (const char *name, + CORBA::Boolean_out created_flag); + + /// Retrieve a previously created mutex. + virtual RTCORBA::Mutex_ptr open_named_mutex (const char * name); + + /** + * Create and return a TCPProtocolProperties instance with the specified + * parameters. + */ + RTCORBA::TCPProtocolProperties_ptr + create_tcp_protocol_properties (CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size, + CORBA::Boolean keep_alive, + CORBA::Boolean dont_route, + CORBA::Boolean no_delay, + CORBA::Boolean enable_network_priority); + + RTCORBA::UnixDomainProtocolProperties_ptr + create_unix_domain_protocol_properties (CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size); + + RTCORBA::SharedMemoryProtocolProperties_ptr + create_shared_memory_protocol_properties (CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size, + CORBA::Boolean keep_alive, + CORBA::Boolean dont_route, + CORBA::Boolean no_delay, + CORBA::Long preallocate_buffer_size, + const char *mmap_filename, + const char *mmap_lockname); + + RTCORBA::UserDatagramProtocolProperties_ptr + create_user_datagram_protocol_properties (CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size, + CORBA::Boolean enable_network_priority); + + RTCORBA::StreamControlProtocolProperties_ptr + create_stream_control_protocol_properties (CORBA::Long send_buffer_size, + CORBA::Long recv_buffer_size, + CORBA::Boolean keep_alive, + CORBA::Boolean dont_route, + CORBA::Boolean no_delay, + CORBA::Boolean enable_network_priority); + + /// Create a RTCORBA threadpool to manage a set of threads without lanes. + virtual RTCORBA::ThreadpoolId + create_threadpool (CORBA::ULong stacksize, + CORBA::ULong static_threads, + CORBA::ULong dynamic_threads, + RTCORBA::Priority default_priority, + CORBA::Boolean allow_request_buffering, + CORBA::ULong max_buffered_requests, + CORBA::ULong max_request_buffer_size); + + /** + * Create a threadpool and separate it into subsets based on + * priorities. + */ + virtual RTCORBA::ThreadpoolId + create_threadpool_with_lanes (CORBA::ULong stacksize, + const RTCORBA::ThreadpoolLanes & lanes, + CORBA::Boolean allow_borrowing, + CORBA::Boolean allow_request_buffering, + CORBA::ULong max_buffered_requests, + CORBA::ULong max_request_buffer_size); + + /// Free the resources associated with the specified threadpool. + virtual void destroy_threadpool (RTCORBA::ThreadpoolId threadpool); + + /// Create a priority model policy for use when configuring a POA. + virtual RTCORBA::PriorityModelPolicy_ptr + create_priority_model_policy (RTCORBA::PriorityModel priority_model, + RTCORBA::Priority server_priority); + + /// Create a ThreadpoolPolicy instance for POA creation + virtual RTCORBA::ThreadpoolPolicy_ptr + create_threadpool_policy (RTCORBA::ThreadpoolId threadpool); + + /** + * Create a PriorityBandedConnectionPolicy instance + * for use on either the client or server side + */ + virtual RTCORBA::PriorityBandedConnectionPolicy_ptr + create_priority_banded_connection_policy (const RTCORBA::PriorityBands & + priority_bands); + + /** + * Create a PrivateConnectionPolicy instance to use on client + * to request a private (non-multiplexed) transport connection + * to the server. + */ + virtual RTCORBA::PrivateConnectionPolicy_ptr + create_private_connection_policy (void); + + /** + * Create a ServerProtocolPolicy instance to select and configure + * communication protocols on the server side. + */ + virtual RTCORBA::ServerProtocolPolicy_ptr + create_server_protocol_policy (const RTCORBA::ProtocolList & protocols); + + /** + * Create a ClientProtocolPolicy instance to select and configure + * communication protocols on the client side. + */ + virtual RTCORBA::ClientProtocolPolicy_ptr + create_client_protocol_policy (const RTCORBA::ProtocolList & protocols); + + /// Reference to our creating ORB Core. + TAO_ORB_Core *orb_core (void) const; + + /// Get the Thread Pool Manager. + TAO_Thread_Pool_Manager &tp_manager (void) const; + + /** + * This method changes the scheduling policy of the calling thread + * to match the scheduling policy specified in the svc.conf file. + * The priority of the calling thread will be set to the minimum + * priority supported by that scheduling policy. + * + * This method make sense on those platform (e.g., Linux) where + * PTHREAD_SCOPE_SYSTEM is the only scheduling scope supported. On + * other platforms, this method is a no-op since the only way to get + * the real-time threading behavior is to setup the + * PTHREAD_SCOPE_SYSTEM scheduling scope when a thread is being + * created. On such platforms, one can set the correct scheduling + * scope and policy when creating the thread, thus not needing to + * use this method. + */ + static int modify_thread_scheduling_policy (CORBA::ORB_ptr orb); + +protected: + + /// Protected destructor to enforce proper memory management of this + /// reference counted object. + virtual ~TAO_RT_ORB (void); + +protected: + + /// Reference to our creating ORB Core. + TAO_ORB_Core * const orb_core_; + + /// mutex_mgr_ manages the names associated with named mutexes. + TAO_Named_RT_Mutex_Manager mutex_mgr_; + + /// Thread Pool Manager + TAO_Thread_Pool_Manager *tp_manager_; + + /// Dynamic thread lifespan policy + TAO_RT_ORBInitializer::TAO_RTCORBA_DT_LifeSpan lifespan_; + + /// Dynamic thread run time + ACE_Time_Value const dynamic_thread_time_; +}; + +TAO_END_VERSIONED_NAMESPACE_DECL + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#endif /* TAO_HAS_CORBA_MESSAGING && TAO_HAS_CORBA_MESSAGING != 0 */ + +#include /**/ "ace/post.h" +#endif /* TAO_RT_ORB_H */ |