diff options
Diffstat (limited to 'tests/Cached_Conn_Test.cpp')
| -rw-r--r-- | tests/Cached_Conn_Test.cpp | 731 |
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 */ |