TAO: TAO_Thread_Lane_Resources class Reference

00027   : orb_core_ (orb_core),
00028     acceptor_registry_ (0),
00029     connector_registry_ (0),
00030     transport_cache_ (0),
00031     leader_follower_ (0),
00032     new_leader_generator_ (new_leader_generator),
00033     input_cdr_dblock_allocator_ (0),
00034     input_cdr_buffer_allocator_ (0),
00035     input_cdr_msgblock_allocator_ (0),
00036     transport_message_buffer_allocator_ (0),
00037     output_cdr_dblock_allocator_ (0),
00038     output_cdr_buffer_allocator_ (0),
00039     output_cdr_msgblock_allocator_ (0),
00040     amh_response_handler_allocator_ (0),
00041     ami_response_handler_allocator_ (0)
00042 {
00043   // Create the transport cache.
00044   ACE_NEW (this->transport_cache_,
00045            TAO::Transport_Cache_Manager (orb_core));
00046 
00047 }

00050 {
00051 
00052 }

00079 {
00080   // Double check.
00081   if (this->acceptor_registry_ == 0)
00082     {
00083       // @todo: Wouldnt this crash big time if you happen to
00084       // dereference a null-pointer? Needs fixing.
00085       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX,
00086                         ace_mon,
00087                         this->lock_,
00088                         *this->acceptor_registry_);
00089 
00090       if (this->acceptor_registry_ == 0)
00091         {
00092           // @@ Not exception safe code
00093           // Get the resource factory.
00094           TAO_Resource_Factory &resource_factory =
00095             *this->orb_core_.resource_factory ();
00096 
00097           // Ask it to create a new acceptor registry.
00098           this->acceptor_registry_ =
00099             resource_factory.get_acceptor_registry ();
00100         }
00101     }
00102 
00103   return *this->acceptor_registry_;
00104 }

00310 {
00311   if (this->amh_response_handler_allocator_ == 0)
00312     {
00313       // Double checked locking
00314       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0);
00315 
00316       if (this->amh_response_handler_allocator_ == 0)
00317         {
00318           this->amh_response_handler_allocator_ =
00319             this->resource_factory ()->amh_response_handler_allocator ();
00320         }
00321     }
00322 
00323   return this->amh_response_handler_allocator_;
00324 }

00328 {
00329   if (this->ami_response_handler_allocator_ == 0)
00330     {
00331       // Double checked locking
00332       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0);
00333 
00334       if (this->ami_response_handler_allocator_ == 0)
00335         {
00336           this->ami_response_handler_allocator_ =
00337             this->resource_factory ()->ami_response_handler_allocator ();
00338         }
00339     }
00340 
00341   return this->ami_response_handler_allocator_;
00342 }

00519 {
00520   // If we have no-drop-reply strategy or already fininalized simply return.
00521   if (!this->orb_core_.resource_factory ()->drop_replies_during_shutdown () ||
00522        this->transport_cache_ == 0)
00523     return;
00524 
00525   // Set of handlers still in the connection cache.
00526   TAO::Connection_Handler_Set handlers;
00527 
00528   this->transport_cache_->blockable_client_transports (handlers);
00529 
00530   // Go through the handler set, closing the connections and removing
00531   // the references.
00532   TAO_Connection_Handler **handler = 0;
00533 
00534   for (TAO::Connection_Handler_Set::iterator iter (handlers);
00535        iter.next (handler);
00536        iter.advance ())
00537     {
00538       // Connection is closed. There will be a double closure but that
00539       // is okay.
00540       (*handler)->release_os_resources ();
00541 
00542       // #REFCOUNT# related to the handler set decreases.
00543       (*handler)->transport ()->remove_reference ();
00544     }
00545 }

00108 {
00109   // Double check.
00110   if (this->connector_registry_ == 0)
00111     {
00112       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX,
00113                         ace_mon,
00114                         this->lock_,
00115                         0);
00116 
00117       if (this->connector_registry_ == 0)
00118         {
00119           // Ask it to create a new acceptor registry.
00120           TAO_Connector_Registry *connector_registry =
00121             this->orb_core_.resource_factory ()->get_connector_registry ();
00122 
00123           if (connector_registry == 0)
00124             {
00125               throw ::CORBA::INITIALIZE (
00126                 CORBA::SystemException::_tao_minor_code (
00127                   TAO_CONNECTOR_REGISTRY_INIT_LOCATION_CODE,
00128                   0),
00129                 CORBA::COMPLETED_NO);
00130             }
00131 
00132           if (connector_registry->open (&this->orb_core_) != 0)
00133             {
00134               throw ::CORBA::INITIALIZE (
00135                 CORBA::SystemException::_tao_minor_code (
00136                   TAO_CONNECTOR_REGISTRY_INIT_LOCATION_CODE,
00137                   0),
00138                 CORBA::COMPLETED_NO);
00139             }
00140 
00141           // Finally, everything is created and opened successfully:
00142           // now we can assign to the member.  Otherwise, the
00143           // assignment would be premature.
00144           this->connector_registry_ = connector_registry;
00145         }
00146     }
00147 
00148   return this->connector_registry_;
00149 }

