Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

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:

Collaboration graph
[legend]
List of all members.

Public Types

typedef ACE_Hash_Map_Manager_Ex<
TAO_Cache_ExtId, TAO_Cache_IntId,
ACE_Hash< TAO_Cache_ExtId >,
ACE_Equal_To< TAO_Cache_ExtId >,
ACE_Null_Mutex
HASH_MAP
typedef HASH_MAP::iterator HASH_MAP_ITER
typedef ACE_Hash_Map_Entry<
TAO_Cache_ExtId, TAO_Cache_IntId
HASH_MAP_ENTRY
typedef TAO_Condition< TAO_SYNCH_MUTEX > CONDITION

Public Methods

 TAO_Transport_Cache_Manager (TAO_ORB_Core &orb_core)
 Constructor. More...

virtual ~TAO_Transport_Cache_Manager (void)
 Destructor. More...

int cache_transport (TAO_Transport_Descriptor_Interface *prop, TAO_Transport *transport)
 Add the transport to the cache. More...

int cache_idle_transport (TAO_Transport_Descriptor_Interface *prop, TAO_Transport *transport)
 Similar to the one above, but the transport is left in ACE_RECYCLABLE_IDLE_AND_PURGABLE state. More...

int 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. More...

int purge (void)
 Remove entries from the cache depending upon the strategy. More...

int purge_entry (HASH_MAP_ENTRY *&)
 Purge the entry from the Cache Map. More...

void mark_invalid (HASH_MAP_ENTRY *&)
 Mark the entry as invalid for use but keep it in cache. More...

int make_idle (HASH_MAP_ENTRY *&entry)
 Make the entry idle and ready for use. More...

int update_entry (HASH_MAP_ENTRY *&entry)
 Mark the entry as touched. This call updates the purging strategy policy information. More...

int close (ACE_Handle_Set &reactor_registered, TAO_EventHandlerSet &unregistered)
 Close the underlying hash map manager and return the handle set that have been registered with the reactor. More...

size_t current_size (void) const
 Return the current size of the cache. More...

size_t total_size (void) const
 Return the total size of the cache. More...

HASH_MAPmap (void)
 Return the underlying cache map. More...


Private Types

typedef HASH_MAP_ENTRY ** DESCRIPTOR_SET

Private Methods

int bind (TAO_Cache_ExtId &ext_id, TAO_Cache_IntId &int_id)
 Associate <ext_id> with <int_id>. Grabs the lock and calls the implementation function bind_i. More...

int find (const TAO_Cache_ExtId &key, TAO_Cache_IntId &value)
 Lookup entry<key,value> in the cache. Grabs the lock and calls the implementation function find_i. More...

int bind_i (TAO_Cache_ExtId &ext_id, TAO_Cache_IntId &int_id)
int find_i (const TAO_Cache_ExtId &key, TAO_Cache_IntId &value)
int make_idle_i (HASH_MAP_ENTRY *&entry)
 Non-locking version and actual implementation of make_idle (). More...

int close_i (ACE_Handle_Set &reactor_registered, TAO_EventHandlerSet &unregistered)
 Non-locking version and actual implementation of close (). More...

int purge_entry_i (HASH_MAP_ENTRY *&entry)
 Purge the entry from the Cache Map. More...

void mark_invalid_i (HASH_MAP_ENTRY *&)
 Mark the entry as invalid for use but keep it in cache. More...

int get_last_index_bind (TAO_Cache_ExtId &key, TAO_Cache_IntId &val, HASH_MAP_ENTRY *&entry)
int is_entry_idle (HASH_MAP_ENTRY *&entry)
void sort_set (DESCRIPTOR_SET &entries, int size)
 Sort the list of entries. More...

int fill_set_i (DESCRIPTOR_SET &sorted_set)
 Fill sorted_set in with the TAO_Transport_Descriptor_Interface's in a sorted order. More...

int wait_for_connection (TAO_Cache_ExtId &extid)
 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. <extid> has all the information about the connection that is being searched. More...

int is_wakeup_useful (TAO_Cache_ExtId &extid)
 Is the wakeup useful todo some work? More...


Static Private Methods

int cpscmp (const void *a, const void *b)
 Used by qsort. More...


Private Attributes

int percent_
 The percentage of the cache to purge at one time. More...

TAO_Connection_Purging_Strategypurging_strategy_
 The underlying connection purging strategy. More...

HASH_MAP cache_map_
 The hash map that has the connections. More...

CONDITIONcondition_
 The condition variable. More...

ACE_Lockcache_lock_
 The lock that is used by the cache map. More...

CORBA::ULong muxed_number_
 Number of allowed muxed connections. More...

int no_waiting_threads_
 Number of threads waiting for connections. More...

TAO_Cache_ExtIdlast_entry_returned_
 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. More...


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 76 of file Transport_Cache_Manager.h.

typedef HASH_MAP_ENTRY** TAO_Transport_Cache_Manager::DESCRIPTOR_SET [private]
 

Definition at line 207 of file Transport_Cache_Manager.h.

typedef ACE_Hash_Map_Manager_Ex<TAO_Cache_ExtId, TAO_Cache_IntId, ACE_Hash<TAO_Cache_ExtId>, ACE_Equal_To<TAO_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<TAO_Cache_ExtId, TAO_Cache_IntId> TAO_Transport_Cache_Manager::HASH_MAP_ENTRY
 

Definition at line 74 of file Transport_Cache_Manager.h.

Referenced by TAO_Transport::cache_map_entry.

typedef HASH_MAP::iterator TAO_Transport_Cache_Manager::HASH_MAP_ITER
 

Definition at line 71 of file Transport_Cache_Manager.h.

Referenced by close_i, and fill_set_i.


