TAO_RTCORBA: RT_ORB.cpp Source File

00001 // $Id: RT_ORB.cpp 80216 2007-12-10 08:15:33Z johnnyw $
00002 
00003 #include "tao/RTCORBA/RT_ORB.h"
00004 
00005 #if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
00006 
00007 #include "tao/RTCORBA/RT_Policy_i.h"
00008 #include "tao/RTCORBA/RT_Mutex.h"
00009 #include "tao/RTCORBA/Priority_Mapping_Manager.h"
00010 #include "tao/ORB_Core.h"
00011 #include "tao/ORB.h"
00012 #include "tao/SystemException.h"
00013 #include "tao/RTCORBA/Thread_Pool.h"
00014 #include "tao/RTCORBA/RT_Thread_Lane_Resources_Manager.h"
00015 #include "ace/Sched_Params.h"
00016 
00017 ACE_RCSID(RTCORBA,
00018           RT_ORB,
00019           "$Id: RT_ORB.cpp 80216 2007-12-10 08:15:33Z johnnyw $")
00020 
00021 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
00022 
00023 TAO_RT_ORB::TAO_RT_ORB (TAO_ORB_Core *orb_core,
00024                         TAO_RT_ORBInitializer::TAO_RTCORBA_DT_LifeSpan lifespan,
00025                         ACE_Time_Value const &dynamic_thread_time)
00026   : orb_core_ (orb_core),
00027     mutex_mgr_ (),
00028     tp_manager_ (0),
00029     lifespan_ (lifespan),
00030     dynamic_thread_time_ (dynamic_thread_time)
00031 {
00032   TAO_Thread_Lane_Resources_Manager *thread_lane_resources_manager =
00033     &this->orb_core_->thread_lane_resources_manager ();
00034 
00035   TAO_RT_Thread_Lane_Resources_Manager *rt_thread_lane_resources_manager =
00036     dynamic_cast <TAO_RT_Thread_Lane_Resources_Manager *> (thread_lane_resources_manager);
00037 
00038   if (!rt_thread_lane_resources_manager)
00039     throw CORBA::INTERNAL ();
00040 
00041   this->tp_manager_ =
00042     &rt_thread_lane_resources_manager->tp_manager ();
00043 }
00044 
00045 TAO_RT_ORB::~TAO_RT_ORB (void)
00046 {
00047 }
00048 
00049 RTCORBA::Mutex_ptr
00050 TAO_RT_ORB::create_mutex (void)
00051 {
00052   return this->mutex_mgr_.create_mutex ();
00053 }
00054 
00055 void
00056 TAO_RT_ORB::destroy_mutex (RTCORBA::Mutex_ptr mutex)
00057 {
00058   this->mutex_mgr_.destroy_mutex (mutex);
00059 }
00060 
00061 
00062 RTCORBA::Mutex_ptr
00063 TAO_RT_ORB::create_named_mutex (const char *name,
00064                                 CORBA::Boolean_out created_flag)
00065 {
00066   return this->mutex_mgr_.create_named_mutex (name, created_flag);
00067 }
00068 
00069 RTCORBA::Mutex_ptr
00070 TAO_RT_ORB::open_named_mutex (const char *name)
00071 {
00072   return this->mutex_mgr_.open_named_mutex (name);
00073 }
00074 
00075 ////////////////////////////////////////////////////////////////////////////////
00076 
00077 TAO_Named_RT_Mutex_Manager::TAO_Named_RT_Mutex_Manager (void)
00078 {
00079 }
00080 
00081 TAO_Named_RT_Mutex_Manager::~TAO_Named_RT_Mutex_Manager (void)
00082 {
00083 }
00084 
00085 RTCORBA::Mutex_ptr
00086 TAO_Named_RT_Mutex_Manager::create_mutex (void)
00087 {
00088   TAO_RT_Mutex *mutex = 0;
00089   ACE_NEW_THROW_EX (mutex,
00090                     TAO_RT_Mutex (),
00091                     CORBA::NO_MEMORY (
00092                       CORBA::SystemException::_tao_minor_code (
00093                         TAO::VMCID,
00094                         ENOMEM),
00095                       CORBA::COMPLETED_NO));
00096 
00097   return mutex;
00098 }
00099 
00100 // If Named RT_Mutexes aren't enabled, this function is a nop
00101 // as also indicated by the comment below.
00102 #if (TAO_HAS_NAMED_RT_MUTEXES == 1)
00103 void
00104 TAO_Named_RT_Mutex_Manager::destroy_mutex (RTCORBA::Mutex_ptr mutex)
00105 {
00106   TAO_RT_Mutex *tao_mutex =
00107     dynamic_cast<TAO_RT_Mutex *> (mutex);
00108 
00109   // If this mutex is named, then we need to remove it from our table.
00110   // Otherwise, we don't have to do anything.
00111   const char *name = tao_mutex->name ();
00112   if (name != 0)
00113     {
00114       // The following should be atomic.
00115       ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX,
00116                           monitor,
00117                           this->lock_,
00118                           CORBA::INTERNAL ());
00119 
00120       int result =
00121         this->map_.unbind (name);
00122 
00123       if (result != 0)
00124         throw ::CORBA::INTERNAL ();
00125     }
00126 }
00127 #else /* TAO_HAS_NAMED_RT_MUTEXES == 1 */
00128 void
00129 TAO_Named_RT_Mutex_Manager::destroy_mutex (RTCORBA::Mutex_ptr)
00130 {
00131 }
00132 #endif /* TAO_HAS_NAMED_RT_MUTEXES == 1 */
00133 
00134 RTCORBA::Mutex_ptr
00135 TAO_Named_RT_Mutex_Manager::create_named_mutex (const char *name,
00136                                                 CORBA::Boolean_out created_flag)
00137 {
00138 #if (TAO_HAS_NAMED_RT_MUTEXES == 1)
00139   // The following should be atomic.
00140   ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX,
00141                       monitor,
00142                       this->lock_,
00143                       CORBA::INTERNAL ());
00144 
00145   // Optimistic that we'll find it.
00146   created_flag = false;
00147 
00148   // If we find the mutex, simply return it.
00149   RTCORBA::Mutex_var mutex;
00150   if (this->map_.find (name, mutex) != 0)
00151     {
00152       // Oops, we didn't find it.
00153       created_flag = true;
00154 
00155       RTCORBA::Mutex_ptr tmp_mutex;
00156 
00157       // Create a new one.
00158       ACE_NEW_THROW_EX (tmp_mutex,
00159                         TAO_Named_RT_Mutex (name),
00160                         CORBA::NO_MEMORY (
00161                           CORBA::SystemException::_tao_minor_code (
00162                             TAO::VMCID,
00163                             ENOMEM),
00164                           CORBA::COMPLETED_NO));
00165 
00166       mutex = tmp_mutex;
00167 
00168       // Add it to the map.
00169       int const result = this->map_.bind (name, mutex);
00170 
00171       if (result != 0)
00172         throw ::CORBA::INTERNAL ();
00173     }
00174 
00175   // Return the one we found or created.
00176   return mutex._retn ();
00177 #else /* TAO_HAS_NAMED_RT_MUTEXES */
00178   ACE_UNUSED_ARG (name);
00179   ACE_UNUSED_ARG (created_flag);
00180   throw ::CORBA::NO_IMPLEMENT ();
00181 #endif /* TAO_HAS_NAMED_RT_MUTEXES */
00182 }
00183 
00184 RTCORBA::Mutex_ptr
00185 TAO_Named_RT_Mutex_Manager::open_named_mutex (const char *name)
00186 {
00187 #if (TAO_HAS_NAMED_RT_MUTEXES == 1)
00188   // The following should be atomic.
00189   ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX,
00190                       monitor,
00191                       this->lock_,
00192                       CORBA::INTERNAL ());
00193 
00194   // If we find the mutex, simply return it.
00195   RTCORBA::Mutex_var mutex;
00196   if (this->map_.find (name, mutex) != 0)
00197     throw RTCORBA::RTORB::MutexNotFound ();
00198 
00199   // Return the one we found.
00200   return mutex._retn ();
00201 #else /* TAO_HAS_NAMED_RT_MUTEXES */
00202   ACE_UNUSED_ARG (name);
00203   throw ::CORBA::NO_IMPLEMENT ();
00204 #endif /* TAO_HAS_NAMED_RT_MUTEXES */
00205 }
00206 
00207 ///////////////////////////////////////////////////////////////////////////////
00208 
00209 RTCORBA::TCPProtocolProperties_ptr
00210 TAO_RT_ORB::create_tcp_protocol_properties (CORBA::Long send_buffer_size,
00211                                             CORBA::Long recv_buffer_size,
00212                                             CORBA::Boolean keep_alive,
00213                                             CORBA::Boolean dont_route,
00214                                             CORBA::Boolean no_delay,
00215                                             CORBA::Boolean enable_network_priority
00216                                             )
00217 {
00218   TAO_TCP_Protocol_Properties *tmp = 0;
00219   ACE_NEW_THROW_EX (tmp,
00220                     TAO_TCP_Protocol_Properties (send_buffer_size,
00221                                         recv_buffer_size,
00222                                         keep_alive,
00223                                         dont_route,
00224                                         no_delay,
00225                                         enable_network_priority),
00226                     CORBA::NO_MEMORY (TAO::VMCID,
00227                                       CORBA::COMPLETED_NO));
00228 
00229   return tmp;
00230 }
00231 
00232 RTCORBA::UnixDomainProtocolProperties_ptr
00233 TAO_RT_ORB::create_unix_domain_protocol_properties (
00234                                                     CORBA::Long send_buffer_size,
00235                                                     CORBA::Long recv_buffer_size)
00236 {
00237   TAO_UnixDomain_Protocol_Properties *tmp = 0;
00238   ACE_NEW_THROW_EX (tmp,
00239                     TAO_UnixDomain_Protocol_Properties (
00240                                                send_buffer_size,
00241                                                recv_buffer_size),
00242                     CORBA::NO_MEMORY (TAO::VMCID,
00243                                       CORBA::COMPLETED_NO));
00244 
00245   return tmp;
00246 }
00247 
00248 RTCORBA::SharedMemoryProtocolProperties_ptr
00249 TAO_RT_ORB::create_shared_memory_protocol_properties (
00250                                                       CORBA::Long send_buffer_size,
00251                                                       CORBA::Long recv_buffer_size,
00252                                                       CORBA::Boolean keep_alive,
00253                                                       CORBA::Boolean dont_route,
00254                                                       CORBA::Boolean no_delay,
00255                                                       CORBA::Long preallocate_buffer_size,
00256                                                       const char *mmap_filename,
00257                                                       const char *mmap_lockname)
00258 {
00259   TAO_SharedMemory_Protocol_Properties *tmp = 0;
00260   ACE_NEW_THROW_EX (tmp,
00261                     TAO_SharedMemory_Protocol_Properties (send_buffer_size,
00262                                                           recv_buffer_size,
00263                                                           keep_alive,
00264                                                           dont_route,
00265                                                           no_delay,
00266                                                           preallocate_buffer_size,
00267                                                           mmap_filename,
00268                                                           mmap_lockname),
00269                     CORBA::NO_MEMORY (TAO::VMCID,
00270                                       CORBA::COMPLETED_NO));
00271 
00272   return tmp;
00273 }
00274 
00275 RTCORBA::UserDatagramProtocolProperties_ptr
00276 TAO_RT_ORB::create_user_datagram_protocol_properties (
00277                                                       CORBA::Long send_buffer_size,
00278                                                       CORBA::Long recv_buffer_size,
00279                                                       CORBA::Boolean enable_network_priority)
00280 {
00281   TAO_UserDatagram_Protocol_Properties *tmp = 0;
00282   ACE_NEW_THROW_EX (tmp,
00283                     TAO_UserDatagram_Protocol_Properties (
00284                                                  send_buffer_size,
00285                                                  recv_buffer_size,
00286                                                  enable_network_priority),
00287                     CORBA::NO_MEMORY (TAO::VMCID,
00288                                       CORBA::COMPLETED_NO));
00289 
00290   return tmp;
00291 }
00292 
00293 RTCORBA::StreamControlProtocolProperties_ptr
00294 TAO_RT_ORB::create_stream_control_protocol_properties (
00295                                                        CORBA::Long send_buffer_size,
00296                                                        CORBA::Long recv_buffer_size,
00297                                                        CORBA::Boolean keep_alive,
00298                                                        CORBA::Boolean dont_route,
00299                                                        CORBA::Boolean no_delay,
00300                                                        CORBA::Boolean enable_network_priority
00301                                                        )
00302 {
00303   TAO_StreamControl_Protocol_Properties *tmp = 0;
00304   ACE_NEW_THROW_EX (tmp,
00305                     TAO_StreamControl_Protocol_Properties (
00306                                                   send_buffer_size,
00307                                                   recv_buffer_size,
00308                                                   keep_alive,
00309                                                   dont_route,
00310                                                   no_delay,
00311                                                   enable_network_priority),
00312                     CORBA::NO_MEMORY (TAO::VMCID,
00313                                       CORBA::COMPLETED_NO));
00314 
00315   return tmp;
00316 }
00317 
00318 RTCORBA::ThreadpoolId
00319 TAO_RT_ORB::create_threadpool (CORBA::ULong stacksize,
00320                                CORBA::ULong static_threads,
00321                                CORBA::ULong dynamic_threads,
00322                                RTCORBA::Priority default_priority,
00323                                CORBA::Boolean allow_request_buffering,
00324                                CORBA::ULong max_buffered_requests,
00325                                CORBA::ULong max_request_buffer_size
00326                                )
00327 {
00328   return this->tp_manager_->create_threadpool (stacksize,
00329                                                static_threads,
00330                                                dynamic_threads,
00331                                                default_priority,
00332                                                allow_request_buffering,
00333                                                max_buffered_requests,
00334                                                max_request_buffer_size,
00335                                                this->lifespan_,
00336                                                this->dynamic_thread_time_);
00337 }
00338 
00339 RTCORBA::ThreadpoolId
00340 TAO_RT_ORB::create_threadpool_with_lanes (CORBA::ULong stacksize,
00341                                           const RTCORBA::ThreadpoolLanes &lanes,
00342                                           CORBA::Boolean allow_borrowing,
00343                                           CORBA::Boolean allow_request_buffering,
00344                                           CORBA::ULong max_buffered_requests,
00345                                           CORBA::ULong max_request_buffer_size)
00346 {
00347   return this->tp_manager_->create_threadpool_with_lanes (stacksize,
00348                                                           lanes,
00349                                                           allow_borrowing,
00350                                                           allow_request_buffering,
00351                                                           max_buffered_requests,
00352                                                           max_request_buffer_size,
00353                                                           this->lifespan_,
00354                                                           this->dynamic_thread_time_);
00355 }
00356 
00357 void
00358 TAO_RT_ORB::destroy_threadpool (RTCORBA::ThreadpoolId threadpool)
00359 {
00360   this->tp_manager_->destroy_threadpool (threadpool);
00361 }
00362 
00363 RTCORBA::PriorityModelPolicy_ptr
00364 TAO_RT_ORB::create_priority_model_policy (RTCORBA::PriorityModel priority_model,
00365                                           RTCORBA::Priority server_priority)
00366 {
00367   TAO_PriorityModelPolicy *tmp = 0;
00368   ACE_NEW_THROW_EX (tmp,
00369                     TAO_PriorityModelPolicy (priority_model, server_priority),
00370                     CORBA::NO_MEMORY (TAO::VMCID,
00371                                       CORBA::COMPLETED_NO));
00372 
00373   return tmp;
00374 }
00375 
00376 RTCORBA::ThreadpoolPolicy_ptr
00377 TAO_RT_ORB::create_threadpool_policy (RTCORBA::ThreadpoolId threadpool)
00378 {
00379   TAO_ThreadpoolPolicy *tmp = 0;
00380   ACE_NEW_THROW_EX (tmp,
00381                     TAO_ThreadpoolPolicy (threadpool),
00382                     CORBA::NO_MEMORY (TAO::VMCID,
00383                                       CORBA::COMPLETED_NO));
00384 
00385   return tmp;
00386 }
00387 
00388 RTCORBA::PriorityBandedConnectionPolicy_ptr
00389 TAO_RT_ORB::create_priority_banded_connection_policy (const
00390                                                       RTCORBA::PriorityBands & priority_bands)
00391 {
00392   TAO_PriorityBandedConnectionPolicy *tmp = 0;
00393   ACE_NEW_THROW_EX (tmp,
00394                     TAO_PriorityBandedConnectionPolicy (priority_bands),
00395                     CORBA::NO_MEMORY (TAO::VMCID,
00396                                       CORBA::COMPLETED_NO));
00397 
00398   return tmp;
00399 }
00400 
00401 RTCORBA::PrivateConnectionPolicy_ptr
00402 TAO_RT_ORB::create_private_connection_policy (void)
00403 {
00404   TAO_PrivateConnectionPolicy *tmp = 0;
00405   ACE_NEW_THROW_EX (tmp,
00406                     TAO_PrivateConnectionPolicy (),
00407                     CORBA::NO_MEMORY (TAO::VMCID,
00408                                       CORBA::COMPLETED_NO));
00409 
00410   return tmp;
00411 }
00412 
00413 RTCORBA::ServerProtocolPolicy_ptr
00414 TAO_RT_ORB::create_server_protocol_policy (const RTCORBA::ProtocolList & protocols)
00415 {
00416   TAO_ServerProtocolPolicy *tmp = 0;
00417   ACE_NEW_THROW_EX (tmp,
00418                     TAO_ServerProtocolPolicy (protocols),
00419                     CORBA::NO_MEMORY (TAO::VMCID,
00420                                       CORBA::COMPLETED_NO));
00421 
00422   return tmp;
00423 }
00424 
00425 RTCORBA::ClientProtocolPolicy_ptr
00426 TAO_RT_ORB::create_client_protocol_policy (const RTCORBA::ProtocolList & protocols)
00427 {
00428   TAO_ClientProtocolPolicy *tmp = 0;
00429   ACE_NEW_THROW_EX (tmp,
00430                     TAO_ClientProtocolPolicy (protocols),
00431                     CORBA::NO_MEMORY (TAO::VMCID,
00432                                       CORBA::COMPLETED_NO));
00433 
00434   return tmp;
00435 }
00436 
00437 TAO_Thread_Pool_Manager &
00438 TAO_RT_ORB::tp_manager (void) const
00439 {
00440   return *this->tp_manager_;
00441 }
00442 
00443 TAO_ORB_Core *
00444 TAO_RT_ORB::orb_core (void) const
00445 {
00446   return this->orb_core_;
00447 }
00448 
00449 /* static */
00450 int
00451 TAO_RT_ORB::modify_thread_scheduling_policy (CORBA::ORB_ptr orb)
00452 {
00453   //
00454   // This method changes the scheduling policy of the calling thread
00455   // to match the scheduling policy specified in the svc.conf file.
00456   // The priority of the calling thread will be set to the minimum
00457   // priority supported by that scheduling policy.
00458   //
00459   // This method make sense on those platform (e.g., Linux) where
00460   // PTHREAD_SCOPE_SYSTEM is the only scheduling scope supported.  On
00461   // other platforms, this method is a no-op since the only way to get
00462   // the real-time threading behavior is to setup the
00463   // PTHREAD_SCOPE_SYSTEM scheduling scope when a thread is being
00464   // created.  On such platforms, one can set the correct scheduling
00465   // scope and policy when creating the thread, thus not needing to
00466   // use this method.
00467   //
00468 
00469 #if defined (linux)
00470 
00471   int const sched_policy = orb->orb_core ()->orb_params ()->ace_sched_policy ();
00472 
00473   int const minimum_priority = ACE_Sched_Params::priority_min (sched_policy);
00474 
00475   ACE_hthread_t thread_id;
00476   ACE_Thread::self (thread_id);
00477 
00478   return ACE_Thread::setprio (thread_id, minimum_priority, sched_policy);
00479 
00480 #else /* linux */
00481 
00482   ACE_UNUSED_ARG (orb);
00483   ACE_NOTSUP_RETURN (-1);
00484 
00485 #endif /* linux */
00486 
00487 }
00488 
00489 TAO_END_VERSIONED_NAMESPACE_DECL
00490 
00491 ///////////////////////////////////////////////////////////////////////////////
00492 
00493 #endif /* TAO_HAS_CORBA_MESSAGING && TAO_HAS_CORBA_MESSAGING != 0 */