ChangeLogTag:Wed Jul 21 03:20:16 1999 Kirthika Parameswaran <kirthika@cs.wustl.edu>

13 files changed, 909 insertions, 257 deletions

diff --git a/TAO/ChangeLog-99c b/TAO/ChangeLog-99c
index 17c50bd22e7..740a3241adf 100644
--- a/TAO/ChangeLog-99c
+++ b/TAO/ChangeLog-99c
@@ -1,3 +1,85 @@
+Wed Jul 21 03:20:16 1999 Kirthika Parameswaran  <kirthika@cs.wustl.edu>
+
+	* Connection Caching Feature
+	  --------------------------
+
+	  Motivation:
+
+  	  In TAO, open connections are stored in a connection cache and
+	  reused for the subsequent requests between the same client and
+	  server.  This is done to avoid the cost of establishing new
+	  connections. Every connection needs a OS handle which has to
+	  obtained from the OS. The OS can allot only a fixed number of
+	  handles to a process.  This can become a issue in case of
+	  clients and servers with multiple handles open who may not be
+	  allowed to establish a new connection as the process has run out
+	  of handles.
+
+	  Aim:
+
+  	  Clients and servers should be able to to continue making new
+	  connections by tearing down "old" connections.
+
+	  Solution: Auto-purging
+
+	  The connections are stored in a cache. When ever the connect
+	  call fails due to the process running out of handles,
+	  auto-purging will kick in and some "old" connections will be
+	  removed from the connection cache.  The decision about which
+	  connections are "old" is made by the caching strategies. The
+	  percentage of existing connections to be purged is controlled by
+	  a purge percent.
+
+	  ACE classes: Caching_Utility, Cleanup_Stratgies, and
+	  Caching_Strategies have been used.  Simple examples are
+	  available in $ACE_ROOT/tests/Cached_Accept_Conn_Test.cpp and
+	  $ACE_ROOT/tests/Cached_Conn_Test.cpp.
+
+	  Note that the users can also purge handles used by the ORB
+	  explicitly through TAO_Connector_Registry::purge_connections().
+	  This can enable them to open new handles for their application.
+
+	  Todo: Implement purging for new handles created by the Acceptor.
+	  This will increase the scalability.
+
+	  Usage: Through options to the Resource_Factory :-
+
+	  -ORBConnectionCachingStrategy <lru/lfu/fifo/null>
+	  -ORBPurgePercent <percentage>
+
+	  Now for the changes made:
+
+	* tao/Connector_Registry.{h,cpp}:
+	  Added a purge_connections () method which purges entries from
+	  the connection cache of the different connectors registered with
+	  the registry.
+
+	* tao/IIOP_Connector.{h,cpp}:
+	* tao/UIOP_Connector.{h,cpp}:
+	  Changed Cached_Connect_Strategy to Cached_Connect_Strategy_Ex as
+	  the connection strategy.  It contains the caching strategy which
+	  decides the entries to remove on demand. A
+	  Hash_Cache_Map_Manager is used to store connections and appends
+	  each entry with special attributes used for purging
+	  purposes.
+
+	* tao/orbconf.h:
+	  Added:
+	  TAO_CONNECTION_CACHING_STRATEGY (default) is LRU
+	  TAO_PURGE_PERCENT (default) is 20%
+
+	* tao/Resource_Factory.{h,cpp}:
+	  Added hooks for connection_caching_strategy_type and
+	  purge_percent. Also an enum is added which is used for deciding
+	  the different caching strategies.
+
+	* tao/default_resource.{h,cpp}:
+	  Input from the user is parsed and the caching_stratgey_type and
+	  purge_percent is decided.
+
+	  Thanks to Irfan from the DOC group for being a great help and
+	  guiding me on this project.
+
 Wed Jul 21 16:59:07 1999  Jeff Parsons  <parsons@cs.wustl.edu>
 
 	* TAO_IDL/be/be_decl.cpp:
diff --git a/TAO/tao/Connector_Registry.cpp b/TAO/tao/Connector_Registry.cpp
index c2d6eb18b48..5a368c11210 100644
--- a/TAO/tao/Connector_Registry.cpp
+++ b/TAO/tao/Connector_Registry.cpp
@@ -111,7 +111,7 @@ int
 TAO_Connector_Registry::preconnect (TAO_ORB_Core *orb_core,
                                     TAO_PreconnectSet &preconnections)
 {
-  // Put the preconnects in a form that makes it simple for protocol 
+  // Put the preconnects in a form that makes it simple for protocol
   // implementers to parse.
   if (this->preprocess_preconnects (orb_core, preconnections) != 0)
     {
@@ -162,9 +162,9 @@ TAO_Connector_Registry::preprocess_preconnects (TAO_ORB_Core *orb_core,
   //   uiop://1.1@/tmp/foobar,/tmp/chicken,/tmp/soup
   //   iiop://1.0@localhost,1.1@mopbucket
   //
-  // The four elements in the preconnect set will be squeezed into two 
+  // The four elements in the preconnect set will be squeezed into two
   // elements, in this case. This is done to simplify the preconnect
-  // parsing code in each protocol specific connector and to make sure 
+  // parsing code in each protocol specific connector and to make sure
   // that all preconnections are established during the first
   // attempt.  Otherwise, secondary attempts to establish
   // preconnections will not be successful since all preconnections
@@ -401,6 +401,26 @@ TAO_Connector_Registry::object_key_delimiter (const char *ior)
   return 0;
 }
 
+int
+TAO_Connector_Registry::purge_connections (void)
+{
+  TAO_ConnectorSetItor end =
+    this->connectors_.end ();
+
+  TAO_ConnectorSetItor iterator =
+    this->connectors_.begin ();
+
+  for (;
+       iterator != end ;
+       iterator++)
+    {
+      if ((*iterator)->purge_connections () == -1)
+        return -1;
+    }
+
+  return 0;
+}
+
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 
 template class ACE_Node<TAO_Connector*>;
diff --git a/TAO/tao/Connector_Registry.h b/TAO/tao/Connector_Registry.h
index 6e2b28064ce..d5e39254b49 100644
--- a/TAO/tao/Connector_Registry.h
+++ b/TAO/tao/Connector_Registry.h
@@ -103,6 +103,9 @@ public:
   // Obtain the object key delimiter used by the protocol specified in
   // the provided URL style IOR.
 
+  int purge_connections (void);
+  // Purge "old" connections.
+
 private:
   int preprocess_preconnects (TAO_ORB_Core *orb_core,
                               TAO_PreconnectSet &preconnects);
diff --git a/TAO/tao/IIOP_Connector.cpp b/TAO/tao/IIOP_Connector.cpp
index 8dec3dabd2f..c1b655ec1f4 100644
--- a/TAO/tao/IIOP_Connector.cpp
+++ b/TAO/tao/IIOP_Connector.cpp
@@ -1,18 +1,6 @@
 // This may look like C, but it's really -*- C++ -*-
 // $Id$
 
-// ============================================================================
-//
-// = LIBRARY
-//
-// = FILENAME
-//
-// = DESCRIPTION
-//
-// = AUTHOR
-//
-// ============================================================================
-
 #include "tao/IIOP_Connector.h"
 #include "tao/IIOP_Profile.h"
 #include "tao/GIOP.h"
@@ -45,20 +33,18 @@ TAO_IIOP_Connect_Creation_Strategy::make_svc_handler (
                           this->orb_core_),
                       -1);
     }
+
   return 0;
 }
 
 // ****************************************************************
 
-typedef ACE_Cached_Connect_Strategy<TAO_IIOP_Client_Connection_Handler,
-                                    ACE_SOCK_CONNECTOR,
-                                    TAO_Cached_Connector_Lock>
-        TAO_CACHED_CONNECT_STRATEGY;
-
 TAO_IIOP_Connector::TAO_IIOP_Connector (void)
   : TAO_Connector (TAO_IOP_TAG_INTERNET_IOP),
     base_connector_ (),
-    orb_core_ (0)
+    orb_core_ (0),
+    cached_connect_strategy_ (0),
+    caching_strategy_ (0)
 {
 }
 
@@ -72,8 +58,12 @@ TAO_IIOP_Connector::open (TAO_ORB_Core *orb_core)
                   TAO_Cached_Connector_Lock (this->orb_core_),
                   -1);
 
