ACE/tests/Semaphore_Test.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    Semaphore_Test.cpp
   5  *
   6  *  This test verifies the functionality of the <ACE_Thread_Semaphore>
   7  *  implementation.
   8  *
   9  *  @author Darrell Brunsch <brunsch@cs.wustl.edu>
  10  */
  11 //=============================================================================
  12
  13 #include "test_config.h"
  14 #include "ace/Thread_Semaphore.h"
  15 #include "ace/Thread.h"
  16 #include "ace/Thread_Manager.h"
  17 #include "ace/Get_Opt.h"
  18 #include "ace/OS_NS_sys_time.h"
  19 #include "ace/OS_NS_time.h"
  20 #include "ace/OS_NS_unistd.h"
  21
  22 // msec that times are allowed to differ before test fails.
  23 #if defined (ACE_HAS_HI_RES_TIMER) || \
  24     defined (ACE_HAS_PENTIUM) || \
  25     defined (ACE_HAS_POWERPC_TIMER)
  26 # define ACE_ALLOWED_SLACK 100
  27 #else  /* don't have a high-res timer */
  28 # define ACE_ALLOWED_SLACK 1100
  29 #endif /* don't have a high-res timer */
  30
  31 // Test results, 'success' is 0
  32 static int test_result = 0;
  33
  34 #if defined (ACE_HAS_THREADS)
  35
  36 // Semaphore used in the tests.  Start it "locked" (i.e., its initial
  37 // count is 0).
  38 static ACE_Thread_Semaphore s ((unsigned int) 0);
  39
  40 // Default number of iterations.
  41 static int n_iterations = 10;
  42
  43 // Number of worker threads.
  44 static size_t n_workers = 10;
  45
  46 // Amount to release the semaphore.
  47 static u_int n_release_count = 3;
  48
  49 // Number of timeouts.
  50 static size_t timeouts = 0;
  51
  52 // Number of times to call test_timeout ().
  53 static size_t test_timeout_count = 3;
  54
  55 // Tests the amount of time spent in a timed wait.
  56 static int
  57 test_timeout ()
  58 {
  59   int status = 0;
  60
  61   // milliseconds...
  62   long msecs_expected;
  63   long msecs_waited;
  64   long msecs_diff;
  65
  66   // Wait a little longer each time
  67   static long wait_secs = 3;
  68
  69   ACE_Time_Value wait = ACE_OS::gettimeofday ();
  70
  71   ACE_Time_Value begin = wait;
  72
  73   wait.sec (wait.sec () + wait_secs);
  74
  75   if (s.acquire (wait) == -1)
  76     {
  77       if (errno != ETIME)
  78         {
  79           ACE_ERROR ((LM_ERROR,
  80                       ACE_TEXT ("%p\n"),
  81                       ACE_TEXT ("test_timeout should be ETIME but is")));
  82           status = -1;
  83         }
  84     }
  85
  86   ACE_Time_Value wait_diff = ACE_OS::gettimeofday () - begin;
  87
  88   msecs_waited = wait_diff.msec ();
  89   msecs_expected = wait_secs * 1000;
  90   msecs_diff = labs (msecs_expected - msecs_waited);
  91
  92   if (msecs_diff > ACE_ALLOWED_SLACK)
  93     {
  94       ACE_ERROR ((LM_ERROR,
  95                   ACE_TEXT ("Timed wait fails length test\n")));
  96       ACE_ERROR ((LM_ERROR,
  97                   ACE_TEXT ("Expected %d ms, actual %d ms; %d allowed\n"),
  98                   (int)msecs_expected,
  99                   (int)msecs_waited,
 100                   (int)ACE_ALLOWED_SLACK));
 101       status = -1;
 102     }
 103
 104   ++wait_secs;
 105   return status;
 106 }
 107
 108 // Explain usage and exit.
 109 static void
 110 print_usage_and_die ()
 111 {
 112   ACE_DEBUG ((LM_DEBUG,
 113               ACE_TEXT ("usage: %n [-s n_release_count] [-w n_workers] [-n iteration_count]\n")));
 114   ACE_OS::exit (1);
 115 }
 116
 117 static void
 118 parse_args (int argc, ACE_TCHAR *argv[])
 119 {
 120   ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("s:w:n:"));
 121
 122   int c;
 123
 124   while ((c = get_opt ()) != -1)
 125     switch (c)
 126     {
 127     case 's':
 128       n_release_count = ACE_OS::atoi (get_opt.opt_arg ());
 129       break;
 130     case 'w':
 131       n_workers = ACE_OS::atoi (get_opt.opt_arg ());
 132       break;
 133     case 'n':
 134       n_iterations = ACE_OS::atoi (get_opt.opt_arg ());
 135       break;
 136     default:
 137       print_usage_and_die ();
 138       break;
 139   }
 140 }
 141
 142 // Worker tries to acquire the semaphore, hold it for a while, and
 143 // then releases it.
 144
 145 static void *
 146 worker (void *)
 147 {
 148   for (int iterations = 1;
 149        iterations <= n_iterations;
 150        iterations++)
 151     {
 152       //FUZZ: disable check_for_lack_ACE_OS
 153       ACE_Time_Value wait (0,
 154                            iterations * 1000 * 100);  // Wait 'iter' msec
 155       //FUZZ: enable check_for_lack_ACE_OS
 156
 157       ACE_Time_Value tv = ACE_OS::gettimeofday () + wait;
 158       if (s.acquire (tv) == -1)
 159       {
 160           // verify that we have ETIME
 161           if (ACE_OS::last_error() != ETIME)
 162             {
 163               ACE_ERROR ((LM_ERROR,
 164                           ACE_TEXT ("%p\n"),
 165                           ACE_TEXT ("Worker should be ETIME but is")));
 166             }
 167           else
 168             ++timeouts;
 169           ACE_Time_Value diff = ACE_OS::gettimeofday ();
 170           diff = diff - tv;       // tv should have been reset to time acquired
 171           long diff_msec = diff.msec ();
 172
 173           if (diff_msec > ACE_ALLOWED_SLACK)
 174             {
 175               ACE_ERROR ((LM_ERROR,
 176                           ACE_TEXT ("Acquire fails time reset test\n")));
 177               ACE_ERROR ((LM_ERROR,
 178                           ACE_TEXT ("Diff btw now and returned time: %d ms; ")
 179                           ACE_TEXT ("%d allowed\n"),
 180                           (int)diff_msec,
 181                           (int)ACE_ALLOWED_SLACK));
 182               test_result = 1;
 183             }
 184           // Hold the lock for a while.
 185           ACE_OS::sleep (ACE_Time_Value (0,
 186                                          (ACE_OS::rand () % 1000) * 1000));
 187           s.release ();
 188         }
 189       ACE_Thread::yield ();
 190     }
 191
 192   return 0;
 193 }
 194
 195 #endif /* ACE_HAS_THREADS */
 196
 197 // Test semaphore functionality.
 198
 199 int run_main (int argc, ACE_TCHAR *argv[])
 200 {
 201   ACE_START_TEST (ACE_TEXT ("Semaphore_Test"));
 202
 203 #if defined (ACE_HAS_THREADS)
 204   parse_args (argc, argv);
 205   ACE_OS::srand ((u_int) ACE_OS::time (0L));
 206
 207   //Test timed waits.
 208   for (size_t i = 0; i < test_timeout_count; i++)
 209     if (test_timeout () != 0)
 210       test_result = 1;
 211
 212   // Release the semaphore a certain number of times.
 213   s.release (n_release_count);
 214
 215   if (ACE_Thread_Manager::instance ()->spawn_n
 216       (static_cast<size_t> (n_workers),
 217        ACE_THR_FUNC (worker),
 218        0,
 219        THR_NEW_LWP) == -1)
 220     ACE_ERROR_RETURN ((LM_ERROR,
 221                        ACE_TEXT ("%p\n"),
 222                        ACE_TEXT ("spawn_n")),
 223                       1);
 224
 225   ACE_Thread_Manager::instance ()->wait ();
 226
 227   size_t percent = (timeouts * 100) / (n_workers * n_iterations);
 228
 229   ACE_DEBUG ((LM_DEBUG,
 230               ACE_TEXT ("Worker threads timed out %d percent of the time\n"),
 231               (int)percent));
 232
 233   if (test_result == 0)
 234     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Semaphore Test successful\n")));
 235 #else
 236   ACE_UNUSED_ARG (argc);
 237   ACE_UNUSED_ARG (argv);
 238   ACE_ERROR ((LM_INFO,
 239               ACE_TEXT ("Threads not supported on this platform\n")));
 240 #endif /* ACE_HAS_THREADS */
 241   ACE_END_TEST;
 242   return test_result;
 243 }