diff options
Diffstat (limited to 'examples/Shared_Malloc/test_malloc.cpp')
| -rw-r--r-- | examples/Shared_Malloc/test_malloc.cpp | 195 |
1 files changed, 195 insertions, 0 deletions
diff --git a/examples/Shared_Malloc/test_malloc.cpp b/examples/Shared_Malloc/test_malloc.cpp new file mode 100644 index 00000000000..9a1d355701b --- /dev/null +++ b/examples/Shared_Malloc/test_malloc.cpp @@ -0,0 +1,195 @@ +// This program tests out all the various ACE_Malloc combinations and +// @(#)test_malloc.cpp 1.1 10/18/96 + +// the ACE_Allocator_Adapter. + +#include "ace/Thread.h" +#include "ace/Thread_Manager.h" +#include "Malloc.h" +#include "Options.h" + +// Global thread manager. +static ACE_Thread_Manager thread_manager; + +static int +gen_size (void) +{ +#if defined (ACE_HAS_THREADS) + ACE_RANDR_TYPE seed = ACE_RANDR_TYPE (&seed); + return (ACE_OS::rand_r (ACE_RANDR_TYPE (seed)) % Options::instance ()->max_msg_size ()) + 1; +#else + return (ACE_OS::rand () % Options::instance ()->max_msg_size ()) + 1; +#endif /* ACE_HAS_THREADS */ +} + +// Recursively allocate and deallocate dynamic memory. + +static int +malloc_recurse (int count) +{ + static char default_char = 0; + + if (count <= 0) + { + if (Options::instance ()->debug ()) + AMS (Malloc::instance ()->print_stats ()); + } + else + { + int alloc_size = gen_size (); + void *ptr = Malloc::instance ()->malloc (alloc_size); + + if (ptr == 0) + ACE_ERROR ((LM_ERROR, "(%P|%t) *** malloc of size %d failed, %p\n%a", + "malloc", alloc_size)); + else + { + ACE_OS::memset (ptr, default_char++, alloc_size); + + if (Options::instance ()->debug ()) + ACE_DEBUG ((LM_INFO, "(%P|%t) %u (alloc), size = %d\n", ptr, alloc_size)); + + // Call ourselves recursively + malloc_recurse (count - 1); + + if (Options::instance ()->debug ()) + ACE_DEBUG ((LM_INFO, "(%P|%t) %u (free), size = %d\n", ptr, alloc_size)); + + Malloc::instance ()->free (ptr); + } + } + return 0; +} + +static void * +worker (void *arg) +{ + // Allocate a thread control object, which automatically removes the + // thread from the thread manager on exit. + ACE_Thread_Control tc (&thread_manager); + + malloc_recurse (int (arg)); + return 0; +} + +// Create the appropriate type of process/thread. + +static void +spawn (void) +{ + if (Options::instance ()->spawn_threads ()) + { +#if defined (ACE_HAS_THREADS) + if (thread_manager.spawn (ACE_THR_FUNC (worker), + (void *) Options::instance ()->iteration_count (), + THR_BOUND) == -1) + ACE_ERROR ((LM_ERROR, "%p\n%a", "thread create failed")); +#else + if (Options::instance ()->spawn_count () > 1) + ACE_ERROR ((LM_ERROR, "only one thread may be run in a process on this platform\n%a", 1)); +#endif /* ACE_HAS_THREADS */ + } +#if !defined (ACE_WIN32) + else + { + if (ACE_OS::fork () == 0) + { + if (Options::instance ()->exec_slave ()) + { + char iterations[20]; + char msg_size[20]; + + ACE_OS::sprintf (iterations, "%d", Options::instance ()->iteration_count ()); + ACE_OS::sprintf (msg_size, "%d", Options::instance ()->max_msg_size ()); + + char *argv[8]; + argv[0] = (char *) Options::instance ()->slave_name (); + argv[1] = "-p"; + argv[2] = "-n"; + argv[3] = iterations; + argv[4] = "-L"; + argv[5] = msg_size; + argv[6] = Options::instance ()->debug () ? "-d" : ""; + argv[7] = (char *) 0; + + if (ACE_OS::execv (Options::instance ()->program_name (), argv) == -1) + ACE_ERROR ((LM_ERROR, "%p\n", "exec failed")); + ACE_OS::_exit (1); + } + else + { + ACE_LOG_MSG->sync (Options::instance ()->program_name ()); + + ACE_DEBUG ((LM_INFO, + "(%P|%t) about to recurse with iteration count = %d\n", + Options::instance ()->iteration_count ())); + + malloc_recurse (Options::instance ()->iteration_count ()); + ACE_OS::exit (0); + } + } + } +#endif /* ACE_WIN32 */ +} + +// Wait for all the child processes/threads to exit. + +static void +wait_for_children (void) +{ + if (Options::instance ()->spawn_threads ()) + { +#if defined (ACE_HAS_THREADS) + // Wait for the threads to terminate. + thread_manager.wait (); +#else + malloc_recurse (Options::instance ()->iteration_count ()); +#endif /* ACE_HAS_THREADS */ + } +#if !defined (ACE_WIN32) + else + { + pid_t pid; + + while ((pid = ACE_OS::wait (0)) != -1) + ACE_DEBUG ((LM_DEBUG, "(%P|%t) reaped pid = %d\n", pid)); + } +#endif /* ACE_WIN32 */ +} + +static void +handler (int) +{ + Malloc::instance ()->remove (); + ACE_ERROR ((LM_ERROR, "(%P|%t) removed handler\n%a", 0)); +} + +int +main (int argc, char *argv[]) +{ + signal (SIGINT, ACE_SignalHandler (handler)); + + Options::instance ()->parse_args (argc, argv); + +#if !defined (ACE_WIN32) + if (Options::instance ()->child ()) + { + ACE_DEBUG ((LM_INFO, + "(%P|%t) about to recurse with iteration count = %d, debug = %d\n", + Options::instance ()->iteration_count ())); + + // We've been forked... + malloc_recurse (Options::instance ()->iteration_count ()); + } + else +#endif /* ACE_WIN32 */ + { + for (size_t i = 0; i < Options::instance ()->spawn_count (); i++) + spawn (); + + wait_for_children (); + Malloc::instance ()->remove (); + } + return 0; +} + |