-  TAO_CACHED_CONNECT_STRATEGY *cached_connect_strategy =
-    new TAO_CACHED_CONNECT_STRATEGY (
+  int result = this->make_caching_strategy ();
+  if (result == -1)
+    return -1;
+
+  this->cached_connect_strategy_ =
+    new CACHED_CONNECT_STRATEGY (*this->caching_strategy_,
         new TAO_IIOP_Connect_Creation_Strategy (this->orb_core_->thr_mgr (),
                                                 this->orb_core_),
         0,
@@ -83,20 +73,22 @@ TAO_IIOP_Connector::open (TAO_ORB_Core *orb_core)
 
   return this->base_connector_.open (this->orb_core_->reactor (),
                                      &this->null_creation_strategy_,
-                                     cached_connect_strategy,
+                                     this->cached_connect_strategy_,
                                      &this->null_activation_strategy_);
 }
 
 int
 TAO_IIOP_Connector::close (void)
 {
-  TAO_CACHED_CONNECT_STRATEGY *cached_connect_strategy =
-    ACE_dynamic_cast (TAO_CACHED_CONNECT_STRATEGY *,
-                      this->base_connector_.connect_strategy ());
+  //
+  // @@ Can we delete the strategies that the connector uses before we
+  // close the connector itself??
+  //
 
   // Zap the creation strategy that we created earlier
-  delete cached_connect_strategy->creation_strategy ();
-  delete cached_connect_strategy;
+  delete this->cached_connect_strategy_->creation_strategy ();
+  delete this->cached_connect_strategy_;
+  delete this->caching_strategy_;
 
   this->base_connector_.close ();
   return 0;
@@ -131,7 +123,6 @@ TAO_IIOP_Connector::connect (TAO_Profile *profile,
   // object; but we obtain the transport in the <result>
   // variable. Other threads may modify the hint, but we are not
   // affected.
-  errno = 0;
   if (this->base_connector_.connect (iiop_profile->hint (),
                                      result,
                                      oa,
@@ -375,13 +366,104 @@ TAO_IIOP_Connector::object_key_delimiter (void) const
   return TAO_IIOP_Profile::object_key_delimiter;
 }
 
+int
+TAO_IIOP_Connector::purge_connections (void)
+{
+  return this->cached_connect_strategy_->purge_connections ();
+}
+
+#define TAO_HANDLER TAO_IIOP_Client_Connection_Handler
+#define TAO_SVC_TUPLE ACE_Svc_Tuple<TAO_HANDLER>
+#define TAO_ADDR TAO_IIOP_Connector::ADDR
+#define TAO_HASH_KEY TAO_IIOP_Connector::HASH_KEY
+#define TAO_COMPARE_KEYS TAO_IIOP_Connector::COMPARE_KEYS
+#define TAO_ATTRIBUTES TAO_IIOP_Connector::ATTRIBUTES
+#define TAO_CACHED_HANDLER TAO_IIOP_Connector::CACHED_HANDLER
+#define TAO_HASH_MAP TAO_IIOP_Connector::HASH_MAP
+#define TAO_HASH_MAP_ITERATOR TAO_IIOP_Connector::HASH_MAP_ITERATOR
+#define TAO_HASH_MAP_REVERSE_ITERATOR TAO_IIOP_Connector::HASH_MAP_REVERSE_ITERATOR
+#define TAO_CACHING_UTILITY TAO_IIOP_Connector::CACHING_UTILITY
+#define TAO_CACHING_STRATEGY TAO_IIOP_Connector::CACHING_STRATEGY
+#define TAO_CACHED_CONNECT_STRATEGY TAO_IIOP_Connector::CACHED_CONNECT_STRATEGY
+
+typedef ACE_LRU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+        TAO_IIOP_LRU_CACHING_STRATEGY;
+
+#if defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES)
+typedef TAO_IIOP_LRU_CACHING_STRATEGY
+        TAO_IIOP_CACHING_STRATEGY;
+#else
+typedef ACE_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+        TAO_IIOP_CACHING_STRATEGY;
+typedef ACE_LFU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+        TAO_IIOP_LFU_CACHING_STRATEGY;
+typedef ACE_FIFO_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+        TAO_IIOP_FIFO_CACHING_STRATEGY;
+typedef ACE_Null_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+        TAO_IIOP_NULL_CACHING_STRATEGY;
+typedef ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_LRU_CACHING_STRATEGY>
+        TAO_IIOP_LRU_CACHING_STRATEGY_ADAPTER;
+typedef ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_LFU_CACHING_STRATEGY>
+        TAO_IIOP_LFU_CACHING_STRATEGY_ADAPTER;
+typedef ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_FIFO_CACHING_STRATEGY>
+        TAO_IIOP_FIFO_CACHING_STRATEGY_ADAPTER;
+typedef ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_NULL_CACHING_STRATEGY>
+        TAO_IIOP_NULL_CACHING_STRATEGY_ADAPTER;
+#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
+
+int
+TAO_IIOP_Connector::make_caching_strategy (void)
+{
 
+  TAO_Resource_Factory *resource_factory =
+    this->orb_core_->resource_factory ();
+
+#if defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES)
+
+  ACE_NEW_RETURN (this->caching_strategy_,
+                  TAO_IIOP_CACHING_STRATEGY,
+                  -1);
+
+#else
+
+  switch (resource_factory->connection_caching_strategy_type ())
+    {
+    case TAO_Resource_Factory::NOOP:
+      ACE_NEW_RETURN (this->caching_strategy_,
+                      TAO_IIOP_NULL_CACHING_STRATEGY_ADAPTER,
+                      -1);
+      break;
+
+    default:
+    case TAO_Resource_Factory::LRU:
+      ACE_NEW_RETURN (this->caching_strategy_,
+                      TAO_IIOP_LRU_CACHING_STRATEGY_ADAPTER,
+                      -1);
+      break;
+
+    case TAO_Resource_Factory::LFU:
+      ACE_NEW_RETURN (this->caching_strategy_,
+                      TAO_IIOP_LFU_CACHING_STRATEGY_ADAPTER,
+                      -1);
+      break;
+
+    case TAO_Resource_Factory::FIFO:
+      ACE_NEW_RETURN (this->caching_strategy_,
+                      TAO_IIOP_FIFO_CACHING_STRATEGY_ADAPTER,
+                      -1);
+      break;
+    }
+
+#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
+
+  this->caching_strategy_->purge_percent (resource_factory->purge_percentage ());
+  return 0;
+}
+
+//
 // The TAO_Cached_Connector_Lock template instantiations are in
 // Resource_Factory.cpp.
-
-#define TAO_SVC_TUPLE ACE_Svc_Tuple<TAO_IIOP_Client_Connection_Handler>
-#define CACHED_CONNECT_STRATEGY ACE_Cached_Connect_Strategy<TAO_IIOP_Client_Connection_Handler, ACE_SOCK_CONNECTOR, TAO_Cached_Connector_Lock>
-#define REFCOUNTED_HASH_RECYCLABLE_ADDR ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr>
+//
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 
@@ -389,50 +471,81 @@ template class ACE_Node<ACE_INET_Addr>;
 template class ACE_Unbounded_Stack<ACE_INET_Addr>;
 template class ACE_Unbounded_Stack_Iterator<ACE_INET_Addr>;
 
-template class ACE_Creation_Strategy<TAO_IIOP_Client_Connection_Handler>;
-template class ACE_Connect_Strategy<TAO_IIOP_Client_Connection_Handler, ACE_SOCK_CONNECTOR>;
-template class ACE_Strategy_Connector<TAO_IIOP_Client_Connection_Handler, ACE_SOCK_CONNECTOR>;
-template class ACE_NOOP_Creation_Strategy<TAO_IIOP_Client_Connection_Handler>;
-template class ACE_Concurrency_Strategy<TAO_IIOP_Client_Connection_Handler>;
-template class ACE_NOOP_Concurrency_Strategy<TAO_IIOP_Client_Connection_Handler>;
-template class ACE_Recycling_Strategy<TAO_IIOP_Client_Connection_Handler>;
-template class ACE_Connector<TAO_IIOP_Client_Connection_Handler, ACE_SOCK_CONNECTOR>;
-
-template class ACE_Node<TAO_IIOP_Client_Connection_Handler *>;
-
 template class ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>;
-template class CACHED_CONNECT_STRATEGY;
-template class REFCOUNTED_HASH_RECYCLABLE_ADDR;
-template class ACE_Map_Manager<int, TAO_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>;
-template class ACE_Map_Iterator_Base<int, TAO_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>;
-template class ACE_Map_Iterator<int, TAO_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>;
-template class ACE_Map_Reverse_Iterator<int, TAO_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr>;
+template class ACE_NOOP_Creation_Strategy<TAO_HANDLER>;
+template class ACE_Concurrency_Strategy<TAO_HANDLER>;
+template class ACE_Connect_Strategy<TAO_HANDLER, ACE_SOCK_CONNECTOR>;
+template class ACE_Connector<TAO_HANDLER, ACE_SOCK_CONNECTOR>;
+template class ACE_Creation_Strategy<TAO_HANDLER>;
+template class ACE_Hash_Map_Entry<TAO_ADDR, TAO_HANDLER *>;
+template class ACE_Hash<ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr> >;
+template class ACE_Equal_To<ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr> >;
+template class ACE_Map_Entry<ACE_HANDLE, TAO_SVC_TUPLE *>;
+template class ACE_Map_Manager<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Map_Iterator_Base<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Map_Iterator<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Map_Reverse_Iterator<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_NOOP_Concurrency_Strategy<TAO_HANDLER>;
+template class ACE_Recycling_Strategy<TAO_HANDLER>;
+template class ACE_Strategy_Connector<TAO_HANDLER, ACE_SOCK_CONNECTOR>;
 template class TAO_SVC_TUPLE;
-template class ACE_Map_Entry<int, TAO_SVC_TUPLE*>;
-
-template class ACE_Hash_Map_Entry<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *>;
-template class ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>;
-template class ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>;
-
-#if defined(ACE_HAS_THREADS)
-template class ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_SYNCH_MUTEX>;
-template class ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>;
-template class ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>;
-template class ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_SYNCH_MUTEX>;
-template class ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>;
-template class ACE_Hash_Map_Bucket_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>;
-template class ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_SYNCH_MUTEX>;
-template class ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>;
-#endif /* ACE_HAS_THREADS */
-
-template class ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_SYNCH_NULL_MUTEX>;
-template class ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>;
-template class ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>;
-template class ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_SYNCH_NULL_MUTEX>;
-template class ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>;
-template class ACE_Hash_Map_Bucket_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>;
-template class ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_SYNCH_NULL_MUTEX>;
-template class ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>;
+
+template class ACE_Pair<TAO_HANDLER *, TAO_ATTRIBUTES>;
+template class ACE_Reference_Pair<TAO_ADDR, TAO_HANDLER *>;
+template class ACE_Hash_Map_Entry<TAO_ADDR, TAO_CACHED_HANDLER>;
+
+template class ACE_Hash_Map_Manager<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Reverse_Iterator<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Manager_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Reverse_Iterator_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator_Base_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+
+template class ACE_Hash_Map_Manager<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Reverse_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Manager_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Reverse_Iterator_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator_Base_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Bucket_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Bucket_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+
+// = Caching_Strategy
+template class ACE_Hash_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>;
+
+template class ACE_LRU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>;
+
+#if !defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES)
+
+template class ACE_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>;
+template class ACE_LFU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>;
+template class ACE_FIFO_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>;
+template class ACE_Null_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>;
+
+template class ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_LRU_CACHING_STRATEGY>;
+template class ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_LFU_CACHING_STRATEGY>;
+template class ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_FIFO_CACHING_STRATEGY>;
+template class ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_NULL_CACHING_STRATEGY>;
+
+template class ACE_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP, TAO_HASH_MAP_ITERATOR, TAO_HASH_MAP_REVERSE_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>;
+template class ACE_Cache_Map_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>;
+template class ACE_Cache_Map_Reverse_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP_REVERSE_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>;
+
+#else
+
+template class ACE_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>;
+
+#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
+
+template class ACE_Cached_Connect_Strategy_Ex<TAO_HANDLER, ACE_SOCK_CONNECTOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES, TAO_Cached_Connector_Lock>;
+template class ACE_Cached_Connect_Strategy<TAO_HANDLER, ACE_SOCK_CONNECTOR, TAO_Cached_Connector_Lock>;
+
+template class ACE_Cleanup_Strategy<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP>;
+template class ACE_Recyclable_Handler_Cleanup_Strategy<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP>;
+template class ACE_Recyclable_Handler_Caching_Utility<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP, TAO_HASH_MAP_ITERATOR, TAO_ATTRIBUTES>;
 
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
 
@@ -440,50 +553,80 @@ template class ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR,
 #pragma instantiate ACE_Unbounded_Stack<ACE_INET_Addr>
 #pragma instantiate ACE_Unbounded_Stack_Iterator<ACE_INET_Addr>
 
-#pragma instantiate ACE_Creation_Strategy<TAO_IIOP_Client_Connection_Handler>
-#pragma instantiate ACE_Connect_Strategy<TAO_IIOP_Client_Connection_Handler, ACE_SOCK_CONNECTOR>
-#pragma instantiate ACE_Strategy_Connector<TAO_IIOP_Client_Connection_Handler, ACE_SOCK_CONNECTOR>
-#pragma instantiate ACE_NOOP_Creation_Strategy<TAO_IIOP_Client_Connection_Handler>
-#pragma instantiate ACE_Concurrency_Strategy<TAO_IIOP_Client_Connection_Handler>
-#pragma instantiate ACE_NOOP_Concurrency_Strategy<TAO_IIOP_Client_Connection_Handler>
-#pragma instantiate ACE_Recycling_Strategy<TAO_IIOP_Client_Connection_Handler>
-#pragma instantiate ACE_Connector<TAO_IIOP_Client_Connection_Handler, ACE_SOCK_CONNECTOR>
-
-#pragma instantiate ACE_Node<TAO_IIOP_Client_Connection_Handler *>
-
 #pragma instantiate ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>
-#pragma instantiate CACHED_CONNECT_STRATEGY
-#pragma instantiate REFCOUNTED_HASH_RECYCLABLE_ADDR
-#pragma instantiate ACE_Map_Manager<int, TAO_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>
-#pragma instantiate ACE_Map_Iterator_Base<int, TAO_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>
-#pragma instantiate ACE_Map_Iterator<int, TAO_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>
-#pragma instantiate ACE_Map_Reverse_Iterator<int, TAO_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr>
+#pragma instantiate ACE_NOOP_Creation_Strategy<TAO_HANDLER>
+#pragma instantiate ACE_Concurrency_Strategy<TAO_HANDLER>
+#pragma instantiate ACE_Connect_Strategy<TAO_HANDLER, ACE_SOCK_CONNECTOR>
+#pragma instantiate ACE_Connector<TAO_HANDLER, ACE_SOCK_CONNECTOR>
+#pragma instantiate ACE_Creation_Strategy<TAO_HANDLER>
+#pragma instantiate ACE_Hash_Map_Entry<TAO_ADDR, TAO_HANDLER *>
+#pragma instantiate ACE_Hash<ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr> >
+#pragma instantiate ACE_Equal_To<ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr> >
+#pragma instantiate ACE_Map_Entry<ACE_HANDLE, TAO_SVC_TUPLE *>
+#pragma instantiate ACE_Map_Manager<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Map_Iterator_Base<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Map_Iterator<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Map_Reverse_Iterator<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_NOOP_Concurrency_Strategy<TAO_HANDLER>
+#pragma instantiate ACE_Recycling_Strategy<TAO_HANDLER>
+#pragma instantiate ACE_Strategy_Connector<TAO_HANDLER, ACE_SOCK_CONNECTOR>
 #pragma instantiate TAO_SVC_TUPLE
-#pragma instantiate ACE_Map_Entry<int, TAO_SVC_TUPLE*>
-
-
-#pragma instantiate ACE_Hash_Map_Entry<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *>
-#pragma instantiate ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>
-#pragma instantiate ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>
-
-#if defined(ACE_HAS_THREADS)
-#pragma instantiate ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_SYNCH_MUTEX>
-#pragma instantiate ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>
-#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>
-#pragma instantiate ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_SYNCH_MUTEX>
-#pragma instantiate ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>
-#pragma instantiate ACE_Hash_Map_Bucket_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_SYNCH_MUTEX>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>
-#endif /* ACE_HAS_THREADS */
-
-#pragma instantiate ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_SYNCH_NULL_MUTEX>
-#pragma instantiate ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>
-#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>
-#pragma instantiate ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_SYNCH_NULL_MUTEX>
-#pragma instantiate ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>
-#pragma instantiate ACE_Hash_Map_Bucket_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_SYNCH_NULL_MUTEX>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_IIOP_Client_Connection_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>
+
+#pragma instantiate ACE_Pair<TAO_HANDLER *, TAO_ATTRIBUTES>
+#pragma instantiate ACE_Reference_Pair<TAO_ADDR, TAO_HANDLER *>
+#pragma instantiate ACE_Hash_Map_Entry<TAO_ADDR, TAO_CACHED_HANDLER>
+
+#pragma instantiate ACE_Hash_Map_Manager<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Manager_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+
+#pragma instantiate ACE_Hash_Map_Manager<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Manager_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Bucket_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Bucket_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+
+// = Caching_Strategy
+#pragma instantiate ACE_Hash_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>
+
+#pragma instantiate ACE_LRU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+
+#if !defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES)
+
+#pragma instantiate ACE_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+#pragma instantiate ACE_LFU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+#pragma instantiate ACE_FIFO_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+#pragma instantiate ACE_Null_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+
+#pragma instantiate ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_LRU_CACHING_STRATEGY>
+#pragma instantiate ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_LFU_CACHING_STRATEGY>
+#pragma instantiate ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_FIFO_CACHING_STRATEGY>
+#pragma instantiate ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_IIOP_NULL_CACHING_STRATEGY>
+
+#pragma instantiate ACE_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP, TAO_HASH_MAP_ITERATOR, TAO_HASH_MAP_REVERSE_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>
+#pragma instantiate ACE_Cache_Map_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>
+#pragma instantiate ACE_Cache_Map_Reverse_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP_REVERSE_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>
+
+#else
+
+#pragma instantiate ACE_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>
+
+#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
+
+#pragma instantiate ACE_Cached_Connect_Strategy_Ex<TAO_HANDLER, ACE_SOCK_CONNECTOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES, TAO_Cached_Connector_Lock>
+#pragma instantiate ACE_Cached_Connect_Strategy<TAO_HANDLER, ACE_SOCK_CONNECTOR, TAO_Cached_Connector_Lock>
+
+#pragma instantiate ACE_Cleanup_Strategy<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP>
+#pragma instantiate ACE_Recyclable_Handler_Cleanup_Strategy<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP>
+#pragma instantiate ACE_Recyclable_Handler_Caching_Utility<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP, TAO_HASH_MAP_ITERATOR, TAO_ATTRIBUTES>
 
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/TAO/tao/IIOP_Connector.h b/TAO/tao/IIOP_Connector.h
index 6676995a58c..c3c168778b8 100644
--- a/TAO/tao/IIOP_Connector.h
+++ b/TAO/tao/IIOP_Connector.h
@@ -29,8 +29,17 @@
 #include "ace/SOCK_Connector.h"
 #include "tao/Pluggable.h"
 #include "tao/IIOP_Connect.h"
+#include "tao/Resource_Factory.h"
 
-typedef ACE_Strategy_Connector<TAO_IIOP_Client_Connection_Handler, ACE_SOCK_CONNECTOR> TAO_IIOP_BASE_CONNECTOR;
+#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ < 8
+#define ACE_HAS_BROKEN_EXTENDED_TEMPLATES
+#endif /* __GNUC__ */
+
+#include "ace/Cached_Connect_Strategy_T.h"
+
+typedef ACE_Strategy_Connector<TAO_IIOP_Client_Connection_Handler,
+                               ACE_SOCK_CONNECTOR>
+        TAO_IIOP_BASE_CONNECTOR;
 
 // ****************************************************************
 
@@ -87,6 +96,9 @@ public:
 
   virtual char object_key_delimiter (void) const;
 
+  virtual int purge_connections (void);
+  // Purge "old" connections.
+
 protected:
   // = More TAO_Connector methods, please check the documentation on
   //   Pluggable.h
@@ -94,7 +106,66 @@ protected:
                              TAO_Profile *&,
                              CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ());
 
-protected:
+  virtual int make_caching_strategy (void);
+  // According to the option specified, create the appropriate caching
+  // strategy used for purging unused connections from the connection
+  // cache.
+
+public:
+
+  // = Connection Caching Strategy.
+  typedef size_t ATTRIBUTES;
+  typedef ACE_Pair<TAO_IIOP_Client_Connection_Handler *,
+                   ATTRIBUTES>
+          CACHED_HANDLER;
+  typedef ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr>
+          ADDR;
+  typedef ACE_Hash<ADDR> HASH_KEY;
+  typedef ACE_Equal_To<ADDR> COMPARE_KEYS;
+
+  typedef ACE_Hash_Map_Manager_Ex<ADDR,
+                                  CACHED_HANDLER,
+                                  HASH_KEY,
+                                  COMPARE_KEYS,
+                                  ACE_Null_Mutex>
+          HASH_MAP;
+  typedef ACE_Hash_Map_Iterator_Ex<ADDR,
+                                   CACHED_HANDLER,
+                                   HASH_KEY,
+                                   COMPARE_KEYS,
+                                   ACE_Null_Mutex>
+          HASH_MAP_ITERATOR;
+  typedef ACE_Hash_Map_Reverse_Iterator_Ex<ADDR,
+                                           CACHED_HANDLER,
+                                           HASH_KEY,
+                                           COMPARE_KEYS,
+                                           ACE_Null_Mutex>
+          HASH_MAP_REVERSE_ITERATOR;
+
+  typedef ACE_Recyclable_Handler_Caching_Utility<ADDR,
+                                                 CACHED_HANDLER,
+                                                 HASH_MAP,
+                                                 HASH_MAP_ITERATOR,
+                                                 ATTRIBUTES>
+          CACHING_UTILITY;
+
+#if defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES)
+  typedef ACE_LRU_Caching_Strategy<ATTRIBUTES,
+                                   CACHING_UTILITY>
+          CACHING_STRATEGY;
+#else
+  typedef ACE_Caching_Strategy<ATTRIBUTES,
+                               CACHING_UTILITY>
+          CACHING_STRATEGY;
+#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
+
+  typedef ACE_Cached_Connect_Strategy_Ex<TAO_IIOP_Client_Connection_Handler,
+                                         ACE_SOCK_CONNECTOR,
+                                         CACHING_STRATEGY,
+                                         ATTRIBUTES,
+                                         TAO_Cached_Connector_Lock>
+          CACHED_CONNECT_STRATEGY;
+
   typedef ACE_NOOP_Concurrency_Strategy<TAO_IIOP_Client_Connection_Handler>
         TAO_NULL_ACTIVATION_STRATEGY;
 
@@ -105,11 +176,18 @@ private:
   TAO_NULL_ACTIVATION_STRATEGY null_activation_strategy_;
   TAO_NULL_CREATION_STRATEGY null_creation_strategy_;
 
-  TAO_IIOP_BASE_CONNECTOR  base_connector_;
+  TAO_IIOP_BASE_CONNECTOR base_connector_;
   // The connector initiating connection requests for IIOP.
 
   TAO_ORB_Core *orb_core_;
   // ORB Core.
+
+  CACHED_CONNECT_STRATEGY *cached_connect_strategy_;
+  // Cached connect strategy.
+
+  CACHING_STRATEGY *caching_strategy_;
+  // Caching strategy which decides the order of removal of entries
+  // from the connection cache.
 };
 
 #endif  /* TAO_IIOP_CONNECTOR_H */
diff --git a/TAO/tao/Pluggable.h b/TAO/tao/Pluggable.h
index 7657e6360ae..ff9798da3fc 100644
--- a/TAO/tao/Pluggable.h
+++ b/TAO/tao/Pluggable.h
@@ -456,6 +456,9 @@ public:
   virtual char object_key_delimiter (void) const = 0;
   // Return the object key delimiter to use or expect.
 
+  virtual int purge_connections (void) = 0;
+  // Purge "old" connections.
+
 protected:
   virtual void make_profile (const char *endpoint,
                              TAO_Profile *&,
diff --git a/TAO/tao/Resource_Factory.cpp b/TAO/tao/Resource_Factory.cpp
index fce27f2d04d..976596fa629 100644
--- a/TAO/tao/Resource_Factory.cpp
+++ b/TAO/tao/Resource_Factory.cpp
@@ -121,6 +121,18 @@ TAO_Resource_Factory::init_protocol_factories (void)
   return -1;
 }
 
+TAO_Resource_Factory::Caching_Strategy
+TAO_Resource_Factory::connection_caching_strategy_type (void) const
+{
+  return TAO_Resource_Factory::NOOP;
+}
+
+double
+TAO_Resource_Factory::purge_percentage (void) const
+{
+  return 0;
+}
+
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 
 template class ACE_Dynamic_Service<TAO_Resource_Factory>;
diff --git a/TAO/tao/Resource_Factory.h b/TAO/tao/Resource_Factory.h
index 6280b6efad9..c2133008e9a 100644
--- a/TAO/tao/Resource_Factory.h
+++ b/TAO/tao/Resource_Factory.h
@@ -93,6 +93,22 @@ class TAO_Export TAO_Resource_Factory : public ACE_Service_Object
   //   resources.
   //
 public:
+
+  enum Caching_Strategy
+  {
+    // Least Recently Used
+    LRU,
+
+    // Least Frequently Used
+    LFU,
+
+    // First In First Out
+    FIFO,
+
+    // Dont use any strategy.
+    NOOP
+  };
+
   // = Initialization and termination methods.
   TAO_Resource_Factory (void);
   virtual ~TAO_Resource_Factory (void);
@@ -137,6 +153,14 @@ public:
   // from the service configurator.  It is assumed
   // that only one thread will call this method at ORB initialization.
   // NON-THREAD-SAFE
+
+  virtual Caching_Strategy connection_caching_strategy_type (void) const;
+  // This accesses the connection caching strategy we use for managing
+  // purging of unused entries from the connection cache on demnad.
+
+  virtual double purge_percentage (void) const;
+  // This denotes the amount of entries to remove from the connection
+  // cache.
 };
 
 #endif /* TAO_RESOURCE_FACTORY_H */
diff --git a/TAO/tao/UIOP_Connector.cpp b/TAO/tao/UIOP_Connector.cpp
index 2c5caecbc89..e330db166de 100644
--- a/TAO/tao/UIOP_Connector.cpp
+++ b/TAO/tao/UIOP_Connector.cpp
@@ -1,21 +1,6 @@
 // This may look like C, but it's really -*- C++ -*-
 // $Id$
 
-// ============================================================================
-//
-// = LIBRARY
-//     TAO
-//
-// = FILENAME
-//     UIOP_Connector.cpp
-//
-// = DESCRIPTION
-//
-// = AUTHOR
-//     Fred Kuhns <fredk@cs.wustl.edu>
-//     Ossama Othman <othman@cs.wustl.edu>
-// ============================================================================
-
 #include "tao/UIOP_Connector.h"
 
 #if !defined (ACE_LACKS_UNIX_DOMAIN_SOCKETS)
@@ -50,20 +35,18 @@ TAO_UIOP_Connect_Creation_Strategy::make_svc_handler (
                           this->orb_core_),
                       -1);
     }