Constructor & Destructor Documentation

TAO_Transport_Cache_Manager::TAO_Transport_Cache_Manager TAO_ORB_Core   orb_core
 

Constructor.

Definition at line 23 of file Transport_Cache_Manager.cpp.

References ACE_NEW, and muxed_number_.

00024   : percent_ (orb_core.resource_factory ()->purge_percentage ()),
00025     purging_strategy_ (orb_core.resource_factory ()->create_purging_strategy ()),
00026     cache_map_ (ACE_static_cast (size_t, ACE::max_handles ())),
00027     condition_ (0),
00028     cache_lock_ (0),
00029     muxed_number_ (orb_core.resource_factory ()->max_muxed_connections ()),
00030     no_waiting_threads_ (0),
00031     last_entry_returned_ (0)
00032 {
00033   if (orb_core.resource_factory ()->locked_transport_cache ())
00034     {
00035       ACE_NEW (this->condition_,
00036                TAO_Condition <TAO_SYNCH_MUTEX>);
00037 
00038       ACE_NEW (this->cache_lock_,
00039                ACE_Lock_Adapter <TAO_SYNCH_MUTEX> (*this->condition_->mutex ()));
00040     }
00041   else
00042     {
00043       /// If the cache is not going to be locked then dont create a
00044       /// condition variable. Make the <muxed_number_> to 0, else a
00045       /// single thread could get into waiting mode
00046       this->muxed_number_ = 0;
00047       ACE_NEW (this->cache_lock_,
00048                ACE_Lock_Adapter<ACE_SYNCH_NULL_MUTEX>);
00049     }
00050 }

TAO_Transport_Cache_Manager::~TAO_Transport_Cache_Manager void    [virtual]
 

Destructor.

Definition at line 52 of file Transport_Cache_Manager.cpp.

References TAO_Condition< TAO_SYNCH_MUTEX >::broadcast, cache_lock_, condition_, no_waiting_threads_, and purging_strategy_.

00053 {
00054   // Wakeup all the waiting threads threads before we shutdown stuff
00055   if (this->no_waiting_threads_)
00056     this->condition_->broadcast ();
00057 
00058   // Delete the lock that we have
00059   if (this->cache_lock_)
00060     {
00061       delete this->cache_lock_;
00062       this->cache_lock_ = 0;
00063     }
00064 
00065   // Delete the purging strategy
00066   if (this->purging_strategy_)
00067     {
00068       delete this->purging_strategy_;
00069       this->purging_strategy_ = 0;
00070     }
00071 
00072   // Delete the condition variable
00073   if (this->condition_)
00074     {
00075       delete this->condition_;
00076       this->condition_ = 0;
00077     }
00078 }


Member Function Documentation

ACE_INLINE int TAO_Transport_Cache_Manager::bind TAO_Cache_ExtId   ext_id,
TAO_Cache_IntId   int_id
[private]
 

Associate <ext_id> with <int_id>. Grabs the lock and calls the implementation function bind_i.

Definition at line 5 of file Transport_Cache_Manager.inl.

References ACE_GUARD_RETURN, ACE_MT, and bind_i.

00007 {
00008   ACE_MT (ACE_GUARD_RETURN (ACE_Lock,
00009                             guard,
00010                             *this->cache_lock_,
00011                             -1));
00012 
00013   return this->bind_i (ext_id,
00014                        int_id);
00015 }

int TAO_Transport_Cache_Manager::bind_i TAO_Cache_ExtId   ext_id,
TAO_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 82 of file Transport_Cache_Manager.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_Hash_Map_Manager_Ex< TAO_Cache_ExtId, TAO_Cache_IntId, ACE_Hash< TAO_Cache_ExtId >, ACE_Equal_To< TAO_Cache_ExtId >, ACE_Null_Mutex >::bind, cache_map_, TAO_Transport::cache_map_entry, get_last_index_bind, TAO_Transport::id, LM_DEBUG, LM_ERROR, TAO_Cache_ExtId::property, purging_strategy_, TAO_Cache_IntId::transport, and TAO_Connection_Purging_Strategy::update_item.

Referenced by bind, cache_idle_transport, and cache_transport.

00084 {
00085   if (TAO_debug_level > 0)
00086     {
00087       ACE_DEBUG ((LM_DEBUG,
00088                   "TAO (%P|%t) - Transport_Cache_Manager::bind_i, "
00089                   "0x%x -> 0x%x Transport[%d]\n",
00090                   ext_id.property (),
00091                   int_id.transport (),
00092                   int_id.transport ()->id ()));
00093     }
00094 
00095   // Get the entry too
00096   HASH_MAP_ENTRY *entry = 0;
00097 
00098   // Update the purging strategy information while we
00099   // are holding our lock
00100   this->purging_strategy_->update_item (int_id.transport ());
00101 
00102 
00103 
00104   int retval = this->cache_map_.bind (ext_id,
00105                                       int_id,
00106                                       entry);
00107   if (retval == 0)
00108     {
00109       // The entry has been added to cache succesfully
00110       // Add the cache_map_entry to the transport
00111       int_id.transport ()->cache_map_entry (entry);
00112     }
00113   else if (retval == 1)
00114     {
00115       if (TAO_debug_level > 4 && retval != 0)
00116         {
00117           ACE_DEBUG ((LM_DEBUG,
00118                       "TAO (%P|%t) - Transport_Cache_Manager::bind_i, "
00119                       "unable to bind in the first attempt. "
00120                       "Trying with a new index\n"));
00121         }
00122 
00123 
00124       // There was an entry like this before, so let us do some
00125       // minor adjustments and rebind
00126       retval = this->get_last_index_bind (ext_id,
00127                                           int_id,
00128                                           entry);
00129       if (retval == 0)
00130         {
00131           int_id.transport ()->cache_map_entry (entry);
00132         }
00133     }
00134 
00135   if (TAO_debug_level > 5 && retval != 0)
00136     {
00137       ACE_ERROR ((LM_ERROR,
00138                   "TAO (%P|%t) - Transport_Cache_Manager::bind_i, "
00139                   "unable to bind\n"));
00140     }
00141   else if (TAO_debug_level > 3)
00142     {
00143       ACE_DEBUG ((LM_DEBUG,
00144                   "TAO (%P|%t) - Transport_Cache_Manager::bind_i, "
00145                   " size is [%d] \n",
00146                   this->current_size ()));
00147     }
00148 
00149   return retval;
00150 }

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 ACE_RECYCLABLE_IDLE_AND_PURGABLE state.

Definition at line 45 of file Transport_Cache_Manager.inl.

References ACE_GUARD_RETURN, ACE_MT, ACE_RECYCLABLE_IDLE_AND_PURGABLE, bind_i, and TAO_Cache_IntId::recycle_state.

Referenced by TAO_IIOP_Connection_Handler::add_transport_to_cache.

00048 {
00049   // Compose the ExternId & Intid
00050   TAO_Cache_ExtId ext_id (prop);
00051   TAO_Cache_IntId int_id (transport);
00052 
00053   int retval = 0;
00054   {
00055     ACE_MT (ACE_GUARD_RETURN (ACE_Lock,
00056                               guard,
00057                               *this->cache_lock_,
00058                               -1));
00059 
00060     // Do as the semantics of this method dictates
00061     int_id.recycle_state (ACE_RECYCLABLE_IDLE_AND_PURGABLE);
00062     retval = this->bind_i (ext_id,
00063                            int_id);
00064 
00065 
00066   }
00067 
00068   return retval;
00069 }

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 19 of file Transport_Cache_Manager.inl.

References ACE_GUARD_RETURN, ACE_MT, ACE_RECYCLABLE_BUSY, bind_i, and TAO_Cache_IntId::recycle_state.

Referenced by TAO_IIOP_Connector::make_connection, and TAO_Transport::recache_transport.

00022 {
00023   // Compose the ExternId & Intid
00024   TAO_Cache_ExtId ext_id (prop);
00025   TAO_Cache_IntId int_id (transport);
00026 
00027   int retval = 0;
00028   {
00029     ACE_MT (ACE_GUARD_RETURN (ACE_Lock,
00030                               guard,
00031                               *this->cache_lock_,
00032                               -1));
00033 
00034     // Do as the semantics of this method dictates
00035     int_id.recycle_state (ACE_RECYCLABLE_BUSY);
00036 
00037     retval = this->bind_i (ext_id,
00038                            int_id);
00039   }
00040 
00041   return retval;
00042 }

ACE_INLINE int TAO_Transport_Cache_Manager::close ACE_Handle_Set   reactor_registered,
TAO_EventHandlerSet   unregistered
 

Close the underlying hash map manager and return the handle set that have been registered with the reactor.

Definition at line 111 of file Transport_Cache_Manager.inl.

References ACE_GUARD_RETURN, ACE_MT, cache_lock_, and close_i.

Referenced by TAO_Thread_Lane_Resources::finalize.

00113 {
00114   // The cache lock pointer should only be zero if
00115   // Transport_Cache_Manager::open() was never called.  Note that
00116   // only one thread opens the Transport_Cache_Manager at any given
00117   // time, so it is safe to check for a non-zero lock pointer.
00118   if (this->cache_lock_ == 0)
00119     return -1;
00120 
00121   ACE_MT (ACE_GUARD_RETURN (ACE_Lock,
00122                             guard,
00123                             *this->cache_lock_,
00124                             -1));
00125 
00126   return this->close_i (reactor_registered, unregistered);
00127 }

int TAO_Transport_Cache_Manager::close_i ACE_Handle_Set   reactor_registered,
TAO_EventHandlerSet   unregistered
[private]
 

Non-locking version and actual implementation of close ().

Definition at line 332 of file Transport_Cache_Manager.cpp.

References ACE_RECYCLABLE_CLOSED, ACE_Hash_Map_Manager_Ex< TAO_Cache_ExtId, TAO_Cache_IntId, ACE_Hash< TAO_Cache_ExtId >, ACE_Equal_To< TAO_Cache_ExtId >, ACE_Null_Mutex >::begin, cache_map_, ACE_Hash_Map_Manager_Ex< TAO_Cache_ExtId, TAO_Cache_IntId, ACE_Hash< TAO_Cache_ExtId >, ACE_Equal_To< TAO_Cache_ExtId >, ACE_Null_Mutex >::end, HASH_MAP_ITER, and ACE_Hash_Map_Manager_Ex< TAO_Cache_ExtId, TAO_Cache_IntId, ACE_Hash< TAO_Cache_ExtId >, ACE_Equal_To< TAO_Cache_ExtId >, ACE_Null_Mutex >::unbind_all.

Referenced by close.

00334 {
00335   HASH_MAP_ITER end_iter =
00336     this->cache_map_.end ();
00337 
00338   for (HASH_MAP_ITER iter = this->cache_map_.begin ();
00339        iter != end_iter;
00340        ++iter)
00341     {
00342       // First we look through whether we have an entry that has already
00343       // been closed.
00344 
00345       if ((*iter).int_id_.recycle_state () != ACE_RECYCLABLE_CLOSED)
00346         {
00347           // Get the transport to fill its associated connection's handle in
00348           // the handle sets.
00349           (*iter).int_id_.transport ()->provide_handle (reactor_registered,
00350                                                         unregistered);
00351           // Inform the transport that has a reference to the entry in the
00352           // map that we are *gone* now. So, the transport should not use
00353           // the reference to the entry that he has, to acces us *at any
00354           // time*.
00355           (*iter).int_id_.transport ()->cache_map_entry (0);
00356         }
00357      }
00358 
00359   // Unbind all the entries in the map
00360   this->cache_map_.unbind_all ();
00361 
00362   return 0;
00363 }