00370 {
00371   // Close connectors before acceptors!
00372   // Ask the registry to close all registered connectors.
00373   if (this->connector_registry_ != 0)
00374     {
00375       this->connector_registry_->close_all ();
00376       delete this->connector_registry_;
00377       this->connector_registry_ = 0;
00378     }
00379 
00380   // Ask the registry to close all registered acceptors.
00381   if (this->acceptor_registry_ != 0)
00382     {
00383       this->acceptor_registry_->close_all ();
00384       delete this->acceptor_registry_;
00385       this->acceptor_registry_ = 0;
00386     }
00387 
00388   // Set of handlers still in the connection cache.
00389   TAO::Connection_Handler_Set handlers;
00390 
00391   // Close the transport cache and return the handlers that were still
00392   // registered.  The cache will decrease the #REFCOUNT# on the
00393   // handler when it removes the handler from cache.  However,
00394   // #REFCOUNT# is increased when the handler is placed in the handler
00395   // set.
00396   this->transport_cache_->close (handlers);
00397 
00398   // Go through the handler set, closing the connections and removing
00399   // the references.
00400   TAO_Connection_Handler **handler = 0;
00401 
00402   for (TAO::Connection_Handler_Set::iterator iter (handlers);
00403        iter.next (handler);
00404        iter.advance ())
00405     {
00406       // Connection is closed.  Potential removal from the Reactor.
00407       (*handler)->close_connection ();
00408 
00409       // #REFCOUNT# related to the handler set decreases.
00410       (*handler)->transport ()->remove_reference ();
00411     }
00412 
00413   delete this->transport_cache_;
00414   this->transport_cache_ = 0;
00415 
00416   delete this->leader_follower_;
00417   this->leader_follower_ = 0;
00418 
00419   // Delete all the allocators here.. They shouldnt be done earlier,
00420   // lest some of the contents in the above, say reactor or acceptor
00421   // may use memory from the pool..
00422   if (this->input_cdr_dblock_allocator_ != 0)
00423     {
00424       this->input_cdr_dblock_allocator_->remove ();
00425       delete this->input_cdr_dblock_allocator_;
00426       this->input_cdr_dblock_allocator_ = 0;
00427     }
00428 
00429   if (this->input_cdr_buffer_allocator_ != 0)
00430     {
00431       this->input_cdr_buffer_allocator_->remove ();
00432       delete this->input_cdr_buffer_allocator_;
00433       this->input_cdr_buffer_allocator_ = 0;
00434     }
00435 
00436   if (this->input_cdr_msgblock_allocator_ != 0)
00437     {
00438       this->input_cdr_msgblock_allocator_->remove ();
00439       delete this->input_cdr_msgblock_allocator_;
00440       this->input_cdr_msgblock_allocator_ = 0;
00441     }
00442 
00443   if (this->transport_message_buffer_allocator_ != 0)
00444     {
00445       this->transport_message_buffer_allocator_->remove ();
00446       delete this->transport_message_buffer_allocator_;
00447       this->transport_message_buffer_allocator_ = 0;
00448     }
00449 
00450   if (this->output_cdr_dblock_allocator_ != 0)
00451     {
00452       this->output_cdr_dblock_allocator_->remove ();
00453       delete this->output_cdr_dblock_allocator_;
00454       this->output_cdr_dblock_allocator_ = 0;
00455     }
00456 
00457   if (this->output_cdr_buffer_allocator_ != 0)
00458     {
00459       this->output_cdr_buffer_allocator_->remove ();
00460       delete this->output_cdr_buffer_allocator_;
00461       this->output_cdr_buffer_allocator_ = 0;
00462     }
00463 
00464   if (this->output_cdr_msgblock_allocator_ != 0)
00465     {
00466       this->output_cdr_msgblock_allocator_->remove ();
00467       delete this->output_cdr_msgblock_allocator_;
00468       this->output_cdr_msgblock_allocator_ = 0;
00469     }
00470 
00471   if (this->amh_response_handler_allocator_ != 0)
00472     {
00473       this->amh_response_handler_allocator_->remove ();
00474       delete this->amh_response_handler_allocator_;
00475       this->amh_response_handler_allocator_ = 0;
00476     }
00477 
00478   if (this->ami_response_handler_allocator_ != 0)
00479     {
00480       this->ami_response_handler_allocator_->remove ();
00481       delete this->ami_response_handler_allocator_;
00482       this->ami_response_handler_allocator_ = 0;
00483     }
00484 }