+
   return 0;
 }
 
 // ****************************************************************
 
-typedef ACE_Cached_Connect_Strategy<TAO_UIOP_Client_Connection_Handler,
-                                    ACE_LSOCK_CONNECTOR,
-                                    TAO_Cached_Connector_Lock>
-        TAO_CACHED_CONNECT_STRATEGY;
-
 TAO_UIOP_Connector::TAO_UIOP_Connector (void)
   : TAO_Connector (TAO_IOP_TAG_UNIX_IOP),
     base_connector_ (),
-    orb_core_ (0)
+    orb_core_ (0),
+    cached_connect_strategy_ (0),
+    caching_strategy_ (0)
 {
 }
 
@@ -77,32 +60,37 @@ TAO_UIOP_Connector::open (TAO_ORB_Core *orb_core)
                   TAO_Cached_Connector_Lock (orb_core),
                   -1);
 
-  TAO_CACHED_CONNECT_STRATEGY* cached_connect_strategy =
-    new TAO_CACHED_CONNECT_STRATEGY (
-        new TAO_UIOP_Connect_Creation_Strategy (
-            orb_core->thr_mgr (),
-            orb_core),
+  int result = this->make_caching_strategy ();
+  if (result == -1)
+    return -1;
+
+  this->cached_connect_strategy_ =
+    new CACHED_CONNECT_STRATEGY (*this->caching_strategy_,
+        new TAO_UIOP_Connect_Creation_Strategy (this->orb_core_->thr_mgr (),
+                                                this->orb_core_),
         0,
         0,
         connector_lock,
         1);
 
-  return this->base_connector_.open (orb_core->reactor (),
+  return this->base_connector_.open (this->orb_core_->reactor (),
                                      &this->null_creation_strategy_,
-                                     cached_connect_strategy,
+                                     this->cached_connect_strategy_,
                                      &this->null_activation_strategy_);
 }
 
 int
 TAO_UIOP_Connector::close (void)
 {
-  TAO_CACHED_CONNECT_STRATEGY *cached_connect_strategy =
-    ACE_dynamic_cast (TAO_CACHED_CONNECT_STRATEGY *,
-                      this->base_connector_.connect_strategy ());
+  //
+  // @@ Can we delete the strategies that the connector uses before we
+  // close the connector itself??
+  //
 
   // Zap the creation strategy that we created earlier
-  delete cached_connect_strategy->creation_strategy ();
-  delete cached_connect_strategy;
+  delete this->cached_connect_strategy_->creation_strategy ();
+  delete this->cached_connect_strategy_;
+  delete this->caching_strategy_;
 
   this->base_connector_.close ();
   return 0;
@@ -153,6 +141,7 @@ TAO_UIOP_Connector::connect (TAO_Profile *profile,
                       buffer,
                       "errno"));
         }
+
       return -1;
     }
 
@@ -174,7 +163,6 @@ TAO_UIOP_Connector::preconnect (const char *preconnects)
   char *preconnections = ACE_OS::strdup (protocol_removed);
 
   int successes = 0;
-
   if (preconnections)
     {
       ACE_UNIX_Addr dest;
@@ -352,119 +340,269 @@ TAO_UIOP_Connector::object_key_delimiter (void) const
   return TAO_UIOP_Profile::object_key_delimiter;
 }
 
+int
+TAO_UIOP_Connector::purge_connections (void)
+{
+  return this->cached_connect_strategy_->purge_connections ();
+}
 
-// The TAO_Cached_Connector_Lock template instantiations are in
-// Resource_Factory.cpp.
-
-#define TAO_UIOP_SVC_TUPLE ACE_Svc_Tuple<TAO_UIOP_Client_Connection_Handler>
-#define UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR ACE_Refcounted_Hash_Recyclable<ACE_UNIX_Addr>
+#define TAO_HANDLER TAO_UIOP_Client_Connection_Handler
+#define TAO_SVC_TUPLE ACE_Svc_Tuple<TAO_HANDLER>
+#define TAO_ADDR TAO_UIOP_Connector::ADDR
+#define TAO_HASH_KEY TAO_UIOP_Connector::HASH_KEY
+#define TAO_COMPARE_KEYS TAO_UIOP_Connector::COMPARE_KEYS
+#define TAO_ATTRIBUTES TAO_UIOP_Connector::ATTRIBUTES
+#define TAO_CACHED_HANDLER TAO_UIOP_Connector::CACHED_HANDLER
+#define TAO_HASH_MAP TAO_UIOP_Connector::HASH_MAP
+#define TAO_HASH_MAP_ITERATOR TAO_UIOP_Connector::HASH_MAP_ITERATOR
+#define TAO_HASH_MAP_REVERSE_ITERATOR TAO_UIOP_Connector::HASH_MAP_REVERSE_ITERATOR
+#define TAO_CACHING_UTILITY TAO_UIOP_Connector::CACHING_UTILITY
+#define TAO_CACHING_STRATEGY TAO_UIOP_Connector::CACHING_STRATEGY
+#define TAO_CACHED_CONNECT_STRATEGY TAO_UIOP_Connector::CACHED_CONNECT_STRATEGY
+
+typedef ACE_LRU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+        TAO_UIOP_LRU_CACHING_STRATEGY;
+
+#if defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES)
+typedef TAO_UIOP_LRU_CACHING_STRATEGY
+        TAO_UIOP_CACHING_STRATEGY;
+#else
+typedef ACE_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+        TAO_UIOP_CACHING_STRATEGY;
+typedef ACE_LFU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+        TAO_UIOP_LFU_CACHING_STRATEGY;
+typedef ACE_FIFO_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+        TAO_UIOP_FIFO_CACHING_STRATEGY;
+typedef ACE_Null_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+        TAO_UIOP_NULL_CACHING_STRATEGY;
+typedef ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_UIOP_LRU_CACHING_STRATEGY>
+        TAO_UIOP_LRU_CACHING_STRATEGY_ADAPTER;
+typedef ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_UIOP_LFU_CACHING_STRATEGY>
+        TAO_UIOP_LFU_CACHING_STRATEGY_ADAPTER;
+typedef ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_UIOP_FIFO_CACHING_STRATEGY>
+        TAO_UIOP_FIFO_CACHING_STRATEGY_ADAPTER;
+typedef ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_UIOP_NULL_CACHING_STRATEGY>
+        TAO_UIOP_NULL_CACHING_STRATEGY_ADAPTER;
+#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
 