int TAO_Transport_Cache_Manager::cpscmp const void *    a,
const void *    b
[static, private]
 

Used by qsort.

Definition at line 439 of file Transport_Cache_Manager.cpp.

Referenced by sort_set.

00440 {
00441   const HASH_MAP_ENTRY** left  = (const HASH_MAP_ENTRY**)a;
00442   const HASH_MAP_ENTRY** right = (const HASH_MAP_ENTRY**)b;
00443 
00444   if ((*left)->int_id_.transport ()->purging_order () <
00445       (*right)->int_id_.transport ()->purging_order ())
00446     return -1;
00447 
00448   if ((*left)->int_id_.transport ()->purging_order () >
00449       (*right)->int_id_.transport ()->purging_order ())
00450     return 1;
00451 
00452   return 0;
00453 }

ACE_INLINE size_t TAO_Transport_Cache_Manager::current_size void    const
 

Return the current size of the cache.

Definition at line 131 of file Transport_Cache_Manager.inl.

References cache_map_, and ACE_Hash_Map_Manager_Ex< TAO_Cache_ExtId, TAO_Cache_IntId, ACE_Hash< TAO_Cache_ExtId >, ACE_Equal_To< TAO_Cache_ExtId >, ACE_Null_Mutex >::current_size.

Referenced by fill_set_i, and sort_set.

00132 {
00133   return this->cache_map_.current_size ();
00134 }

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 576 of file Transport_Cache_Manager.cpp.

References ACE_DEBUG, ACE_NEW_RETURN, ACE_Hash_Map_Manager_Ex< TAO_Cache_ExtId, TAO_Cache_IntId, ACE_Hash< TAO_Cache_ExtId >, ACE_Equal_To< TAO_Cache_ExtId >, ACE_Null_Mutex >::begin, cache_map_, TAO_Connection_Purging_Strategy::cache_maximum, current_size, HASH_MAP_ITER, LM_DEBUG, purging_strategy_, and sort_set.

Referenced by purge.

00577 {
00578   int current_size = 0;
00579   int cache_maximum = this->purging_strategy_->cache_maximum ();
00580 
00581   // set sorted_set to 0.  This signifies nothing to purge.
00582   sorted_set = 0;
00583 
00584   // Do we need to worry about cache purging?
00585   if (cache_maximum >= 0)
00586     {
00587       current_size = ACE_static_cast(int, this->cache_map_.current_size ());
00588 
00589       if (TAO_debug_level > 0)
00590         {
00591           ACE_DEBUG ((LM_DEBUG,
00592                       "TAO (%P|%t) - Transport_Cache_Manager::fill_set_i, "
00593                       "current_size = %d, cache_maximum = %d\n",
00594                       current_size, cache_maximum));
00595         }
00596 
00597       if (current_size >= cache_maximum)
00598         {
00599           ACE_NEW_RETURN (sorted_set, HASH_MAP_ENTRY*[current_size], 0);
00600 
00601           HASH_MAP_ITER iter = this->cache_map_.begin ();
00602           for (int i = 0; i < current_size; i++)
00603             {
00604               sorted_set[i] = &(*iter);
00605               iter++;
00606             }
00607           this->sort_set (sorted_set, current_size);
00608         }
00609     }
00610 
00611   return current_size;
00612 }

int TAO_Transport_Cache_Manager::find const TAO_Cache_ExtId   key,
TAO_Cache_IntId   value
[private]
 

Lookup entry<key,value> in the cache. Grabs the lock and calls the implementation function find_i.

Definition at line 178 of file Transport_Cache_Manager.cpp.

References ACE_GUARD_RETURN, ACE_MT, find_i, purging_strategy_, TAO_Cache_IntId::transport, and TAO_Connection_Purging_Strategy::update_item.

Referenced by find_transport.

00180 {
00181   ACE_MT (ACE_GUARD_RETURN  (ACE_Lock,
00182                              guard,
00183                              *this->cache_lock_,
00184                              -1));
00185 
00186   int status =  this->find_i (key,
00187                               value);
00188 
00189   if (status == 0)
00190     {
00191       // Update the purging strategy information while we
00192       // are holding our lock
00193       this->purging_strategy_->update_item (value.transport ());
00194     }
00195 
00196   return status;
00197 }

int TAO_Transport_Cache_Manager::find_i const TAO_Cache_ExtId   key,
TAO_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 202 of file Transport_Cache_Manager.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_RECYCLABLE_BUSY, cache_map_, ACE_Hash_Map_Entry< TAO_Cache_ExtId, TAO_Cache_IntId >::ext_id_, ACE_Hash_Map_Manager_Ex< TAO_Cache_ExtId, TAO_Cache_IntId, ACE_Hash< TAO_Cache_ExtId >, ACE_Equal_To< TAO_Cache_ExtId >, ACE_Null_Mutex >::find, TAO_Transport::id, TAO_Cache_ExtId::incr_index, TAO_Cache_ExtId::index, ACE_Hash_Map_Entry< TAO_Cache_ExtId, TAO_Cache_IntId >::int_id_, is_entry_idle, LM_DEBUG, LM_ERROR, TAO_Cache_ExtId::property, TAO_Cache_IntId::recycle_state, TAO_Cache_IntId::transport, and wait_for_connection.

Referenced by find.

00204 {
00205   HASH_MAP_ENTRY *entry = 0;
00206 
00207   // Get the entry from the Hash Map
00208   int retval = 0;
00209 
00210   // Make a temporary object. It does not do a copy.
00211   TAO_Cache_ExtId tmp_key (key.property ());
00212 
00213   while (retval == 0)
00214     {
00215       // Wait for a connection..
00216       this->wait_for_connection (tmp_key);
00217 
00218       // Look for an entry in the map
00219       retval = this->cache_map_.find (tmp_key,
00220                                       entry);
00221 
00222       // We have an entry in the map, check whether it is idle.
00223       if (entry)
00224         {
00225           CORBA::Boolean idle =
00226             this->is_entry_idle (entry);
00227 
00228           if (idle)
00229             {
00230               // Successfully found a TAO_Transport.
00231 
00232               // NOTE: This assignment operator indirectly incurs two
00233               //       lock operations since it duplicates and releases
00234               //       TAO_Transport objects.
00235               value = entry->int_id_;
00236 
00237               entry->int_id_.recycle_state (ACE_RECYCLABLE_BUSY);
00238 
00239               if (TAO_debug_level > 4)
00240                 {
00241                   ACE_DEBUG ((LM_DEBUG,
00242                               "TAO (%P|%t) - Transport_Cache_Manager::find_i, "
00243                               "index in find <%d> (Transport[%d])\n",
00244                               entry->ext_id_.index (),
00245                               value.transport ()->id ()
00246                               ));
00247                 }
00248               return 0;
00249             }
00250         }
00251 
00252       // Bump the index up
00253       tmp_key.incr_index ();
00254     }
00255 
00256   // If we are here then it is an error
00257   if (TAO_debug_level > 4 && retval != 0)
00258     {
00259       ACE_ERROR ((LM_ERROR,
00260                   "TAO (%P|%t) - Transport_Cache_Manager::find_i, "
00261                   "unable to locate a free connection\n"));
00262     }
00263 
00264   return retval;
00265 }

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 153 of file Transport_Cache_Manager.cpp.

References find, and TAO_Cache_IntId::relinquish_transport.

Referenced by TAO_Connector::connect.

00156 {
00157   if (prop == 0)
00158     {
00159       transport = 0;
00160       return -1;
00161     }
00162 
00163   // Compose the ExternId
00164   TAO_Cache_ExtId ext_id (prop);
00165   TAO_Cache_IntId int_id;
00166 
00167   int retval = this->find (ext_id,
00168                            int_id);
00169   if (retval == 0)
00170     {
00171       transport = int_id.relinquish_transport ();
00172     }
00173 
00174   return retval;
00175 }

int TAO_Transport_Cache_Manager::get_last_index_bind TAO_Cache_ExtId   key,
TAO_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 393 of file Transport_Cache_Manager.cpp.

References ACE_Hash_Map_Manager_Ex< TAO_Cache_ExtId, TAO_Cache_IntId, ACE_Hash< TAO_Cache_ExtId >, ACE_Equal_To< TAO_Cache_ExtId >, ACE_Null_Mutex >::bind, cache_map_, ACE_Hash_Map_Entry< TAO_Cache_ExtId, TAO_Cache_IntId >::ext_id_, ACE_Hash_Map_Manager_Ex< TAO_Cache_ExtId, TAO_Cache_IntId, ACE_Hash< TAO_Cache_ExtId >, ACE_Equal_To< TAO_Cache_ExtId >, ACE_Null_Mutex >::find, and TAO_Cache_ExtId::index.

Referenced by bind_i.

00396 {
00397   CORBA::ULong ctr = entry->ext_id_.index ();
00398 
00399   int retval = 0;
00400 
00401   while (retval == 0)
00402     {
00403       // Set the index
00404       key.index (++ctr);
00405 
00406       // Check to see if an element exists in the Map. If it exists we
00407       // loop, else we drop out of the loop
00408       retval =
00409         this->cache_map_.find (key);
00410     }
00411 
00412   // Now do a bind again with the new index
00413   return  this->cache_map_.bind (key,
00414                                  val,
00415                                  entry);
00416 }

int TAO_Transport_Cache_Manager::is_entry_idle HASH_MAP_ENTRY *&    entry [private]
 

Tries to find if the <int_id_> 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 420 of file Transport_Cache_Manager.cpp.

References ACE_DEBUG, ACE_RECYCLABLE_IDLE_AND_PURGABLE, ACE_RECYCLABLE_IDLE_BUT_NOT_PURGABLE, ACE_Hash_Map_Entry< TAO_Cache_ExtId, TAO_Cache_IntId >::int_id_, LM_DEBUG, and TAO_Cache_IntId::recycle_state.

Referenced by find_i, and purge.

00421 {
00422   if (TAO_debug_level)
00423     {
00424       ACE_DEBUG ((LM_DEBUG,
00425                   "TAO (%P|%t) - Transport_Cache_Manager::is_entry_idle_i, "
00426                   "state is [%d]\n",
00427                   entry->int_id_.recycle_state ()));
00428     }
00429   if (entry->int_id_.recycle_state () == ACE_RECYCLABLE_IDLE_AND_PURGABLE ||
00430       entry->int_id_.recycle_state () == ACE_RECYCLABLE_IDLE_BUT_NOT_PURGABLE)
00431     return 1;
00432 
00433   return 0;
00434 }

int TAO_Transport_Cache_Manager::is_wakeup_useful TAO_Cache_ExtId   extid [private]
 

Is the wakeup useful todo some work?

Definition at line 657 of file Transport_Cache_Manager.cpp.

References condition_, TAO_Cache_ExtId::index, TAO_Transport_Descriptor_Interface::is_equivalent, last_entry_returned_, no_waiting_threads_, TAO_Cache_ExtId::property, and TAO_Condition< TAO_SYNCH_MUTEX >::signal.

Referenced by wait_for_connection.

00658 {
00659   // Get the underlying property that we are looking for
00660   TAO_Transport_Descriptor_Interface *prop = extid.property ();
00661 
00662   // Just check the underlying property for equivalence. If the last
00663   // connection that was returned  had the same property just return
00664   // 1.
00665   if (this->last_entry_returned_ &&
00666       prop->is_equivalent (this->last_entry_returned_->property ()))
00667     {
00668       // Set the index to be right so that we can pick teh connection
00669       // right away..
00670       extid.index (this->last_entry_returned_->index ());
00671 
00672       // There is no more use for it ...
00673       this->last_entry_returned_ = 0;
00674 
00675       return 1;
00676     }
00677 
00678   // If there  is an entry that was returned and if there are more
00679   // threads just wake up the peer to check for the returned
00680   // connection.
00681   if (this->last_entry_returned_ &&
00682       this->no_waiting_threads_ > 1)
00683     {
00684       this->condition_->signal ();
00685     }
00686 
00687   return 0;
00688 }

ACE_INLINE int TAO_Transport_Cache_Manager::make_idle HASH_MAP_ENTRY *&    entry
 

Make the entry idle and ready for use.

Definition at line 98 of file Transport_Cache_Manager.inl.

References ACE_GUARD_RETURN, ACE_MT, and make_idle_i.

Referenced by TAO_Transport::make_idle.

00099 {
00100   if(entry == 0)
00101     return -1;
00102 
00103   ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->cache_lock_, -1));
00104   return this->make_idle_i (entry);
00105 }

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 268 of file Transport_Cache_Manager.cpp.

References ACE_ERROR, ACE_RECYCLABLE_IDLE_AND_PURGABLE, cache_map_, condition_, ACE_Hash_Map_Entry< TAO_Cache_ExtId, TAO_Cache_IntId >::ext_id_, ACE_Hash_Map_Manager_Ex< TAO_Cache_ExtId, TAO_Cache_IntId, ACE_Hash< TAO_Cache_ExtId >, ACE_Equal_To< TAO_Cache_ExtId >, ACE_Null_Mutex >::find, ACE_Hash_Map_Entry< TAO_Cache_ExtId, TAO_Cache_IntId >::int_id_, last_entry_returned_, LM_ERROR, no_waiting_threads_, and TAO_Condition< TAO_SYNCH_MUTEX >::signal.

Referenced by make_idle.

00269 {
00270   if (entry == 0)
00271     return -1;
00272 
00273   // First get the entry again (if at all things had changed in the
00274   // cache map in the mean time)
00275 
00276   // @todo: Is this required? Looks like a legacy one..
00277 
00278   HASH_MAP_ENTRY *new_entry = 0;
00279   int retval = this->cache_map_.find (entry->ext_id_,
00280                                       new_entry);
00281   if (retval == 0)
00282     {
00283 
00284       new_entry->int_id_.
00285         recycle_state (ACE_RECYCLABLE_IDLE_AND_PURGABLE);
00286 
00287       entry = new_entry;
00288 
00289       // Does any one need waking?
00290       if (this->no_waiting_threads_)
00291         {
00292           // We returned this entry to the map
00293           this->last_entry_returned_ = &new_entry->ext_id_;
00294 
00295           // Wake up a thread
00296           this->condition_->signal ();
00297         }
00298     }
00299   else if (TAO_debug_level > 0 && retval != 0)
00300     {
00301       ACE_ERROR ((LM_ERROR,
00302                   "TAO (%P|%t) - Transport_Cache_Manager::make_idle_i, "
00303                   "unable to locate the entry to make it idle\n"));
00304     }
00305 
00306   return retval;
00307 }

ACE_INLINE TAO_Transport_Cache_Manager::HASH_MAP & TAO_Transport_Cache_Manager::map void   
 

Return the underlying cache map.

Definition at line 143 of file Transport_Cache_Manager.inl.

References cache_map_.

00144 {
00145   return this->cache_map_;
00146 }

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 84 of file Transport_Cache_Manager.inl.

References ACE_GUARD, ACE_MT, and mark_invalid_i.

00085 {
00086   if(entry == 0)
00087     return;
00088 
00089   // Double checked locking
00090   ACE_MT (ACE_GUARD (ACE_Lock, guard, *this->cache_lock_));
00091 
00092   this->mark_invalid_i (entry);
00093 }

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 381 of file Transport_Cache_Manager.cpp.

References ACE_RECYCLABLE_PURGABLE_BUT_NOT_IDLE, ACE_Hash_Map_Entry< TAO_Cache_ExtId, TAO_Cache_IntId >::int_id_, and TAO_Cache_IntId::recycle_state.

Referenced by mark_invalid.

00382 {
00383   if (entry == 0)
00384     return;
00385 
00386   // Mark the entry as not usable
00387   entry->int_id_.recycle_state (ACE_RECYCLABLE_PURGABLE_BUT_NOT_IDLE);
00388 }

int TAO_Transport_Cache_Manager::purge void   
 

Remove entries from the cache depending upon the strategy.

Definition at line 457 of file Transport_Cache_Manager.cpp.

References TAO_Transport::_duplicate, ACE_DEBUG, ACE_GUARD_RETURN, ACE_MT, ACE_RECYCLABLE_BUSY, ACE_TEXT, TAO_Transport::cache_map_entry, TAO_Transport::close_connection_no_purge, fill_set_i, TAO_Transport::id, ACE_Hash_Map_Entry< TAO_Cache_ExtId, TAO_Cache_IntId >::int_id_, ACE_Unbounded_Stack::is_empty, is_entry_idle, LM_DEBUG, LM_INFO, percent_, ACE_Unbounded_Stack::pop, purge_entry_i, ACE_Unbounded_Stack::push, TAO_Cache_IntId::recycle_state, TAO_Transport::release, and TAO_Cache_IntId::transport.

Referenced by TAO_Connector::connect, and TAO_Creation_Strategy::make_svc_handler.

00458 {
00459   ACE_Unbounded_Stack<TAO_Transport*> transports_to_be_closed;
00460 
00461   {
00462     ACE_MT (ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->cache_lock_, 0));
00463 
00464     DESCRIPTOR_SET sorted_set = 0;
00465     int sorted_size = this->fill_set_i (sorted_set);
00466 
00467     // Only call close_entries () if sorted_set != 0.  It takes control of
00468     // sorted_set and cleans up any allocated memory.  If sorted_set == 0,
00469     // then there is nothing to de-allocate.
00470     if (sorted_set != 0)
00471       {
00472         // BEGIN FORMER close_entries
00473         // Calculate the number of entries to purge
00474         const int amount = (sorted_size * this->percent_) / 100;
00475 
00476         if (TAO_debug_level > 0)
00477           {
00478             ACE_DEBUG ((LM_DEBUG,
00479                         ACE_TEXT ("TAO (%P|%t) - Transport_Cache_Manager::purge, ")
00480                         ACE_TEXT ("purging %d of %d cache entries\n"),
00481                         amount,
00482                         sorted_size));
00483           }
00484 
00485         int count = 0;
00486         for(int i = 0; count < amount && i < sorted_size; i++)
00487           {
00488             if (this->is_entry_idle(sorted_set[i]))
00489               {
00490                 sorted_set[i]->int_id_.recycle_state (ACE_RECYCLABLE_BUSY);
00491 
00492                 TAO_Transport* transport = sorted_set[i]->int_id_.transport ();
00493                 if (transports_to_be_closed.push (TAO_Transport::_duplicate(transport)) != 0)
00494                   {
00495                     ACE_DEBUG ((LM_INFO,
00496                                 ACE_TEXT ("TAO (%P|%t) - ")
00497                                 ACE_TEXT ("Unable to push transport %lu on the to-be-closed stack, so it will leak\n"),
00498                                 transport));
00499                   }
00500 
00501                 if (TAO_debug_level > 0)
00502                   {
00503                     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - ")
00504                                           ACE_TEXT ("Idle transport found in ")
00505                                           ACE_TEXT ("cache: [%d] \n"),
00506                                           transport->id ()));
00507                   }
00508 
00509                 // We need to save the cache_map_entry before we
00510                 // set it to zero, so we can call purge_entry_i()
00511                 // after we call close_connection_no_purge ().
00512                 HASH_MAP_ENTRY* entry = transport->cache_map_entry ();
00513 
00514                 // This is a bit ugly, but we must do this to
00515                 // avoid taking and giving locks inside this loop.
00516                 transport->cache_map_entry (0);
00517                 this->purge_entry_i (entry);
00518 
00519                 // Count this as a successful purged entry
00520                 count++;
00521               }
00522           }
00523 
00524       delete [] sorted_set;
00525       sorted_set = 0;
00526       // END FORMER close_entries
00527     }
00528   }
00529 
00530   // Now, without the lock held, lets go through and close all the transports.
00531   TAO_Transport *transport = 0;
00532   while (! transports_to_be_closed.is_empty ())
00533     {
00534       if (transports_to_be_closed.pop (transport) == 0)
00535         {
00536           if (transport)
00537             transport->close_connection_no_purge ();
00538           TAO_Transport::release (transport);
00539         }
00540     }
00541 
00542   return 0;
00543 }

ACE_INLINE int TAO_Transport_Cache_Manager::purge_entry HASH_MAP_ENTRY *&   
 

Purge the entry from the Cache Map.

Definition at line 72 of file Transport_Cache_Manager.inl.

References ACE_GUARD_RETURN, ACE_MT, and purge_entry_i.

Referenced by TAO_Transport::close_connection_shared, TAO_Transport::purge_entry, and TAO_Transport::recache_transport.

00073 {
00074   // Double checked locking
00075   if(entry == 0)
00076     return 0;
00077 
00078   ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->cache_lock_, -1));
00079 
00080   return this->purge_entry_i (entry);
00081 }

int TAO_Transport_Cache_Manager::purge_entry_i HASH_MAP_ENTRY *&    entry [private]
 

Purge the entry from the Cache Map.

Definition at line 366 of file Transport_Cache_Manager.cpp.

References cache_map_, and ACE_Hash_Map_Manager_Ex< TAO_Cache_ExtId, TAO_Cache_IntId, ACE_Hash< TAO_Cache_ExtId >, ACE_Equal_To< TAO_Cache_ExtId >, ACE_Null_Mutex >::unbind.

Referenced by purge, and purge_entry.

00367 {
00368   if (entry == 0)
00369     return 0;
00370 
00371   // Remove the entry from the Map
00372  int retval = this->cache_map_.unbind (entry);
00373 
00374   // Set the entry pointer to zero
00375   entry = 0;
00376 
00377   return retval;
00378 }

void TAO_Transport_Cache_Manager::sort_set DESCRIPTOR_SET   entries,
int    size
[private]
 

Sort the list of entries.

Definition at line 547 of file Transport_Cache_Manager.cpp.

References ACE_COMPARE_FUNC, cpscmp, current_size, ACE_Hash_Map_Entry< TAO_Cache_ExtId, TAO_Cache_IntId >::int_id_, TAO_Transport::purging_order, ACE_OS::qsort, and TAO_Cache_IntId::transport.

Referenced by fill_set_i.

