ACE/tests/Atomic_Op_Test.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    Atomic_Op_Test.cpp
   5  *
   6  *    This is a simple test of the Atomic Operations Class in ACE.
   7  *    On platforms like Win32, ACE uses template specialization to
   8  *    use native implementations provided by the OS to accelarate
   9  *    these operations.
  10  *
  11  *  @author Irfan Pyarali <irfan@cs.wustl.edu>
  12  */
  13 //=============================================================================
  14
  15
  16 #include "test_config.h"
  17
  18 #include "ace/Atomic_Op.h"
  19 #include "ace/Synch_Traits.h"
  20 #include "ace/Time_Value.h"
  21 #include "ace/OS_NS_sys_time.h"
  22 #include "ace/Barrier.h"
  23 #include "ace/Task.h"
  24
  25
  26 /*
  27  * Exchange_Test tests the exchange() operation in ACE_Atomic_Op. It runs
  28  * a number of threads and each tries to "claim" the op_ by exchanging it
  29  * with '1'. Only one thread should do this. The claimed_ member counts
  30  * the number of threads that actually do claim it.
  31  */
  32 template <typename T>
  33 class Exchange_Tester : public ACE_Task<ACE_NULL_SYNCH>
  34 {
  35 public:
  36   Exchange_Tester (unsigned int thr_count);
  37   int result () const;
  38
  39 private:
  40   Exchange_Tester () {}
  41   int svc () override;
  42
  43   ACE_Barrier barrier_;
  44   ACE_Atomic_Op<ACE_SYNCH_MUTEX, T> op_;
  45   ACE_Atomic_Op<ACE_SYNCH_MUTEX, int> claimed_;
  46 };
  47
  48 template <typename T>
  49 Exchange_Tester<T>::Exchange_Tester (unsigned int thr_count)
  50   : barrier_(thr_count), op_ (0), claimed_ (0)
  51 {
  52   this->activate (THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED,
  53                   (int)thr_count);
  54 }
  55
  56 template <typename T>
  57 int
  58 Exchange_Tester<T>::result () const
  59 {
  60   return this->claimed_ == 1 ? 0 : 1;
  61 }
  62
  63 template <typename T>
  64 int
  65 Exchange_Tester<T>::svc ()
  66 {
  67   this->barrier_.wait ();     // Want all threads to try to claim "at once"
  68   bool claimed = this->op_.exchange (1) == 0;
  69   ACE_DEBUG ((LM_DEBUG,
  70               ACE_TEXT ("Thread %t %s claim.\n"),
  71               claimed ? ACE_TEXT ("DID") : ACE_TEXT ("DID NOT")));
  72   if (claimed)
  73     ++this->claimed_;
  74   return 0;
  75 }
  76
  77
  78 template <typename TYPE, typename dummy>
  79 int test (const ACE_TCHAR* type, int iterations)
  80 {
  81   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Measuring %d iterations for %s\n"), iterations, type));
  82
  83   int retval = 0;
  84   ACE_Atomic_Op <ACE_SYNCH_MUTEX, TYPE> foo (5);
  85
  86   ACE_TEST_ASSERT (foo == 5);
  87
  88   TYPE result = ++foo;
  89   ACE_TEST_ASSERT (foo == 6);
  90   ACE_TEST_ASSERT (result == 6);
  91
  92   result = --foo;
  93   ACE_TEST_ASSERT (foo == 5);
  94   ACE_TEST_ASSERT (result == 5);
  95
  96   result = foo++;
  97   ACE_TEST_ASSERT (foo == 6);
  98   ACE_TEST_ASSERT (result == 5);
  99
 100   result = foo--;
 101   ACE_TEST_ASSERT (foo == 5);
 102   ACE_TEST_ASSERT (result == 6);
 103
 104   result = foo += 10;
 105   ACE_TEST_ASSERT (foo == 15);
 106   ACE_TEST_ASSERT (result == 15);
 107
 108   result = foo -= 10;
 109   ACE_TEST_ASSERT (foo == 5);
 110   ACE_TEST_ASSERT (result == 5);
 111
 112   foo = 7;
 113   ACE_TEST_ASSERT (foo == 7);
 114
 115   ACE_Atomic_Op <ACE_SYNCH_MUTEX, TYPE> foo2 (5);
 116   foo2 = foo;
 117   ACE_TEST_ASSERT (foo == 7);
 118   ACE_TEST_ASSERT (foo2 == 7);
 119
 120   ACE_UINT64 usec;
 121
 122   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting <%s> assignment %D\n"), type));
 123   ACE_Time_Value diff = ACE_OS::gettimeofday ();
 124   int i;
 125   for (i = 0; i < iterations; ++i)
 126     {
 127       foo = 1;
 128       foo = 2;
 129       foo = 3;
 130       foo = 4;
 131     }
 132   diff = ACE_OS::gettimeofday () - diff;
 133   diff.to_usec (usec);
 134   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Ending <%s> assignment %D, took %Q\n"), type, usec));
 135
 136   foo = 0;
 137
 138   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting <%s> prefix increment %D\n"), type));
 139   diff = ACE_OS::gettimeofday ();
 140   for (i = 0; i < iterations; ++i)
 141     {
 142       ++foo;
 143       ++foo;
 144       ++foo;
 145       ++foo;
 146     }
 147   diff = ACE_OS::gettimeofday () - diff;
 148   diff.to_usec (usec);
 149   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Ending <%s> prefix increment %D, took %Q\n"), type, usec));
 150
 151   if (foo != iterations * 4)
 152     {
 153       ++retval;
 154       ACE_ERROR ((LM_ERROR, ACE_TEXT ("Error: Prefix increment failed\n")));
 155     }
 156
 157   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting <%s> prefix decrement %D\n"), type));
 158   diff = ACE_OS::gettimeofday ();
 159   for (i = 0; i < iterations; ++i)
 160     {
 161       foo--;
 162       foo--;
 163       foo--;
 164       foo--;
 165     }
 166   diff = ACE_OS::gettimeofday () - diff;
 167   diff.to_usec (usec);
 168   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Ending <%s> prefix decrement %D, took %Q\n"), type, usec));
 169
 170   if (foo != 0)
 171     {
 172       ++retval;
 173       ACE_ERROR ((LM_ERROR, ACE_TEXT ("Error: Prefix decrement failed\n")));
 174     }
 175
 176   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting <%s> postfix increment %D\n"), type));
 177   diff = ACE_OS::gettimeofday ();
 178   for (i = 0; i < iterations; ++i)
 179     {
 180       foo++;
 181       foo++;
 182       foo++;
 183       foo++;
 184     }
 185   diff = ACE_OS::gettimeofday () - diff;
 186   diff.to_usec (usec);
 187   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Ending <%s> postfix increment %D, took %Q\n"), type, usec));
 188
 189   if (foo != iterations * 4)
 190     {
 191       ++retval;
 192       ACE_ERROR ((LM_ERROR, ACE_TEXT ("Error: Postfix increment failed\n")));
 193     }
 194
 195   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting <%s> postfix decrement %D\n"), type));
 196   diff = ACE_OS::gettimeofday ();
 197   for (i = 0; i < iterations; ++i)
 198     {
 199       --foo;
 200       --foo;
 201       --foo;
 202       --foo;
 203     }
 204   diff = ACE_OS::gettimeofday () - diff;
 205   diff.to_usec (usec);
 206   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Ending <%s> postfix decrement %D, took %Q\n"), type, usec));
 207
 208   if (foo != 0)
 209     {
 210       ++retval;
 211       ACE_ERROR ((LM_ERROR, ACE_TEXT ("Error: Postfix decrement failed\n")));
 212     }
 213
 214   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting <%s> addition %D\n"), type));
 215   diff = ACE_OS::gettimeofday ();
 216   for (i = 0; i < iterations; ++i)
 217     {
 218       foo += 5;
 219       foo += 5;
 220       foo += 5;
 221       foo += 5;
 222     }
 223   diff = ACE_OS::gettimeofday () - diff;
 224   diff.to_usec (usec);
 225   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Ending <%s> addition %D, took %Q\n"), type, usec));
 226
 227   if (foo != iterations * 4 * 5)
 228     {
 229       ++retval;
 230       ACE_ERROR ((LM_ERROR, ACE_TEXT ("Error: Addition failed\n")));
 231      }
 232
 233   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting <%s> subtraction %D\n"), type));
 234   diff = ACE_OS::gettimeofday ();
 235   for (i = 0; i < iterations; ++i)
 236     {
 237       foo -= 5;
 238       foo -= 5;
 239       foo -= 5;
 240       foo -= 5;
 241     }
 242   diff = ACE_OS::gettimeofday () - diff;
 243   diff.to_usec (usec);
 244   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Ending <%s> subtraction %D, took %Q\n"), type, usec));
 245
 246   if (foo != 0)
 247     {
 248       ++retval;
 249       ACE_ERROR ((LM_ERROR, ACE_TEXT ("Error: Subtraction failed\n")));
 250     }
 251
 252   return retval;
 253 }
 254
 255 template <typename TYPE>
 256 int test (const ACE_TCHAR* type, int iterations)
 257 {
 258   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Measuring %d iterations for %s\n"), iterations, type));
 259
 260   ACE_UINT64 usec;
 261   int retval = 0;
 262   ACE_Atomic_Op <ACE_SYNCH_MUTEX, TYPE> foo (true);
 263
 264   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting <%s> assignment %D\n"), type));
 265   ACE_Time_Value diff = ACE_OS::gettimeofday ();
 266   int i;
 267   for (i = 0; i < iterations; ++i)
 268     {
 269       foo = true;
 270       foo = true;
 271       foo = true;
 272       foo = true;
 273     }
 274   diff = ACE_OS::gettimeofday () - diff;
 275   diff.to_usec (usec);
 276   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Ending <%s> assignment %D, took %Q\n"), type, usec));
 277
 278   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Starting <%s> comparison %D\n"), type));
 279   diff = ACE_OS::gettimeofday ();
 280   for (i = 0; i < iterations; ++i)
 281     {
 282       if (foo != true) ++retval;
 283       if (foo == false) ++retval;
 284       if (foo != true) ++retval;
 285       if (foo == false) ++retval;
 286     }
 287   diff = ACE_OS::gettimeofday () - diff;
 288   diff.to_usec (usec);
 289   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Ending <%s> comparison %D, took %Q\n"), type, usec));
 290
 291   return retval;
 292 }
 293
 294 int
 295 run_main (int, ACE_TCHAR *[])
 296 {
 297   ACE_START_TEST (ACE_TEXT ("Atomic_Op_Test"));
 298
 299   // Some platforms w/o builtin atomic ops time out the regression tests,
 300   // so run fewer iterations there.
 301 #if defined (ACE_HAS_BUILTIN_ATOMIC_OP)
 302   const int ITERATIONS = 1000000;
 303 #else
 304   const int ITERATIONS = 100000;
 305 #endif /* ACE_HAS_BUILTIN_ATOMIC_OP */
 306
 307   int retval = 0;
 308
 309   retval += test <int, int> (ACE_TEXT("int"), ITERATIONS);
 310   retval += test <long, int> (ACE_TEXT("long"), ITERATIONS);
 311   retval += test <unsigned int, int> (ACE_TEXT("unsigned int"), ITERATIONS);
 312   retval += test <unsigned long, int> (ACE_TEXT("unsigned long"), ITERATIONS);
 313   retval += test <short, int> (ACE_TEXT("short"), ITERATIONS);
 314   retval += test <unsigned short, int> (ACE_TEXT("unsigned short"), ITERATIONS);
 315   retval += test <bool> (ACE_TEXT("bool"), ITERATIONS);
 316   retval += test <long long, int> (ACE_TEXT("long long"), ITERATIONS);
 317
 318 #if defined (ACE_HAS_THREADS)
 319   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing exchange with long\n")));
 320   Exchange_Tester<long> e1 (5);
 321   e1.wait ();
 322   retval += e1.result ();
 323
 324   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing exchange with unsigned long\n")));
 325   Exchange_Tester<unsigned long> e2 (5);
 326   e2.wait ();
 327   retval += e2.result ();
 328
 329   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Testing exchange with int\n")));
 330   Exchange_Tester<int> e3 (5);
 331   e3.wait ();
 332   retval += e3.result ();
 333
 334 #endif /* ACE_HAS_THREADS */
 335
 336   ACE_END_TEST;
 337   return retval;
 338 }
 339