-# if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+int
+TAO_UIOP_Connector::make_caching_strategy (void)
+{
 
-template class ACE_Node<ACE_UNIX_Addr>;
-template class ACE_Unbounded_Stack<ACE_UNIX_Addr>;
-template class ACE_Unbounded_Stack_Iterator<ACE_UNIX_Addr>;
+  TAO_Resource_Factory *resource_factory =
+    this->orb_core_->resource_factory ();
 
-template class ACE_Connector<TAO_UIOP_Client_Connection_Handler, ACE_LSOCK_CONNECTOR>;
-template class ACE_Connect_Strategy<TAO_UIOP_Client_Connection_Handler, ACE_LSOCK_CONNECTOR>;
-template class ACE_Cached_Connect_Strategy<TAO_UIOP_Client_Connection_Handler, ACE_LSOCK_CONNECTOR, TAO_Cached_Connector_Lock>;
-template class ACE_Strategy_Connector<TAO_UIOP_Client_Connection_Handler, ACE_LSOCK_CONNECTOR>;
+#if defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES)
 
-template class ACE_Concurrency_Strategy<TAO_UIOP_Client_Connection_Handler>;
-template class ACE_Creation_Strategy<TAO_UIOP_Client_Connection_Handler>;
+  ACE_NEW_RETURN (this->caching_strategy_,
+                  TAO_UIOP_CACHING_STRATEGY,
+                  -1);
 
-template class ACE_NOOP_Creation_Strategy<TAO_UIOP_Client_Connection_Handler>;
-template class ACE_NOOP_Concurrency_Strategy<TAO_UIOP_Client_Connection_Handler>;
-template class ACE_Recycling_Strategy<TAO_UIOP_Client_Connection_Handler>;
+#else
 
-template class ACE_Svc_Handler<ACE_LSOCK_STREAM, ACE_NULL_SYNCH>;
-template class UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR;
-template class TAO_UIOP_SVC_TUPLE;
-template class ACE_Map_Manager<int, TAO_UIOP_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>;
-template class ACE_Map_Iterator_Base<int, TAO_UIOP_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>;
-template class ACE_Map_Iterator<int, TAO_UIOP_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>;
-template class ACE_Map_Reverse_Iterator<int, TAO_UIOP_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>;
-template class ACE_Map_Entry<int, TAO_UIOP_SVC_TUPLE*>;
-
-template class ACE_Hash_Map_Entry<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *>;
-template class ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>;
-template class ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>;
-
-#if defined(ACE_HAS_THREADS)
-template class ACE_Hash_Map_Manager<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_SYNCH_MUTEX>;
-template class ACE_Hash_Map_Manager_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>;
-template class ACE_Hash_Map_Iterator_Base_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>;
-template class ACE_Hash_Map_Iterator<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_SYNCH_MUTEX>;
-template class ACE_Hash_Map_Iterator_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>;
-template class ACE_Hash_Map_Bucket_Iterator<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>;
-template class ACE_Hash_Map_Reverse_Iterator<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_SYNCH_MUTEX>;
-template class ACE_Hash_Map_Reverse_Iterator_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>;
-#endif /* ACE_HAS_THREADS */
-
-template class ACE_Hash_Map_Manager<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_SYNCH_NULL_MUTEX>;
-template class ACE_Hash_Map_Manager_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>;
-template class ACE_Hash_Map_Iterator_Base_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>;
-template class ACE_Hash_Map_Iterator<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_SYNCH_NULL_MUTEX>;
-template class ACE_Hash_Map_Iterator_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>;
-template class ACE_Hash_Map_Bucket_Iterator<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>;
-template class ACE_Hash_Map_Reverse_Iterator<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_SYNCH_NULL_MUTEX>;
-template class ACE_Hash_Map_Reverse_Iterator_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>;
-
-# elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  switch (resource_factory->connection_caching_strategy_type ())
+    {
+    case TAO_Resource_Factory::NOOP:
+      ACE_NEW_RETURN (this->caching_strategy_,
+                      TAO_UIOP_NULL_CACHING_STRATEGY_ADAPTER,
+                      -1);
+      break;
 
-#pragma instantiate ACE_Node<ACE_UNIX_Addr>
-#pragma instantiate ACE_Unbounded_Stack<ACE_UNIX_Addr>
-#pragma instantiate ACE_Unbounded_Stack_Iterator<ACE_UNIX_Addr>
+    default:
+    case TAO_Resource_Factory::LRU:
+      ACE_NEW_RETURN (this->caching_strategy_,
+                      TAO_UIOP_LRU_CACHING_STRATEGY_ADAPTER,
+                      -1);
+      break;
 
-#pragma instantiate ACE_Connector<TAO_UIOP_Client_Connection_Handler, ACE_LSOCK_CONNECTOR>
-#pragma instantiate ACE_Connect_Strategy<TAO_UIOP_Client_Connection_Handler, ACE_LSOCK_CONNECTOR>
-#pragma instantiate ACE_Cached_Connect_Strategy<TAO_UIOP_Client_Connection_Handler, ACE_LSOCK_CONNECTOR, TAO_Cached_Connector_Lock>
-#pragma instantiate ACE_Strategy_Connector<TAO_UIOP_Client_Connection_Handler, ACE_LSOCK_CONNECTOR>
+    case TAO_Resource_Factory::LFU:
+      ACE_NEW_RETURN (this->caching_strategy_,
+                      TAO_UIOP_LFU_CACHING_STRATEGY_ADAPTER,
+                      -1);
+      break;
 
-#pragma instantiate ACE_Concurrency_Strategy<TAO_UIOP_Client_Connection_Handler>
-#pragma instantiate ACE_Creation_Strategy<TAO_UIOP_Client_Connection_Handler>
+    case TAO_Resource_Factory::FIFO:
+      ACE_NEW_RETURN (this->caching_strategy_,
+                      TAO_UIOP_FIFO_CACHING_STRATEGY_ADAPTER,
+                      -1);
+      break;
+    }
 
-#pragma instantiate ACE_NOOP_Creation_Strategy<TAO_UIOP_Client_Connection_Handler>
-#pragma instantiate ACE_NOOP_Concurrency_Strategy<TAO_UIOP_Client_Connection_Handler>
-#pragma instantiate ACE_Recycling_Strategy<TAO_UIOP_Client_Connection_Handler>
+#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
 
-#pragma instantiate ACE_Svc_Handler<ACE_LSOCK_STREAM, ACE_NULL_SYNCH>
-#pragma instantiate UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR
-#pragma instantiate TAO_UIOP_SVC_TUPLE
-#pragma instantiate ACE_Map_Manager<int, TAO_UIOP_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>
-#pragma instantiate ACE_Map_Iterator_Base<int, TAO_UIOP_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>
-#pragma instantiate ACE_Map_Iterator<int, TAO_UIOP_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>
-#pragma instantiate ACE_Map_Reverse_Iterator<int, TAO_UIOP_SVC_TUPLE*, ACE_SYNCH_RW_MUTEX>
-#pragma instantiate ACE_Map_Entry<int, TAO_UIOP_SVC_TUPLE*>
-
-#pragma instantiate ACE_Hash_Map_Entry<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *>
-#pragma instantiate ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>
-#pragma instantiate ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>
+  this->caching_strategy_->purge_percent (resource_factory->purge_percentage ());
+  return 0;
+}
 
 //
-// Instantiation for the reverse lock is in the IIOP Connector.
+// The TAO_Cached_Connector_Lock template instantiations are in
+// Resource_Factory.cpp.
 //
 
-#if defined(ACE_HAS_THREADS)
-#pragma instantiate ACE_Hash_Map_Manager<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_SYNCH_MUTEX>
-#pragma instantiate ACE_Hash_Map_Manager_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>
-#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>
-#pragma instantiate ACE_Hash_Map_Iterator<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_SYNCH_MUTEX>
-#pragma instantiate ACE_Hash_Map_Iterator_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>
-#pragma instantiate ACE_Hash_Map_Bucket_Iterator<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_SYNCH_MUTEX>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_MUTEX>
-#endif /* ACE_HAS_THREADS */
-
-#pragma instantiate ACE_Hash_Map_Manager<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_SYNCH_NULL_MUTEX>
-#pragma instantiate ACE_Hash_Map_Manager_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>
-#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>
-#pragma instantiate ACE_Hash_Map_Iterator<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_SYNCH_NULL_MUTEX>
-#pragma instantiate ACE_Hash_Map_Iterator_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>
-#pragma instantiate ACE_Hash_Map_Bucket_Iterator<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_SYNCH_NULL_MUTEX>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR, TAO_UIOP_Client_Connection_Handler *, ACE_Hash<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Equal_To<UIOP_REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_SYNCH_NULL_MUTEX>
-
-# endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+
+template class ACE_Node<ACE_UNIX_Addr>;
+template class ACE_Unbounded_Stack<ACE_UNIX_Addr>;
+template class ACE_Unbounded_Stack_Iterator<ACE_UNIX_Addr>;
+
+template class ACE_Svc_Handler<ACE_LSOCK_STREAM, ACE_NULL_SYNCH>;
+template class ACE_Refcounted_Hash_Recyclable<ACE_UNIX_Addr>;
+template class ACE_NOOP_Creation_Strategy<TAO_HANDLER>;
+template class ACE_Concurrency_Strategy<TAO_HANDLER>;
+template class ACE_Connect_Strategy<TAO_HANDLER, ACE_LSOCK_CONNECTOR>;
+template class ACE_Connector<TAO_HANDLER, ACE_LSOCK_CONNECTOR>;
+template class ACE_Creation_Strategy<TAO_HANDLER>;
+template class ACE_Hash_Map_Entry<TAO_ADDR, TAO_HANDLER *>;
+template class ACE_Hash<ACE_Refcounted_Hash_Recyclable<ACE_UNIX_Addr> >;
+template class ACE_Equal_To<ACE_Refcounted_Hash_Recyclable<ACE_UNIX_Addr> >;
+template class ACE_Map_Entry<ACE_HANDLE, TAO_SVC_TUPLE *>;
+template class ACE_Map_Manager<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Map_Iterator_Base<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Map_Iterator<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Map_Reverse_Iterator<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_NOOP_Concurrency_Strategy<TAO_HANDLER>;
+template class ACE_Recycling_Strategy<TAO_HANDLER>;
+template class ACE_Strategy_Connector<TAO_HANDLER, ACE_LSOCK_CONNECTOR>;
+template class TAO_SVC_TUPLE;
+
+template class ACE_Pair<TAO_HANDLER *, TAO_ATTRIBUTES>;
+template class ACE_Reference_Pair<TAO_ADDR, TAO_HANDLER *>;
+template class ACE_Hash_Map_Entry<TAO_ADDR, TAO_CACHED_HANDLER>;
+
+template class ACE_Hash_Map_Manager<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Reverse_Iterator<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Manager_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Reverse_Iterator_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator_Base_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+
+template class ACE_Hash_Map_Manager<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Reverse_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Manager_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Reverse_Iterator_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator_Base_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Bucket_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Bucket_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>;
+
+// = Caching_Strategy
+template class ACE_Hash_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>;
+
+template class ACE_LRU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>;
+
+#if !defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES)
+
+template class ACE_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>;
+template class ACE_LFU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>;
+template class ACE_FIFO_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>;
+template class ACE_Null_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>;
+
+template class ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_UIOP_LRU_CACHING_STRATEGY>;
+template class ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_UIOP_LFU_CACHING_STRATEGY>;
+template class ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_UIOP_FIFO_CACHING_STRATEGY>;
+template class ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_UIOP_NULL_CACHING_STRATEGY>;
+
+template class ACE_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP, TAO_HASH_MAP_ITERATOR, TAO_HASH_MAP_REVERSE_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>;
+template class ACE_Cache_Map_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>;
+template class ACE_Cache_Map_Reverse_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP_REVERSE_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>;
+
+#else
+
+template class ACE_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>;
+
+#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
+
+template class ACE_Cached_Connect_Strategy_Ex<TAO_HANDLER, ACE_LSOCK_CONNECTOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES, TAO_Cached_Connector_Lock>;
+template class ACE_Cached_Connect_Strategy<TAO_HANDLER, ACE_LSOCK_CONNECTOR, TAO_Cached_Connector_Lock>;
+
+template class ACE_Cleanup_Strategy<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP>;
+template class ACE_Recyclable_Handler_Cleanup_Strategy<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP>;
+template class ACE_Recyclable_Handler_Caching_Utility<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP, TAO_HASH_MAP_ITERATOR, TAO_ATTRIBUTES>;
+
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+
+#pragma instantiate ACE_Node<ACE_UNIX_Addr>
+#pragma instantiate ACE_Unbounded_Stack<ACE_UNIX_Addr>
+#pragma instantiate ACE_Unbounded_Stack_Iterator<ACE_UNIX_Addr>
+
+#pragma instantiate ACE_Svc_Handler<ACE_LSOCK_STREAM, ACE_NULL_SYNCH>
+#pragma instantiate ACE_Refcounted_Hash_Recyclable<ACE_UNIX_Addr>
+#pragma instantiate ACE_NOOP_Creation_Strategy<TAO_HANDLER>
+#pragma instantiate ACE_Concurrency_Strategy<TAO_HANDLER>
+#pragma instantiate ACE_Connect_Strategy<TAO_HANDLER, ACE_LSOCK_CONNECTOR>
+#pragma instantiate ACE_Connector<TAO_HANDLER, ACE_LSOCK_CONNECTOR>
+#pragma instantiate ACE_Creation_Strategy<TAO_HANDLER>
+#pragma instantiate ACE_Hash_Map_Entry<TAO_ADDR, TAO_HANDLER *>
+#pragma instantiate ACE_Hash<ACE_Refcounted_Hash_Recyclable<ACE_UNIX_Addr> >
+#pragma instantiate ACE_Equal_To<ACE_Refcounted_Hash_Recyclable<ACE_UNIX_Addr> >
+#pragma instantiate ACE_Map_Entry<ACE_HANDLE, TAO_SVC_TUPLE *>
+#pragma instantiate ACE_Map_Manager<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Map_Iterator_Base<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Map_Iterator<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Map_Reverse_Iterator<ACE_HANDLE, TAO_SVC_TUPLE *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_NOOP_Concurrency_Strategy<TAO_HANDLER>
+#pragma instantiate ACE_Recycling_Strategy<TAO_HANDLER>
+#pragma instantiate ACE_Strategy_Connector<TAO_HANDLER, ACE_LSOCK_CONNECTOR>
+#pragma instantiate TAO_SVC_TUPLE
+
+#pragma instantiate ACE_Pair<TAO_HANDLER *, TAO_ATTRIBUTES>
+#pragma instantiate ACE_Reference_Pair<TAO_ADDR, TAO_HANDLER *>
+#pragma instantiate ACE_Hash_Map_Entry<TAO_ADDR, TAO_CACHED_HANDLER>
+
+#pragma instantiate ACE_Hash_Map_Manager<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator<TAO_ADDR, TAO_HANDLER *, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Manager_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+
+#pragma instantiate ACE_Hash_Map_Manager<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Manager_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Bucket_Iterator<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Bucket_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, ACE_Null_Mutex>
+
+// = Caching_Strategy
+#pragma instantiate ACE_Hash_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_KEY, TAO_COMPARE_KEYS, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>
+
+#pragma instantiate ACE_LRU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+
+#if !defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES)
+
+#pragma instantiate ACE_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+#pragma instantiate ACE_LFU_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+#pragma instantiate ACE_FIFO_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+#pragma instantiate ACE_Null_Caching_Strategy<TAO_ATTRIBUTES, TAO_CACHING_UTILITY>
+
+#pragma instantiate ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_UIOP_LRU_CACHING_STRATEGY>
+#pragma instantiate ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_UIOP_LFU_CACHING_STRATEGY>
+#pragma instantiate ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_UIOP_FIFO_CACHING_STRATEGY>
+#pragma instantiate ACE_Caching_Strategy_Adapter<TAO_ATTRIBUTES, TAO_CACHING_UTILITY, TAO_UIOP_NULL_CACHING_STRATEGY>
+
+#pragma instantiate ACE_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP, TAO_HASH_MAP_ITERATOR, TAO_HASH_MAP_REVERSE_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>
+#pragma instantiate ACE_Cache_Map_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>
+#pragma instantiate ACE_Cache_Map_Reverse_Iterator<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP_REVERSE_ITERATOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>
+
+#else
+
+#pragma instantiate ACE_Cache_Map_Manager<TAO_ADDR, TAO_HANDLER *, TAO_HASH_MAP, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES>
+
+#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
+
+#pragma instantiate ACE_Cached_Connect_Strategy_Ex<TAO_HANDLER, ACE_LSOCK_CONNECTOR, TAO_CACHING_STRATEGY, TAO_ATTRIBUTES, TAO_Cached_Connector_Lock>
+#pragma instantiate ACE_Cached_Connect_Strategy<TAO_HANDLER, ACE_LSOCK_CONNECTOR, TAO_Cached_Connector_Lock>
+
+#pragma instantiate ACE_Cleanup_Strategy<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP>
+#pragma instantiate ACE_Recyclable_Handler_Cleanup_Strategy<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP>
+#pragma instantiate ACE_Recyclable_Handler_Caching_Utility<TAO_ADDR, TAO_CACHED_HANDLER, TAO_HASH_MAP, TAO_HASH_MAP_ITERATOR, TAO_ATTRIBUTES>
+
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
 #endif /* !ACE_LACKS_UNIX_DOMAIN_SOCKETS */
