This commit was manufactured by cvs2svn to create tagami_phase4_end

'ami_phase4_end'.

1 files changed, 312 insertions, 419 deletions

diff --git a/tests/Cached_Conn_Test.cpp b/tests/Cached_Conn_Test.cpp
index 70d0134f794..39ffc3f235f 100644
--- a/tests/Cached_Conn_Test.cpp
+++ b/tests/Cached_Conn_Test.cpp
@@ -9,11 +9,11 @@
 //    Cached_Conn_Test.cpp
 //
 // = DESCRIPTION
-//    The test illustrates how the <ACE_Strategy_Connector> works by
-//    showing how you can cache connections on the client using
-//    different caching strategies. Also how connections can be purged
-//    explicitly and implicitly if needed from the connection cache
-//    maintained by the connector.
+//     The test illustrates how the <ACE_Strategy_Connector> works by
+//   showing how you can cache connections on the client using
+//   different caching strategies. Also how connections can be purged
+//   explicitly if needed from the connection cache maintained by the
+//   connector.
 //
 // = AUTHOR
 //    Kirthika Parameswaran <kirthika@cs.wustl.edu>
@@ -24,20 +24,9 @@
 #define CACHED_CONNECT_TEST
 
 #include "test_config.h"
-
-// IBM C Set++ just can't grok the templates in here for auto template
-// instantiation. It ends up overwriting a tempinc/*.C file and mashes
-// its contents.
-#if !defined (__xlC__) || (__xlC__ > 0x0301)
-
-#include "Cached_Conn_Test.h"
-
-#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ < 8
-#define ACE_HAS_BROKEN_EXTENDED_TEMPLATES
-#endif /* __GNUC__ */
-
 #include "ace/INET_Addr.h"
 #include "ace/Strategies.h"
+#include "ace/Auto_Ptr.h"
 #include "ace/SOCK_Connector.h"
 #include "ace/SOCK_Acceptor.h"
 #include "ace/Svc_Handler.h"
@@ -47,11 +36,6 @@
 #include "ace/Get_Opt.h"
 #include "ace/Caching_Utility_T.h"
 #include "ace/Cached_Connect_Strategy_T.h"
-#include "ace/Handle_Gobbler.h"
-
-#if defined(_MSC_VER)
-#pragma warning(disable:4503)
-#endif /* _MSC_VER */
 
 ACE_RCSID(tests, Cached_Conn_Test, "$Id$")
 
@@ -60,170 +44,150 @@ USELIB("..\ace\aced.lib");
 //---------------------------------------------------------------------------
 #endif /* defined(__BORLANDC__) && __BORLANDC__ >= 0x0530 */
 
-static int debug = 0;
+// Default number of clients/servers.
+static int n_servers = 3000;
+static double purge_percentage = 20;
 
-Svc_Handler::Svc_Handler (ACE_Thread_Manager *t)
-  : ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH> (t)
+enum Caching_Strategy_Type
 {
-}
+  ACE_LFU,
+  ACE_FIFO,
+  ACE_LRU,
+  ACE_NULL,
+  ACE_ALL
+};
+static Caching_Strategy_Type caching_strategy_type = ACE_ALL;
 
-int
-Svc_Handler::open (void *)
+class Svc_Handler : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>
 {
-  if (debug)
-    ACE_DEBUG ((LM_DEBUG,
-                ASYS_TEXT ("opening Svc_Handler %d with handle %d\n"),
-                this,
-                this->peer ().get_handle ()));
 
-  return 0;
-}
+public:
 
-int
-Svc_Handler::close (u_long flags)
-{
-  ACE_DEBUG ((LM_DEBUG,
-              ASYS_TEXT ("Closing Svc_Handler %d with handle %d\n"),
-              this,
-              this->peer ().get_handle ()));
-  return ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>::close (flags);
-}
+  Svc_Handler (ACE_Thread_Manager *t = 0)
+    : ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH> (t)
+    {
+    }
+     
+  int open (void *v = 0)
+    {
+      ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>::open (v);
+      ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("(%P|%t) opening Svc_Handler %d with handle %d\n"),
+                  this,
+                  this->peer ().get_handle ()));
+      return 0;
+    }
+ 
+  int close (u_long flags = 0)
+    {
+      ACE_UNUSED_ARG (flags);
+      ACE_DEBUG ((LM_DEBUG, 
+                  ASYS_TEXT ("(%P|%t) Closing Svc_Handler %d with handle %d\n"),
+                  this,
+                  this->peer ().get_handle ()));
+      return this->handle_close ();
+    }
+
+  int idle (u_long flags = 0)
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  ASYS_TEXT ("(%P|%t) idling Svc_Handler %d with handle %d\n"),
+                  this,
+                  this->peer ().get_handle ()));
+      return ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>::idle (flags);
+    }
+  
+};
 
 typedef size_t ATTRIBUTES;
-typedef ACE_Pair<Svc_Handler *, ATTRIBUTES>
+typedef ACE_Pair<Svc_Handler *, ATTRIBUTES> 
         CACHED_HANDLER;
 typedef ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr>
-        ADDR;
-typedef ACE_Hash<ADDR> H_KEY;
-typedef ACE_Equal_To<ADDR> C_KEYS;
+        REFCOUNTED_HASH_RECYCLABLE_ADDR;
+typedef ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR> H_KEY;
+typedef ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR> C_KEYS;
 
-typedef ACE_Hash_Map_Manager_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>
+typedef ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>,\
+                                ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Null_Mutex>
         HASH_MAP;
-typedef ACE_Hash_Map_Iterator_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>
+typedef ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, \
+                                 ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Null_Mutex>
         HASH_MAP_ITERATOR;
-typedef ACE_Hash_Map_Reverse_Iterator_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>
+typedef ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>,\
+                                         ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>, ACE_Null_Mutex>
         HASH_MAP_REVERSE_ITERATOR;
-
-typedef ACE_Recyclable_Handler_Cleanup_Strategy<ADDR, CACHED_HANDLER, HASH_MAP>
+typedef ACE_Svc_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP>
         CLEANUP_STRATEGY;
-typedef ACE_Recyclable_Handler_Caching_Utility<ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP_ITERATOR, ATTRIBUTES>
+typedef ACE_Recyclable_Handler_Caching_Utility<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP_ITERATOR, ATTRIBUTES>
         CACHING_UTILITY;
 
-typedef ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>
-        LRU_CACHING_STRATEGY;
-
-#if defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES)
-
-typedef LRU_CACHING_STRATEGY
+typedef ACE_Caching_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>
         CACHING_STRATEGY;
-
-#else
-
-typedef ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>
+typedef ACE_LRU_Caching_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>
+        LRU_CACHING_STRATEGY;
+typedef ACE_LFU_Caching_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>
         LFU_CACHING_STRATEGY;
-typedef ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>
+typedef ACE_FIFO_Caching_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>
         FIFO_CACHING_STRATEGY;
-typedef ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>
+typedef ACE_Null_Caching_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>
         NULL_CACHING_STRATEGY;
-typedef ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, LRU_CACHING_STRATEGY>
+typedef ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, LRU_CACHING_STRATEGY >
         LRU_CACHING_STRATEGY_ADAPTER;
-typedef ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, LFU_CACHING_STRATEGY>
+typedef ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, LFU_CACHING_STRATEGY>
         LFU_CACHING_STRATEGY_ADAPTER;
-typedef ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, FIFO_CACHING_STRATEGY>
+typedef ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, FIFO_CACHING_STRATEGY>
         FIFO_CACHING_STRATEGY_ADAPTER;
-typedef ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, NULL_CACHING_STRATEGY>
+typedef ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, NULL_CACHING_STRATEGY>
         NULL_CACHING_STRATEGY_ADAPTER;
-typedef ACE_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>
-        CACHING_STRATEGY;
-
-#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
 
 typedef ACE_Oneshot_Acceptor<Svc_Handler, ACE_SOCK_ACCEPTOR>
         ACCEPTOR;
-
+  
 typedef ACE_Strategy_Connector<Svc_Handler, ACE_SOCK_CONNECTOR>
         STRATEGY_CONNECTOR;
-
+  
 typedef ACE_NOOP_Creation_Strategy<Svc_Handler>
         NULL_CREATION_STRATEGY;
-
+  
 typedef ACE_NOOP_Concurrency_Strategy<Svc_Handler>
         NULL_ACTIVATION_STRATEGY;
-
+ 
 typedef ACE_Cached_Connect_Strategy_Ex<Svc_Handler, ACE_SOCK_CONNECTOR, CACHING_STRATEGY, ATTRIBUTES, ACE_SYNCH_NULL_MUTEX>
         CACHED_CONNECT_STRATEGY;
 
-enum Caching_Strategy_Type
-{
-  ACE_LFU,
-  ACE_FIFO,
-  ACE_LRU,
-  ACE_NULL,
-  ACE_ALL
-};
-
-// Default number of clients/servers.
-static int listen_once = 1;
-static int user_has_specified_iterations = 0;
-static size_t keep_handles_available = 100;
-static double purge_percentage = 20;
-static Caching_Strategy_Type caching_strategy_type = ACE_ALL;
-static CACHED_CONNECT_STRATEGY *connect_strategy = 0;
-
-// On Win32, the handle gobbling doesn't work.  Therefore, we need
-// more iterations to get to the handle limit.
-#if defined (ACE_WIN32)
-static int iterations = 2000;
-#else
-static int iterations = 200;
-#endif /* ACE_WIN32 */
-
 //====================================================================
 
-static void
-out_of_sockets_handler (void)
-{
-  if (ACE::out_of_handles (errno))
-    {
-      // Close connections which are cached by explicitly purging the
-      // connection cache maintained by the connector.
-      ACE_DEBUG ((LM_DEBUG, "Purging connections from Connection Cache...\n"));
-
-      int retval = connect_strategy->purge_connections ();
-      ACE_ASSERT (retval != -1);
-    }
-  else
-    {
-      ACE_ERROR ((LM_ERROR,
-                  ASYS_TEXT ("%p\n"),
-                  ASYS_TEXT ("out_of_sockets_handler  failed!")));
-      // This shouldn't happen!
-      ACE_ASSERT (0);
-    }
-}
 
 static int
 cached_connect (STRATEGY_CONNECTOR &con,
                 const ACE_INET_Addr &server_addr)
 {
-  // This will make sure we get the host information correct.
-  ACE_INET_Addr remote_addr (server_addr.get_port_number (),
-                             ACE_LOCALHOST);
-
-  // Perform a blocking connect to the server using the Strategy
-  // Connector with a connection caching strategy.
   Svc_Handler *svc_handler = 0;
+  
+  // Perform a blocking connect to the server using the Strategy
+  // Connector with a connection caching strategy.  Since we are
+  // connecting to the same <server_addr> these calls will return
+  // the same dynamically allocated <Svc_Handler> for each
+  // <connect>.
   int result = con.connect (svc_handler,
-                            remote_addr);
+                            server_addr);
   if (result == -1)
     ACE_ERROR_RETURN ((LM_ERROR,
-                       ASYS_TEXT ("%p\n"),
+                       ASYS_TEXT ("(%P|%t) %p\n"),
                        ASYS_TEXT ("connection failed")),
                       -1);
-
-  // Reset Svc_Handler state.
-  svc_handler->recycle_state (ACE_RECYCLABLE_PURGABLE_BUT_NOT_IDLE);
-
+      
+  // Send the data to the server.
+  for (char *c = ACE_ALPHABET; *c != '\0'; c++)
+    if (svc_handler->peer ().send_n (c, 1) == -1)
+      ACE_ERROR_RETURN ((LM_ERROR,
+                         ASYS_TEXT ("(%P|%t) %p\n"),
+                         ASYS_TEXT ("send_n")),
+                        -1);
+      
+  // Svc_Handler is now idle, so mark it as such and let the cache
+  // recycle it.
+  svc_handler->idle (1);
   return 0;
 }
 
@@ -231,117 +195,133 @@ static int
 server (ACCEPTOR *acceptor)
 {
   ACE_INET_Addr cli_addr;
-
+      
   // Create a new <Svc_Handler> to consume the data.
   Svc_Handler svc_handler;
-
+  
   int result = acceptor->accept (&svc_handler,
                                  &cli_addr);
   if (result == -1)
-    return -1;
+    {
+      if (errno == EMFILE)
+        return 1;
+          
+      return -1;
+    }
 
-  if (debug)
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT ("(%P|%t) client %s connected from %d\n"),
+              cli_addr.get_host_name (),
+              cli_addr.get_port_number ()));
+      
+  char c;
+  char *t = ACE_ALPHABET;
+  ssize_t r_bytes = 0;
+      
+  // Read data from client (terminate on error).
+  while ((r_bytes ==  svc_handler.peer ().recv_n (&c, 1)) > 0)
+    {
+      ACE_ASSERT (*t == c);
+          
+      // We need to guard against cached connections, which
+      // will send multiple sequences of letters from 'a' ->
+      // 'z' through the same connection.
+      if (*t == 'z')
+        t = ACE_ALPHABET;
+      else
+        t++;
+    }
+      
+  if (r_bytes == 0)
     ACE_DEBUG ((LM_DEBUG,
-                ASYS_TEXT ("client %s connected from %d\n"),
-                cli_addr.get_host_name (),
-                cli_addr.get_port_number ()));
+                ASYS_TEXT ("(%P|%t) reached end of input, connection closed by client\n")));
+  else if (r_bytes == -1)
+    {
+      if (errno == EWOULDBLOCK)
+        ACE_DEBUG ((LM_DEBUG,
+                    ASYS_TEXT ("(%P|%t) no input available, going back to reading\n")));
+      else
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           ASYS_TEXT ("(%P|%t) %p\n"),
+                           ASYS_TEXT ("recv_n")),
+                          -1);
+    }
 
-  //
-  // Svc_Handler dies here, closing the server side socket.
-  //
   return 0;
 }
 
