TAO::Transport_Cache_Manager Class Reference

The Transport Cache Manager for TAO. More...

#include <Transport_Cache_Manager.h>

Collaboration diagram for TAO::Transport_Cache_Manager:

[legend]List of all members.

Public Types
typedef ACE_Hash_Map_Manager_Ex< Cache_ExtId, Cache_IntId, ACE_Hash< Cache_ExtId >, ACE_Equal_To< Cache_ExtId >, ACE_Null_Mutex >	HASH_MAP
typedef HASH_MAP::iterator	HASH_MAP_ITER
typedef ACE_Hash_Map_Entry< Cache_ExtId, Cache_IntId >	HASH_MAP_ENTRY
typedef TAO_Condition< TAO_SYNCH_MUTEX >	CONDITION
Public Member Functions
	Transport_Cache_Manager (TAO_ORB_Core &orb_core)
	Constructor.
	~Transport_Cache_Manager (void)
	Destructor.
int	cache_transport (TAO_Transport_Descriptor_Interface *prop, TAO_Transport *transport)
	Add the transport to the cache.
int	cache_idle_transport (TAO_Transport_Descriptor_Interface *prop, TAO_Transport *transport)
int	find_transport (TAO_Transport_Descriptor_Interface *prop, TAO_Transport *&transport)
int	purge (void)
	Remove entries from the cache depending upon the strategy.
int	purge_entry (HASH_MAP_ENTRY *&)
	Purge the entry from the Cache Map.
void	mark_invalid (HASH_MAP_ENTRY *&)
	Mark the entry as invalid for use but keep it in cache.
int	make_idle (HASH_MAP_ENTRY *&entry)
	Make the entry idle and ready for use.
int	update_entry (HASH_MAP_ENTRY *&entry)
int	close (Connection_Handler_Set &handlers)
bool	blockable_client_transports (Connection_Handler_Set &handlers)
size_t	current_size (void) const
	Return the current size of the cache.
size_t	total_size (void) const
	Return the total size of the cache.
HASH_MAP &	map (void)
	Return the underlying cache map.
Private Types
typedef HASH_MAP_ENTRY **	DESCRIPTOR_SET
Private Member Functions
int	bind (Cache_ExtId &ext_id, Cache_IntId &int_id)
int	find (const Cache_ExtId &key, Cache_IntId &value)
int	bind_i (Cache_ExtId &ext_id, Cache_IntId &int_id)
int	find_i (const Cache_ExtId &key, Cache_IntId &value)
int	make_idle_i (HASH_MAP_ENTRY *&entry)
	Non-locking version and actual implementation of make_idle ().
int	close_i (Connection_Handler_Set &handlers)
	Non-locking version and actual implementation of close ().
int	purge_entry_i (HASH_MAP_ENTRY *&entry)
	Purge the entry from the Cache Map.
void	mark_invalid_i (HASH_MAP_ENTRY *&)
	Mark the entry as invalid for use but keep it in cache.
int	get_last_index_bind (Cache_ExtId &key, Cache_IntId &val, HASH_MAP_ENTRY *&entry)
bool	is_entry_idle (HASH_MAP_ENTRY *&entry)
void	sort_set (DESCRIPTOR_SET &entries, int size)
	Sort the list of entries.
int	fill_set_i (DESCRIPTOR_SET &sorted_set)
int	wait_for_connection (Cache_ExtId &extid)
int	is_wakeup_useful (Cache_ExtId &extid)
	Is the wakeup useful todo some work?
bool	blockable_client_transports_i (Connection_Handler_Set &handlers)
	Non-locking version of blockable_client_transports ().
Static Private Member Functions
int	cpscmp (const void *a, const void *b)
	Used by qsort.
Private Attributes
int	percent_
	The percentage of the cache to purge at one time.
TAO_Connection_Purging_Strategy *	purging_strategy_
	The underlying connection purging strategy.
HASH_MAP	cache_map_
	The hash map that has the connections.
CONDITION *	condition_
	The condition variable.
ACE_Lock *	cache_lock_
	The lock that is used by the cache map.
CORBA::ULong	muxed_number_
	Number of allowed muxed connections.
int	no_waiting_threads_
	Number of threads waiting for connections.
Cache_ExtId *	last_entry_returned_

---

Detailed Description

The Transport Cache Manager for TAO.

This class provides interfaces associating a TAO_Cache_ExtId & TAO_Cache_IntId. This class is wrapper around the ACE_Hash_Map_Manager class which is used as a container to Cache the connections. This class protects the entries with a lock. The map is updated only by holding the lock. The more compelling reason to have the lock in this class and not in the Hash_Map is that, we do quite a bit of work in this class for which we need a lock.

Definition at line 60 of file Transport_Cache_Manager.h.

---

Member Typedef Documentation

typedef TAO_Condition<TAO_SYNCH_MUTEX> TAO::Transport_Cache_Manager::CONDITION

Definition at line 77 of file Transport_Cache_Manager.h.

typedef HASH_MAP_ENTRY** TAO::Transport_Cache_Manager::DESCRIPTOR_SET [private]

