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

enum  Find_Result { CACHE_FOUND_NONE, CACHE_FOUND_CONNECTING, CACHE_FOUND_BUSY, CACHE_FOUND_AVAILABLE }
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, Cache_Entries_State state=ENTRY_IDLE_BUT_NOT_PURGABLE)
 Add the transport to the cache.
int cache_idle_transport (TAO_Transport_Descriptor_Interface *prop, TAO_Transport *transport)
Find_Result find_transport (TAO_Transport_Descriptor_Interface *prop, TAO_Transport *&transport, size_t &busy_count)
int purge (void)
 Remove entries from the cache depending upon the strategy.
int purge_entry (HASH_MAP_ENTRY *&entry)
 Purge the entry from the Cache Map.
void mark_invalid (HASH_MAP_ENTRY *entry)
 Mark the entry as invalid for use but keep it in cache.
void mark_connected (HASH_MAP_ENTRY *entry, bool state)
 Mark the entry as connected.
int make_idle (HASH_MAP_ENTRY *entry)
 Make the entry idle and ready for use.
void set_entry_state (HASH_MAP_ENTRY *entry, TAO::Cache_Entries_State state)
 Modify the state setting on the provided entry.
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_MAPmap (void)
 Return the underlying cache map.

Private Types

typedef HASH_MAP_ENTRY ** DESCRIPTOR_SET

Private Member Functions

Find_Result find (TAO_Transport_Descriptor_Interface *prop, TAO_Transport *&transport, size_t &busy_count)
int bind_i (Cache_ExtId &ext_id, Cache_IntId &int_id)
Find_Result find_i (TAO_Transport_Descriptor_Interface *prop, TAO_Transport *&transport, size_t &busy_count)
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 *entry)
 Mark the entry as invalid for use but keep it in cache.
bool is_entry_available (const HASH_MAP_ENTRY &entry)
bool is_entry_connecting (const 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)
bool blockable_client_transports_i (Connection_Handler_Set &handlers)
 Non-locking version of blockable_client_transports ().

Static Private Member Functions

static 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_Strategypurging_strategy_
 The underlying connection purging strategy.
HASH_MAP cache_map_
 The hash map that has the connections.
TAO_SYNCH_MUTEX cache_map_mutex_
ACE_Lockcache_lock_
 The lock that is used by the cache map.


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.


Member Typedef Documentation

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

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

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

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


Member Enumeration Documentation

enum TAO::Transport_Cache_Manager::Find_Result

Enumerator:
CACHE_FOUND_NONE 
CACHE_FOUND_CONNECTING 
CACHE_FOUND_BUSY 
CACHE_FOUND_AVAILABLE 


Constructor & Destructor Documentation

TAO::Transport_Cache_Manager::Transport_Cache_Manager ( TAO_ORB_Core orb_core  ) 

Constructor.

TAO::Transport_Cache_Manager::~Transport_Cache_Manager ( void   ) 

Destructor.


Member Function Documentation

ACE_INLINE int TAO::Transport_Cache_Manager::cache_transport ( TAO_Transport_Descriptor_Interface prop,
TAO_Transport transport,
Cache_Entries_State  state = ENTRY_IDLE_BUT_NOT_PURGABLE 
)

Add the transport to the cache.

The transport has the property definition based on which caching can be done. This method sets the cache entry status. By default the status is set to ENTRY_IDLE_BUT_NOT_PURGABLE

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

this is just a shortcut for cache_transport with a third argument of ENTRY_IDLE_AND_PURGABLE @TODO: it should be replaced with a direct call to cache_transport, but that would require changes to all *_Connection_Handler so I'm deferring this for now. (wilsond@ociweb.com)

Transport_Cache_Manager::Find_Result TAO::Transport_Cache_Manager::find_transport ( TAO_Transport_Descriptor_Interface prop,
TAO_Transport *&  transport,
size_t &  busy_count 
)

Check the Transport Cache to check whether the connection exists in the Cache and return the connection

int TAO::Transport_Cache_Manager::purge ( void   ) 

Remove entries from the cache depending upon the strategy.

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

Purge the entry from the Cache Map.

ACE_INLINE void TAO::Transport_Cache_Manager::mark_invalid ( HASH_MAP_ENTRY entry  ) 

Mark the entry as invalid for use but keep it in cache.

ACE_INLINE void TAO::Transport_Cache_Manager::mark_connected ( HASH_MAP_ENTRY entry,
bool  state 
)

Mark the entry as connected.

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

Make the entry idle and ready for use.

void TAO::Transport_Cache_Manager::set_entry_state ( HASH_MAP_ENTRY entry,
TAO::Cache_Entries_State  state 
)

Modify the state setting on the provided entry.

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

Mark the entry as touched. This call updates the purging strategy policy information.

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

Close the underlying hash map manager and return any handlers still registered

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

Return a set of connection handlers that belong to transports that have a RW wait strategy. 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.

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

Return the current size of the cache.

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

Return the total size of the cache.

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

Return the underlying cache map.

ACE_INLINE Transport_Cache_Manager::Find_Result TAO::Transport_Cache_Manager::find ( TAO_Transport_Descriptor_Interface prop,
TAO_Transport *&  transport,
size_t &  busy_count 
) [private]

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

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.

Transport_Cache_Manager::Find_Result TAO::Transport_Cache_Manager::find_i ( TAO_Transport_Descriptor_Interface prop,
TAO_Transport *&  transport,
size_t &  busy_count 
) [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 ().

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

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

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

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

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

Purge the entry from the Cache Map.

void TAO::Transport_Cache_Manager::mark_invalid_i ( HASH_MAP_ENTRY entry  )  [private]

Mark the entry as invalid for use but keep it in cache.

bool TAO::Transport_Cache_Manager::is_entry_available ( const HASH_MAP_ENTRY entry  )  [private]

Tries to find if the <int_id_> in entry is available for use.

bool TAO::Transport_Cache_Manager::is_entry_connecting ( const HASH_MAP_ENTRY entry  )  [private]

Tries to find if the <int_id_> in entry is connect pending

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

Used by qsort.

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

Sort the list of entries.

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.

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

Non-locking version of blockable_client_transports ().


Member Data Documentation

int TAO::Transport_Cache_Manager::percent_ [private]

The percentage of the cache to purge at one time.

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

The underlying connection purging strategy.

HASH_MAP TAO::Transport_Cache_Manager::cache_map_ [private]

The hash map that has the connections.

TAO_SYNCH_MUTEX TAO::Transport_Cache_Manager::cache_map_mutex_ [private]

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

The lock that is used by the cache map.


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

Generated on Mon Sep 15 07:45:04 2008 for TAO by  doxygen 1.5.5