+
 static void
 test_connection_management (CACHING_STRATEGY &caching_strategy)
 {
+  NULL_CREATION_STRATEGY creation_strategy;
+  NULL_ACTIVATION_STRATEGY activation_strategy;     
+      
   // Configure the Strategy Connector with a strategy that caches
   // connection.
   CACHED_CONNECT_STRATEGY caching_connect_strategy (caching_strategy);
-
-  // This is required by the <out_of_sockets_handler>.
-  connect_strategy = &caching_connect_strategy;
-
-  NULL_CREATION_STRATEGY creation_strategy;
-  NULL_ACTIVATION_STRATEGY activation_strategy;
-
+      
   STRATEGY_CONNECTOR strategy_connector (0,
                                          &creation_strategy,
                                          &caching_connect_strategy,
                                          &activation_strategy);
-
-  // If <listen_once> is true, only one Acceptor is used for the test.
-  ACCEPTOR listen_one_time_acceptor;
-  ACE_INET_Addr server_addr;
-
-  int result = listen_one_time_acceptor.open (ACE_sap_any_cast (const ACE_INET_Addr &));
-  ACE_ASSERT (result == 0);
-
-  result = listen_one_time_acceptor.acceptor ().get_local_addr (server_addr);
-  ACE_ASSERT (result == 0);
-
-  for (int i = 1; i <= iterations; ++i)
+      
+  // Set the purging percentage explicitly. By default it is 10%.
+  // Note: The purge_percent could have been set before itself but,
+  // the following has been done just to show how one would explicitly
+  // set the purge_percent at any moment.
+  CACHED_CONNECT_STRATEGY *connect_strategy = 
+    ACE_dynamic_cast (CACHED_CONNECT_STRATEGY *,
+                      strategy_connector.connect_strategy ());
+  
+  connect_strategy->caching_strategy ().purge_percent (purge_percentage);
+      
+  for (int i = 0; i < n_servers; ++i)
     {
-      ACE_DEBUG ((LM_DEBUG,
-                  ASYS_TEXT ("iteration %d\n"),
-                  i));
-
-      // If <listen_once> is false, one Acceptor is used for every
-      // iteration.
-      ACCEPTOR listen_multiple_times_acceptor;
-
-      ACCEPTOR &acceptor = listen_once ?
-        listen_one_time_acceptor :
-        listen_multiple_times_acceptor;
-
-      if (!listen_once)
+      // Acceptor
+      ACCEPTOR acceptor;
+      ACE_INET_Addr server_addr;
+          
+      // Bind acceptor to any port and then find out what the port
+      // was.
+      if (acceptor.open (ACE_sap_any_cast (const ACE_INET_Addr &)) == -1
+          || acceptor.acceptor ().get_local_addr (server_addr) == -1)
         {
-          // Bind acceptor to any port and then find out what the port
-          // was.
-          if (acceptor.open (ACE_sap_any_cast (const ACE_INET_Addr &)) == -1)
-            {
-              out_of_sockets_handler ();
-              continue;
-            }
-
-          if (acceptor.acceptor ().get_local_addr (server_addr) == -1)
-            {
-              ACE_ERROR ((LM_ERROR,
-                          ASYS_TEXT ("%p\n"),
-                          ASYS_TEXT ("get_local_addr")));
-              ACE_ASSERT (0);
-            }
-
-          if (debug)
-            ACE_DEBUG ((LM_DEBUG,
-                        ASYS_TEXT ("starting server at port %d\n"),
-                        server_addr.get_port_number ()));
+          ACE_ERROR ((LM_ERROR,
+                      ASYS_TEXT ("(%P|%t) %p\n"),
+                      ASYS_TEXT ("open")));
+          return;
         }
-
+      else
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                      ASYS_TEXT ("(%P|%t) starting server at port %d\n"),
+                      server_addr.get_port_number ()));
+        }
+          
       // Run the cached blocking test.
+      ACE_DEBUG ((LM_DEBUG,
+                  ASYS_TEXT ("(%P|%t) *starting cached blocking connect\n")));
+          
       int result = cached_connect (strategy_connector,
                                    server_addr);
       ACE_ASSERT (result != -1);
-
+          
       result = server (&acceptor);
-      if (result == -1)
-        out_of_sockets_handler ();
-    }
-}
-
-#if defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES)
-
-void
-test_caching_strategy_type (void)
-{
-  ACE_DEBUG ((LM_DEBUG, "\nLRU_Caching_Strategy\n\n"));
-  CACHING_STRATEGY caching_strategy;
-  caching_strategy.purge_percent (purge_percentage);
-  test_connection_management (caching_strategy);
+      if (result == 1)
+        {
+          // Close connections which are cached by explicitly purging
+          // the connection cache maintained by the connector.
+          ACE_DEBUG ((LM_DEBUG, "Purging connections from Connection Cache...\n"));
+              
+          int retval = connect_strategy->purge_connections (purge_percentage);
+          ACE_ASSERT (retval != -1);
+        }
+          
+      ACE_ASSERT (result != -1);
+    } 
 }
-
-#else
-
+  
 void
 test_caching_strategy_type (void)
 {
@@ -372,45 +352,33 @@ test_caching_strategy_type (void)
       ACE_NEW (caching_strategy,
                FIFO_CACHING_STRATEGY_ADAPTER);
       break;
-
+      
     case ACE_ALL: // Just to remove warnings!
       break;
-    }
+    } 
 
-  caching_strategy->purge_percent (purge_percentage);
   test_connection_management (*caching_strategy);
   delete caching_strategy;
 }
 
