ACE/examples/Threads/recursive_mutex.cpp

   1 // This test program verifies the functionality of the ACE_OS
   2 // implementation of recursive mutexes on Win32 and Posix pthreads.
   3
   4 #include "ace/OS_main.h"
   5 #include "ace/Service_Config.h"
   6 #include "ace/Thread_Manager.h"
   7 #include "ace/Get_Opt.h"
   8
   9
  10 #if defined (ACE_HAS_THREADS)
  11
  12 #include "ace/Guard_T.h"
  13 #include "ace/Recursive_Thread_Mutex.h"
  14
  15 // Total number of iterations.
  16 static size_t n_iterations = 1000;
  17 static size_t n_threads = 4;
  18
  19 // Explain usage and exit.
  20 static void
  21 print_usage_and_die ()
  22 {
  23   ACE_DEBUG ((LM_DEBUG,
  24               "usage: %n [-t n_threads] [-n iteration_count]\n"));
  25   ACE_OS::exit (1);
  26 }
  27
  28 // Parse the command-line arguments and set options.
  29
  30 static void
  31 parse_args (int argc, ACE_TCHAR *argv[])
  32 {
  33   ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("n:t:"));
  34
  35   int c;
  36
  37   while ((c = get_opt ()) != -1)
  38     switch (c)
  39       {
  40       case 'n':
  41         n_iterations = ACE_OS::atoi (get_opt.opt_arg ());
  42         break;
  43       case 't':
  44         n_threads = ACE_OS::atoi (get_opt.opt_arg ());
  45         break;
  46       default:
  47         print_usage_and_die ();
  48         break;
  49       }
  50 }
  51
  52 static void
  53 recursive_worker (size_t nesting_level,
  54                   ACE_Recursive_Thread_Mutex *rm)
  55 {
  56   if (nesting_level < n_iterations)
  57     {
  58       ACE_DEBUG ((LM_DEBUG,
  59                   "(%P|%t) = trying to acquire, nesting = %d, thread id = %u\n",
  60       rm->get_nesting_level (), rm->get_thread_id ()));
  61       {
  62         // This illustrates the use of the ACE_GUARD with an
  63         // ACE_Recursive_Thread_Mutex.
  64         ACE_GUARD (ACE_Recursive_Thread_Mutex, ace_mon, *rm);
  65         ACE_DEBUG ((LM_DEBUG,
  66                     "(%P|%t) = acquired, nesting = %d, thread id = %u\n",
  67         rm->get_nesting_level (), rm->get_thread_id ()));
  68
  69         recursive_worker (nesting_level + 1, rm);
  70       }
  71       ACE_DEBUG ((LM_DEBUG,
  72                   "(%P|%t) = released, nesting = %d, thread id = %u\n",
  73       rm->get_nesting_level (), rm->get_thread_id ()));
  74     }
  75 }
  76
  77 static void *
  78 worker (void *arg)
  79 {
  80   ACE_Recursive_Thread_Mutex *rm
  81     = (ACE_Recursive_Thread_Mutex *) arg;
  82
  83   recursive_worker (0, rm);
  84   return 0;
  85 }
  86
  87 int
  88 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
  89 {
  90   ACE_Service_Config daemon (argv[0]);
  91
  92   parse_args (argc, argv);
  93   ACE_Recursive_Thread_Mutex rm;
  94
  95   ACE_Thread_Manager::instance ()->spawn_n (n_threads,
  96                                             ACE_THR_FUNC (worker),
  97                                             (void *) &rm);
  98
  99   ACE_Thread_Manager::instance ()->wait ();
 100   return 0;
 101 }
 102 #else
 103 int
 104 ACE_TMAIN (int, ACE_TCHAR *[])
 105 {
 106   ACE_ERROR_RETURN ((LM_ERROR,
 107                      "ACE doesn't support support process mutexes on this platform (yet)\n"),
 108                     -1);
 109 }
 110 #endif /* ACE_WIN32 */