diff --git a/TAO/tao/UIOP_Connector.h b/TAO/tao/UIOP_Connector.h
index 950cb74233a..5acfec5c909 100644
--- a/TAO/tao/UIOP_Connector.h
+++ b/TAO/tao/UIOP_Connector.h
@@ -30,12 +30,19 @@
 # if !defined (ACE_LACKS_UNIX_DOMAIN_SOCKETS)
 
 #include "ace/LSOCK_Connector.h"
-
 #include "tao/Pluggable.h"
 #include "tao/UIOP_Connect.h"
+#include "tao/Resource_Factory.h"
+
+#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ < 8
+#define ACE_HAS_BROKEN_EXTENDED_TEMPLATES
+#endif /* __GNUC__ */
+
+#include "ace/Cached_Connect_Strategy_T.h"
 
 typedef ACE_Strategy_Connector<TAO_UIOP_Client_Connection_Handler,
-                               ACE_LSOCK_CONNECTOR> TAO_UIOP_BASE_CONNECTOR;
+                               ACE_LSOCK_CONNECTOR>
+        TAO_UIOP_BASE_CONNECTOR;
 
 // ****************************************************************
 
@@ -91,6 +98,9 @@ public:
 
   virtual char object_key_delimiter (void) const;
 
+  virtual int purge_connections (void);
+  // Purge "old" connections.
+
 protected:
   // = More TAO_Connector methods, please check the documentation on
   //   Pluggable.h
@@ -98,7 +108,66 @@ protected:
                              TAO_Profile *&,
                              CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ());
 
-protected:
+  virtual int make_caching_strategy (void);
+  // According to the option specified, create the appropriate caching
+  // strategy used for purging unused connections from the connection
+  // cache.
+
+public:
+
+  // = Connection Caching Strategy.
+  typedef size_t ATTRIBUTES;
+  typedef ACE_Pair<TAO_UIOP_Client_Connection_Handler *,
+                   ATTRIBUTES>
+          CACHED_HANDLER;
+  typedef ACE_Refcounted_Hash_Recyclable<ACE_UNIX_Addr>
+          ADDR;
+  typedef ACE_Hash<ADDR> HASH_KEY;
+  typedef ACE_Equal_To<ADDR> COMPARE_KEYS;
+
+  typedef ACE_Hash_Map_Manager_Ex<ADDR,
+                                  CACHED_HANDLER,
+                                  HASH_KEY,
+                                  COMPARE_KEYS,
+                                  ACE_Null_Mutex>
+          HASH_MAP;
+  typedef ACE_Hash_Map_Iterator_Ex<ADDR,
+                                   CACHED_HANDLER,
+                                   HASH_KEY,
+                                   COMPARE_KEYS,
+                                   ACE_Null_Mutex>
+          HASH_MAP_ITERATOR;
+  typedef ACE_Hash_Map_Reverse_Iterator_Ex<ADDR,
+                                           CACHED_HANDLER,
+                                           HASH_KEY,
+                                           COMPARE_KEYS,
+                                           ACE_Null_Mutex>
+          HASH_MAP_REVERSE_ITERATOR;
+
+  typedef ACE_Recyclable_Handler_Caching_Utility<ADDR,
+                                                 CACHED_HANDLER,
+                                                 HASH_MAP,
+                                                 HASH_MAP_ITERATOR,
+                                                 ATTRIBUTES>
+          CACHING_UTILITY;
+
+#if defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES)
+  typedef ACE_LRU_Caching_Strategy<ATTRIBUTES,
+                                   CACHING_UTILITY>
+          CACHING_STRATEGY;
+#else
+  typedef ACE_Caching_Strategy<ATTRIBUTES,
+                               CACHING_UTILITY>
+          CACHING_STRATEGY;
+#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
+
+  typedef ACE_Cached_Connect_Strategy_Ex<TAO_UIOP_Client_Connection_Handler,
+                                         ACE_LSOCK_CONNECTOR,
+                                         CACHING_STRATEGY,
+                                         ATTRIBUTES,
+                                         TAO_Cached_Connector_Lock>
+          CACHED_CONNECT_STRATEGY;
+
   typedef ACE_NOOP_Creation_Strategy<TAO_UIOP_Client_Connection_Handler>
         TAO_NULL_CREATION_STRATEGY;
 
@@ -114,6 +183,13 @@ private:
 
   TAO_ORB_Core *orb_core_;
   // ORB Core.
+
+  CACHED_CONNECT_STRATEGY *cached_connect_strategy_;
+  // Cached connect strategy.
+
+  CACHING_STRATEGY *caching_strategy_;
+  // Caching strategy which decides the order of removal of entries
+  // from the connection cache.
 };
 
 # endif  /* !ACE_LACKS_UNIX_DOMAIN_SOCKETS */
diff --git a/TAO/tao/default_resource.cpp b/TAO/tao/default_resource.cpp
index 433ac742f64..40ec7d8d43b 100644
--- a/TAO/tao/default_resource.cpp
+++ b/TAO/tao/default_resource.cpp
@@ -179,6 +179,45 @@ TAO_Default_Resource_Factory::init (int argc, char **argv)
           }
       }
 
+    else if (ACE_OS::strcasecmp (argv[curarg],
+                                 "-ORBConnectionCachingStrategy") == 0)
+      {
+        curarg++;
+        if (curarg < argc)
+          {
+            char *name = argv[curarg];
+
+            if (ACE_OS::strcasecmp (name,
+                                    "lru") == 0)
+              this->connection_caching_type_ = TAO_Resource_Factory::LRU;
+            else if (ACE_OS::strcasecmp (name,
+                                         "lfu") == 0)
+              this->connection_caching_type_ = TAO_Resource_Factory::LFU;
+            else if (ACE_OS::strcasecmp (name,
+                                         "fifo") == 0)
+              this->connection_caching_type_ = TAO_Resource_Factory::FIFO;
+            else if (ACE_OS::strcasecmp (name,
+                                         "null") == 0)
+              this->connection_caching_type_ = TAO_Resource_Factory::NOOP;
+            else
+              ACE_DEBUG ((LM_DEBUG,
+                          "TAO_Default_Factory - unknown argument"
+                          " <%s> for -ORBConnectionCachingStrategy\n", name));
+          }
+      }
+
+   else if (ACE_OS::strcasecmp (argv[curarg],
+                                 "-ORBPurgePercentage") == 0)
+      {
+        curarg++;
+        if (curarg < argc)
+            this->purge_percentage_ = ACE_OS::atoi (argv[curarg]);
+        else
+           ACE_DEBUG ((LM_DEBUG,
+                       "TAO_Default_Factory - unknown argument"
+                       "for -ORBPurgePercentage\n"));
+      }
+
   return 0;
 }
 
@@ -454,6 +493,18 @@ TAO_Default_Resource_Factory::output_cdr_buffer_allocator (void)
   return allocator;
 }
 
+TAO_Resource_Factory::Caching_Strategy
+TAO_Default_Resource_Factory::connection_caching_strategy_type (void) const
+{
+  return this->connection_caching_type_;
+}
+
+double
+TAO_Default_Resource_Factory::purge_percentage (void) const
+{
+  return this->purge_percentage_;
+}
+
 // ****************************************************************
 
 ACE_STATIC_SVC_DEFINE (TAO_Default_Resource_Factory,
diff --git a/TAO/tao/default_resource.h b/TAO/tao/default_resource.h
index 551311386e1..19e94eb1075 100644
--- a/TAO/tao/default_resource.h
+++ b/TAO/tao/default_resource.h
@@ -91,6 +91,9 @@ public:
   virtual TAO_ProtocolFactorySet *get_protocol_factories (void);
   virtual int init_protocol_factories (void);
 
+  virtual TAO_Resource_Factory::Caching_Strategy connection_caching_strategy_type (void) const;
+  virtual double purge_percentage (void) const;
+
 protected:
   virtual ACE_Reactor_Impl *allocate_reactor_impl (void) const;
   // Obtain the reactor implementation
@@ -111,6 +114,14 @@ protected:
 
   TAO_ProtocolFactorySet protocol_factories_;
   // list of loaded protocol factories.
+
+  TAO_Resource_Factory::Caching_Strategy connection_caching_type_;
+  // Specifies the typeof caching strategy we should use for
+  // connection management.
+
+  double purge_percentage_;
+  // Specifies the percentage of entries which should get purged on
+  // demand.
 };
 
 #if defined (__ACE_INLINE__)
diff --git a/TAO/tao/orbconf.h b/TAO/tao/orbconf.h
index 092be28d083..985f8937b42 100644
--- a/TAO/tao/orbconf.h
+++ b/TAO/tao/orbconf.h
@@ -148,6 +148,17 @@
 # define TAO_MAXIMUM_NATIVE_TYPE_SIZE 128
 #endif /* TAO_MAXIMUM_NATIVE_TYPE_SIZE */
 
+// This deals with the strategies for connection caching. By default
+// it is the Least Recently Used (LRU) with the default purging
+// percentage of 20%.
+#if !defined (TAO_CONNECTION_CACHING_STRATEGY)
+# define TAO_CONNECTION_CACHING_STRATEGY TAO_Resource_Factory::LRU
+#endif /* TAO_CONNECTION_CACHING_STRATEGY */
+
+#if !defined (TAO_PURGE_PERCENT)
+# define TAO_PURGE_PERCENT 20
+#endif /* TAO_PURGE_PERCENT */
+
 // This deals with platforms that support namespaces vs platforms that
 // don't.  @@ MSVC's namespace implementation is somehow broken.
 // The following macros are required to deal with the most bizarre and insane