-#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
 
 int
 parse_args (int argc, char *argv[])
 {
-  ACE_Get_Opt get_opt (argc, argv, "l:i:p:c:a:d");
-
+  ACE_Get_Opt get_opt (argc, argv, "s:p:c:");
+      
   int cc;
-
+      
   while ((cc = get_opt ()) != -1)
     switch (cc)
       {
-      case 'd':
-        debug = 1;
-        break;
-      case 'l':
-        listen_once = atoi (get_opt.optarg);
-        break;
-      case 'i':
-        iterations = atoi (get_opt.optarg);
-        user_has_specified_iterations = 1;
+      case 's':
+        n_servers = atoi (get_opt.optarg);
         break;
       case 'p':
         purge_percentage = atoi (get_opt.optarg);
         break;
-      case 'c':
-        // Note that if null caching strategy is used then this test
-        // will fail if the number of servers exceed number of open
-        // files allowed for the process.
+      case 'c': // If Null Caching Strategy then this test will fail!
         if (ACE_OS::strcmp (get_opt.optarg, "null") == 0)
           caching_strategy_type = ACE_NULL;
         if (ACE_OS::strcmp (get_opt.optarg, "lru") == 0)
@@ -420,20 +388,14 @@ parse_args (int argc, char *argv[])
         if (ACE_OS::strcmp (get_opt.optarg, "fifo") == 0)
           caching_strategy_type = ACE_FIFO;
         break;
-      case 'a':
-        keep_handles_available = atoi (get_opt.optarg);
-        break;
       case '?':
       case 'h':
       default:
         ACE_ERROR ((LM_ERROR,
-                    ASYS_TEXT ("usage: %s ")
-                    ASYS_TEXT ("[-c (caching strategy: lru / lfu / fifo / null [default = all])] ")
-                    ASYS_TEXT ("[-i (iterations)] ")
-                    ASYS_TEXT ("[-l (listen once)] ")
-                    ASYS_TEXT ("[-d (addition debugging output)] ")
-                    ASYS_TEXT ("[-p (purge percent)] ")
-                    ASYS_TEXT ("[-a (keep handles available)] "),
+                    "usage: %s "
+                    "[-s (number of servers to connect to)] "
+                    "[-p (purge percent)] "
+                    "[-c (caching_strategy_type 0=NULL , 1=LRU, 2=LFU, 3=FIFO default=LRU)]\n",
                     argv[0]));
         return -1;
       }
@@ -445,51 +407,21 @@ int
 main (int argc,
       ASYS_TCHAR *argv[])
 {
-  // Validate options.
-  int result = parse_args (argc, argv);
-  if (result != 0)
-    return result;
-
-#if defined (ACE_WIN32)
-  // Somehow, on Win32, the <listen once> option allows us to create
-  // more handles.
-  if (!user_has_specified_iterations &&
-      listen_once)
-    iterations *= 2;
-#endif /* ACE_WIN32 */
-
-  // Start the test only if options are valid.
   ACE_START_TEST (ASYS_TEXT ("Cached_Conn_Test"));
-
-  // Remove the extra debugging attributes from Log_Msg output.
   ACE_LOG_MSG->clr_flags (ACE_Log_Msg::VERBOSE_LITE);
-
-  // The reactor's constructor changes the handle limit for the
-  // process.
-  ACE_Reactor::instance ();
-
-  // Consume all handles in the process, leaving us
-  // <keep_handles_available> to play with.
-  ACE_Handle_Gobbler handle_gobbler;
-  result = handle_gobbler.consume_handles (keep_handles_available);
+  
+  // Obtain the <number of servers> to connect to. Also the purge
+  // percentage using which the entries in the connection cache of
+  // the connector will be removed.
+  int result = parse_args (argc, argv);
   ACE_ASSERT (result == 0);
 
-#if defined ACE_HAS_BROKEN_EXTENDED_TEMPLATES
-  caching_strategy_type = ACE_LRU;
-#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
-
-  // Do we need to test all the strategies.  Note, that the less
-  // useful null strategy is ignored in this case.
+  // Do we need to test all the strategies.
   if (caching_strategy_type == ACE_ALL)
     {
       caching_strategy_type = ACE_LRU;
       test_caching_strategy_type ();
 
-      // Default iterations are too many; if the user hasn't specified
-      // otherwise, we'll shrink the iterations for LFU and FIFO.
-      if (!user_has_specified_iterations)
-        iterations /= 100;
-
       caching_strategy_type = ACE_LFU;
       test_caching_strategy_type ();
 
@@ -500,24 +432,8 @@ main (int argc,
     {
       test_caching_strategy_type ();
     }
-
+  
   ACE_LOG_MSG->set_flags (ACE_Log_Msg::VERBOSE_LITE);
-
-#else   /* Do this for C Set++ 3.1 */
-
-int
-main (int argc,
-      ASYS_TCHAR *argv[])
-{
-  ACE_UNUSED_ARG (argc);
-  ACE_UNUSED_ARG (argv);
-
-  ACE_START_TEST (ASYS_TEXT ("Cached_Conn_Test"));
-  ACE_ERROR ((LM_INFO,
-              ASYS_TEXT ("C Set++ won't build this test correctly\n")));
-
-#endif /* !__xlC__ || __xlC > 0x0301 */
-
   ACE_END_TEST;
   return 0;
 }
@@ -525,11 +441,6 @@ main (int argc,
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 
-// = Handle Gobbler
-template class ACE_Node<ACE_HANDLE>;
-template class ACE_Unbounded_Set<ACE_HANDLE>;
-template class ACE_Unbounded_Set_Iterator<ACE_HANDLE>;
-
 template class ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>;
 template class ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr>;
 template class ACE_NOOP_Creation_Strategy<Svc_Handler>;
@@ -537,9 +448,16 @@ template class ACE_Concurrency_Strategy<Svc_Handler>;
 template class ACE_Connect_Strategy<Svc_Handler, ACE_SOCK_CONNECTOR>;
 template class ACE_Connector<Svc_Handler, ACE_SOCK_CONNECTOR>;
 template class ACE_Creation_Strategy<Svc_Handler>;
-template class ACE_Hash_Map_Entry<ADDR, Svc_Handler *>;
-template class ACE_Hash<ADDR>;
-template class ACE_Equal_To<ADDR>;
+template class ACE_Hash_Map_Entry<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *>;
+template class ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>;
+template class ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>;
+template class ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, C_KEYS, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, C_KEYS, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, C_KEYS, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>;
+template class ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>, C_KEYS, ACE_SYNCH_RW_MUTEX>;
 template class ACE_Map_Entry<ACE_HANDLE, ACE_Svc_Tuple<Svc_Handler> *>;
 template class ACE_Map_Manager<ACE_HANDLE, ACE_Svc_Tuple<Svc_Handler> *, ACE_SYNCH_RW_MUTEX>;
 template class ACE_Map_Iterator_Base<ACE_HANDLE, ACE_Svc_Tuple<Svc_Handler> *, ACE_SYNCH_RW_MUTEX>;
@@ -552,70 +470,51 @@ template class ACE_Svc_Tuple<Svc_Handler>;
 template class ACE_Oneshot_Acceptor<Svc_Handler, ACE_SOCK_ACCEPTOR>;
 
 template class ACE_Pair<Svc_Handler *, ATTRIBUTES>;
-template class ACE_Reference_Pair<ADDR, Svc_Handler *>;
-template class ACE_Hash_Map_Entry<ADDR, CACHED_HANDLER>;
-
-template class ACE_Hash_Map_Manager<ADDR, Svc_Handler *, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator<ADDR, Svc_Handler *, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Reverse_Iterator<ADDR, Svc_Handler *, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Manager_Ex<ADDR, Svc_Handler *, H_KEY,  C_KEYS, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Reverse_Iterator_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator_Base_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>;
-
-template class ACE_Hash_Map_Manager<ADDR, CACHED_HANDLER, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator<ADDR, CACHED_HANDLER, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Reverse_Iterator<ADDR, CACHED_HANDLER, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Manager_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Reverse_Iterator_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Iterator_Base_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Bucket_Iterator<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>;
-template class ACE_Hash_Map_Bucket_Iterator<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>;
+template class ACE_Reference_Pair<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *>;
+template class ACE_Hash_Map_Entry<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER>;
+
+template class ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY,  C_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>;
+
+template class ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>;
+template class ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>;
 
 // = Caching_Strategy
-template class ACE_Hash_Cache_Map_Manager<ADDR, Svc_Handler *, H_KEY, C_KEYS, CACHING_STRATEGY, ATTRIBUTES>;
-
-template class ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>;
-
-#if !defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES)
-
-template class ACE_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>;
-template class ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>;
-template class ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>;
-template class ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>;
-
-template class ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, LRU_CACHING_STRATEGY>;
-template class ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, LFU_CACHING_STRATEGY>;
-template class ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, FIFO_CACHING_STRATEGY>;
-template class ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, NULL_CACHING_STRATEGY>;
-
-template class ACE_Cache_Map_Manager<ADDR, Svc_Handler *, HASH_MAP, HASH_MAP_ITERATOR, HASH_MAP_REVERSE_ITERATOR, CACHING_STRATEGY, ATTRIBUTES>;
-template class ACE_Cache_Map_Iterator<ADDR, Svc_Handler *, HASH_MAP_ITERATOR, CACHING_STRATEGY, ATTRIBUTES>;
-template class ACE_Cache_Map_Reverse_Iterator<ADDR, Svc_Handler *, HASH_MAP_REVERSE_ITERATOR, CACHING_STRATEGY, ATTRIBUTES>;
-
-#else
-
-template class ACE_Cache_Map_Manager<ADDR, Svc_Handler *, HASH_MAP, CACHING_STRATEGY, ATTRIBUTES>;
-
-#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
-
+template class ACE_Hash_Cache_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, CACHING_STRATEGY, ATTRIBUTES>;
+template class ACE_Cache_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, HASH_MAP, HASH_MAP::iterator, HASH_MAP::reverse_iterator, CACHING_STRATEGY, ATTRIBUTES>;
+template class ACE_Cache_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, HASH_MAP::iterator, CACHING_STRATEGY, ATTRIBUTES>;
+template class ACE_Cache_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, HASH_MAP::reverse_iterator, CACHING_STRATEGY, ATTRIBUTES>;
 template class ACE_Cached_Connect_Strategy_Ex<Svc_Handler, ACE_SOCK_CONNECTOR, CACHING_STRATEGY, ATTRIBUTES, ACE_SYNCH_NULL_MUTEX>;
 template class ACE_Cached_Connect_Strategy<Svc_Handler, ACE_SOCK_CONNECTOR, ACE_SYNCH_NULL_MUTEX>;
 
-template class ACE_Cleanup_Strategy<ADDR, CACHED_HANDLER, HASH_MAP>;
-template class ACE_Recyclable_Handler_Cleanup_Strategy<ADDR, CACHED_HANDLER, HASH_MAP>;
-template class ACE_Recyclable_Handler_Caching_Utility<ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP_ITERATOR, ATTRIBUTES>;
+template class ACE_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP>;
+template class ACE_Default_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP>;
+template class ACE_Recyclable_Handler_Caching_Utility<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP::iterator, ATTRIBUTES>;
+template class ACE_Pair_Caching_Utility<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP::iterator, ATTRIBUTES>;
+template class ACE_Svc_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP>;
 
-template class ACE_Reverse_Lock<ACE_SYNCH_NULL_MUTEX>;
-template class ACE_Guard<ACE_Reverse_Lock<ACE_SYNCH_NULL_MUTEX> >;
+template class ACE_Caching_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>;
+template class ACE_LRU_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>;
+template class ACE_LFU_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>;
+template class ACE_FIFO_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>;
+template class ACE_Null_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>;
 
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+template class ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, LRU_CACHING_STRATEGY >;
+template class ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, LFU_CACHING_STRATEGY >;
+template class ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, FIFO_CACHING_STRATEGY >;
+template class ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, NULL_CACHING_STRATEGY >;
 
-// = Handle Gobbler
-#pragma instantiate ACE_Node<ACE_HANDLE>
-#pragma instantiate ACE_Unbounded_Set<ACE_HANDLE>
-#pragma instantiate ACE_Unbounded_Set_Iterator<ACE_HANDLE>
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
 
 #pragma instantiate ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>
 #pragma instantiate ACE_Refcounted_Hash_Recyclable<ACE_INET_Addr>
@@ -624,9 +523,16 @@ template class ACE_Guard<ACE_Reverse_Lock<ACE_SYNCH_NULL_MUTEX> >;
 #pragma instantiate ACE_Connect_Strategy<Svc_Handler, ACE_SOCK_CONNECTOR>
 #pragma instantiate ACE_Connector<Svc_Handler, ACE_SOCK_CONNECTOR>
 #pragma instantiate ACE_Creation_Strategy<Svc_Handler>
-#pragma instantiate ACE_Hash_Map_Entry<ADDR, Svc_Handler *>
-#pragma instantiate ACE_Hash<ADDR>
-#pragma instantiate ACE_Equal_To<ADDR>
+#pragma instantiate ACE_Hash_Map_Entry<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *>
+#pragma instantiate ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDR>
+#pragma instantiate ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDR>
+#pragma instantiate ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_SYNCH_RW_MUTEX>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_SYNCH_RW_MUTEX>
 #pragma instantiate ACE_Map_Entry<ACE_HANDLE, ACE_Svc_Tuple<Svc_Handler> *>
 #pragma instantiate ACE_Map_Manager<ACE_HANDLE, ACE_Svc_Tuple<Svc_Handler> *, ACE_SYNCH_RW_MUTEX>
 #pragma instantiate ACE_Map_Iterator_Base<ACE_HANDLE, ACE_Svc_Tuple<Svc_Handler> *, ACE_SYNCH_RW_MUTEX>
@@ -635,67 +541,54 @@ template class ACE_Guard<ACE_Reverse_Lock<ACE_SYNCH_NULL_MUTEX> >;
 #pragma instantiate ACE_NOOP_Concurrency_Strategy<Svc_Handler>
 #pragma instantiate ACE_Recycling_Strategy<Svc_Handler>
 #pragma instantiate ACE_Strategy_Connector<Svc_Handler, ACE_SOCK_CONNECTOR>
+
 #pragma instantiate ACE_Svc_Tuple<Svc_Handler>
 #pragma instantiate ACE_Oneshot_Acceptor<Svc_Handler, ACE_SOCK_ACCEPTOR>
 
 #pragma instantiate ACE_Pair<Svc_Handler *, ATTRIBUTES>
-#pragma instantiate ACE_Reference_Pair<ADDR, Svc_Handler *>
-#pragma instantiate ACE_Hash_Map_Entry<ADDR, CACHED_HANDLER>
-
-#pragma instantiate ACE_Hash_Map_Manager<ADDR, Svc_Handler *, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Iterator<ADDR, Svc_Handler *, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator<ADDR, Svc_Handler *, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Manager_Ex<ADDR, Svc_Handler *, H_KEY,  C_KEYS, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Iterator_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>
-
-#pragma instantiate ACE_Hash_Map_Manager<ADDR, CACHED_HANDLER, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Iterator<ADDR, CACHED_HANDLER, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator<ADDR, CACHED_HANDLER, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Manager_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Iterator_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Bucket_Iterator<ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>
-#pragma instantiate ACE_Hash_Map_Bucket_Iterator<ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Reference_Pair<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *>
+#pragma instantiate ACE_Hash_Map_Entry<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER>
+
+#pragma instantiate ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, ACE_Null_Mutex>
+
+#pragma instantiate ACE_Hash_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Manager_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>
+#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, H_KEY, C_KEYS, ACE_Null_Mutex>
 
 // = Caching_Strategy
-#pragma instantiate ACE_Hash_Cache_Map_Manager<ADDR, Svc_Handler *, H_KEY, C_KEYS, CACHING_STRATEGY, ATTRIBUTES>
-
-#pragma instantiate ACE_LRU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>
-
-#if !defined (ACE_HAS_BROKEN_EXTENDED_TEMPLATES)
-
-#pragma instantiate ACE_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>
-#pragma instantiate ACE_LFU_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>
-#pragma instantiate ACE_FIFO_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>
-#pragma instantiate ACE_Null_Caching_Strategy<ATTRIBUTES, CACHING_UTILITY>
-
-#pragma instantiate ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, LRU_CACHING_STRATEGY>
-#pragma instantiate ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, LFU_CACHING_STRATEGY>
-#pragma instantiate ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, FIFO_CACHING_STRATEGY>
-#pragma instantiate ACE_Caching_Strategy_Adapter<ATTRIBUTES, CACHING_UTILITY, NULL_CACHING_STRATEGY>
-
-#pragma instantiate ACE_Cache_Map_Manager<ADDR, Svc_Handler *, HASH_MAP, HASH_MAP_ITERATOR, HASH_MAP_REVERSE_ITERATOR, CACHING_STRATEGY, ATTRIBUTES>
-#pragma instantiate ACE_Cache_Map_Iterator<ADDR, Svc_Handler *, HASH_MAP_ITERATOR, CACHING_STRATEGY, ATTRIBUTES>
-#pragma instantiate ACE_Cache_Map_Reverse_Iterator<ADDR, Svc_Handler *, HASH_MAP_REVERSE_ITERATOR, CACHING_STRATEGY, ATTRIBUTES>
-
-#else
-
-#pragma instantiate ACE_Cache_Map_Manager<ADDR, Svc_Handler *, HASH_MAP, CACHING_STRATEGY, ATTRIBUTES>
-
-#endif /* ACE_HAS_BROKEN_EXTENDED_TEMPLATES */
-
+#pragma instantiate ACE_Hash_Cache_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, H_KEY, C_KEYS, CACHING_STRATEGY, ATTRIBUTES>
+#pragma instantiate ACE_Cache_Map_Manager<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, HASH_MAP, HASH_MAP::iterator, HASH_MAP::reverse_iterator, CACHING_STRATEGY, ATTRIBUTES>
+#pragma instantiate ACE_Cache_Map_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, HASH_MAP::iterator, CACHING_STRATEGY, ATTRIBUTES>
+#pragma instantiate ACE_Cache_Map_Reverse_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDR, Svc_Handler *, HASH_MAP::reverse_iterator, CACHING_STRATEGY, ATTRIBUTES>
 #pragma instantiate ACE_Cached_Connect_Strategy_Ex<Svc_Handler, ACE_SOCK_CONNECTOR, CACHING_STRATEGY, ATTRIBUTES, ACE_SYNCH_NULL_MUTEX>
 #pragma instantiate ACE_Cached_Connect_Strategy<Svc_Handler, ACE_SOCK_CONNECTOR, ACE_SYNCH_NULL_MUTEX>
 
-#pragma instantiate ACE_Cleanup_Strategy<ADDR, CACHED_HANDLER, HASH_MAP>
-#pragma instantiate ACE_Recyclable_Handler_Cleanup_Strategy<ADDR, CACHED_HANDLER, HASH_MAP>
-#pragma instantiate ACE_Recyclable_Handler_Caching_Utility<ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP_ITERATOR, ATTRIBUTES>
-
-#pragma instantiate ACE_Reverse_Lock<ACE_SYNCH_NULL_MUTEX>
-#pragma instantiate ACE_Guard<ACE_Reverse_Lock<ACE_SYNCH_NULL_MUTEX> >
+#pragma instantiate ACE_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP>
+#pragma instantiate ACE_Default_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP>
+#pragma instantiate ACE_Recyclable_Handler_Caching_Utility<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP::iterator, ATTRIBUTES>
+#pragma instantiate ACE_Pair_Caching_Utility<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, HASH_MAP::iterator, ATTRIBUTES>
+#pragma instantiate ACE_Svc_Cleanup_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP>
+
+#pragma instantiate ACE_Caching_Strategy<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>
+#pragma instantiate ACE_LRU_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>
+#pragma instantiate ACE_LFU_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>
+#pragma instantiate ACE_FIFO_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>
+#pragma instantiate ACE_Null_Caching_Strategy <REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY>
+
+#pragma instantiate ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, LRU_CACHING_STRATEGY >
+#pragma instantiate ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, LFU_CACHING_STRATEGY >
+#pragma instantiate ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, FIFO_CACHING_STRATEGY >
+#pragma instantiate ACE_Caching_Strategy_Adapter<REFCOUNTED_HASH_RECYCLABLE_ADDR, CACHED_HANDLER, HASH_MAP, ATTRIBUTES, CACHING_UTILITY, NULL_CACHING_STRATEGY >
 
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */