TAO/tao/RTCORBA/RT_ORB.cpp

   1 #include "tao/RTCORBA/RT_ORB.h"
   2
   3 #if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
   4
   5 #include "tao/RTCORBA/RT_Policy_i.h"
   6 #include "tao/RTCORBA/RT_Mutex.h"
   7 #include "tao/RTCORBA/Priority_Mapping_Manager.h"
   8 #include "tao/ORB_Core.h"
   9 #include "tao/ORB.h"
  10 #include "tao/SystemException.h"
  11 #include "tao/RTCORBA/Thread_Pool.h"
  12 #include "tao/RTCORBA/RT_Thread_Lane_Resources_Manager.h"
  13 #include "ace/Sched_Params.h"
  14
  15 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  16
  17 TAO_RT_ORB::TAO_RT_ORB (TAO_ORB_Core *orb_core,
  18                         TAO_RT_ORBInitializer::TAO_RTCORBA_DT_LifeSpan lifespan,
  19                         ACE_Time_Value const &dynamic_thread_time)
  20   : orb_core_ (orb_core),
  21     mutex_mgr_ (),
  22     tp_manager_ (0),
  23     lifespan_ (lifespan),
  24     dynamic_thread_time_ (dynamic_thread_time)
  25 {
  26   TAO_Thread_Lane_Resources_Manager *thread_lane_resources_manager =
  27     &this->orb_core_->thread_lane_resources_manager ();
  28
  29   TAO_RT_Thread_Lane_Resources_Manager *rt_thread_lane_resources_manager =
  30     dynamic_cast <TAO_RT_Thread_Lane_Resources_Manager *> (thread_lane_resources_manager);
  31
  32   if (!rt_thread_lane_resources_manager)
  33     throw CORBA::INTERNAL ();
  34
  35   this->tp_manager_ =
  36     &rt_thread_lane_resources_manager->tp_manager ();
  37 }
  38
  39 TAO_RT_ORB::~TAO_RT_ORB ()
  40 {
  41 }
  42
  43 RTCORBA::Mutex_ptr
  44 TAO_RT_ORB::create_mutex ()
  45 {
  46   return this->mutex_mgr_.create_mutex ();
  47 }
  48
  49 void
  50 TAO_RT_ORB::destroy_mutex (RTCORBA::Mutex_ptr mutex)
  51 {
  52   this->mutex_mgr_.destroy_mutex (mutex);
  53 }
  54
  55
  56 RTCORBA::Mutex_ptr
  57 TAO_RT_ORB::create_named_mutex (const char *name,
  58                                 CORBA::Boolean_out created_flag)
  59 {
  60   return this->mutex_mgr_.create_named_mutex (name, created_flag);
  61 }
  62
  63 RTCORBA::Mutex_ptr
  64 TAO_RT_ORB::open_named_mutex (const char *name)
  65 {
  66   return this->mutex_mgr_.open_named_mutex (name);
  67 }
  68
  69 ////////////////////////////////////////////////////////////////////////////////
  70
  71 TAO_Named_RT_Mutex_Manager::TAO_Named_RT_Mutex_Manager ()
  72 {
  73 }
  74
  75 TAO_Named_RT_Mutex_Manager::~TAO_Named_RT_Mutex_Manager ()
  76 {
  77 }
  78
  79 RTCORBA::Mutex_ptr
  80 TAO_Named_RT_Mutex_Manager::create_mutex ()
  81 {
  82   TAO_RT_Mutex *mutex = 0;
  83   ACE_NEW_THROW_EX (mutex,
  84                     TAO_RT_Mutex (),
  85                     CORBA::NO_MEMORY (
  86                       CORBA::SystemException::_tao_minor_code (
  87                         TAO::VMCID,
  88                         ENOMEM),
  89                       CORBA::COMPLETED_NO));
  90
  91   return mutex;
  92 }
  93
  94 // If Named RT_Mutexes aren't enabled, this function is a nop
  95 // as also indicated by the comment below.
  96 #if (TAO_HAS_NAMED_RT_MUTEXES == 1)
  97 void
  98 TAO_Named_RT_Mutex_Manager::destroy_mutex (RTCORBA::Mutex_ptr mutex)
  99 {
 100   TAO_RT_Mutex *tao_mutex =
 101     dynamic_cast<TAO_RT_Mutex *> (mutex);
 102
 103   // If this mutex is named, then we need to remove it from our table.
 104   // Otherwise, we don't have to do anything.
 105   const char *name = tao_mutex->name ();
 106   if (name != 0)
 107     {
 108       // The following should be atomic.
 109       ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX,
 110                           monitor,
 111                           this->lock_,
 112                           CORBA::INTERNAL ());
 113
 114       int result =
 115         this->map_.unbind (name);
 116
 117       if (result != 0)
 118         throw ::CORBA::INTERNAL ();
 119     }
 120 }
 121 #else /* TAO_HAS_NAMED_RT_MUTEXES == 1 */
 122 void
 123 TAO_Named_RT_Mutex_Manager::destroy_mutex (RTCORBA::Mutex_ptr)
 124 {
 125 }
 126 #endif /* TAO_HAS_NAMED_RT_MUTEXES == 1 */
 127
 128 RTCORBA::Mutex_ptr
 129 TAO_Named_RT_Mutex_Manager::create_named_mutex (const char *name,
 130                                                 CORBA::Boolean_out created_flag)
 131 {
 132 #if (TAO_HAS_NAMED_RT_MUTEXES == 1)
 133   // The following should be atomic.
 134   ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX,
 135                       monitor,
 136                       this->lock_,
 137                       CORBA::INTERNAL ());
 138
 139   // Optimistic that we'll find it.
 140   created_flag = false;
 141
 142   // If we find the mutex, simply return it.
 143   RTCORBA::Mutex_var mutex;
 144   if (this->map_.find (name, mutex) != 0)
 145     {
 146       // Oops, we didn't find it.
 147       created_flag = true;
 148
 149       RTCORBA::Mutex_ptr tmp_mutex;
 150
 151       // Create a new one.
 152       ACE_NEW_THROW_EX (tmp_mutex,
 153                         TAO_Named_RT_Mutex (name),
 154                         CORBA::NO_MEMORY (
 155                           CORBA::SystemException::_tao_minor_code (
 156                             TAO::VMCID,
 157                             ENOMEM),
 158                           CORBA::COMPLETED_NO));
 159
 160       mutex = tmp_mutex;
 161
 162       // Add it to the map.
 163       int const result = this->map_.bind (name, mutex);
 164
 165       if (result != 0)
 166         throw ::CORBA::INTERNAL ();
 167     }
 168
 169   // Return the one we found or created.
 170   return mutex._retn ();
 171 #else /* TAO_HAS_NAMED_RT_MUTEXES */
 172   ACE_UNUSED_ARG (name);
 173   ACE_UNUSED_ARG (created_flag);
 174   throw ::CORBA::NO_IMPLEMENT ();
 175 #endif /* TAO_HAS_NAMED_RT_MUTEXES */
 176 }
 177
 178 RTCORBA::Mutex_ptr
 179 TAO_Named_RT_Mutex_Manager::open_named_mutex (const char *name)
 180 {
 181 #if (TAO_HAS_NAMED_RT_MUTEXES == 1)
 182   // The following should be atomic.
 183   ACE_GUARD_THROW_EX (TAO_SYNCH_MUTEX,
 184                       monitor,
 185                       this->lock_,
 186                       CORBA::INTERNAL ());
 187
 188   // If we find the mutex, simply return it.
 189   RTCORBA::Mutex_var mutex;
 190   if (this->map_.find (name, mutex) != 0)
 191     throw RTCORBA::RTORB::MutexNotFound ();
 192
 193   // Return the one we found.
 194   return mutex._retn ();
 195 #else /* TAO_HAS_NAMED_RT_MUTEXES */
 196   ACE_UNUSED_ARG (name);
 197   throw ::CORBA::NO_IMPLEMENT ();
 198 #endif /* TAO_HAS_NAMED_RT_MUTEXES */
 199 }
 200
 201 ///////////////////////////////////////////////////////////////////////////////
 202
 203 RTCORBA::TCPProtocolProperties_ptr
 204 TAO_RT_ORB::create_tcp_protocol_properties (CORBA::Long send_buffer_size,
 205                                             CORBA::Long recv_buffer_size,
 206                                             CORBA::Boolean keep_alive,
 207                                             CORBA::Boolean dont_route,
 208                                             CORBA::Boolean no_delay,
 209                                             CORBA::Boolean enable_network_priority)
 210 {
 211   TAO_TCP_Protocol_Properties *tmp = 0;
 212   ACE_NEW_THROW_EX (tmp,
 213                     TAO_TCP_Protocol_Properties (send_buffer_size,
 214                                         recv_buffer_size,
 215                                         keep_alive,
 216                                         dont_route,
 217                                         no_delay,
 218                                         enable_network_priority),
 219                     CORBA::NO_MEMORY (TAO::VMCID,
 220                                       CORBA::COMPLETED_NO));
 221
 222   return tmp;
 223 }
 224
 225 RTCORBA::UnixDomainProtocolProperties_ptr
 226 TAO_RT_ORB::create_unix_domain_protocol_properties (
 227                                                     CORBA::Long send_buffer_size,
 228                                                     CORBA::Long recv_buffer_size)
 229 {
 230   TAO_UnixDomain_Protocol_Properties *tmp = 0;
 231   ACE_NEW_THROW_EX (tmp,
 232                     TAO_UnixDomain_Protocol_Properties (
 233                                                send_buffer_size,
 234                                                recv_buffer_size),
 235                     CORBA::NO_MEMORY (TAO::VMCID,
 236                                       CORBA::COMPLETED_NO));
 237
 238   return tmp;
 239 }
 240
 241 RTCORBA::SharedMemoryProtocolProperties_ptr
 242 TAO_RT_ORB::create_shared_memory_protocol_properties (
 243                                                       CORBA::Long send_buffer_size,
 244                                                       CORBA::Long recv_buffer_size,
 245                                                       CORBA::Boolean keep_alive,
 246                                                       CORBA::Boolean dont_route,
 247                                                       CORBA::Boolean no_delay,
 248                                                       CORBA::Long preallocate_buffer_size,
 249                                                       const char *mmap_filename,
 250                                                       const char *mmap_lockname)
 251 {
 252   TAO_SharedMemory_Protocol_Properties *tmp = 0;
 253   ACE_NEW_THROW_EX (tmp,
 254                     TAO_SharedMemory_Protocol_Properties (send_buffer_size,
 255                                                           recv_buffer_size,
 256                                                           keep_alive,
 257                                                           dont_route,
 258                                                           no_delay,
 259                                                           preallocate_buffer_size,
 260                                                           mmap_filename,
 261                                                           mmap_lockname),
 262                     CORBA::NO_MEMORY (TAO::VMCID,
 263                                       CORBA::COMPLETED_NO));
 264
 265   return tmp;
 266 }
 267
 268 RTCORBA::UserDatagramProtocolProperties_ptr
 269 TAO_RT_ORB::create_user_datagram_protocol_properties (
 270                                                       CORBA::Long send_buffer_size,
 271                                                       CORBA::Long recv_buffer_size,
 272                                                       CORBA::Boolean enable_network_priority)
 273 {
 274   TAO_UserDatagram_Protocol_Properties *tmp = 0;
 275   ACE_NEW_THROW_EX (tmp,
 276                     TAO_UserDatagram_Protocol_Properties (
 277                                                  send_buffer_size,
 278                                                  recv_buffer_size,
 279                                                  enable_network_priority),
 280                     CORBA::NO_MEMORY (TAO::VMCID,
 281                                       CORBA::COMPLETED_NO));
 282
 283   return tmp;
 284 }
 285
 286 RTCORBA::StreamControlProtocolProperties_ptr
 287 TAO_RT_ORB::create_stream_control_protocol_properties (
 288                                                        CORBA::Long send_buffer_size,
 289                                                        CORBA::Long recv_buffer_size,
 290                                                        CORBA::Boolean keep_alive,
 291                                                        CORBA::Boolean dont_route,
 292                                                        CORBA::Boolean no_delay,
 293                                                        CORBA::Boolean enable_network_priority)
 294 {
 295   TAO_StreamControl_Protocol_Properties *tmp = 0;
 296   ACE_NEW_THROW_EX (tmp,
 297                     TAO_StreamControl_Protocol_Properties (
 298                                                   send_buffer_size,
 299                                                   recv_buffer_size,
 300                                                   keep_alive,
 301                                                   dont_route,
 302                                                   no_delay,
 303                                                   enable_network_priority),
 304                     CORBA::NO_MEMORY (TAO::VMCID,
 305                                       CORBA::COMPLETED_NO));
 306
 307   return tmp;
 308 }
 309
 310 RTCORBA::ThreadpoolId
 311 TAO_RT_ORB::create_threadpool (CORBA::ULong stacksize,
 312                                CORBA::ULong static_threads,
 313                                CORBA::ULong dynamic_threads,
 314                                RTCORBA::Priority default_priority,
 315                                CORBA::Boolean allow_request_buffering,
 316                                CORBA::ULong max_buffered_requests,
 317                                CORBA::ULong max_request_buffer_size)
 318 {
 319   return this->tp_manager_->create_threadpool (stacksize,
 320                                                static_threads,
 321                                                dynamic_threads,
 322                                                default_priority,
 323                                                allow_request_buffering,
 324                                                max_buffered_requests,
 325                                                max_request_buffer_size,
 326                                                this->lifespan_,
 327                                                this->dynamic_thread_time_);
 328 }
 329
 330 RTCORBA::ThreadpoolId
 331 TAO_RT_ORB::create_threadpool_with_lanes (CORBA::ULong stacksize,
 332                                           const RTCORBA::ThreadpoolLanes &lanes,
 333                                           CORBA::Boolean allow_borrowing,
 334                                           CORBA::Boolean allow_request_buffering,
 335                                           CORBA::ULong max_buffered_requests,
 336                                           CORBA::ULong max_request_buffer_size)
 337 {
 338   return this->tp_manager_->create_threadpool_with_lanes (stacksize,
 339                                                           lanes,
 340                                                           allow_borrowing,
 341                                                           allow_request_buffering,
 342                                                           max_buffered_requests,
 343                                                           max_request_buffer_size,
 344                                                           this->lifespan_,
 345                                                           this->dynamic_thread_time_);
 346 }
 347
 348 void
 349 TAO_RT_ORB::destroy_threadpool (RTCORBA::ThreadpoolId threadpool)
 350 {
 351   this->tp_manager_->destroy_threadpool (threadpool);
 352 }
 353
 354 RTCORBA::PriorityModelPolicy_ptr
 355 TAO_RT_ORB::create_priority_model_policy (RTCORBA::PriorityModel priority_model,
 356                                           RTCORBA::Priority server_priority)
 357 {
 358   TAO_PriorityModelPolicy *tmp = 0;
 359   ACE_NEW_THROW_EX (tmp,
 360                     TAO_PriorityModelPolicy (priority_model, server_priority),
 361                     CORBA::NO_MEMORY (TAO::VMCID,
 362                                       CORBA::COMPLETED_NO));
 363
 364   return tmp;
 365 }
 366
 367 RTCORBA::ThreadpoolPolicy_ptr
 368 TAO_RT_ORB::create_threadpool_policy (RTCORBA::ThreadpoolId threadpool)
 369 {
 370   TAO_ThreadpoolPolicy *tmp = 0;
 371   ACE_NEW_THROW_EX (tmp,
 372                     TAO_ThreadpoolPolicy (threadpool),
 373                     CORBA::NO_MEMORY (TAO::VMCID,
 374                                       CORBA::COMPLETED_NO));
 375
 376   return tmp;
 377 }
 378
 379 RTCORBA::PriorityBandedConnectionPolicy_ptr
 380 TAO_RT_ORB::create_priority_banded_connection_policy (const
 381                                                       RTCORBA::PriorityBands & priority_bands)
 382 {
 383   TAO_PriorityBandedConnectionPolicy *tmp = 0;
 384   ACE_NEW_THROW_EX (tmp,
 385                     TAO_PriorityBandedConnectionPolicy (priority_bands),
 386                     CORBA::NO_MEMORY (TAO::VMCID,
 387                                       CORBA::COMPLETED_NO));
 388
 389   return tmp;
 390 }
 391
 392 RTCORBA::PrivateConnectionPolicy_ptr
 393 TAO_RT_ORB::create_private_connection_policy ()
 394 {
 395   TAO_PrivateConnectionPolicy *tmp = 0;
 396   ACE_NEW_THROW_EX (tmp,
 397                     TAO_PrivateConnectionPolicy (),
 398                     CORBA::NO_MEMORY (TAO::VMCID,
 399                                       CORBA::COMPLETED_NO));
 400
 401   return tmp;
 402 }
 403
 404 RTCORBA::ServerProtocolPolicy_ptr
 405 TAO_RT_ORB::create_server_protocol_policy (const RTCORBA::ProtocolList & protocols)
 406 {
 407   TAO_ServerProtocolPolicy *tmp = 0;
 408   ACE_NEW_THROW_EX (tmp,
 409                     TAO_ServerProtocolPolicy (protocols),
 410                     CORBA::NO_MEMORY (TAO::VMCID,
 411                                       CORBA::COMPLETED_NO));
 412
 413   return tmp;
 414 }
 415
 416 RTCORBA::ClientProtocolPolicy_ptr
 417 TAO_RT_ORB::create_client_protocol_policy (const RTCORBA::ProtocolList & protocols)
 418 {
 419   TAO_ClientProtocolPolicy *tmp = 0;
 420   ACE_NEW_THROW_EX (tmp,
 421                     TAO_ClientProtocolPolicy (protocols),
 422                     CORBA::NO_MEMORY (TAO::VMCID,
 423                                       CORBA::COMPLETED_NO));
 424
 425   return tmp;
 426 }
 427
 428 TAO_Thread_Pool_Manager &
 429 TAO_RT_ORB::tp_manager () const
 430 {
 431   return *this->tp_manager_;
 432 }
 433
 434 TAO_ORB_Core *
 435 TAO_RT_ORB::orb_core () const
 436 {
 437   return this->orb_core_;
 438 }
 439
 440 /* static */
 441 int
 442 TAO_RT_ORB::modify_thread_scheduling_policy (CORBA::ORB_ptr orb)
 443 {
 444   // This method changes the scheduling policy of the calling thread
 445   // to match the scheduling policy specified in the svc.conf file.
 446   // The priority of the calling thread will be set to the minimum
 447   // priority supported by that scheduling policy.
 448   //
 449   // This method make sense on those platform (e.g., Linux) where
 450   // PTHREAD_SCOPE_SYSTEM is the only scheduling scope supported.  On
 451   // other platforms, this method is a no-op since the only way to get
 452   // the real-time threading behavior is to setup the
 453   // PTHREAD_SCOPE_SYSTEM scheduling scope when a thread is being
 454   // created.  On such platforms, one can set the correct scheduling
 455   // scope and policy when creating the thread, thus not needing to
 456   // use this method.
 457
 458 #if !defined (ACE_LACKS_THREAD_PROCESS_SCOPING) && defined (ACE_LACKS_PTHREAD_SCOPE_PROCESS)
 459
 460   int const sched_policy = orb->orb_core ()->orb_params ()->ace_sched_policy ();
 461
 462   int const minimum_priority = ACE_Sched_Params::priority_min (sched_policy);
 463
 464   ACE_hthread_t thread_id;
 465   ACE_Thread::self (thread_id);
 466
 467   return ACE_Thread::setprio (thread_id, minimum_priority, sched_policy);
 468
 469 #else /* !ACE_LACKS_THREAD_PROCESS_SCOPING && ACE_LACKS_PTHREAD_SCOPE_PROCESS */
 470
 471   ACE_UNUSED_ARG (orb);
 472   ACE_NOTSUP_RETURN (-1);
 473
 474 #endif /* linux */
 475
 476 }
 477
 478 TAO_END_VERSIONED_NAMESPACE_DECL
 479
 480 ///////////////////////////////////////////////////////////////////////////////
 481
 482 #endif /* TAO_HAS_CORBA_MESSAGING && TAO_HAS_CORBA_MESSAGING != 0 */