ACE/ace/Cached_Connect_Strategy_T.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Cached_Connect_Strategy_T.h
   6  *
   7  *  @author Kirthika Parameswaran <kirthika@cs.wustl.edu>
   8  */
   9 //=============================================================================
  10
  11 #ifndef CACHED_CONNECT_STRATEGY_T_H
  12 #define CACHED_CONNECT_STRATEGY_T_H
  13
  14 #include /**/ "ace/pre.h"
  15
  16 #include /**/ "ace/config-all.h"
  17
  18 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  19 # pragma once
  20 #endif /* ACE_LACKS_PRAGMA_ONCE */
  21
  22 #include "ace/Strategies_T.h"
  23 #include "ace/Hash_Cache_Map_Manager_T.h"
  24 #include "ace/Caching_Strategies_T.h"
  25 #include "ace/Functor_T.h"
  26 #include "ace/Pair_T.h"
  27
  28 // For linkers which cant grok long names...
  29 #define ACE_Cached_Connect_Strategy_Ex ACCSE
  30
  31 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  32
  33 /**
  34  * @class ACE_Cached_Connect_Strategy_Ex
  35  *
  36  * @brief A connection strategy which caches connections to peers
  37  * (represented by SVC_HANDLER instances), thereby allowing
  38  * subsequent re-use of unused, but available, connections.
  39  *
  40  * <Cached_Connect_Strategy> is intended to be used as a
  41  * plug-in connection strategy for ACE_Strategy_Connector.
  42  * It's added value is re-use of established connections and
  43  * tweaking the role of the cache as per the caching strategy.
  44  */
  45 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class CACHING_STRATEGY, class ATTRIBUTES, class MUTEX>
  46 class ACE_Cached_Connect_Strategy_Ex
  47  : public ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>
  48 {
  49 public:
  50   /// Constructor
  51   ACE_Cached_Connect_Strategy_Ex (
  52     CACHING_STRATEGY &caching_s,
  53     ACE_Creation_Strategy<SVC_HANDLER> *cre_s = 0,
  54     ACE_Concurrency_Strategy<SVC_HANDLER> *con_s = 0,
  55     ACE_Recycling_Strategy<SVC_HANDLER> *rec_s = 0,
  56     MUTEX *lock = 0,
  57     int delete_lock = 0);
  58
  59   /// Destructor
  60   virtual ~ACE_Cached_Connect_Strategy_Ex ();
  61
  62   /// Explicit purging of connection entries from the connection cache.
  63   virtual int purge_connections ();
  64
  65   /// Mark as closed (non-locking version). This is used during the cleanup of the
  66   /// connections purged.
  67   virtual int mark_as_closed_i (const void *recycling_act);
  68
  69   /**
  70    * Since g++ version < 2.8 arent happy with templates, this special
  71    * method had to be devised to avoid memory leaks and perform
  72    * cleanup of the <connection_cache_>.
  73    */
  74   void cleanup ();
  75
  76   // = Typedefs for managing the map
  77   typedef ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR>
  78           REFCOUNTED_HASH_RECYCLABLE_ADDRESS;
  79  typedef ACE_Hash_Cache_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDRESS,
  80                                     SVC_HANDLER *,
  81                                     ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>,
  82                                     ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>,
  83                                     CACHING_STRATEGY,
  84                                     ATTRIBUTES>
  85           CONNECTION_CACHE;
  86   typedef typename CONNECTION_CACHE::CACHE_ENTRY CONNECTION_CACHE_ENTRY;
  87   typedef typename CONNECTION_CACHE::key_type KEY;
  88   typedef typename CONNECTION_CACHE::mapped_type VALUE;
  89
  90   typedef ACE_Recyclable_Handler_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDRESS,
  91                                                   std::pair<SVC_HANDLER *, ATTRIBUTES>,
  92                                                   ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDRESS,
  93                                                                           std::pair<SVC_HANDLER *, ATTRIBUTES>,
  94                                                                           ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>,
  95                                                                           ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>,
  96                                                                           MUTEX> >
  97           CLEANUP_STRATEGY;
  98
  99   typedef ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>
 100           CCSBASE;
 101
 102   // = Accessor.
 103   CACHING_STRATEGY &caching_strategy ();
 104
 105   /// Declare the dynamic allocation hooks.
 106   ACE_ALLOC_HOOK_DECLARE;
 107
 108 protected:
 109   /// Find an idle handle.
 110   int find (ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR> &search_addr,
 111             ACE_Hash_Map_Entry<ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR>, std::pair<SVC_HANDLER *, ATTRIBUTES> > *&entry);
 112
 113   /// Remove from cache (non-locking version).
 114   virtual int purge_i (const void *recycling_act);
 115
 116   /// Add to cache (non-locking version).
 117   virtual int cache_i (const void *recycling_act);
 118
 119   /// Get/Set recycle_state (non-locking version).
 120   virtual int recycle_state_i (const void *recycling_act,
 121                                ACE_Recyclable_State new_state);
 122   virtual ACE_Recyclable_State recycle_state_i (const void *recycling_act) const;
 123
 124   /// Cleanup hint and reset @c *act_holder to zero if @a act_holder != 0.
 125   virtual int cleanup_hint_i (const void *recycling_act,
 126                               void **act_holder);
 127
 128   // = Helpers
 129   int check_hint_i (SVC_HANDLER *&sh,
 130                     const ACE_PEER_CONNECTOR_ADDR &remote_addr,
 131                     ACE_Time_Value *timeout,
 132                     const ACE_PEER_CONNECTOR_ADDR &local_addr,
 133                     bool reuse_addr,
 134                     int flags,
 135                     int perms,
 136                     ACE_Hash_Map_Entry<ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR>, std::pair<SVC_HANDLER *, ATTRIBUTES> > *&entry,
 137                     int &found);
 138
 139   virtual int find_or_create_svc_handler_i (SVC_HANDLER *&sh,
 140                                     const ACE_PEER_CONNECTOR_ADDR &remote_addr,
 141                                     ACE_Time_Value *timeout,
 142                                     const ACE_PEER_CONNECTOR_ADDR &local_addr,
 143                                     bool reuse_addr,
 144                                     int flags,
 145                                     int perms,
 146                                     ACE_Hash_Map_Entry<ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR>, std::pair<SVC_HANDLER *, ATTRIBUTES> > *&entry,
 147                                     int &found);
 148
 149   virtual int connect_svc_handler_i (SVC_HANDLER *&sh,
 150                                      const ACE_PEER_CONNECTOR_ADDR &remote_addr,
 151                                      ACE_Time_Value *timeout,
 152                                      const ACE_PEER_CONNECTOR_ADDR &local_addr,
 153                                      bool reuse_addr,
 154                                      int flags,
 155                                      int perms,
 156                                      int &found);
 157
 158   /**
 159    * Connection of the svc_handler with the remote host.  This method
 160    * also encapsulates the connection done with auto_purging under the
 161    * hood. If the connect failed due to the process running out of
 162    * file descriptors then, auto_purging of some connections are done
 163    * from the CONNECTION_CACHE. This frees the descriptors which get
 164    * used in the connect process and hence the connect operation can
 165    * succeed.
 166    */
 167   virtual int cached_connect (SVC_HANDLER *&sh,
 168                               const ACE_PEER_CONNECTOR_ADDR &remote_addr,
 169                               ACE_Time_Value *timeout,
 170                               const ACE_PEER_CONNECTOR_ADDR &local_addr,
 171                               bool reuse_addr,
 172                               int flags,
 173                               int perms);
 174
 175   /// Table that maintains the cache of connected SVC_HANDLERs.
 176   CONNECTION_CACHE connection_cache_;
 177 };
 178
 179 /////////////////////////////////////////////////////////////////////////////
 180
 181 // For linkers which cant grok long names...
 182 #define ACE_Bounded_Cached_Connect_Strategy ABCCS
 183
 184 /**
 185  * @class ACE_Bounded_Cached_Connect_Strategy
 186  *
 187  * @brief
 188  * A connection strategy which caches connections to peers
 189  * (represented by SVC_HANDLER instances), thereby allowing
 190  * subsequent re-use of unused, but available, connections.
 191  * This strategy should be used when the cache is bounded by
 192  * maximum size.
 193  *
 194  * Bounded_Cached_Connect_Strategy is intended to be used as a
 195  * plug-in connection strategy for ACE_Strategy_Connector.
 196  * It's added value is re-use of established connections and
 197  * tweaking the role of the cache as per the caching strategy.
 198  * Thanks to Edan Ayal  <edana@bandwiz.com> for contributing this
 199  * class and Susan Liebeskind  <shl@janis.gtri.gatech.edu> for
 200  * brainstorming about it.
 201  */
 202 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1,
 203           class CACHING_STRATEGY, class ATTRIBUTES,
 204           class MUTEX>
 205 class ACE_Bounded_Cached_Connect_Strategy
 206   : public ACE_Cached_Connect_Strategy_Ex<SVC_HANDLER, ACE_PEER_CONNECTOR_2, CACHING_STRATEGY, ATTRIBUTES, MUTEX>
 207 {
 208    typedef ACE_Cached_Connect_Strategy_Ex<SVC_HANDLER, ACE_PEER_CONNECTOR_2, CACHING_STRATEGY, ATTRIBUTES, MUTEX>
 209    CCSEBASE;
 210
 211   // = Typedefs for managing the map
 212   typedef ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR>
 213           REFCOUNTED_HASH_RECYCLABLE_ADDRESS;
 214
 215 public:
 216   /// Constructor
 217   ACE_Bounded_Cached_Connect_Strategy (size_t  max_size,
 218                                        CACHING_STRATEGY &caching_s,
 219                                        ACE_Creation_Strategy<SVC_HANDLER> *cre_s = 0,
 220                                        ACE_Concurrency_Strategy<SVC_HANDLER> *con_s = 0,
 221                                        ACE_Recycling_Strategy<SVC_HANDLER> *rec_s = 0,
 222                                        MUTEX *lock = 0,
 223                                        int delete_lock = 0);
 224
 225   /// Destructor
 226   virtual ~ACE_Bounded_Cached_Connect_Strategy () = default;
 227
 228   /// Declare the dynamic allocation hooks.
 229   ACE_ALLOC_HOOK_DECLARE;
 230
 231 protected:
 232   virtual int find_or_create_svc_handler_i (SVC_HANDLER *&sh,
 233                                             const ACE_PEER_CONNECTOR_ADDR &remote_addr,
 234                                             ACE_Time_Value *timeout,
 235                                             const ACE_PEER_CONNECTOR_ADDR &local_addr,
 236                                             bool reuse_addr,
 237                                             int flags,
 238                                             int perms,
 239                                             ACE_Hash_Map_Entry<ACE_Refcounted_Hash_Recyclable<ACE_PEER_CONNECTOR_ADDR>,
 240                                             std::pair<SVC_HANDLER *, ATTRIBUTES> > *&entry,
 241                                             int &found);
 242
 243 protected:
 244   /// Max items in the cache, used as a bound for the creation of svc_handlers.
 245   size_t  max_size_;
 246 };
 247
 248 ACE_END_VERSIONED_NAMESPACE_DECL
 249
 250 #include "ace/Cached_Connect_Strategy_T.cpp"
 251
 252 #include /**/ "ace/post.h"
 253 #endif /* CACHED_CONNECT_STRATEGY_T_H */