Definition at line 215 of file Transport_Cache_Manager.h. Referenced by fill_set_i(), purge(), and sort_set().

typedef ACE_Hash_Map_Manager_Ex<Cache_ExtId, Cache_IntId, ACE_Hash<Cache_ExtId>, ACE_Equal_To<Cache_ExtId>, ACE_Null_Mutex> TAO::Transport_Cache_Manager::HASH_MAP

Definition at line 69 of file Transport_Cache_Manager.h.

typedef ACE_Hash_Map_Entry<Cache_ExtId, Cache_IntId> TAO::Transport_Cache_Manager::HASH_MAP_ENTRY

Definition at line 75 of file Transport_Cache_Manager.h. Referenced by bind_i(), TAO_Transport::cache_map_entry(), cpscmp(), fill_set_i(), find_i(), get_last_index_bind(), is_entry_idle(), make_idle(), make_idle_i(), mark_invalid(), mark_invalid_i(), purge_entry(), purge_entry_i(), sort_set(), and update_entry().

typedef HASH_MAP::iterator TAO::Transport_Cache_Manager::HASH_MAP_ITER

Definition at line 71 of file Transport_Cache_Manager.h. Referenced by blockable_client_transports_i(), close_i(), and fill_set_i().

---

Constructor & Destructor Documentation

TAO::Transport_Cache_Manager::Transport_Cache_Manager (  TAO_ORB_Core &  orb_core  )

Constructor. If the cache is not going to be locked then dont create a condition variable. Make the to 0, else a single thread could get into waiting mode Definition at line 27 of file Transport_Cache_Manager.cpp. References ACE_NEW, TAO_Resource_Factory::locked_transport_cache(), muxed_number_, and TAO_ORB_Core::resource_factory(). : percent_ (orb_core.resource_factory ()->purge_percentage ()) , purging_strategy_ (orb_core.resource_factory ()->create_purging_strategy ()) , cache_map_ (orb_core.resource_factory ()->cache_maximum ()) , condition_ (0) , cache_lock_ (0) , muxed_number_ (orb_core.resource_factory ()->max_muxed_connections ()) , no_waiting_threads_ (0) , last_entry_returned_ (0) { if (orb_core.resource_factory ()->locked_transport_cache ()) { ACE_NEW (this->condition_, TAO_Condition <TAO_SYNCH_MUTEX>); ACE_NEW (this->cache_lock_, ACE_Lock_Adapter <TAO_SYNCH_MUTEX> (*this->condition_->mutex ())); } else { /// If the cache is not going to be locked then dont create a /// condition variable. Make the <muxed_number_> to 0, else a /// single thread could get into waiting mode this->muxed_number_ = 0; ACE_NEW (this->cache_lock_, ACE_Lock_Adapter<ACE_SYNCH_NULL_MUTEX>); } }

TAO::Transport_Cache_Manager::~Transport_Cache_Manager (  void   )

Destructor. Definition at line 56 of file Transport_Cache_Manager.cpp. References TAO_Condition< MUTEX >::broadcast(), cache_lock_, no_waiting_threads_, and purging_strategy_. { // Wakeup all the waiting threads threads before we shutdown stuff if (this->no_waiting_threads_) { this->condition_->broadcast (); } // Delete the lock that we have if (this->cache_lock_) { delete this->cache_lock_; this->cache_lock_ = 0; } // Delete the purging strategy if (this->purging_strategy_) { delete this->purging_strategy_; this->purging_strategy_ = 0; } // Delete the condition variable if (this->condition_) { delete this->condition_; this->condition_ = 0; } }

---

Member Function Documentation

ACE_INLINE int TAO::Transport_Cache_Manager::bind (  Cache_ExtId &  ext_id, Cache_IntId &  int_id )  [private]

Associate ext_id with int_id. Grabs the lock and calls the implementation function bind_i. Definition at line 11 of file Transport_Cache_Manager.inl. References ACE_GUARD_RETURN, and bind_i(). { ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->cache_lock_, -1)); return this->bind_i (ext_id, int_id); }

int TAO::Transport_Cache_Manager::bind_i (  Cache_ExtId &  ext_id, Cache_IntId &  int_id )  [private]

Non-Locking version and actual implementation of bind () call. Calls bind on the Hash_Map_Manager that it holds. If the bind succeeds, it adds the Hash_Map_Entry in to the Transport for its reference. If the bind fails because of an exiting entry, this method calls the get_last_index_bind (). Definition at line 88 of file Transport_Cache_Manager.cpp. References ACE_DEBUG, ACE_ERROR, ACE_TEXT, cache_map_, TAO_Transport::cache_map_entry(), get_last_index_bind(), TAO::Cache_ExtId::hash(), HASH_MAP_ENTRY, TAO_Transport::id(), LM_DEBUG, LM_ERROR, LM_INFO, purging_strategy_, TAO_debug_level, TAO::Cache_IntId::transport(), and TAO_Connection_Purging_Strategy::update_item(). Referenced by bind(), cache_idle_transport(), and cache_transport(). { if (TAO_debug_level > 0) { ACE_DEBUG ((LM_INFO, ACE_TEXT ("TAO (%P|%t) - Transport_Cache_Manager::bind_i: ") ACE_TEXT ("Transport[%d] ;hash %d\n"), int_id.transport ()->id (), ext_id.hash () )); } // Get the entry too HASH_MAP_ENTRY *entry = 0; // Update the purging strategy information while we // are holding our lock this->purging_strategy_->update_item (int_id.transport ()); int retval = this->cache_map_.bind (ext_id, int_id, entry); if (retval == 0) { // The entry has been added to cache succesfully // Add the cache_map_entry to the transport int_id.transport ()->cache_map_entry (entry); } else if (retval == 1) { if (TAO_debug_level > 4) { ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) - Transport_Cache_Manager::bind_i, " "unable to bind in the first attempt. " "Trying with a new index\n")); } // There was an entry like this before, so let us do some // minor adjustments and rebind retval = this->get_last_index_bind (ext_id, int_id, entry); if (retval == 0) { int_id.transport ()->cache_map_entry (entry); } } if (TAO_debug_level > 5 && retval != 0) { ACE_ERROR ((LM_ERROR, "TAO (%P|%t) - Transport_Cache_Manager::bind_i, " "unable to bind\n")); } else if (TAO_debug_level > 3) { ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) - Transport_Cache_Manager::bind_i, " "cache size is [%d]\n", this->current_size ())); } return retval; }

ACE_INLINE bool TAO::Transport_Cache_Manager::blockable_client_transports (  Connection_Handler_Set &  handlers  )

This call is used for a specific use case by the ORB_Core during shutdown. The only way the ORB can wake up threads waiting on these sockstes for replies is to iterate over these blockable transports and close the socket handles. Without these the threads will continue to wait there for ever. Definition at line 127 of file Transport_Cache_Manager.inl. References ACE_GUARD_RETURN, blockable_client_transports_i(), and TAO::Connection_Handler_Set. Referenced by TAO_Thread_Lane_Resources::cleanup_rw_transports(). { ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->cache_lock_, false)); return this->blockable_client_transports_i (handlers); }