00549 {
00550 #if defined (ACE_LACKS_QSORT)
00551   // Use insertion sort if we don't have qsort
00552   for(int i = 1; i < current_size; i++)
00553     {
00554       if (entries[i]->int_id_.transport ()->purging_order () <
00555                     entries[i - 1]->int_id_.transport ()->purging_order ())
00556         {
00557           HASH_MAP_ENTRY* entry = entries[i];
00558           for(int j = i; j > 0 &&
00559               entries[j - 1]->int_id_.transport ()->purging_order () >
00560               entry->int_id_.transport ()->purging_order (); j--)
00561             {
00562               HASH_MAP_ENTRY* holder = entries[j];
00563               entries[j] = entries[j - 1];
00564               entries[j - 1] = holder;
00565             }
00566         }
00567     }
00568 #else
00569   ACE_OS::qsort (entries, current_size,
00570                  sizeof (HASH_MAP_ENTRY*), (ACE_COMPARE_FUNC)cpscmp);
00571 #endif /* ACE_LACKS_QSORT */
00572 }

ACE_INLINE size_t TAO_Transport_Cache_Manager::total_size void    const
 

Return the total size of the cache.

Definition at line 137 of file Transport_Cache_Manager.inl.

References cache_map_, and ACE_Hash_Map_Manager_Ex< TAO_Cache_ExtId, TAO_Cache_IntId, ACE_Hash< TAO_Cache_ExtId >, ACE_Equal_To< TAO_Cache_ExtId >, ACE_Null_Mutex >::total_size.

00138 {
00139   return this->cache_map_.total_size ();
00140 }

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 311 of file Transport_Cache_Manager.cpp.

References ACE_GUARD_RETURN, ACE_MT, ACE_Hash_Map_Entry< TAO_Cache_ExtId, TAO_Cache_IntId >::int_id_, purging_strategy_, TAO_Cache_IntId::transport, and TAO_Connection_Purging_Strategy::update_item.

Referenced by TAO_Transport::update_transport.

00312 {
00313   if(entry == 0)
00314     return -1;
00315 
00316   ACE_MT (ACE_GUARD_RETURN (ACE_Lock,
00317                             guard,
00318                             *this->cache_lock_, -1));
00319 
00320   if (entry == 0)
00321     return -1;
00322 
00323   TAO_Connection_Purging_Strategy *st =
00324     this->purging_strategy_;
00325 
00326   (void) st->update_item (entry->int_id_.transport ());
00327 
00328   return 0;
00329 }

int TAO_Transport_Cache_Manager::wait_for_connection TAO_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. <extid> has all the information about the connection that is being searched.

Definition at line 616 of file Transport_Cache_Manager.cpp.

References ACE_DEBUG, condition_, TAO_Cache_ExtId::index, is_wakeup_useful, LM_DEBUG, muxed_number_, no_waiting_threads_, and TAO_Condition< TAO_SYNCH_MUTEX >::wait.

Referenced by find_i.

00617 {
00618   if (this->muxed_number_ &&
00619       this->muxed_number_ == extid.index ())
00620     {
00621       // If we have a limit on the number of muxed connections for
00622       // a particular endpoint just wait to get the connection
00623       ++this->no_waiting_threads_;
00624 
00625       if (TAO_debug_level > 2)
00626         {
00627           ACE_DEBUG ((LM_DEBUG,
00628                       "TAO (%P|%t) - Transport_Cache_Manager::wait_for_connection, "
00629                       "entering wait loop\n"));
00630         }
00631 
00632       int ready_togo = 0;
00633 
00634       while (ready_togo == 0)
00635         {
00636           this->condition_->wait ();
00637 
00638           // Check whether we are waiting for this connection
00639           ready_togo = this->is_wakeup_useful (extid);
00640         }
00641 
00642       if (TAO_debug_level > 2)
00643         {
00644           ACE_DEBUG ((LM_DEBUG,
00645                       "TAO (%P|%t) - Transport_Cache_Manager::wait_for_connection, "
00646                       "left wait loop\n"));
00647         }
00648 
00649       // We are not waiting anymore
00650       --this->no_waiting_threads_;
00651     }
00652 
00653   return 0;
00654 }


Member Data Documentation

ACE_Lock* TAO_Transport_Cache_Manager::cache_lock_ [private]
 

The lock that is used by the cache map.

Definition at line 240 of file Transport_Cache_Manager.h.

Referenced by close, and ~TAO_Transport_Cache_Manager.

HASH_MAP TAO_Transport_Cache_Manager::cache_map_ [private]
 

The hash map that has the connections.

Definition at line 234 of file Transport_Cache_Manager.h.

Referenced by bind_i, close_i, current_size, fill_set_i, find_i, get_last_index_bind, make_idle_i, map, purge_entry_i, and total_size.

CONDITION* TAO_Transport_Cache_Manager::condition_ [private]
 

The condition variable.

Definition at line 237 of file Transport_Cache_Manager.h.

Referenced by is_wakeup_useful, make_idle_i, wait_for_connection, and ~TAO_Transport_Cache_Manager.

TAO_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 252 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 243 of file Transport_Cache_Manager.h.

Referenced by TAO_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 246 of file Transport_Cache_Manager.h.

Referenced by is_wakeup_useful, make_idle_i, wait_for_connection, and ~TAO_Transport_Cache_Manager.

int TAO_Transport_Cache_Manager::percent_ [private]
 

The percentage of the cache to purge at one time.

Definition at line 228 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 231 of file Transport_Cache_Manager.h.

Referenced by bind_i, fill_set_i, find, update_entry, and ~TAO_Transport_Cache_Manager.


The documentation for this class was generated from the following files:
Generated on Mon Jun 16 15:44:09 2003 for TAO by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002