ACE/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.cpp

   1 #define  ACE_BUILD_SVC_DLL
   2
   3 #include "Baseline_Test.h"
   4
   5 # if defined (ACE_HAS_THREADS)
   6
   7 #include "ace/OS_NS_unistd.h"
   8 #include "ace/Service_Repository.h"
   9 #include "ace/Get_Opt.h"
  10 #include "ace/Thread_Manager.h"
  11
  12 #if !defined (__ACE_INLINE__)
  13 #include "Baseline_Test.inl"
  14 #endif /* __ACE_INLINE__ */
  15
  16 Baseline_Test_Options baseline_options;
  17 // Static Baseline Options holds the test configuration information
  18 // and the test statistics.
  19
  20 Baseline_Test_Base::Baseline_Test_Base ()
  21   : Benchmark_Base (Benchmark_Base::BASELINE),
  22     yield_method_ (Baseline_Test_Options::USE_SLEEP_ZERO),
  23     iteration_ (DEFAULT_ITERATIONS),
  24     what_(TEST_LOCK)
  25 {
  26 }
  27
  28 int
  29 Baseline_Test_Base::init (int argc, ACE_TCHAR *argv[])
  30 {
  31   return this->parse_args (argc, argv);
  32 }
  33
  34 int
  35 Baseline_Test_Base::parse_args (int argc, ACE_TCHAR *argv[])
  36 {
  37   ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("i:ylrw"), 0);
  38   int c;
  39
  40   while ((c = get_opt ()) != -1)
  41     switch (c)
  42       {
  43       case 'i':                 // Total iterations
  44         {
  45           int tmp = ACE_OS::atoi (get_opt.opt_arg ());
  46           if (tmp <= 0)
  47             ACE_ERROR_RETURN ((LM_ERROR,
  48                                "%d is not a valid value for iteration\n",
  49                                tmp), -1);
  50           else
  51             this->iteration_ = static_cast<size_t> (tmp);
  52         }
  53         break;
  54
  55       case 'y':                 // Use thr_yield.
  56         this->yield_method_ = Baseline_Test_Options::USE_THR_YIELD;
  57         break;
  58
  59       case 'l':
  60         this->what_ = TEST_LOCK;
  61         break;
  62
  63       case 'r':
  64         this->what_ = TEST_READLOCK;
  65         break;
  66
  67       case 'w':
  68         this->what_ = TEST_WRITELOCK;
  69         break;
  70
  71       default:
  72         ACE_ERROR ((LM_ERROR, "Invalid argument %c used\n", c));
  73         break;
  74       }
  75   return 0;
  76 }
  77
  78 void
  79 Baseline_Test_Base::yield ()
  80 {
  81   if (this->yield_method_ == Baseline_Test_Options::USE_SLEEP_ZERO)
  82     ACE_OS::sleep (0);
  83   else
  84     ACE_OS::thr_yield ();
  85 }
  86
  87 Baseline_Test_Options::Baseline_Test_Options ()
  88   : test_try_lock_ (0),
  89     verbose_ (0),
  90     current_yield_method_ (0),
  91     current_iteration_ (0),
  92     total_iteration_ (DEFAULT_ITERATIONS)
  93 {
  94 }
  95
  96 int
  97 Baseline_Test_Options::parse_args (int argc, ACE_TCHAR *argv[])
  98 {
  99   //FUZZ: disable check_for_lack_ACE_OS
 100   ACE_Get_Opt getopt (argc, argv, ACE_TEXT("tv"), 0);
 101   int c;
 102
 103   while ((c = getopt ()) != -1)
 104   //FUZZ: enable check_for_lack_ACE_OS
 105     switch (c)
 106       {
 107       case 't':
 108         this->test_try_lock_ = 1;
 109         break;
 110
 111       case 'v':
 112         this->verbose_ = 1;
 113         break;
 114
 115       default:
 116         ACE_ERROR ((LM_ERROR, "Invalid arguemnt %c used.\n", c));
 117         break;
 118       }
 119   return 0;
 120 }
 121
 122 int
 123 Baseline_Test_Options::reset_params (size_t iteration,
 124                                      int yield)
 125 {
 126   this->current_iteration_ = 0;
 127   this->timer.reset ();
 128
 129   this->current_yield_method_ = yield;
 130   this->total_iteration_ = iteration;
 131   return 0;
 132 }
 133
 134 void
 135 Baseline_Test_Options::print_result ()
 136 {
 137   ACE_Time_Value tv;
 138   ACE_hrtime_t nsec;
 139
 140   this->timer.elapsed_time_incr (tv);
 141   this->timer.elapsed_time_incr (nsec);
 142   ACE_DEBUG ((LM_DEBUG,
 143               "Total Time: %d sec %d usec for a "
 144               "total of %d iterations\n"
 145               "Average time: %d nanoseconds.\n",
 146               tv.sec (), tv.usec (),
 147               this->current_iteration_,
 148               (int) (nsec / this->current_iteration_)));
 149 }
 150
 151 Baseline_Test::Baseline_Test ()
 152   : current_test_ (0),
 153     get_lock_ (2),
 154     let_go_lock_ (2)
 155 {
 156 }
 157
 158 // Initialize and run the benchmarks tests.
 159
 160 int
 161 Baseline_Test::init (int argc, ACE_TCHAR **argv)
 162 {
 163   return baseline_options.parse_args (argc, argv);
 164 }
 165
 166 int
 167 Baseline_Test::pre_run_test (Benchmark_Base *bb)
 168 {
 169   this->current_test_ = (Baseline_Test_Base *) bb;
 170   baseline_options.reset_params (this->current_test_->iteration (),
 171                                  this->current_test_->yield_method ());
 172   if (baseline_options.test_try_lock ())
 173     {
 174       ACE_Thread_Manager::instance ()->spawn
 175         (ACE_THR_FUNC (Baseline_Test::hold_lock),
 176          (void *) this);
 177
 178       this->get_lock_.wait ();
 179       // Wait until the lock is held by the spawning thread.
 180     }
 181
 182   return 0;
 183 }
 184
 185 int
 186 Baseline_Test::run_test ()
 187 {
 188   if (baseline_options.test_try_lock ())
 189     return this->current_test_->test_try_lock ();
 190   else
 191     return this->current_test_->test_acquire_release ();
 192 }
 193
 194 int
 195 Baseline_Test::post_run_test ()
 196 {
 197   if (baseline_options.test_try_lock ())
 198     {
 199       // Release the lock we hold.
 200       this->let_go_lock_.wait ();
 201
 202       ACE_Thread_Manager::instance ()->wait ();
 203     }
 204
 205   baseline_options.print_result ();
 206
 207   return 0;
 208 }
 209
 210 int
 211 Baseline_Test::valid_test_object (Benchmark_Base *bb)
 212 {
 213   return (bb->benchmark_type () == Benchmark_Base::BASELINE);
 214 }
 215
 216 void *
 217 Baseline_Test::hold_lock (void *arg)
 218 {
 219   Baseline_Test *this_test = (Baseline_Test *) arg;
 220   this_test->current_test_->acquire ();
 221   this_test->get_lock_.wait ();
 222
 223   this_test->let_go_lock_.wait ();
 224   return 0;
 225 }
 226
 227 ACE_SVC_FACTORY_DEFINE (Baseline_Test)
 228
 229 #endif  /* ACE_HAS_THREADS */