bool TAO::Transport_Cache_Manager::blockable_client_transports_i (  Connection_Handler_Set &  handlers  )  [private]

Non-locking version of blockable_client_transports (). Definition at line 368 of file Transport_Cache_Manager.cpp. References cache_map_, TAO::Connection_Handler_Set, TAO::ENTRY_CLOSED, and HASH_MAP_ITER. Referenced by blockable_client_transports(). { HASH_MAP_ITER end_iter = this->cache_map_.end (); for (HASH_MAP_ITER iter = this->cache_map_.begin (); iter != end_iter; ++iter) { // Get the transport to fill its associated connection's // handler. bool retval = (*iter).int_id_.transport ()->provide_blockable_handler (h); // Do not mark the entry as closed if we don't have a // blockable handler added if (retval) (*iter).int_id_.recycle_state (ENTRY_CLOSED); } return true; }

ACE_INLINE int TAO::Transport_Cache_Manager::cache_idle_transport (  TAO_Transport_Descriptor_Interface *  prop, TAO_Transport *  transport )

Similar to the one above, but the transport is left in ENTRY_IDLE_AND_PURGABLE state. Definition at line 50 of file Transport_Cache_Manager.inl. References ACE_GUARD_RETURN, bind_i(), TAO::ENTRY_IDLE_AND_PURGABLE, and TAO::Cache_IntId::recycle_state(). Referenced by TAO_IIOP_Connection_Handler::add_transport_to_cache(). { // Compose the ExternId & Intid Cache_ExtId ext_id (prop); Cache_IntId int_id (transport); int retval = 0; { ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->cache_lock_, -1)); // Do as the semantics of this method dictates int_id.recycle_state (ENTRY_IDLE_AND_PURGABLE); retval = this->bind_i (ext_id, int_id); } return retval; }

ACE_INLINE int TAO::Transport_Cache_Manager::cache_transport (  TAO_Transport_Descriptor_Interface *  prop, TAO_Transport *  transport )

Add the transport to the cache. The transport has the property definition based on which caching can be done. This method marks the transport ACE_RECYCLABLE_BUSY which helps the threads opening up connections to use the transport immediately. Definition at line 24 of file Transport_Cache_Manager.inl. References ACE_GUARD_RETURN, bind_i(), TAO::ENTRY_BUSY, and TAO::Cache_IntId::recycle_state(). Referenced by TAO_Transport::recache_transport(). { // Compose the ExternId & Intid Cache_ExtId ext_id (prop); Cache_IntId int_id (transport); int retval = 0; { ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->cache_lock_, -1)); // Do as the semantics of this method dictates int_id.recycle_state (ENTRY_BUSY); retval = this->bind_i (ext_id, int_id); } return retval; }

ACE_INLINE int TAO::Transport_Cache_Manager::close (  Connection_Handler_Set &  handlers  )

Close the underlying hash map manager and return any handlers still registered Definition at line 109 of file Transport_Cache_Manager.inl. References ACE_GUARD_RETURN, cache_lock_, close_i(), and TAO::Connection_Handler_Set. Referenced by TAO_Thread_Lane_Resources::finalize(). { // The cache lock pointer should only be zero if // Transport_Cache_Manager::open() was never called. Note that // only one thread opens the Transport_Cache_Manager at any given // time, so it is safe to check for a non-zero lock pointer. if (this->cache_lock_ == 0) return -1; ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->cache_lock_, -1)); return this->close_i (handlers); }

int TAO::Transport_Cache_Manager::close_i (  Connection_Handler_Set &  handlers  )  [private]

Non-locking version and actual implementation of close (). Definition at line 343 of file Transport_Cache_Manager.cpp. References cache_map_, TAO::Connection_Handler_Set, and HASH_MAP_ITER. Referenced by close(). { HASH_MAP_ITER end_iter = this->cache_map_.end (); for (HASH_MAP_ITER iter = this->cache_map_.begin (); iter != end_iter; ++iter) { // Get the transport to fill its associated connection's handler. (*iter).int_id_.transport ()->provide_handler (handlers); // Inform the transport that has a reference to the entry in the // map that we are *gone* now. So, the transport should not use // the reference to the entry that he has, to acces us *at any // time*. (*iter).int_id_.transport ()->cache_map_entry (0); } // Unbind all the entries in the map this->cache_map_.unbind_all (); return 0; }

int TAO::Transport_Cache_Manager::cpscmp (  const void *  a, const void *  b )  [static, private]

Used by qsort. Definition at line 468 of file Transport_Cache_Manager.cpp. References HASH_MAP_ENTRY. Referenced by sort_set(). { const HASH_MAP_ENTRY** left = (const HASH_MAP_ENTRY**)a; const HASH_MAP_ENTRY** right = (const HASH_MAP_ENTRY**)b; if ((*left)->int_id_.transport ()->purging_order () < (*right)->int_id_.transport ()->purging_order ()) return -1; if ((*left)->int_id_.transport ()->purging_order () > (*right)->int_id_.transport ()->purging_order ()) return 1; return 0; }

ACE_INLINE size_t TAO::Transport_Cache_Manager::current_size (  void   )  const

Return the current size of the cache. Definition at line 139 of file Transport_Cache_Manager.inl. References cache_map_. { return this->cache_map_.current_size (); }

int TAO::Transport_Cache_Manager::fill_set_i (  DESCRIPTOR_SET &  sorted_set  )  [private]

Fill sorted_set in with the TAO_Transport_Descriptor_Interface's in a sorted order. Definition at line 605 of file Transport_Cache_Manager.cpp. References ACE_DEBUG, ACE_NEW_RETURN, ACE_TEXT, cache_map_, TAO_Connection_Purging_Strategy::cache_maximum(), DESCRIPTOR_SET, HASH_MAP_ENTRY, HASH_MAP_ITER, LM_DEBUG, purging_strategy_, sort_set(), and TAO_debug_level. Referenced by purge(). { int current_size = 0; int cache_maximum = this->purging_strategy_->cache_maximum (); // set sorted_set to 0. This signifies nothing to purge. sorted_set = 0; // Do we need to worry about cache purging? if (cache_maximum >= 0) { current_size = static_cast<int> (this->cache_map_.current_size ()); if (TAO_debug_level > 0) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("TAO (%P|%t) - Transport_Cache_Manager::fill_set_i, ") ACE_TEXT("current_size = %d, cache_maximum = %d\n"), current_size, cache_maximum)); } if (current_size >= cache_maximum) { ACE_NEW_RETURN (sorted_set, HASH_MAP_ENTRY*[current_size], 0); HASH_MAP_ITER iter = this->cache_map_.begin (); for (int i = 0; i < current_size; ++i) { sorted_set[i] = &(*iter); iter++; } this->sort_set (sorted_set, current_size); } } return current_size; }

int TAO::Transport_Cache_Manager::find (  const Cache_ExtId &  key, Cache_IntId &  value )  [private]

Lookup entry<key,value> in the cache. Grabs the lock and calls the implementation function find_i. Definition at line 207 of file Transport_Cache_Manager.cpp. References ACE_GUARD_RETURN, find_i(), purging_strategy_, TAO::Cache_IntId::transport(), and TAO_Connection_Purging_Strategy::update_item(). Referenced by find_transport(). { ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->cache_lock_, -1)); int const status = this->find_i (key, value); if (status == 0) { // Update the purging strategy information while we // are holding our lock this->purging_strategy_->update_item (value.transport ()); } return status; }

int TAO::Transport_Cache_Manager::find_i (  const Cache_ExtId &  key, Cache_IntId &  value )  [private]

Non-locking version and actual implementation of find () call. This calls the find () on the underlying Hash_Map_Manager. If the find succeeds, it calls the get_idle_transport (). Definition at line 229 of file Transport_Cache_Manager.cpp. References ACE_DEBUG, ACE_ERROR, ACE_TEXT, cache_map_, TAO::ENTRY_BUSY, ACE_Hash_Map_Entry< EXT_ID, INT_ID >::ext_id_, HASH_MAP_ENTRY, TAO::Cache_ExtId::incr_index(), ACE_Hash_Map_Entry< EXT_ID, INT_ID >::int_id_, is_entry_idle(), LM_DEBUG, LM_ERROR, TAO::Cache_ExtId::property(), TAO_debug_level, and wait_for_connection(). Referenced by find(). { HASH_MAP_ENTRY *entry = 0; // Get the entry from the Hash Map int retval = 0; // Make a temporary object. It does not do a copy. Cache_ExtId tmp_key (key.property ()); while (retval == 0) { // Wait for a connection.. this->wait_for_connection (tmp_key); // Look for an entry in the map retval = this->cache_map_.find (tmp_key, entry); // We have an entry in the map, check whether it is idle. if (entry) { CORBA::Boolean idle = this->is_entry_idle (entry); if (idle) { // Successfully found a TAO_Transport. entry->int_id_.recycle_state (ENTRY_BUSY); // NOTE: This assignment operator indirectly incurs two // lock operations since it duplicates and releases // TAO_Transport objects. value = entry->int_id_; if (TAO_debug_level > 4) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("TAO (%P|%t) - Transport_Cache_Manager::find_i, ") ACE_TEXT("at index %d (Transport[%d]) - idle\n"), entry->ext_id_.index (), entry->int_id_.transport ()->id ())); } return 0; } else if (TAO_debug_level > 6) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("TAO (%P|%t) - Transport_Cache_Manager::find_i, ") ACE_TEXT("at index %d (Transport[%d]) - not idle\n"), entry->ext_id_.index (), entry->int_id_.transport ()->id ())); } } // Bump the index up tmp_key.incr_index (); } // If we are here then it is an error if (TAO_debug_level > 4 && retval != 0) { ACE_ERROR ((LM_ERROR, "TAO (%P|%t) - Transport_Cache_Manager::find_i, " "no idle transport is available\n")); } return retval; }

int TAO::Transport_Cache_Manager::find_transport (  TAO_Transport_Descriptor_Interface *  prop, TAO_Transport *&  transport )

Check the Transport Cache to check whether the connection exists in the Cache and return the connection Definition at line 156 of file Transport_Cache_Manager.cpp. References ACE_ERROR, ACE_TEXT, TAO_ORB_Core::client_factory(), TAO_Transport::event_handler_i(), find(), TAO_Transport::id(), TAO_Wait_Strategy::is_registered(), LM_ERROR, TAO_Wait_Strategy::non_blocking(), TAO_Transport::orb_core(), TAO_ORB_Core::reactor(), TAO::Cache_IntId::relinquish_transport(), ACE_Reactor::remove_handler(), TAO_debug_level, TAO_Client_Strategy_Factory::use_cleanup_options(), and TAO_Transport::wait_strategy(). Referenced by TAO_Connector::connect(), TAO::Profile_Transport_Resolver::find_transport(), and TAO_Connector::parallel_connect(). { if (prop == 0) { transport = 0; return -1; } // Compose the ExternId Cache_ExtId ext_id (prop); Cache_IntId int_id; int const retval = this->find (ext_id, int_id); if (retval == 0) { transport = int_id.relinquish_transport (); if (transport->wait_strategy ()->non_blocking () == 0 && transport->orb_core ()->client_factory ()->use_cleanup_options ()) { ACE_Event_Handler * const eh = transport->event_handler_i (); ACE_Reactor * const r = transport->orb_core ()->reactor (); if (eh && r->remove_handler (eh, ACE_Event_Handler::READ_MASK | ACE_Event_Handler::DONT_CALL) == -1) { if (TAO_debug_level > 0) ACE_ERROR ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) - TAO_Transport_Cache_Manager[%d]") ACE_TEXT ("::find_transport, remove_handler failed \n"), transport->id ())); } else { transport->wait_strategy ()->is_registered (false); } } } return retval; }

int TAO::Transport_Cache_Manager::get_last_index_bind (  Cache_ExtId &  key, Cache_IntId &  val, HASH_MAP_ENTRY *&  entry )  [private]

This is called by the bind () call when a bind fails with a available entry. When a new connection is created in TAO with an already existing endpoint, in addition to an exisitng one, we mark the connections with an index. This method, finds out the last highest index and binds the entry with an index = (last highest index + 1). Definition at line 421 of file Transport_Cache_Manager.cpp. References cache_map_, ACE_Hash_Map_Entry< EXT_ID, INT_ID >::ext_id_, HASH_MAP_ENTRY, and TAO::Cache_ExtId::index(). Referenced by bind_i(). { CORBA::ULong ctr = entry->ext_id_.index (); int retval = 0; while (retval == 0) { // Set the index key.index (++ctr); // Check to see if an element exists in the Map. If it exists we // loop, else we drop out of the loop retval = this->cache_map_.find (key); } // Now do a bind again with the new index return this->cache_map_.bind (key, val, entry); }

bool TAO::Transport_Cache_Manager::is_entry_idle (  HASH_MAP_ENTRY *&  entry  )  [private]

Tries to find if the in entry is idle for use. If it is idle it is immediately markes as busy and returns a value of 1, else it returns a value of 0 Definition at line 446 of file Transport_Cache_Manager.cpp. References ACE_DEBUG, ACE_TEXT, TAO::Cache_Entries_State, TAO::ENTRY_IDLE_AND_PURGABLE, TAO::ENTRY_IDLE_BUT_NOT_PURGABLE, HASH_MAP_ENTRY, ACE_Hash_Map_Entry< EXT_ID, INT_ID >::int_id_, LM_DEBUG, and TAO_debug_level. Referenced by find_i(), and purge(). { Cache_Entries_State entry_state = entry->int_id_.recycle_state (); if (TAO_debug_level) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("TAO (%P|%t) - Transport_Cache_Manager::is_entry_idle, ") ACE_TEXT("state is [%d]\n"), entry_state)); } if (entry_state == ENTRY_IDLE_AND_PURGABLE || entry_state == ENTRY_IDLE_BUT_NOT_PURGABLE) return true; return false; }

int TAO::Transport_Cache_Manager::is_wakeup_useful (  Cache_ExtId &  extid  )  [private]

Is the wakeup useful todo some work? Definition at line 688 of file Transport_Cache_Manager.cpp. References TAO::Cache_ExtId::index(), TAO_Transport_Descriptor_Interface::is_equivalent(), last_entry_returned_, no_waiting_threads_, TAO::Cache_ExtId::property(), and TAO_Condition< MUTEX >::signal(). Referenced by wait_for_connection(). { // Get the underlying property that we are looking for TAO_Transport_Descriptor_Interface *prop = extid.property (); // Just check the underlying property for equivalence. If the last // connection that was returned had the same property just return // 1. if (this->last_entry_returned_ && prop->is_equivalent (this->last_entry_returned_->property ())) { // Set the index to be right so that we can pick teh connection // right away.. extid.index (this->last_entry_returned_->index ()); // There is no more use for it ... this->last_entry_returned_ = 0; return 1; } // If there is an entry that was returned and if there are more // threads just wake up the peer to check for the returned // connection. if (this->last_entry_returned_ && this->no_waiting_threads_ > 1) { this->condition_->signal (); } return 0; }

ACE_INLINE int TAO::Transport_Cache_Manager::make_idle (  HASH_MAP_ENTRY *&  entry  )

Make the entry idle and ready for use. Definition at line 99 of file Transport_Cache_Manager.inl. References ACE_GUARD_RETURN, HASH_MAP_ENTRY, and make_idle_i(). Referenced by TAO_Transport::make_idle(). { if(entry == 0) return -1; ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->cache_lock_, -1)); return this->make_idle_i (entry); }

int TAO::Transport_Cache_Manager::make_idle_i (  HASH_MAP_ENTRY *&  entry  )  [private]

Non-locking version and actual implementation of make_idle (). Definition at line 303 of file Transport_Cache_Manager.cpp. References TAO::ENTRY_IDLE_AND_PURGABLE, ACE_Hash_Map_Entry< EXT_ID, INT_ID >::ext_id_, HASH_MAP_ENTRY, ACE_Hash_Map_Entry< EXT_ID, INT_ID >::int_id_, last_entry_returned_, no_waiting_threads_, and TAO_Condition< MUTEX >::signal(). Referenced by make_idle(). { if (entry == 0) return -1; entry->int_id_.recycle_state (ENTRY_IDLE_AND_PURGABLE); // Does any one need waking? if (this->no_waiting_threads_) { // We returned this entry to the map this->last_entry_returned_ = &entry->ext_id_; // Wake up a thread this->condition_->signal (); } return 0; }

ACE_INLINE Transport_Cache_Manager::HASH_MAP & TAO::Transport_Cache_Manager::map (  void   )

Return the underlying cache map. Definition at line 151 of file Transport_Cache_Manager.inl. References cache_map_. { return this->cache_map_; }

ACE_INLINE void TAO::Transport_Cache_Manager::mark_invalid (  HASH_MAP_ENTRY *&   )

Mark the entry as invalid for use but keep it in cache. Definition at line 87 of file Transport_Cache_Manager.inl. References ACE_GUARD, HASH_MAP_ENTRY, and mark_invalid_i(). { if(entry == 0) return; // Double checked locking ACE_MT (ACE_GUARD (ACE_Lock, guard, *this->cache_lock_)); this->mark_invalid_i (entry); }

void TAO::Transport_Cache_Manager::mark_invalid_i (  HASH_MAP_ENTRY *&   )  [private]

Mark the entry as invalid for use but keep it in cache. Definition at line 409 of file Transport_Cache_Manager.cpp. References TAO::ENTRY_PURGABLE_BUT_NOT_IDLE, HASH_MAP_ENTRY, and ACE_Hash_Map_Entry< EXT_ID, INT_ID >::int_id_. Referenced by mark_invalid(). { if (entry == 0) { return; } // Mark the entry as not usable entry->int_id_.recycle_state (ENTRY_PURGABLE_BUT_NOT_IDLE); }

int TAO::Transport_Cache_Manager::purge (  void   )

Remove entries from the cache depending upon the strategy. Definition at line 486 of file Transport_Cache_Manager.cpp. References ACE_DEBUG, ACE_GUARD_RETURN, ACE_TEXT, TAO_Transport::add_reference(), TAO_Transport::close_connection(), DESCRIPTOR_SET, TAO::ENTRY_BUSY, fill_set_i(), TAO_Transport::id(), ACE_Hash_Map_Entry< EXT_ID, INT_ID >::int_id_, ACE_Unbounded_Stack< T >::is_empty(), is_entry_idle(), LM_DEBUG, LM_INFO, percent_, ACE_Unbounded_Stack< T >::pop(), ACE_Unbounded_Stack< T >::push(), TAO_Transport::remove_reference(), and TAO_debug_level. Referenced by TAO_Connector::connect(), and TAO_Creation_Strategy< SVC_HANDLER >::make_svc_handler(). { ACE_Unbounded_Stack<TAO_Transport*> transports_to_be_closed; { ACE_MT (ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->cache_lock_, 0)); DESCRIPTOR_SET sorted_set = 0; int sorted_size = this->fill_set_i (sorted_set); // Only call close_entries () if sorted_set != 0. It takes // control of sorted_set and cleans up any allocated memory. If // sorted_set == 0, then there is nothing to de-allocate. if (sorted_set != 0) { // BEGIN FORMER close_entries // Calculate the number of entries to purge const int amount = (sorted_size * this->percent_) / 100; if (TAO_debug_level > 0) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - Transport_Cache_Manager::") ACE_TEXT ("purge, purging %d of %d cache entries\n"), amount, sorted_size)); } int count = 0; for (int i = 0; count < amount && i < sorted_size; ++i) { if (this->is_entry_idle (sorted_set[i])) { sorted_set[i]->int_id_.recycle_state (ENTRY_BUSY); TAO_Transport* transport = sorted_set[i]->int_id_.transport (); transport->add_reference (); if (transports_to_be_closed.push (transport) != 0) { ACE_DEBUG ((LM_INFO, ACE_TEXT ("TAO (%P|%t) - ") ACE_TEXT ("Unable to push transport %u ") ACE_TEXT ("on the to-be-closed stack, so ") ACE_TEXT ("it will leak\n"), transport->id ())); } if (TAO_debug_level > 0) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - ") ACE_TEXT ("Idle transport found in ") ACE_TEXT ("cache: [%d] \n"), transport->id ())); } // Count this as a successful purged entry count++; } } delete [] sorted_set; sorted_set = 0; // END FORMER close_entries } } // Now, without the lock held, lets go through and close all the transports. TAO_Transport *transport = 0; while (! transports_to_be_closed.is_empty ()) { if (transports_to_be_closed.pop (transport) == 0) { if (transport) { transport->close_connection (); transport->remove_reference (); } } } return 0; }

ACE_INLINE int TAO::Transport_Cache_Manager::purge_entry (  HASH_MAP_ENTRY *&   )

Purge the entry from the Cache Map. Definition at line 75 of file Transport_Cache_Manager.inl. References ACE_GUARD_RETURN, HASH_MAP_ENTRY, and purge_entry_i(). Referenced by TAO_Transport::purge_entry(). { // Double checked locking if(entry == 0) return 0; ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->cache_lock_, -1)); return this->purge_entry_i (entry); }

int TAO::Transport_Cache_Manager::purge_entry_i (  HASH_MAP_ENTRY *&  entry  )  [private]

Purge the entry from the Cache Map. Definition at line 392 of file Transport_Cache_Manager.cpp. References cache_map_, and HASH_MAP_ENTRY. Referenced by purge_entry(). { if (entry == 0) { return 0; } // Remove the entry from the Map int retval = this->cache_map_.unbind (entry); // Set the entry pointer to zero entry = 0; return retval; }

void TAO::Transport_Cache_Manager::sort_set (  DESCRIPTOR_SET &  entries, int  size )  [private]

Sort the list of entries. Definition at line 575 of file Transport_Cache_Manager.cpp. References ACE_COMPARE_FUNC, cpscmp(), DESCRIPTOR_SET, HASH_MAP_ENTRY, ACE_Hash_Map_Entry< EXT_ID, INT_ID >::int_id_, and ACE_OS::qsort(). Referenced by fill_set_i(). { #if defined (ACE_LACKS_QSORT) // Use insertion sort if we don't have qsort for(int i = 1; i < current_size; ++i) { if (entries[i]->int_id_.transport ()->purging_order () < entries[i - 1]->int_id_.transport ()->purging_order ()) { HASH_MAP_ENTRY* entry = entries[i]; for(int j = i; j > 0 && entries[j - 1]->int_id_.transport ()->purging_order () > entry->int_id_.transport ()->purging_order (); --j) { HASH_MAP_ENTRY* holder = entries[j]; entries[j] = entries[j - 1]; entries[j - 1] = holder; } } } #else ACE_OS::qsort (entries, current_size, sizeof (HASH_MAP_ENTRY*), (ACE_COMPARE_FUNC)cpscmp); #endif /* ACE_LACKS_QSORT */ }

ACE_INLINE size_t TAO::Transport_Cache_Manager::total_size (  void   )  const

Return the total size of the cache. Definition at line 145 of file Transport_Cache_Manager.inl. References cache_map_. { return this->cache_map_.total_size (); }

int TAO::Transport_Cache_Manager::update_entry (  HASH_MAP_ENTRY *&  entry  )

Mark the entry as touched. This call updates the purging strategy policy information. Definition at line 324 of file Transport_Cache_Manager.cpp. References ACE_GUARD_RETURN, HASH_MAP_ENTRY, ACE_Hash_Map_Entry< EXT_ID, INT_ID >::int_id_, purging_strategy_, and TAO_Connection_Purging_Strategy::update_item(). Referenced by TAO_Transport::update_transport(). { if(entry == 0) return -1; ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->cache_lock_, -1)); if (entry == 0) return -1; TAO_Connection_Purging_Strategy *st = this->purging_strategy_; (void) st->update_item (entry->int_id_.transport ()); return 0; }

int TAO::Transport_Cache_Manager::wait_for_connection (  Cache_ExtId &  extid  )  [private]

Wait for connections if we have reached the limit on the number of muxed connections. If not (ie. if we dont use a muxed connection or if we have not reached the limit) this just behaves as a no-op. has all the information about the connection that is being searched. Definition at line 647 of file Transport_Cache_Manager.cpp. References ACE_DEBUG, ACE_TEXT, TAO::Cache_ExtId::index(), is_wakeup_useful(), LM_DEBUG, muxed_number_, no_waiting_threads_, TAO_debug_level, and TAO_Condition< MUTEX >::wait(). Referenced by find_i(). { if (this->muxed_number_ && this->muxed_number_ == extid.index ()) { // If we have a limit on the number of muxed connections for // a particular endpoint just wait to get the connection ++this->no_waiting_threads_; if (TAO_debug_level > 2) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("TAO (%P|%t) - Transport_Cache_Manager") ACE_TEXT("::wait_for_connection, ") ACE_TEXT("entering wait loop\n"))); } int ready_togo = 0; while (ready_togo == 0) { this->condition_->wait (); // Check whether we are waiting for this connection ready_togo = this->is_wakeup_useful (extid); } if (TAO_debug_level > 2) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT("TAO (%P|%t) - Transport_Cache_Manager::wait_for_connection, ") ACE_TEXT("left wait loop\n"))); } // We are not waiting anymore --this->no_waiting_threads_; } return 0; }

---

Member Data Documentation

ACE_Lock* TAO::Transport_Cache_Manager::cache_lock_ [private]

The lock that is used by the cache map. Definition at line 251 of file Transport_Cache_Manager.h. Referenced by close(), and ~Transport_Cache_Manager().

HASH_MAP TAO::Transport_Cache_Manager::cache_map_ [private]

The hash map that has the connections. Definition at line 245 of file Transport_Cache_Manager.h. Referenced by bind_i(), blockable_client_transports_i(), close_i(), current_size(), fill_set_i(), find_i(), get_last_index_bind(), map(), purge_entry_i(), and total_size().

CONDITION* TAO::Transport_Cache_Manager::condition_ [private]

The condition variable. Definition at line 248 of file Transport_Cache_Manager.h.

Cache_ExtId* TAO::Transport_Cache_Manager::last_entry_returned_ [private]

This is for optimization purposes. In a situation where number of threads are waiting for connections, the last connection that is put back is cached here. This should prevent all th threads trying to search for their required entry. Definition at line 263 of file Transport_Cache_Manager.h. Referenced by is_wakeup_useful(), and make_idle_i().

CORBA::ULong TAO::Transport_Cache_Manager::muxed_number_ [private]

Number of allowed muxed connections. Definition at line 254 of file Transport_Cache_Manager.h. Referenced by Transport_Cache_Manager(), and wait_for_connection().

int TAO::Transport_Cache_Manager::no_waiting_threads_ [private]

Number of threads waiting for connections. Definition at line 257 of file Transport_Cache_Manager.h. Referenced by is_wakeup_useful(), make_idle_i(), wait_for_connection(), and ~Transport_Cache_Manager().

int TAO::Transport_Cache_Manager::percent_ [private]

The percentage of the cache to purge at one time. Definition at line 239 of file Transport_Cache_Manager.h. Referenced by purge().

TAO_Connection_Purging_Strategy* TAO::Transport_Cache_Manager::purging_strategy_ [private]

The underlying connection purging strategy. Definition at line 242 of file Transport_Cache_Manager.h. Referenced by bind_i(), fill_set_i(), find(), update_entry(), and ~Transport_Cache_Manager().

---

The documentation for this class was generated from the following files:

• Transport_Cache_Manager.h
• Transport_Cache_Manager.cpp
• Transport_Cache_Manager.inl

---