*** empty log message ***

8 files changed, 210 insertions, 89 deletions

diff --git a/performance-tests/Synch-Benchmarks/Base_Test/Base_Test.dsp b/performance-tests/Synch-Benchmarks/Base_Test/Base_Test.dsp
index 5a9e91df41e..7e5e1c77b49 100644
--- a/performance-tests/Synch-Benchmarks/Base_Test/Base_Test.dsp
+++ b/performance-tests/Synch-Benchmarks/Base_Test/Base_Test.dsp
@@ -94,6 +94,10 @@ LINK32=link.exe
 

 SOURCE=.\Baseline_Test.cpp

 # End Source File

+# Begin Source File

+

+SOURCE=.\mutex_test.cpp

+# End Source File

 # End Group

 # Begin Group "Header Files"

 

diff --git a/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.cpp b/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.cpp
index a8079fe061f..3d1bb993e8c 100644
--- a/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.cpp
+++ b/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.cpp
@@ -11,61 +11,30 @@
 #include "Baseline_Test.i"
 #endif /* __ACE_INLINE__ */
 
-ACE_RCSID(Synch_Benchmarks, Benchmark_Baseline, "$Id$")
+ACE_RCSID(Synch_Benchmarks, Baseline_Test, "$Id$")
 
-Baseline_Options baseline_options;
+Baseline_Test_Options baseline_options;
 // Static Baseline Options holds the test configuration information
 // and the test statistics.
 
-Benchmark_Baseline_Test_Base::Benchmark_Baseline_Test_Base (void)
-  : Benchmark_Base (Benchmark_Base::BASELINE)
+Baseline_Test_Base::Baseline_Test_Base (void)
+  : multiply_factor_ (0),
+    iteration_ (0),
+    Benchmark_Base (Benchmark_Base::BASELINE)
 {
 }
 
 int
-Benchmark_Baseline_Test_Base::init (int argc, char *argv[])
-{
-  return baseline_options.parse_test_args (argc, argv);
-}
-
-Baseline_Options::Baseline_Options (void)
-  : test_try_lock_ (0),
-    multiply_factor_ (10),
-    iteration_ (10000)
+Baseline_Test_Base::init (int argc, char *argv[])
 {
+  return this->parse_args (argc, argv);
 }
 
 int
-Baseline_Options::parse_method_args (int argc, char *argv[])
+Baseline_Test_Base::parse_args (int argc, char *argv[])
 {
-  ACE_Get_Opt getopt (argc, argv, "t");
-  char c;
-
-  while ((c = getopt ()) != -1)
-    switch (c)
-      {
-      case 't':
-        this->test_try_lock_ = 1;
-        break;
-
-      default:
-        ACE_ERROR ((LM_ERROR, "Invalid arguemnt %c used.\n", c));
-        break;
-      }
-  return 0;
-}
-
-int
-Baseline_Options::parse_test_args (int argc, char *argv[])
-{
-  this->total_iteration_ = 0;
-  this->real_ = 0;
-  this->system_ = 0;
-  this->user_ = 0;
-  // Start a new test, reset statistic info.
-
-  ACE_Get_Opt getopt (argc, argv, "m:i:");
-  char c;
+  ACE_Get_Opt getopt (argc, argv, "m:i:", 0);
+  int c;
 
   while ((c = getopt ()) != -1)
     switch (c)
@@ -101,7 +70,59 @@ Baseline_Options::parse_test_args (int argc, char *argv[])
   return 0;
 }
 
-Benchmark_Baseline::Benchmark_Baseline (void)
+Baseline_Test_Options::Baseline_Test_Options (void)
+  : test_try_lock_ (0),
+    verbose_ (0),
+    multiply_factor_ (10),
+    iteration_ (10000)
+{
+}
+
+int
+Baseline_Test_Options::parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt getopt (argc, argv, "tv", 0);
+  int c;
+
+  while ((c = getopt ()) != -1)
+    switch (c)
+      {
+      case 't':
+        this->test_try_lock_ = 1;
+        break;
+
+      case 'v':
+        this->verbose_ = 1;
+        break;
+
+      default:
+        ACE_ERROR ((LM_ERROR, "Invalid arguemnt %c used.\n", c));
+        break;
+      }
+  return 0;
+}
+
+int
+Baseline_Test_Options::reset_params (size_t multiply, size_t iteration)
+{
+  this->total_iteration_ = 0;
+  this->real_ = 0;
+  this->system_ = 0;
+  this->user_ = 0;
+  // Start a new test, reset statistic info.
+
+  this->multiply_factor_ = multiply;
+  this->iteration_ = iteration;
+  return 0;
+}
+
+void
+Baseline_Test_Options::print_result (void)
+{
+  ACE_DEBUG ((LM_DEBUG, "Baseline_Test_Options::print_result (void)\n"));
+}
+
+Baseline_Test::Baseline_Test (void)
   : current_test_ (0),
     get_lock_ (2),
     let_go_lock_ (2)
@@ -111,59 +132,69 @@ Benchmark_Baseline::Benchmark_Baseline (void)
 // Initialize and run the benchmarks tests.
 
 int
-Benchmark_Baseline::init (int argc, char **argv)
+Baseline_Test::init (int argc, char **argv)
 {
-  return baseline_options.parse_method_args (argc, argv);
+  return baseline_options.parse_args (argc, argv);
 }
 
 int
-Benchmark_Baseline::pre_run_test (Benchmark_Base *bb)
+Baseline_Test::pre_run_test (Benchmark_Base *bb)
 {
-  this->current_test_ = (Benchmark_Baseline_Test_Base *) bb;
+  this->current_test_ = (Baseline_Test_Base *) bb;
+  baseline_options.reset_params (this->current_test_->multiply_factor (),
+                                 this->current_test_->iteration ());
 
   if (baseline_options.test_try_lock ())
     {
       ACE_Thread_Manager::instance ()->spawn
-        (ACE_THR_FUNC (Benchmark_Baseline::hold_lock),
+        (ACE_THR_FUNC (Baseline_Test::hold_lock),
          (void *) this);
 
       this->get_lock_.wait ();
       // Wait until the lock is held by the spawning thread.
     }
+
+  ACE_DEBUG ((LM_DEBUG, "Pre_run_test\n"));
+
   return 0;
 }
 
 int
-Benchmark_Baseline::run_test (void)
+Baseline_Test::run_test (void)
 {
-  return -1;
+  ACE_DEBUG ((LM_DEBUG, "calling Baseline_Test::run_test\n"));
+  return 0;
 }
 
 int
-Benchmark_Baseline::post_run_test (void)
+Baseline_Test::post_run_test (void)
 {
   if (baseline_options.test_try_lock ())
-    // Release the lock we hold.
-    this->let_go_lock_.wait ();
+    {
+      // Release the lock we hold.
+      this->let_go_lock_.wait ();
+
+      ACE_Thread_Manager::instance ()->wait ();
+    }
 
-  ACE_Thread_Manager::instance ()->wait ();
+  baseline_options.print_result ();
 
   return 0;
 }
 
 int
-Benchmark_Baseline::valid_test_object (Benchmark_Base *bb)
+Baseline_Test::valid_test_object (Benchmark_Base *bb)
 {
   return (bb->benchmark_type () == Benchmark_Base::BASELINE);
 }
 
 void *
-Benchmark_Baseline::hold_lock (void *arg)
+Baseline_Test::hold_lock (void *arg)
 {
-  Benchmark_Baseline *this_test = (Benchmark_Baseline *) arg;
+  Baseline_Test *this_test = (Baseline_Test *) arg;
 
   ACE_UNUSED_ARG (this_test);
   return 0;
 }
 
-ACE_SVC_FACTORY_DEFINE (Benchmark_Baseline)
+ACE_SVC_FACTORY_DEFINE (Baseline_Test)
diff --git a/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.h b/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.h
index 5753646018c..6d51baad452 100644
--- a/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.h
+++ b/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.h
@@ -8,7 +8,7 @@
 
 #include "Synch_Lib/Benchmark_Base.h"
 
-class ACE_Svc_Export Benchmark_Baseline_Test_Base : public Benchmark_Base
+class ACE_Svc_Export Baseline_Test_Base : public Benchmark_Base
 {
   // = TITLE
   //     This class identifies itself as Benmarking Performance Test class.
@@ -16,6 +16,9 @@ public:
   virtual int init (int argc, char *argv[]);
   // Standard initializing method for Baseline Test.
 
+  int parse_args (int argc, char *argv[]);
+  // Parsing the svc.conf file arguments.
+
   virtual int acquire () = 0;
   virtual int release () = 0;
   // These two method are used to test try_acquire performance.
@@ -24,21 +27,35 @@ public:
   virtual int test_try_lock () = 0;
   // Real test methods.
 
+  size_t multiply_factor (void);
+  size_t iteration (void);
+  // Access methods.
+
 protected:
-  Benchmark_Baseline_Test_Base (void);
+  Baseline_Test_Base (void);
+
+  size_t multiply_factor_;
+  // Number of operations before yielding to other threads.
+
+  size_t iteration_;
+  // Total number of operations.  <iterations_> <= <multiply_factor_> * n
 };
 
-class ACE_Svc_Export Baseline_Options
+class ACE_Svc_Export Baseline_Test_Options
 {
+  // = TITLE
+  //    This class holds the global settings for Baseline Test.
 public:
-  Baseline_Options (void);
+  friend class Baseline_Test;
+
+  Baseline_Test_Options (void);
   // ctor.
 
-  int parse_method_args (int argc, char *argv[]);
-  // Parse and set the Benchmark_Baseline options and flags.
+  int parse_args (int argc, char *argv[]);
+  // Parse and set the Baseline_Test options and flags.
 
-  int parse_test_args (int argc, char *argv[]);
-  // Parse and set the
+  int reset_params (size_t mulply_factor, size_t iteration);
+  // Reset test parameters for next round.
 
   int test_try_lock (void);
   // Return test configuration.
@@ -55,7 +72,7 @@ public:
   size_t iteration (void);
   // Return <iteration_>.
 
-  size_t print_result (void);
+  void print_result (void);
   // Print out the result.
 
 private:
@@ -63,6 +80,9 @@ private:
   // A flag indicates whether we are testing try_lock or lock and
   // release.
 
+  int verbose_;
+  // Print out the result in verbose mode.
+
   size_t multiply_factor_;
   // Number loop before performing thread yield.
 
@@ -79,13 +99,13 @@ private:
   // Profile timer result.
 };
 
-extern Baseline_Options baseline_options;
+extern Baseline_Test_Options baseline_options;
 
-class ACE_Svc_Export Benchmark_Baseline : public Benchmark_Method_Base
+class ACE_Svc_Export Baseline_Test : public Benchmark_Method_Base
 {
 public:
-  Benchmark_Baseline (void);
-  int init (int argc, char **argv);
+  Baseline_Test (void);
+  virtual int init (int argc, char *argv[]);
   virtual int pre_run_test (Benchmark_Base *bp);
   virtual int run_test (void);
   virtual int post_run_test (void);
@@ -96,12 +116,12 @@ public:
   // we test the performance of try lock.
 
 private:
-  Benchmark_Baseline_Test_Base *current_test_;
+  Baseline_Test_Base *current_test_;
   ACE_Barrier get_lock_;
   ACE_Barrier let_go_lock_;
 };
 
-ACE_SVC_FACTORY_DECLARE (Benchmark_Baseline)
+ACE_SVC_FACTORY_DECLARE (Baseline_Test)
 
 #if defined (__ACE_INLINE__)
 #include "Baseline_Test.i"
diff --git a/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.i b/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.i
index 4b27d6ed0da..5c389d87040 100644
--- a/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.i
+++ b/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.i
@@ -1,25 +1,37 @@
 // $Id$
 
+size_t
+Baseline_Test_Base::multiply_factor (void)
+{
+  return this->multiply_factor_;
+}
+
+size_t
+Baseline_Test_Base::iteration (void)
+{
+  return this->iteration_;
+}
+
 int
-Baseline_Options::test_try_lock (void)
+Baseline_Test_Options::test_try_lock (void)
 {
   return this->test_try_lock_;
 }
 
 size_t
-Baseline_Options::multiply_factor (void)
+Baseline_Test_Options::multiply_factor (void)
 {
   return this->multiply_factor_;
 }
 
 size_t
-Baseline_Options::iteration (void)
+Baseline_Test_Options::iteration (void)
 {
   return this->iteration_;
 }
 
 int
-Baseline_Options::add_time (ACE_Profile_Timer::ACE_Elapsed_Time &et)
+Baseline_Test_Options::add_time (ACE_Profile_Timer::ACE_Elapsed_Time &et)
 {
   this->real_ += et.real_time;
   this->system_ += et.system_time;
@@ -28,7 +40,7 @@ Baseline_Options::add_time (ACE_Profile_Timer::ACE_Elapsed_Time &et)
 }
 
 int
-Baseline_Options::inc_loop_counter (void)
+Baseline_Test_Options::inc_loop_counter (void)
 {
   this->total_iteration_ += this->multiply_factor_;
   return (this->total_iteration_ >= this->iteration_);
diff --git a/performance-tests/Synch-Benchmarks/Base_Test/mutex_test.cpp b/performance-tests/Synch-Benchmarks/Base_Test/mutex_test.cpp
new file mode 100644
index 00000000000..71c4e77bb60
--- /dev/null
+++ b/performance-tests/Synch-Benchmarks/Base_Test/mutex_test.cpp
@@ -0,0 +1,49 @@
+// $Id$
+
+#define ACE_BUILD_SVC_DLL
+
+#include "ace/Synch.h"
+#include "Baseline_Test.h"
+
+class ACE_Svc_Export Baseline_Mutex_Test : public Baseline_Test_Base
+{
+public:
+  virtual int acquire ();
+  virtual int release ();
+  // These two method are used to test try_acquire performance.
+
+  virtual int test_acquire_release ();
+  virtual int test_try_lock ();
+  // Real test methods.
+
+private:
+  ACE_Thread_Mutex lock_;
+  //
+};
+ACE_SVC_FACTORY_DECLARE (Baseline_Mutex_Test)
+
+int
+Baseline_Mutex_Test::acquire ()
+{
+  return this->lock_.acquire ();
+}
+
+int
+Baseline_Mutex_Test::release ()
+{
+  return this->lock_.release ();
+}
+
+int
+Baseline_Mutex_Test::test_acquire_release ()
+{
+  return 0;
+}
+
+int
+Baseline_Mutex_Test::test_try_lock ()
+{
+  return 0;
+}
+
+ACE_SVC_FACTORY_DEFINE (Baseline_Mutex_Test)
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test.cpp
index a123778ffc3..d013da6aa3f 100644
--- a/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test.cpp
+++ b/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test.cpp
@@ -21,6 +21,7 @@ Performance_Test::Performance_Test (void)
 int
 Performance_Test::init (int argc, char **argv)
 {
+  ACE_DEBUG ((LM_DEBUG, "Performance_Test::init\n"));
   performance_test_options.parse_args (argc, argv);
   return 0;
 }
@@ -79,13 +80,12 @@ Performance_Test::post_run_test (void)
 
   ACE_DEBUG ((LM_DEBUG, "------------------------------------------------------------------------\n"));
   ACE_DEBUG ((LM_DEBUG, "targ 0x%x (%s, %s, %s)\n"
-	     "n_lwps_orig = %d, n_lwps_set = %d, n_lwps_end = %d\n",
-	     performance_test_options.t_flags (),
-	     (performance_test_options.t_flags () & THR_DETACHED) ? "THR_DETACHED" : "Not Detached",
-	     (performance_test_options.t_flags () & THR_BOUND)	? "THR_BOUND"    : "Not Bound",
-	     (performance_test_options.t_flags () & THR_NEW_LWP)  ? "THR_NEW_LWP"  : "No New_LWP",
-	     this->orig_n_lwps_, this->n_lwps_, ACE_Thread::getconcurrency ()));
-
+              "n_lwps_orig = %d, n_lwps_set = %d, n_lwps_end = %d\n",
+              performance_test_options.t_flags (),
+              (performance_test_options.t_flags () & THR_DETACHED) ? "THR_DETACHED" : "Not Detached",
+              (performance_test_options.t_flags () & THR_BOUND) ? "THR_BOUND"    : "Not Bound",
+              (performance_test_options.t_flags () & THR_NEW_LWP)  ? "THR_NEW_LWP"  : "No New_LWP",
+              this->orig_n_lwps_, this->n_lwps_, ACE_Thread::getconcurrency ()));
   int count = performance_test_options.count ();
   float rate  = count / (float (performance_test_options.sleep_time ()));
 
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test.h b/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test.h
index 27c60d8cc9c..c6775cb5bbe 100644
--- a/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test.h
+++ b/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test.h
@@ -10,7 +10,7 @@ class ACE_Svc_Export Performance_Test : public Benchmark_Method_Base
 {
 public:
   Performance_Test (void);
-  int init (int argc, char **argv);
+  virtual int init (int argc, char *argv[]);
   virtual int pre_run_test (Benchmark_Base *bp);
   virtual int run_test (void);
   virtual int post_run_test (void);
diff --git a/performance-tests/Synch-Benchmarks/svc.conf b/performance-tests/Synch-Benchmarks/svc.conf
index 33677395aba..c06400e8a92 100644
--- a/performance-tests/Synch-Benchmarks/svc.conf
+++ b/performance-tests/Synch-Benchmarks/svc.conf
@@ -1,7 +1,12 @@
 # Dynamically configure all the tests
-dynamic Performance_Test Service_Object * Perf_Test/Perf_Test:_make_Performance_Test() "-s 3"
-dynamic SYSVSema_Test Service_Object * Perf_Test/Perf_Test:_make_SYSVSema_Test()
-dynamic Mutex_Test Service_Object * Perf_Test/Perf_Test:_make_Mutex_Test()
+
+dynamic Baseline_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Test() ""
+dynamic Baseline_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Mutex_Test() "-i 3"
+
+
+#dynamic Performance_Test Service_Object * Perf_Test/Perf_Test:_make_Performance_Test() "-s 3"
+#dynamic SYSVSema_Test Service_Object * Perf_Test/Perf_Test:_make_SYSVSema_Test()
+#dynamic Mutex_Test Service_Object * Perf_Test/Perf_Test:_make_Mutex_Test()
 #dynamic Adaptive_Mutex_Test Service_Object * Perf_Test/Perf_Test:_make_Adaptive_Mutex_Test()
 #dynamic Recursive_Lock_Test Service_Object * Perf_Test/Perf_Test:_make_Recursive_Lock_Test()
 #dynamic Adaptive_Recursive_Lock_Test Service_Object * Perf_Test/Perf_Test:_make_Adaptive_Recursive_Lock_Test()