00062 {
00063   return this->acceptor_registry_ != 0;
00064 }

00198 {
00199   if (this->input_cdr_buffer_allocator_ == 0)
00200     {
00201       // Double checked locking
00202       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0);
00203 
00204       if (this->input_cdr_buffer_allocator_ == 0)
00205         {
00206           this->input_cdr_buffer_allocator_ =
00207             this->resource_factory ()->input_cdr_buffer_allocator ();
00208         }
00209     }
00210 
00211   return this->input_cdr_buffer_allocator_;
00212 }

00179 {
00180   if (this->input_cdr_dblock_allocator_ == 0)
00181     {
00182       // Double checked locking
00183       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0);
00184 
00185       if (this->input_cdr_dblock_allocator_ == 0)
00186         {
00187           this->input_cdr_dblock_allocator_ =
00188             this->resource_factory ()->input_cdr_dblock_allocator ();
00189         }
00190     }
00191 
00192   return this->input_cdr_dblock_allocator_;
00193 }

00217 {
00218   if (this->input_cdr_msgblock_allocator_ == 0)
00219     {
00220       // Double checked locking
00221       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0);
00222 
00223       if (this->input_cdr_msgblock_allocator_ == 0)
00224         {
00225           this->input_cdr_msgblock_allocator_ =
00226             this->resource_factory ()->input_cdr_msgblock_allocator ();
00227         }
00228     }
00229 
00230   return this->input_cdr_msgblock_allocator_;
00231 }

00068 {
00069   if (!this->has_acceptor_registry_been_created ())
00070     {
00071       return 0;
00072     }
00073 
00074   return this->acceptor_registry ().is_collocated (mprofile);
00075 }

00154 {
00155   // Double check.
00156   if (this->leader_follower_ == 0)
00157     {
00158       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX,
00159                         ace_mon,
00160                         this->lock_,
00161                         *this->leader_follower_);
00162 
00163       if (this->leader_follower_ == 0)
00164         {
00165           // Create a new Leader Follower object.
00166           ACE_NEW_RETURN (this->leader_follower_,
00167                           TAO_Leader_Follower (&this->orb_core_,
00168                                                this->new_leader_generator_),
00169                           *this->leader_follower_);
00170         }
00171     }
00172 
00173   return *this->leader_follower_;
00174 }

00348 {
00349   // Access the acceptor registry.
00350   TAO_Acceptor_Registry &ar = this->acceptor_registry ();
00351 
00352   // Open it.
00353   int result = ar.open (&this->orb_core_,
00354                         this->leader_follower ().reactor (),
00355                         endpoint_set,
00356                         ignore_address
00357                        );
00358 
00359   return result;
00360 }

00273 {
00274   if (this->output_cdr_buffer_allocator_ == 0)
00275     {
00276       // Double checked locking
00277       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0);
00278 
00279       if (this->output_cdr_buffer_allocator_ == 0)
00280         {
00281           this->output_cdr_buffer_allocator_ =
00282             this->resource_factory ()->output_cdr_buffer_allocator ();
00283         }
00284     }
00285 
00286   return this->output_cdr_buffer_allocator_;
00287 }

00254 {
00255   if (this->output_cdr_dblock_allocator_ == 0)
00256     {
00257       // Double checked locking
00258       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0);
00259 
00260       if (this->output_cdr_dblock_allocator_ == 0)
00261         {
00262           this->output_cdr_dblock_allocator_ =
00263             this->resource_factory ()->output_cdr_dblock_allocator ();
00264         }
00265     }
00266 
00267   return this->output_cdr_dblock_allocator_;
00268 }

00292 {
00293   if (this->output_cdr_msgblock_allocator_ == 0)
00294     {
00295       // Double checked locking
00296       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0);
00297 
00298       if (this->output_cdr_msgblock_allocator_ == 0)
00299         {
00300           this->output_cdr_msgblock_allocator_ =
00301             this->resource_factory ()->output_cdr_msgblock_allocator ();
00302         }
00303     }
00304 
00305   return this->output_cdr_msgblock_allocator_;
00306 }

00364 {
00365   return this->orb_core_.resource_factory ();
00366 }

00488 {
00489   TAO_Leader_Follower &leader_follower = this->leader_follower ();
00490 
00491   ACE_GUARD (TAO_SYNCH_MUTEX,
00492              ace_mon,
00493              leader_follower.lock ());
00494 
00495   ACE_Reactor *reactor = leader_follower.reactor ();
00496 
00497   // Wakeup all the threads waiting blocked in the event loop, this
00498   // does not guarantee that they will all go away, but reduces the
00499   // load on the POA....
00500 
00501   // If there are some client threads running we have to wait until
00502   // they finish, when the last one does it will shutdown the reactor
00503   // for us.  Meanwhile no new requests will be accepted because the
00504   // POA will not process them.
00505   if (!this->orb_core_.resource_factory ()->drop_replies_during_shutdown () &&
00506       leader_follower.has_clients ())
00507     {
00508       reactor->wakeup_all_threads ();
00509       return;
00510     }
00511 
00512   // End the reactor if we want shutdown dropping replies along the
00513   // way.
00514   reactor->end_reactor_event_loop ();
00515 }

00056 {
00057   return *this->transport_cache_;
00058 }

00235 {
00236   if (this->transport_message_buffer_allocator_ == 0)
00237     {
00238       // Double checked locking
00239       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->lock_, 0);
00240 
00241       if (this->transport_message_buffer_allocator_ == 0)
00242         {
00243           this->transport_message_buffer_allocator_ =
00244             this->resource_factory ()->input_cdr_dblock_allocator ();
00245         }
00246     }
00247 
00248   return this->transport_message_buffer_allocator_;
00249 }


Accessors
TAO_Acceptor_Registry &	acceptor_registry (void)
TAO_Connector_Registry *	connector_registry (void)
TAO::Transport_Cache_Manager &	transport_cache (void)
TAO_Leader_Follower &	leader_follower (void)
ACE_Allocator *	input_cdr_dblock_allocator (void)
ACE_Allocator *	input_cdr_buffer_allocator (void)
ACE_Allocator *	input_cdr_msgblock_allocator (void)
ACE_Allocator *	transport_message_buffer_allocator (void)
ACE_Allocator *	output_cdr_dblock_allocator (void)
ACE_Allocator *	output_cdr_buffer_allocator (void)
ACE_Allocator *	output_cdr_msgblock_allocator (void)
ACE_Allocator *	amh_response_handler_allocator (void)
ACE_Allocator *	ami_response_handler_allocator (void)
The allocators for the input CDR streams.
ACE_Allocator *	input_cdr_dblock_allocator_
ACE_Allocator *	input_cdr_buffer_allocator_
ACE_Allocator *	input_cdr_msgblock_allocator_
The allocators for the buffering messages in the transport.
ACE_Allocator *	transport_message_buffer_allocator_
The allocators for the output CDR streams.
ACE_Allocator *	output_cdr_dblock_allocator_
ACE_Allocator *	output_cdr_buffer_allocator_
ACE_Allocator *	output_cdr_msgblock_allocator_
The allocators for AMH.
ACE_Allocator *	amh_response_handler_allocator_
The allocators for AMI.
ACE_Allocator *	ami_response_handler_allocator_
Public Member Functions
	TAO_Thread_Lane_Resources (TAO_ORB_Core &orb_core, TAO_New_Leader_Generator *new_leader_generator=0)
	Constructor.
	~TAO_Thread_Lane_Resources (void)
	Destructor.
int	is_collocated (const TAO_MProfile &mprofile)
int	open_acceptor_registry (const TAO_EndpointSet &endpoint_set, bool ignore_address)
	Open the acceptor registry.
void	finalize (void)
	Finalize resources.
void	shutdown_reactor (void)
	Shutdown the reactor.
void	cleanup_rw_transports (void)
Private Member Functions
int	has_acceptor_registry_been_created (void) const
	Checks if the acceptor registry has been created.
TAO_Resource_Factory *	resource_factory (void)
	Helper to get the resource factory in the ORB_Core.
Private Attributes
TAO_ORB_Core &	orb_core_
	ORB_Core related to this thread lane.
TAO_Acceptor_Registry *	acceptor_registry_
TAO_Connector_Registry *	connector_registry_
TAO::Transport_Cache_Manager *	transport_cache_
	Transport cache.
TAO_Leader_Follower *	leader_follower_
	The leader/followers management class for this lane.
TAO_SYNCH_MUTEX	lock_
	Synchronization.
TAO_New_Leader_Generator *	new_leader_generator_
	Generator of new leader threads.

TAO_Thread_Lane_Resources Class Reference

Accessors

The allocators for the input CDR streams.

The allocators for the buffering messages in the transport.

The allocators for the output CDR streams.

The allocators for AMH.

The allocators for AMI.

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation