This commit was manufactured by cvs2svn to create tag 'TAO-1_4_2'.TAO-1_4_2

128 files changed, 0 insertions, 17937 deletions

diff --git a/performance-tests/Misc/Misc.mpc b/performance-tests/Misc/Misc.mpc
deleted file mode 100644
index 94a3bea51b4..00000000000
--- a/performance-tests/Misc/Misc.mpc
+++ /dev/null
@@ -1,52 +0,0 @@
-// -*- MPC -*-
-// $Id$
-
-project(*basic_perf) : aceexe {
-  Source_Files {
-    basic_func.cpp
-    basic_perf.cpp
-  }
-}
-
-project(*childbirth_time) : aceexe {
-  Source_Files {
-    childbirth_time.cpp
-  }
-}
-
-project(*context_switch_time) : aceexe {
-  Source_Files {
-    context_switch_time.cpp
-  }
-}
-
-project(*test_mutex) : aceexe {
-  Source_Files {
-    test_mutex.cpp
-  }
-}
-
-project(*test_naming) : aceexe {
-  Source_Files {
-    test_naming.cpp
-  }
-}
-
-project(*test_singleton) : aceexe {
-  Source_Files {
-    test_singleton.cpp
-  }
-}
-
-project(*preempt) : aceexe {
-  Source_Files {
-    preempt.cpp
-  }
-}
-
-// May need to add an ace_obsolete_guard_class feature
-//project(*test_guard) : aceexe {
-//  Source_Files {
-//    test_guard.cpp
-//  }
-//}
diff --git a/performance-tests/Misc/basic_func.cpp b/performance-tests/Misc/basic_func.cpp
deleted file mode 100644
index 84943e0b22a..00000000000
--- a/performance-tests/Misc/basic_func.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-// $Id$
-
-#include "basic_func.h"
-
-ACE_RCSID(Misc, basic_func, "$Id$")
-
-int A, B, C, D, E, F;
-
-void
-func ()
-{
-  DO_SOMETHING
-}
-
-
-void
-Foo::func ()
-{
-  DO_SOMETHING
-}
-
-
-Foo_v::~Foo_v ()
-{
-}
-
-
-void
-Foo_v::func ()
-{
-  DO_SOMETHING
-}
-
-
-void
-Foo_v::v_func ()
-{
-  DO_SOMETHING
-}
-
-
-void
-Foo_d_v::v_func ()
-{
-  DO_SOMETHING
-}
-
-
-// EOF
diff --git a/performance-tests/Misc/basic_func.h b/performance-tests/Misc/basic_func.h
deleted file mode 100644
index dcb70bae5da..00000000000
--- a/performance-tests/Misc/basic_func.h
+++ /dev/null
@@ -1,77 +0,0 @@
-// $Id$
-
-// ============================================================================
-//
-// = LIBRARY
-//    performance-tests/Misc
-//
-// = FILENAME
-//    basic_func.h
-//
-// = DESCRIPTION
-//    For use with basic_perf.cpp.
-//
-// = AUTHOR
-//    David Levine
-//
-// ============================================================================
-
-#ifndef BASIC_FUNC_H
-#define BASIC_FUNC_H
-
-#include "ace/ACE.h"
-
-#if !defined (ACE_LACKS_PRAGMA_ONCE)
-# pragma once
-#endif /* ACE_LACKS_PRAGMA_ONCE */
-
-extern int A,B,C,D,E,F;
-
-// If your compiler optimizes away Empty_Iteration_Test::run (), then
-// #defining ACE_HAS_OPTIMIZED_NULL_FUNCTIONS may help produce more
-// reasonable numbers.
-#if defined (_MSC_VER)
-  // MSVC 5.0 needs it . . .
-# define ACE_HAS_OPTIMIZED_NULL_FUNCTIONS
-#endif /* _MSC_VER */
-
-#if defined (ACE_HAS_OPTIMIZED_NULL_FUNCTIONS)
-# define EXPR(R,A,B,C,D) (R=(A*B + C*D))
-# define DO_SOMETHING EXPR(A,B,EXPR(F,A,E,C,B),EXPR(B,F,A,D,E),EXPR(E,B,F,A,C));
-#else  /* ACE_HAS_OPTIMIZED_NULL_FUNCTIONS */
-# define DO_SOMETHING
-#endif /* ACE_HAS_OPTIMIZED_NULL_FUNCTIONS */
-
-
-// An external (global) function.
-void func ();
-
-
-// A class with no virtual functions.
-class Foo
-{
-  public:
-    void inline_func () { DO_SOMETHING }
-    void func ();
-};
-
-
-// A class with a virtual function.
-class Foo_v
-{
-  public:
-    virtual ~Foo_v ();
-    void inline_func () { DO_SOMETHING }
-    void func ();
-    virtual void v_func ();
-};
-
-
-// A derived class.
-class Foo_d_v : public Foo_v
-{
-  public:
-    virtual void v_func ();
-};
-
-#endif /* BASIC_FUNC_H */
diff --git a/performance-tests/Misc/basic_perf.cpp b/performance-tests/Misc/basic_perf.cpp
deleted file mode 100644
index c34adbceb9c..00000000000
--- a/performance-tests/Misc/basic_perf.cpp
+++ /dev/null
@@ -1,646 +0,0 @@
-// $Id$
-
-// ============================================================================
-//
-// = LIBRARY
-//    performance-tests/Misc
-//
-// = FILENAME
-//    basic_perf.cpp
-//
-// = DESCRIPTION
-//    Times various simple operations.
-//
-//    With Sun C++, use -O2: make CFLAGS="-mt -O2" BIN=basic_perf
-//    -fast seems to produce slower times.
-//
-// = AUTHOR
-//    David Levine
-//
-// ============================================================================
-
-#include "basic_func.h"
-#include "ace/High_Res_Timer.h"
-#include "ace/Get_Opt.h"
-#include "ace/OS_main.h"
-#include "ace/Log_Msg.h"
-#include "ace/OS_NS_stdlib.h"
-#include "ace/OS_NS_sys_utsname.h"
-
-ACE_RCSID(Misc, basic_perf, "$Id$")
-
-static const char usage [] = "[-? |\n"
-                             "            [-i <iterations> [1000000]]";
-
-// These are global.  They appear to bust the CPU cache, on an Ultra 2
-// w/Sun C++ 4.2.
-static u_int iterations = 1000000;
-Foo foo;
-Foo_v foo_v;
-
-inline
-void
-inline_func ()
-{
-  DO_SOMETHING
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// function per_iteration
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// Given an elapsed time in nanoseconds, returns the time per iteration
-// in microseconds.
-static
-inline
-double
-per_iteration (const ACE_hrtime_t elapsed /* nanoseconds */)
-{
-  double ms_per_iteration = (double) ACE_CU64_TO_CU32 (elapsed) / 1000.0 /
-                            (double) iterations;
-
-  // Don't print out "-0.000" or "-0.001" . . .
-  return -0.002 < ms_per_iteration  &&  ms_per_iteration < 0.0
-           ?  0.0
-           :  ms_per_iteration;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Basic_Test
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-class Basic_Test
-{
-public:
-  Basic_Test (ACE_High_Res_Timer &timer,
-              ACE_hrtime_t empty_iteration_time);
-  virtual ~Basic_Test (void);
-
-  virtual void run (void) = 0;
-
-  double iteration_time (void);
-
-  void print_iteration_time (const char *message);
-
-protected:
-  ACE_hrtime_t elapsed_time_;
-
-  void start_timing (void)
-  {
-    timer_.reset ();
-    timer_.start ();
-  }
-
-  void stop_timing (void)
-  {
-    timer_.stop ();
-    timer_.elapsed_time (elapsed_time_);
-  }
-
-private:
-  ACE_High_Res_Timer &timer_;
-  ACE_hrtime_t empty_iteration_time_;
-
-  // Require the timer reference.
-  Basic_Test (void);
-
-  // Force construction of independent instances by prohibiting copying.
-  Basic_Test (const Basic_Test &);
-  Basic_Test &operator= (const Basic_Test &);
-};
-
-Basic_Test::Basic_Test (ACE_High_Res_Timer &timer,
-                        ACE_hrtime_t empty_iteration_time)
-  : elapsed_time_ (0),
-    timer_ (timer),
-    empty_iteration_time_ (empty_iteration_time)
-{
-}
-
-Basic_Test::~Basic_Test (void)
-{
-}
-
-double
-Basic_Test::iteration_time (void)
-{
-  return per_iteration (elapsed_time_ > empty_iteration_time_  ?
-                          elapsed_time_ - empty_iteration_time_  :
-                          ACE_static_cast (ACE_hrtime_t, 0));
-}
-
-void
-Basic_Test::print_iteration_time (const char *message)
-{
-  ACE_DEBUG ((LM_INFO, "  %-41s %8.3f\n",
-              message,
-              this->iteration_time ()));
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Empty_Iteration_Test
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-class Empty_Iteration_Test : public Basic_Test
-{
-public:
-  Empty_Iteration_Test (ACE_High_Res_Timer &timer) : Basic_Test (timer, 0) {}
-  virtual ~Empty_Iteration_Test (void) {};
-
-  virtual void run (void);
-
-  ACE_hrtime_t empty_iteration_time (void) const
-    {
-      return elapsed_time_;
-    }
-
-private:
-  // Require the timer reference.
-  Empty_Iteration_Test (void);
-
-  // Force construction of independent instances by prohibiting copying.
-  Empty_Iteration_Test (const Empty_Iteration_Test &);
-  Empty_Iteration_Test &operator= (const Empty_Iteration_Test &);
-};
-
-void
-Empty_Iteration_Test::run (void)
-{
-  this->start_timing ();
-
-  for (u_int i = 0; i < iterations; ++i)
-    {
-      DO_SOMETHING
-    }
-
-  this->stop_timing ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Inline_Call_Test
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-class Inline_Call_Test : public Basic_Test
-{
-public:
-  Inline_Call_Test (ACE_High_Res_Timer &timer,
-                    ACE_hrtime_t empty_iteration_time)
-    : Basic_Test (timer, empty_iteration_time) {}
-  virtual ~Inline_Call_Test (void) {};
-
-  virtual void run (void);
-
-private:
-  // Require the timer reference.
-  Inline_Call_Test (void);
-
-  // Force construction of independent instances by prohibiting copying.
-  Inline_Call_Test (const Inline_Call_Test &);
-  Inline_Call_Test &operator= (const Inline_Call_Test &);
-};
-
-void
-Inline_Call_Test::run (void)
-{
-  this->start_timing ();
-
-  for (u_int i = 0; i < iterations; ++i)
-    inline_func ();
-
-  this->stop_timing ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Noninline_Call_Test
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-class Noninline_Call_Test : public Basic_Test
-{
-public:
-  Noninline_Call_Test (ACE_High_Res_Timer &timer,
-                       ACE_hrtime_t empty_iteration_time)
-    : Basic_Test (timer, empty_iteration_time) {}
-  virtual ~Noninline_Call_Test (void) {};
-
-  virtual void run (void);
-
-private:
-  // Require the timer reference.
-  Noninline_Call_Test (void);
-
-  // Force construction of independent instances by prohibiting copying.
-  Noninline_Call_Test (const Noninline_Call_Test &);
-  Noninline_Call_Test &operator= (const Noninline_Call_Test &);
-};
-
-void
-Noninline_Call_Test::run (void)
-{
-  this->start_timing ();
-
-  for (u_int i = 0; i < iterations; ++i)
-    func ();
-
-  this->stop_timing ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Inline_Member_Call_Test
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-class Inline_Member_Call_Test : public Basic_Test
-{
-public:
-  Inline_Member_Call_Test (ACE_High_Res_Timer &timer,
-                           ACE_hrtime_t empty_iteration_time)
-    : Basic_Test (timer, empty_iteration_time) {}
-  virtual ~Inline_Member_Call_Test (void) {};
-
-  virtual void run (void);
-
-private:
-  // Require the timer reference.
-  Inline_Member_Call_Test (void);
-
-  // Force construction of independent instances by prohibiting copying.
-  Inline_Member_Call_Test (const Inline_Member_Call_Test &);
-  Inline_Member_Call_Test &operator= (const Inline_Member_Call_Test &);
-};
-
-void
-Inline_Member_Call_Test::run (void)
-{
-  this->start_timing ();
-
-  for (u_int i = 0; i < iterations; ++i)
-    foo.inline_func ();
-
-  this->stop_timing ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Noninline_Member_Call_Test
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-class Noninline_Member_Call_Test : public Basic_Test
-{
-public:
-  Noninline_Member_Call_Test (ACE_High_Res_Timer &timer,
-                              ACE_hrtime_t empty_iteration_time)
-    : Basic_Test (timer, empty_iteration_time) {}
-  virtual ~Noninline_Member_Call_Test (void) {};
-
-  virtual void run (void);
-
-private:
-  // Require the timer reference.
-  Noninline_Member_Call_Test (void);
-
-  // Force construction of independent instances by prohibiting copying.
-  Noninline_Member_Call_Test (const Noninline_Member_Call_Test &);
-  Noninline_Member_Call_Test &operator= (const Noninline_Member_Call_Test &);
-};
-
-void
-Noninline_Member_Call_Test::run (void)
-{
-  this->start_timing ();
-
-  for (u_int i = 0; i < iterations; ++i)
-    foo.func ();
-
-  this->stop_timing ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Inline_Member_With_Virtual_Call_Test
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-class Inline_Member_With_Virtual_Call_Test : public Basic_Test
-{
-public:
-  Inline_Member_With_Virtual_Call_Test (ACE_High_Res_Timer &timer,
-                                        ACE_hrtime_t empty_iteration_time)
-    : Basic_Test (timer, empty_iteration_time) {}
-  virtual ~Inline_Member_With_Virtual_Call_Test (void) {};
-
-  virtual void run (void);
-
-private:
-  // Require the timer reference.
-  Inline_Member_With_Virtual_Call_Test (void);
-
-  // Force construction of independent instances by prohibiting copying.
-  Inline_Member_With_Virtual_Call_Test (
-    const Inline_Member_With_Virtual_Call_Test &);
-  Inline_Member_With_Virtual_Call_Test &operator= (
-    const Inline_Member_With_Virtual_Call_Test &);
-};
-
-void
-Inline_Member_With_Virtual_Call_Test::run (void)
-{
-  this->start_timing ();
-
-  for (u_int i = 0; i < iterations; ++i)
-    foo_v.inline_func ();
-
-  this->stop_timing ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Noninline_Member_With_Virtual_Call_Test
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-class Noninline_Member_With_Virtual_Call_Test : public Basic_Test
-{
-public:
-  Noninline_Member_With_Virtual_Call_Test (ACE_High_Res_Timer &timer,
-                                           ACE_hrtime_t empty_iteration_time)
-    : Basic_Test (timer, empty_iteration_time) {}
-  virtual ~Noninline_Member_With_Virtual_Call_Test (void) {};
-
-  virtual void run (void);
-
-private:
-  // Require the timer reference.
-  Noninline_Member_With_Virtual_Call_Test (void);
-
-  // Force construction of independent instances by prohibiting copying.
-  Noninline_Member_With_Virtual_Call_Test
-    (const Noninline_Member_With_Virtual_Call_Test &);
-  Noninline_Member_With_Virtual_Call_Test &operator=
-    (const Noninline_Member_With_Virtual_Call_Test &);
-};
-
-void
-Noninline_Member_With_Virtual_Call_Test::run (void)
-{
-  this->start_timing ();
-
-  for (u_int i = 0; i < iterations; ++i)
-    foo_v.func ();
-
-  this->stop_timing ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Virtual_Member_Optimizable_Call_Test
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-class Virtual_Member_Optimizable_Call_Test : public Basic_Test
-{
-public:
-  Virtual_Member_Optimizable_Call_Test (ACE_High_Res_Timer &timer,
-                                        ACE_hrtime_t empty_iteration_time)
-    : Basic_Test (timer, empty_iteration_time) {}
-  virtual ~Virtual_Member_Optimizable_Call_Test (void) {};
-
-  virtual void run (void);
-
-private:
-  // Require the timer reference.
-  Virtual_Member_Optimizable_Call_Test (void);
-
-  // Force construction of independent instances by prohibiting copying.
-  Virtual_Member_Optimizable_Call_Test (
-    const Virtual_Member_Optimizable_Call_Test &);
-  Virtual_Member_Optimizable_Call_Test &operator= (
-    const Virtual_Member_Optimizable_Call_Test &);
-};
-
-void
-Virtual_Member_Optimizable_Call_Test::run (void)
-{
-  Foo_v &fv_o = foo_v;
-
-  this->start_timing ();
-
-  for (u_int i = 0; i < iterations; ++i)
-    fv_o.v_func ();
-
-  this->stop_timing ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Virtual_Member_Call_Test
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-class Virtual_Member_Call_Test : public Basic_Test
-{
-public:
-  Virtual_Member_Call_Test (ACE_High_Res_Timer &timer,
-                            ACE_hrtime_t empty_iteration_time)
-    : Basic_Test (timer, empty_iteration_time) {}
-  virtual ~Virtual_Member_Call_Test (void) {};
-
-  virtual void run (void);
-
-private:
-  // Require the timer reference.
-  Virtual_Member_Call_Test (void);
-
-  // Force construction of independent instances by prohibiting copying.
-  Virtual_Member_Call_Test (const Virtual_Member_Call_Test &);
-  Virtual_Member_Call_Test &operator= (const Virtual_Member_Call_Test &);
-};
-
-void
-Virtual_Member_Call_Test::run (void)
-{
-  Foo_v *fv;
-
-  if (iterations < 2)
-    fv = new Foo_v;
-  else
-    fv = new Foo_d_v;
-
-  this->start_timing ();
-
-  for (u_int i = 0; i < iterations; ++i)
-    fv->v_func ();
-
-  this->stop_timing ();
-
-  delete fv;
-  fv = 0;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// function get_options
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-static
-unsigned int
-get_options (int argc, ACE_TCHAR *argv [])
-{
-  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("i:?"));
-  int opt;
-
-  while ((opt = get_opt ()) != EOF)
-    {
-      switch (opt)
-        {
-        case 'i':
-          {
-            int temp = ACE_OS::atoi (get_opt.opt_arg ());
-            if (temp > 0)
-              iterations = (u_int) temp;
-            else
-              {
-                ACE_DEBUG ((LM_ERROR, "%s: number of iterations must be > 0\n",
-                            argv [0]));
-                return 1;
-              }
-            break;
-          }
-        case '?':
-          ACE_DEBUG ((LM_INFO, "usage: %s %s\n", argv [0], usage));
-          ACE_OS::exit (0);
-          break;
-        default:
-          ACE_DEBUG ((LM_ERROR, "%s: unknown arg, %c\n", argv [0],
-                                (char) opt));
-          ACE_DEBUG ((LM_ERROR, "usage: %s %s\n", argv [0], usage));
-          return 1;
-        }
-    }
-
-  switch (argc - get_opt.opt_ind ())
-    {
-    case 0:
-      // OK
-      break;
-    default:
-      ACE_DEBUG ((LM_ERROR, "%s: too many arguments\n", argv [0]));
-      ACE_DEBUG ((LM_ERROR, "usage: %s %s\n", argv [0], usage));
-      return 1;
-    }
-
-  return 0;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// function main
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-int
-ACE_TMAIN (int argc, ACE_TCHAR *argv[])
-{
-  if (get_options (argc, argv))
-    ACE_OS::exit (-1);
-
-  ACE_utsname name;
-
-  if (ACE_OS::uname (&name) != -1)
-    ACE_DEBUG ((LM_INFO, "%s (%s), %s %s at %T\n",
-                name.nodename, name.machine, name.sysname, name.release));
-
-  ACE_DEBUG ((LM_INFO, "%u iterations\n", iterations));
-
-
-  // Use one timer for all the tests.  No particular reason why.
-  ACE_High_Res_Timer timer;
-
-  // Calculate the time for an "empty iteration", and subtract it
-  // from each test time.
-  ACE_hrtime_t iteration_time;
-
-  Empty_Iteration_Test empty_iteration_test (timer);
-  empty_iteration_test.run ();
-  ACE_DEBUG ((LM_INFO, "An empty iteration costs %8.3f microseconds.\n\n",
-              empty_iteration_test.iteration_time ()));
-  iteration_time = empty_iteration_test.empty_iteration_time ();
-
-
-  // Run the real tests . . .
-  Inline_Call_Test inline_call_test (timer, iteration_time);
-  inline_call_test.run ();
-
-  Noninline_Call_Test noninline_call_test (timer, iteration_time);
-  noninline_call_test.run ();
-
-  Inline_Member_Call_Test inline_member_call_test (timer, iteration_time);
-  inline_member_call_test.run ();
-
-  Noninline_Member_Call_Test noninline_member_call_test (
-      timer, iteration_time);
-  noninline_member_call_test.run ();
-
-  Inline_Member_With_Virtual_Call_Test
-    inline_member_with_virtual_call_test (timer, iteration_time);
-  inline_member_with_virtual_call_test.run ();
-
-  Noninline_Member_With_Virtual_Call_Test
-    noninline_member_with_virtual_call_test (timer, iteration_time);
-  noninline_member_with_virtual_call_test.run ();
-
-  Virtual_Member_Optimizable_Call_Test
-    virtual_member_optimizable_call_test (timer, iteration_time);
-  virtual_member_optimizable_call_test.run ();
-
-  Virtual_Member_Call_Test virtual_member_call_test (timer, iteration_time);
-  virtual_member_call_test.run ();
-
-
-  // Print results . . .
-  ACE_DEBUG ((LM_INFO, "operation                              "
-                  "time, microseconds\n"));
-  ACE_DEBUG ((LM_INFO, "=========                              "
-                  "=================="));
-
-  ACE_DEBUG ((LM_INFO, "\nglobal function calls:\n"));
-  inline_call_test.print_iteration_time ("inline function call");
-  noninline_call_test.print_iteration_time ("non-inline function call");
-
-  ACE_DEBUG ((LM_INFO, "\nmember function calls:\n"));
-  inline_member_call_test.print_iteration_time (
-    "inline member function call");
-  noninline_member_call_test.print_iteration_time (
-    "non-inline member function call");
-
-  ACE_DEBUG ((LM_INFO, "\nmember function calls, class has a virtual "
-                       "function:\n"));
-  inline_member_with_virtual_call_test.print_iteration_time (
-    "inline member function with virtual call");
-  noninline_member_with_virtual_call_test.print_iteration_time (
-    "non-inline member function w/virtual call");
-
-  ACE_DEBUG ((LM_INFO, "\nvirtual member function calls:\n"));
-  virtual_member_optimizable_call_test.print_iteration_time (
-    "virtual member function call, optimizable");
-  virtual_member_call_test.print_iteration_time (
-    "virtual member function call");
-
-  return 0;
-}
-
-
-// EOF
diff --git a/performance-tests/Misc/childbirth_time.cpp b/performance-tests/Misc/childbirth_time.cpp
deleted file mode 100644
index 308f3f97e48..00000000000
--- a/performance-tests/Misc/childbirth_time.cpp
+++ /dev/null
@@ -1,402 +0,0 @@
-// $Id$
-
-// ============================================================================
-//
-// = LIBRARY
-//    (none)
-//
-// = FILENAME
-//    childbirth_time.cpp
-//
-// = DESCRIPTION
-//   This program is used to measure various child-creation mechanisms
-//   on various platforms.  By default, the program measure the time
-//   to 'fork' a new process using ACE_Process.spawn ().  Other tests
-//   are possible as described below.   James Hu provides the idea to
-//   batch measuring threads creation.
-//
-//   Usage: childbirth_time [-n ###] [-l ###] [-p|-f|-t|-a|-m|-x] [-h] [-e]
-//
-//          -n ###: Specify number of iteration in tens.  If this
-//                  option is not specified, the default is
-//                  MULTIPLY_FACTOR * (100 iterations,) which is
-//                  equivalent to -n 10.
-//
-//          -l ###: Specify MULTIPLY_FACTOR.  Default is 10.
-//
-//             *-p: Measure the performance of forking a child process
-//                  and exec an "empty" program.  This test uses
-//                  ACE_Process.spawn ().  (Default)
-//
-//              -f: Measure the performance of native "fork" function
-//                  call.  Notice that there is no equivalent NT
-//                  function calls and this option is only available
-//                  on UN*X platform.
-//
-//              -t: Measure the performance of native thread creation
-//                  mechanisms.  On Solaris, this is thr_create ().
-//                  On NT, this is CreateThread ().  Currently, only
-//                  these two platforms are implemented.
-//
-//              -m: Measure the performance of Thread_Manager::spawn_n
-//                  method.
-//
-//              -x: Test the baseline performance of ACE_Thread_Mutex.
-//                  This really doesn't belong here
-//
-//              -a: Measure the performance of thread creation using
-//                  ACE_OS::thr_create ().
-//
-//              -h: Use High Resolution Timer if supported by platform.
-//
-//              -e: Exec a program after fork ().  This option has no
-//                  effect on NT.
-//
-//   = CREATION DATE
-//      June 29, 1997
-//
-//   = AUTHOR
-//      Nanbor Wang
-//
-// ============================================================================
-
-// Process Creation profiling
-
-#include "ace/OS_NS_unistd.h"
-#include "ace/OS_main.h"
-#include "ace/Get_Opt.h"
-#include "ace/Process.h"
-#include "ace/Profile_Timer.h"
-#include "ace/Thread_Manager.h"
-
-ACE_RCSID(Misc, childbirth_time, "$Id$")
-
-#define  ACE_STOP_SIGN  ACE_OS::sleep (0)
-
-#define MAX_NO_ITERATION  10000
-#if defined (ACE_WIN32)
-#define SUBPROGRAM "date.exe"
-#else
-#define SUBPROGRAM "date"
-#endif
-
-size_t MULTIPLY_FACTOR = 10;
-typedef double (*Profiler)(size_t);
-static int do_exec_after_fork = 0;
-
-/// do nothing thread function
-extern "C" void *ace_empty (void*)
-{
-  return 0;
-}
-
-static double
-prof_ace_process (size_t iteration)
-{
-  if (iteration != 0)
-    {
-      ACE_Process_Options popt;
-      ACE_Process aProcess;
-
-      popt.command_line (SUBPROGRAM);
-
-      iteration *= MULTIPLY_FACTOR;
-
-      if (do_exec_after_fork == 0)
-        popt.creation_flags (ACE_Process_Options::NO_EXEC);
-
-      ACE_Profile_Timer ptimer;
-      ACE_Profile_Timer::ACE_Elapsed_Time et;
-      double time = 0;
-      pid_t result;
-
-      for (size_t c = 0; c < iteration; c++)
-        {
-          ACE_STOP_SIGN;
-          ptimer.start ();
-          result = aProcess.spawn (popt);
-          ptimer.stop ();
-
-          if (result == -1)
-            ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "process.spawn"), -1);
-          else if (do_exec_after_fork == 0 && result == 0)
-            ACE_OS::exit (0) ;
-          else
-            {
-              ptimer.elapsed_time (et);
-              time += et.real_time;
-            }
-        }
-
-      return time / iteration;
-    }
-  else
-    return -1.0;
-}
-
-static double
-prof_fork (size_t iteration)
-{
-#if !defined (ACE_LACKS_EXEC)
-  if (iteration != 0)
-    {
-      ACE_Profile_Timer ptimer;
-      ACE_Profile_Timer::ACE_Elapsed_Time et;
-      double time = 0;
-
-      iteration *= MULTIPLY_FACTOR;
-
-      for (size_t i = 0; i < iteration; i++)
-        {
-          ACE_STOP_SIGN;
-          ptimer.start ();
-          switch (ACE_OS::fork ())
-            {
-            case -1:
-              ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "process.spawn"), -1);
-              /* NOTREACHED */
-            case 0:
-              exit (0);
-              /* NOTREACHED */
-              break;
-            default:
-              ptimer.stop ();
-              ptimer.elapsed_time (et);
-              time += et.real_time;
-            }
-        }
-      return time / iteration;
-    }
-  else
-    return -1.0;
-#else
-  ACE_UNUSED_ARG (iteration);
-  ACE_ERROR_RETURN ((LM_ERROR, "fork () is not supported on this platform."), -1);
-#endif
-}
-
-static double
-prof_native_thread (size_t iteration)
-{
-#if defined (ACE_HAS_THREADS)  && (defined (ACE_HAS_WTHREADS) || defined (ACE_HAS_STHREADS))
-  if (iteration != 0)
-    {
-      ACE_Profile_Timer ptimer;
-      ACE_Profile_Timer::ACE_Elapsed_Time et;
-      double time = 0;
-
-      for (size_t i = 0; i < iteration; i++)
-        {
-          ACE_STOP_SIGN;
-          ptimer.start ();
-          for (size_t j = 0; j < MULTIPLY_FACTOR; j++)
-            {
-#if defined (ACE_HAS_WTHREADS)
-              if (::CreateThread (0,
-                                  0,
-                                  LPTHREAD_START_ROUTINE (ace_empty),
-                                  0,
-                                  CREATE_SUSPENDED,
-                                  0) == 0)
-#elif defined (ACE_HAS_STHREADS)
-                if (::thr_create (0,
-                                  0,
-                                  &ace_empty,
-                                  0,
-                                  THR_SUSPENDED,
-                                  0) != 0)
-#endif
-                  ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "CreateThread"), -1);
-            }
-          ptimer.stop ();
-          ptimer.elapsed_time (et);
-          time += et.real_time;
-        }
-      iteration *= MULTIPLY_FACTOR;
-      return time / iteration;
-    }
-  else
-    return -1.0;
-#else
-  ACE_UNUSED_ARG (iteration);
-  ACE_ERROR_RETURN ((LM_ERROR, "Testing of native threads is not supported on this platform.\n"), -1);
-#endif
-}
-
-static double
-prof_ace_os_thread (size_t iteration)
-{
-#if defined (ACE_HAS_THREADS)
-  if (iteration != 0)
-    {
-      ACE_Profile_Timer ptimer;
-      ACE_Profile_Timer::ACE_Elapsed_Time et;
-      double time = 0;
-
-      for (size_t i = 0; i < iteration; i++)
-        {
-          ACE_STOP_SIGN;
-          ptimer.start ();
-
-          for (size_t j = 0; j < MULTIPLY_FACTOR; j++)
-            if (ACE_OS::thr_create ((ACE_THR_FUNC) ace_empty,
-                                    0,
-                                    THR_SUSPENDED,
-                                    0) == -1)
-              ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "CreateThread"), -1);
-
-          ptimer.stop ();
-          ptimer.elapsed_time (et);
-          time += et.real_time;
-        }
-      iteration *= MULTIPLY_FACTOR;
-      return time / iteration;
-    }
-  else
-    return -1.0;
-#else
-  ACE_UNUSED_ARG (iteration);
-  ACE_ERROR_RETURN ((LM_ERROR, "Threads are not supported on this platform.\n"), -1);
-#endif
-}
-
-static double
-prof_tm_thread (size_t iteration)
-{
-#if defined (ACE_HAS_THREADS)
-  if (iteration != 0)
-    {
-      ACE_Profile_Timer ptimer;
-      ACE_Profile_Timer::ACE_Elapsed_Time et;
-      double time = 0;
-
-      for (size_t i = 0; i < iteration; i++)
-        {
-          ACE_STOP_SIGN;
-          ptimer.start ();
-
-          if (ACE_Thread_Manager::instance ()->spawn_n (MULTIPLY_FACTOR,
-                                                        (ACE_THR_FUNC) ace_empty,
-                                                        0,
-                                                        THR_SUSPENDED) == -1)
-            ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "CreateThread"), -1);
-
-          ptimer.stop ();
-          ptimer.elapsed_time (et);
-          time += et.real_time;
-        }
-      iteration *= MULTIPLY_FACTOR;
-      return time / iteration;
-    }
-  else
-    return -1.0;
-#else
-  ACE_UNUSED_ARG (iteration);
-  ACE_ERROR_RETURN ((LM_ERROR, "Threads are not supported on this platform."), -1);
-#endif
-}
-
-static double
-prof_mutex_base (size_t iteration)
-{
-#if defined (ACE_HAS_THREADS)
-  ACE_Thread_Mutex plain;
-  if (iteration != 0)
-    {
-      ACE_Profile_Timer ptimer;
-      ACE_Profile_Timer::ACE_Elapsed_Time et;
-      double time = 0;
-
-      for (size_t i = 0; i < iteration; i++)
-        {
-          ACE_STOP_SIGN;
-          ptimer.start ();
-
-          for (size_t j=0; j < MULTIPLY_FACTOR; j++)
-            {
-              plain.acquire ();
-              plain.release ();
-            }
-
-          ptimer.stop ();
-          ptimer.elapsed_time (et);
-          time += et.real_time;
-        }
-      iteration *= MULTIPLY_FACTOR;
-      return time / iteration;
-    }
-  else
-    return -1.0;
-#else
-  ACE_UNUSED_ARG (iteration);
-  ACE_ERROR_RETURN ((LM_ERROR, "Threads are not supported on this platform."), -1);
-#endif
-}
-
-int
-ACE_TMAIN (int argc, ACE_TCHAR* argv[])
-{
-  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("n:l:pftahmxe"));
-  int c;
-  size_t iteration = 10;
-  Profiler profiler = 0;
-  const char *profile_name = 0 ;
-
-  while ((c=get_opt ()) != -1)
-    {
-      switch (c)
-        {
-        case 'n':
-          iteration = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        case 'l':
-          MULTIPLY_FACTOR = ACE_static_cast (size_t,
-                                             ACE_OS::atoi (get_opt.opt_arg ()));
-          break;
-        case 'p':                       // test ACE_Process.spawn ()
-          profiler = prof_ace_process;
-          profile_name = "ACE_Process.spawn ()";
-          break;
-        case 'f':                       // test fork ()
-          profiler = prof_fork;
-          profile_name = "fork ()";
-          break;
-        case 't':                       // test native thread creation
-          profiler = prof_native_thread;
-          profile_name = "native threads";
-          break;
-        case 'a':                       // test ACE_OS::thr_create
-          profiler = prof_ace_os_thread;
-          profile_name = "ACE_OS::thr_create ()";
-          break;
-        case 'm':
-          profiler = prof_tm_thread;
-          profile_name = "ACE_Thread_Manager::spawn_n ()";
-          break;
-        case 'x':
-          profiler = prof_mutex_base;
-          profile_name = "ACE_Thread_Mutex Baseline";
-          break;
-        case 'h':                       // use high resolution timer
-          ACE_High_Res_Timer::get_env_global_scale_factor ();
-          break;
-        case 'e':
-          do_exec_after_fork = 1;
-          break;
-        default:
-          break;
-        }
-    }
-
-  if (profiler == 0)
-    ACE_ERROR_RETURN ((LM_ERROR, "Usage: childbirth_time {-p|-f|-t|-a|-m|-x} [-n ###] [-L ###] [-h] [-e]\n"), 1);
-  else
-    {
-      double time = profiler (iteration);
-      if (time > 0)
-        ACE_DEBUG ((LM_DEBUG,
-                    "Average performance of %d iterations of %s: %.0f usec\n",
-                    iteration * MULTIPLY_FACTOR, profile_name, time * 1e6));
-    }
-  return 0;
-}
diff --git a/performance-tests/Misc/context_switch_time.cpp b/performance-tests/Misc/context_switch_time.cpp
deleted file mode 100644
index d4c70e005eb..00000000000
--- a/performance-tests/Misc/context_switch_time.cpp
+++ /dev/null
@@ -1,1321 +0,0 @@
-// $Id$
-
-// ============================================================================
-//
-// = LIBRARY
-//    (none)
-//
-// = FILENAME
-//    context_switch_time.cpp
-//
-// = DESCRIPTION
-//   Program that calculates context switch time between threads.
-//   The Suspend-Resume test is based on the Task Context Switching
-//   measurement approach described in:
-//   Darren Cathey<br>
-//   "RTOS Benchmarking -- All Things Considered . . ."<br>
-//   <a href="http://www.realtime-info.be"><em>Real-Time Magazine</em></a>,
-//      Second Quarter 1993,
-//   <em>reprinted by <a href="http://www.wrs.com/artreqfm.html">Wind River
-//                    Systems</a></em><p>
-//   which in turn is based on Superconducting Super Collider (SSC)
-//   Laboratory Ping Suspend/Resume Task and Suspend/Resume Task benchmarks.
-//   It measures two different times:
-//   1) The time to resume a blocked high priority task, which does
-//      nothing other than block immediately.  A lower priority task
-//      resumes the high priority task, so the elapsed time includes
-//      two context switches, one task suspend, and one task resume.
-//   2) The time to suspend and resume a low priority task that does
-//      nothing.  There is no context switching.  This time is subtracted
-//      from the one described in 1) above, and the result is divided by
-//      two to yield the context switch time.
-//
-//   Notes:
-//   On Solaris 2.5.1, it appears that the lowest context switching times,
-//   at least on a single-CPU machine, are obtained _without_ creating new
-//   LWPs for new threads (THR_NEW_LWP).  The -n option enables the use of
-//   THR_NEW_LWP for testing.
-//
-// = CREATION DATE
-//    17 January 1997
-//
-// = AUTHOR
-//    David L. Levine
-//
-// ============================================================================
-
-static const char usage [] = "[-? |\n"
-                             "       [-c <repeat count, 0 means forever>]\n"
-                             "       [-n to spawn a new LWP with each thread\n"
-                             "[<iterations>]]";
-
-#include "ace/OS_NS_stdio.h"
-#include "ace/OS_main.h"
-#include "ace/Task.h"
-#include "ace/Sched_Params.h"
-#include "ace/Stats.h"
-#include "ace/High_Res_Timer.h"
-#include "ace/Get_Opt.h"
-#include "ace/Thread_Semaphore.h"
-#include "ace/Barrier.h"
-#include "ace/OS_NS_unistd.h"
-#include "ace/OS_NS_errno.h"
-
-ACE_RCSID(Misc, context_switch_time, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-#if !defined (ACE_DEBUG_CST)
-# define ACE_DEBUG_CST 0
-#endif /* ACE_DEBUG_CST */
-
-static const u_int LOW_PRIORITY = ACE_THR_PRI_FIFO_DEF;
-static u_int HIGH_PRIORITY;
-
-// Global test configuration parameters.
-static ACE_UINT32 count = 1;
-static ACE_UINT32 num_iterations = 1000;
-static ACE_UINT32 new_lwp = 0;
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Low_Priority_Null_Task
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-class Low_Priority_Null_Task : public ACE_Task<ACE_MT_SYNCH>
-{
-public:
-  Low_Priority_Null_Task ();
-  virtual ~Low_Priority_Null_Task ();
-
-  virtual int svc ();
-
-  // Called by other task:  it returns when this task is ready to
-  // continue.
-  void ready () { initialized_.acquire (); }
-
-  void done ();
-
-  ACE_hthread_t thread_id () const { return thread_id_; }
-private:
-  ACE_hthread_t thread_id_;
-  ACE_Semaphore initialized_;  // Blocks until thread_id_ is assigned.
-  ACE_Semaphore blocked_semaphore_;
-
-  // Force proper construction of independent instances.
-  Low_Priority_Null_Task (const Low_Priority_Null_Task &);
-  Low_Priority_Null_Task &operator= (const Low_Priority_Null_Task &);
-};
-
-inline
-Low_Priority_Null_Task::Low_Priority_Null_Task() :
-  ACE_Task<ACE_MT_SYNCH> (ACE_Thread_Manager::instance ()),
-  initialized_ (0),  // initialize to locked, then unlock when ready
-  blocked_semaphore_ (0)
-{
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Low_Priority_Null_Task ctor\n"));
-#endif /* ACE_DEBUG_CST */
-
-  if (this->activate (THR_BOUND | THR_DETACHED | THR_SCHED_FIFO | new_lwp,
-                      1, 0, LOW_PRIORITY))
-    ACE_OS::perror (ACE_TEXT("activate"));
-
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Low_Priority_Null_Task ctor, activated\n"));
-#endif /* ACE_DEBUG_CST */
-}
-
-Low_Priority_Null_Task::~Low_Priority_Null_Task()
-{
-}
-
-int
-Low_Priority_Null_Task::svc ()
-{
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Low_Priority_Null_Task::svc (), entering"));
-#endif /* ACE_DEBUG_CST */
-
-  ACE_Thread_Manager::instance ()->thr_self (thread_id_);
-  initialized_.release ();
-
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "; thread ID is %u\n", thread_id_));
-#endif /* ACE_DEBUG_CST */
-
-  // This task must never actually execute, so just have it block
-  // on a semaphore forever . . .
-  blocked_semaphore_.acquire ();
-
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Low_Priority_Task::svc, finishing\n"));
-#endif /* ACE_DEBUG_CST */
-
-  return 0;
-}
-
-void
-Low_Priority_Null_Task::done ()
-{
-  blocked_semaphore_.release ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Suspend_Resume_Test
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-class Suspend_Resume_Test : public ACE_Task<ACE_MT_SYNCH>
-{
-public:
-  Suspend_Resume_Test (const ACE_UINT32 iterations);
-  virtual ~Suspend_Resume_Test ();
-
-  virtual int svc ();
-
-  ACE_hrtime_t elapsed_time () const { return elapsed_time_; }
-private:
-  const ACE_UINT32 iterations_;
-
-  Low_Priority_Null_Task low_;
-
-  ACE_High_Res_Timer timer_;
-
-  ACE_hrtime_t elapsed_time_;
-
-  // Force proper construction of independent instances.
-  Suspend_Resume_Test ();
-  Suspend_Resume_Test (const Suspend_Resume_Test &);
-  Suspend_Resume_Test &operator= (const Suspend_Resume_Test &);
-};
-
-Suspend_Resume_Test::Suspend_Resume_Test (const ACE_UINT32 iterations) :
-  ACE_Task<ACE_MT_SYNCH> (),
-  iterations_ (iterations),
-  low_ (),
-  timer_ ()
-{
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Suspend_Resume_Test ctor\n"));
-#endif /* ACE_DEBUG_CST */
-
-  if (this->activate (THR_BOUND | THR_DETACHED | THR_SCHED_FIFO | new_lwp,
-                  1, 0, HIGH_PRIORITY))
-    ACE_OS::perror (ACE_TEXT("activate"));
-}
-
-Suspend_Resume_Test::~Suspend_Resume_Test()
-{
-}
-
-int
-Suspend_Resume_Test::svc ()
-{
-#if ACE_DEBUG_CST > 0
-  ACE_hthread_t thread_id;
-  ACE_Thread_Manager::instance ()->thr_self (thread_id);
-
-  ACE_DEBUG ((LM_DEBUG, "Suspend_Resume_Test::svc (), thread ID is %d\n",
-              thread_id));
-#endif /* ACE_DEBUG_CST */
-
-  low_.ready ();
-
-  // For information:  the cost of the just the loop itself below,
-  // without the suspend and resume calls, on a 166 MHz Ultrasparc
-  // is about 12.3 nanoseconds per iteration.
-
-  timer_.start ();
-
-  for (ACE_UINT32 i = 0; i < iterations_; ++i)
-    {
-#if ACE_DEBUG_CST > 0
-      if (i % (iterations_ >= 10  ?  iterations_ / 10  :  1) ==  0)
-        ACE_DEBUG ((LM_DEBUG, "Suspend_Resume_Test::svc (), iteration %u\n",
-                    i));
-#endif /* ACE_DEBUG_CST */
-
-      if (ACE_OS::thr_suspend (low_.thread_id ()) != 0)
-        {
-          ACE_ERROR ((LM_ERROR, "%p\n", "thr_suspend"));
-          low_.done ();
-          return -1;
-        }
-
-      if (ACE_OS::thr_continue (low_.thread_id ()) != 0  &&
-          errno != EINVAL)
-        // EINVAL is OK:  it just means that the thread needs to be joined.
-        {
-          ACE_ERROR ((LM_ERROR, "%p\n", "thr_continue"));
-          low_.done ();
-          return -1;
-        }
-    }
-
-  timer_.stop ();
-  timer_.elapsed_microseconds (elapsed_time_);
-
-  low_.done ();
-
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Suspend_Resume_Test::svc, finishing\n"));
-#endif /* ACE_DEBUG_CST */
-
-  return 0;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class High_Priority_Simple_Task
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-class High_Priority_Simple_Task : public ACE_Task<ACE_MT_SYNCH>
-{
-public:
-  High_Priority_Simple_Task ();
-  virtual ~High_Priority_Simple_Task ();
-
-  virtual int svc ();
-
-  // called by other task:  it returns when this task is ready to
-  // continue
-  void ready () { initialized_.acquire (); }
-
-  void done ();
-
-  ACE_hthread_t thread_id () const { return thread_id_; }
-  ACE_UINT32 iterations () const { return iterations_; }
-private:
-  ACE_hthread_t thread_id_;
-  ACE_Semaphore initialized_;  // Block until thread_id_ is assigned.
-  int terminate_;
-  ACE_UINT32 iterations_;
-
-  // Force proper construction of independent instances.
-  High_Priority_Simple_Task (const High_Priority_Simple_Task &);
-  High_Priority_Simple_Task &operator= (const High_Priority_Simple_Task &);
-};
-
-inline
-High_Priority_Simple_Task::High_Priority_Simple_Task() :
-  ACE_Task<ACE_MT_SYNCH> (ACE_Thread_Manager::instance ()),
-  initialized_ (0),  // Initialize to locked, then unlock when ready.
-  terminate_ (0),
-  iterations_ (0)
-{
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "High_Priority_Simple_Task ctor\n"));
-#endif /* ACE_DEBUG_CST */
-
-  if (this->activate (THR_BOUND | THR_DETACHED | THR_SCHED_FIFO | new_lwp,
-                  1, 0, HIGH_PRIORITY))
-    ACE_OS::perror (ACE_TEXT("activate"));
-
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "High_Priority_Simple_Task ctor, activated\n"));
-#endif /* ACE_DEBUG_CST */
-}
-
-High_Priority_Simple_Task::~High_Priority_Simple_Task()
-{
-}
-
-int
-High_Priority_Simple_Task::svc ()
-{
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "High_Priority_Simple_Task::svc (), entering"));
-#endif /* ACE_DEBUG_CST */
-
-  ACE_Thread_Manager::instance ()->thr_self (thread_id_);
-  initialized_.release ();
-
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "; thread ID is %u\n", thread_id_));
-#endif /* ACE_DEBUG_CST */
-
-  for (ACE_UINT32 i = 0; ! terminate_; ++i)
-    {
-#if ACE_DEBUG_CST > 0
-      ACE_DEBUG ((LM_DEBUG, "High_Priority_Simple_Task::svc, suspend self ("
-                            "%u)\n", thread_id_));
-#endif /* ACE_DEBUG_CST */
-
-      ++iterations_;
-
-      // immediately suspend self
-      if (ACE_OS::thr_suspend (thread_id_) != 0)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "thr_suspend"), -1);
-        }
-
-#if ACE_DEBUG_CST > 0
-      ACE_DEBUG ((LM_DEBUG, "High_Priority_Simple_Task::svc, resumed (%u)\n",
-                            thread_id_));
-#endif /* ACE_DEBUG_CST */
-    }
-
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "High_Priority_Simple_Task::svc, finishing\n"));
-#endif /* ACE_DEBUG_CST */
-
-  return 0;
-}
-
-inline
-void
-High_Priority_Simple_Task::done ()
-{
-  terminate_ = 1;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Ping_Suspend_Resume_Test
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-class Ping_Suspend_Resume_Test : public ACE_Task<ACE_MT_SYNCH>
-{
-public:
-  Ping_Suspend_Resume_Test (const ACE_UINT32 iterations);
-  virtual ~Ping_Suspend_Resume_Test ();
-
-  virtual int svc ();
-
-  ACE_hrtime_t elapsed_time () const { return elapsed_time_; }
-private:
-  const ACE_UINT32 iterations_;
-
-  High_Priority_Simple_Task high_;
-
-  ACE_High_Res_Timer timer_;
-
-  ACE_hrtime_t elapsed_time_;
-
-  // Force proper construction of independent instances.
-  Ping_Suspend_Resume_Test ();
-  Ping_Suspend_Resume_Test (const Ping_Suspend_Resume_Test &);
-  Ping_Suspend_Resume_Test &operator= (const Ping_Suspend_Resume_Test &);
-};
-
-Ping_Suspend_Resume_Test::Ping_Suspend_Resume_Test (
-  const ACE_UINT32 iterations)
-:
-  ACE_Task<ACE_MT_SYNCH> (),
-  iterations_ (iterations),
-  high_ (),
-  timer_ ()
-{
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test ctor\n"));
-#endif /* ACE_DEBUG_CST */
-
-  if (this->activate (THR_BOUND | THR_DETACHED | THR_SCHED_FIFO | new_lwp,
-                  1, 0, LOW_PRIORITY))
-    ACE_OS::perror (ACE_TEXT("activate"));
-}
-
-Ping_Suspend_Resume_Test::~Ping_Suspend_Resume_Test()
-{
-}
-
-int
-Ping_Suspend_Resume_Test::svc ()
-{
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test::svc (), entering"));
-
-  ACE_hthread_t thread_id;
-  ACE_Thread_Manager::instance ()->thr_self (thread_id);
-
-  ACE_DEBUG ((LM_DEBUG, "; thread ID is %u\n", thread_id));
-#endif /* ACE_DEBUG_CST */
-
-  high_.ready ();
-
-#if ACE_DEBUG_CST > 0
-  int priority, high_priority;
-  ACE_OS::thr_getprio (thread_id, priority);
-  ACE_OS::thr_getprio (high_.thread_id (), high_priority);
-  ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test::svc (), priority is %d, "
-                        ", high thread priority is %d\n",
-              priority, high_priority));
-#endif /* ACE_DEBUG_CST */
-
-  // For information:  the cost of the just the loop itself below,
-  // without the suspend and resume calls, on a 166 MHz Ultrasparc
-  // is about 12.3 nanoseconds per iteration.
-
-  timer_.start ();
-
-  ACE_UINT32 i;
-
-  for (i = 0; i < iterations_; ++i)
-    {
-#if ACE_DEBUG_CST > 0
-      if (i % (iterations_ >= 10  ?  iterations_ / 10  :  1) ==  0)
-        {
-          ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test::svc (), iteration "
-                                "%d, continue high-priority thread %u\n",
-                      i, high_.thread_id ()));
-        }
-#endif /* ACE_DEBUG_CST */
-      if (ACE_OS::thr_continue (high_.thread_id ()) != 0  &&
-          errno != EINVAL)
-        // EINVAL is OK:  it just means that the thread needs to be joined.
-        {
-          ACE_ERROR ((LM_ERROR, "%p\n", "thr_continue"));
-          high_.done ();
-          return -1;
-        }
-    }
-
-  timer_.stop ();
-  timer_.elapsed_microseconds (elapsed_time_);
-
-  high_.done ();
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test::svc: told high priority "
-                        "task to terminate\n"));
-#endif /* ACE_DEBUG_CST */
-
-  // Resume the thread until thr_continue fails, indicating that it has
-  // finished.
-  for (i = 0; i < 10000  &&  ! ACE_OS::thr_continue (high_.thread_id ());
-       ++i) /* null */;
-
-  // Don't count the one iteration that was used to allow the high-priority
-  // thread to terminate.
-  if (high_.iterations () < iterations_)
-    ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test: high priority task "
-                "executed only %u iterations!\n",
-                high_.iterations ()));
-
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Ping_Suspend_Resume_Test::svc, finishing\n"));
-#endif /* ACE_DEBUG_CST */
-
-  return 0;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Yield_Test
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-class Yield_Test : public ACE_Task<ACE_MT_SYNCH>
-{
-public:
-  Yield_Test (const ACE_UINT32 iterations);
-  virtual ~Yield_Test ();
-
-  virtual int svc ();
-
-  ACE_hrtime_t elapsed_time () const { return elapsed_time_; }
-private:
-  const ACE_UINT32 iterations_;
-#if defined (VXWORKS)
-  ACE_Thread_Mutex mutex_;
-  u_int started_;
-  u_int stopped_;
-#else  /* ! VXWORKS */
-  ACE_Barrier timer_barrier_;
-#endif /* ! VXWORKS */
-  ACE_High_Res_Timer timer_;
-  ACE_hrtime_t elapsed_time_;
-
-  // Force proper construction of independent instances.
-  Yield_Test ();
-  Yield_Test (const Yield_Test &);
-  Yield_Test &operator= (const Yield_Test &);
-};
-
-Yield_Test::Yield_Test (const ACE_UINT32 iterations) :
-  ACE_Task<ACE_MT_SYNCH> (),
-  iterations_ (iterations),
-#if defined (VXWORKS)
-  mutex_ (),
-  started_ (0),
-  stopped_ (0),
-#else  /* ! VXWORKS */
-  timer_barrier_ (3),
-#endif /* ! VXWORKS */
-  timer_ ()
-{
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Yield_Test ctor\n"));
-#endif /* ACE_DEBUG_CST */
-
-#if !defined (VXWORKS)
-  timer_.start ();
-#endif /* ! VXWORKS */
-
-  if (this->activate (THR_BOUND | THR_DETACHED | THR_SCHED_FIFO | new_lwp,
-                  2, 0, LOW_PRIORITY))
-    ACE_OS::perror (ACE_TEXT("activate"));
-
-#if !defined (VXWORKS)
-  timer_barrier_.wait ();
-  timer_.stop ();
-#endif /* ! VXWORKS */
-
-  timer_.elapsed_microseconds (elapsed_time_);
-}
-
-Yield_Test::~Yield_Test()
-{
-}
-
-int
-Yield_Test::svc ()
-{
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Yield_Test::svc (), entering"));
-
-  ACE_hthread_t thread_id;
-  ACE_Thread_Manager::instance ()->thr_self (thread_id);
-
-  int priority;
-  ACE_OS::thr_getprio (thread_id, priority);
-
-  ACE_DEBUG ((LM_DEBUG, "; thread ID is %u, priority is %u\n", thread_id,
-              priority));
-#endif /* ACE_DEBUG_CST */
-
-#if defined (VXWORKS)
-  // Start the timer, if it hasn't already been started.
-  if (! started_)
-    {
-      // Double-check.
-      ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, mutex_, -1);
-
-      if (! started_)
-        {
-          started_ = 1;
-          timer_.start ();
-        }
-    }
-#endif /* VXWORKS */
-
-  for (ACE_UINT32 i = 0; i < iterations_; ++i)
-    {
-#if ACE_DEBUG_CST > 0
-      if (i % (iterations_ >= 10  ?  iterations_ / 10  :  1) ==  0)
-        {
-          ACE_DEBUG ((LM_DEBUG, "Yield_Test::svc () [%u], iteration %u\n",
-                      thread_id, i));
-        }
-#endif /* ACE_DEBUG_CST */
-
-      ACE_OS::thr_yield ();
-    }
-
-#if defined (VXWORKS)
-  // Stop the timer, if it hasn't already been started.
-  if (! stopped_)
-    {
-      // Maybe it would be better to read the clock before grabbing
-      // the mutex.  Then, only apply the clock reading below, instead
-      // of reading the clock after grabbing the mutex.
-
-      // Double-check.
-      ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, mutex_, -1);
-
-      if (! stopped_)
-        {
-          stopped_ = 1;
-          timer_.stop ();
-          timer_.elapsed_time (elapsed_time_); /* nanoseconds */
-        }
-    }
-#else  /* ! VXWORKS */
-  timer_barrier_.wait ();
-#endif /* ! VXWORKS */
-
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Yield_Test::svc, finishing\n"));
-#endif /* ACE_DEBUG_CST */
-
-  return 0;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Mutex_Acquire_Release_Test
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-class Mutex_Acquire_Release_Test
-{
-public:
-  Mutex_Acquire_Release_Test (const ACE_UINT32 iterations);
-  virtual ~Mutex_Acquire_Release_Test ();
-
-  virtual int svc ();
-
-  ACE_hrtime_t elapsed_time () const { return elapsed_time_; }
-private:
-  ACE_Thread_Mutex mutex_;
-  // Mutex used for acquire/release time measurement.
-
-  ACE_Thread_Semaphore sem_;
-  // Semaphore used for acquire/release time measurement.
-
-  const ACE_UINT32 iterations_;
-
-  ACE_High_Res_Timer timer_;
-
-  ACE_hrtime_t elapsed_time_;
-
-  // Force proper construction of independent instances.
-  Mutex_Acquire_Release_Test ();
-  Mutex_Acquire_Release_Test (const Mutex_Acquire_Release_Test &);
-  Mutex_Acquire_Release_Test &operator= (const Mutex_Acquire_Release_Test &);
-};
-
-Mutex_Acquire_Release_Test::Mutex_Acquire_Release_Test (
-    const ACE_UINT32 iterations) :
-  mutex_ (),
-  sem_ (),
-  iterations_ (iterations),
-  timer_ ()
-{
-}
-
-Mutex_Acquire_Release_Test::~Mutex_Acquire_Release_Test()
-{
-}
-
-int
-Mutex_Acquire_Release_Test::svc ()
-{
-#if ACE_DEBUG_CST > 0
-  ACE_hthread_t thread_id;
-  ACE_Thread_Manager::instance ()->thr_self (thread_id);
-
-  ACE_DEBUG ((LM_DEBUG,
-              "Mutex_Acquire_Release_Test::svc (), thread ID is %d\n",
-              thread_id));
-#endif /* ACE_DEBUG_CST */
-
-  timer_.start ();
-
-  for (ACE_UINT32 i = 0; i < iterations_; ++i)
-    {
-      // Block on the mutex.
-      ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, mutex_, -1);
-
-      // Release the mutex so that the low priority thread can
-      // proceed.  The ACE_GUARD_RETURN macro implicity releases the
-      // mutex.
-    }
-
-  timer_.stop ();
-  timer_.elapsed_time (elapsed_time_); /* nanoseconds */
-
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Mutex_Acquire_Release_Test::svc, finishing\n"));
-#endif /* ACE_DEBUG_CST */
-
-  return 0;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class High_Priority_Synchronized_Task
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-class High_Priority_Synchronized_Task : public ACE_Task<ACE_MT_SYNCH>
-{
-public:
-  High_Priority_Synchronized_Task (ACE_Thread_Semaphore &sem,
-                                   ACE_Thread_Mutex &mutex,
-                                   ACE_High_Res_Timer &timer);
-  virtual ~High_Priority_Synchronized_Task ();
-
-  virtual int svc ();
-
-  void ready () { initialized_.acquire (); }
-  // Called by other task:  it returns when this task is ready to
-  // continue
-
-  void done ();
-
-  ACE_UINT32 average_context_switch_time () const;
-
-  ACE_hthread_t thread_id () const { return thread_id_; }
-  ACE_UINT32 iterations () const { return iterations_; }
-private:
-  ACE_hthread_t thread_id_;
-  ACE_Semaphore initialized_;  // Block until thread_id_ is assigned.
-  int terminate_;
-  ACE_UINT32 iterations_;
-
-  ACE_Thread_Semaphore &sem_;
-  // Semaphore used to resume the task.
-
-  ACE_Thread_Mutex &mutex_;
-  // Mutex used to block the task.
-
-  ACE_High_Res_Timer &timer_;
-  // Clock shared between low and high priority tasks.
-
-  ACE_hrtime_t total_time_;
-  // Running total context switch time, nsec.
-
-  // Force proper construction of independent instances.
-  High_Priority_Synchronized_Task ();
-  High_Priority_Synchronized_Task (const High_Priority_Synchronized_Task &);
-  High_Priority_Synchronized_Task &
-    operator= (const High_Priority_Synchronized_Task &);
-};
-
-High_Priority_Synchronized_Task::High_Priority_Synchronized_Task (
-    ACE_Thread_Semaphore &sem,
-    ACE_Thread_Mutex &mutex,
-    ACE_High_Res_Timer &timer) :
-  ACE_Task<ACE_MT_SYNCH> (ACE_Thread_Manager::instance ()),
-  initialized_ (0),  // Initialize to locked, then unlock when ready.
-  terminate_ (0),
-  iterations_ (0),
-  sem_ (sem),
-  mutex_ (mutex),
-  timer_ (timer),
-  total_time_ (0)
-{
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "High_Priority_Synchronized_Task ctor\n"));
-#endif /* ACE_DEBUG_CST */
-
-  if (this->activate (THR_BOUND | THR_DETACHED | THR_SCHED_FIFO | new_lwp,
-                  1, 0, HIGH_PRIORITY))
-    ACE_OS::perror (ACE_TEXT("activate"));
-
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "High_Priority_Synchronized_Task ctor, activated\n"));
-#endif /* ACE_DEBUG_CST */
-}
-
-High_Priority_Synchronized_Task::~High_Priority_Synchronized_Task()
-{
-}
-
-int
-High_Priority_Synchronized_Task::svc ()
-{
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "High_Priority_Synchronized_Task::svc (), entering"));
-#endif /* ACE_DEBUG_CST */
-
-  ACE_Thread_Manager::instance ()->thr_self (thread_id_);
-
-  ACE_UINT32 mutex_acquire_release_time = 0;
-  {
-    Mutex_Acquire_Release_Test mutex_acquire_release_test (num_iterations);
-    mutex_acquire_release_test.svc ();
-    mutex_acquire_release_time =
-      ACE_static_cast (ACE_UINT32,
-                       mutex_acquire_release_test.elapsed_time () /
-                       num_iterations);
-#if ACE_DEBUG_CST > 0
-    ACE_DEBUG ((LM_DEBUG, "mutex_acquire_release: %u nsec\n",
-                mutex_acquire_release_time));
-#endif /* ACE_DEBUG_CST */
-  }
-
-  initialized_.release ();
-
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "; thread ID is %u\n", thread_id_));
-#endif /* ACE_DEBUG_CST */
-
-  for (ACE_UINT32 i = 0; ! terminate_; ++i)
-    {
-#if ACE_DEBUG_CST > 0
-      ACE_DEBUG ((LM_DEBUG,
-                  "High_Priority_Synchronized_Task::svc, wait on sem ("
-                  "%u)\n", thread_id_));
-#endif /* ACE_DEBUG_CST */
-
-      if (sem_.acquire () != 0)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "sem_.acquire"), -1);
-        }
-
-      {
-        // Block on the mutex.
-        ACE_GUARD_RETURN (ACE_Thread_Mutex, guard, mutex_, -1);
-
-        timer_.stop ();
-
-        ++iterations_;
-
-        ACE_hrtime_t nsec;
-        timer_.elapsed_time (nsec);
-        const ACE_UINT32 context_switch_time =
-          ACE_U64_TO_U32 (nsec) >= mutex_acquire_release_time  ?
-            ACE_U64_TO_U32 (nsec) - mutex_acquire_release_time  :  0;
-
-        total_time_ += context_switch_time;
-
-        // Release the mutex so that the low priority thread can
-        // proceed.  The ACE_GUARD_RETURN macro implicity releases the
-        // mutex.
-      }
-
-#if ACE_DEBUG_CST > 0
-      ACE_DEBUG ((LM_DEBUG,
-                  "High_Priority_Synchronized_Task::svc, resumed (%u)\n",
-                  thread_id_));
-#endif /* ACE_DEBUG_CST */
-    }
-
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "High_Priority_Synchronized_Task::svc, finishing\n"));
-#endif /* ACE_DEBUG_CST */
-
-  return 0;
-}
-
-inline
-void
-High_Priority_Synchronized_Task::done ()
-{
-  terminate_ = 1;
-}
-
-ACE_UINT32
-High_Priority_Synchronized_Task:: average_context_switch_time () const
-{
-  return iterations_ > 0  ?  ACE_static_cast (ACE_UINT32,
-                                              total_time_ / iterations_)
-                          : 0;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Synchronized_Suspend_Resume_Test
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-class Synchronized_Suspend_Resume_Test : public ACE_Task<ACE_MT_SYNCH>
-{
-public:
-  Synchronized_Suspend_Resume_Test (const ACE_UINT32 iterations);
-  virtual ~Synchronized_Suspend_Resume_Test ();
-
-  virtual int svc ();
-
-  ACE_UINT32 average_context_switch_time ();
-
-  ACE_hrtime_t elapsed_time () const { return elapsed_time_; }
-private:
-  const ACE_UINT32 iterations_;
-
-  ACE_Thread_Semaphore sem_;
-  // Used by the low priority thread to resume the high priority thread.
-
-  ACE_Thread_Mutex mutex_;
-  // Used by the low priority thread to block the high priority thread.
-
-  ACE_High_Res_Timer timer_;
-  // Clock shared between low and high priority tasks.
-
-  High_Priority_Synchronized_Task high_;
-  // The high priority task.
-
-  ACE_hrtime_t elapsed_time_;
-
-  ACE_UINT32 mutex_acquire_release_time_;
-
-  // Force proper construction of independent instances.
-  Synchronized_Suspend_Resume_Test ();
-  Synchronized_Suspend_Resume_Test (const Synchronized_Suspend_Resume_Test &);
-  Synchronized_Suspend_Resume_Test &
-    operator= (const Synchronized_Suspend_Resume_Test &);
-};
-
-Synchronized_Suspend_Resume_Test::Synchronized_Suspend_Resume_Test (
-  const ACE_UINT32 iterations)
-:
-  ACE_Task<ACE_MT_SYNCH> (),
-  iterations_ (iterations),
-  sem_ (0),
-  mutex_ (),
-  timer_ (),
-  high_ (sem_, mutex_, timer_),
-  mutex_acquire_release_time_ (0)
-{
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Synchronized_Suspend_Resume_Test ctor\n"));
-#endif /* ACE_DEBUG_CST */
-
-  if (this->activate (THR_BOUND | THR_DETACHED | THR_SCHED_FIFO | new_lwp,
-                  1, 0, LOW_PRIORITY))
-    ACE_OS::perror (ACE_TEXT("activate"));
-}
-
-Synchronized_Suspend_Resume_Test::~Synchronized_Suspend_Resume_Test()
-{
-}
-
-int
-Synchronized_Suspend_Resume_Test::svc ()
-{
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Synchronized_Suspend_Resume_Test::svc (), entering"));
-
-  ACE_hthread_t thread_id;
-  ACE_Thread_Manager::instance ()->thr_self (thread_id);
-
-  ACE_DEBUG ((LM_DEBUG, "; thread ID is %u\n", thread_id));
-#endif /* ACE_DEBUG_CST */
-
-  {
-    Mutex_Acquire_Release_Test mutex_acquire_release_test (num_iterations);
-    mutex_acquire_release_test.svc ();
-    mutex_acquire_release_time_ =
-      ACE_static_cast (ACE_UINT32,
-                       mutex_acquire_release_test.elapsed_time () /
-                       num_iterations);
-#if ACE_DEBUG_CST > 0
-    ACE_DEBUG ((LM_DEBUG, "mutex_acquire_release: %u nsec\n",
-                mutex_acquire_release_time_));
-#endif /* ACE_DEBUG_CST */
-  }
-
-  high_.ready ();
-
-#if ACE_DEBUG_CST > 0
-  int priority, high_priority;
-  ACE_OS::thr_getprio (thread_id, priority);
-  ACE_OS::thr_getprio (high_.thread_id (), high_priority);
-  ACE_DEBUG ((LM_DEBUG,
-              "Synchronized_Suspend_Resume_Test::svc (), priority is %d, "
-              ", high thread priority is %d\n",
-              priority, high_priority));
-#endif /* ACE_DEBUG_CST */
-
-  // For information:  the cost of the just the loop itself below,
-  // without the suspend and resume calls, on a 166 MHz Ultrasparc
-  // is about 12.3 nanoseconds per iteration.
-
-  ACE_UINT32 i;
-
-  for (i = 0; i < iterations_; ++i)
-    {
-#if ACE_DEBUG_CST > 0
-      if (i % (iterations_ >= 10  ?  iterations_ / 10  :  1) ==  0)
-        {
-          ACE_DEBUG ((LM_DEBUG,
-                      "Synchronized_Suspend_Resume_Test::svc (), iteration "
-                      "%d, continue high-priority thread %u\n",
-                      i, high_.thread_id ()));
-        }
-#endif /* ACE_DEBUG_CST */
-
-      {
-        // Acquire the mutex so that the high priority thread will
-        // block after we signal it via the condition variable.
-        ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, mutex_, -1);
-
-        // Release the semaphore so that the high priority thread can
-        // proceed.
-        if (sem_.release () != 0)
-          ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "sem_.release"), -1);
-
-        timer_.start ();
-
-        // Release the mutex so that the high priority thread can
-        // proceed.  The ACE_GUARD_RETURN macro implicity releases
-        // the mutex.
-      }
-    }
-
-  high_.done ();
-
-  // The high priority thread will be block on the semaphore, so
-  // release it.
-  if (sem_.release () != 0)
-    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "sem_.release"), -1);
-
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG,
-              "Synchronized_Suspend_Resume_Test::svc: told high priority "
-              "task to terminate\n"));
-#endif /* ACE_DEBUG_CST */
-
-  // Resume the thread until thr_continue fails, indicating that it has
-  // finished.
-  for (i = 0; i < 10000  &&  ! ACE_OS::thr_continue (high_.thread_id ());
-       ++i) /* null */;
-
-#if ACE_DEBUG_CST > 0
-  ACE_DEBUG ((LM_DEBUG, "Synchronized_Suspend_Resume_Test::svc, finishing\n"));
-#endif /* ACE_DEBUG_CST */
-
-  return 0;
-}
-
-ACE_UINT32
-Synchronized_Suspend_Resume_Test::average_context_switch_time ()
-{
-  return high_.average_context_switch_time ();
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// function get_options
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-static
-u_int
-get_options (int argc, ACE_TCHAR *argv[])
-{
-  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("c:n?"));
-  int opt;
-  while ((opt = get_opt ()) != EOF) {
-    switch (opt) {
-    case 'c':
-      if (ACE_OS::atoi (get_opt.opt_arg ()) >= 0)
-        {
-          count = ACE_OS::atoi (get_opt.opt_arg ());
-        }
-      else
-        {
-          ACE_DEBUG ((LM_ERROR, "%n: count must be >= 0\n"));
-          return 1;
-        }
-      break;
-    case 'n':
-      new_lwp = THR_NEW_LWP;
-      break;
-    case '?':
-      ACE_DEBUG ((LM_ERROR, "usage: %n %s\n", usage));
-      ACE_OS::exit (1);
-      /* NOTREACHED */
-      break;
-    default:
-      ACE_DEBUG ((LM_ERROR, "%n: unknown arg, %c\n", opt));
-      ACE_DEBUG ((LM_ERROR, "usage: %n %s\n", usage));
-      return 1;
-    }
-  }
-
-  switch (argc - get_opt.opt_ind ()) {
-  case 0:
-    // use default number of iterations
-    break;
-  case 1:
-    if (ACE_OS::atoi (argv [get_opt.opt_ind ()]) > 0)
-      num_iterations = ACE_OS::atoi (argv [get_opt.opt_ind ()]);
-    else
-      {
-        ACE_DEBUG ((LM_ERROR, "%n: iterations must be > 0\n"));
-        return 1;
-      }
-    break;
-  default:
-    ACE_DEBUG ((LM_ERROR, "%n: too many arguments\n"));
-    ACE_DEBUG ((LM_ERROR, "usage: %n %s\n", usage));
-    return 1;
-  }
-
-  return 0;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// function main
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-int
-ACE_TMAIN (int argc, ACE_TCHAR *argv [])
-{
-  ACE_LOG_MSG->open (argv[0] > 0  ?  argv[0]  :  ACE_TEXT("context_switch_time"));
-
-  if (get_options (argc, argv))
-    ACE_OS::exit (-1);
-
-  // Disable LM_DEBUG.
-  ACE_Log_Msg::instance ()->priority_mask (ACE_LOG_MSG->priority_mask () ^
-                                           LM_DEBUG);
-
-#if defined (ACE_HAS_PENTIUM)  &&  \
-    !defined (ACE_HAS_HI_RES_TIMER)  &&  !defined (ACE_WIN32)
-  // Just to verify that ACE_High_Res_Timer::global_scale_factor ()
-  // correctly determines the clock speed.
-  ACE_DEBUG ((LM_INFO, "clock speed: %u MHz\n",
-              ACE_High_Res_Timer::global_scale_factor ()));
-#endif /* ACE_HAS_PENTIUM && ! ACE_HAS_HI_RES_TIMER && ! ACE_WIN32 */
-
-  if (ACE_OS::sched_params (
-        ACE_Sched_Params (
-          ACE_SCHED_FIFO,
-          ACE_Sched_Params::priority_min (ACE_SCHED_FIFO),
-          ACE_SCOPE_PROCESS)) != 0)
-    {
-      if (ACE_OS::last_error () == EPERM)
-        {
-          ACE_DEBUG ((LM_MAX, "context_switch_time: user is not superuser, "
-                              "so remain in time-sharing class\n"));
-        }
-      else
-        {
-          ACE_OS::perror (ACE_TEXT("context_switch_time"));
-          ACE_OS::exit (-1);
-        }
-    }
-
-  HIGH_PRIORITY = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO,
-                                                   LOW_PRIORITY);
-  ACE_DEBUG ((LM_INFO, "low priority: %d, high priority: %d\n",
-              LOW_PRIORITY, HIGH_PRIORITY));
-
-  // Set the priority of this thread so that it's higher than any of
-  // the test threads.  That might help avoid problems when waiting on
-  // those threads, below.  It also seems to help the times
-  // significantly on LynxOS.
-  ACE_hthread_t self;
-  ACE_OS::thr_self (self);
-  ACE_OS::thr_setprio (ACE_Sched_Params::next_priority (ACE_SCHED_FIFO,
-                                                        HIGH_PRIORITY));
-
-  int forever = count == 0;
-
-  ACE_Stats context_switch_test_stats;
-  ACE_Stats yield_test_stats;
-  ACE_Stats synchronized_suspend_resume_test_stats;
-
-  int suspend_resume_supported = 0;
-  // Check to see if thr_continue (), and therefore thr_suspend (),
-  // probably, are supported.
-  if (ACE_OS::thr_continue (self) == 0  ||  errno != ENOTSUP)
-    suspend_resume_supported = 1;
-
- while (forever  ||  count-- > 0)
-    {
-      if (suspend_resume_supported)
-        {
-          // Run suspend/resume test first . . .
-          Suspend_Resume_Test suspend_resume_test (num_iterations);
-          // Wait for all tasks to exit.
-          ACE_Thread_Manager::instance ()->wait ();
-
-          // Then Ping Suspend/Resume test.
-          Ping_Suspend_Resume_Test ping_suspend_resume_test (num_iterations);
-          // Wait for all tasks to exit.
-          ACE_Thread_Manager::instance ()->wait ();
-
-          if (ping_suspend_resume_test.elapsed_time () >
-               suspend_resume_test.elapsed_time ())
-            {
-              context_switch_test_stats.
-                sample (ACE_U64_TO_U32 (
-                  ping_suspend_resume_test.elapsed_time () -
-                  suspend_resume_test.elapsed_time ()));
-
-              ACE_DEBUG ((LM_INFO, "context switch time is (%.3f - %.3f)/2 = "
-                                   "%.3f microseconds\n",
-                          (double) ACE_UINT64_DBLCAST_ADAPTER (
-                            ping_suspend_resume_test.elapsed_time ()) /
-                              num_iterations,
-                          (double) ACE_UINT64_DBLCAST_ADAPTER (
-                            suspend_resume_test.elapsed_time ()) /
-                              num_iterations,
-                          (double) ACE_UINT64_DBLCAST_ADAPTER (
-                            ping_suspend_resume_test.elapsed_time () -
-                            suspend_resume_test.elapsed_time ()) /
-                              num_iterations / 2u));
-            }
-          else
-            {
-              ACE_DEBUG ((LM_INFO, "ping suspend/resume time of %u usec was "
-                                   "less than suspend/resume time of %u\n",
-                                   ping_suspend_resume_test.elapsed_time () /
-                                      num_iterations,
-                                   suspend_resume_test.elapsed_time () /
-                                      num_iterations));
-            }
-        }
-
-      // Then Yield test.
-      Yield_Test yield_test (num_iterations);
-      // Wait for all tasks to exit.
-      ACE_Thread_Manager::instance ()->wait ();
-
-      yield_test_stats.sample (ACE_U64_TO_U32 (yield_test.elapsed_time ()));
-
-      // Try _really_ hard not to use floating point.
-      ACE_DEBUG ((LM_INFO, "context switch time from yield test is %u.%03u "
-                           "microseconds\n",
-                  (ACE_UINT32)
-                    (yield_test.elapsed_time () / num_iterations / 2u),
-                  (ACE_UINT32)
-                    (yield_test.elapsed_time () % (num_iterations * 2u)) *
-                      1000u / num_iterations / 2u));
-
-      Synchronized_Suspend_Resume_Test
-        synchronized_suspend_resume_test (num_iterations);
-      // Wait for all tasks to exit.
-      ACE_Thread_Manager::instance ()->wait ();
-
-      synchronized_suspend_resume_test_stats.sample (
-        synchronized_suspend_resume_test.average_context_switch_time ());
-
-      ACE_DEBUG ((LM_INFO, "context switch time from synch susp/resume test "
-                           "is %u.%03u microseconds\n",
-                  synchronized_suspend_resume_test.
-                    average_context_switch_time () / 1000u,
-                  synchronized_suspend_resume_test.
-                    average_context_switch_time () % 1000u));
-
-      // Give, e.g., Draft 4 Posix platforms a chance to cleanup threads.
-      const ACE_Time_Value half_sec (0L, 500000L);
-      ACE_OS::sleep (half_sec);
-    }
-
-  if (suspend_resume_supported)
-    {
-      ACE_OS::printf ("suspend-resume test: ");
-      context_switch_test_stats.print_summary (3, num_iterations * 2u);
-    }
-
-  ACE_OS::printf ("\nyield_test: ");
-  yield_test_stats.print_summary (3, num_iterations * 2u);
-
-  ACE_OS::printf ("\nsynchronized suspend-resume test: ");
-  synchronized_suspend_resume_test_stats.print_summary (3,
-                                                        1000u /* nsec/usec */);
-
-  return 0;
-}
-#else
-int
-main (int, char *[])
-{
-  ACE_ERROR ((LM_ERROR, "threads not supported on this platform\n"));
-  return 0;
-}
-#endif /* ACE_HAS_THREADS */
-
-
-// EOF
diff --git a/performance-tests/Misc/preempt.cpp b/performance-tests/Misc/preempt.cpp
deleted file mode 100644
index 56a961031e8..00000000000
--- a/performance-tests/Misc/preempt.cpp
+++ /dev/null
@@ -1,461 +0,0 @@
-// $Id$
-
-// ============================================================================
-//
-// = LIBRARY
-//    performance-tests/Misc
-//
-// = FILENAME
-//    preempt.cpp
-//
-// = DESCRIPTION
-//      This is a simple test to illustrate OS thread preemption.  One
-//      ore more high priority threads periodically (every half
-//      second, by default) reads the clock.  They use select () to
-//      block for that duration.  Meanwhile, a low priority thread
-//      continually chews up the CPU.  Without preemption, the high
-//      priority thread won't have a chance to read the clock in a
-//      timely manner.
-//
-//      At the end of the test, the actual clock read intervals by the
-//      high priority task(s) are printed out.  With proper
-//      preemption, the intervals should correspond to the requested
-//      clock read interval.
-//
-//      There is a -y option for the low priority thread to periodically
-//      yield.  It shouldn't be necessary to use that option, if preemption
-//      is supported.  It's a handy option for testing.
-//
-// = AUTHOR
-//    David L. Levine
-//
-// ============================================================================
-
-#include "ace/OS_main.h"
-#include "ace/ACE.h"
-#include "ace/Task.h"
-#include "ace/Sched_Params.h"
-#include "ace/Get_Opt.h"
-#include "ace/OS_NS_sys_select.h"
-#include "ace/OS_NS_time.h"
-#include "ace/OS_NS_errno.h"
-#include "ace/OS_NS_unistd.h"
-
-ACE_RCSID(Misc, preempt, "$Id$")
-
-#if defined (ACE_HAS_THREADS) || ! defined (ACE_LACKS_FORK)
-
-#if defined (ACE_HAS_STHREADS)
-# include <sys/lwp.h> /* for _lwp_self () */
-#endif /* ACE_HAS_STHREADS */
-
-static const char usage [] = "[-? |\n"
-#if defined (ACE_HAS_THREADS)
-                            "       [-f use fork instead of spawn]\n"
-#endif /* ACE_HAS_THREADS */
-                            "       [-h <high pri iterations, default 10>]\n"
-                            "       [-l <low pri iterations, default 25000>]\n"
-                            "       [-n <high priority threads, default 1>]\n"
-                            "       [-p <read period, default 500000 usec>]\n"
-                            "       [-y to yield the low priority thread]]\n";
-
-// Configuration options.
-#if defined (ACE_HAS_THREADS)
-u_int use_fork = 0;
-#else  /* ! ACE_HAS_THREADS */
-u_int use_fork = 1;
-#endif /* ! ACE_HAS_THREADS */
-u_int high_iterations = 10;
-u_int high_priority_tasks = 1;
-u_int low_iterations = 25000;  /* Big enough to keep the low priority task
-                                  cranking for a while */
-u_long read_period = 500000; /* usec */
-u_int low_yield = 0;
-
-// To permit calculation of relative times.
-ACE_hrtime_t starttime;
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class High_Priority_Task
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-class High_Priority_Task : public ACE_Task<ACE_SYNCH>
-{
-public:
-  High_Priority_Task (void);
-  ~High_Priority_Task (void);
-
-  int open (void *);
-  int svc (void);
-  int done () const { return done_; }
-  void print_times () const;
-
-private:
-  int priority_;
-  int done_;
-  u_long *time_;
-};
-
-High_Priority_Task::High_Priority_Task (void)
-  : ACE_Task<ACE_SYNCH> (ACE_Thread_Manager::instance ()),
-    priority_ (ACE_Sched_Params::next_priority (
-                 ACE_SCHED_FIFO,
-                 ACE_Sched_Params::priority_min (ACE_SCHED_FIFO,
-                                                 ACE_SCOPE_THREAD),
-                 ACE_SCOPE_THREAD)),
-    done_ (0)
-{
-  ACE_NEW (time_, u_long[high_iterations]);
-}
-
-High_Priority_Task::~High_Priority_Task (void)
-{
-  delete [] time_;
-  time_ = 0;
-}
-
-int
-High_Priority_Task::open (void *)
-{
-  if (use_fork == 1)
-    {
-      ACE_hthread_t thr_handle;
-      ACE_Thread::self (thr_handle);
-
-      if (ACE_Thread::setprio (thr_handle, priority_) == -1)
-        ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "setprio failed"), -1);
-
-      return svc ();
-    }
-  else
-    {
-      long flags = THR_BOUND | THR_NEW_LWP | THR_SCHED_FIFO;
-
-      // Become an active object.
-      if (this->activate (flags, 1, 0, this->priority_) == -1)
-        {
-          ACE_DEBUG ((LM_ERROR, "(%P|%t) task activation failed, exiting!\n"));
-          ACE_OS::exit (1);
-        }
-
-      return 0;
-    }
-}
-
-int
-High_Priority_Task::svc (void)
-{
-  ACE_hthread_t thr_handle;
-  ACE_Thread::self (thr_handle);
-  int prio;
-
-  if (ACE_Thread::getprio (thr_handle, prio) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "getprio failed"), -1);
-
-#if defined (ACE_HAS_STHREADS)
-  ACE_DEBUG ((LM_DEBUG, "(%P|%u|%t) High: prio = %d, priority_ = %d\n",
-              _lwp_self (), prio, this->priority_));
-#else  /* ! ACE_HAS_STHREADS */
-  ACE_DEBUG ((LM_DEBUG, "(%P|%t) High: prio = %d, priority_ = %d\n",
-              prio, this->priority_));
-#endif /* ! ACE_HAS_STHREADS */
-  ACE_ASSERT (this->priority_ == prio);
-
-  ACE_Time_Value pause (0, read_period);
-
-  for (u_int i = 0; i < high_iterations; ++i)
-    {
-      time_ [i] = (u_long) ((ACE_OS::gethrtime () - starttime)/
-                            (ACE_UINT32) 1000000u);
-      ACE_OS::select (0, 0, 0, 0, &pause);
-    }
-
-  done_ = 1;
-
-  return 0;
-}
-
-void
-High_Priority_Task::print_times () const
-{
-  for (u_int i = 0; i < high_iterations; ++i)
-    {
-      ACE_DEBUG ((LM_INFO, "  iteration %u, time %u msec\n",
-                           i, time_ [i]));
-    }
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// class Low_Priority_Task
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-class Low_Priority_Task : public ACE_Task<ACE_SYNCH>
-{
-public:
-  Low_Priority_Task (const High_Priority_Task &);
-
-  int open (void *);
-  int svc (void);
-
-private:
-  int priority_;
-  const High_Priority_Task &high_priority_task_;
-};
-
-Low_Priority_Task::Low_Priority_Task (
-  const High_Priority_Task &high_priority_task)
-  : ACE_Task<ACE_SYNCH> (ACE_Thread_Manager::instance ()),
-    priority_ (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO,
-                                               ACE_SCOPE_THREAD)),
-    high_priority_task_ (high_priority_task)
-{
-}
-
-int
-Low_Priority_Task::open (void *)
-{
-  if (use_fork == 1)
-    {
-      ACE_hthread_t thr_handle;
-      ACE_Thread::self (thr_handle);
-
-      if (ACE_Thread::setprio (thr_handle, priority_) == -1)
-        ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "setprio failed"), -1);
-
-      return svc ();
-    }
-  else
-    {
-  long flags = THR_BOUND | THR_NEW_LWP | THR_SCHED_FIFO;
-
-  // Become an active object.
-  if (this->activate (flags, 1, 0, this->priority_) == -1)
-    ACE_ERROR ((LM_ERROR,
-                "(%P|%t) task activation failed, exiting!\n%a",
-                -1));
-  return 0;
-    }
-}
-
-int
-Low_Priority_Task::svc (void)
-{
-  ACE_hthread_t thr_handle;
-  ACE_Thread::self (thr_handle);
-  int prio;
-
-  if (ACE_Thread::getprio (thr_handle, prio) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "getprio failed"), -1);
-
-#if defined (ACE_HAS_STHREADS)
-  ACE_DEBUG ((LM_DEBUG, "(%P|%u|%t) Low: prio = %d, priority_ = %d\n",
-              _lwp_self (), prio, this->priority_));
-#else  /* ! ACE_HAS_STHREADS */
-  ACE_DEBUG ((LM_DEBUG, "(%P|%t) Low: prio = %d, priority_ = %d\n",
-              prio, this->priority_));
-#endif /* ! ACE_HAS_STHREADS */
-  ACE_ASSERT (this->priority_ == prio);
-
-  u_long iterations = 0;
-
-  // Chew up CPU for the entire interval.
-  for (;
-       ! high_priority_task_.done () && iterations < low_iterations;
-       ++iterations)
-    {
-      u_long n = 1279ul;  /* Takes about 40.2 usecs on a 168 MHz Ultra2. */
-      ACE::is_prime (n,
-                     2ul /* min_factor */,
-                     n/2 /* max_factor */);
-
-      if (low_yield)
-        ACE_OS::thr_yield ();
-    }
-
-  ACE_DEBUG ((LM_INFO, "Low completed %u iterations\n", iterations));
-
-  return 0;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// function get_options
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-static int
-get_options (int argc, ACE_TCHAR *argv[])
-{
-  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("fh:l:n:p:y?"));
-  int opt;
-  while ((opt = get_opt ()) != EOF) {
-    switch (opt) {
-    case 'f':
-      use_fork = 1;
-      break;
-    case 'h':
-      if (ACE_OS::atoi (get_opt.opt_arg ()) >= 2)
-        high_iterations = ACE_OS::atoi (get_opt.opt_arg ());
-      else
-        ACE_ERROR_RETURN ((LM_ERROR, "%n: high iterations must be >= 2\n"),
-                          -1);
-      break;
-    case 'l':
-      if (ACE_OS::atoi (get_opt.opt_arg ()) >= 2)
-        low_iterations = ACE_OS::atoi (get_opt.opt_arg ());
-      else
-        ACE_ERROR_RETURN ((LM_ERROR, "%n: low iterations must be >= 2\n"), -1);
-      break;
-    case 'n':
-      if (ACE_OS::atoi (get_opt.opt_arg ()) >= 1)
-        high_priority_tasks = ACE_OS::atoi (get_opt.opt_arg ());
-      else
-        ACE_ERROR_RETURN ((LM_ERROR, "%n: number of high priority threads "
-                           "must be >= 1\n"), -1);
-      break;
-    case 'p':
-      if (ACE_OS::atoi (get_opt.opt_arg ()) > 0)
-        read_period = ACE_OS::atoi (get_opt.opt_arg ());
-      else
-        ACE_ERROR_RETURN ((LM_ERROR, "%n: read period > 0\n"), -1);
-      break;
-    case 'y':
-      low_yield = 1;
-      break;
-    case '?':
-      ACE_DEBUG ((LM_ERROR, "usage: %n %s\n%a", usage, 0));
-      break;
-    default:
-      ACE_ERROR_RETURN ((LM_ERROR,
-                         "%n: unknown arg, %c\nusage: %n %s\n", opt, usage),
-                        -1);
-    }
-  }
-
-  switch (argc - get_opt.opt_ind ()) {
-  case 0:
-    // OK, no non-flag arguments.
-    break;
-  default:
-      ACE_ERROR_RETURN ((LM_ERROR,
-                         "%n: too many arguments\nusage: %n %s\n", usage),
-                        -1);
-  }
-
-  return 0;
-}
-
-#endif /* ACE_HAS_THREADS || ! ACE_LACKS_FORK */
-
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-// function main
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-int
-ACE_TMAIN (int argc, ACE_TCHAR *argv[])
-{
-  ACE_LOG_MSG->open (argv[0] ? argv[0] : ACE_TEXT("preempt"));
-
-#if defined (ACE_HAS_THREADS) || !defined (ACE_LACKS_FORK)
-
-  u_int i;
-
-  if (get_options (argc, argv))
-    ACE_OS::exit (-1);
-
-  // Enable FIFO scheduling, e.g., RT scheduling class on Solaris.
-  if (ACE_OS::sched_params (
-        ACE_Sched_Params (
-          ACE_SCHED_FIFO,
-          ACE_Sched_Params::priority_min (ACE_SCHED_FIFO),
-          ACE_SCOPE_PROCESS)) != 0)
-    {
-      if (ACE_OS::last_error () == EPERM)
-        ACE_DEBUG ((LM_MAX, "preempt: user is not superuser, "
-                    "so remain in time-sharing class\n"));
-      else
-        ACE_ERROR_RETURN ((LM_ERROR, "%n: ACE_OS::sched_params failed\n%a"),
-                          -1);
-    }
-
-  High_Priority_Task *high_priority_task;
-  ACE_NEW_RETURN (high_priority_task, High_Priority_Task [high_priority_tasks],
-                  1);
-
-  Low_Priority_Task low_priority_task (high_priority_task[0]);
-
-  if (! use_fork)
-    {
-      ACE_DEBUG ((LM_DEBUG,
-                  "(%P|%t) main (), wait for threads to exit . . .\n"));
-    }
-
-  // Save the start time, so that deltas can be displayed later.
-  starttime = ACE_OS::gethrtime ();
-
-  // Spawn the threads/processes . . .
-  pid_t child = 0;
-  if (use_fork == 1)
-    {
-      switch ((child = ACE_OS::fork (ACE_TEXT("preempt-low_priority_process"))))
-        {
-        case -1:
-          ACE_ERROR ((LM_ERROR, "%p\n%a", "fork failed"));
-          return -1;
-        case 0: // In child
-          {
-            low_priority_task.open (0);
-            break;
-          }
-        default: // In parent
-          for (i = 0; i < high_priority_tasks; ++i)
-            {
-              high_priority_task[i].open (0);
-            }
-          break;
-        }
-    }
-  else
-    {
-      for (i = 0; i < high_priority_tasks; ++i)
-        {
-          high_priority_task[i].open (0);
-        }
-      low_priority_task.open (0);
-
-#if defined (ACE_HAS_THREADS)
-     // Wait for all threads to exit.
-     ACE_Thread_Manager::instance ()->wait ();
-#endif /* ACE_HAS_THREADS */
-    }
-
-  // Display the time deltas.  They should be about a half second apart.
-  if (child || ! use_fork)
-    {
-      for (i = 0; i < high_priority_tasks; ++i)
-        {
-          ACE_DEBUG ((LM_DEBUG, "High priority task %u:\n", i + 1));
-          high_priority_task[i].print_times ();
-        }
-    }
-
-  delete [] high_priority_task;
-
-#else  /* ! ACE_HAS_THREADS && ACE_LACKS_FORK */
-  ACE_UNUSED_ARG (argc);
-  ACE_UNUSED_ARG (argv);
-  ACE_ERROR ((LM_ERROR, "threads and fork not supported on this platform\n"));
-#endif /* ! ACE_HAS_THREADS && ACE_LACKS_FORK */
-
-  return 0;
-}
diff --git a/performance-tests/Misc/test_guard.cpp b/performance-tests/Misc/test_guard.cpp
deleted file mode 100644
index 507f22bfff7..00000000000
--- a/performance-tests/Misc/test_guard.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-// $Id$
-
-// This test program illustrates the performance of ACE_Guard and
-// ACE_Thread_Mutex_Guard.
-
-#include "ace/Log_Msg.h"
-#include "ace/Get_Opt.h"
-#include "ace/Profile_Timer.h"
-
-#if !defined (ACE_USES_OBSOLETE_GUARD_CLASSES)
-#error You must compile ACE and this program with ACE_USES_OBSOLETE_GUARD_CLASSES defined!
-#endif /* ACE_USES_OBSOLETE_GUARD_CLASSES */
-
-ACE_RCSID(Misc, test_guard, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-# define ACE_THREAD_GUARD(OBJ,LOCK) \
-  ACE_Thread_Mutex_Guard OBJ (LOCK); \
-    if (OBJ.locked () == 0) return;
-
-static const int DEFAULT_ITERATIONS = 100000000;
-
-enum
-{
-  TEST_GUARD,
-  TEST_THR_GUARD,
-  TEST_END
-};
-
-ACE_Thread_Mutex lock_;
-typedef void (*guard_func)(void);
-int test_type = TEST_GUARD;
-int dummy = 0;
-
-void guard (void)
-{
-  ACE_GUARD (ACE_Thread_Mutex, _ace_mon, lock_);
-  dummy++;
-}
-
-void thr_guard (void)
-{
-  ACE_THREAD_GUARD (_ace_mon, lock_);
-  dummy++;
-}
-
-char *test_name[TEST_END] = { "ACE_Guard", "ACE_Thread_Mutex_Guard" };
-
-guard_func test_function=guard;
-
-int
-main (int argc, char *argv[])
-{
-  ACE_Profile_Timer timer;
-  ACE_Get_Opt getopt (argc, argv, "gtn:");
-  int iterations = DEFAULT_ITERATIONS;
-  int c, i;
-
-  while ((c = getopt()) != -1)
-    switch (c)
-      {
-#if defined (ACE_USES_OBSOLETE_GUARD_CLASSES)
-      case 't':
-        test_type = TEST_THR_GUARD;
-        test_function = thr_guard;
-        break;
-#endif /* ACE_USES_OBSOLETE_GUARD_CLASSES */
-      case 'g':
-        test_type = TEST_GUARD;
-        test_function = guard;
-        break;
-      case 'n':
-        iterations = ACE_OS::atoi (getopt.opt_arg ());
-        break;
-      default:
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "Invalid option\n"), -1);
-      }
-
-  ACE_DEBUG ((LM_DEBUG, "%s for iterations = %d\n", test_name[test_type], iterations));
-
-  timer.start ();
-
-  // Test the thread mutex (which doesn't use inheritance or dynamic
-  // binding).
-
-  for (i = 0; i < iterations; i++)
-    test_function ();
-
-  timer.stop ();
-
-  ACE_Profile_Timer::ACE_Elapsed_Time et;
-
-  timer.elapsed_time (et);
-
-  ACE_DEBUG ((LM_DEBUG, "Thread_Mutex\n"));
-  ACE_DEBUG ((LM_DEBUG, "real time = %f secs, user time = %f secs, system time = %f secs\n",
-              et.real_time, et.user_time, et.system_time));
-
-  ACE_DEBUG ((LM_DEBUG, "time per call = %f usecs\n",
-              (et.real_time / double (iterations)) * 1000000));
-
-  return 0;
-}
-#else
-int
-main (int, char *[])
-{
-  ACE_ERROR ((LM_ERROR, "threads not supported on this platform\n"));
-  return 0;
-}
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Misc/test_mutex.cpp b/performance-tests/Misc/test_mutex.cpp
deleted file mode 100644
index 0c7ccf33f0d..00000000000
--- a/performance-tests/Misc/test_mutex.cpp
+++ /dev/null
@@ -1,233 +0,0 @@
-// $Id$
-
-// This test program illustrates the performance difference between
-// three versions of wrappers for thread mutexes.  These three
-// versions exercise various combinations of the following classes:
-//
-// Thread_Mutex --
-//    This version is just like ACE_Thread_Mutex, which doesn't use
-//    inheritance and dynamic binding.
-//
-// Mutex_Base --
-//    This is an abstract base class that defines the
-//    acquire()/release() interface.
-//
-// Thread_Mutex_Derived --
-//    This derived from Mutex_Base and uses inheritance and
-//    dynamic binding.
-//
-// The following are the results I got when running this on our
-// SPARCstation 20 model 712:
-//
-// ./test_mutex 1000000
-// iterations = 1000000
-// Thread_Mutex
-// real time = 1.727843 secs, user time = 1.729262 secs, system time = 0.000325 secs
-// time per call = 1.747843 usecs
-// Thread_Mutex_Derived
-// real time = 1.730225 secs, user time = 1.724744 secs, system time = 0.000096 secs
-// time per call = 1.730225 usecs
-// Mutex_Base
-// real time = 2.112831 secs, user time = 2.104245 secs, system time = 0.000095 secs
-// time per call = 2.112831 usecs
-//
-// My conclusions are as follows:
-//
-// 1. If your C++ compiler optimizes calls to virtual functions that
-//    are made through instances of derived classes, then the
-//    performance of the Thread_Mutex and Thread_Mutex_Derived are
-//    essentially identical.
-//
-// 2. The overhead from using virtual functions is approximately
-//    20%.  Naturally, as the amount of contention goes up, the
-//    relative overhead of the virtual function calls will decrease.
-//
-// Keep in mind, however, that using virtual functions to implement
-// the Thread_Mutex will make it infeasible to put instances of
-// Thread_Mutex into shared memory since the vptrs won't point to the
-// correct vtables...
-
-#include "ace/Log_Msg.h"
-#include "ace/Profile_Timer.h"
-#include "ace/OS_main.h"
-#include "ace/OS_NS_Thread.h"
-
-ACE_RCSID(Misc, test_mutex, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-static const int DEFAULT_ITERATIONS = 100000000;
-
-// A thread mutex that doesn't use virtual functions.
-class Thread_Mutex
-{
-public:
-  Thread_Mutex (void);
-  ~Thread_Mutex (void);
-  int acquire (void);
-  int release (void);
-
-private:
-  ACE_mutex_t mutex_;
-};
-
-Thread_Mutex::Thread_Mutex (void)
-{
-  ACE_OS::mutex_init (&this->mutex_);
-}
-
-Thread_Mutex::~Thread_Mutex (void)
-{
-  ACE_OS::mutex_destroy (&this->mutex_);
-}
-
-inline int
-Thread_Mutex::acquire (void)
-{
-  return ACE_OS::mutex_lock (&this->mutex_);
-}
-
-inline int
-Thread_Mutex::release (void)
-{
-  return ACE_OS::mutex_unlock (&this->mutex_);
-}
-
-// Base class for mutex, declares pure virtual functions.
-class Mutex_Base
-{
-public:
-  virtual int acquire (void) = 0;
-  virtual int release (void) = 0;
-};
-
-// Subclass for threaded mutex, defines virtual functions.
-class Thread_Mutex_Derived : public Mutex_Base
-{
-public:
-  Thread_Mutex_Derived (void);
-  virtual ~Thread_Mutex_Derived (void);
-  virtual int acquire (void);
-  virtual int release (void);
-
-private:
-  ACE_mutex_t mutex_;
-};
-
-Thread_Mutex_Derived::Thread_Mutex_Derived (void)
-{
-  ACE_OS::mutex_init (&this->mutex_);
-}
-
-Thread_Mutex_Derived::~Thread_Mutex_Derived (void)
-{
-  ACE_OS::mutex_destroy (&this->mutex_);
-}
-
-inline int
-Thread_Mutex_Derived::acquire (void)
-{
-  return ACE_OS::mutex_lock (&this->mutex_);
-}
-
-inline int
-Thread_Mutex_Derived::release (void)
-{
-  return ACE_OS::mutex_unlock (&this->mutex_);
-}
-
-static Thread_Mutex thread_mutex;
-static Thread_Mutex_Derived thread_mutex_derived;
-static Mutex_Base *mutex_base = &thread_mutex_derived;
-
-int
-ACE_TMAIN (int argc, ACE_TCHAR *argv[])
-{
-  ACE_Profile_Timer timer;
-  int iterations = argc > 1 ? ACE_OS::atoi (argv[1]) : DEFAULT_ITERATIONS;
-  int i;
-
-  ACE_DEBUG ((LM_DEBUG, "iterations = %d\n", iterations));
-
-  timer.start ();
-
-  // Test the thread mutex (which doesn't use inheritance or dynamic
-  // binding).
-
-  for (i = 0; i < iterations; i++)
-    {
-      thread_mutex.acquire ();
-      thread_mutex.release ();
-    }
-
-  timer.stop ();
-
-  ACE_Profile_Timer::ACE_Elapsed_Time et;
-
-  timer.elapsed_time (et);
-
-  ACE_DEBUG ((LM_DEBUG, "Thread_Mutex\n"));
-  ACE_DEBUG ((LM_DEBUG, "real time = %f secs, user time = %f secs, system time = %f secs\n",
-	      et.real_time, et.user_time, et.system_time));
-
-  ACE_DEBUG ((LM_DEBUG, "time per call = %f usecs\n",
-	      (et.real_time / double (iterations)) * 1000000));
-
-  // Test the thread mutex derived (which does use inheritance or
-  // dynamic binding).  Note that we call this via an instance of the
-  // derived class, so good C++ compilers should optimize the virtual
-  // function calls in this case.
-
-  timer.start ();
-
-  for (i = 0; i < iterations; i++)
-    {
-      thread_mutex_derived.acquire ();
-      thread_mutex_derived.release ();
-    }
-
-  timer.stop ();
-
-  timer.elapsed_time (et);
-
-  ACE_DEBUG ((LM_DEBUG, "Thread_Mutex_Derived\n"));
-  ACE_DEBUG ((LM_DEBUG, "real time = %f secs, user time = %f secs, system time = %f secs\n",
-	      et.real_time, et.user_time, et.system_time));
-
-  ACE_DEBUG ((LM_DEBUG, "time per call = %f usecs\n",
-	      (et.real_time / double (iterations)) * 1000000));
-
-  // Test the thread mutex derived (which does use inheritance or
-  // dynamic binding).  Note that we call this via a pointer to the
-  // base class, which points to an instance of the derived class.
-  // Thus, C++ compilers won't be able to optimize the virtual
-  // function calls in this case.
-
-  timer.start ();
-
-  for (i = 0; i < iterations; i++)
-    {
-      mutex_base->acquire ();
-      mutex_base->release ();
-    }
-
-  timer.stop ();
-
-  timer.elapsed_time (et);
-
-  ACE_DEBUG ((LM_DEBUG, "Mutex_Base\n"));
-  ACE_DEBUG ((LM_DEBUG, "real time = %f secs, user time = %f secs, system time = %f secs\n",
-	      et.real_time, et.user_time, et.system_time));
-
-  ACE_DEBUG ((LM_DEBUG, "time per call = %f usecs\n",
-	      (et.real_time / double (iterations)) * 1000000));
-  return 0;
-}
-#else
-int
-ACE_TMAIN (int, ACE_TCHAR *[])
-{
-  ACE_ERROR ((LM_ERROR, "threads not supported on this platform\n"));
-  return 0;
-}
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Misc/test_naming.cpp b/performance-tests/Misc/test_naming.cpp
deleted file mode 100644
index f152053a16e..00000000000
--- a/performance-tests/Misc/test_naming.cpp
+++ /dev/null
@@ -1,193 +0,0 @@
-// $Id$
-
-// ============================================================================
-//
-// = LIBRARY
-//    performance_tests
-//
-// = FILENAME
-//    test_naming.cpp
-//
-// = DESCRIPTION
-//      This is an example to do performance testing of the Naming Service
-//      using both the normal Memory Pool as well as the light Memory Pool.
-//
-// = AUTHOR
-//    Prashant Jain
-//
-// ============================================================================
-
-#include "ace/OS_main.h"
-#include "ace/ACE.h"
-#include "ace/SString.h"
-#include "ace/Naming_Context.h"
-#include "ace/Profile_Timer.h"
-#include "ace/Log_Msg.h"
-#include "ace/OS_NS_stdio.h"
-
-ACE_RCSID(Misc, test_naming, "$Id$")
-
-
-#define ACE_NS_MAX_ENTRIES 4000
-
-static char name[BUFSIZ];
-static char value[BUFSIZ];
-static char type[BUFSIZ];
-
-void
-bind (ACE_Naming_Context *ns_context, int result)
-{
-  // do the binds
-  for (int i = 1; i <= ACE_NS_MAX_ENTRIES; i++)
-    {
-      if (i % 50 == 0)
-        ACE_DEBUG ((LM_DEBUG, "."));
-      ACE_OS::sprintf (name, "%s%d", "name", i);
-      ACE_NS_WString w_name (name);
-
-      ACE_OS::sprintf (value, "%s%d", "value", i);
-      ACE_NS_WString w_value (value);
-
-      ACE_OS::sprintf (type, "%s%d", "type", i);
-      if (ns_context->bind (w_name, w_value, type) != result) {
-        ACE_ERROR ((LM_ERROR, "bind failed!"));
-      }
-    }
-  ACE_DEBUG ((LM_DEBUG, "\n"));
-}
-
-void
-rebind (ACE_Naming_Context *ns_context, int result)
-{
-  // do the rebinds
-  for (int i = 1; i <= ACE_NS_MAX_ENTRIES; i++)
-    {
-      ACE_OS::sprintf (name, "%s%d", "name", i);
-      ACE_NS_WString w_name (name);
-      ACE_OS::sprintf (value, "%s%d", "value", -i);
-      ACE_NS_WString w_value (value);
-      ACE_OS::sprintf (type, "%s%d", "type", -i);
-      if (ns_context->rebind (w_name, w_value, type) != result) {
-        ACE_ERROR ((LM_ERROR, "rebind failed!"));
-      }
-    }
-}
-
-void
-unbind (ACE_Naming_Context *ns_context, int result)
-{
-  // do the unbinds
-  for (int i = 1; i <= ACE_NS_MAX_ENTRIES; i++)
-    {
-      ACE_OS::sprintf (name, "%s%d", "name", i);
-      ACE_NS_WString w_name (name);
-      if (ns_context->unbind (w_name) != result) {
-        ACE_ERROR ((LM_ERROR, "unbind failed!"));
-      }
-    }
-}
-
-void
-find (ACE_Naming_Context *ns_context, int sign, int result)
-{
-  char temp_val[BUFSIZ];
-  char temp_type[BUFSIZ];
-
-  // do the finds
-  for (int i = 1; i <= ACE_NS_MAX_ENTRIES; i++)
-    {
-      ACE_OS::sprintf (name, "%s%d", "name", i);
-      ACE_NS_WString w_name (name);
-
-      ACE_NS_WString w_value;
-      char *type_out;
-
-      if (sign == 1)
-        {
-          ACE_OS::sprintf (temp_val, "%s%d", "value", i);
-          ACE_OS::sprintf (temp_type, "%s%d", "type", i);
-        }
-      else
-        {
-          ACE_OS::sprintf (temp_val, "%s%d", "value", -i);
-          ACE_OS::sprintf (temp_type, "%s%d", "type", -i);
-        }
-
-      ACE_NS_WString val (temp_val);
-
-      int resolve_result = ns_context->resolve (w_name, w_value, type_out);
-      if (resolve_result != result) {
-        ACE_ERROR ((LM_ERROR, "resolved failed!"));
-      }
-      ACE_ASSERT (resolve_result == result);
-      ACE_UNUSED_ARG (resolve_result); // To avoid compile warning
-                                       // with ACE_NDEBUG.
-
-      if (w_value.char_rep ())
-        {
-          ACE_DEBUG ((LM_DEBUG, "Name: %s\tValue: %s\tType: %s\n",
-                      name, w_value.char_rep (), type_out));
-          ACE_ASSERT (w_value == val);
-          if (type_out)
-            {
-              ACE_ASSERT (::strcmp (type_out, temp_type) == 0);
-              delete[] type_out;
-            }
-        }
-    }
-}
-
-void do_testing (int argc, ACE_TCHAR *argv[], int light)
-{
-  ACE_Profile_Timer timer;
-
-  ACE_Naming_Context ns_context;
-  ACE_Name_Options *name_options = ns_context.name_options ();
-  name_options->parse_args (argc, argv);
-
-  if (light == 0)  // Use SYNC
-    {
-      name_options->database (ACE::basename (name_options->process_name (),
-                                             ACE_DIRECTORY_SEPARATOR_CHAR));
-      ns_context.open (ACE_Naming_Context::PROC_LOCAL);
-    }
-  else  // Use NO-SYNC
-    {
-      const ACE_TCHAR *p = ACE::basename (name_options->process_name (),
-                                          ACE_DIRECTORY_SEPARATOR_CHAR);
-      ACE_TCHAR s[5 /* strlen ("light") */ + MAXNAMELEN + 1];
-      ACE_OS::sprintf (s, ACE_TEXT("light%s"), p);
-      name_options->database (s);
-      ns_context.open (ACE_Naming_Context::PROC_LOCAL, 1);
-    }
-
-  // Add bindings to the database
-  ACE_DEBUG ((LM_DEBUG, "Binding\n"));
-
-  timer.start ();
-  bind (&ns_context, 0);
-
-  ACE_DEBUG ((LM_DEBUG, "Unbinding\n"));
-  unbind (&ns_context, 0);
-  timer.stop ();
-
-  ACE_Profile_Timer::ACE_Elapsed_Time et;
-
-  timer.elapsed_time (et);
-  ACE_DEBUG ((LM_DEBUG, "real time = %f secs, user time = %f secs, system time = %f secs\n",
-              et.real_time, et.user_time, et.system_time));
-}
-
-
-int
-ACE_TMAIN (int argc, ACE_TCHAR *argv[])
-{
-  // Do testing with SYNC on
-  ACE_DEBUG ((LM_DEBUG, "SYNC is ON\n"));
-  do_testing (argc, argv, 0);
-
-  // Do testing with SYNC off
-  ACE_DEBUG ((LM_DEBUG, "SYNC is OFF\n"));
-  do_testing (argc, argv, 1);
-  return 0;
-}
diff --git a/performance-tests/Misc/test_singleton.cpp b/performance-tests/Misc/test_singleton.cpp
deleted file mode 100644
index b888f21d276..00000000000
--- a/performance-tests/Misc/test_singleton.cpp
+++ /dev/null
@@ -1,183 +0,0 @@
-// $Id$
-
-// This example illustrates the performance impact of using the
-// Double-Checked Locking pattern compared with using the "standard"
-// practice of acquiring and releasing a lock on every instance()
-// call.  In addition, we compare the performance of using the
-// ACE_Singleton (which encapsulates the Double-Check Locking pattern)
-// vs. hand-coding the pattern.
-//
-// Here's the output from running this test on our SPARCstation 20, model 712s.
-//
-// ./test_singleton 1000000
-// iterations = 1000000
-// ACE_Singleton
-// real time = 0.193731 secs, user time = 0.190416 secs, system time = 0.000549 secs
-// time per call = 0.193731 usecs
-// DC_Singleton
-// real time = 0.176208 secs, user time = 0.176045 secs, system time = 0.000092 secs
-// time per call = 0.176208 usecs
-// Mutex_Singleton
-// real time = 3.160998 secs, user time = 3.121434 secs, system time = 0.000109 secs
-// time per call = 3.160998 usecs
-//
-// As you can see, both Double-Checked Locking implementations are about
-// 15 times faster than the standard mutex version.  Moreover,
-// this test is run with only a single thread, so there's no contention
-// for the lock.  If there were multiple threads contending for the lock,
-// the Mutex_Singleton performance would get increasing worse...
-
-#include "ace/OS_main.h"
-#include "ace/Guard_T.h"
-#include "ace/Profile_Timer.h"
-#include "ace/Singleton.h"
-#include "ace/Synch_Traits.h"
-#include "ace/Log_Msg.h"
-
-#include "test_singleton.h"
-
-ACE_RCSID(Misc, test_singleton, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-static const int DEFAULT_ITERATIONS = 100000000;
-
-class Mutex_Singleton
-{
-public:
-  Mutex_Singleton (void) {}
-  void svc (void) {}
-  static Mutex_Singleton *instance (void);
-
-private:
-  static ACE_SYNCH_MUTEX lock_;
-  static Mutex_Singleton *instance_;
-};
-
-ACE_SYNCH_MUTEX Mutex_Singleton::lock_;
-
-Mutex_Singleton *Mutex_Singleton::instance_;
-
-Mutex_Singleton *
-Mutex_Singleton::instance (void)
-{
-  // Acquire the lock every time in.
-  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, Mutex_Singleton::lock_, 0);
-
-  if (Mutex_Singleton::instance_ == 0)
-    ACE_NEW_RETURN (Mutex_Singleton::instance_, Mutex_Singleton, 0);
-
-  return Mutex_Singleton::instance_;
-}
-
-ACE_SYNCH_MUTEX DC_Singleton::lock_;
-
-DC_Singleton *DC_Singleton::instance_;
-
-DC_Singleton *
-DC_Singleton::instance (void)
-{
-  if (DC_Singleton::instance_ == 0)
-    {
-      // Only lock if instance_ isn't 0.
-      ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, DC_Singleton::lock_, 0);
-
-      // Perform the Double-Check.
-      if (DC_Singleton::instance_ == 0)
-	ACE_NEW_RETURN (DC_Singleton::instance_, DC_Singleton, 0);
-    }
-
-  return DC_Singleton::instance_;
-}
-
-typedef ACE_Singleton <DC_Singleton, ACE_SYNCH_MUTEX> My_Singleton;
-
-int
-ACE_TMAIN (int argc, ACE_TCHAR *argv[])
-{
-  ACE_Profile_Timer timer;
-  int iterations = argc > 1 ? ACE_OS::atoi (argv[1]) : DEFAULT_ITERATIONS;
-  int i;
-
-  ACE_DEBUG ((LM_DEBUG, "iterations = %d\n", iterations));
-
-  // Test the ACE_Singleton performance (which uses Double-Checked
-  // Locking).
-
-  timer.start ();
-
-  for (i = 0; i < iterations; i++)
-    My_Singleton::instance ()->svc ();
-
-  timer.stop ();
-
-  ACE_Profile_Timer::ACE_Elapsed_Time et;
-
-  timer.elapsed_time (et);
-
-  ACE_DEBUG ((LM_DEBUG, "ACE_Singleton\n"));
-  ACE_DEBUG ((LM_DEBUG, "real time = %f secs, user time = %f secs, system time = %f secs\n",
-	    et.real_time, et.user_time, et.system_time));
-
-  ACE_DEBUG ((LM_DEBUG, "time per call = %f usecs\n",
-	      (et.real_time / double (iterations)) * 1000000));
-
-  // Test the hand-coded Singleton performance (which uses
-  // Double-Checked Locking).
-
-  timer.start ();
-
-  for (i = 0; i < iterations; i++)
-    DC_Singleton::instance ()->svc ();
-
-  timer.stop ();
-
-  timer.elapsed_time (et);
-
-  ACE_DEBUG ((LM_DEBUG, "DC_Singleton\n"));
-  ACE_DEBUG ((LM_DEBUG, "real time = %f secs, user time = %f secs, system time = %f secs\n",
-	      et.real_time, et.user_time, et.system_time));
-
-  ACE_DEBUG ((LM_DEBUG, "time per call = %f usecs\n",
-	      (et.real_time / double (iterations)) * 1000000));
-
-  // Test the Mutex_Singleton implementation (which does not use
-  // Double-Checked Locking).
-
-  timer.start ();
-
-  for (i = 0; i < iterations; i++)
-    Mutex_Singleton::instance ()->svc ();
-
-  timer.stop ();
-
-  timer.elapsed_time (et);
-
-  ACE_DEBUG ((LM_DEBUG, "Mutex_Singleton\n"));
-  ACE_DEBUG ((LM_DEBUG, "real time = %f secs, user time = %f secs, system time = %f secs\n",
-	      et.real_time, et.user_time, et.system_time));
-
-  ACE_DEBUG ((LM_DEBUG, "time per call = %f usecs\n",
-	      (et.real_time / double (iterations)) * 1000000));
-
-  return 0;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class ACE_Singleton<DC_Singleton, ACE_SYNCH_MUTEX>;
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate ACE_Singleton<DC_Singleton, ACE_SYNCH_MUTEX>
-#elif defined (ACE_HAS_EXPLICIT_STATIC_TEMPLATE_MEMBER_INSTANTIATION)
-template ACE_Singleton<DC_Singleton, ACE_SYNCH_MUTEX> *
-  ACE_Singleton<DC_Singleton, ACE_SYNCH_MUTEX>::singleton_;
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-
-#else
-int
-ACE_TMAIN (int, ACE_TCHAR *[])
-{
-  ACE_ERROR ((LM_ERROR, "threads not supported on this platform\n"));
-  return 0;
-}
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Misc/test_singleton.h b/performance-tests/Misc/test_singleton.h
deleted file mode 100644
index 70aef65d89b..00000000000
--- a/performance-tests/Misc/test_singleton.h
+++ /dev/null
@@ -1,24 +0,0 @@
-// $Id$
-
-// Define the DC_Singleton here - it needs to be in a separate file to
-// get picked up correctly on AIX with auto template instantiation using
-// IBM C++ compiler (xlC).
-
-#ifndef __TEST_SINGLETON_H
-#define __TEST_SINGLETON_H
-
-#include "ace/Synch_Traits.h"
-
-class DC_Singleton
-{
-public:
-  DC_Singleton (void) {}
-  void svc (void) {}
-  static DC_Singleton *instance (void);
-
-private:
-  static ACE_SYNCH_MUTEX lock_;
-  static DC_Singleton *instance_;
-};
-
-#endif /* __TEST_SINGLETON_H */
diff --git a/performance-tests/README b/performance-tests/README
deleted file mode 100644
index 36751c061fe..00000000000
--- a/performance-tests/README
+++ /dev/null
@@ -1,16 +0,0 @@
-The subdirectories in this directory provide a number of benchmarks
-that use ACE features to determine performance of various concurrency
-and communication mechanisms.
-
-        . Synch-Benchmarks -- Implements a number of benchmarks
-          that test the performance of various synchronization
-          mechanisms.
-
-        . TTCP -- Implements several variants of the TTCP benchmarking
-          test for TCP and UCP using C sockets and ACE C++ wrappers.
-
-        . UDP -- Contains UDP test, which measures UDP round-trip
-          performance.
-
-        . Misc -- Miscellaneous tests, e.g., Double-Checked Locking,
-          context switching, mutexes, naming, etc.
diff --git a/performance-tests/RPC/README b/performance-tests/RPC/README
deleted file mode 100644
index 49b9131733e..00000000000
--- a/performance-tests/RPC/README
+++ /dev/null
@@ -1,6 +0,0 @@
-# $Id$
-
-	Measure latency over RPC, run as:
-
-$ server
-$ client -n <samples> -k host
diff --git a/performance-tests/RPC/RPC.mpc b/performance-tests/RPC/RPC.mpc
deleted file mode 100644
index feccec74ce5..00000000000
--- a/performance-tests/RPC/RPC.mpc
+++ /dev/null
@@ -1,17 +0,0 @@
-// -*- MPC -*-
-// $Id$
-
-project(*client) : aceexe, rpc {
-  source_files {
-    client.cpp
-    ping_clnt.c
-  }
-}
-
-project(*server) : aceexe, rpc {
-  exename = server
-  source_files {
-    server.c
-    ping_svc.c
-  }
-}
\ No newline at end of file
diff --git a/performance-tests/RPC/client.cpp b/performance-tests/RPC/client.cpp
deleted file mode 100644
index b0f4a476600..00000000000
--- a/performance-tests/RPC/client.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * $Id$
- */
-#include "ace/Stats.h"
-#include "ace/High_Res_Timer.h"
-#include "ace/Get_Opt.h"
-
-#include "ping.h"
-
-int main (int argc, char* argv[])
-{
-  const char* host = 0;
-  int nsamples = 10000;
-  int c;
-
-  ACE_Get_Opt getopt (argc, argv, "h:i:");
-
-  while ((c = getopt ()) != -1)
-    {
-      switch ((char) c)
-        {
-        case 'h':
-          host = getopt.opt_arg ();
-          break;
-
-        case 'i':
-          nsamples = ACE_OS::atoi (getopt.opt_arg ());
-          break;
-        }
-    }
-
-  if (host == 0)
-    {
-      ACE_DEBUG ((LM_DEBUG, "Usage: client -h host -i iterations\n"));
-      return 1;
-    }
-
-  CLIENT *cl =
-    clnt_create (host, PINGPROG, PINGVERS, "tcp");
-
-  if (cl == 0)
-    {
-      ACE_DEBUG ((LM_DEBUG, "Cannot create client handle\n"));
-      return 1;
-    }
-
-  ACE_Throughput_Stats throughput;
-
-  ACE_hrtime_t test_start = ACE_OS::gethrtime ();
-  for (int i = 0; i != nsamples; ++i)
-    {
-      ACE_hrtime_t start = ACE_OS::gethrtime ();
-
-      int p = 0;
-      (void) ping_1 (&p, cl);
-
-      ACE_hrtime_t end = ACE_OS::gethrtime ();
-
-      throughput.sample (end - test_start,
-                         end - start);
-
-    }
-
-  ACE_DEBUG ((LM_DEBUG, "Calibrating high resolution timer . . ."));
-  ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor ();
-  ACE_DEBUG ((LM_DEBUG, " done\n"));
-
-  throughput.dump_results ("Client", gsf);
-
-
-  return 0;
-}
diff --git a/performance-tests/RPC/ping.x b/performance-tests/RPC/ping.x
deleted file mode 100644
index ea078ffe139..00000000000
--- a/performance-tests/RPC/ping.x
+++ /dev/null
@@ -1,12 +0,0 @@
-/*
- * $Id$
- */
-
-/*
- * A small program to test RPC round-trip delays.
- */
-program PINGPROG {
-  version PINGVERS {
-    int PING (int) = 1;
-  } = 1;
-} = 0x20000001;
diff --git a/performance-tests/RPC/run_test.pl b/performance-tests/RPC/run_test.pl
deleted file mode 100755
index 305509dc83a..00000000000
--- a/performance-tests/RPC/run_test.pl
+++ /dev/null
@@ -1,34 +0,0 @@
-eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
-     & eval 'exec perl -S $0 $argv:q'
-     if 0;
-
-# $Id$
-# -*- perl -*-
-
-use lib '../../bin';
-use PerlACE::Run_Test;
-
-$SV = new PerlACE::Process ("server");
-$CL = new PerlACE::Process ("client", "-i 10000 -h localhost");
-
-$status = 0;
-
-$SV->Spawn ();
-
-sleep 5;
-
-$client = $CL->SpawnWaitKill (60);
-
-$server = $SV->WaitKill (5);
-
-if ($server != 0) {
-    print "ERROR: server returned $server\n";
-    $status = 1;
-}
-
-if ($client != 0) {
-    print "ERROR: client returned $client\n";
-    $status = 1;
-}
-
-exit $status;
diff --git a/performance-tests/RPC/server.c b/performance-tests/RPC/server.c
deleted file mode 100644
index 2f8526a6733..00000000000
--- a/performance-tests/RPC/server.c
+++ /dev/null
@@ -1,15 +0,0 @@
-/*
- * $Id$
- */
-
-#include "ping.h"
-#include <rpc/rpc.h>
-#include <stdio.h>
-
-static int return_value = 0;
-
-int* ping_1_svc (int* value, struct svc_req* r)
-{
-  return_value = *value;
-  return &return_value;
-}
diff --git a/performance-tests/SCTP/Options_Manager.cpp b/performance-tests/SCTP/Options_Manager.cpp
deleted file mode 100644
index 8bfbc42a270..00000000000
--- a/performance-tests/SCTP/Options_Manager.cpp
+++ /dev/null
@@ -1,528 +0,0 @@
-// -*- C++ -*-
-
-// $Id$
-
-extern "C" {
-#include "ace/os_include/sys/os_types.h"
-}
-
-#include "ace/Get_Opt.h"
-#include "ace/os_include/netinet/os_in.h"
-#include "ace/OS_NS_stdlib.h"
-#include "ace/OS_NS_string.h"
-
-// make sure that the code compiles cleanly even if SCTP is not
-// available. If SCTP is not installed, program will exit early in
-// main() with an error message.
-#ifdef ACE_HAS_SCTP
-extern "C" {
-#include <netinet/sctp.h>
-};
-#else
-#ifndef IPPROTO_SCTP
-#define IPPROTO_SCTP 132 /* always the same value on every platform */
-#endif
-#endif
-
-#include "Options_Manager.h"
-
-// FUZZ: disable check_for_streams_include
-#include "ace/streams.h"
-
-#include "ace/OS_NS_stdio.h"
-#include "ace/OS_NS_arpa_inet.h"
-
-// Set default values
-ACE_CDR::ULong Options_Manager::test_iterations=1000000;
-ACE_CDR::Boolean Options_Manager::test_enable_nagle=0;
-ACE_CDR::Long Options_Manager::test_transport_protocol=IPPROTO_SCTP;
-ACE_CDR::Double Options_Manager::histogram_min_bin=0.0;
-ACE_CDR::Double Options_Manager::histogram_max_bin=10000.0;
-ACE_CDR::ULong Options_Manager::histogram_num_outliers=100;
-ACE_CDR::ULong Options_Manager::histogram_bin_count=1000;
-ACE_CDR::UShort Options_Manager::client_port = 0;
-ACE_CDR::ULong Options_Manager::client_connect_addr=INADDR_ANY;
-ACE_CDR::UShort Options_Manager::server_port = 45453;
-ACE_TCHAR Options_Manager::server_host[Options_Manager::string_len];
-ACE_CDR::ULong Options_Manager::server_accept_addr=INADDR_ANY;
-ACE_CDR::UShort Options_Manager::payload_size_power_of_2=31;
-ACE_CDR::ULong Options_Manager::secondary_connect_addrs[max_num_secondary_connect_addrs];
-ACE_CDR::UShort Options_Manager::num_secondary_connect_addrs = 0;
-ACE_CDR::ULong Options_Manager::secondary_accept_addrs[max_num_secondary_accept_addrs];
-ACE_CDR::UShort Options_Manager::num_secondary_accept_addrs = 0;
-ACE_CDR::UShort Options_Manager::_usage = 0;
-ACE_CDR::UShort Options_Manager::_error = 0;
-ACE_TCHAR Options_Manager::__program_name[Options_Manager::string_len];
-ACE_CDR::Boolean Options_Manager::__initialized=0;
-const ACE_TCHAR* Options_Manager::_error_message;
-
-
-Options_Manager::Options_Manager(int argc, ACE_TCHAR **argv, ACE_TCHAR const * const opts_set)
-{
-  if (!__initialized) {
-    // Set default values that were not set during static initialization
-    ACE_OS::strcpy(server_host, "localhost");
-
-    // Remember argv[0]
-    if (strlen(argv[0]) < Options_Manager::string_len)
-      ACE_OS::strcpy(__program_name, argv[0]);
-    else{
-      ACE_OS::strncpy(__program_name, argv[0], (Options_Manager::string_len-1));
-      __program_name[Options_Manager::string_len - 1] = '\0';
-    }
-
-    // Declare options with ACE_Get_Opt
-    int c;
-    ACE_Get_Opt * get_opt=NULL;
-    if (!ACE_OS::strcmp("client-opts", opts_set)){
-      get_opt = new ACE_Get_Opt(argc, argv, ACE_TEXT("c:nt:m:M:x:b:C:i:p:H:s:h"));
-
-      get_opt->long_option("test_iterations",         'c', ACE_Get_Opt::ARG_REQUIRED);
-      get_opt->long_option("test_enable_nagle",       'n');
-      get_opt->long_option("test_transport_protocol", 't', ACE_Get_Opt::ARG_REQUIRED);
-      get_opt->long_option("histogram_min_bin",       'm', ACE_Get_Opt::ARG_REQUIRED);
-      get_opt->long_option("histogram_max_bin",       'M', ACE_Get_Opt::ARG_REQUIRED);
-      get_opt->long_option("histogram_num_outliers",  'x', ACE_Get_Opt::ARG_REQUIRED);
-      get_opt->long_option("histogram_bin_count",     'b', ACE_Get_Opt::ARG_REQUIRED);
-      get_opt->long_option("client_port",             'C', ACE_Get_Opt::ARG_REQUIRED);
-      get_opt->long_option("client_accept_addr",      'i', ACE_Get_Opt::ARG_REQUIRED);
-      get_opt->long_option("server_port",             'p', ACE_Get_Opt::ARG_REQUIRED);
-      get_opt->long_option("server_host",             'H', ACE_Get_Opt::ARG_REQUIRED);
-      get_opt->long_option("payload_size_power_of_2", 's', ACE_Get_Opt::ARG_REQUIRED);
-      get_opt->long_option("help",                    'h');
-    } else if (!ACE_OS::strcmp("server-opts", opts_set)){
-      get_opt = new ACE_Get_Opt(argc, argv, ACE_TEXT("nt:p:a:u"));
-      get_opt->long_option("test_enable_nagle",       'n');
-      get_opt->long_option("test_transport_protocol", 't', ACE_Get_Opt::ARG_REQUIRED);
-      get_opt->long_option("server_port",             'p', ACE_Get_Opt::ARG_REQUIRED);
-      get_opt->long_option("server_accept_addr",      'a', ACE_Get_Opt::ARG_REQUIRED);
-      get_opt->long_option("help",                    'h');
-    } else {
-      _error = 1;
-      _error_message = "invalid options set specified";
-      delete get_opt;
-      return;
-    }
-
-    // Parse options with ACE_Get_Opt
-    while ((c = (*get_opt)()) != -1)
-      {
-        switch ((char) c)
-          {
-          case 'c':
-            test_iterations        = ACE_OS::atoi(get_opt->opt_arg ());
-            break;
-          case 'n':
-            test_enable_nagle     = 1;
-            break;
-          case 't':{
-            char const * const str=get_opt->opt_arg();
-            if (!ACE_OS::strcmp(str, "tcp"))
-              test_transport_protocol = IPPROTO_TCP;
-            else if (!ACE_OS::strcmp(str, "sctp"))
-              test_transport_protocol = IPPROTO_SCTP;
-            else
-              test_transport_protocol = -1;
-            break;
-          }
-          case 'm':
-            histogram_min_bin      = ACE_OS::strtod(get_opt->opt_arg (), 0);
-            break;
-          case 'M':
-            histogram_max_bin      = ACE_OS::strtod(get_opt->opt_arg (), 0);
-            break;
-          case 'x':
-            histogram_num_outliers = ACE_OS::atoi(get_opt->opt_arg ());
-            break;
-          case 'b':
-            histogram_bin_count    = ACE_OS::atoi(get_opt->opt_arg ());
-            break;
-          case 'C':
-            client_port            = ACE_OS::atoi(get_opt->opt_arg ());
-            break;
-          case 'i':{
-
-            // The argument to this option is a comma-separated list
-            // of dotted-decimal ipv4 addresses.
-
-            // Create a writable copy of the options argument
-            char str[Options_Manager::string_len];
-            ACE_OS::strncpy(str, get_opt->opt_arg(), Options_Manager::string_len);
-
-            // Get a pointer to the first comma in the list
-            char *next_secondary_addr = ACE_OS::strchr(str, ',');
-
-            // If found, the comma is replaced with \0 and pointer
-            // updated to point to the string that begins immediately
-            // after the comma.
-            if (next_secondary_addr) {
-              *next_secondary_addr = '\0';
-              ++next_secondary_addr;
-            }
-
-            // Obtain the 32-bit, host-byte-order representation of
-            // the primary address.
-            struct in_addr foo;
-            int aton_retval = ACE_OS::inet_aton(str, &foo);
-
-            // If this representation was not obtained, terminate with
-            // an error.
-            if (!aton_retval) {
-
-              char error_message[Options_Manager::string_len + 100];
-              ACE_OS::sprintf(error_message,
-                              "Could not make sense of primary "
-                              "address: %s",
-                              str);
-
-              _error = 1;
-              _error_message = ACE_OS::strdup(error_message);
-              break;
-            }
-
-            // Otherwise, store the representation in the
-            // client_connect_addr member variable.
-            client_connect_addr = ntohl(foo.s_addr);
-
-//              ACE_DEBUG ((LM_DEBUG,
-//                          "Primary connect addr: %s     retval = %d\n",
-//                          str,
-//                      aton_retval));
-
-//              if (next_secondary_addr) {
-//                ACE_DEBUG ((LM_DEBUG,
-//                            "Secondary addr(s) remaining to be parsed: %s\n",
-//                            next_secondary_addr));
-//              } else {
-//                ACE_DEBUG ((LM_DEBUG,
-//                            "No secondary addr remaining to be parsed.\n"));
-//              }
-
-            // The following loop parses secondary addresses from the
-            // list.  The loop repeats as long as ACE_OS::strchr
-            // returns non-null (i.e., as long as yet another comma is
-            // found.
-            while (next_secondary_addr &&
-                   num_secondary_connect_addrs <
-                   max_num_secondary_connect_addrs) {
-
-              // Get a pointer to the next comma in the list.
-              char *next_next_secondary_addr = ACE_OS::strchr(next_secondary_addr, ',');
-
-              // If found, the comma is replaced with \0 and pointer
-              // updated to point to the string that begins immediately
-              // after the comma.
-              if (next_next_secondary_addr) {
-                *next_next_secondary_addr = '\0';
-                ++next_next_secondary_addr;
-              }
-
-              // Obtain the 32-bit, host-byte-order representation of
-              // a secondary address.
-              aton_retval = ACE_OS::inet_aton(next_secondary_addr, &foo);
-
-              // If the representation was obtained without error,
-              // store it in the next available slot of the
-              // secondary_connect_addrs array.  Otherwise, terminate
-              // with an error.
-              if (aton_retval) {
-                secondary_connect_addrs[num_secondary_connect_addrs++] =
-                  ntohl(foo.s_addr);
-              } else {
-
-                char error_message[Options_Manager::string_len + 100];
-                ACE_OS::sprintf(error_message,
-                                "Could not make sense of secondary "
-                                "address: %s",
-                                next_secondary_addr);
-
-                _error = 1;
-                _error_message = ACE_OS::strdup(error_message);
-                break;
-              }
-
-//                ACE_DEBUG ((LM_DEBUG,
-//                            "secondary_addr[%d] = %s      retval = %d\n",
-//                            num_secondary_connect_addrs - 1,
-//                            next_secondary_addr,
-//                        aton_retval));
-
-              next_secondary_addr = next_next_secondary_addr;
-            }
-
-            break;
-          }
-          case 'p':
-            server_port = ACE_OS::atoi(get_opt->opt_arg ());
-            break;
-          case 'a':{
-
-            // The argument to this option is a comma-separated list
-            // of dotted-decimal ipv4 addresses.
-
-            // Create a writable copy of the options argument
-            char str[Options_Manager::string_len];
-            ACE_OS::strncpy(str, get_opt->opt_arg(), Options_Manager::string_len);
-
-            // Get a pointer to the first comma in the list
-            char *next_secondary_addr = ACE_OS::strchr(str, ',');
-
-            // If found, the comma is replaced with \0 and pointer
-            // updated to point to the string that begins immediately
-            // after the comma.
-            if (next_secondary_addr) {
-              *next_secondary_addr = '\0';
-              ++next_secondary_addr;
-            }
-
-            // Obtain the 32-bit, host-byte-order representation of
-            // the primary address.
-            struct in_addr foo;
-            int aton_retval = ACE_OS::inet_aton(str, &foo);
-
-            // If this representation was not obtained, terminate with
-            // an error.
-            if (!aton_retval) {
-
-              char error_message[Options_Manager::string_len + 100];
-              ACE_OS::sprintf(error_message,
-                              "Could not make sense of primary "
-                              "address: %s",
-                              str);
-
-              _error = 1;
-              _error_message = ACE_OS::strdup(error_message);
-              break;
-            }
-
-            // Otherwise, store the representation in the
-            // server_accept_addr member variable.
-            server_accept_addr = ntohl(foo.s_addr);
-
-//              ACE_DEBUG ((LM_DEBUG,
-//                          "Primary accept addr: %s     retval = %d\n",
-//                          str,
-//                      aton_retval));
-
-//              if (next_secondary_addr) {
-//                ACE_DEBUG ((LM_DEBUG,
-//                            "Secondary addr(s) remaining to be parsed: %s\n",
-//                            next_secondary_addr));
-//              } else {
-//                ACE_DEBUG ((LM_DEBUG,
-//                            "No secondary addr remaining to be parsed.\n"));
-//              }
-
-            // The following loop parses secondary addresses from the
-            // list.  The loop repeats as long as ACE_OS::strchr
-            // returns non-null (i.e., as long as yet another comma is
-            // found.
-            while (next_secondary_addr &&
-                   num_secondary_accept_addrs <
-                   max_num_secondary_accept_addrs) {
-
-              // Get a pointer to the next comma in the list.
-              char *next_next_secondary_addr = ACE_OS::strchr(next_secondary_addr, ',');
-
-              // If found, the comma is replaced with \0 and pointer
-              // updated to point to the string that begins immediately
-              // after the comma.
-              if (next_next_secondary_addr) {
-                *next_next_secondary_addr = '\0';
-                ++next_next_secondary_addr;
-              }
-
-              // Obtain the 32-bit, host-byte-order representation of
-              // a secondary address.
-              aton_retval = ACE_OS::inet_aton(next_secondary_addr, &foo);
-
-              // If the representation was obtained without error,
-              // store it in the next available slot of the
-              // secondary_accept_addrs array.  Otherwise, terminate
-              // with an error.
-              if (aton_retval) {
-                secondary_accept_addrs[num_secondary_accept_addrs++] =
-                  ntohl(foo.s_addr);
-              } else {
-
-                char error_message[Options_Manager::string_len + 100];
-                ACE_OS::sprintf(error_message,
-                                "Could not make sense of secondary "
-                                "address: %s",
-                                next_secondary_addr);
-
-                _error = 1;
-                _error_message = ACE_OS::strdup(error_message);
-                break;
-              }
-
-//                ACE_DEBUG ((LM_DEBUG,
-//                            "secondary_addr[%d] = %s      retval = %d\n",
-//                            num_secondary_accept_addrs - 1,
-//                            next_secondary_addr,
-//                        aton_retval));
-
-              next_secondary_addr = next_next_secondary_addr;
-            }
-
-            break;
-          }
-          case 'H':{
-            char const * const str=get_opt->opt_arg();
-            if (strlen(str) < Options_Manager::string_len)
-              ACE_OS::strcpy(server_host, str);
-            else{
-              ACE_OS::strncpy(server_host, str, (Options_Manager::string_len-1));
-              server_host[Options_Manager::string_len - 1] = '\0';
-            }
-            break;
-          }
-          case 's':
-            payload_size_power_of_2 = ACE_OS::atoi(get_opt->opt_arg ());
-            break;
-          case 'h':
-            _usage = 1;
-            break;
-          }
-      }
-
-    // Check option values
-    if (test_iterations < 1)
-      {
-        _error = 1;
-        _error_message = "test_iterations must be no less than than 1";
-      }
-
-    if (histogram_min_bin < 0.0)
-      {
-        _error = 1;
-        _error_message = "histogram_min_bin must be no less than 0.0";
-      }
-
-    if (histogram_max_bin < histogram_min_bin)
-      {
-        _error = 1;
-        _error_message = "histogram_max_bin must be no less than histogram_min_bin";
-      }
-
-    if (histogram_num_outliers < 1)
-      {
-        _error = 1;
-        _error_message = "histogram_num_outliers must be no less than 1";
-      }
-
-    if (histogram_bin_count < 1)
-      {
-        _error = 1;
-        _error_message = "histogram_bin_count must be no less than 1";
-      }
-
-    if ((server_port < 1010 ||
-        server_port > 65000) && server_port != 0)
-      {
-        _error = 1;
-        _error_message = "server_port must be between 1010 and 65000 inclusive, or zero.";
-      }
-
-    if ((!ACE_OS::strcmp("client-opts", opts_set)) && payload_size_power_of_2 > 17)
-      {
-        _error = 1;
-        _error_message = "payload_size_power_of_2 must be specified between 0 and 16 inclusive";
-      }
-
-    if (test_transport_protocol == -1) {
-      _error = 1;
-      _error_message = "test_transport_protocol may only take 'sctp' and 'tcp' as values";
-    }
-
-    __initialized = 1;
-
-    delete get_opt;
-  }
-}
-
-void Options_Manager::_show_usage(ostream& out, ACE_TCHAR const * const opts_set)
-{
-  // Show usage message.  KEEP THE DEFAULTS DISPLAYED HERE IN SYNC
-  // WITH THE DEFAULTS SET AT THE BEGINNING OF THE CONSTRUCTOR.
-
-  out << __program_name << " - Measures round trip latency statistics of ACE synchronous" << endl;
-  // indent past program name
-  for (unsigned int i=0;i<ACE_OS::strlen(__program_name);++i)
-    out << " ";
-
-  if (ACE_OS::strstr(__program_name, "SOCK_STREAM_clt") || ACE_OS::strstr(__program_name, "SOCK_STREAM_srv")) {
-    out << "   messaging (SOCK_Stream) using unmarshalled ACE_CDR::Octet." << endl;
-  } else {
-    out << "   messaging (SOCK_SEQPACK) using unmarshalled ACE_CDR::Octet." << endl;
-  }
-
-  out << "USAGE: " << __program_name << " [ -<flag> [<val>] | --<name> [<val>] ]..." << endl;
-
-  out << endl;
-
-  if (!ACE_OS::strcmp("client-opts", opts_set)){
-    out << "  Flag  Args           Option-Name                 Default"    << endl;
-    out << "   -c   int            test-iterations             1000000"    << endl;
-    out << "   -n   none           test-enable-nagle           NO NAGLING" << endl;
-    if (ACE_OS::strstr(__program_name, "SOCK_STREAM_clt")) {
-      out << "   -t   str (sctp|tcp) test-transport-protocol     sctp"       << endl;
-    }
-
-    out << endl;
-
-    out << "   -m   dbl            histogram-min-bin           0"     << endl;
-    out << "   -M   dbl            histogram-max-bin           10000" << endl;
-    out << "   -x   int            histogram-num-outliers      100"   << endl;
-    out << "   -b   int            histogram-bin-count         1000"  << endl;
-
-    out << endl;
-
-    out << "   -C   int            client-port                 assigned by kernel"     << endl;
-    out << "   -i   str            client-connect-addr         INADDR_ANY" << endl;
-
-    out << endl;
-
-    out << "   -p   int            server-port                 45453"     << endl;
-    out << "   -H   str            server-host                 localhost" << endl;
-
-    out << endl;
-
-    out << "   -s   int (0-16)     payload-size-power-of-2     <MUST SET VALUE>" << endl;
-
-    out << endl;
-
-    out << "   -h   none           help" << endl;
-
-    out << endl;
-
-  } else if (!ACE_OS::strcmp("server-opts", opts_set)){
-    out << "  Flag  Args           Option-Name                 Default"    << endl;
-    out << "   -n   none           test-enable-nagle           NO NAGLING" << endl;
-    if (ACE_OS::strstr(__program_name, "SOCK_STREAM_srv")) {
-      out << "   -t   str (sctp|tcp) test-transport-protocol     sctp"       << endl;
-    }
-
-    out << endl;
-
-    out << "   -p   int            server-port                 45453"     << endl;
-
-    if (ACE_OS::strstr(__program_name, "SOCK_SEQPACK_srv")) {
-      out << "   -a   w.x.y.z,a.b.c.d,...  server-accept-addr    INADDR_ANY" << endl;
-      out << "        (comma-separated                                     " << endl;
-      out << "         list of one or more                                 " << endl;
-      out << "         addresses)                                          " << endl;
-    } else {
-      out << "   -a   w.x.y.z        server-accept-addr          INADDR_ANY" << endl;
-    }
-
-    out << "   -h   none           help" << endl;
-
-    out << endl;
-
-  } else {
-    out << "Invalid options set specified." << endl;
-  }
-
-  return;
-}
diff --git a/performance-tests/SCTP/Options_Manager.h b/performance-tests/SCTP/Options_Manager.h
deleted file mode 100644
index 2b9b8b3b7d3..00000000000
--- a/performance-tests/SCTP/Options_Manager.h
+++ /dev/null
@@ -1,66 +0,0 @@
-// -*- C++ -*-
-
-// $Id$
-
-// The types defined in ACE_CDR are more complete that those in Basic_Types.h
-
-
-#ifndef OPTIONS_MANAGER_H
-#define OPTIONS_MANAGER_H
-
-#ifndef ACE_CDR_BASE_H
-#include "ace/CDR_Base.h"
-#endif
-
-#include "ace/streams.h"
-
-class Options_Manager
-{
-public:
-
-  Options_Manager(int argc, ACE_TCHAR **argv, ACE_TCHAR const * const opts_set);
-
-  // constant string size
-  enum { string_len = 100 };
-
-  static ACE_CDR::ULong test_iterations;
-  static ACE_CDR::Boolean test_enable_nagle;
-  static ACE_CDR::Long test_transport_protocol;
-
-  static ACE_CDR::Double histogram_min_bin;
-  static ACE_CDR::Double histogram_max_bin;
-  static ACE_CDR::ULong histogram_bin_count;
-  static ACE_CDR::ULong histogram_num_outliers;
-
-  static ACE_CDR::UShort client_port;
-  static ACE_CDR::ULong  client_connect_addr;
-
-  static ACE_CDR::UShort server_port;
-  static ACE_TCHAR server_host[string_len];
-  static ACE_CDR::ULong server_accept_addr;
-
-  static ACE_CDR::UShort payload_size_power_of_2;
-
-  // Secondary client_connect_addrs for SCTP SOCK_SEQPACK test
-  enum { max_num_secondary_connect_addrs = 100 };
-  static ACE_CDR::ULong secondary_connect_addrs[max_num_secondary_connect_addrs];
-  static ACE_CDR::UShort num_secondary_connect_addrs;
-
-  // Secondary server_accept_addrs for SCTP SOCK_SEQPACK test
-  enum { max_num_secondary_accept_addrs = 100 };
-  static ACE_CDR::ULong secondary_accept_addrs[max_num_secondary_accept_addrs];
-  static ACE_CDR::UShort num_secondary_accept_addrs;
-
-  static ACE_CDR::UShort _error;
-  static const ACE_TCHAR* _error_message;
-
-  static ACE_CDR::UShort _usage;
-  void _show_usage(ostream& out, ACE_TCHAR const * const opts_set);
-
-private:
-  static ACE_CDR::Boolean __initialized;
-  static ACE_TCHAR __program_name[string_len];
-
-};
-
-#endif /* OPTIONS_MANAGER_H */
diff --git a/performance-tests/SCTP/README b/performance-tests/SCTP/README
deleted file mode 100644
index f6d0ac65954..00000000000
--- a/performance-tests/SCTP/README
+++ /dev/null
@@ -1,81 +0,0 @@
-This directory provides programs that measure the round trip latency
-of synchronous octet messaging using ACE wrapper-facades for the SCTP
-protocol. Currently these programs provide the only example code on
-how to use ACE's wrapper-facades for SCTP. In the future additional
-code will be placed in the ACE_wrappers/examples/IPC_SAP/SOCK_SAP
-directory.
-
-SOCK_STREAM_clt and SOCK_STREAM_srv use the SOCK_STREAM service
-provided by SCTP via ACE's SOCK_Connector, SOCK_Stream,
-SOCK_Association wrapper-facade classes. 
-
-SOCK_SEQPACK_clt and SOCK_SEQPACK_srv use the SOCK_SEQPACKET service
-provided by SCTP via ACE's SOCK_SEQPACK_Connector,
-SOCK_SEQPACK_Association and SOCK_SEQPACK_Acceptor wrapper-facade
-classes.
-
-The following table provides a summary of relationships between two main
-Linux SCTP implementations (OpenSS7 and LKSCTP), and ACE Wrapper Facades
-support that is provided. Built on top of the ACE Wrapper Facade support is
-the SCIOP support in TAO. SCIOP works identically on both OpenSS7 and
-LKSCTP implementations. Please read additional README* files listed below.
-
--------------------------------------------------------------------------------
-    SCTP      Transport          Transport                ACE
-   Protocol    Service            Service               Wrapper
-    Impl.       Type           Characteristics          Facades
- ------------------------------------------------------------------------------
- OpenSS7     SOCK_SEQPACKET    {Connected,      ACE_SOCK_SEQPACKET_Acceptor
-                                Reliable,       ACE_SOCK_SEQPACKET_Connector 
-                                Messages}       ACE_SOCK_SEQPACKET_Association
- 
- OpenSS7      SOCK_STREAM      {Connected,      ACE_SOCK_Acceptor(IPPROTO_SCTP)
-                                Reliable,       ACE_SOCK_Connector(IPPROTO_SCTP)
-                                Byte Stream}    ACE_SOCK_Stream(IPPROTO_SCTP)
- 
- OpenSS7       SOCK_RDM        {Connectionless,      NOT IMPLEMENTED IN ACE
-                                Reliable,     
-                                Messages}     
- 
- 
- LKSCTP      SOCK_SEQPACKET    {Connectionless,         NOT USED IN ACE  
-                                UNRELIABLE,        
-                                Messages}        
- 
- LKSCTP      SOCK_STREAM      {Connected,       ACE_SOCK_SEQPACKET_Acceptor
-                                Reliable,       ACE_SOCK_SEQPACKET_Connector 
-                                Messages}       ACE_SOCK_SEQPACKET_Association 
-                                                ACE_SOCK_Acceptor(IPPROTO_SCTP)
-                                                ACE_SOCK_Connector(IPPROTO_SCTP)
-                                                ACE_SOCK_Stream(IPPROTO_SCTP)
-
-
-Additional information can be found in the following README files also
-located in this directory.
-
- README.SCTP - Brief description of the major features and benefits
-               SCTP protocol and references for further information.
-
- README.SCTP_in_ACE - Description of the wrapper-facade classes that
-                      ACE provides to use SCTP, general usage
-                      guidance, release notes, technical point of
-                      contact information.
-
- README.SCTP_PERF_TEST - Detailed description on how to use the
-                         performance tests and the run_spectrum.pl
-                         script contained in this directory. 
-                         Discussion of the baseline performance
-                         results obtained by LM ATL. 
-
- THANKS - Documents all the people who contributed to the development
-          of the ACE wrapper-facades for SCTP and the SCIOP (SCTP
-          Inter-ORB Protocol) for TAO. Information on that can be
-          found in ACE_wrappers/TAO/tao/Strategies/README.SCIOP
-
-General requests for information beyond what is contained in these
-files can be sent to either of the following individuals.
-
-Patrick Lardieri plardier@atl.lmco.com
-Gautam Thaker    gthaker@atl.lmco.com
-
-This work was sponsored by DARPA/IXO PCES Program.
diff --git a/performance-tests/SCTP/README.LKSCTP b/performance-tests/SCTP/README.LKSCTP
deleted file mode 100644
index 494167abe30..00000000000
--- a/performance-tests/SCTP/README.LKSCTP
+++ /dev/null
@@ -1,46 +0,0 @@
-This README describes the LKSCTP implementation of SCTP for Linux.
-
-June 2003 - 1.0
-
-Overview
---------
-
-The LKSCTP project is the Linux Kernel implementation of SCTP.  As of this 
-writing it has been incorporated into the Linux 2.6 test series of
-kernels.   
-
-LKSCTP adheres to the IETF's SCTP Sockets Draft API.  Please refer to that 
-document for API specifics.  
-
-You MUST use Linux 2.6-test4 or later.  Earlier versions have a different
-api.   
-
-Building ACE/TAO with LKSCTP support
---------------------------------
-
-        - compile kernel with SCTP support
-                + if compiled as a module, be sure to load it.  
-
-        - download LKSCTP userspace functions library from 
-          http://lksctp.sourceforge.net/
-
-        - install userspace library (libsctp.a) into /usr/local/lib
-
-        - install header file (sctp.h) into /usr/local/include/sctp.h
-
-        - make ACE/TAO with "sctp=lksctp"
-
-Caveats
----------------------------------
-
-        - Both services interfaces (SOCK_STREAM and SOCK_SEQPACKET) will
-          preserve message boundaries.  
-
-Resources
----------------------------------
-  
-        - LKSCTP Homepage: http://lksctp.sourceforge.net/
-                - Latest Patches
-                - Userspace Library
-                - Mailing Lists
---
diff --git a/performance-tests/SCTP/README.OpenSS7 b/performance-tests/SCTP/README.OpenSS7
deleted file mode 100644
index 5183e872e12..00000000000
--- a/performance-tests/SCTP/README.OpenSS7
+++ /dev/null
@@ -1,271 +0,0 @@
-// $Id$
-
-This document describes the OpenSS7 API in detail.
-
-Introduction
-=============
- 
-OpenSS7 defines two types of services, UDP style and TCP style.  How OpenSS7 
-distinguishes the two styles is by the way in which the data is presented to 
-the application.  In OpenSS7, data is presented as byte streams or datagrams.  
-The stream style is considered the TCP style socket, and the datagram is 
-considered the UDP style socket.  The UDP style socket does not represent a one
-to many mapping of file descriptors to associations as the IETF compatible 
-sockets does.
-
-Instead of adding new system calls, OpenSS7 decided to modify some of the
-existing system calls to play nicely with multi-homing.  So, to bind to 
-multiple addresses, you pass in an array of struct sockaddr* structures and the
-total length in bytes of the array.  Also, when accepting connections from a
-peer, you would pass in a pointer to an array of struct sockaddr* and the 
-length of the array in bytes.
-
-
-Building ACE/TAO with support for OpenSS7 SCTP
-==============================================
-
-        - apply OpenSS7's SCTP patch (see OpenSS7's readme for details) 
-
-        - compile kernel with the following kernel variables (.config file)
-                + CONFIG_SCTP=y
-                + CONFIG_SCTP_TCP_COMPATIBLE=y
-                + CONFIG_SCTP_HMAC_SHA1=y
-                + CONFIG_SCTP_HMAC_MD5=y
-                + CONFIG_SCTP_ADLER_32=y
-                + CONFIG_SCTP_CRC_32C=y
-
-        - install header file (sctp.h) into /usr/local/include/sctp.h
-
-        - make ACE/TAO with "sctp=openss7" -- ie. "make sctp=openss7"
-
-Common Calls
-============
-
-There are a few common calls which have the same semantics no matter which
-interface you are using (UDP style or TCP style).  So, the usual calls used in 
-a client are:
-
-  1) socket()
-  2) bind()
-  3) setsockopt()
-  4) connect()
-  5) send/recv()
-  6) close()
-
-while the usual calls for a server are as follows:
-
-  1) socket()
-  2) bind()
-  3) setsockopt()
-  4) listen()
-  5) accept()
-  6) close()
-
-The previous example mimics the way in which the TCP protocol is used.  
-There are some exceptions to the above sequence which we will get into a little
-later. So, let's talk about the system calls above.
-
-Socket()
---------
-The socket() call creates a file descriptor for the application to use to
-communicate with the SCTP stack.  The signature of socket() is as follows:
-
-  int socket(int network, int service, int proto)
-  Where:
-    network - AF_INET or AF_INET6 (AF_INET6 is not currently supported)
-    service - SOCK_SEQPACKET which gives us the UDP style interface
-              SOCK_STREAM which gives us the TCP style interface
-    proto   - IPPROTO_SCTP which is the SCTP protocol number(132)
-
-Bind()
-------
-The bind() call is used to attach the socket descriptor to the given array of
-addresses.  bind() may only be called once.  The address structures sent in as
-arguments to bind must have the same port number.  That is, you may have
-multiple addresses, but only 1 port number.  The signature of bind() is as
-follows:
-
-  int bind(int fd, struct sockaddr* addrs, socklen_t addrs_len)
-  Where:
-    fd        - A SCTP socket descriptor
-    addrs     - An array of struct sockaddr* which have the same port number
-    addrs_len - The total length in bytes of the addrs array
-
-If an address structure is sent in with the address of INADDR_ANY, then SCTP
-will bind to all the addresses on the host and either pick an ephemeral port or
-use the one specified in the address structure.
-
-Setsockopt()
-------------
-The setsockopt() call is used to adjust many different parameters to the SCTP
-protocol.  Please see the sctp(7) man page for more details.
-
-Connect()
----------
-The connect() call can be used to initialize a connection with a peer SCTP
-machine.  A connection can be initialized in 2 ways.  The first is this
-call(connect()).  The second way is to allow implicit initialization when the
-application calls sendmsg or sendto with the address of the remote host
-specified.  To allow data to be piggybacked with the COOKIE_ECHO chunk, you 
-must use the second initialization technique.  The signature of connect is as
-follows:
-
-  int connect(int fd, struct sockaddr* r_addr, socklen_t r_addr_len)
-  Where:
-    fd         - An SCTP socket descriptor
-    r_addr     - A single address structure with the address of the remote host
-    r_addr_len - Length in bytes of the the address structure
-
-Note that only one address is sent into the connect call.  The SCTP protocol
-will negotiate the valid IP addresses to use with multi-homing.
-
-Listen()
---------
-The listen() call prepares the SCTP socket to accept new associations.  The
-signature is as follows:
-
-  int listen(int fd, int backlog)
-  Where:
-    fd    - An SCTP socket descriptor
-    backlog - The maximum number of unaccepted connections
-
-Accept()
---------
-The accept() call allows the application to explicitly accept an incoming
-association initialization attempt.  accept() returns a new file descriptor
-which can be used to send data to the client.  accept() has a slightly 
-different semantic which allows it to take an array of address structures.  
-This gives the application the chance to get a specified number of addresses 
-from the peer on initialization.  The signature of accept() is as follows:
-
-  int accept(int fd, struct sockaddr* r_addr, socklen_t *r_addr_len)
-  Where:
-    fd         - A SCTP socket descriptor
-    r_addr     - An array of address structures which will be filled with the
-                 addresses of the remote host
-    r_addr_len - The length of the array of address structures passed in.
-
-accept() will only put as many addresses in the address array as is specified
-by the r_addr_len argument.
-
-Close()
--------
-Start the association shutdown sequence.  The signature is as follows:
-
-  int close(int fd)
-  Where:
-    fd - A SCTP socket descriptor
-
-Data Interfaces
-===============
-This section describes the sending and receiving of data on an SCTP socket.
-This is where the differences between the TCP style and UDP style sockets 
-shows.  SCTP uses the standard pairs of calls:
-
-  1) send()/recv()
-  2) sendmsg()/recvmsg()
-  3) sendto()/readfrom()
-  4) write()/read()
-  5) writev()/readv()
-
-When the SCTP socket is opened as a UDP style socket, data is presented to the
-application as datagrams.  This means that calls to the receive class of system
-calls returns only datagrams.  For example, assume a sender sends 2 100 byte
-datagrams.  Now assume that the receiver calls one of the receive routines with
-a max buffer size of 120 bytes.  Assuming no errors are encountered, only 100
-bytes are returned to the receiver (only 1 datagram), leaving the last 20 bytes
-empty in the receivers buffer.  When the last of a datagram is read, the 
-MSG_EOR flag is returned, and if the datagram is too big to fit into the 
-specified buffer, the MSG_TRUNC flag is returned.  
-
-With TCP styles sockets, the data is presented to the application as a stream
-of bytes (like TCP).  For example, assume the sender sends 2 100 byte 
-datagrams.  Now assume that the receiver calls one of the receive routines with 
-a max buffer size of 120.  Assuming no errors are encountered, 120 bytes are 
-returned (100 from the first datagram and 20 from the next datagram), leaving 
-80 bytes in the second datagram.  MSG_EOR and MSG_TRUNC are never returned.
-
-Send()/Recv()
--------------
-The send/recv interface is one of the easiest ways of sending data back and
-forth between peers.  When send/recv is called, data is sent/read from the
-default stream.  The signature of send/recv is as follows:
-
-  int send(int fd, void *data, size_t d_len, int flags)
-  Where:
-    fd    - A SCTP socket descriptor
-    data  - Data to be sent to the peer
-    d_len - The length of the data in bytes
-    flags - Possible flags to be sent to be passed to the SCTP stack
-            (see send(3))
-
-Sendmsg()/Recvmsg()
--------------------
-The sendmsg/recvmsg interface is the most powerful and hard to use interface
-in the SCTP stack.  This interface allows the specification of which stream to
-send data out or receive data from.  It also allows the sending of data with a
-specified protocol payload identifier.  The signature is as follows:
-
-  int sendmsg(int fd, struct msghdr *msg, int flags)
-  Where:
-    fd    - A SCTP socket descriptor
-    msg   - A struct msghdr structure which holds miscellaneous information
-    flags - Possible flags to be passed to the SCTP stack
-            (see sendmsg(3))
-
-The msg argument holds the data to be sent to the peer.  It also can take an
-address to send the data to.  So, for example, if you had an association with 2
-addresses for the peer and the default path used the first address, and you
-wanted to send data to the other address, you could specify that address in the
-msg structure.  If this address field is NULL, then data is sent out the       
-default address.  
-
-This interface also allows other functions by using the ancillary data field 
-in the msg structure.  By using the ancillary data field, you may send data out
-a different stream by using the SCTP_SID control message.  This type of control
-message would take an integer representing the stream to send data out as it's
-data.  Another option is to use the SCTP_PPI control message which allows the
-setting of the protocol payload identifier to the specified integer argument.
-Both of these options only set their values for the current data being sent out.
-
-Sendto()/Recvfrom()
--------------------
-The sendto/recvfrom interface allows the specification of which remote address
-to send data.  The signature of sendto/recvfrom is as follows:
-
-  int sendto(int fd, void *data, size_t d_len, int flags, 
-             struct sockaddr* r_addr, socklen_t r_addr_len)
-  Where:
-    fd         - A SCTP socket descriptor
-    data       - Data to send to peer
-    d_len      - Length of the data to be sent
-    flags      - Possible flags to be passed to the SCTP stack
-    r_addr     - Address of peer to send data to
-    r_addr_len - Length of peer address
-
-Write()/Read()
---------------
-This interface is the simplest way of sending data to a peer.  When this
-interface is used, data is sent/received through the default stream (as set by
-SCTP_SID).  The signature is as follows:
-
-  int write(int fd, void *data, size_t d_len)
-  Where:
-    fd    - A SCTP socket descriptor
-    data  - Data to be sent to peer
-    d_len - Length of data
-
-Writev()/Readv()
-----------------
-This interface allows the sending of multiple buffers of data in one system
-call.  This call places all the buffers into one SCTP data chunk.  The          signature is as follows:
-
-  int writev(int fd, struct iovec *iov, int ct)
-  Where:
-    fd  - A SCTP socket descriptor
-    iov - An array of iovec structures.  The order they are in the array is the
-          order they are placed in the data chunk
-    ct  - The number of iovec structures to send
-
---
-
diff --git a/performance-tests/SCTP/README.SCIOP b/performance-tests/SCTP/README.SCIOP
deleted file mode 100644
index 503b81f7eaf..00000000000
--- a/performance-tests/SCTP/README.SCIOP
+++ /dev/null
@@ -1,63 +0,0 @@
-README.SCIOP
-------------
-
-Author: Jason Cohen
-Lockheed Martin, Advanced Technology Labs
-
-
-The SCIOP pluggable protocol for TAO uses the SCTP transport protocol through
-the use of the SOCK_SEQPACK ACE wrappers for sequence based transport.  The
-current implementation supported is the OpenSS7 SCTP protocol layer, tested
-under Linux 2.4.18.
-
-For more information on SOCK_SEQPACK and OpenSS7 SCTP see
-ACE_wrappers/performance-tests/SCTP/README*
-
-Features Currently Supported:
------------------------------
-
-o) Sequenced delivery via SOCK_SEQPACK
-Currently, only one stream is supported as there are no available bindings to
-provide a user with stream designation for messages.
-
-o) SCIOR compliance to OMG GIOP SCTP Protocol Mapping submission mars/2002-09-01.  
-
-o) Multiple address SCIOR profiles
-When multiple addresses are included in a SCIOR profile, each address is
-handled separately during the connection process.  Specifying multiple
-addresses for a single connection attempt remains as work to be done.
-However, multiple path discovery during connection time in OpenSS7's
-SCTP implementation has been tested to work properly with SCIOP.
-
-The catior utility under ACE_wrappers/TAO/utils/catior has also modified
-to display SCIOR profile information.
-
-To test SCIOP after installing an SCTP implementation supported by
-SOCK_SEQPACK, try using a performance test specifying an sciop address as the
-ORBEndpoint.  One way to do this is with the test found under:
-ACE_wrappers/TAO/performance-tests/Pluggable/
-
-Make sure to build the pluggable protocols into the executable:
-gmake LIBS+=-lTAO_Strategies
-
-Run the server with an sciop endpoint specified:
-./server -ORBEndpoint sciop://${HOSTNAME} -o test.ior &
-
-Finally, run the client on the same machine or another that has file
-access to your IOR file:
-./client -f test.ior
-
-TO-DO:
-------
-
-o) Multiple association connection using Multihomed_INET_Addr
-Currently, only one address connection is attempted at a time, even when a
-profile contains multiple address.  Later, we hope to allow this
-implementation of SCIOP to exploit the multiple address connection
-capabilities of STCP.
-
-o) SCTP ProtocolManagement/SCTPProtocolProperties
-
-o) Support for max_streams > 1
-
-o) SCIOR Profile Components
diff --git a/performance-tests/SCTP/README.SCTP b/performance-tests/SCTP/README.SCTP
deleted file mode 100644
index 95c3cb0b53a..00000000000
--- a/performance-tests/SCTP/README.SCTP
+++ /dev/null
@@ -1,81 +0,0 @@
-#       $Id$        
-
-This document provides general information about the SCTP protocol.  
-
-
-Introduction
-=============
-SCTP (Stream Control Transmission Protocol) is a new transport layer protocol 
-developed by the IETF and defined by RFC2960.  Originally designed for the 
-transmission of message-oriented applications such as the transportation of 
-signaling data for PSTNs (Public Switched Telephone Networks), SCTP can be used
-in any application that uses TCP.  
-
-        Major Features
-        --------------
-
-        - Direct support for multi-homing
-        - Support for multiple streams per connection (known as associations) 
-          to reduce "head of line" blocking problems.   
-        - Four way handshake reducing the possibility for blind denial of
-          service attacks.
-        - Adjustment of congestion control parameters
-        - Cookie mechanism to protect against "SYN" attacks
-
-API's
-========
-
-The SCTP drafts have defined several different API's.  The first reference 
-implementation was a user level library.  This allowed an application to use 
-SCTP through several functions and callbacks.  As of this writing a 
-transition from the user level libraries to the kernel is underway.
-
-The IETF TSVWG (Transport Area Working Group) has published a draft 
-(draft-ietf-tsvwg-sctpsocket-06.txt) that defines a mapping between SCTP and 
-the BSD sockets interface.  This interface has made porting TCP applications to
-SCTP as simple as changing one socket call.
-
-        OpenSS7
-        --------
-        OpenSS7 has defined, a similar BSD style sockets interface.  It is 
-        slightly different from the one defined by the IETF, however, at the
-        time of our evaluation it was the most stable implementation.  
-
-        Please see README.OpenSS7 for details and build instructions.   
-
-        LKSCTP
-        ------
-        The LKSCTP implementation is based on the TSVWG's sockets draft.  
-        It is included with the Linux 2.6 series test kernels. Backported
-        (Linux 2.4) patches are also available from the LKSCTP website.  
-
-        Please see README.LKSCTP for more details and build instructions.  
-
-Resources
-===========
-
-        RFCs
-        -----
-        RFC2960: Stream Control Transmission Protocol
-        RFC3309: Stream Control Transmission Protocol Checksum Change
-
-        Internet-Drafts
-        ----------------
-        
-        draft-ietf-tsvwg-sctpsocket-07.txt: 
-                Sockets API Extensions for Stream Control Transmission Protocol
-
-        draft-ietf-tsvwg-sctpimpguide-08.txt
-                Stream Control Transmission Protocol Implementer's Guide
-
-        Internet Links
-        ---------------
-        IETF: Transport Area Working Group (tsvwg):
-                http://www.ietf.org/html.charters/tsvwg-charter.html
-
-        The OpenSS7 Project: http://www.openss7.org/sctp.html
-
-        The LKSCTP Project: http://lksctp.sourceforge.net/
-
---
-
diff --git a/performance-tests/SCTP/README.SCTP_PERF_TEST b/performance-tests/SCTP/README.SCTP_PERF_TEST
deleted file mode 100644
index 81cacef02e0..00000000000
--- a/performance-tests/SCTP/README.SCTP_PERF_TEST
+++ /dev/null
@@ -1,405 +0,0 @@
-$Id$
-
-Release 1.0 - January 2003
-
-***********************************
-*    Performance Test Overview    *
-***********************************
-
-This directory contains performance tests for measuring round-trip
-latency statistics of ACE synchronous messaging using unmarshalled
-ACE_CDR::Octet.
-
-In terms of protocol and service type, three different tests are
-available:
-
- * TCP over SOCK_STREAM
- * SCTP over SOCK_STREAM
- * SCTP over SOCK_SEQPACK
-
-All three of these tests share the same architecture, which is
-described in the following section.
-
-***************************
-*    Test Architecture    *
-***************************
-
-As mentioned above, the performance tests measure round-trip latency
-statistics.  We are talking about the round trip between two service
-endpoints, a client and a server.  The client sends the server an
-arbitrary message with a specific length---up to 2^16 bytes---and the
-server responds with a 2-byte reply.  The client measures and records
-the time it takes to complete this exchange.  The whole test is then
-repeated through many iterations, and finally the client outputs the
-resulting statistics.
-
-In detail,
-
-1.  The server program is started first.  It creates a passive-mode
-    socket and runs an infinite loop waiting for clients to connect.
-
-2.  The client program is started next.  It may be configured with
-    numerous parameters, which include:
-
-      * the hostname and port where the server's passive-mode socket
-        is listening,
-      * the desired message length, which may be any power of two
-        between 2^0 and 2^16,
-      * the desired number of iterations (by default 1 million)
-
-3.  The client connects to the server's passive-mode socket.  If all
-    goes well, the client and server will each obtain a data-mode
-    socket that serves as a communication endpoint.
-
-4.  The client sends an initial header message containing the intended
-    number of iterations and the message length (which will be
-    the same for each iteration).  Armed with this information, the
-    server spawns a separate thread to handle these iterations.
-
-5.  The client creates an in-memory data structure that serves as a
-    histogram.  The histogram is configured with a range of possible
-    round-trip latencies, and this range is divided into a number of
-    "bins".  The latency measured for each test entry will either
-    fall into one of these "bins", or it will fall outside the entire
-    range and will be logged as an outlier.
-
-6.  The client and server repeat the following interaction for each
-    test iteration.
-
-    a.  The client starts a stopwatch.
-
-    b.  The client sends the server an arbitrary message of the
-        established length.
-
-    c.  After receiving this entire message from the client, the
-        server sends the client a 2-byte reply.
-
-    d.  After receiving the 2-byte reply from the server, the client
-        stops the stopwatch.
-
-    e.  The round-trip latency, as measureed by the stopwatch, is
-        logged to the in-memory histogram.
-
-7.  After all these iterations are complete, the client disconnects
-    from the server.  The client then takes the in-memory histogram
-    and dumps its text representation to STDOUT.
-
-8.  The client exits.  The server thread dedicated to this client
-    exits.  The main thread of the server continues to run an infinite
-    loop waiting for more clients to connect to the passive-mode
-    socket.
-
-**************************
-*    Test Executables    *
-**************************
-
-You must use a different pair of client and server executables
-depending on whether you desire to use the SOCK_STREAM service or the
-SOCK_SEQPACK service.
-
-The SOCK_STREAM client and server are called SOCK_STREAM_clt and
-SOCK_STREAM_srv, respectively.  The SOCK_SEQPACK client and server are
-called SOCK_SEQPACK_clt and SOCK_SEQPACK_srv, respectively.
-
-Each of these executables uses SCTP as its default protocol.  As an
-extra feature, SOCK_STREAM_clt and SOCK_STREAM_srv offer TCP as an
-alternate protocol.  The choice between TCP and SCTP is exposed via
-the '-t' option.  (Individual instances of SOCK_STREAM_clt and
-SOCK_STREAM_srv must use the same protocol in order to connect and
-function.)
-
-Any of the four executables will show usage information if you run it
-with the '-h' option.  For instance, here is the usage message
-produced by SOCK_STREAM_clt:
-
-./SOCK_STREAM_clt - Measures round trip latency statistics of ACE synchronous
-                    messaging (SOCK_Stream) using unmarshalled ACE_CDR::Octet.
-USAGE: ./SOCK_STREAM_clt [ -<flag> [<val>] | --<name> [<val>] ]...
-
-  Flag  Args           Option-Name                 Default
-   -c   int            test-iterations             1000000
-   -n   none           test-enable-nagle           NO NAGLING
-   -t   str (sctp|tcp) test-transport-protocol     sctp
-
-   -m   dbl            histogram-min-bin           0
-   -M   dbl            histogram-max-bin           10000
-   -x   int            histogram-num-outliers      100
-   -b   int            histogram-bin-count         1000
-
-   -C   int            client-port                 assigned by kernel
-   -i   str            client-connect-addr         INADDR_ANY
-
-   -p   int            server-port                 45453
-   -H   str            server-host                 localhost
-
-   -s   int (0-16)     payload-size-power-of-2     <MUST SET VALUE>
-
-   -h   none           help
-
-For each option, the long "Option-Name" may be prefixed by two dashes
-and used on the command line in place of the shorter "Flag".  Hence
-
-   ./SOCK_STREAM_clt -s 5
-
-is equivalent to 
-
-   ./SOCK_STREAM_clt --payload-size-power-of-2 5
-
-The options shown above for SOCK_STREAM_clt (and the similar options
-available for SOCK_SEQPACK_clt) are discussed in the next section.
-
-*****************************
-*    Client-Side Options    *
-*****************************
-
-The following options are available for both SOCK_STREAM_clt and
-SOCK_SEQPACK_clt.
-
-    test-iterations  [ -c int ]
-
-        the number of times to repeat the round-trip-latency test
-        loop.  The default is 1000000.
-
-    test-enable-nagle  [ -n ]
-
-        Enable Nagle's algorithm (which is disabled by default).
-
-    histogram-min-bin  [ -m double ]
-
-        the lower boundary on the range of the histogram.
-        The default is 0.  The unit of measurement is the millisecond.
-
-    histogram-max-bin  [ -M double ]
-
-        the upper boundary on the range of the histogram.
-        The default is 10000.  The unit of measurement is the
-        millisecond.
-
-    histogram-num-outliers  [ -x int ]
-
-        the maximum number of outliers to maintain in the histogram.
-        The default is 100.
-
-    histogram-bin-count  [ -b int ]
-
-        the number of histogram bins.  The default is 1000.  The width
-        of each bin will be
-
-          (histogram-max-bin - histogram-min-bin) / histogram-bin-count
-
-    client-port          [ -C int ]
-    client-connect-addr  [ -i string ]
-
-        the port and network address where the client's data-mode
-        socket is to be bound.  By default, the port number is
-        assigned by the kernel, and the socket is bound to all network
-        interfaces.
-
-    server-port  [ -p int ]
-    server-host  [ -H string ]
-
-        the port and hostname where the server's passive-mode socket
-        is bound.  The default port is 45453 and the default host is
-        localhost.
-
-    payload-size-power-of-2  [ -s int ]
-
-        an integer X.  The size of the payload will be 2^X bytes.
-
-    help  [ -h ]
-
-        Show usage message.
-
-The following option is available only for SOCK_STREAM_clt:
-
-    test-transport-protocol  [ -t (sctp|tcp) ]
-
-        the protocol for the test.  The default is sctp.
-
-In contrast, SOCK_SEQPACK_clt always uses SCTP as its protocol.
-
-*****************************
-*    Server-Side Options    *
-*****************************
-
-The following options are available for both SOCK_STREAM_srv and
-SOCK_SEQPACK_srv:
-
-    test-enable-nagle  [ -n ]
-
-        Enable Nagle's algorithm (which is disabled by default).
-
-    server-port  [ -p int ]
- 
-        the port where the server's passive-mode socket will be
-        bound.  The default is 45453.
-
-    help  [ -h ]
-
-        Show usage message.
-
-The following option is available for both SOCK_STREAM_srv and
-SOCK_SEQPACK_srv, but the latter offers additional functionality:
-
-    server-accept-addr  [ -a w.x.y.z ]              (for SOCK_STREAM_srv)
-                        [ -a w.x.y.z,a.b.c.d,... ]  (for SOCK_SEQPACK_srv)
-
-        the network address (or addresses) to which the server's
-        passive-mode socket will be bound.
-
-        The default value of INADDR_ANY should be sufficient for
-        machines that have only one network interface.
-
-        If your machine has two interfaces, and you wish to bind the
-        socket only to one of these, then you may explicitly specify
-        the desired interface with an expression such as
-        "-a 192.168.221.104" or "-a 192.168.1.43".
-
-        If your machine has three or more interfaces, and you wish to
-        bind the socket only to a subset of two or more, AND you are
-        using SOCK_SEQPACK_srv, THEN you may explicitly specify the
-        desired interface with an expression such as 
-        "-a 192.168.221.104,192.168.1.43".  The argument here is a
-        comma-delimited list of dotted-decimal IPv4 addresses with no
-        whitespace interspersed.  This level of control is not
-        possible with SOCK_STREAM_srv.
-
-The following option is available only for SOCK_STREAM_srv:
-
-    test-transport-protocol  [ -t (sctp|tcp) ]
-
-        the protocol for the test.  The default is sctp.
-
-In contrast, SOCK_SEQPACK_srv always uses SCTP as its protocol.
-
-***************************
-*    Test Walk-Through    *
-***************************
-
-This section shows a walk-through of a typical scenario using
-SOCK_STREAM_clt and SOCK_STREAM_srv to run an SCTP performance test.
-
-You can run the equivalent TCP performance test by adding "-t tcp" to
-the command line of both programs.  Alternately, you can run a
-SOCK_SEQPACK-based SCTP performance test by substituting
-SOCK_SEQPACK_clt and SOCK_SEQPACK_srv for SOCK_STREAM_clt and
-SOCK_STREAM_srv, respectively.
-
-In this scenario, both client and server run on the same machine.  We
-use a message size of 2^7 bytes and a relatively small number of
-iterations, 1000, in order to make the test go quickly.  The server's
-passive-mode socket binds to the default port, 45453, which is also
-the default port expected by the client.  We invoke no other special
-or unusual options.
-
-For clarity, we envision starting the client and server in two
-separate shells.
-
-The steps of the walk-through are as follows:
-
-1.  Start the server.
-
-    $ ./SOCK_STREAM_srv
-    (12761|1024) Accepting connections on port 45453 
-                 on interface INADDR_ANY using IPPROTO_SCTP
-    (12761|1024) starting server at port 45453
-    (12761|1024) select timed out
-    (12761|1024) select timed out
-    (12761|1024) select timed out
-    (12761|1024) select timed out
-    ...
-    
-    The server will continue to print, periodically, the message
-    "select timed out" as it waits for clients to connect.
-
-2.  Start the client.
-
-    $ ./SOCK_STREAM_clt -s 7 -c 1000
-
-3.  Observing the debugging output from the server, you should see
-    evidence that the client has connected.  
-
-    (12761|1024) select timed out
-    (12761|1024) select timed out
-    (12761|1024) select timed out
-    (12761|1024) spawning server
-    (12761|1024) client utica-b connected from 32768
-    (12761|1024) Test for 1100 iterations
-    (12761|1024) select timed out
-    (12761|1024) select timed out
-
-    Note that the server expects 1100 iterations, even though we
-    configured the client for only 1000 iterations.  The reason for
-    this discrepencany is that the client always runs 100 primer
-    iterations before the requested test iterations.
-
-4.  When the 1100 iterations are complete, observing the output from
-    the client, you should see the histogram:
-
-
-                                Histogram ACE Unmarshalled Msg Synchronous Latency Test
-                                        (Message Size 128, Message Type octet)
-    version: 1.1
-    minimum: 41
-    maximum: 60182
-    mean: 106.858
-    variance: 3.62659e+06
-    num_points: 1000
-    num_bins: 1000 0 10000
-
-              Low     -          High     Count  Fraction  Cumulative
-             below    -         0.000  :      0    0.000    0.000
-               0.000  -        10.000  :      0    0.000    0.000
-              10.000  -        20.000  :      0    0.000    0.000
-              20.000  -        30.000  :      0    0.000    0.000
-              30.000  -        40.000  :      0    0.000    0.000
-              40.000  -        50.000  :    988    0.988    0.988
-              50.000  -        60.000  :      5    0.005    0.993
-              60.000  -        70.000  :      2    0.002    0.995
-              70.000  -        80.000  :      0    0.000    0.995
-              80.000  -        90.000  :      1    0.001    0.996
-              90.000  -       100.000  :      0    0.000    0.996
-             100.000  -       110.000  :      0    0.000    0.996
-    ...
-            9960.000  -      9970.000  :      0    0.000    0.999
-            9970.000  -      9980.000  :      0    0.000    0.999
-            9980.000  -      9990.000  :      0    0.000    0.999
-            9990.000  -     10000.000  :      0    0.000    0.999
-           10000.000  -       above    :      1    0.001    1.000
-
-    outliers:
-           60182.000
-
-******************************************
-*    Running a Complete Test Spectrum    *
-******************************************
-
-People who are interested in round-trip latency often want to see a
-"spectrum" of statistics for a range of payload sizes.  This directory
-includes a script, run_spectrum.pl, that automates running
-SOCK_STREAM_clt or SOCK_SEQPACK_clt multiple times in order to
-generate a spectrum.  (The appropriate server program must be started
-manually.)
-
-The run_spectrum.pl script offers embedded documentation.  To see the
-full documentation, please run
-
-   ./run_spectrum.pl --manual
-
-************************
-*    Sample Results    *
-************************
-
-The file sample-spectrum.png plots the spectrum data for a test run at
-LM ATL facilities on the following systems:  two Linux 2.4.18, 1600 MHz
-Pentium 4 machines on an isolated 100Mbps Ethernet network.
-
-The test conditions include several critical parameters that were set
-as follows:
-
-   sctp_rto_initial = 20
-   sctp_rto_min     = 20
-   sctp_rto_max     = 20
-
-Testing has shown that these parameters affect maximum round-trip
-latency.
diff --git a/performance-tests/SCTP/README.SCTP_in_ACE b/performance-tests/SCTP/README.SCTP_in_ACE
deleted file mode 100644
index b51cd6b3fe6..00000000000
--- a/performance-tests/SCTP/README.SCTP_in_ACE
+++ /dev/null
@@ -1,269 +0,0 @@
-Release 1.1 - June 2003
-
-Overview of SCTP sockets
-------------------------
-
-In order to support multiple implementations of SCTP, we had to standardize 
-on a set of semantics.  
-
-The IETF sockets draft states that service type SOCK_SEQPACKET indicates a UDP
-style socket (i.e. connection-less), while service type SOCK_STREAM indicates
-a TCP style socket.  However, this conflicts with the POSIX definition for 
-SOCK_SEQPACKET as connection-oriented. 
-
-In ACE we choose to support the standard POSIX definition. In doing so, certain 
-socket semantics will be guaranteed regardless of implementation.   
- 
-	[1] SOCK_SEQPACKET sockets will always be message-based, 
-            connection-oriented, and reliable.
-
-	[2] SOCK_STREAM sockets will be message-based or byte-stream based,
-            connection-oriented, and reliable.  
-	
-
-SCTP Features Accessible Within ACE
------------------------------------
-
- * SOCK_STREAM (byte stream oriented or msg oriented) data transport service
-
- * SOCK_SEQPACKET (message oriented) data transport service (this is
-   the service used by TAO's SCIOP pluggable protocol)
-
- * Explicit control of binding network interfaces (all, one, or any
-   subset) to server-side passive- and active- mode sockets on
-   multi-homed machines. (for SOCK_SEQPACKET service only.  The
-   SOCK_STREAM service may only bind one or all interfaces because we
-   avoided changing the interface of ACE_SOCK_Acceptor.)
-
- * Setting and getting of all parameters exposed by SCTP 
-   (e.g. retransmission timeout (RTO)) via ACE_SOCK::set_option(...)
-   and ACE_SOCK::get_option(...) for both SOCK_STREAM and
-   SOCK_SEQPACKET sockets.  You must set the socket level appropriately.  
-
- * Multiplexing of lightweight "SCTP Streams" (over the SOCK_STREAM
-   and SOCK_SEQPACKET services) via ACE_SOCK::set_option(...)
-
- * Network path multiplexing (provided opaquely by the protocol---no
-   explicit support required in ACE other than the ability to
-   configure various parameters and the set of interfaces as described
-   above)
-
-
-Supported SCTP Implementations
-------------------------------
-
- * OpenSS7's Linux Implementation (Berkeley UNIX Network API) 
-   Linux 2.4.18 patch available at: http://www.openss7.org/linux-sctp-0.2.14.tgz
-   (as of April 2003)
-
- * The LKSCTP Linux Kernel Implementation (IETF Sockets Draft API compliant)
-   Available in the Linux 2.5 kernels (http://www.kernel.org/)
-   Tools/Libs available at http://lksctp.sourceforge.net/
-     (All socket interfaces are message-based -- please see README.LKSCTP)
-
-
-BUGS
-----
-
- * OpenSS7 BUGS 
-
-    - protocol crashes when transmitting message sizes greater than
-      PATH MTU in the presence of network failures (message size
-      includes SCTP and IP headers and data.)
-
- * LKSCTP BUGS
-
-    - certain combinations of SCTP parameters will cause a kernel panic
-      (ie. setting rto_initial, rto_max, or rto_min to 0)
-
-
-TO-DO
-----
-
- * Provide explicit control of binding network interfaces to
-   client-side active-mode sockets on multi-homed machines. Current
-   implementation supports all interfaces but not restriction to one
-   or to an arbitrary subset. (This will be done for SOCK_SEQPACKET
-   service only. We want to avoid changing the existing interfaces for
-   the SOCK_STREAM service).
-
- * Integrate management and use of "SCTP Streams" into the
-   ACE_SOCK_SEQPACK_* wrapper-facade. (currently they can only be
-   accessed indirectly through ACE_SOCK::set_option(...))
-
- * Support SOCK_RDM service (connection-less) within ACE for OpenSS7.
-
- * Convert ATL's histogram utility (located under
-   performance-tests/SCTP) into a ACE utility and integrate with other
-   ACE provided statistics classes.
-
- * Support Draft API msg notifications via sendmsg() and recvmsg().  
-
-
-USAGE
------
-
- SOCK_STREAM - Use the ACE_SOCK_Connector, ACE_SOCK_Stream and
-               ACE_SOCK_Acceptor classes. In ACE_SOCK_Connector pass
-               the value IPPROTO_SCTP for the protocol parameter in
-               either the constructor or the connect(...) method
-               as shown in SOCK_STREAM_clt.cpp. In ACE_SOCK_Acceptor
-               pass the value IPPROTO_SCTP for the protocol parameter
-               in either the constructor or the open(...) method
-               as shown in SOCK_STREAM_srv.cpp.
-
-               You must include the file sctp.h in order for
-               IPPROTO_SCTP to be defined.  This file should be under
-               /usr/include/netinet
-
-               Aside from these changes, the classes can be used as
-               they are under TCP (the protocol they use by
-               default). Be cautious to use SCTP protocol options when
-               setting socket options on SCTP sockets (e.g., use
-               SCTP_NODELAY, not TCP_NODELAY, to disable Nagle's
-               algorithm on an SCTP socket.)
-
- SOCK_SEQPACKET - Use the ACE_SOCK_SEQPACK_Connector,
-                  ACE_SOCK_SEQPACK_Association, and
-                  ACE_SOCK_SEQPACK_Acceptor classes, which parallel
-                  the familiar ACE_SOCK_Connector, ACE_SOCK_Stream,
-                  and ACE_SOCK_Acceptor classes, respectively.  Please
-                  see SOCK_SEQPACK_clt.cpp and SOCK_SEQPACK_srv.cpp for
-                  more details.
-
-                  In the special case where you want to specify a set
-                  of interfaces---other than one or all
-                  interfaces---for an ACE_SOCK_SEQPACK_Acceptor, use
-                  an ACE_Multihomed_INET_Addr in place of the familiar
-                  ACE_INET_Addr.  (See SOCK_SEQPACK_srv.cpp for an
-                  example.)
-
-                  SCTP associations may have more than one local and
-                  more than one remote address bound to them.
-                  Accordingly, ACE_SOCK_SEQPACK_Association provides
-                  methods get_local_addrs(...) and
-                  get_remote_addrs(...). These methods return the list
-                  of local and remote addresses bound to an active
-                  mode SCTP socket. Alternately, the familiar
-                  ACE_SOCK::get_local_addr(...)  and
-                  ACE_SOCK::get_remote_addr(...) methods will work
-                  properly with an active mode SCTP socket, but each
-                  will only return a single address. These functions
-                  are only NOT available on ACE_SOCK_SEQPACK_Acceptor
-                  even though that is an SCTP socket as well. This is
-                  because the functions getpeername() and
-                  getsockname() called on a passive SCTP acceptor
-                  socket returns the same values as a TCP socket. As
-                  such, the current ACE methods get_local_addr() and
-                  get_remote_addr() defined in ACE_SOCK are sufficient.
-
-
-DESIGN
-------
-
-SCTP supports two types of network service: SOCK_STREAM and
-SOCK_SEQPACKET.  To integrate SCTP's SOCK_STREAM service into ACE we
-had to make a small modification to the current SOCK_STREAM wrapper
-facade. We had to add a protocol parameter to one constructor and one
-connect method of the ACE_SOCK_Connector class. After this
-modification the ACE SOCK_STREAM wrapper facade worked properly over
-both TCP and SCTP.
-
-To integrate SCTP's SOCK_SEQPACKET service into ACE we had to create a
-new wrapper facade, which we refer to as SOCK_SEQPACK. We closely
-emulated the current SOCK_STREAM wrapper facade to develop our new
-SOCK_SEQPACK wrapper facade. SOCK_SEQPACK_wrapper_facade.jpg depicts
-the classes that implement this new wrapper facade. Also indicated are
-those methods that have a substantial change from their SOCK_STREAM
-wrapper façade counterparts. Not depicted in the figure but noteworthy
-is the removal of the QoS enabled constructor and accept method that
-were imported to SOCK_SEQPACK_Acceptor from SOCK_Acceptor and the
-removal of the QoS enabled constructor and connect method that were
-imported into SOCK_SEQPACK_Connector from SOCK_Connector. SOCK_SEQPACK
-association provides two methods to get the list of secondary
-addresses associated with the local and remote socket (explained in
-more detail in the usage section above).
-
-
-To enable the user to fully exploit the network path multiplexing
-features of SCTP we created a new subclass of ACE_INET_Addr called
-ACE_INET_Multihomed_Addr. This class enables applications to specify
-restricted subsets of network interfaces for inclusion on SCTP
-associations on the client and server side. Multihomed_INET_Addr
-provides a subset of the ACE_INET_Addr API with the addition of
-optional parameters for lists of secondary addresses or hostnames.  If
-just a primary address or hostname is provided
-ACE_Multihomed_INET_Addr behaves as an ACE_INET_Addr (in fact it just
-populates the base ACE_INET_Addr) This is also depicted in
-SOCK_SEQPACK_wrapper_facade.jpg. Multihomed_INET_Addr is only used by
-the SOCK_SEQPACK wrapper facade.
-
-
-All SCTP socket options can be read and written from the current
-socket options methods provided by ACE_SOCK. 
-
-Finally, our SOCK_SEQPACK wrapper facade does not yet support SCTP
-stream multiplexing.
-
-Here are the files under $(ACE_ROOT) that were either modified or
-added. NO files were removed.
-
-$(ACE_ROOT)/ace/ace_dll.dsp                                MODIFIED
-$(ACE_ROOT)/ace/OS.h                                       MODIFIED
-$(ACE_ROOT)/ace/Makefile.ace                               MODIFIED
-$(ACE_ROOT)/ace/SOCK_Connector.h                           MODIFIED
-$(ACE_ROOT)/ace/SOCK_Connector.cpp                         MODIFIED
-
-$(ACE_ROOT)/ace/SOCK_SEQPACK_Acceptor.h                    ADDED
-$(ACE_ROOT)/ace/SOCK_SEQPACK_Acceptor.i                    ADDED
-$(ACE_ROOT)/ace/SOCK_SEQPACK_Acceptor.cpp                  ADDED
-
-$(ACE_ROOT)/ace/SOCK_SEQPACK_Connector.h                   ADDED
-$(ACE_ROOT)/ace/SOCK_SEQPACK_Connector.i                   ADDED
-$(ACE_ROOT)/ace/SOCK_SEQPACK_Connector.cpp                 ADDED
-
-$(ACE_ROOT)/ace/SOCK_SEQPACK_Association.h                 ADDED
-$(ACE_ROOT)/ace/SOCK_SEQPACK_Association.i                 ADDED
-$(ACE_ROOT)/ace/SOCK_SEQPACK_Association.cpp               ADDED
-
-$(ACE_ROOT)/ace/Multihomed_INET_Addr.h                     ADDED
-$(ACE_ROOT)/ace/Multihomed_INET_Addr.i                     ADDED
-$(ACE_ROOT)/ace/Multihomed_INET_Addr.cpp                   ADDED
-
-$(ACE_ROOT)/bin/PerlACE/Process_Unix.pm                    MODIFIED
-$(ACE_ROOT)/bin/PerlACE/Process_Win32.pm                   MODIFIED
-
-$(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU         MODIFIED
-$(ACE_ROOT)/include/makeinclude/platform_linux.GNU         MODIFIED
-
-$(ACE_ROOT)/tests/Makefile                                 MODIFIED
-$(ACE_ROOT)/tests/Multihomed_INET_Addr_Test.cpp            ADDED
-$(ACE_ROOT)/tests/Multihomed_INET_Addr_Test.dsp            ADDED
-$(ACE_ROOT)/tests/SOCK_SEQPACK_Association_Test.cpp        ADDED
-$(ACE_ROOT)/tests/SOCK_SEQPACK_Association_Test.dsp        ADDED
-$(ACE_ROOT)/tests/run_test.lst                             MODIFIED
-$(ACE_ROOT)/tests/run_tests.bat                            MODIFIED
-$(ACE_ROOT)/tests/tests.dsw                                MODIFIED
-
-$(ACE_ROOT)/performance-tests/SCTP/THANKS                  ADDED
-$(ACE_ROOT)/performance-tests/SCTP/README                  ADDED
-$(ACE_ROOT)/performance-tests/SCTP/README.SCTP             ADDED
-$(ACE_ROOT)/performance-tests/SCTP/README.SCTP_in_ACE      ADDED
-$(ACE_ROOT)/performance-tests/SCTP/README.SCTP_PERF_TEST   ADDED
-$(ACE_ROOT)/performance-tests/SCTP/README.OpenSS7          ADDED
-$(ACE_ROOT)/performance-tests/SCTP/README.LKSCTP           ADDED
-
-$(ACE_ROOT)/performance-tests/SCTP/Makefile                ADDED
-$(ACE_ROOT)/performance-tests/SCTP/run_spectrum.pl         ADDED
-
-$(ACE_ROOT)/performance-tests/SCTP/hist.h                  ADDED
-$(ACE_ROOT)/performance-tests/SCTP/hist.cpp                ADDED
-
-$(ACE_ROOT)/performance-tests/SCTP/Options_Manager.h       ADDED
-$(ACE_ROOT)/performance-tests/SCTP/Options_Manager.cpp     ADDED
-
-$(ACE_ROOT)/performance-tests/SCTP/SOCK_STREAM_clt.cpp     ADDED
-$(ACE_ROOT)/performance-tests/SCTP/SOCK_STREAM_srv.cpp     ADDED
-
-$(ACE_ROOT)/performance-tests/SCTP/SOCK_SEQPACK_clt.cpp    ADDED
-$(ACE_ROOT)/performance-tests/SCTP/SOCK_SEQPACK_srv.cpp    ADDED
diff --git a/performance-tests/SCTP/SOCK_SEQPACK_Association_Test.cpp b/performance-tests/SCTP/SOCK_SEQPACK_Association_Test.cpp
deleted file mode 100644
index f47421060f4..00000000000
--- a/performance-tests/SCTP/SOCK_SEQPACK_Association_Test.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-// $Id$
-
-// ============================================================================
-//
-// = LIBRARY
-//    tests
-//
-// = FILENAME
-//    SOCK_SEQPACK_Association_Test.cpp
-//
-// = DESCRIPTION
-//
-//   Tests the methods get_local_addrs and get_remote_addrs of class
-//   ACE_SOCK_SEQPACK_Association.
-//
-//   This is not an automated "one-button" test.  Rather, it prints
-//   some output to a log file, so that an interested human can
-//   inspect the output and get a vague notion of whether or not
-//   the methods are working properly.
-//
-// = AUTHOR
-//    Edward Mulholland (emulholl@atl.lmco.com)
-//
-// ============================================================================
-
-#include "ace/SOCK_SEQPACK_Association.h"
-#include "ace/SOCK_SEQPACK_Connector.h"
-#include "ace/INET_Addr.h"
-#include "ace/Log_Msg.h"
-
-void dump_names(const ACE_SOCK_SEQPACK_Association& assoc);
-
-int main (int argc, ACE_TCHAR *argv[])
-{
-  int status = 0;     // Innocent until proven guilty
-
-  // object that manages the connection to the server
-  ACE_SOCK_SEQPACK_Connector connector;
-
-  // object that manages the data xfer between the client and server
-  ACE_SOCK_SEQPACK_Association dataStream;
-
-  // object that represents the server's IP address and port
-  ACE_INET_Addr serverAddr;
-
-  if (argc < 2) {
-
-    ACE_ERROR ((LM_ERROR,
-                ACE_TEXT ("Usage: SOCK_SEQPACK_Association_Test hostname:port\n")));
-    status = 1;
-
-  } else if (serverAddr.set(argv[1])) {
-
-    ACE_ERROR ((LM_ERROR,
-                ACE_TEXT ("%p\n"),
-                ACE_TEXT ("ACE_INET_Addr::set")));
-    status = 1;
-
-  } else if (connector.connect (dataStream, serverAddr)) {
-
-    ACE_ERROR ((LM_ERROR,
-                ACE_TEXT ("%p\n"),
-                ACE_TEXT ("ACE_SOCK_SEQPACK_Connector::connect")));
-    status = 1;
-
-  } else {
-
-    ACE_DEBUG ((LM_DEBUG,
-                ACE_TEXT ("Connected to server at %s\n"),
-                argv[1]));
-
-    dump_names(dataStream);
-  }
-
-  dataStream.close();
-
-  return status;
-}
-
-void dump_names(const ACE_SOCK_SEQPACK_Association& assoc)
-{
-  // Pre-declare for-loop index
-  size_t i = 0;
-
-  size_t in_out_size = 100;
-  ACE_INET_Addr in_out[100];
-
-  // Output char buffer
-  const size_t outbuf_size = 1024;
-  ACE_TCHAR outbuf[outbuf_size];
-
-  // Get local addresses of the association
-  if (assoc.get_local_addrs(in_out, in_out_size)) {
-
-    ACE_ERROR((LM_ERROR,
-               "%p\n",
-               "get_local_addrs"));
-    return;
-  }
-
-  ACE_DEBUG((LM_DEBUG, "Called get_local_addrs\n"));
-
-  // Print individual results of get_local_addrs
-  for (i = 0; i < in_out_size; ++i) {
-
-    if (in_out[i].addr_to_string(outbuf, outbuf_size)) {
-
-      ACE_ERROR((LM_ERROR,
-                 "%p\n",
-                 "addr_to_string"));
-      return;
-    }
-
-    ACE_DEBUG((LM_DEBUG,
-               "get_local_addrs[%i] = %s\n",
-               i,
-               outbuf));
-  }
-
-  // Reset in_out_size
-  in_out_size = 100;
-
-  // Get remote addresses of the association
-  if (assoc.get_remote_addrs(in_out, in_out_size)) {
-
-    ACE_ERROR((LM_ERROR,
-               "%p\n",
-               "get_remote_addrs"));
-    return;
-  }
-
-  ACE_DEBUG((LM_DEBUG, "Called get_remote_addrs\n"));
-
-  // Print individual results of get_remote_addrs
-  for (i = 0; i < in_out_size; ++i) {
-
-    if (in_out[i].addr_to_string(outbuf, outbuf_size)) {
-
-      ACE_ERROR((LM_ERROR,
-                 "%p\n",
-                 "addr_to_string"));
-      return;
-    }
-
-    ACE_DEBUG((LM_DEBUG,
-               "get_remote_addrs[%i] = %s\n",
-               i,
-               outbuf));
-  }
-}
-
-
diff --git a/performance-tests/SCTP/SOCK_SEQPACK_clt.cpp b/performance-tests/SCTP/SOCK_SEQPACK_clt.cpp
deleted file mode 100644
index 140efc1784b..00000000000
--- a/performance-tests/SCTP/SOCK_SEQPACK_clt.cpp
+++ /dev/null
@@ -1,309 +0,0 @@
-// $Id$
-
-#include "ace/INET_Addr.h"
-#include "ace/SOCK_SEQPACK_Association.h"
-#include "ace/SOCK_SEQPACK_Connector.h"
-#include "ace/Log_Msg.h"
-#include "ace/CDR_Stream.h"
-#include "ace/High_Res_Timer.h"
-
-// FUZZ: disable check_for_streams_include
-#include "ace/streams.h"
-
-#include "ace/os_include/arpa/os_inet.h"
-
-// make sure that the code compiles cleanly even if SCTP is not
-// available. If SCTP is not installed, program will exit early in
-// main() with an error message
-#ifdef ACE_HAS_SCTP
-extern "C" {
-#include <netinet/sctp.h>
-};
-#else
-#ifndef IPPROTO_SCTP
-#define IPPROTO_SCTP 132
-#endif // !IPPROTO_SCTP
-#define SCTP_NODELAY 1
-#endif // ACE_HAS_SCTP
-
-// class that manages setting of options
-#include "Options_Manager.h"
-
-// histogram code
-#include "hist.h"
-
-// global constants
-ACE_CDR::UShort const primerIterations = 100;
-// ace/High_Res_Timer.h describes the need for the following.
-ACE_UINT32 const microsec_clock_scale_factor = ACE_High_Res_Timer::global_scale_factor();
-
-// forward declations of functions. Bodies follow main() to improve
-// file readability.
-HIST runTest(ACE_SOCK_SEQPACK_Association &);
-
-int main(int argc, char **argv){
-
-  // Initialize the options manager
-  Options_Manager optsMgr(argc, argv, "client-opts");
-
-  // show usage is requested
-  if (optsMgr._usage) {
-    optsMgr._show_usage(cerr, "client-opts");
-    return 1;
-  }
-
-#ifndef ACE_HAS_SCTP
-  ACE_ERROR_RETURN((LM_ERROR,
-                    "SCTP was NOT installed/accessible when this binary was compiled.\n"),
-                   1);
-#endif
-
-  // check that valid options were specified
-  if (optsMgr._error) {
-    cerr << "ERROR: " << optsMgr._error_message << endl;
-    return 1;
-  }
-
-
-  // Create the address that we want the client to connect to
-  ACE_INET_Addr serverAddr(Options_Manager::server_port,
-                           Options_Manager::server_host);
-
-  // Create the address that we want the client to connect FROM
-  ACE_Multihomed_INET_Addr clientAddr;
-  clientAddr.set(optsMgr.client_port,
-                 optsMgr.client_connect_addr,
-                 1,
-                 optsMgr.secondary_connect_addrs,
-                 optsMgr.num_secondary_connect_addrs);
-
-  // object that manages the connection to the server
-  ACE_SOCK_SEQPACK_Connector connector;
-
-  // object that manages the data xfer between the client and server
-  ACE_SOCK_SEQPACK_Association dataStream;
-
-  // connect to the server
-  if (connector.connect (dataStream,
-                         serverAddr,
-                         0,clientAddr, 0, 0, 0, optsMgr.test_transport_protocol) == -1) /*, // ALL DEFAULT ARGUMENTS
-                                                                                                 Options_Manager::test_transport_protocol) == -1) */
-    ACE_ERROR_RETURN ((LM_ERROR,
-                       "(%P|%t) %p\n",
-                       "connection failed"),
-                      1);
-
-  // run the test
-  HIST testResultsHistogram = NULL;
-  // connection is closed by runTest* functions
-  testResultsHistogram = runTest(dataStream);
-
-  // report out the test statistics IF NO EXECPTIONS have been thrown
-  // all histograms created are placed onto a linked list that report()
-  // can access. So the histogram created in one of the *_test() functions
-  // will be reported out by the report() call
-  if (testResultsHistogram)
-    report();
-
-  return 0;
-}
-
-// create a histogram to store test results
-HIST createHistogram(ACE_CDR::ULong messageSize){
-  // The histogram created below lives beyond the scope of this
-  // function. So the memory allocated here cannot be cleaned up when
-  // this function goes out of scope. Unfortunately the histogram
-  // implementation does not clean it up either. So it is a small
-  // memory leak.
-  char * histName = (char *) malloc(200);
-
-  sprintf(histName, "%s Unmarshalled Msg Synchronous Latency Test\n\t\t\t\t\t(Message Size %u, Message Type octet)",
-          "ACE", messageSize);
-
-  // actually create the histogram
-  HIST createdHist = histogram(histName,
-                               Options_Manager::histogram_bin_count,
-                               Options_Manager::histogram_min_bin,
-                               Options_Manager::histogram_max_bin);
-
-  // set the maximum number of outliers to maintain in the histogram
-  set_outer(Options_Manager::histogram_num_outliers, createdHist);
-
-  return (createdHist);
-}
-
-// send the test header (only contains number of iterations)
-int sendHeader(ACE_SOCK_SEQPACK_Association & stream) {
-
-  // create an ACE CDR output stream and place the header information
-  // into it
-  ACE_OutputCDR hdrCDR;
-  hdrCDR << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER);
-  hdrCDR << ACE_CDR::ULong(Options_Manager::test_iterations+primerIterations);
-  if (!hdrCDR.good_bit())
-    return (0);
-
-  // send the header to the server (HEADER is 8 BYTES LONG)
-  size_t bt;
-  if (stream.send_n(hdrCDR.begin(), 0,  &bt) == -1)
-    return 0;
-
-  return 1;
-}
-
-// conduct the UnMarshalled Octet performance test using separate
-// send_n calls with Nagle's algorithm disabled
-HIST runUnmarshalledOctetTest(ACE_CDR::Octet *buf, size_t seqLen, ACE_SOCK_SEQPACK_Association & stream){
-
-  ACE_CDR::ULong const testIterations = Options_Manager::test_iterations;
-
-  size_t bt;
-  ACE_CDR::ULong cnt = 0;
-  // variables for the timing measurements
-  ACE_hrtime_t startTime, endTime;
-  ACE_CDR::Double messageLatency_usec = 0.0;
-  ACE_CDR::ULong msgLen = seqLen*ACE_CDR::OCTET_SIZE;
-
-  // explicity configure Nagling. Default is
-  // Options_Manager::test_enable_nagle=0 so default configurations is
-  // NO NAGLING
-  ACE_CDR::Long nagle;
-  if (Options_Manager::test_enable_nagle)
-    nagle=0;
-  else
-    nagle=1;
-  if (-1 == stream.set_option(IPPROTO_SCTP, SCTP_NODELAY, &nagle, sizeof nagle))
-    ACE_ERROR_RETURN ((LM_ERROR,
-                       "%p\n",
-                       "set_option"),
-                      0);
-
-  // prime the client and server before starting the test
-  for(cnt=0;cnt<primerIterations;++cnt){
-
-    // send message size
-    // TODO : The message length should be CDR encoded
-    ACE_CDR::ULong msgLenExpressed = ACE_HTONL(msgLen);
-    if (-1 == stream.send_n (&msgLenExpressed, ACE_CDR::LONG_SIZE, 0, &bt))
-      ACE_ERROR_RETURN ((LM_ERROR,
-                         "%p\n",
-                         "send_n"),
-                        0);
-
-    // send a message
-    if (-1 == stream.send_n (buf, msgLen, 0, &bt))
-      ACE_ERROR_RETURN ((LM_ERROR,
-                         "%p\n",
-                         "send_n"),
-                        0);
-
-    // block for a Short reply
-    ACE_CDR::Short reply;
-    if ((stream.recv_n(&reply, ACE_CDR::SHORT_SIZE, 0, &bt)) == -1)
-      ACE_ERROR_RETURN((LM_ERROR,
-                        "%p\n",
-                        "recv_n"),
-                       0);
-  }
-
-  // AFTER PRIMING THE PUMP CREATE THE HISTOGRAM
-  HIST aceStream_hist=NULL;
-  aceStream_hist = createHistogram(msgLen);
-  if (NULL == aceStream_hist)
-    ACE_ERROR_RETURN((LM_ERROR,
-                      "%p\n",
-                      "histogram create failed"),
-                     0);
-
-  iovec iov[2];
-  // PERFORMANCE TEST LOOP
-  for (cnt = 0; cnt < testIterations; ++cnt){
-
-    // get the start time
-    startTime = ACE_OS::gethrtime();
-    if (!startTime)
-      ACE_ERROR_RETURN((LM_ERROR,
-                        "%p\n",
-                        "ACE_OS::gethrtime()"),
-                       0);
-
-    ACE_CDR::ULong msgLenExpressed = ACE_HTONL(msgLen);
-    iov[0].iov_base = ACE_reinterpret_cast(char *, &msgLenExpressed);
-    iov[0].iov_len = ACE_CDR::LONG_SIZE;
-    iov[1].iov_base = ACE_reinterpret_cast(char *, buf);
-    iov[1].iov_len = msgLen;
-
-    if (-1 == stream.sendv_n (iov, 2))
-      ACE_ERROR_RETURN ((LM_ERROR,
-                         "%p\n",
-                         "send_n"),
-                        0);
-
-    // block for a Short reply
-    ACE_CDR::Short reply;
-    if ((stream.recv_n(&reply, ACE_CDR::SHORT_SIZE, 0, &bt)) == -1)
-      ACE_ERROR_RETURN((LM_ERROR,
-                        "%p\n",
-                        "recv_n"),
-                       0);
-
-    // get the end time
-    endTime = ACE_OS::gethrtime();
-    if (!endTime)
-      ACE_ERROR_RETURN((LM_ERROR,
-                        "%p\n",
-                        "ACE_OS::gethrtime()"),
-                       0);
-
-    // compute the message latency in micro-seconds
-    messageLatency_usec =
-
-      (ACE_static_cast(double,
-                       ACE_UINT64_DBLCAST_ADAPTER(endTime)) -
-       ACE_static_cast(double,
-                       ACE_UINT64_DBLCAST_ADAPTER(startTime)))
-
-      / microsec_clock_scale_factor;
-
-
-    // record the message latency in the histogram
-    record(messageLatency_usec, aceStream_hist);
-  }
-
-  // THE HEADER MESSAGE SENT TO THE SERVER CONTAINED THE NUMBER OF
-  // PRIMER AND TEST MESSAGES TO BE SENT AFTER WHICH THE SERVER WILL
-  // CLOSE THE STREAM SO ONCE WE REACH THIS POINT THE STREAM IS NO
-  // LONGER VALID AND WE CLOSE IT.
-  stream.close();
-
-  // allocated by runTest
-  delete[] buf;
-  return aceStream_hist;
-}
-
-// sends the test information to the server and calls the correct test
-// function.
-HIST runTest(ACE_SOCK_SEQPACK_Association & stream)
-{
-  size_t msgLen = 1;
-  for (int i=1; i <= Options_Manager::payload_size_power_of_2; i++)
-    msgLen *= 2;
-  
-
-
-  // send a header to the server that contains test parameters
-  if (sendHeader(stream) < 0)
-    ACE_ERROR_RETURN((LM_ERROR,
-                      "Could NOT Send CDR Encoded Header"),
-                     0);
-
-  // create the forward message buffer
-
-  ACE_CDR::Octet *o_arr;
-  ACE_CDR::ULong seqLen = msgLen/ACE_CDR::OCTET_SIZE;
-  ACE_NEW_RETURN(o_arr,
-                 ACE_CDR::Octet[seqLen],
-                 0);
-  // o_arr is deleted in run_octet_test
-  return(runUnmarshalledOctetTest(o_arr, seqLen, stream));
-}
diff --git a/performance-tests/SCTP/SOCK_SEQPACK_srv.cpp b/performance-tests/SCTP/SOCK_SEQPACK_srv.cpp
deleted file mode 100644
index 0191628c60c..00000000000
--- a/performance-tests/SCTP/SOCK_SEQPACK_srv.cpp
+++ /dev/null
@@ -1,357 +0,0 @@
-// $Id$
-
-#include "ace/Multihomed_INET_Addr.h"
-#include "ace/SOCK_SEQPACK_Association.h"
-#include "ace/SOCK_SEQPACK_Acceptor.h"
-#include "ace/Log_Msg.h"
-#include "ace/Thread_Manager.h"
-#include "ace/Handle_Set.h"
-#include "ace/CDR_Stream.h"
-
-// FUZZ: disable check_for_streams_include
-#include "ace/streams.h"
-
-#include "ace/os_include/arpa/os_inet.h"
-#include "ace/OS_NS_sys_select.h"
-#include "ace/OS_NS_string.h"
-#include "ace/OS_NS_arpa_inet.h"
-
-// make sure that the code compiles cleanly even if SCTP is not
-// available. If SCTP is not installed, program will exit early in
-// main() with an error message
-#ifdef ACE_HAS_SCTP
-extern "C" {
-#include <netinet/sctp.h>
-};
-#else
-#ifndef IPPROTO_SCTP
-#define IPPROTO_SCTP 132
-#endif // !IPPROTO_SCTP
-#define SCTP_NODELAY 1
-#endif
-
-// class that manages setting of options
-#include "Options_Manager.h"
-
-// structure to bundle arguments for thread functions
-struct ArgStruct {
-  ACE_SOCK_SEQPACK_Association * stream;
-  ACE_CDR::ULong numIters;
-};
-
-// thread function that serves the client for the UnMarshalled Octet
-// test
-static ACE_THR_FUNC_RETURN unmarshalledOctetServer (void *arg){
-
-  // unbundle the arguments
-  ArgStruct * args = ACE_reinterpret_cast(ArgStruct *,arg);
-  ACE_SOCK_SEQPACK_Association * dataModeStream = args->stream;
-  ACE_CDR::ULong numIterations = args->numIters;
-  delete args;
-
-  // serve the client for numIterations synchronous invocations
-  do {
-
-    // READ A MESSAGE FROM THE CLIENT
-
-    size_t bt;
-    ACE_CDR::ULong msgBufSize=0;
-    // read the size of the buffer to follow
-    if ((dataModeStream->recv_n(&msgBufSize, ACE_CDR::LONG_SIZE, 0, &bt)) == -1)
-      ACE_ERROR_RETURN((LM_ERROR,
-                        "%p\n",
-                        "recv_n"),
-                       0);
-    msgBufSize = ACE_NTOHL(msgBufSize);
-
-    // allocate the buffer for the message payload
-    ACE_CDR::Octet * msgBuf=NULL;
-    ACE_NEW_RETURN(msgBuf,
-                   ACE_CDR::Octet[msgBufSize],
-                   0);
-
-    // read the buffer
-    if ((dataModeStream->recv_n(msgBuf, msgBufSize, 0, &bt)) == -1)
-      ACE_ERROR_RETURN((LM_ERROR,
-                        "%p\n",
-                        "recv_n"),
-                       0);
-
-    // clean up the allocated buffer
-    delete[] msgBuf;
-
-    // SEND A REPLY TO THE CLIENT
-
-    // send back a 2 byte reply
-    ACE_CDR::Short reply;
-    if ((dataModeStream->send_n(&reply, ACE_CDR::SHORT_SIZE, 0, &bt)) == -1)
-      ACE_ERROR_RETURN((LM_ERROR,
-                        "%p\n",
-                        "send_n"),
-                       0);
-
-  } while (--numIterations);
-
-  // close and destroy the stream
-  dataModeStream->close();
-  delete dataModeStream;
-
-  return NULL;
-}
-
-// sets up the dataModeSocket Stream, reads the test header infomation
-// and launches a thread to handle the requested test.
-static void run_server (ACE_HANDLE handle)
-{
-  ACE_INET_Addr cli_addr;
-  // create a new stream and initialized with the handle returned by
-  // accept
-  ACE_SOCK_SEQPACK_Association * dataModeStream = new ACE_SOCK_SEQPACK_Association;
-  dataModeStream->set_handle (handle);
-
-  // Make sure we're not in non-blocking mode.
-  if (dataModeStream->disable (ACE_NONBLOCK) == -1){
-    ACE_ERROR ((LM_ERROR,
-                "%p\n",
-                "disable"));
-    return;
-  }
-  else if (dataModeStream->get_remote_addr (cli_addr) == -1){
-    ACE_ERROR ((LM_ERROR,
-                "%p\n",
-                "get_remote_addr"));
-    return;
-  }
-
-  // explicity configure Nagling. Default is
-  // Options_Manager::test_enable_nagle=0 so default configurations is
-  // NO NAGLING
-  ACE_CDR::Long nagle;
-  if (Options_Manager::test_enable_nagle)
-    nagle=0;
-  else
-    nagle=1;
-
-  if (-1 == dataModeStream->set_option(IPPROTO_SCTP, SCTP_NODELAY, &nagle, sizeof nagle)){
-    // can't ise ACE_ERROR_RETURN b/c function has void return value
-    ACE_ERROR((LM_ERROR,
-               "%p\n",
-               "set_option"));
-    return;
-  }
-
-  ACE_DEBUG ((LM_DEBUG,
-              "(%P|%t) client %s connected from %d\n",
-              cli_addr.get_host_name (),
-              cli_addr.get_port_number ()));
-
-  // hdr bufSize is hardcoded to 8 bytes
-  // (4 for a CDR-encoded boolean and 4 for a CDR-encoded ULong)
-  ACE_CDR::ULong hdrBufSize = 8;
-  // allocate a raw buffer large enough to receive the header and be
-  // properly aligned for the CDR decoding.
-  ACE_CDR::Char * hdrBuf= new ACE_CDR::Char[hdrBufSize+ACE_CDR::MAX_ALIGNMENT];
-  // align the raw buffer before reading data into it.
-  char * hdrBuf_a = ACE_ptr_align_binary(hdrBuf, ACE_CDR::MAX_ALIGNMENT);
-
-  size_t bt;
-  // read the header
-  if ((dataModeStream->recv_n(hdrBuf_a, hdrBufSize, 0, &bt)) == -1){
-    ACE_ERROR ((LM_ERROR,
-                "%p\n",
-                "recv_n"));
-    return;
-  }
-
-  // pass the CDR encoded data into an ACE_InputCDR class. hdrCDR does
-  // NOT copy this data. Nor does it delete. It assumes the buffer
-  // remains valid while it is in scope.
-  ACE_InputCDR hdrCDR(hdrBuf_a, hdrBufSize);
-
-  ACE_CDR::Boolean byteOrder;
-  ACE_CDR::ULong numIterations;
-
-  // extract the data
-  hdrCDR >> ACE_InputCDR::to_boolean (byteOrder);
-  hdrCDR.reset_byte_order(byteOrder);
-  hdrCDR >> numIterations;
-
-  // make sure the stream is good after the extractions
-  if (!hdrCDR.good_bit()){
-    ACE_ERROR((LM_ERROR,
-               "%p\n",
-               "hdrCDR"));
-
-    return;
-  }
-
-  ACE_DEBUG ((LM_DEBUG,
-              "(%P|%t) Test for %u iterations\n",
-              numIterations));
-
-  // deallocate the header buffer
-  delete[] hdrBuf;
-
-  // bundle up the arguments
-  ArgStruct * args = new ArgStruct;
-  args->stream = dataModeStream;
-  args->numIters = numIterations;
-
-#if defined (ACE_HAS_THREADS)
-  // Spawn a new thread and run the new connection in that thread of
-  // control using the <server> function as the entry point.
-  if (ACE_Thread_Manager::instance ()->spawn (unmarshalledOctetServer,
-                                              ACE_reinterpret_cast(void *,args),
-                                              THR_DETACHED) == -1)
-    ACE_ERROR ((LM_ERROR,
-                "(%P|%t) %p\n",
-                "spawn"));
-#else
-  (*unmarshalledOctetServer) (ACE_reinterpret_cast(void *, args));
-#endif /* ACE_HAS_THREADS */
-
-}
-
-int main(int argc, char **argv){
-
-  Options_Manager optsMgr(argc, argv, "server-opts");
-
-  // show usage is requested
-  if (optsMgr._usage) {
-    optsMgr._show_usage(cerr, "server-opts");
-    return 1;
-  }
-
-#ifndef ACE_HAS_SCTP
-  // SCTP is not installed. Exit with informative error message.
-  ACE_ERROR_RETURN((LM_ERROR,
-                    "SCTP was NOT installed/accessible when this binary was compiled.\n"),
-                   1);
-#endif
-
-  // check that valid options were specified
-  if (optsMgr._error) {
-    cerr << "ERROR: " << optsMgr._error_message << endl;
-    return 1;
-  }
-
-  // this is the socket that the server will listen on
-  ACE_SOCK_SEQPACK_Acceptor acceptor_socket;
-
-  // Create the address that we want to listen for connections on. If
-  // server_accept_addr=INADDR_ANY (the default), SCTP will listen for
-  // connections on all IP interfaces. If an address is specified,
-  // SCTP will listen for connections on that address ONLY.
-  ACE_Multihomed_INET_Addr serverAddr;
-
-  serverAddr.set(optsMgr.server_port,
-                 optsMgr.server_accept_addr,
-                 1,
-                 optsMgr.secondary_accept_addrs,
-                 optsMgr.num_secondary_accept_addrs);
-
-  // this operation creates a socket, binds the specified internet
-  // address to it and calls listen. As this is a wrapper facade
-  // approach, the ACE_OS::{socket,bind,listen} calls are invoked in
-  // the implementation of open.
-  if (acceptor_socket.open(serverAddr, 1,
-                           AF_INET,
-                           ACE_DEFAULT_BACKLOG,
-                           optsMgr.test_transport_protocol) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR,
-                       "%p\n",
-                       "open"),
-                      1);
-
-  // this function checks that the port that was actually bound was
-  // the port we asked for. Apparently some operating systems will
-  // automatically select new ports if the specified port is currently
-  // used.
-  if (acceptor_socket.get_local_addr(serverAddr) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR,
-                       "%p\n",
-                       "get_local_addr"),
-                      1);
-
-    sockaddr_in *addresses = new sockaddr_in[ 1 + serverAddr.get_num_secondary_addresses() ];
-    serverAddr.get_addresses( addresses, 1 + serverAddr.get_num_secondary_addresses() ) ;
-    ACE_DEBUG((LM_DEBUG,
-               "(%P|%t) Accepting connections, using %s on port %u "
-               "on interfaces %s",
-               (optsMgr.test_transport_protocol == IPPROTO_SCTP) ? "IPPROTO_SCTP" : "IPPROTO_TCP", 
-               serverAddr.get_port_number(), 
-               ACE_OS::inet_ntoa( addresses[0].sin_addr)  ));
-
-   unsigned int i;
-   for(i=1; i < serverAddr.get_num_secondary_addresses() ; ++i ) {
-     ACE_DEBUG((LM_DEBUG, " and %s", ACE_OS::inet_ntoa( addresses[i].sin_addr) ));
-   }
-   ACE_DEBUG((LM_DEBUG, "\n" ));
-
-   delete[] addresses;
-
-  // this is the stream object that will associated with a completed
-  // connection (aka the data mode socket). It will be set when accept
-  // is called below.
-  ACE_SOCK_SEQPACK_Association new_stream;
-
-  // a file decriptor set
-  ACE_Handle_Set handle_set;
-  // add the acceptor socket to the file descriptor set.
-  handle_set.set_bit(acceptor_socket.get_handle());
-
-  for (;;){
-
-    ACE_Time_Value timeout(ACE_DEFAULT_TIMEOUT);
-    ACE_Handle_Set temp = handle_set;
-
-    // wait for connect() call from client. In the original test there
-    // were two different acceptor sockets for two different
-    // services. So select was needed to wait on both sockets
-    // simultaneously. In this test we could just call accept on the
-    // one socket.
-    int result = ACE_OS::select((int) (acceptor_socket.get_handle()) +1,
-                                (fd_set *) temp,
-                                0,
-                                0,
-                                timeout);
-
-    // check that select did not end with an error.
-    if (result == -1)
-      ACE_ERROR ((LM_ERROR,
-                  "(%P|%t) %p\n",
-                  "select"));
-    // check to see if select timed out.
-    else if (result == 0){
-      ACE_DEBUG ((LM_DEBUG,
-                  "(%P|%t) select timed out\n"));
-
-    }
-    else { // case where a file descriptor was actually set
-      if (!(temp.is_set(acceptor_socket.get_handle()))){
-        // CANNOT BE REACHED
-        ACE_ERROR ((LM_ERROR,
-                    "(%P|%t) %p\n",
-                    "select: NO ERROR BUT NO FD SET"));
-      } else {
-        // call accept to set up the new stream.
-        if (acceptor_socket.accept(new_stream) == -1) {
-          ACE_ERROR ((LM_ERROR,
-                      "%p\n",
-                      "accept"));
-          continue;
-        }
-        else{
-          ACE_DEBUG ((LM_DEBUG,
-                      "(%P|%t) spawning server\n"));
-
-        }
-        // Run the server.
-        run_server (new_stream.get_handle ());
-      }
-
-    }
-
-  }
-  return 0;
-}
diff --git a/performance-tests/SCTP/SOCK_SEQPACK_wrapper_facade.jpg b/performance-tests/SCTP/SOCK_SEQPACK_wrapper_facade.jpg
deleted file mode 100755
index 3cb82002fe5..00000000000
--- a/performance-tests/SCTP/SOCK_SEQPACK_wrapper_facade.jpg
+++ /dev/null
diff --git a/performance-tests/SCTP/SOCK_STREAM_clt.cpp b/performance-tests/SCTP/SOCK_STREAM_clt.cpp
deleted file mode 100644
index 55fd85c2c15..00000000000
--- a/performance-tests/SCTP/SOCK_STREAM_clt.cpp
+++ /dev/null
@@ -1,318 +0,0 @@
-// $Id$
-
-#include "ace/INET_Addr.h"
-#include "ace/SOCK_Stream.h"
-#include "ace/SOCK_Connector.h"
-#include "ace/Log_Msg.h"
-#include "ace/CDR_Stream.h"
-#include "ace/High_Res_Timer.h"
-
-// FUZZ: disable check_for_streams_include
-#include "ace/streams.h"
-
-#include "ace/os_include/netinet/os_tcp.h"
-#include "ace/os_include/arpa/os_inet.h"
-
-// make sure that the code compiles cleanly even if SCTP is not
-// available. If SCTP is not installed, program will exit early in
-// main() with an error message
-#ifdef ACE_HAS_SCTP
-extern "C" {
-#include <netinet/sctp.h>
-};
-#else
-#ifndef IPPROTO_SCTP
-#define IPPROTO_SCTP 132
-#endif
-#define SCTP_NODELAY -1
-#endif
-
-// class that manages setting of options
-#include "Options_Manager.h"
-
-// histogram code
-#include "hist.h"
-
-// global constants
-ACE_CDR::UShort const primerIterations = 100;
-// ace/High_Res_Timer.h describes the need for the following.
-ACE_UINT32 const microsec_clock_scale_factor = ACE_High_Res_Timer::global_scale_factor();
-
-// forward declations of functions. Bodies follow main() to improve
-// file readability.
-HIST runTest(ACE_SOCK_Stream &);
-
-int main(int argc, char **argv){
-
-  // Initialize the options manager
-  Options_Manager optsMgr(argc, argv, "client-opts");
-
-  // show usage if requested
-  if (optsMgr._usage) {
-    optsMgr._show_usage(cerr, "client-opts");
-    return 1;
-  }
-
-  // If SCTP is not installed then terminate the program, unless TCP
-  // was specified.
-#ifndef ACE_HAS_SCTP
-  if (optsMgr.test_transport_protocol == IPPROTO_SCTP)
-    ACE_ERROR_RETURN((LM_ERROR,
-                      "SCTP was NOT installed when this binary was compiled.\nSOCK_STREAM_clt may still be run using TCP via the '-t tcp' option.\n"),
-                     1);
-#endif
-
-  // check that valid options were specified
-  if (optsMgr._error) {
-    cerr << "ERROR: " << optsMgr._error_message << endl;
-    return 1;
-  }
-
-
-  // Create the address that we want the client to connect to
-  ACE_INET_Addr serverAddr(Options_Manager::server_port,
-                           Options_Manager::server_host);
-
-  // Create the address that we want the client to connect FROM
-  ACE_INET_Addr clientAddr(Options_Manager::client_port,
-                           Options_Manager::client_connect_addr);
-
-  // object that manages the connection to the server
-  ACE_SOCK_Connector connector;
-
-  // object that manages the data xfer between the client and server
-  ACE_SOCK_Stream dataStream;
-
-  // connect to the server
-  if (connector.connect (dataStream,
-                         serverAddr,
-                         0,clientAddr, 0, 0, 0, // ALL DEFAULT ARGUMENTS
-                         Options_Manager::test_transport_protocol) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR,
-                       "(%P|%t) %p\n",
-                       "connection failed"),
-                      1);
-
-  // run the test
-  HIST testResultsHistogram = NULL;
-  // connection is closed by runTest* functions
-  testResultsHistogram = runTest(dataStream);
-
-  // report out the test statistics.
-  // all histograms created are placed onto a linked list that report()
-  // can access. So the histogram created in one of the *_test() functions
-  // will be reported out by the report() call
-  if (testResultsHistogram)
-    report();
-
-  return 0;
-}
-
-// create a histogram to store test results
-HIST createHistogram(ACE_CDR::ULong messageSize){
-  // The histogram created below lives beyond the scope of this
-  // function. So the memory allocated here cannot be cleaned up when
-  // this function goes out of scope. Unfortunately the histogram
-  // implementation does not clean it up either. So it is a small
-  // memory leak.
-  char * histName = (char *) malloc(200);
-
-  sprintf(histName, "%s Unmarshalled Msg Synchronous Latency Test\n\t\t\t\t\t(Message Size %u, Message Type octet)",
-          "ACE", messageSize);
-
-  // actually create the histogram
-  HIST createdHist = histogram(histName,
-                               Options_Manager::histogram_bin_count,
-                               Options_Manager::histogram_min_bin,
-                               Options_Manager::histogram_max_bin);
-
-  // set the maximum number of outliers to maintain in the histogram
-  set_outer(Options_Manager::histogram_num_outliers, createdHist);
-
-  return (createdHist);
-}
-
-// send the test header (only contains number of iterations)
-int sendHeader(ACE_SOCK_Stream & stream) {
-
-  // create an ACE CDR output stream and place the header information
-  // into it
-  ACE_OutputCDR hdrCDR;
-    hdrCDR << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER);
-    hdrCDR << ACE_CDR::ULong(Options_Manager::test_iterations+primerIterations);
-  if (!hdrCDR.good_bit())
-    return (0);
-
-  // send the header to the server (HEADER IS 8 BYTES LONG)
-  size_t bt;
-  if (stream.send_n(hdrCDR.begin(), 0,  &bt) == -1)
-    return 0;
-
-  return 1;
-}
-
-// conduct the UnMarshalled Octet performance test using separate
-// send_n calls with Nagle's algorithm disabled
-HIST runUnmarshalledOctetTest(ACE_CDR::Octet *buf, size_t seqLen, ACE_SOCK_Stream & stream){
-
-  ACE_CDR::ULong const testIterations = Options_Manager::test_iterations;
-
-  size_t bt;
-  ACE_CDR::ULong cnt = 0;
-  // variables for the timing measurements
-  ACE_hrtime_t startTime, endTime;
-  ACE_CDR::Double messageLatency_usec = 0.0;
-  ACE_CDR::ULong msgLen = seqLen*ACE_CDR::OCTET_SIZE;
-
-  // explicity configure Nagling. Default is
-  // Options_Manager::test_enable_nagle=0 so default configurations is
-  // NO NAGLING
-  ACE_CDR::Long nagle;
-  if (Options_Manager::test_enable_nagle)
-    nagle=0;
-  else
-    nagle=1;
-  if (Options_Manager::test_transport_protocol == IPPROTO_SCTP){
-    // default - sctp case
-    if (-1 == stream.set_option(IPPROTO_SCTP, SCTP_NODELAY, &nagle, sizeof nagle))
-      ACE_ERROR_RETURN ((LM_ERROR,
-                         "%p\n",
-                         "set_option"),
-                        0);
-  } else {
-    // tcp case
-    if (-1 == stream.set_option(IPPROTO_TCP, TCP_NODELAY, &nagle, sizeof nagle))
-      ACE_ERROR_RETURN ((LM_ERROR,
-                         "%p\n",
-                         "set_option"),
-                        0);
-  }
-
-  // prime the client and server before starting the test
-  for(cnt=0;cnt<primerIterations;++cnt){
-
-    // send message size
-    // TODO : The message length should be CDR encoded
-    ACE_CDR::ULong msgLenExpressed = ACE_HTONL(msgLen);
-    if (-1 == stream.send_n (&msgLenExpressed, ACE_CDR::LONG_SIZE, 0, &bt))
-      ACE_ERROR_RETURN ((LM_ERROR,
-                         "%p\n",
-                         "send_n"),
-                        0);
-
-    // send a message
-    if (-1 == stream.send_n (buf, msgLen, 0, &bt))
-      ACE_ERROR_RETURN ((LM_ERROR,
-                         "%p\n",
-                         "send_n"),
-                        0);
-
-    // block for a Short reply
-    ACE_CDR::Short reply;
-    if ((stream.recv_n(&reply, ACE_CDR::SHORT_SIZE, 0, &bt)) == -1)
-      ACE_ERROR_RETURN((LM_ERROR,
-                        "%p\n",
-                        "recv_n"),
-                       0);
-  }
-
-  // AFTER PRIMING THE PUMP CREATE THE HISTOGRAM
-  HIST aceStream_hist=NULL;
-  aceStream_hist = createHistogram(msgLen);
-  if (NULL == aceStream_hist)
-    ACE_ERROR_RETURN((LM_ERROR,
-                      "%p\n",
-                      "histogram create failed"),
-                     0);
-
-  iovec iov[2];
-  // PERFORMANCE TEST LOOP
-  for (cnt = 0; cnt < testIterations; ++cnt){
-
-    // get the start time
-    startTime = ACE_OS::gethrtime();
-    if (!startTime)
-      ACE_ERROR_RETURN((LM_ERROR,
-                        "%p\n",
-                        "ACE_OS::gethrtime()"),
-                       0);
-
-
-    ACE_CDR::ULong msgLenExpressed = ACE_HTONL(msgLen);
-    iov[0].iov_base = ACE_reinterpret_cast(char *, &msgLenExpressed);
-    iov[0].iov_len = ACE_CDR::LONG_SIZE;
-    iov[1].iov_base = ACE_reinterpret_cast(char *, buf);
-    iov[1].iov_len = msgLen;
-
-    if (-1 == stream.sendv_n (iov, 2))
-      ACE_ERROR_RETURN ((LM_ERROR,
-                         "%p\n",
-                         "send_n"),
-                        0);
-
-    // block for a Short reply
-    ACE_CDR::Short reply;
-    if ((stream.recv_n(&reply, ACE_CDR::SHORT_SIZE, 0, &bt)) == -1)
-      ACE_ERROR_RETURN((LM_ERROR,
-                        "%p\n",
-                        "recv_n"),
-                       0);
-
-    // get the end time
-    endTime = ACE_OS::gethrtime();
-    if (!endTime)
-      ACE_ERROR_RETURN((LM_ERROR,
-                        "%p\n",
-                        "ACE_OS::gethrtime()"),
-                       0);
-
-    // compute the message latency in micro-seconds
-    messageLatency_usec =
-
-      (ACE_static_cast(double,
-                       ACE_UINT64_DBLCAST_ADAPTER(endTime)) -
-       ACE_static_cast(double,
-                       ACE_UINT64_DBLCAST_ADAPTER(startTime)))
-
-      / microsec_clock_scale_factor;
-
-    // record the message latency in the histogram
-    record(messageLatency_usec, aceStream_hist);
-  }
-
-  // THE HEADER MESSAGE SENT TO THE SERVER CONTAINED THE NUMBER OF
-  // PRIMER AND TEST MESSAGES TO BE SENT AFTER WHICH THE SERVER WILL
-  // CLOSE THE STREAM SO ONCE WE REACH THIS POINT THE STREAM IS NO
-  // LONGER VALID AND WE CLOSE IT.
-  stream.close();
-
-  // allocated by runTest
-  delete[] buf;
-  return aceStream_hist;
-}
-
-// sends the test information to the server and calls the correct test
-// function.
-HIST runTest(ACE_SOCK_Stream & stream)
-{
-
-  size_t msgLen = 1;
-  for (int i=1; i <= Options_Manager::payload_size_power_of_2; i++)
-    msgLen *= 2;
-
-  // send a header to the server that contains test parameters
-  if (sendHeader(stream) < 0)
-    ACE_ERROR_RETURN((LM_ERROR,
-                      "Could NOT Send CDR Encoded Header"),
-                     0);
-
-  // create the forward message buffer
-
-  ACE_CDR::Octet *o_arr;
-  ACE_CDR::ULong seqLen = msgLen/ACE_CDR::OCTET_SIZE;
-  ACE_NEW_RETURN(o_arr,
-                 ACE_CDR::Octet[seqLen],
-                 0);
-  // o_arr is deleted in run_octet_test
-  return(runUnmarshalledOctetTest(o_arr, seqLen, stream));
-}
diff --git a/performance-tests/SCTP/SOCK_STREAM_srv.cpp b/performance-tests/SCTP/SOCK_STREAM_srv.cpp
deleted file mode 100644
index 1e04d41807d..00000000000
--- a/performance-tests/SCTP/SOCK_STREAM_srv.cpp
+++ /dev/null
@@ -1,358 +0,0 @@
-// $Id$
-
-#include "ace/INET_Addr.h"
-#include "ace/SOCK_Stream.h"
-#include "ace/SOCK_Acceptor.h"
-#include "ace/Log_Msg.h"
-#include "ace/Thread_Manager.h"
-#include "ace/Handle_Set.h"
-#include "ace/CDR_Stream.h"
-
-// FUZZ: disable check_for_streams_include
-#include "ace/streams.h"
-
-#include "ace/os_include/netinet/os_tcp.h"
-#include "ace/os_include/arpa/os_inet.h"
-#include "ace/OS_NS_sys_select.h"
-
-// make sure that the code compiles cleanly even if SCTP is not
-// available. If SCTP is not installed, program will exit early in
-// main() with an error message
-#ifdef ACE_HAS_SCTP
-extern "C" {
-#include <netinet/sctp.h>
-};
-#else
-#ifndef IPPROTO_SCTP
-#define IPPROTO_SCTP 132 /* always the same value on every platform */ 
-#endif
-#define SCTP_NODELAY -1
-#endif
-
-// class that manages setting of options
-#include "Options_Manager.h"
-
-// structure to bundle arguments for thread functions
-struct ArgStruct {
-  ACE_SOCK_Stream * stream;
-  ACE_CDR::ULong numIters;
-};
-
-// thread function that serves the client for the UnMarshalled Octet
-// test
-static ACE_THR_FUNC_RETURN unmarshalledOctetServer (void *arg){
-
-  // unbundle the arguments
-  ArgStruct * args = ACE_reinterpret_cast(ArgStruct *,arg);
-  ACE_SOCK_Stream * dataModeStream = args->stream;
-  ACE_CDR::ULong numIterations = args->numIters;
-  delete args;
-
-  // serve the client for numIterations synchronous invocations
-  do {
-
-    // READ A MESSAGE FROM THE CLIENT
-
-    size_t bt;
-    ACE_CDR::ULong msgBufSize=0;
-    // read the size of the buffer to follow
-    if ((dataModeStream->recv_n(&msgBufSize, ACE_CDR::LONG_SIZE, 0, &bt)) == -1)
-      ACE_ERROR_RETURN((LM_ERROR,
-                        "%p\n",
-                        "recv_n"),
-                       0);
-    msgBufSize = ACE_NTOHL(msgBufSize);
-
-    // allocate the buffer for the message payload
-    ACE_CDR::Octet * msgBuf=NULL;
-    ACE_NEW_RETURN(msgBuf,
-                   ACE_CDR::Octet[msgBufSize],
-                   0);
-
-    // read the buffer
-    if ((dataModeStream->recv_n(msgBuf, msgBufSize, 0, &bt)) == -1)
-      ACE_ERROR_RETURN((LM_ERROR,
-                        "%p\n",
-                        "recv_n"),
-                       0);
-
-    // clean up the allocated buffer
-    delete[] msgBuf;
-
-    // SEND A REPLY TO THE CLIENT
-
-    // send back a 2 byte reply
-    ACE_CDR::Short reply;
-    if ((dataModeStream->send_n(&reply, ACE_CDR::SHORT_SIZE, 0, &bt)) == -1)
-      ACE_ERROR_RETURN((LM_ERROR,
-                        "%p\n",
-                        "send_n"),
-                       0);
-
-  } while (--numIterations);
-
-  // close and destroy the stream
-  dataModeStream->close();
-  delete dataModeStream;
-
-  return NULL;
-}
-
-// sets up the dataModeSocket Stream, reads the test header infomation
-// and launches a thread to handle the requested test.
-static void run_server (ACE_HANDLE handle)
-{
-  ACE_INET_Addr cli_addr;
-  // create a new stream and initialized with the handle returned by
-  // accept
-  ACE_SOCK_Stream * dataModeStream = new ACE_SOCK_Stream;
-  dataModeStream->set_handle (handle);
-
-  // Make sure we're not in non-blocking mode.
-  if (dataModeStream->disable (ACE_NONBLOCK) == -1){
-    ACE_ERROR ((LM_ERROR,
-                "%p\n",
-                "disable"));
-    return;
-  }
-  else if (dataModeStream->get_remote_addr (cli_addr) == -1){
-    ACE_ERROR ((LM_ERROR,
-                "%p\n",
-                "get_remote_addr"));
-    return;
-  }
-
-  // explicity configure Nagling. Default is
-  // Options_Manager::test_enable_nagle=0 so default configurations is
-  // NO NAGLING
-  ACE_CDR::Long nagle;
-  if (Options_Manager::test_enable_nagle)
-    nagle=0;
-  else
-    nagle=1;
-
-  if (Options_Manager::test_transport_protocol == IPPROTO_SCTP){
-    // default - sctp case
-    if (-1 == dataModeStream->set_option(IPPROTO_SCTP, SCTP_NODELAY, &nagle, sizeof nagle)){
-      ACE_ERROR((LM_ERROR,
-                 "%p\n",
-                 "set_option"));
-      return;
-    }
-  } else {
-    // tcp case
-    if (-1 == dataModeStream->set_option(IPPROTO_TCP, TCP_NODELAY, &nagle, sizeof nagle)){
-      ACE_ERROR ((LM_ERROR,
-                  "%p\n",
-                  "set_option"));
-      return;
-    }
-  }
-
-  ACE_DEBUG ((LM_DEBUG,
-              "(%P|%t) client %s connected from %d\n",
-              cli_addr.get_host_name (),
-              cli_addr.get_port_number ()));
-
-  // hdr bufSize is hardcoded to 8 bytes
-  // (4 for a CDR-encoded boolean and 4 for a CDR-encoded ULong)
-  ACE_CDR::ULong hdrBufSize = 8;
-  // allocate a raw buffer large enough to receive the header and be
-  // properly aligned for the CDR decoding.
-  ACE_CDR::Char * hdrBuf= new ACE_CDR::Char[hdrBufSize+ACE_CDR::MAX_ALIGNMENT];
-  // align the raw buffer before reading data into it.
-  char * hdrBuf_a = ACE_ptr_align_binary(hdrBuf, ACE_CDR::MAX_ALIGNMENT);
-
-  size_t bt;
-  // read the header
-  if ((dataModeStream->recv_n(hdrBuf_a, hdrBufSize, 0, &bt)) == -1){
-    ACE_ERROR ((LM_ERROR,
-                "%p\n",
-                "recv_n"));
-    return;
-  }
-
-  // pass the CDR encoded data into an ACE_InputCDR class. hdrCDR does
-  // NOT copy this data. Nor does it delete. It assumes the buffer
-  // remains valid while it is in scope.
-  ACE_InputCDR hdrCDR(hdrBuf_a, hdrBufSize);
-
-  ACE_CDR::Boolean byteOrder;
-  ACE_CDR::ULong numIterations;
-
-  // extract the data
-  hdrCDR >> ACE_InputCDR::to_boolean (byteOrder);
-  hdrCDR.reset_byte_order(byteOrder);
-  hdrCDR >> numIterations;
-
-  // make sure the stream is good after the extractions
-  if (!hdrCDR.good_bit()){
-    ACE_ERROR((LM_ERROR,
-               "%p\n",
-               "hdrCDR"));
-
-    return;
-  }
-
-  ACE_DEBUG ((LM_DEBUG,
-              "(%P|%t) Test for %u iterations\n",
-              numIterations));
-
-  // deallocate the header buffer
-  delete[] hdrBuf;
-
-  // bundle up the arguments
-  ArgStruct * args = new ArgStruct;
-  args->stream = dataModeStream;
-  args->numIters = numIterations;
-
-#if defined (ACE_HAS_THREADS)
-  // Spawn a new thread and run the new connection in that thread of
-  // control using the <server> function as the entry point.
-  if (ACE_Thread_Manager::instance ()->spawn (unmarshalledOctetServer,
-                                              ACE_reinterpret_cast(void *,args),
-                                              THR_DETACHED) == -1)
-    ACE_ERROR ((LM_ERROR,
-                "(%P|%t) %p\n",
-                "spawn"));
-#else
-  (*unmarshalledOctetServer) (ACE_reinterpret_cast(void *, args));
-#endif /* ACE_HAS_THREADS */
-
-}
-
-int main(int argc, char **argv){
-
-  Options_Manager optsMgr(argc, argv, "server-opts");
-
-  // show usage is requested
-  if (optsMgr._usage) {
-    optsMgr._show_usage(cerr, "server-opts");
-    return 1;
-  }
-
-  // If SCTP is not installed then terminate the program, unless TCP
-  // was specified.
-#ifndef ACE_HAS_SCTP
-  if (optsMgr.test_transport_protocol == IPPROTO_SCTP)
-    ACE_ERROR_RETURN((LM_ERROR,
-                      "SCTP was NOT installed when this binary was compiled.\n"
-                      "SOCK_STREAM_srv may still be run using TCP "
-                      "via the '-t tcp' option.\n"),
-                     1);
-#endif
-
-  // check that valid options were specified
-  if (optsMgr._error) {
-    cerr << "ERROR: " << optsMgr._error_message << endl;
-    return 1;
-  }
-
-  // this is the socket that the server will listen on
-  ACE_SOCK_Acceptor acceptor_socket;
-
-  // Create the address that we want to listen for connections on. If
-  // server_accept_addr=INADDR_ANY (the default), SCTP will listen for
-  // connections on all IP interfaces. If an address is specified,
-  // SCTP will listen for connections on that address ONLY.
-  ACE_INET_Addr serverAddr(optsMgr.server_port,
-                           optsMgr.server_accept_addr);
-
-  ACE_DEBUG((LM_DEBUG,
-             "(%P|%t) Accepting connections on port %u on interface %s using %s\n",
-             serverAddr.get_port_number(),
-             (optsMgr.server_accept_addr == INADDR_ANY) ? "INADDR_ANY" : serverAddr.get_host_addr(),
-             (optsMgr.test_transport_protocol == IPPROTO_SCTP) ? "IPPROTO_SCTP" : "IPPROTO_TCP"));
-
-  // this operation creates a socket, binds the specified internet
-  // address to it and calls listen. As this is a wrapper facade
-  // approach, the ACE_OS::{socket,bind,listen} calls are invoked in
-  // the implementation of open.
-  if (acceptor_socket.open(serverAddr, 1,
-                           AF_INET,
-                           ACE_DEFAULT_BACKLOG,
-                           optsMgr.test_transport_protocol) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR,
-                       "%p\n",
-                       "open"),
-                      1);
-
-  // this function checks that the port that was actually bound was
-  // the port we asked for. Apparently some operating systems will
-  // automatically select new ports if the specified port is currently
-  // used.
-  else if (acceptor_socket.get_local_addr(serverAddr) == -1)
-    ACE_ERROR_RETURN ((LM_ERROR,
-                       "%p\n",
-                       "get_local_addr"),
-                      1);
-
-  ACE_DEBUG ((LM_DEBUG,
-              "(%P|%t) starting server at port %d\n",
-              serverAddr.get_port_number()));
-
-  // this is the stream object that will associated with a completed
-  // connection (aka the data mode socket). It will be set when accept
-  // is called below.
-  ACE_SOCK_Stream new_stream;
-
-  // a file decriptor set
-  ACE_Handle_Set handle_set;
-  // add the acceptor socket to the file descriptor set.
-  handle_set.set_bit(acceptor_socket.get_handle());
-
-  for (;;){
-
-    ACE_Time_Value timeout(ACE_DEFAULT_TIMEOUT);
-    ACE_Handle_Set temp = handle_set;
-
-    // wait for connect() call from client. In the original test there
-    // were two different acceptor sockets for two different
-    // services. So select was needed to wait on both sockets
-    // simultaneously. In this test we could just call accept on the
-    // one socket.
-    int result = ACE_OS::select((int) (acceptor_socket.get_handle()) +1,
-                                (fd_set *) temp,
-                                0,
-                                0,
-                                timeout);
-
-    // check that select did not end with an error.
-    if (result == -1)
-      ACE_ERROR ((LM_ERROR,
-                  "(%P|%t) %p\n",
-                  "select"));
-    // check to see if select timed out.
-    else if (result == 0){
-      ACE_DEBUG ((LM_DEBUG,
-                  "(%P|%t) select timed out\n"));
-
-    }
-    else { // case where a file descriptor was actually set
-      if (!(temp.is_set(acceptor_socket.get_handle()))){
-        // CANNOT BE REACHED
-        ACE_ERROR ((LM_ERROR,
-                    "(%P|%t) %p\n",
-                    "select: NO ERROR BUT NO FD SET"));
-      } else {
-        // call accept to set up the new stream.
-        if (acceptor_socket.accept(new_stream) == -1) {
-          ACE_ERROR ((LM_ERROR,
-                      "%p\n",
-                      "accept"));
-          continue;
-        }
-        else{
-          ACE_DEBUG ((LM_DEBUG,
-                      "(%P|%t) spawning server\n"));
-
-        }
-        // Run the server.
-        run_server (new_stream.get_handle ());
-      }
-
-    }
-
-  }
-  return 0;
-}
diff --git a/performance-tests/SCTP/THANKS b/performance-tests/SCTP/THANKS
deleted file mode 100644
index eb646d9dae1..00000000000
--- a/performance-tests/SCTP/THANKS
+++ /dev/null
@@ -1,30 +0,0 @@
-Lockheed Martin Advanced Technology Laboratories (LM ATL) development
-of the SCIOP pluggable protocol for TAO was funded under DARPA/IXO's
-Program Composition for Embedded Systems (PCES) program.
-
-The LM ATL PCES project leads, Patrick Lardieri and Gautam Thaker,
-thank the following individuals for their contributions to the
-development TAO's SCIOP pluggable protocol.
-
-Jason Cohen         LM ATL
-Edward Mulholland   LM ATL
-Keith O'Hara        LM ATL
-Chuck Winters       LM ATL
-
-We also thank Mr. Brian Bidulock of OpenSS7 (www.openss7.org) for his
-rapid development of a fully functional Linux implementation of SCTP
-which made this work possible.
-
-We also thank the following individuals for their valuable review and
-critiques of our SCIOP designs and for the expert advice on the more
-arcane and subtle aspects of ACE and TAO.
-
-Dr. Chris Gill            DOC Group
-Balachandran Natarajan    DOC Group
-
-Dr. Douglas Schmidt       DARPA/IXO, DOC Group
-
-Steve Houston             OCI
-
-
-
diff --git a/performance-tests/SCTP/hist.cpp b/performance-tests/SCTP/hist.cpp
deleted file mode 100644
index 81197b7939e..00000000000
--- a/performance-tests/SCTP/hist.cpp
+++ /dev/null
@@ -1,303 +0,0 @@
-// $Id$
-
-/* Replacement for CSIM histogram created by Alex Carobus 7/20/98
-   #include <std/disclaimer.h>
-   */
-/*
-//
-// Update history:
-//
-// [99.10.18] jcohen
-//   version 1.3
-//   added optional fields to header
-//   to use: add_field("key","value",histogram);
-//       or: add_field_n("key",45,histogram);
-//
-// [99.01.08] jcohen
-//   version 1.2
-//   histogram includes skew and kurtosis
-//   call enable_skew(h) to enable skew and kurtosis on histogram h
-//
-// [98.07.29] jcohen
-//   added add_histogram function
-//   added version 1.1 display, added num_bins display
-//   added read_hist
-//
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <float.h>
-#include <string.h>
-#include "ace/os_include/os_math.h"
-#include "hist.h"
-
-hist_t *head_hist, *tail_hist;
-
-hist_t *histogram(char *name, unsigned int num_bins, double first,
-                  double last) {
-  hist_t *hist;
-  if ((hist = (hist_t *)malloc(sizeof(hist_t))) == NULL) {
-    fprintf(stderr, "unable to allocate memory for histogram : %s", name);
-    exit(-1);
-  }
-  if ((hist->hs = (unsigned int *)malloc(sizeof(unsigned int) * (num_bins+2))) == NULL){
-    fprintf(stderr, "unable to allocate memory for histogram : %s", name);
-    exit(-1);
-  }
-  memset(hist->hs, 0, sizeof(unsigned int) * (num_bins+2));
-  hist->name = name;
-  hist->num_bins = num_bins;
-  hist->first = first;
-  hist->last = last;
-  hist->num_points = 0;
-  hist->max_num_outer = hist->num_outer = 0;
-  hist->sum = 0.0;
-  hist->sum2 = 0.0;
-  hist->sum3 = 0.0;
-  hist->sum4 = 0.0;
-  hist->max = DBL_MIN;
-  hist->min = DBL_MAX;
-  hist->outer = NULL;
-  hist->next = NULL;
-  hist->skew = 0;
-  hist->firstoptheader = NULL;
-  if(head_hist == NULL)
-    head_hist = tail_hist = hist;
-  else {
-    tail_hist->next = hist;
-    tail_hist = tail_hist->next;
-  }
-  return hist;
-}
-
-
-void set_outer(unsigned int max_num_outer, hist_t *hist) {
-  hist->outer = (double *)realloc(hist->outer,sizeof(double) * max_num_outer);
-  hist->max_num_outer = max_num_outer;
-}
-
-
-void enable_skew(hist_t *hist) {
-  hist->skew = 1;
-}
-
-
-void add_field(char *key, char *value, hist_t *hist) {
-  struct optheader *nextoptheader, *trace;
-
-     /* create and prepare nextoptheader */
-  nextoptheader = (struct optheader *) malloc(sizeof(struct optheader));
-  nextoptheader->key = (char *) malloc(strlen(key)+1);
-  nextoptheader->value = (char *) malloc(strlen(value)+1);
-  nextoptheader->next = NULL;
-  strcpy(nextoptheader->key,key);
-  strcpy(nextoptheader->value,value);
-
-     /* tack nextoptheader onto end of optheader list */
-  if (hist->firstoptheader == NULL) {
-     hist->firstoptheader = nextoptheader;
-  } else {
-     trace = hist->firstoptheader;
-     while (trace->next != NULL) {
-        trace = trace->next;
-     }
-     trace->next = nextoptheader;
-  }
-}
-
-
-void add_field_n(char *key, int value, hist_t *hist) {
-  char textvalue[40];
-
-  sprintf(textvalue,"%d",value);
-  add_field(key,textvalue,hist);
-}
-
-
-void record(double point, hist_t *hist) {
-  unsigned int bin;
-  double incsum;
-  if (point < hist->min) hist->min = point;
-  if (point > hist->max) hist->max = point;
-  if (point < hist->first) {
-    bin = 0;
-    if (hist->max_num_outer > hist->num_outer)
-      hist->outer[hist->num_outer++] = point;
-  }
-  else if (point >= hist->last) {
-    bin = hist->num_bins+1;
-    if (hist->max_num_outer > hist->num_outer)
-      hist->outer[hist->num_outer++] = point;
-  }
-  else
-    bin = (unsigned int)(((point - hist->first)*(hist->num_bins))/(hist->last - hist->first)+1);
-
-  hist->hs[bin]++;
-  hist->num_points++;
-  hist->sum+=point;
-  incsum = point*point;
-  hist->sum2 += incsum;
-  if (hist->skew) {
-    incsum *= point;
-    hist->sum3 += incsum;
-    incsum *= point;
-    hist->sum4 += incsum;
-  }
-
-/*  printf("point : %g, bin %u, points in bin %u\n", point, bin, hist->hs[bin]); */
-}
-
-void report_to(FILE *strm, hist_t *hist) {
-  unsigned int sofar, i;
-  double p1, p2, d, mean;
-  double variance;
-  struct optheader *trace;
-
-  if (hist->num_points == 0) {
-    fprintf(strm, "\n\n\t\t\t\tHistogram %s is empty\n\n", hist->name);
-    return;
-  }
-  fprintf(strm, "\n\n\t\t\t\tHistogram %s\n", hist->name);
-  if (hist->skew) fprintf(strm, "version: %s\n", HIST_VERSION);
-  else fprintf(strm, "version: 1.1\n");
-  fprintf(strm, "minimum: %g\n", hist->min);
-  fprintf(strm, "maximum: %g\n", hist->max);
-  fprintf(strm, "mean: %g\n", mean = hist->sum/hist->num_points);
-  variance = (hist->sum2 -
-          2*hist->sum*mean +
-          hist->num_points*mean*mean) / (hist->num_points-1);
-  fprintf(strm, "variance: %g\n", variance);
-  if (hist->skew) {
-    fprintf(strm, "skew: %g\n", ((hist->sum3 -
-          3*hist->sum2*mean +
-          3*hist->sum*mean*mean -
-          hist->num_points*mean*mean*mean) /
-          pow(sqrt(variance),3) / hist->num_points));
-    fprintf(strm, "kurtosis: %g\n", ((hist->sum4 -
-          4*hist->sum3*mean +
-          6*hist->sum2*mean*mean -
-          4*hist->sum*mean*mean*mean +
-          hist->num_points*mean*mean*mean*mean) /
-          pow(sqrt(variance),4)) / hist->num_points - 3);
-  }
-  fprintf(strm, "num_points: %u\n", hist->num_points);
-  fprintf(strm, "num_bins: %d %g %g\n", hist->num_bins,hist->first,hist->last);
-  if (hist->firstoptheader) {
-     trace = hist->firstoptheader;
-     while(trace->next != NULL) {
-        fprintf(strm, "%s: %s\n", trace->key, trace->value);
-        trace = trace->next;
-     }
-     fprintf(strm, "%s: %s\n", trace->key, trace->value);
-  }
-  fprintf(strm, "\n");
-  sofar = hist->hs[0];
-  fprintf(strm, "\t      Low     -          High     Count  Fraction  Cumulative\n");
-  fprintf(strm, "\t     below    -  %12.3f  :  %5u    %0.3f    %0.3f\n", hist->first,
-          hist->hs[0], (double)hist->hs[0]/hist->num_points,
-          (double)histfloor(1000.0*sofar/hist->num_points)/1000.0);
-  p2 = hist->first;
-  d = (hist->last - hist->first)/hist->num_bins;
-  for(i = 1; i <= hist->num_bins; i++) {
-    p1 = p2;
-    p2 = i*d+hist->first;
-    sofar += hist->hs[i];
-    fprintf(strm, "\t%12.3f  -  %12.3f  :  %5u    %0.3f    %0.3f\n", p1, p2, hist->hs[i],
-            (double)hist->hs[i]/hist->num_points,
-            (double)histfloor(1000.0*sofar/hist->num_points)/1000.0);
-  }
-  sofar += hist->hs[hist->num_bins+1];
-  fprintf(strm, "\t%12.3f  -       above    :  %5u    %0.3f    %0.3f\n\n",
-          hist->last, hist->hs[hist->num_bins+1],
-          (double)hist->hs[hist->num_bins+1]/hist->num_points,
-          (double)histfloor(1000.0*sofar/hist->num_points)/1000.0);
-  if (hist->num_outer) {
-    fprintf(strm, "outliers:\n");
-    for(i = 0; i < hist->num_outer; i++) fprintf(strm, "\t%12.3f\n",
-                                            hist->outer[i]);
-  }
-  fprintf(strm, "\n\n");
-}
-
-void report() {
-  hist_t *temp = head_hist;
-  for(; temp; temp = temp->next)
-    report_to(stdout, temp);
-}
-
-void stats_init() {
-  /* this is not necessary */
-}
-
-double get_mean(HIST hist) {
-  return(hist->sum/hist->num_points);
-}
-
-double get_min(HIST hist) {
-  return(hist->min);
-}
-
-double get_max(HIST hist) {
-  return(hist->max);
-}
-
-double get_variance(HIST hist) {
-  double mean = hist->sum/hist->num_points;
-  return((hist->sum2 - 2*hist->sum*mean + hist->num_points*mean*mean)/
-    (hist->num_points-1));
-}
-
-double get_num(HIST hist) {
-  return(hist->num_points);
-}
-
-void set_mean(HIST hist, double mean) {
-  hist->sum = mean*hist->num_points;
-}
-
-void set_min(HIST hist, double min) {
- hist->min = min;
-}
-
-void set_max(HIST hist, double max) {
-  hist->max = max;
-}
-
-void set_variance(HIST hist, double variance) {
-  /* do this after seting mean */
-  double mean = hist->sum/hist->num_points;
-  hist->sum2 = variance *(hist->num_points-1) + 2*hist->sum*mean - hist->num_points*mean*mean;
-}
-
-void add_histogram(HIST dest, HIST source) {
-  unsigned int i,j;
-  double d,midpoint;
-
-   d = (source->last - source->first)/source->num_bins;
-
-   for(i=1;i<=source->num_bins;i++) {
-      midpoint = source->first + ((i - 0.5) * d);
-      for(j=0;j<source->hs[i];j++) {
-         record(midpoint,dest);
-      }
-   }
-
-   for(i=0;i<source->num_outer;i++)
-      record(source->outer[i],dest);
-
-   set_min(dest, get_min(source));
-   set_max(dest, get_max(source));
-   set_mean(dest, get_mean(source));
-   set_variance(dest, get_variance(source));
-}
-
-double histfloor(double x) {
-
-#ifdef WIN32
-  return floor(x);
-#else
-  return((long long)x);
-#endif
-
-}
diff --git a/performance-tests/SCTP/hist.h b/performance-tests/SCTP/hist.h
deleted file mode 100644
index 46999d39182..00000000000
--- a/performance-tests/SCTP/hist.h
+++ /dev/null
@@ -1,68 +0,0 @@
-// $Id$
-
-#include <stdio.h>
-
-#define HIST_VERSION  "1.3"
-
-
-struct optheader {
-  char *key;
-  char *value;
-  struct optheader *next;
-};
-
-typedef struct hist_s {
-  char *name;
-  double max, min, sum, sum2, sum3, sum4;
-  double first, last;
-  unsigned int num_points, num_bins;
-  unsigned int *hs;
-  unsigned int num_outer, max_num_outer;
-  double *outer;
-  struct hist_s *next;
-  int skew;
-  struct optheader *firstoptheader;
-} hist_t;
-
-#define HIST hist_t *
-
-hist_t *histogram(char *name, unsigned int num_bins, double first,
-                  double last);
-
-void set_outer(unsigned int max_num_outer, hist_t *hist);
-
-void enable_skew(hist_t *hist);
-
-void add_field(char *key, char *value, hist_t *hist);
-
-void add_field_n(char *key, int value, hist_t *hist);
-
-void record(double point, hist_t *hist);
-
-void report_to(FILE *strm, hist_t *hist);
-
-void report();
-
-void stats_init();
-
-double get_mean(HIST hist);
-
-double get_min(HIST hist);
-
-double get_max(HIST hist);
-
-double get_variance(HIST hist);
-
-double get_num(HIST hist);
-
-void set_mean(HIST hist, double mean);
-
-void set_min(HIST hist, double min);
-
-void set_max(HIST hist, double max);
-
-void set_variance(HIST hist, double variance);
-
-void add_histogram(HIST dest, HIST source);
-
-double histfloor(double x);
diff --git a/performance-tests/SCTP/run_spectrum.config b/performance-tests/SCTP/run_spectrum.config
deleted file mode 100644
index cb2beb17f5e..00000000000
--- a/performance-tests/SCTP/run_spectrum.config
+++ /dev/null
@@ -1,12 +0,0 @@
-#
-# $Id$
-#
-# This is the default configuration file for run_spectrum.pl.
-# Configuration options given in this file will be passed to
-# SOCK_STREAM_clt or SOCK_SEQPACK_clt.
-#
-# Note that the configuration options are defined as "the first
-# double-quote string that is not to the right of a pound sign."
-# (Double-quotes and pound signs cannot be escaped).
-
-"-c 1000"
diff --git a/performance-tests/SCTP/run_spectrum.pl b/performance-tests/SCTP/run_spectrum.pl
deleted file mode 100755
index d6ec34e6075..00000000000
--- a/performance-tests/SCTP/run_spectrum.pl
+++ /dev/null
@@ -1,260 +0,0 @@
-eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
-    & eval 'exec perl -S $0 $argv:q'
-    if 0;
-
-# $Id$
-
-use warnings;
-use strict;
-
-use lib '../../bin';
-use PerlACE::Run_Test;
-use Getopt::Long;
-use Pod::Usage;
-
-#### Program Documentation ####
-
-=head1 NAME
-
-run_spectrum.pl - Run a spectrum of performance tests.
-
-=head1 SYNOPSIS
-
- run_spectrum.pl [ --help ]
-                 [ --manual ]
-                 [ --service (STREAM|SEQPACK) ]
-                 [ --protocol (TCP|SCTP) ]
-                 [ --config_file filename ]
-
-=head1 OPTIONS
-
-=over 8
-
-=item B<--help, -h>
-
-Print this help message and exit.
-
-=item B<--manual, -m>
-
-Print full documentation and exit.
-
-=item B<--service, -s> (STREAM|SEQPACK)
-
-Select SOCK_STREAM or SOCK_SEQPACK service respectively.  The default
-is SOCK_STREAM.
-
-=item B<--protocol, -p> (TCP|SCTP)
-
-Select TCP or SCTP transport protocol.  The default is TCP.  Note that
-TCP cannot be used together with the SEQPACK service.
-
-=item B<--config_file, -c> filename
-
-Read configuration parameters from the nominated file.  By default,
-parameters are read from C<run_spectrum.config> in the current
-directory.
-
-=back
-
-=head1 DESCRIPTION
-
-This directory contains performance tests for measuring round-trip
-latency statistics of ACE synchronous messaging using unmarshalled
-ACE_CDR::Octet.
-
-The SOCK_STREAM performance test comprises SOCK_STREAM_clt on the
-client side and SOCK_STREAM_srv on the server side.  The SOCK_SEQPACK
-performance test comprises SOCK_SEQPACK_clt on the client side and
-SOCK_SEQPACK_srv on the server side.
-
-People who are interested in round-trip latency often want to see a
-I<spectrum> of statistics for a range of payload sizes.  The job of
-this script, B<run_spectrum.pl>, is to run the client-side
-performance-test program repeatedly, so as to generate a spectrum of
-statistics.
-
-The script supports two types of services (SOCK_STREAM and
-SOCK_SEQPACK) and two protocols (TCP and UDP).  All combinations are
-valid except TCP over SOCK_SEQPACK.  Please see L<"OPTIONS"> for
-information about the command-line options that specify the service
-and the protocol.
-
-By default, B<run_spectrum.pl> will execute SOCK_STREAM_clt (or
-SOCK_SEQPACK_clt) with a minimal set of command-line options.  You can
-specify additional options in an external configuration file.  By
-default, the configuration file is called C<run_spectrum.config>.  You
-may name an alternate configuration file using the B<--config_file>
-option.
-
-The configuration file should contain the options that you would
-ordinarly give to SOCK_STREAM_clt or SOCK_SEQPACK_clt on the command
-line.  To see the command-line options available for these programs,
-please run C<SOCK_STREAM_clt --help> or C<SOCK_SEQPACK_clt --help>.
-Note that the options B<-s> and B<-t> are used by this script when it
-launches the client.  An occurrence of either of these options in the
-configuration file will be ignored as redundant.
-
-The client is executed 15 times: once for each payload size from 2^2
-bytes to 2^16 bytes.  (SCTP tests only go up to 2^15 bytes because of
-limitations in our SCTP implementation.)  Histograms summarizing the
-round-trip latency performance are dumped to a file called
-C<TIMESTAMP.spectrum> where C<TIMESTAMP> is the current time in
-hyphen-delimited form.
-
-=head1 EXAMPLES
-
-B<Example 1>: Run a spectrum of TCP performance tests using
-SOCK_STREAM with both endpoints on the local machine.  Each test in
-the spectrum should have 10,000 data points.
-
-=over 4
-
-=item 1.
-
-Start the SOCK_STREAM server on the local machine with the S<C<-t
-tcp>> option:
-
-    % ./SOCK_STREAM_srv -t tcp
-
-=item 2.
-
-Configure the client to run 10,000 individual trials:
-
-    % echo '"-c 10000"' > run_spectrum.config
-
-=item 3.
-
-Execute B<run_spectrum.pl>:
-
-    % ./run_spectrum.pl
-
-(The script uses TCP and SOCK_STREAM by default.)
-
-=back
-
-B<Example 2>: Run a spectrum of SCTP performance tests using
-SOCK_SEQPACK with one endpoint on the local machine and one endpoint
-on a remote machine that happens to be named oneida.  Each test in the
-spectrum should have 50,000 data points.
-
-=over 4
-
-=item 1.
-
-On the remote host oneida, start the SOCK_SEQPACK server:
-
-    % ./SOCK_SEQPACK_srv
-
-=item 2.
-
-On the local host, configure the client to run 50,000 individual
-trials and to look for the server on oneida:
-
-    % echo '"-c 50000 -H oneida"' > run_spectrum.config
-
-=item 3.
-
-On the local host, execute B<run_spectrum.pl>:
-
-    % ./run_spectrum.pl --service SEQPACK --protocol SCTP
-
-=back
-
-=cut
-
-# Global variable declarations
-my $help        = 0;
-my $manual      = 0;
-my $service     = "stream";
-my $protocol    = "tcp";
-my $config_file = "run_spectrum.config";
-my $options     = "";
-my $output_file;
-
-# Map from services to client programs
-my %client_programs = (stream  => "SOCK_STREAM_clt",
-                       seqpack => "SOCK_SEQPACK_clt");
-
-#### MAIN PROGRAM ####
-
-# Canonicalize arguments to lower-case
-tr/A-Z/a-z/ for @ARGV;
-
-# Use Getopt::Long to parse options
-GetOptions ("help" => \$help,
-            "manual" => \$manual,
-            "service=s" => \$service,
-            "protocol=s" => \$protocol,
-            "config_file=s" => \$config_file
-            );
-
-# Show help if requested
-pod2usage(1) if $help;
-
-# Show manual if requested
-pod2usage(-verbose => 2) if $manual;
-
-# Validate service option
-$service =~ s/seqpacket/seqpack/;    # Accept "seqpacket" as synonym for "seqpack"
-$service =~ /^(stream|seqpack)$/
-    or pod2usage("Service must be STREAM or SEQPACK\n");
-
-$protocol =~ /^(tcp|sctp)$/
-    or pod2usage("Protocol must be TCP or SCTP\n");
-
-$service eq "seqpack" and $protocol eq "tcp"
-    and pod2usage("Cannot use SEQPACK service with TCP\n");
-
-# Open config file
-open CONFIG, "< $config_file"
-    or die "cannot open file: $config_file\n";
-
-# Read options from the config file.  The options are defined as the
-# first double-quoted string that is not to the right of a pound sign.
-# (Pound signs and quotes cannot be escaped.)
-
-while (<CONFIG>) {
-    chomp;
-    if (/^[^\#]*?\"(.*?)\"/) {
-        $options = $1;
-        last;
-    }
-}
-
-# Close config file
-close CONFIG;
-
-# Print options
-print "Read options from $config_file: \"$options\"\n\n";
-
-# Name a unique file to store the results in.
-($output_file = localtime() . ".spectrum") =~ tr/ /-/;
-
-# Run the test for message sizes ranging from 2^2 bytes to 2^16 bytes
-# (SCTP tests only go up to 2^15 bytes because of limitations in our
-#  SCTP implementation)
-my $max_size = 16;
-$max_size = 15 if $protocol eq "sctp";
-for (my $i = 2; $i <= $max_size; ++$i) {
-
-    # Assemble client parameters and print out the command line
-    my $client_params = "-t $protocol -s $i $options >> $output_file";
-    print "$client_programs{$service} $client_params\n";
-
-    # Configure client
-    my $client =
-        new PerlACE::Process($client_programs{$service}, $client_params);
-
-    # Spawn client
-    $client->Spawn();
-
-    # Wait for client to finish
-    $client->Wait();
-
-    # Remind the client that it's finished running
-    $client->{RUNNING} = 0;
-
-    # Sleep for a while
-    sleep 5;
-}
-
diff --git a/performance-tests/SCTP/sample-spectrum.png b/performance-tests/SCTP/sample-spectrum.png
deleted file mode 100644
index d6fc94f205b..00000000000
--- a/performance-tests/SCTP/sample-spectrum.png
+++ /dev/null
diff --git a/performance-tests/Server_Concurrency/Latency_Stats.h b/performance-tests/Server_Concurrency/Latency_Stats.h
deleted file mode 100644
index d0cec975627..00000000000
--- a/performance-tests/Server_Concurrency/Latency_Stats.h
+++ /dev/null
@@ -1,217 +0,0 @@
-// $Id$
-
-class Latency_Stats
-{
-public:
-  Latency_Stats (void);
-
-  void dump_results (const ACE_TCHAR* test_name,
-                     const ACE_TCHAR* sub_test);
-
-  void sample (ACE_hrtime_t sample);
-
-  void accumulate (const Latency_Stats& stats);
-  // Useful to merge several Latency_Stats.
-
-private:
-  u_long n_;
-  ACE_hrtime_t sum_;
-  ACE_hrtime_t sum2_;
-  ACE_hrtime_t min_;
-  ACE_hrtime_t max_;
-};
-
-inline
-Latency_Stats::Latency_Stats (void)
-  :  n_ (0),
-     sum_ (0),
-     sum2_ (0),
-     min_ (0),
-     max_ (0)
-{
-}
-
-inline void
-Latency_Stats::sample (ACE_hrtime_t sample)
-{
-  this->sum_  += sample;
-#ifndef ACE_LACKS_LONGLONG_T
-  this->sum2_ += sample * sample;
-#else
-  // possible loss of precision here due to lack of 64bit support
-  this->sum2_ += sample * sample.lo();
-#endif
-  if (this->n_ == 0)
-    {
-      this->min_ = sample;
-      this->max_ = sample;
-    }
-  if (this->min_ > sample)
-    this->min_ = sample;
-  if (this->max_ < sample)
-    this->max_ = sample;
-  this->n_++;
-}
-
-inline void
-Latency_Stats::dump_results (const ACE_TCHAR *test_name,
-                             const ACE_TCHAR *sub_test)
-{
-  if (this->n_ < 1)
-    return;
-
-  ACE_hrtime_t avg = this->sum_ / this->n_;
-#ifndef ACE_LACKS_LONGLONG_T
-  ACE_hrtime_t dev =
-    this->sum2_ / this->n_ - avg*avg;
-#else
-  ACE_hrtime_t dev =
-    this->sum2_ / this->n_ - avg.lo()*avg.lo();
-#endif
-  ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor ();
-
-  double min_usec = ACE_CU64_TO_CU32 (this->min_) / gsf;
-  double max_usec = ACE_CU64_TO_CU32 (this->max_) / gsf;
-  double avg_usec = ACE_CU64_TO_CU32 (avg) / gsf;
-  double dev_usec = ACE_CU64_TO_CU32 (dev) / (gsf * gsf);
-  ACE_DEBUG ((LM_DEBUG,
-              "%s/%s: %.2f/%.2f/%.2f/%.2f (min/avg/max/var^2) [usecs]\n",
-              test_name, sub_test,
-              min_usec, avg_usec, max_usec, dev_usec));
-}
-
-inline void
-Latency_Stats::accumulate (const Latency_Stats& rhs)
-{
-  if (rhs.n_ == 0)
-    return;
-
-  if (this->n_ == 0)
-    {
-      this->n_    = rhs.n_;
-      this->min_  = rhs.min_;
-      this->max_  = rhs.max_;
-      this->sum_  = rhs.sum_;
-      this->sum2_ = rhs.sum2_;
-      return;
-    }
-
-  if (this->min_ > rhs.min_)
-    this->min_ = rhs.min_;
-  if (this->max_ < rhs.max_)
-    this->max_ = rhs.max_;
-
-  this->sum_  += rhs.sum_;
-  this->sum2_ += rhs.sum2_;
-  this->n_    += rhs.n_;
-}
-
-class Throughput_Stats
-{
-public:
-  Throughput_Stats (void);
-
-  void dump_results (const ACE_TCHAR* test_name,
-                     const ACE_TCHAR* sub_test);
-
-  void sample (void);
-  // An event has been received
-
-  void accumulate (const Throughput_Stats& stats);
-  // Useful to merge several Throughput_Stats.
-
-private:
-  u_long n_;
-  ACE_hrtime_t start_;
-  ACE_hrtime_t stop_;
-};
-
-inline void
-Throughput_Stats::accumulate (const Throughput_Stats& rhs)
-{
-  if (rhs.n_ == 0)
-    return;
-
-  if (this->n_ == 0)
-    {
-      this->start_ = rhs.start_;
-      this->stop_ = rhs.stop_;
-      this->n_ = rhs.n_;
-      return;
-    }
-
-  if (this->start_ > rhs.start_)
-    this->start_ = rhs.start_;
-
-  if (this->stop_ < rhs.stop_)
-    this->stop_ = rhs.stop_;
-
-  this->n_ += rhs.n_;
-}
-
-inline void
-Throughput_Stats::dump_results (const ACE_TCHAR *test_name,
-                                const ACE_TCHAR *subtest)
-{
-  if (this->n_ == 0)
-    {
-      ACE_DEBUG ((LM_DEBUG,
-                  "%s/%s: no events recorded\n",
-                  test_name, subtest));
-      return;
-    }
-
-  ACE_Time_Value tv;
-  ACE_High_Res_Timer::hrtime_to_tv (tv, this->stop_ - this->start_);
-
-  double f = 1.0/(tv.sec () + tv.usec () / 1000000.0);
-  double events_per_second = this->n_ * f;
-
-  ACE_DEBUG ((LM_DEBUG,
-              "%s/%s: "
-              "%d / %d.%06.6d = %.3f events/second\n",
-              test_name, subtest,
-              this->n_,
-              tv.sec (), tv.usec (),
-              events_per_second));
-}
-
-inline
-Throughput_Stats::Throughput_Stats (void)
-  : n_ (0)
-{
-}
-
-inline void
-Throughput_Stats::sample (void)
-{
-  if (this->n_ == 0)
-    {
-      this->start_ = ACE_OS::gethrtime ();
-    }
-  this->n_++;
-  this->stop_ = ACE_OS::gethrtime ();
-}
-
-inline void
-move_to_rt_class (void)
-{
-  // Enable FIFO scheduling, e.g., RT scheduling class on Solaris.
-  int priority =
-    (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
-     + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
-
-  int result = ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO,
-                                                       priority,
-                                                       ACE_SCOPE_PROCESS));
-  if (result == 0)
-    {
-      result = ACE_OS::thr_setprio (priority);
-    }
-
-  if (result != 0)
-    {
-      ACE_DEBUG ((LM_DEBUG,
-                  "Cannot move program to realtime class.\n"));
-    }
-}
diff --git a/performance-tests/Server_Concurrency/Leader_Follower/RT_CORBA_Leader_Follower.cpp b/performance-tests/Server_Concurrency/Leader_Follower/RT_CORBA_Leader_Follower.cpp
deleted file mode 100644
index 9ac4bcd71f7..00000000000
--- a/performance-tests/Server_Concurrency/Leader_Follower/RT_CORBA_Leader_Follower.cpp
+++ /dev/null
@@ -1,404 +0,0 @@
-// $Id$
-
-#include "RT_CORBA_Leader_Follower.h"
-
-
-
-#if defined (ACE_HAS_THREADS)
-
-// We need the following only if we have threads enabled..
-#include "ace/OS_main.h"
-#include "ace/ACE.h"
-#include "ace/Get_Opt.h"
-#include "ace/High_Res_Timer.h"
-#include "ace/Sched_Params.h"
-#include "ace/Profile_Timer.h"
-
-// Number of messages that are used in this experiment
-static size_t number_of_messages = 1000;
-
-// Number of messages that are used in this experiment
-static size_t number_of_messages_left = 0;
-
-// Number of threads used in this experiment
-static size_t number_of_threads = 2;
-
-// Global variable for the availability of the leader
-static size_t leader_available = 0;
-
-// Number of threads that are ready to go/dispatch
-static size_t ready_threads = 0;
-
-// Work in the upcall
-static size_t message_size = 100;
-
-// Debugging condition
-static DEBUGGING_RANGE debug = DEBUG_NONE;
-
-// Timer for the test
-ACE_High_Res_Timer test_timer;
-
-
-
-
-/*******************************************************************/
-// Constructor for Synchronisers
-Synchronisers::Synchronisers (void)
-  : mutex_ (),
-    condition_ (mutex_),
-    event_ ()
-{
-}
-
-
-int
-Synchronisers::start_synchronization (void)
-{
-  // Hold the lock and increment the global variable to indicate
-  // number of ready threads
-  {
-    ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1);
-
-    ready_threads ++;
-
-    if (debug)
-      {
-        ACE_DEBUG ((LM_DEBUG,
-                    "(%P|%t) Ready to go.. \n"));
-      }
-
-    if (ready_threads == number_of_threads)
-      {
-
-        // Reset the ready_threads so that we can wait at the end of
-        // runs
-        ready_threads = 0;
-
-        // Start the timer
-        test_timer.start ();
-
-        // Signal all the threads
-        this->event_.signal ();
-
-        // return to do our work;
-        return 0;
-      }
-
-    // If we are not the last thread, let go off the lock
-  }
-
-  // Wait blisfully till we are woken up
-  this->event_.wait ();
-
-  return 0;
-}
-
-int
-Synchronisers::end_synchronization (void)
-{
-  // Hold the lock and increment the global variable to indicate
-  // number of ready threads
-  {
-    ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1);
-
-    ready_threads ++;
-
-    if (debug)
-      {
-        ACE_DEBUG ((LM_DEBUG,
-                    "(%P|%t) Ready to go.. \n"));
-      }
-
-    if (ready_threads == number_of_threads)
-      {
-
-        // Reset the ready_threads so that we can wait at the end of
-        // runs
-        ready_threads = 0;
-
-        // Start the timer
-        test_timer.stop ();
-
-        // Signal all the threads
-        this->event_.signal ();
-
-        // return to do our work;
-        return 0;
-      }
-
-    // If we are not the last thread, let go off the lock
-  }
-
-  // Wait blisfully till we are woken up
-  this->event_.wait ();
-
-  return 0;
-}
-
-
-/*******************************************************************/
-
-Leader_Follower_Task::Leader_Follower_Task (Synchronisers &synch)
-  : messages_consumed_ (0),
-    synch_ (synch)
-{
-}
-
-int
-Leader_Follower_Task::processed (void)
-{
-  return this->messages_consumed_;
-}
-
-int
-Leader_Follower_Task::svc (void)
-{
-  (void) this->synch_.start_synchronization ();
-
-  for (;;)
-    {
-      {
-        ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->synch_.mutex_, -1);
-
-        // Wait until there is no leader.
-        while (leader_available)
-          {
-            int result = this->synch_.condition_.wait ();
-            if (result == -1)
-              {
-                ACE_ERROR_RETURN ((LM_ERROR,
-                                   "Leader_Follower_Task::svc (%t) -> %p\n",
-                                   "wait error"),
-                                  -1);
-              }
-          }
-
-        // I am the leader.
-        leader_available = 1;
-
-        //
-        // We are letting go of the leader follower lock before going
-        // in the event loop.
-        //
-      }
-
-      //
-      // It is ok to modify these shared variables without a lock
-      // since we are the only leader.
-      //
-
-      int exit_loop = 0;
-      if (number_of_messages_left == 0)
-        {
-          exit_loop = 1;
-        }
-      else
-        {
-          --number_of_messages_left;
-
-          // Local counter.
-          ++this->messages_consumed_;
-
-          if (debug)
-            {
-              ACE_DEBUG ((LM_DEBUG,
-                          "(%t) message for this thread %d\n",
-                          this->messages_consumed_));
-            }
-        }
-
-      {
-        ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->synch_.mutex_, -1);
-
-        // I am no longer the leader.
-        leader_available = 0;
-
-        // Wake up a follower.
-        this->synch_.condition_.signal ();
-      }
-
-      if (exit_loop)
-        {
-          break;
-        }
-      else
-        {
-          //
-          // Process message here.
-          //
-          for (size_t j = 0; j < message_size; ++j)
-            {
-              // Eat a little CPU
-              /* takes about 40.2 usecs on a 167 MHz Ultra2 */
-              u_long n = 11UL;
-              ACE::is_prime (n, 2, n / 2);
-            }
-
-        }
-    }
-
-  (void) this->synch_.end_synchronization ();
-
-  return 0;
-}
-
-static int
-parse_args (int argc, ACE_TCHAR *argv[])
-{
-  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("m:t:d:s:"));
-  int c;
-
-  while ((c = get_opt ()) != -1)
-    {
-      switch (c)
-        {
-        case 'm':
-          number_of_messages = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        case 't':
-          number_of_threads = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        case 'd':
-          debug = ACE_static_cast (DEBUGGING_RANGE, ACE_OS::atoi (get_opt.opt_arg ()));
-          break;
-        case 's':
-          message_size = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        default:
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "usage: %s\n"
-                             "\t[-m number of messages]\n"
-                             "\t[-s message size]\n"
-                             "\t[-w number of threads]\n"
-                             "\t[-b burst size]\n"
-                             "\t[-t timeout between bursts]\n"
-                             "\t[-d debug]\n",
-                             argv[0]),
-                            -1);
-        }
-    }
-
-  return 0;
-}
-
-/*******************************************************************/
-
-// Entry point
-
-int
-ACE_TMAIN (int argc, ACE_TCHAR *argv[])
-{
-  int result = parse_args (argc, argv);
-  if (result != 0)
-    {
-      return result;
-    }
-
-  Synchronisers synch_forms;
-
-  ACE_High_Res_Timer::calibrate ();
-
-  // Leader Followers.
-  Leader_Follower_Task **leader_followers = 0;
-  ACE_NEW_RETURN (leader_followers,
-                  Leader_Follower_Task *[number_of_threads],
-                  -1);
-
-
-
-
-  int priority =
-    ACE_Sched_Params::priority_max (ACE_SCHED_FIFO);
-
-
-  long flags = THR_SCOPE_PROCESS;
-
-  // Number of messages left = Number_Of_messages
-  number_of_messages_left = number_of_messages;
-
-  size_t i = 0;
-  // Create and activate them.
-  for (i = 0; i < number_of_threads; ++i)
-    {
-      ACE_NEW_RETURN (leader_followers[i],
-                      Leader_Follower_Task (synch_forms),
-                      -1);
-
-      // Activate the leader_followers.
-      result = leader_followers[i]->activate (flags,
-                                              1,
-                                              1,
-                                              priority);
-      if (result != 0)
-        {
-          ACE_DEBUG ((LM_DEBUG,
-                      "(%P|%t) - Activate failed  for RT class "
-                      " - Using default priority for thread [%d]\n",
-                      i));
-
-          flags = THR_BOUND;
-          priority = ACE_Sched_Params::priority_min (ACE_SCHED_OTHER,
-                                                     ACE_SCOPE_THREAD);
-
-          // Activate the leader_followers.
-          result = leader_followers[i]->activate (flags,
-                                                  1,
-                                                  1,
-                                                  priority);
-
-          if (result != 0)
-            {
-              ACE_DEBUG ((LM_DEBUG,
-                          "(%P|%t) - Failed again no hope \n"));
-
-              return 0;
-            }
-
-        }
-    }
-
-  // Wait for all threads to terminate.
-  result = ACE_Thread_Manager::instance ()->wait ();
-
-  ACE_hrtime_t elapsed_time = 0;
-
-  test_timer.elapsed_time (elapsed_time);
-
-  double elapsed_time_per_invocation =
-    ACE_UINT64_DBLCAST_ADAPTER (elapsed_time / number_of_messages);
-
-  /*ACE_DEBUG ((LM_DEBUG,
-              "(%P|%t) Throughput is [%f] \n",
-              elapsed_time_per_invocation));*/
-
-  ACE_DEBUG ((LM_DEBUG,
-              "(%P|%t) Throughput is [%f] \n",
-              1000000000/ elapsed_time_per_invocation));
-
-
-  for (i = 0; i < number_of_threads; ++i)
-    {
-      ACE_DEBUG ((LM_DEBUG,
-                  "Message consumed in thread [%d] is [%d] \n",
-                  i, leader_followers[i]->processed ()));
-      delete leader_followers[i];
-    }
-  delete[] leader_followers;
-
-  return result;
-}
-
-
-
-
-#else /*if defined (ACE_HAS_THREADS)*/
-
-int
-main (int , char *[])
-{
-  ACE_DEBUG ((LM_DEBUG,
-              "(%p|%t) Cannot run in SIngle threaded mode \n"));
-
-  return 0;
-}
-#endif /*ACE_HAS_THREADS*/
diff --git a/performance-tests/Server_Concurrency/Leader_Follower/RT_CORBA_Leader_Follower.h b/performance-tests/Server_Concurrency/Leader_Follower/RT_CORBA_Leader_Follower.h
deleted file mode 100644
index 4664bd3cda8..00000000000
--- a/performance-tests/Server_Concurrency/Leader_Follower/RT_CORBA_Leader_Follower.h
+++ /dev/null
@@ -1,109 +0,0 @@
-//=============================================================================
-/**
- *  @file    RT_CORBA_Leader_Follower.h
- *
- *  $Id$
- *
- *   The leader follower test modified to suit RTCORBA tests. The
- *   original  leader follower test has too many things that doesnt
- *   get what we are looking for (read it as just confusing enough)
- *   . Hence a new test.
- *
- *  @author Balachandran Natarajan <bala@cs.wustl.edu>
- */
-//=============================================================================
-#ifndef PERF_TEST_RT_CORBA_LEADER_FOLLOWER_H
-#define PERF_TEST_RT_CORBA_LEADER_FOLLOWER_H
-#include /**/ "ace/pre.h"
-#include "ace/Task.h"
-
-
-#if !defined (ACE_LACKS_PRAGMA_ONCE)
-# pragma once
-#endif /* ACE_LACKS_PRAGMA_ONCE */
-
-#if defined (ACE_HAS_THREADS)
-
-#include "ace/Manual_Event.h"
-
-enum DEBUGGING_RANGE
-{
-  DEBUG_NONE = 0,
-  DEBUG
-};
-
-
-/**
- * @class Synchronisers
- *
- * @brief This class provides all the synchrnoisers used in this
- *  test.
- *
- *
- */
-
-/// Forward declaration..
-class Leader_Follower_Task;
-
-class Synchronisers
-{
-public:
-  friend class Leader_Follower_Task;
-
-  /// Ctor
-  Synchronisers (void);
-
-  int  start_synchronization (void);
-  int  end_synchronization (void);
-
-private:
-
-  /// The mutex and condition variable that is used for
-  /// synchronisation.
-  ACE_SYNCH_MUTEX mutex_;
-
-  ACE_SYNCH_CONDITION condition_;
-
-  /// A manual event
-  ACE_Manual_Event event_;
-};
-
-
-/**
- * @class Leader_Follower_Task
- *
- * @brief This class provide the interface and an implementation to
- *  simulate how the LF pattern in the ORB would behave.
- *
- *
- *  Basically all threads ready to do an upcall would wait on a token
- *  or lock. The thread that gets the token before it gets ready to do
- *  the upcall would wake up a thread waiting on the token.
- *
- */
-
-class Leader_Follower_Task : public ACE_Task_Base
-{
-public:
-
-  /// Ctor with a mutex and a condition variable
-  Leader_Follower_Task (Synchronisers &synch);
-
-  /// Messages consumed
-  int processed (void);
-
-  /// Method that is run by a daemon thread
-  int svc (void);
-
-private:
-  /// Number of messages processed by this thread
-  int messages_consumed_;
-
-  /// Our reference to the synchroniser
-  Synchronisers &synch_;
-};
-
-#endif /*ACE_HAS_THREADS*/
-
-#include /**/ "ace/post.h"
-#endif /*PERF_TEST_RT_CORBA_LEADER_FOLLOWER*/
diff --git a/performance-tests/Server_Concurrency/Leader_Follower/Svr_Conc_Leader_Follower.mpc b/performance-tests/Server_Concurrency/Leader_Follower/Svr_Conc_Leader_Follower.mpc
deleted file mode 100644
index 18b9e28febf..00000000000
--- a/performance-tests/Server_Concurrency/Leader_Follower/Svr_Conc_Leader_Follower.mpc
+++ /dev/null
@@ -1,14 +0,0 @@
-// -*- MPC -*-
-// $Id$
-
-project : aceexe {
-  source_files {
-    leader_follower.cpp
-  }
-}
-
-project(*RT_CORBA) : aceexe {
-  source_files {
-    RT_CORBA_Leader_Follower.cpp
-  }
-}
\ No newline at end of file
diff --git a/performance-tests/Server_Concurrency/Leader_Follower/leader_follower.cpp b/performance-tests/Server_Concurrency/Leader_Follower/leader_follower.cpp
deleted file mode 100644
index 66b17c0e43d..00000000000
--- a/performance-tests/Server_Concurrency/Leader_Follower/leader_follower.cpp
+++ /dev/null
@@ -1,333 +0,0 @@
-// $Id$
-
-#include "ace/OS_main.h"
-#include "ace/OS_NS_unistd.h"
-#include "ace/ACE.h"
-#include "ace/Task_T.h"
-#include "ace/Get_Opt.h"
-#include "ace/High_Res_Timer.h"
-#include "ace/Sched_Params.h"
-#include "ace/Profile_Timer.h"
-#include "../Latency_Stats.h"
-
-static size_t number_of_messages = 100;
-static size_t message_size = 100;
-static size_t number_of_threads = 10;
-static size_t burst_size = 10;
-static size_t timeout_between_bursts = 1;
-
-static size_t leader_available = 0;
-static size_t messages_in_this_burst = 0;
-static size_t total_messages_consumed = 0;
-static size_t burst = 1;
-
-static ACE_hrtime_t start_of_burst;
-
-enum DEBUGGING_RANGE
-{
-  DEBUG_NONE = 0,
-  DEFAULT = 1,
-  PRINT_INDIVIDUAL_LATENCY = 2
-};
-
-static DEBUGGING_RANGE debug = DEBUG_NONE;
-
-typedef ACE_Task<ACE_SYNCH> TASK;
-
-class Leader_Follower_Task : public TASK
-{
-public:
-  Leader_Follower_Task (ACE_SYNCH_MUTEX &mutex,
-                        ACE_SYNCH_CONDITION &condition);
-  int svc (void);
-
-  size_t messages_consumed_;
-  ACE_SYNCH_MUTEX &mutex_;
-  ACE_SYNCH_CONDITION &condition_;
-
-  Latency_Stats latency_stats_;
-  Throughput_Stats throughput_stats_;
-};
-
-Leader_Follower_Task::Leader_Follower_Task (ACE_SYNCH_MUTEX &mutex,
-                                            ACE_SYNCH_CONDITION &condition)
-  : messages_consumed_ (0),
-    mutex_ (mutex),
-    condition_ (condition)
-{
-}
-
-int
-Leader_Follower_Task::svc (void)
-{
-  for (;;)
-    {
-      {
-        ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1);
-
-        // Wait until there is no leader.
-        while (leader_available)
-          {
-            int result = this->condition_.wait ();
-            if (result == -1)
-              {
-                ACE_ERROR_RETURN ((LM_ERROR,
-                                   "Leader_Follower_Task::svc (%t) -> %p\n",
-                                   "wait error"),
-                                  -1);
-              }
-          }
-
-        // I am the leader.
-        leader_available = 1;
-
-        //
-        // We are letting go of the leader follower lock before going
-        // in the event loop.
-        //
-      }
-
-      //
-      // It is ok to modify these shared variables without a lock
-      // since we are the only leader.
-      //
-
-      int exit_loop = 0;
-      if (number_of_messages == 0)
-        {
-          exit_loop = 1;
-        }
-      else
-        {
-          if (messages_in_this_burst == burst_size)
-            {
-              ++burst;
-              messages_in_this_burst = 0;
-              ACE_Time_Value tv (0, timeout_between_bursts);
-              ACE_OS::sleep (tv);
-            }
-
-          if (messages_in_this_burst == 0)
-            {
-              start_of_burst = ACE_OS::gethrtime ();
-            }
-
-          --number_of_messages;
-
-          // Burst counter.
-          ++messages_in_this_burst;
-
-          // Global counter.
-          ++total_messages_consumed;
-
-          // Local counter.
-          ++this->messages_consumed_;
-
-          if (debug)
-            {
-              ACE_DEBUG ((LM_DEBUG,
-                          "(%t) burst %d: message %d; overall message %d; message for this thread %d\n",
-                          burst,
-                          messages_in_this_burst,
-                          total_messages_consumed,
-                          this->messages_consumed_));
-            }
-        }
-
-      {
-        ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1);
-
-        // I am no longer the leader.
-        leader_available = 0;
-
-        // Wake up a follower.
-        this->condition_.signal ();
-      }
-
-      if (exit_loop)
-        {
-          break;
-        }
-      else
-        {
-          //
-          // Process message here.
-          //
-
-          for (size_t j = 0; j < message_size; ++j)
-            {
-              // Eat a little CPU
-              /* takes about 40.2 usecs on a 167 MHz Ultra2 */
-              u_long n = 11UL;
-              ACE::is_prime (n, 2, n / 2);
-            }
-
-          //
-          // Record stats for this message.
-          //
-          ACE_hrtime_t latency_from_start_of_burst =
-            ACE_OS::gethrtime () - start_of_burst;
-          this->latency_stats_.sample (latency_from_start_of_burst);
-
-          this->throughput_stats_.sample ();
-
-          if (debug >= PRINT_INDIVIDUAL_LATENCY)
-            {
-#ifndef ACE_LACKS_LONGLONG_T
-              ACE_DEBUG ((LM_DEBUG,
-                          "(%t) latency from start of burst: %Q\n",
-                          latency_from_start_of_burst));
-#else
-              ACE_DEBUG ((LM_DEBUG,
-                          "(%t) latency from start of burst: %u\n",
-                          latency_from_start_of_burst.lo()));
-#endif
-            }
-        }
-    }
-
-  return 0;
-}
-
-static int
-parse_args (int argc, ACE_TCHAR *argv[])
-{
-  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("m:s:w:b:t:d:"));
-  int c;
-
-  while ((c = get_opt ()) != -1)
-    {
-      switch (c)
-        {
-        case 'm':
-          number_of_messages = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        case 's':
-          message_size = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        case 'w':
-          number_of_threads = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        case 'b':
-          burst_size = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        case 't':
-          timeout_between_bursts = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        case 'd':
-          debug = ACE_static_cast (DEBUGGING_RANGE, ACE_OS::atoi (get_opt.opt_arg ()));
-          break;
-        default:
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "usage: %s\n"
-                             "\t[-m number of messages]\n"
-                             "\t[-s message size]\n"
-                             "\t[-w number of threads]\n"
-                             "\t[-b burst size]\n"
-                             "\t[-t timeout between bursts]\n"
-                             "\t[-d debug]\n",
-                             argv[0]),
-                            -1);
-        }
-    }
-
-  return 0;
-}
-
-int
-ACE_TMAIN (int argc, ACE_TCHAR *argv[])
-{
-  int result = parse_args (argc, argv);
-  if (result != 0)
-    {
-      return result;
-    }
-
-  move_to_rt_class ();
-  ACE_High_Res_Timer::calibrate ();
-
-  ACE_SYNCH_MUTEX mutex;
-  ACE_SYNCH_CONDITION condition (mutex);
-
-  // Leader Followers.
-  Leader_Follower_Task **leader_followers = 0;
-  ACE_NEW_RETURN (leader_followers,
-                  Leader_Follower_Task *[number_of_threads],
-                  -1);
-
-  ACE_Profile_Timer timer;
-  timer.start ();
-
-  int priority =
-    (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) +
-     ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
-
-  long flags = THR_BOUND | THR_SCHED_FIFO;
-
-  // Create and activate them.
-  size_t i;
-  for (i = 0; i < number_of_threads; ++i)
-    {
-      ACE_NEW_RETURN (leader_followers[i],
-                      Leader_Follower_Task (mutex,
-                                            condition),
-                      -1);
-
-      // Activate the leader_followers.
-      result = leader_followers[i]->activate (flags,
-                                              1,
-                                              1,
-                                              priority);
-      if (result != 0)
-        {
-          flags = THR_BOUND;
-          priority = ACE_Sched_Params::priority_min (ACE_SCHED_OTHER,
-                                                     ACE_SCOPE_THREAD);
-          result = leader_followers[i]->activate (flags,
-                                                  1,
-                                                  1,
-                                                  priority);
-          if (result != 0)
-            {
-              return result;
-            }
-        }
-    }
-
-  // Wait for all threads to terminate.
-  result = ACE_Thread_Manager::instance ()->wait ();
-
-  timer.stop ();
-  ACE_Rusage rusage;
-  timer.elapsed_rusage (rusage);
-
-  Latency_Stats latency;
-  Throughput_Stats throughput;
-  for (i = 0; i < number_of_threads; ++i)
-    {
-      latency.accumulate (leader_followers[i]->latency_stats_);
-      throughput.accumulate (leader_followers[i]->throughput_stats_);
-      ACE_DEBUG ((LM_DEBUG, "Thread[%d]: ", i));
-      leader_followers[i]->throughput_stats_.dump_results (ACE_TEXT(""), ACE_TEXT(""));
-    }
-
-  ACE_DEBUG ((LM_DEBUG, "\nTotals for latency:\n"));
-  latency.dump_results (argv[0], ACE_TEXT("latency"));
-
-  ACE_DEBUG ((LM_DEBUG, "\nTotals for throughput:\n"));
-  throughput.dump_results (argv[0], ACE_TEXT("throughput"));
-
-#if defined(ACE_HAS_PRUSAGE_T)
-  ACE_DEBUG ((LM_DEBUG, "\n(%t) Context switches %d/%d\n",
-              rusage.pr_vctx,
-              rusage.pr_ictx));
-#endif /* ACE_HAS_PRUSAGE_T */
-
-  for (i = 0; i < number_of_threads; ++i)
-    {
-      delete leader_followers[i];
-    }
-  delete[] leader_followers;
-
-  return result;
-}
diff --git a/performance-tests/Server_Concurrency/Queue_Based_Workers/RT_CORBA_Workers.cpp b/performance-tests/Server_Concurrency/Queue_Based_Workers/RT_CORBA_Workers.cpp
deleted file mode 100644
index 2a22d18b385..00000000000
--- a/performance-tests/Server_Concurrency/Queue_Based_Workers/RT_CORBA_Workers.cpp
+++ /dev/null
@@ -1,601 +0,0 @@
-// $Id$
-#include "RT_CORBA_Workers.h"
-
-#if defined (ACE_HAS_THREADS)
-
-#include "ace/OS_main.h"
-#include "ace/ACE.h"
-#include "ace/Get_Opt.h"
-#include "ace/High_Res_Timer.h"
-#include "ace/Sched_Params.h"
-#include "ace/Lock_Adapter_T.h"
-
-// The number of messages that is being processed
-static size_t number_of_messages = 100;
-
-// The number of upcall threads
-static size_t number_of_workers = 2;
-
-// The size of the message
-static size_t message_size = 100;
-
-// Number of threads that are ready to go
-static size_t ready_threads = 0;
-
-// Number of input and output threads
-static size_t io_threads = 2; // 1 for output and 1 for input
-
-// High resolution test timer
-static ACE_High_Res_Timer test_timer;
-
-// Debugging condition
-static DEBUGGING_RANGE debug = DEBUG_NONE;
-
-// Data block used by the message blocks
-ACE_Data_Block *data_block = 0;
-
-/*******************************************************************/
-// Constructor for Synchronisers
-Synchronisers::Synchronisers (void)
-  : mutex_ (),
-    event_ ()
-{
-}
-
-
-int
-Synchronisers::start_synchronization (void)
-{
-  // Hold the lock and increment the global variable to indicate
-  // number of ready threads
-  {
-    ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1);
-
-    ready_threads ++;
-
-    if (ready_threads == (number_of_workers + io_threads))
-      {
-        // Reset the ready_threads so that we can wait at the end of
-        // runs
-        ready_threads = 0;
-
-        if (debug)
-          {
-            ACE_DEBUG ((LM_DEBUG,
-                        "(%P|%t) Ready to signal start \n"));
-          }
-        // Start the timer
-        test_timer.start ();
-
-        // Signal all the threads
-        this->event_.signal ();
-
-        // return to do our work;
-        return 0;
-      }
-
-    // If we are not the last thread, let go off the lock
-  }
-
-  if (debug)
-    {
-      ACE_DEBUG ((LM_DEBUG,
-                  "(%P|%t) Ready to wait () on event.. \n"));
-    }
-
-  // Wait blisfully till we are woken up
-  this->event_.wait ();
-
-  return 0;
-}
-
-int
-Synchronisers::end_synchronization (void)
-{
-  // Hold the lock and increment the global variable to indicate
-  // number of ready threads
-  {
-    ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1);
-
-    ready_threads ++;
-
-    if (ready_threads == (number_of_workers + io_threads))
-      {
-        // Reset the ready_threads so that we can wait at the end of
-        // runs
-        ready_threads = 0;
-
-        // Start the timer
-        test_timer.stop ();
-
-        // Signal all the threads
-        this->event_.signal ();
-
-        if (debug)
-          {
-            ACE_DEBUG ((LM_DEBUG,
-                        "(%P|%t) Ended peacefully \n"));
-          }
-
-        // return to do our work;
-        return 0;
-      }
-
-
-    // If we are not the last thread, let go off the lock
-  }
-
-  if (debug)
-    {
-      ACE_DEBUG ((LM_DEBUG,
-                  "(%P|%t) Going to wait .. \n"));
-    }
-
-  // Wait blisfully till we are woken up
-  this->event_.wait ();
-
-  return 0;
-}
-
-/*******************************************************************/
-
-Worker_Task::Worker_Task (Message_Queue *mq,
-                          Synchronisers &synch)
-  : ACE_Task<ACE_MT_SYNCH> (0, mq),
-  synch_ (synch),
-  messages_processed_ (0)
-{
-}
-
-int
-Worker_Task::svc (void)
-{
-  // Start synchronization
-  (void) this->synch_.start_synchronization ();
-
-  for (;;)
-    {
-      ACE_Message_Block *mb = 0;
-      int result = this->getq (mb);
-      if (result == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "Worker_Task::svc (%t) -> %p\n",
-                             "getq error"),
-                            -1);
-        }
-
-      // Get the flag in the message blok
-      ACE_Message_Block::Message_Flags flag =
-        mb->self_flags ();
-
-      // The stop flag
-      int stop_flag = 0;
-
-      // Check for the stop flag
-      if (ACE_BIT_ENABLED (flag,
-                           Synchronisers::MB_STOP_FLAG))
-        {
-          if (debug)
-            {
-              ACE_DEBUG ((LM_DEBUG,
-                          "(%P|%t) saw flag after [%d] messages\n",
-                          this->messages_processed_));
-            }
-
-          stop_flag = 1;
-        }
-      // Release the message block
-      mb->release ();
-
-      // Counter.
-      ++this->messages_processed_;
-
-      if (debug)
-        {
-          ACE_DEBUG ((LM_DEBUG,
-                      "(%P|%t) dequeued my %d message\n",
-                      this->messages_processed_));
-        }
-
-      //
-      // Process message here.
-      //
-
-      for (size_t j = 0; j < message_size; ++j)
-        {
-          // Eat a little CPU
-          /* takes about 40.2 usecs on a 167 MHz Ultra2 */
-          u_long n = 11UL;
-          ACE::is_prime (n, 2, n / 2);
-        }
-
-      // Make a message block for writing onto output queue
-      ACE_Message_Block *message_block = 0;
-      ACE_NEW_RETURN (message_block,
-                      ACE_Message_Block (data_block),
-                      -1);
-
-      // Put this message block into the next queue or the output
-      // queue
-      result = this->put_next (message_block);
-
-      if (result == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "Input::svc (%t) -> %p\n",
-                             "putq error"),
-                            -1);
-                            }
-
-      // If the stop_flag is set just break and wait..
-      if (stop_flag)
-        {
-          if (debug)
-            ACE_DEBUG ((LM_DEBUG,
-                        "(%P|%t) Got stop message after [%d] messages \n",
-                        this->messages_processed_));
-
-          break;
-        }
-    }
-
-  (void) this->synch_.end_synchronization ();
-  return 0;
-}
-
-int
-Worker_Task::processed (void)
-{
-  return this->messages_processed_;
-}
-
-/*******************************************************************/
-
-Input_Task::Input_Task (Message_Queue *mq,
-                        Synchronisers &synch)
-  : ACE_Task<ACE_MT_SYNCH> (0, mq),
-    synch_ (synch)
-{
-}
-
-int
-Input_Task::svc (void)
-{
-  // Synchronise threads
-  (void) this->synch_.start_synchronization ();
-
-
-  size_t i = 0;
-  for (i = 0;
-       i < (number_of_messages - number_of_workers);
-       ++i)
-    {
-      // Make a message block
-      ACE_Message_Block *message_block = 0;
-      ACE_NEW_RETURN (message_block,
-                      ACE_Message_Block (data_block),
-                      -1);
-
-      int result = this->putq (message_block);
-
-      if (result == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "Input::svc (%t) -> %p\n",
-                             "putq error"),
-                            -1);
-        }
-
-      if (debug)
-        {
-          ACE_DEBUG ((LM_DEBUG,
-                      "(%t) Input thread ->  Sent [%d] messages\n",
-                      i));
-        }
-    }
-
-  if (debug)
-    {
-      ACE_DEBUG ((LM_DEBUG,
-                  "(%t) Sending close messages \n"));
-    }
-
-
-  // Stop messages
-  for (i = 0;
-       i < number_of_workers;
-       ++i)
-    {
-      // Make a message block
-      ACE_Message_Block *message_block = 0;
-      ACE_NEW_RETURN (message_block,
-                      ACE_Message_Block (data_block),
-                      -1);
-
-      // Set the stop flag in the message block and not in the datablock
-      message_block->set_self_flags (Synchronisers::MB_STOP_FLAG);
-
-      int result = this->putq (message_block);
-
-      if (result == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "Input::svc (%t) -> %p\n",
-                             "putq error"),
-                            -1);
-        }
-    }
-
-
-  (void) this->synch_.end_synchronization ();
-  return 0;
-}
-
-/*******************************************************************/
-
-Output_Task::Output_Task (Message_Queue *mq,
-                          Synchronisers &synch)
-  : ACE_Task<ACE_MT_SYNCH> (0, mq),
-    synch_ (synch)
-{
-}
-
-int
-Output_Task::svc (void)
-{
-  // Synchronise threads
-  (void) this->synch_.start_synchronization ();
-
-
-  for (size_t i = 0;
-       i < number_of_messages;
-       ++i)
-    {
-      // Get the message block from queue
-      ACE_Message_Block *mb = 0;
-      int result = this->getq (mb);
-
-      // delete the message block
-      mb->release ();
-
-      if (debug)
-        {
-          ACE_DEBUG ((LM_DEBUG,
-                      "(%t) Output thread ->  received [%d] message\n",
-                      i));
-                      }
-
-      if (result == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "Input::svc (%t) -> %p\n",
-                             "putq error"),
-                            -1);
-        }
-    }
-
-  (void) this->synch_.end_synchronization ();
-  return 0;
-}
-
-int
-Output_Task::put (ACE_Message_Block *mb, ACE_Time_Value *)
-{
-  /*  if (debug)
-    {
-      ACE_DEBUG ((LM_DEBUG,
-                  "(%P|%t) Sticking message into "
-                  " output queue \n"));
-                  }*/
-  return this->putq (mb);
-}
-
-/*******************************************************************/
-
-static int
-parse_args (int argc, ACE_TCHAR *argv[])
-{
-  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("m:s:t:d:"));
-  int c;
-
-  while ((c = get_opt ()) != -1)
-    {
-      switch (c)
-        {
-        case 'm':
-          number_of_messages = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        case 't':
-          number_of_workers = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        case 'd':
-          debug = ACE_static_cast (DEBUGGING_RANGE, ACE_OS::atoi (get_opt.opt_arg ()));
-          break;
-        case 's':
-          message_size = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        default:
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "usage: %s\n"
-                             "\t[-m number of messages]\n"
-                             "\t[-s message size]\n"
-                             "\t[-w number of workers]\n"
-                             "\t[-b burst size]\n"
-                             "\t[-t timeout between bursts]\n"
-                             "\t[-d debug]\n",
-                             argv[0]),
-                            -1);
-        }
-    }
-
-  return 0;
-}
-
-
-/*******************************************************************/
-int
-ACE_TMAIN (int argc, ACE_TCHAR *argv[])
-{
-  int result = parse_args (argc, argv);
-  if (result != 0)
-    {
-      return result;
-    }
-
-  ACE_High_Res_Timer::calibrate ();
-
-  // Create the message queue
-  Message_Queue input_message_queue;
-  Message_Queue output_message_queue;
-
-  // Create the datablocks. IF we use the default Message Blocks Ctor,
-  // it is going to do an extra allocation for the data block
-  ACE_NEW_RETURN (data_block,
-                  ACE_Locked_Data_Block<ACE_Lock_Adapter<ACE_SYNCH_MUTEX> >,
-                  -1);
-
-  // Increment the reference count so that we can share the
-  // datablock. This is donw twice the number of messages for the
-  // input and output queues.
-  size_t i = 0;
-
-  for (i = 0; i < 2*number_of_messages; ++i)
-    {
-      data_block->duplicate ();
-    }
-
-  // Create the Synchronisers
-  Synchronisers synch;
-
-  // Workers.
-  Worker_Task **workers = 0;
-  ACE_NEW_RETURN (workers,
-                  Worker_Task *[number_of_workers],
-                  -1);
-
-  // Input Task
-  Input_Task input_task (&input_message_queue,
-                         synch);
-
-  // Output Task
-  Output_Task output_task (&output_message_queue,
-                           synch);
-  int priority =
-    ACE_Sched_Params::priority_max (ACE_SCHED_FIFO);
-
-
-  long flags = THR_SCHED_FIFO | THR_SCOPE_PROCESS;
-
-  // Create and activate the worker threads
-  for (i = 0; i < number_of_workers; ++i)
-    {
-      ACE_NEW_RETURN (workers[i],
-                      Worker_Task (&input_message_queue, synch),
-                      -1);
-
-      workers[i]->next (&output_task);
-
-      // Activate the workers.
-      result = workers[i]->activate (flags,
-                                     1,
-                                     1,
-                                     priority);
-      if (result != 0)
-        {
-          flags = THR_BOUND;
-          priority = ACE_Sched_Params::priority_min (ACE_SCHED_OTHER,
-                                                     ACE_SCOPE_THREAD);
-          result = workers[i]->activate (flags,
-                                         1,
-                                         1,
-                                         priority);
-          if (result != 0)
-            {
-              return result;
-            }
-        }
-    }
-
-
-
-  // Activate the input and output threads
-  result = input_task.activate (flags,
-                                1,
-                                1,
-                                priority);
-
-  if (result != 0)
-    return result;
-
-
-
-  // Activate the workers.
-  result = output_task.activate (flags,
-                                 1,
-                                 1,
-                                 priority);
-
-  if (result != 0)
-    return result;
-
-
-
-  // Wait for all threads to terminate.
-  result = ACE_Thread_Manager::instance ()->wait ();
-
-
-  ACE_hrtime_t elapsed_time = 0;
-
-  test_timer.elapsed_time (elapsed_time);
-
-# if !defined (ACE_WIN32)
-  double elapsed_time_per_invocation =
-    (double) elapsed_time / number_of_messages;
-
-  ACE_DEBUG ((LM_DEBUG,
-     "(%P|%t) Throughput is [%f] \n",
-     elapsed_time_per_invocation)); 
-
-  ACE_DEBUG ((LM_DEBUG,
-              "(%P|%t) Throughput is [%f] \n",
-              1000000000/ elapsed_time_per_invocation));
-
-#endif /*ACE_WIN32 */
-  for (i = 0; i < number_of_workers; ++i)
-    {
-      ACE_DEBUG ((LM_DEBUG,
-                  "Message process for thread [%d] is [%d] \n",
-                  i, workers[i]->processed ()));
-      delete workers[i];
-    }
-  delete[] workers;
-
-  return result;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-
-template class ACE_Locked_Data_Block<ACE_Lock_Adapter<ACE_SYNCH_MUTEX> >;
-template class ACE_Lock_Adapter<ACE_SYNCH_MUTEX>;
-
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-
-#pragma instantiate ACE_Locked_Data_Block<ACE_Lock_Adapter<ACE_SYNCH_MUTEX> >
-#pragma instantiate ACE_Lock_Adapter<ACE_SYNCH_MUTEX>
-
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-#else /*ACE_HAS_THREADS*/
-
-int
-main (int, char *[])
-{
-  ACE_DEBUG ((LM_DEBUG,
-              "(%P|%t) Not supported in single threaded builds \n"));
-
-  return 0;
-}
-
-
-#endif /*ACE_HAS_THREADS*/
diff --git a/performance-tests/Server_Concurrency/Queue_Based_Workers/RT_CORBA_Workers.h b/performance-tests/Server_Concurrency/Queue_Based_Workers/RT_CORBA_Workers.h
deleted file mode 100644
index 46d78e8624c..00000000000
--- a/performance-tests/Server_Concurrency/Queue_Based_Workers/RT_CORBA_Workers.h
+++ /dev/null
@@ -1,166 +0,0 @@
-/* -*- C++ -*- */
-//=============================================================================
-/**
- *  @file    RT_CORBA_Workers.h
- *
- *  $Id$
- *
- *   The Workes test modified to suit RTCORBA tests. The  original
- *   Workers has too many things that doesnt get what we are looking
- *   for (read it as just confusing enough). Hence a new test.
- *
- *  @author Balachandran Natarajan <bala@cs.wustl.edu>
- */
-//=============================================================================
-#ifndef PERF_TEST_RT_CORBA_WORKERS_H
-#define PERF_TEST_RT_CORBA_WORKERS_H
-#include /**/ "ace/pre.h"
-
-#include "ace/Task_T.h"
-#include "ace/Manual_Event.h"
-
-#if !defined (ACE_LACKS_PRAGMA_ONCE)
-# pragma once
-#endif /* ACE_LACKS_PRAGMA_ONCE */
-
-#if defined (ACE_HAS_THREADS)
-
-enum DEBUGGING_RANGE
-{
-  DEBUG_NONE = 0,
-  DEBUG
-};
-
-typedef ACE_Message_Queue<ACE_MT_SYNCH> Message_Queue;
-
-/**************************************************************/
-/**
- * @class Synchronisers
- *
- * @brief This class provides all the synchrnoisers used in this
- *  test.
- *
- *
- */
-
-/// Forward declaration..
-class IO_Task;
-class Worker_Task;
-
-class Synchronisers
-{
-public:
-  friend class IO_Task;
-  friend class Worker_Task;
-
-  enum
-  {
-    /// Used in the message block to stop processing of message
-    /// blocks.
-    MB_STOP_FLAG = 0x2000
-  };
-
-  /// Ctor
-  Synchronisers (void);
-
-  int  start_synchronization (void);
-  int  end_synchronization (void);
-
-private:
-
-  /// The mutex that is used for synchronisation.
-  ACE_SYNCH_MUTEX mutex_;
-
-  /// A manual event
-  ACE_Manual_Event event_;
-};
-
-
-/**************************************************************/
-/**
- * @class Input_Task
- *
- * @brief Class that does the Input work ie. puts the events into the
- *  message queue
- */
-
-class Input_Task : public ACE_Task<ACE_MT_SYNCH>
-{
-public:
-  /// Ctor
-  Input_Task (Message_Queue *mq,
-              Synchronisers &synch);
-
-  /// The thread runs inside this method..
-  int svc (void);
-
-private:
-
-  /// Our referance to Synchronisers
-  Synchronisers &synch_;
-};
-
-/**************************************************************/
-/**
- * @class Output_Task
- *
- * @brief Class that does the Output work ie. getsx the events into the
- *  message queue
- */
-
-class Output_Task : public ACE_Task<ACE_MT_SYNCH>
-{
-public:
-  /// Ctor
-  Output_Task (Message_Queue *mq,
-              Synchronisers &synch);
-
-  /// The thread runs inside this method..
-  int svc (void);
-
-  /// Need to overload this method to do anything useful..
-  virtual int put (ACE_Message_Block *, ACE_Time_Value * = 0);
-
-private:
-
-  /// Our referance to Synchronisers
-  Synchronisers &synch_;
-};
-
-
-/**************************************************************/
-/**
- * @class Synchronisers
- *
- * @brief This class provides and interface for all the upcall threads
- *  to run and do the actual work
- */
-
-class Worker_Task : public ACE_Task<ACE_MT_SYNCH>
-{
-public:
-  /// Ctor
-  Worker_Task (Message_Queue *mq,
-               Synchronisers &synch);
-
-  /// Methods in which the threads run on
-  int svc (void);
-
-  /// Processed messages
-  int processed (void);
-private:
-
-  /// Our referance to Synchronisers
-  Synchronisers &synch_;
-
-  /// Number of messages processed by us
-  size_t messages_processed_;
-};
-
-
-
-
-#endif /*ACE_HAS_THREADS*/
-
-#include /**/ "ace/post.h"
-#endif /*PERF_TEST_RT_CORBA_WORKERS_H*/
diff --git a/performance-tests/Server_Concurrency/Queue_Based_Workers/Svr_Conc_Queue_Based_Workers.mpc b/performance-tests/Server_Concurrency/Queue_Based_Workers/Svr_Conc_Queue_Based_Workers.mpc
deleted file mode 100644
index 4b4291e1f43..00000000000
--- a/performance-tests/Server_Concurrency/Queue_Based_Workers/Svr_Conc_Queue_Based_Workers.mpc
+++ /dev/null
@@ -1,14 +0,0 @@
-// -*- MPC -*-
-// $Id$
-
-project : aceexe {
-  source_files {
-    workers.cpp
-  }
-}
-
-project(*RTCorba) : aceexe {
-  source_files {
-    RT_CORBA_Workers.cpp
-  }
-}
\ No newline at end of file
diff --git a/performance-tests/Server_Concurrency/Queue_Based_Workers/workers.cpp b/performance-tests/Server_Concurrency/Queue_Based_Workers/workers.cpp
deleted file mode 100644
index 3771e80307e..00000000000
--- a/performance-tests/Server_Concurrency/Queue_Based_Workers/workers.cpp
+++ /dev/null
@@ -1,425 +0,0 @@
-// $Id$
-
-#include "ace/OS_main.h"
-#include "ace/OS_NS_unistd.h"
-#include "ace/ACE.h"
-#include "ace/Task_T.h"
-#include "ace/Get_Opt.h"
-#include "ace/High_Res_Timer.h"
-#include "ace/Sched_Params.h"
-#include "ace/Profile_Timer.h"
-#include "ace/Lock_Adapter_T.h"
-#include "../Latency_Stats.h"
-
-static size_t number_of_messages = 100;
-static size_t message_size = 100;
-static size_t number_of_workers = 10;
-static size_t burst_size = 10;
-static size_t timeout_between_bursts = 1;
-
-enum DEBUGGING_RANGE
-{
-  DEBUG_NONE = 0,
-  DEFAULT = 1,
-  PRINT_INDIVIDUAL_LATENCY = 2
-};
-
-static DEBUGGING_RANGE debug = DEBUG_NONE;
-
-static ACE_Data_Block *data_block = 0;
-
-class Message_Block : public ACE_Message_Block
-{
-public:
-  Message_Block (ACE_Data_Block *data_block,
-                 ACE_hrtime_t start_of_burst);
-
-  ACE_hrtime_t start_of_burst_;
-};
-
-Message_Block::Message_Block (ACE_Data_Block *data_block,
-                              ACE_hrtime_t start_of_burst)
-  : ACE_Message_Block (data_block),
-    start_of_burst_ (start_of_burst)
-{
-}
-
-typedef ACE_Task<ACE_SYNCH> TASK;
-
-class Worker_Task : public TASK
-{
-public:
-  Worker_Task (ACE_Message_Queue<ACE_SYNCH> *mq);
-  int svc (void);
-
-  size_t messages_dequeued_;
-
-  Latency_Stats latency_stats_;
-  Throughput_Stats throughput_stats_;
-};
-
-class IO_Task : public TASK
-{
-public:
-  IO_Task (ACE_Message_Queue<ACE_SYNCH> *mq);
-  int svc (void);
-};
-
-Worker_Task::Worker_Task (ACE_Message_Queue<ACE_SYNCH> *mq)
-  : TASK (0, mq),
-    messages_dequeued_ (0)
-{
-}
-
-int
-Worker_Task::svc (void)
-{
-  for (;;)
-    {
-      ACE_Message_Block *mb = 0;
-      int result = this->getq (mb);
-      if (result == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "Worker_Task::svc (%t) -> %p\n",
-                             "getq error"),
-                            -1);
-        }
-
-      ACE_Message_Block::ACE_Message_Type message_type =
-        mb->msg_type ();
-
-      // If STOP message, break loop and end the task.
-      if (message_type == ACE_Message_Block::MB_STOP)
-        {
-          if (debug)
-            {
-              ACE_DEBUG ((LM_DEBUG,
-                          "(%t) stop message dequeued after %d data messages\n",
-                          this->messages_dequeued_));
-            }
-
-          mb->release ();
-          break;
-        }
-
-      Message_Block *message_block =
-        ACE_dynamic_cast (Message_Block *, mb);
-
-      ACE_hrtime_t start_of_burst_for_this_message_block =
-        message_block->start_of_burst_;
-
-      mb->release ();
-
-      // Counter.
-      ++this->messages_dequeued_;
-
-      if (debug)
-        {
-          ACE_DEBUG ((LM_DEBUG,
-                      "(%t) dequeued its %d message\n",
-                      this->messages_dequeued_));
-        }
-
-      //
-      // Process message here.
-      //
-
-      for (size_t j = 0; j < message_size; ++j)
-        {
-          // Eat a little CPU
-          /* takes about 40.2 usecs on a 167 MHz Ultra2 */
-          u_long n = 11UL;
-          ACE::is_prime (n, 2, n / 2);
-        }
-
-      //
-      // Record stats for this message.
-      //
-      ACE_hrtime_t latency_from_start_of_burst =
-        ACE_OS::gethrtime () - start_of_burst_for_this_message_block;
-      this->latency_stats_.sample (latency_from_start_of_burst);
-
-      this->throughput_stats_.sample ();
-
-      if (debug >= PRINT_INDIVIDUAL_LATENCY)
-        {
-#ifndef ACE_LACKS_LONGLONG_T
-          ACE_DEBUG ((LM_DEBUG,
-                      "(%t) latency from start of burst: %Q\n",
-                      latency_from_start_of_burst));
-#else
-          ACE_DEBUG ((LM_DEBUG,
-                      "(%t) latency from start of burst: %u\n",
-                      latency_from_start_of_burst.lo()));
-#endif
-        }
-    }
-
-  return 0;
-}
-
-IO_Task::IO_Task (ACE_Message_Queue<ACE_SYNCH> *mq)
-  : TASK (0, mq)
-{
-}
-
-int
-IO_Task::svc (void)
-{
-  size_t i = 0;
-  size_t messages_queued = 1;
-  size_t burst = 1;
-
-  // Data messages.
-  while (number_of_messages > 0)
-    {
-      ACE_hrtime_t start_of_burst = ACE_OS::gethrtime ();
-
-      for (i = 1;
-           i <= burst_size && number_of_messages > 0;
-           ++i, --number_of_messages, ++messages_queued)
-        {
-          if (debug)
-            {
-              ACE_DEBUG ((LM_DEBUG,
-                          "(%t) IO thread -> burst %d: message %d; overall message %d\n",
-                          burst,
-                          i,
-                          messages_queued));
-            }
-
-          Message_Block *message_block = 0;
-          ACE_NEW_RETURN (message_block,
-                          Message_Block (data_block,
-                                         start_of_burst),
-                          -1);
-
-          int result = this->putq (message_block);
-          if (result == -1)
-            {
-              ACE_ERROR_RETURN ((LM_ERROR,
-                                 "IO::svc (%t) -> %p\n",
-                                 "putq error"),
-                                -1);
-            }
-        }
-
-      ++burst;
-      ACE_Time_Value tv (0, timeout_between_bursts);
-      ACE_OS::sleep (tv);
-    }
-
-  // Terminate messages.
-  for (i = 0; i < number_of_workers; ++i)
-    {
-      ACE_Message_Block *message_block = 0;
-      ACE_NEW_RETURN (message_block,
-                      ACE_Message_Block ((size_t)0,
-                                         (int)ACE_Message_Block::MB_STOP),
-                      -1);
-
-      int result = this->putq (message_block);
-      if (result == -1)
-        {
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "IO::svc (%t) -> %p\n",
-                             "putq error"),
-                            -1);
-        }
-    }
-
-  return 0;
-}
-
-static int
-parse_args (int argc, ACE_TCHAR *argv[])
-{
-  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT ("m:s:w:b:t:d:"));
-  int c;
-
-  while ((c = get_opt ()) != -1)
-    {
-      switch (c)
-        {
-        case 'm':
-          number_of_messages = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        case 's':
-          message_size = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        case 'w':
-          number_of_workers = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        case 'b':
-          burst_size = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        case 't':
-          timeout_between_bursts = ACE_OS::atoi (get_opt.opt_arg ());
-          break;
-        case 'd':
-          debug = ACE_static_cast (DEBUGGING_RANGE, ACE_OS::atoi (get_opt.opt_arg ()));
-          break;
-        default:
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "usage: %s\n"
-                             "\t[-m number of messages]\n"
-                             "\t[-s message size]\n"
-                             "\t[-w number of workers]\n"
-                             "\t[-b burst size]\n"
-                             "\t[-t timeout between bursts]\n"
-                             "\t[-d debug]\n",
-                             argv[0]),
-                            -1);
-        }
-    }
-
-  return 0;
-}
-
-int
-ACE_TMAIN (int argc, ACE_TCHAR *argv[])
-{
-  int result = parse_args (argc, argv);
-  if (result != 0)
-    {
-      return result;
-    }
-
-  move_to_rt_class ();
-  ACE_High_Res_Timer::calibrate ();
-
-  size_t i = 0;
-
-  ACE_NEW_RETURN (data_block,
-                  ACE_Locked_Data_Block<ACE_Lock_Adapter<ACE_SYNCH_MUTEX> >,
-                  -1);
-
-  for (i = 0; i < number_of_messages; ++i)
-    {
-      data_block->duplicate ();
-    }
-
-  ACE_Message_Queue<ACE_SYNCH> message_queue;
-
-  // Workers.
-  Worker_Task **workers = 0;
-  ACE_NEW_RETURN (workers,
-                  Worker_Task *[number_of_workers],
-                  -1);
-
-  ACE_Profile_Timer timer;
-  timer.start ();
-
-  int priority =
-    (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) +
-     ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
-  // priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO, priority);
-
-  long flags = THR_BOUND | THR_SCHED_FIFO;
-
-  // Create and activate them.
-  for (i = 0; i < number_of_workers; ++i)
-    {
-      ACE_NEW_RETURN (workers[i],
-                      Worker_Task (&message_queue),
-                      -1);
-
-      // Activate the workers.
-      result = workers[i]->activate (flags,
-                                     1,
-                                     1,
-                                     priority);
-      if (result != 0)
-        {
-          flags = THR_BOUND;
-          priority = ACE_Sched_Params::priority_min (ACE_SCHED_OTHER,
-                                                     ACE_SCOPE_THREAD);
-          result = workers[i]->activate (flags,
-                                         1,
-                                         1,
-                                         priority);
-          if (result != 0)
-            {
-              return result;
-            }
-        }
-    }
-
-  // IO Task.
-  IO_Task io (&message_queue);
-
-  // Activate the workers.
-  priority =
-    (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) +
-     ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
-  priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO, priority);
-
-  flags = THR_BOUND | THR_SCHED_FIFO;
-
-  result = io.activate (THR_BOUND);
-  if (result != 0)
-    {
-      flags = THR_BOUND;
-      priority = ACE_Sched_Params::priority_min (ACE_SCHED_OTHER,
-                                                 ACE_SCOPE_THREAD);
-      result = io.activate (flags,
-                            1,
-                            1,
-                            priority);
-      if (result != 0)
-        {
-          return result;
-        }
-    }
-
-  // Wait for all threads to terminate.
-  result = ACE_Thread_Manager::instance ()->wait ();
-
-  timer.stop ();
-  ACE_Rusage rusage;
-  timer.elapsed_rusage (rusage);
-
-  Latency_Stats latency;
-  Throughput_Stats throughput;
-  for (i = 0; i < number_of_workers; ++i)
-    {
-      latency.accumulate (workers[i]->latency_stats_);
-      throughput.accumulate (workers[i]->throughput_stats_);
-      ACE_DEBUG ((LM_DEBUG, "Thread[%d]: ", i));
-      workers[i]->throughput_stats_.dump_results (ACE_TEXT(""), ACE_TEXT(""));
-    }
-
-  ACE_DEBUG ((LM_DEBUG, "\nTotals for latency:\n"));
-  latency.dump_results (argv[0], ACE_TEXT("latency"));
-
-  ACE_DEBUG ((LM_DEBUG, "\nTotals for throughput:\n"));
-  throughput.dump_results (argv[0], ACE_TEXT("throughput"));
-
-#if defined(ACE_HAS_PRUSAGE_T)
-  ACE_DEBUG ((LM_DEBUG, "\n(%t) Context switches %d/%d\n",
-              rusage.pr_vctx,
-              rusage.pr_ictx));
-#endif /* ACE_HAS_PRUSAGE_T */
-
-  for (i = 0; i < number_of_workers; ++i)
-    {
-      delete workers[i];
-    }
-  delete[] workers;
-  delete data_block;
-
-  return result;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-
-template class ACE_Locked_Data_Block<ACE_Lock_Adapter<ACE_SYNCH_MUTEX> >;
-template class ACE_Lock_Adapter<ACE_SYNCH_MUTEX>;
-
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-
-#pragma instantiate ACE_Locked_Data_Block<ACE_Lock_Adapter<ACE_SYNCH_MUTEX> >
-#pragma instantiate ACE_Lock_Adapter<ACE_SYNCH_MUTEX>
-
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/performance-tests/Server_Concurrency/run_test.sh b/performance-tests/Server_Concurrency/run_test.sh
deleted file mode 100755
index 0f45ca8f11a..00000000000
--- a/performance-tests/Server_Concurrency/run_test.sh
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/bin/sh
-#
-# $Id$
-#
-
-for s in 0 25 50 75 100; do
-  for w in 1 2 3 4 5 6; do
-    echo ================ WORK: $s 1>&2
-    echo ================ THREADS: $w 1>&2
-    ./Queue_Based_Workers/workers -m 100000 -b 100000 -s $s -w $w
-    ./Leader_Follower/leader_follower -m 100000 -b 100000 -s $s -w $w
-  done
-done
diff --git a/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.cpp b/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.cpp
deleted file mode 100644
index 99ae0a06c1d..00000000000
--- a/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.cpp
+++ /dev/null
@@ -1,233 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-
-#include "Baseline_Test.h"
-
-# if defined (ACE_HAS_THREADS)
-
-#include "ace/OS_NS_unistd.h"
-#include "ace/Service_Repository.h"
-#include "ace/Get_Opt.h"
-#include "ace/Thread_Manager.h"
-
-#if !defined (__ACE_INLINE__)
-#include "Baseline_Test.i"
-#endif /* __ACE_INLINE__ */
-
-ACE_RCSID (Base_Test,
-           Baseline_Test,
-           "$Id$")
-
-Baseline_Test_Options baseline_options;
-// Static Baseline Options holds the test configuration information
-// and the test statistics.
-
-Baseline_Test_Base::Baseline_Test_Base (void)
-  : Benchmark_Base (Benchmark_Base::BASELINE),
-    yield_method_ (Baseline_Test_Options::USE_SLEEP_ZERO),
-    iteration_ (DEFAULT_ITERATIONS),
-    what_(TEST_LOCK)
-{
-}
-
-int
-Baseline_Test_Base::init (int argc, ACE_TCHAR *argv[])
-{
-  return this->parse_args (argc, argv);
-}
-
-int
-Baseline_Test_Base::parse_args (int argc, ACE_TCHAR *argv[])
-{
-  ACE_Get_Opt getopt (argc, argv, ACE_TEXT("i:ylrw"), 0);
-  int c;
-
-  while ((c = getopt ()) != -1)
-    switch (c)
-      {
-      case 'i':                 // Total iterations
-        {
-          int tmp = ACE_OS::atoi (getopt.opt_arg ());
-          if (tmp <= 0)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "%d is not a valid value for iteration\n",
-                               tmp), -1);
-          else
-            this->iteration_ = ACE_static_cast (size_t, tmp);
-        }
-        break;
-
-      case 'y':                 // Use thr_yield.
-        this->yield_method_ = Baseline_Test_Options::USE_THR_YIELD;
-        break;
-
-      case 'l':
-        this->what_ = TEST_LOCK;
-        break;
-
-      case 'r':
-        this->what_ = TEST_READLOCK;
-        break;
-
-      case 'w':
-        this->what_ = TEST_WRITELOCK;
-        break;
-
-      default:
-        ACE_ERROR ((LM_ERROR, "Invalid argument %c used\n", c));
-        break;
-      }
-  return 0;
-}
-
-void
-Baseline_Test_Base::yield (void)
-{
-  if (this->yield_method_ == Baseline_Test_Options::USE_SLEEP_ZERO)
-    ACE_OS::sleep (0);
-  else
-    ACE_OS::thr_yield ();
-}
-
-Baseline_Test_Options::Baseline_Test_Options (void)
-  : test_try_lock_ (0),
-    verbose_ (0),
-    current_yield_method_ (0),
-    current_iteration_ (0),
-    total_iteration_ (DEFAULT_ITERATIONS)
-{
-}
-
-int
-Baseline_Test_Options::parse_args (int argc, ACE_TCHAR *argv[])
-{
-  ACE_Get_Opt getopt (argc, argv, ACE_TEXT("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 iteration,
-                                     int yield)
-{
-  this->current_iteration_ = 0;
-  this->timer.reset ();
-
-  this->current_yield_method_ = yield;
-  this->total_iteration_ = iteration;
-  return 0;
-}
-
-void
-Baseline_Test_Options::print_result (void)
-{
-  ACE_Time_Value tv;
-  ACE_hrtime_t nsec;
-
-  this->timer.elapsed_time_incr (tv);
-  this->timer.elapsed_time_incr (nsec);
-  ACE_DEBUG ((LM_DEBUG,
-              "Total Time: %d sec %d usec for a "
-              "total of %d iterations\n"
-              "Average time: %d nanoseconds.\n",
-              tv.sec (), tv.usec (),
-              this->current_iteration_,
-              (int) (nsec / this->current_iteration_)));
-}
-
-Baseline_Test::Baseline_Test (void)
-  : current_test_ (0),
-    get_lock_ (2),
-    let_go_lock_ (2)
-{
-}
-
-// Initialize and run the benchmarks tests.
-
-int
-Baseline_Test::init (int argc, ACE_TCHAR **argv)
-{
-  return baseline_options.parse_args (argc, argv);
-}
-
-int
-Baseline_Test::pre_run_test (Benchmark_Base *bb)
-{
-  this->current_test_ = (Baseline_Test_Base *) bb;
-  baseline_options.reset_params (this->current_test_->iteration (),
-                                 this->current_test_->yield_method ());
-  if (baseline_options.test_try_lock ())
-    {
-      ACE_Thread_Manager::instance ()->spawn
-        (ACE_THR_FUNC (Baseline_Test::hold_lock),
-         (void *) this);
-
-      this->get_lock_.wait ();
-      // Wait until the lock is held by the spawning thread.
-    }
-
-  return 0;
-}
-
-int
-Baseline_Test::run_test (void)
-{
-  if (baseline_options.test_try_lock ())
-    return this->current_test_->test_try_lock ();
-  else
-    return this->current_test_->test_acquire_release ();
-}
-
-int
-Baseline_Test::post_run_test (void)
-{
-  if (baseline_options.test_try_lock ())
-    {
-      // Release the lock we hold.
-      this->let_go_lock_.wait ();
-
-      ACE_Thread_Manager::instance ()->wait ();
-    }
-
-  baseline_options.print_result ();
-
-  return 0;
-}
-
-int
-Baseline_Test::valid_test_object (Benchmark_Base *bb)
-{
-  return (bb->benchmark_type () == Benchmark_Base::BASELINE);
-}
-
-void *
-Baseline_Test::hold_lock (void *arg)
-{
-  Baseline_Test *this_test = (Baseline_Test *) arg;
-  this_test->current_test_->acquire ();
-  this_test->get_lock_.wait ();
-
-  this_test->let_go_lock_.wait ();
-  return 0;
-}
-
-ACE_SVC_FACTORY_DEFINE (Baseline_Test)
-
-#endif  /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.h b/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.h
deleted file mode 100644
index b19c2158e1f..00000000000
--- a/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.h
+++ /dev/null
@@ -1,153 +0,0 @@
-// -*- C++ -*-
-// $Id$
-
-#ifndef ACE_BASELINE_TEST_H
-#define ACE_BASELINE_TEST_H
-
-#include "Synch_Lib/Benchmark_Base.h"
-
-#if defined (ACE_HAS_THREADS)
-
-#include "ace/Profile_Timer.h"
-#include "ace/svc_export.h"
-#include "ace/Barrier.h"
-
-const unsigned long DEFAULT_ITERATIONS = 1000000;
-
-class ACE_Svc_Export Baseline_Test_Base : public Benchmark_Base
-{
-  // = TITLE
-  //     This class identifies itself as Benmarking Performance Test class.
-public:
-  enum {
-    TEST_LOCK,
-    TEST_READLOCK,
-    TEST_WRITELOCK
-  };
-
-  virtual int init (int argc, ACE_TCHAR *argv[]);
-  // Standard initializing method for Baseline Test.
-
-  int parse_args (int argc, ACE_TCHAR *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.
-
-  virtual int test_acquire_release () = 0;
-  virtual int test_try_lock () = 0;
-  // Real test methods.
-
-  virtual int yield_method ();
-  // Query the yield method used.
-
-  virtual void yield ();
-  // Yield to other thread.
-
-  size_t iteration (void);
-  // Access methods.
-
-protected:
-  Baseline_Test_Base (void);
-
-  int yield_method_;
-  // Should we your thr_yield or sleep (0).
-
-  size_t iteration_;
-  // Total number of operations.  <iterations_>
-
-  int what_;
-  // What test should be performed?
-};
-
-class ACE_Svc_Export Baseline_Test_Options
-{
-  // = TITLE
-  //    This class holds the global settings for Baseline Test.
-public:
-  friend class Baseline_Test;
-
-  enum
-  {
-    USE_SLEEP_ZERO,
-    USE_THR_YIELD
-  };
-
-  Baseline_Test_Options (void);
-  // ctor.
-
-  int parse_args (int argc, ACE_TCHAR *argv[]);
-  // Parse and set the Baseline_Test options and flags.
-
-  int reset_params (size_t iteration, int yield);
-  // Reset test parameters for next round.
-
-  int test_try_lock (void);
-  // Return test configuration.
-
-  void start_inc_timer (void);
-  void stop_inc_timer (void);
-  // Start/stop measuring time.
-
-  int inc_loop_counter (void);
-  // Returns
-
-  size_t current_iteration (void);
-  // Return <iteration_>.
-
-  void print_result (void);
-  // Print out the result.
-
-private:
-  int test_try_lock_;
-  // A flag indicates whether we are testing try_lock or lock and
-  // release.
-
-  int verbose_;
-  // Print out the result in verbose mode.
-
-  int current_yield_method_;
-  // yield or sleep.
-
-  size_t current_iteration_;
-  // Number of iteration.
-
-  size_t total_iteration_;
-  // Total number of target iteration.
-
-  ACE_High_Res_Timer timer;
-  // Profile timer result.
-};
-
-extern Baseline_Test_Options baseline_options;
-
-class ACE_Svc_Export Baseline_Test : public Benchmark_Method_Base
-{
-public:
-  Baseline_Test (void);
-  virtual int init (int argc, ACE_TCHAR *argv[]);
-  virtual int pre_run_test (Benchmark_Base *bp);
-  virtual int run_test (void);
-  virtual int post_run_test (void);
-  virtual int valid_test_object (Benchmark_Base *);
-
-  static void *hold_lock (void * arg);
-  // This method runs in a separate thread, and is used to hold the lock while
-  // we test the performance of try lock.
-
-private:
-  Baseline_Test_Base *current_test_;
-  ACE_Barrier get_lock_;
-  ACE_Barrier let_go_lock_;
-};
-
-ACE_SVC_FACTORY_DECLARE (Baseline_Test)
-
-#if defined (__ACE_INLINE__)
-#include "Baseline_Test.i"
-#endif /* __ACE_INLINE__ */
-
-#endif  /* ACE_HAS_THREADS */
-
-#endif /* ACE_BASELINE_TEST_H */
diff --git a/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.i b/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.i
deleted file mode 100644
index 05aa007478d..00000000000
--- a/performance-tests/Synch-Benchmarks/Base_Test/Baseline_Test.i
+++ /dev/null
@@ -1,43 +0,0 @@
-// $Id$
-
-ACE_INLINE size_t
-Baseline_Test_Base::iteration (void)
-{
-  return this->iteration_;
-}
-
-ACE_INLINE int
-Baseline_Test_Base::yield_method (void)
-{
-  return this->yield_method_;
-}
-
-ACE_INLINE int
-Baseline_Test_Options::test_try_lock (void)
-{
-  return this->test_try_lock_;
-}
-
-ACE_INLINE size_t
-Baseline_Test_Options::current_iteration (void)
-{
-  return this->current_iteration_;
-}
-
-ACE_INLINE void
-Baseline_Test_Options::start_inc_timer (void)
-{
-  this->timer.start_incr ();
-}
-
-ACE_INLINE void
-Baseline_Test_Options::stop_inc_timer (void)
-{
-  this->timer.stop_incr ();
-}
-
-ACE_INLINE int
-Baseline_Test_Options::inc_loop_counter (void)
-{
-  return (++this->current_iteration_ < this->total_iteration_);
-}
diff --git a/performance-tests/Synch-Benchmarks/Base_Test/Synch_Benchmarks_Base_Test.mpc b/performance-tests/Synch-Benchmarks/Base_Test/Synch_Benchmarks_Base_Test.mpc
deleted file mode 100644
index e5e86e69dea..00000000000
--- a/performance-tests/Synch-Benchmarks/Base_Test/Synch_Benchmarks_Base_Test.mpc
+++ /dev/null
@@ -1,9 +0,0 @@
-// -*- MPC -*-
-// $Id$
-
-project : aceexe {
-  after    += Synch_Lib
-  libs     += Synch_Lib
-  libpaths += ../Synch_Lib
-  includes += ..
-}
\ No newline at end of file
diff --git a/performance-tests/Synch-Benchmarks/Base_Test/base_test.cpp b/performance-tests/Synch-Benchmarks/Base_Test/base_test.cpp
deleted file mode 100644
index 6d3622c27b8..00000000000
--- a/performance-tests/Synch-Benchmarks/Base_Test/base_test.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-// $Id$
-
-#define ACE_BUILD_SVC_DLL
-
-#include "Baseline_Test.h"
-
-# if defined (ACE_HAS_THREADS)
-
-#include "ace/Log_Msg.h"
-
-class ACE_Svc_Export Baseline_Base_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.
-};
-
-int
-Baseline_Base_Test::acquire ()
-{
-  return 0;
-}
-
-int
-Baseline_Base_Test::release ()
-{
-  return 0;
-}
-
-int
-Baseline_Base_Test::test_acquire_release ()
-{
-  baseline_options.start_inc_timer ();
-
-  for (; baseline_options.inc_loop_counter () ; )
-    ;
-
-  baseline_options.stop_inc_timer ();
-  return 0;
-}
-
-int
-Baseline_Base_Test::test_try_lock ()
-{
-  baseline_options.start_inc_timer ();
-
-  for (; baseline_options.inc_loop_counter () ; )
-    ;
-
-  baseline_options.stop_inc_timer ();
-  return 0;
-}
-
-ACE_SVC_FACTORY_DECLARE (Baseline_Base_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_Base_Test)
-
-#endif  /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Base_Test/mutex_test.cpp b/performance-tests/Synch-Benchmarks/Base_Test/mutex_test.cpp
deleted file mode 100644
index 307f093c4fa..00000000000
--- a/performance-tests/Synch-Benchmarks/Base_Test/mutex_test.cpp
+++ /dev/null
@@ -1,247 +0,0 @@
-// $Id$
-
-#define ACE_BUILD_SVC_DLL
-
-#include "Baseline_Test.h"
-
-# if defined (ACE_HAS_THREADS)
-
-#include "ace/Log_Msg.h"
-#include "ace/Token.h"
-#include "ace/Process_Mutex.h"
-#include "ace/RW_Mutex.h"
-#include "ace/RW_Process_Mutex.h"
-#include "ace/RW_Thread_Mutex.h"
-#include "ace/Lock_Adapter_T.h"
-#include "ace/Recursive_Thread_Mutex.h"
-#include "ace/Semaphore.h"
-#include "ace/Null_Semaphore.h"
-#include "ace/Process_Semaphore.h"
-
-
-template<class LOCK>
-class ACE_Svc_Export Baseline_Lock_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:
-  LOCK lock_;
-  //
-};
-
-template<class LOCK> int
-Baseline_Lock_Test<LOCK>::acquire ()
-{
-  int retv = 0;
-  switch (this->what_)
-    {
-    case TEST_READLOCK:
-      retv = this->lock_.acquire_read ();
-      break;
-    case TEST_WRITELOCK:
-      retv = this->lock_.acquire_write ();
-      break;
-    case TEST_LOCK:
-    default:
-      retv = this->lock_.acquire ();
-      break;
-    }
-
-  return retv;
-}
-
-template<class LOCK> int
-Baseline_Lock_Test<LOCK>::release ()
-{
-  return this->lock_.release ();
-}
-
-template<class LOCK> int
-Baseline_Lock_Test<LOCK>::test_acquire_release ()
-{
-  baseline_options.start_inc_timer ();
-
-  switch (this->what_)
-    {
-    case TEST_READLOCK:
-      for (; baseline_options.inc_loop_counter () ; )
-        {
-          this->lock_.acquire_read ();
-          this->lock_.release ();
-        }
-      break;
-    case TEST_WRITELOCK:
-      for (; baseline_options.inc_loop_counter () ; )
-        {
-          this->lock_.acquire_write ();
-          this->lock_.release ();
-        }
-      break;
-    case TEST_LOCK:
-    default:
-      for (; baseline_options.inc_loop_counter () ; )
-        {
-          this->lock_.acquire ();
-          this->lock_.release ();
-        }
-      break;
-    }
-
-  baseline_options.stop_inc_timer ();
-
-  return 0;
-}
-
-template<class LOCK> int
-Baseline_Lock_Test<LOCK>::test_try_lock ()
-{
-  baseline_options.start_inc_timer ();
-  switch (this->what_)
-    {
-    case TEST_READLOCK:
-      for (; baseline_options.inc_loop_counter () ; )
-        this->lock_.tryacquire_read (); // This should always fail.
-      break;
-    case TEST_WRITELOCK:
-      for (; baseline_options.inc_loop_counter () ; )
-        this->lock_.tryacquire_write (); // This should always fail.
-      break;
-    case TEST_LOCK:
-    default:
-      for (; baseline_options.inc_loop_counter () ; )
-        this->lock_.tryacquire (); // This should always fail.
-      break;
-    }
-
-  for (; baseline_options.inc_loop_counter () ; )
-    this->lock_.tryacquire (); // This should always fail.
-
-  baseline_options.stop_inc_timer ();
-  return 0;
-}
-
-typedef Baseline_Lock_Test<ACE_Thread_Mutex> Baseline_Mutex_Test;
-
-ACE_SVC_FACTORY_DECLARE (Baseline_Mutex_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_Mutex_Test)
-
-typedef Baseline_Lock_Test<ACE_RW_Thread_Mutex> Baseline_RW_Thread_Mutex_Test;
-
-ACE_SVC_FACTORY_DECLARE (Baseline_RW_Thread_Mutex_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_RW_Thread_Mutex_Test)
-
-typedef Baseline_Lock_Test<ACE_RW_Mutex> Baseline_RW_Mutex_Test;
-
-ACE_SVC_FACTORY_DECLARE (Baseline_RW_Mutex_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_RW_Mutex_Test)
-
-typedef Baseline_Lock_Test<ACE_Process_Mutex> Baseline_Process_Mutex_Test;
-
-ACE_SVC_FACTORY_DECLARE (Baseline_Process_Mutex_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_Process_Mutex_Test)
-
-typedef Baseline_Lock_Test<ACE_RW_Process_Mutex> Baseline_RW_Process_Mutex_Test;
-
-ACE_SVC_FACTORY_DECLARE (Baseline_RW_Process_Mutex_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_RW_Process_Mutex_Test)
-
-typedef Baseline_Lock_Test<ACE_Null_Mutex> Baseline_Null_Mutex_Test;
-
-ACE_SVC_FACTORY_DECLARE (Baseline_Null_Mutex_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_Null_Mutex_Test)
-
-typedef Baseline_Lock_Test< ACE_Lock_Adapter<ACE_Null_Mutex> > Baseline_Adaptive_Null_Mutex_Test;
-
-ACE_SVC_FACTORY_DECLARE (Baseline_Adaptive_Null_Mutex_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_Adaptive_Null_Mutex_Test)
-
-typedef Baseline_Lock_Test<ACE_Recursive_Thread_Mutex> Baseline_Recursive_Mutex_Test;
-
-ACE_SVC_FACTORY_DECLARE (Baseline_Recursive_Mutex_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_Recursive_Mutex_Test)
-
-typedef Baseline_Lock_Test< ACE_Lock_Adapter<ACE_Thread_Mutex> > Baseline_Adaptive_Mutex_Test;
-
-ACE_SVC_FACTORY_DECLARE (Baseline_Adaptive_Mutex_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_Adaptive_Mutex_Test)
-
-typedef Baseline_Lock_Test< ACE_Lock_Adapter<ACE_RW_Mutex> > Baseline_Adaptive_RW_Mutex_Test;
-
-ACE_SVC_FACTORY_DECLARE (Baseline_Adaptive_RW_Mutex_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_Adaptive_RW_Mutex_Test)
-
-typedef Baseline_Lock_Test< ACE_Lock_Adapter<ACE_Recursive_Thread_Mutex> > Baseline_Adaptive_Recursive_Mutex_Test;
-
-ACE_SVC_FACTORY_DECLARE (Baseline_Adaptive_Recursive_Mutex_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_Adaptive_Recursive_Mutex_Test)
-
-typedef Baseline_Lock_Test<ACE_Semaphore> Baseline_Semaphore_Test;
-
-ACE_SVC_FACTORY_DECLARE (Baseline_Semaphore_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_Semaphore_Test)
-
-typedef Baseline_Lock_Test<ACE_Semaphore> Baseline_Process_Semaphore_Test;
-
-ACE_SVC_FACTORY_DECLARE (Baseline_Process_Semaphore_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_Process_Semaphore_Test)
-
-typedef Baseline_Lock_Test<ACE_Null_Semaphore> Baseline_Null_Semaphore_Test;
-
-ACE_SVC_FACTORY_DECLARE (Baseline_Null_Semaphore_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_Null_Semaphore_Test)
-
-typedef Baseline_Lock_Test<ACE_Token> Baseline_Token_Test;
-
-ACE_SVC_FACTORY_DECLARE (Baseline_Token_Test)
-ACE_SVC_FACTORY_DEFINE (Baseline_Token_Test)
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class Baseline_Lock_Test<ACE_Thread_Mutex>;
-template class Baseline_Lock_Test<ACE_Process_Mutex>;
-template class Baseline_Lock_Test<ACE_RW_Process_Mutex>;
-template class Baseline_Lock_Test<ACE_RW_Mutex>;
-template class Baseline_Lock_Test<ACE_RW_Thread_Mutex>;
-template class Baseline_Lock_Test<ACE_Null_Mutex>;
-template class ACE_Lock_Adapter<ACE_Null_Mutex>;
-template class Baseline_Lock_Test< ACE_Lock_Adapter<ACE_Null_Mutex> >;
-template class Baseline_Lock_Test<ACE_Recursive_Thread_Mutex>;
-template class ACE_Lock_Adapter<ACE_Thread_Mutex>;
-template class Baseline_Lock_Test< ACE_Lock_Adapter<ACE_Thread_Mutex> >;
-template class ACE_Lock_Adapter<ACE_RW_Mutex>;
-template class Baseline_Lock_Test< ACE_Lock_Adapter<ACE_RW_Mutex> >;
-template class ACE_Lock_Adapter<ACE_Recursive_Thread_Mutex>;
-template class Baseline_Lock_Test< ACE_Lock_Adapter<ACE_Recursive_Thread_Mutex> >;
-template class Baseline_Lock_Test<ACE_Semaphore>;
-template class Baseline_Lock_Test<ACE_Process_Semaphore>;
-template class Baseline_Lock_Test<ACE_Null_Semaphore>;
-template class Baseline_Lock_Test<ACE_Token>;
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate Baseline_Lock_Test<ACE_Thread_Mutex>
-#pragma instantiate Baseline_Lock_Test<ACE_Process_Mutex>
-#pragma instantiate Baseline_Lock_Test<ACE_RW_Process_Mutex>
-#pragma instantiate Baseline_Lock_Test<ACE_RW_Mutex>
-#pragma instantiate Baseline_Lock_Test<ACE_RW_Thread_Mutex>
-#pragma instantiate Baseline_Lock_Test<ACE_Null_Mutex>
-#pragma instantiate ACE_Lock_Adapter<ACE_Null_Mutex>
-#pragma instantiate Baseline_Lock_Test< ACE_Lock_Adapter<ACE_Null_Mutex> >
-#pragma instantiate Baseline_Lock_Test<ACE_Recursive_Thread_Mutex>
-#pragma instantiate ACE_Lock_Adapter<ACE_Thread_Mutex>
-#pragma instantiate Baseline_Lock_Test< ACE_Lock_Adapter<ACE_Thread_Mutex> >
-#pragma instantiate ACE_Lock_Adapter<ACE_RW_Mutex>
-#pragma instantiate Baseline_Lock_Test< ACE_Lock_Adapter<ACE_RW_Mutex> >
-#pragma instantiate ACE_Lock_Adapter<ACE_Recursive_Thread_Mutex>
-#pragma instantiate Baseline_Lock_Test< ACE_Lock_Adapter<ACE_Recursive_Thread_Mutex> >
-#pragma instantiate Baseline_Lock_Test<ACE_Semaphore>
-#pragma instantiate Baseline_Lock_Test<ACE_Process_Semaphore>
-#pragma instantiate Baseline_Lock_Test<ACE_Null_Semaphore>
-#pragma instantiate Baseline_Lock_Test<ACE_Token>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-#endif  /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/Adaptive_Lock_Performance_Test_Base.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/Adaptive_Lock_Performance_Test_Base.cpp
deleted file mode 100644
index 32ad7ea5431..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/Adaptive_Lock_Performance_Test_Base.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "Performance_Test_Options.h"
-#include "Adaptive_Lock_Performance_Test_Base.h"
-
-ACE_RCSID(Synch_Benchmarks, Adaptive_Lock_Performance_Test_Base_, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-ACE_Lock *Adaptive_Lock_Performance_Test_Base::lock_ = 0;
-
-int
-Adaptive_Lock_Performance_Test_Base::fini (void)
-{
-  delete Adaptive_Lock_Performance_Test_Base::lock_;
-  Adaptive_Lock_Performance_Test_Base::lock_ = 0;
-  return 0;
-}
-
-int
-Adaptive_Lock_Performance_Test_Base::svc (void)
-{
-  // Extract out the unique thread-specific value to be used as an
-  // index...
-  int ni = this->thr_id ();
-  synch_count = 2;
-
-  while (!this->done ())
-    {
-      Adaptive_Lock_Performance_Test_Base::lock_->acquire ();
-      performance_test_options.thr_work_count[ni]++;
-      buffer++;
-      Adaptive_Lock_Performance_Test_Base::lock_->release ();
-    }
-  /* NOTREACHED */
-  return 0;
-}
-
-int
-Adaptive_Lock_Performance_Test_Base::set_lock (ACE_Lock *lock)
-{
-  delete Adaptive_Lock_Performance_Test_Base::lock_;
-  Adaptive_Lock_Performance_Test_Base::lock_ = lock;
-  return (Adaptive_Lock_Performance_Test_Base::lock_ != 0 ? 0 : -1);
-}
-
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/Adaptive_Lock_Performance_Test_Base.h b/performance-tests/Synch-Benchmarks/Perf_Test/Adaptive_Lock_Performance_Test_Base.h
deleted file mode 100644
index 9fb65628ea8..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/Adaptive_Lock_Performance_Test_Base.h
+++ /dev/null
@@ -1,24 +0,0 @@
-// $Id$
-
-#ifndef ACE_ADAPTIVE_LOCK_PERFORMANCE_TEST_BASE_H
-#define ACE_ADAPTIVE_LOCK_PERFORMANCE_TEST_BASE_H
-#include "Benchmark_Performance.h"
-
-ACE_RCSID(Synch_Benchmarks, Adaptive_Lock_Performance_Test_Base, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Adaptive_Lock_Performance_Test_Base : public Benchmark_Performance
-{
-public:
-  virtual int init (int, ACE_TCHAR *[]) = 0;
-  virtual int fini (void);
-  virtual int svc (void);
-
-  int set_lock (ACE_Lock *lock);
-
-private:
-  static ACE_Lock *lock_;
-};
-#endif /* ACE_HAS_THREADS */
-#endif /* ACE_ADAPTIVE_LOCK_PERFORMANCE_TEST_BASE_H */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/Benchmark_Performance.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/Benchmark_Performance.cpp
deleted file mode 100644
index d563b6e832c..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/Benchmark_Performance.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "Benchmark_Performance.h"
-
-ACE_RCSID(Synch_Benchmarks, Benchmark_Performance, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-// Global variables (used by the dynamically linked services).
-ACE_Svc_Export int synch_count;
-int buffer;
-
-// Initialize the static variables.
-/* static */
-sig_atomic_t Benchmark_Performance::done_ = 0;
-
-Benchmark_Performance_Test_Base::Benchmark_Performance_Test_Base (void)
-  : Benchmark_Base (Benchmark_Base::PERFORMANCE)
-{
-}
-
-sig_atomic_t
-Benchmark_Performance::done (void)
-{
-  return Benchmark_Performance::done_;
-}
-
-void
-Benchmark_Performance::done (sig_atomic_t d)
-{
-  Benchmark_Performance::done_ = d;
-}
-
-int
-Benchmark_Performance::init (int, ACE_TCHAR **)
-{
-  return 1;
-}
-
-int
-Benchmark_Performance::info (ACE_TCHAR **, size_t) const
-{
-  return -1;
-}
-
-int
-Benchmark_Performance::fini (void)
-{
-  return -1;
-}
-
-void *
-Benchmark_Performance::svc_run (Benchmark_Performance *bp)
-{
-  return (void *) (bp->svc () == -1 ? -1 : 0);
-}
-
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/Benchmark_Performance.h b/performance-tests/Synch-Benchmarks/Perf_Test/Benchmark_Performance.h
deleted file mode 100644
index b66a83048a7..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/Benchmark_Performance.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/* -*- C++ -*- */
-// $Id$
-
-/* Defines the class used to dynamically link in the benchmark tests */
-
-#ifndef ACE_BENCHMARK_PERFORMANCE_H
-#define ACE_BENCHMARK_PERFORMANCE_H
-
-#include "Synch_Lib/Benchmark_Base.h"
-
-#if defined (ACE_HAS_THREADS)
-
-#include "ace/svc_export.h"
-
-extern int buffer;
-extern ACE_Svc_Export int synch_count;
-
-class ACE_Svc_Export Benchmark_Performance_Test_Base : public Benchmark_Base
-{
-  // = TITLE
-  //     This class identifies itself as Benmarking Performance Test class.
-protected:
-  Benchmark_Performance_Test_Base (void);
-};
-
-class ACE_Svc_Export Benchmark_Performance : public Benchmark_Performance_Test_Base
-{
-  // = TITLE
-  //   Base class for all the timing tests.
-public:
-  // = Hooks inherited from ACE_Service_Object.
-  virtual int svc (void) = 0;
-  virtual int init (int, ACE_TCHAR *[]);
-  virtual int info (ACE_TCHAR **, size_t) const;
-  virtual int fini (void);
-  static void *svc_run (Benchmark_Performance *bp);
-
-  // = Set/get flag that controls how the tests are shut down
-  // gracefully.
-  static void done (sig_atomic_t);
-  static sig_atomic_t done (void);
-
-protected:
-  static sig_atomic_t done_;
-  // Keeps track if we are finished or not.
-};
-#endif /* ACE_HAS_THREADS */
-#endif /* ACE_BENCHMARK_PERFORMANCE_H */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test.cpp
deleted file mode 100644
index 13c9863d7f1..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-
-#include "Performance_Test.h"
-
-# if defined (ACE_HAS_THREADS)
-
-#include "Performance_Test_Options.h"
-#include "Benchmark_Performance.h"
-
-#include "ace/Service_Repository.h"
-
-ACE_RCSID (Perf_Test,
-           Performance_Test,
-           "$Id$")
-
-Performance_Test::Performance_Test (void)
-  : n_lwps_ (0),
-    orig_n_lwps_ (0)
-{
-}
-
-// Initialize and run the benchmarks tests.
-
-int
-Performance_Test::init (int argc, ACE_TCHAR **argv)
-{
-  ACE_DEBUG ((LM_DEBUG, "Performance_Test::init\n"));
-  performance_test_options.parse_args (argc, argv);
-  return 0;
-}
-
-int
-Performance_Test::pre_run_test (Benchmark_Base *bb)
-{
-  this->orig_n_lwps_ = ACE_Thread::getconcurrency ();
-  this->n_lwps_ = performance_test_options.n_lwps ();
-  Benchmark_Performance *bp = (Benchmark_Performance *) bb;
-
-  if (this->n_lwps_ > 0)
-    ACE_Thread::setconcurrency (this->n_lwps_);
-
-      // We should probably use a "barrier" here rather than
-      // THR_SUSPENDED since many OS platforms lack the ability to
-      // create suspended threads...
-  if (ACE_Thread_Manager::instance ()->spawn_n
-      (performance_test_options.thr_count (), ACE_THR_FUNC (bp->svc_run),
-       (void *) bp, performance_test_options.t_flags () | THR_SUSPENDED) == -1)
-    ACE_ERROR ((LM_ERROR, "%p\n%a", "couldn't spawn threads", 1));
-  return 0;
-}
-
-int
-Performance_Test::run_test (void)
-{
-  // Tell the threads that we are not finished.
-  Benchmark_Performance::done (0);
-
-  // Allow thread(s) to make progress.
-  ACE_Thread_Manager::instance ()->resume_all ();
-
-  ACE_Time_Value timeout (performance_test_options.sleep_time ());
-
-  ACE_DEBUG ((LM_DEBUG, "starting timer\n"));
-  performance_test_options.start_timer ();
-
-  // Use Reactor as a timer (which can be interrupted by a signal).
-  ACE_Reactor::run_event_loop (timeout);
-
-  performance_test_options.stop_timer ();
-  ACE_DEBUG ((LM_DEBUG, "\nstopping timer\n"));
-
-  return 0;
-}
-
-int
-Performance_Test::post_run_test (void)
-{
-  // Stop thread(s) from making any further progress.
-  ACE_Thread_Manager::instance ()->suspend_all ();
-
-  // Tell the threads that we are finished.
-  Benchmark_Performance::done (1);
-
-  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 ()));
-  int count = performance_test_options.count ();
-  float rate  = count / (float (performance_test_options.sleep_time ()));
-
-  ACE_DEBUG ((LM_DEBUG,
-              "to count = %d\nrate = %.3f ops/sec, per operation = %.2f usec\n",
-              count,
-              rate,
-              (1.0e6 / rate) / synch_count));
-  performance_test_options.print_results ();
-  // Allow thread(s) to finish up.
-  ACE_Thread_Manager::instance ()->resume_all ();
-
-  // Wait for all the threads to exit.
-  ACE_Thread_Manager::instance ()->wait ();
-  performance_test_options.init ();
-
-  return 0;
-}
-
-int
-Performance_Test::valid_test_object (Benchmark_Base *bb)
-{
-  return (bb->benchmark_type () == Benchmark_Base::PERFORMANCE);
-}
-
-ACE_SVC_FACTORY_DEFINE (Performance_Test)
-
-#endif  /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test.h b/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test.h
deleted file mode 100644
index f56e8001e76..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// -*- C++ -*-
-//
-// $Id$
-
-#ifndef ACE_PERFORMANCE_TEST_H
-#define ACE_PERFORMANCE_TEST_H
-
-#include "ace/svc_export.h"
-
-#if defined (ACE_HAS_THREADS)
-
-#include "Synch_Lib/Benchmark_Base.h"
-
-class ACE_Svc_Export Performance_Test : public Benchmark_Method_Base
-{
-public:
-  Performance_Test (void);
-  virtual int init (int argc, ACE_TCHAR *argv[]);
-  virtual int pre_run_test (Benchmark_Base *bp);
-  virtual int run_test (void);
-  virtual int post_run_test (void);
-  virtual int valid_test_object (Benchmark_Base *);
-private:
-  int n_lwps_;
-  int orig_n_lwps_;
-};
-
-ACE_SVC_FACTORY_DECLARE (Performance_Test)
-
-#endif  /* ACE_HAS_THREADS */
-
-#endif /* ACE_PERFORMANCE_TEST_H */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test_Options.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test_Options.cpp
deleted file mode 100644
index 83ce801f066..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test_Options.cpp
+++ /dev/null
@@ -1,481 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "Performance_Test_Options.h"
-#include "ace/OS_NS_strings.h"
-
-ACE_RCSID(Synch_Benchmarks, Performance_Test_Options, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-// Manages the options.
-Performance_Test_Options performance_test_options;
-
-size_t
-Performance_Test_Options::count (void)
-{
-  size_t total = 0;
-
-  if (performance_test_options.verbose ())
-    ACE_DEBUG ((LM_DEBUG, "Thread work count size = %d\n", performance_test_options.thr_wc_size));
-
-  for (int i = 0; i < performance_test_options.thr_wc_size; i++)
-    {
-      if (performance_test_options.thr_work_count[i] != 0)
-        {
-          //          if (performance_test_options.verbose ())
-            ACE_DEBUG ((LM_DEBUG, "count[%d] = %d\n", i, performance_test_options.thr_work_count[i]));
-          total += performance_test_options.thr_work_count[i];
-        }
-    }
-
-  return total;
-}
-
-void
-Performance_Test_Options::init (void)
-{
-  for (int i = 0; i < this->thr_wc_size; i++)
-    this->thr_work_count[i] = 0;
-}
-
-Performance_Test_Options::Performance_Test_Options (void)
-                 : thr_wc_size (10000),
-                   _service_entry (0),
-                   _mapped_file (0),
-                   _pipe_addr (ACE_const_cast (ACE_TCHAR *, ACE_DEFAULT_RENDEZVOUS)),
-                   _sleep_time (100),
-                   _n_lwps (0),
-                   _thr_count (4),
-                   _t_flags (0),
-                   _high_water_mark (8 * 1024),
-                   _low_water_mark (1024),
-                   _msg_size (128),
-                   _initial_queue_length (0),
-                   _logical_connections (1),
-                   _physical_connections (1),
-                   _iterations (100000),
-                   _generate (0),
-                   _udp (0),
-                   _debugging (0),
-                   _verbosity (0),
-                   _ack (1),
-                   _checksum (1),
-                   _xdr (1),
-                   _free_memory (1),
-                   _zero_copy (0),
-                   _print_summary (0),
-                   _consecutive_ports (1),
-                   _eager_exit (0)
-{
-  this->thr_work_count = new int[this->thr_wc_size];
-  this->init ();
-}
-
-void
-Performance_Test_Options::parse_args (int argc, ACE_TCHAR *argv[])
-{
-  ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("a:A:bBc:C:dDe:F:g:H:i:L:l:M:m:n:Np:P:s:S:t:T:uvX:Z:"), 0);
-  int c;
-
-  while ((c = get_opt ()) != -1)
-    switch (c)
-      {
-      case 'a':                 // Not used. (do_ack ???)
-        this->_ack = ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_TEXT("ON")) == 0;
-        break;
-      case 'A':                 // Not used. (set rendezvous point.)
-        this->pipe_addr (get_opt.opt_arg ());
-        break;
-      case 'B':                 // Create thread with THR_BOUND.
-        this->t_flags (THR_BOUND);
-        break;
-      case 'c':                 // Not used. (# of connections.)
-        {
-          long connections = ACE_OS::atoi (get_opt.opt_arg ());
-
-          if (connections < 0)
-            this->physical_connections (size_t (-connections));
-          else if (connections > 0)
-            this->logical_connections (size_t (connections));
-          else
-            ACE_DEBUG ((LM_WARNING, "warning, 0 connections!\n"));
-
-          break;
-        }
-      case 'C':                 // Not used.  (Toggle calculate checksum.)
-        this->_checksum = ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_TEXT("ON")) == 0;
-        break;
-      case 'd':                 // Not used.  (Enable debugging.)
-        this->_debugging = 1;
-        break;
-      case 'D':                 // Create thread with THR_DETACHED.
-        this->t_flags (THR_DETACHED);
-        break;
-      case 'e':                 // Perform eager exit (without cleaning up.)
-        this->_eager_exit = ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_TEXT("ON")) == 0;
-        break;
-      case 'F':                 // Not used.
-        this->_free_memory = ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_TEXT("ON")) == 0;
-        break;
-      case 'g':                 // Not used.  (generate data ??)
-        this->_generate = ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_TEXT("ON")) == 0;
-        break;
-      case 'H':                 // Not used.  (set high water mark)
-        this->high_water_mark (ACE_OS::atoi (get_opt.opt_arg ()));
-        break;
-      case 'i':                 // Not used.  (# of iterations)
-        this->iterations (ACE_OS::atoi (get_opt.opt_arg ()));
-        break;
-      case 'L':                 // Not used.  (set low water mark)
-        this->low_water_mark (ACE_OS::atoi (get_opt.opt_arg ()));
-        break;
-      case 'l':                 // Not used.  (set initial queue length)
-        this->initial_queue_length (ACE_OS::atoi (get_opt.opt_arg ()));
-        break;
-      case 'M':                 // Set message size in pipe_[proc|thr]_test.
-        this->msg_size (ACE_OS::atoi (get_opt.opt_arg ()));
-        break;
-      case 'm':                 // Not used.  (set mapped file name)
-        this->mapped_file (get_opt.opt_arg ());
-        break;
-      case 'N':                 // Create thread with flag THR_NEW_LWP.
-        this->t_flags (THR_NEW_LWP);
-        break;
-      case 'n':                 // Set # of lwp's
-        this->n_lwps (ACE_OS::atoi (get_opt.opt_arg ()));
-        break;
-      case 'p':                 // Toggle whether summary is printed.
-        this->_print_summary = ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_TEXT("ON")) == 0;
-        break;
-      case 'P':                 // Not used.
-        this->consecutive_ports (ACE_OS::atoi (get_opt.opt_arg ()));
-        break;
-      case 'S':                 // Not used  (set service_entry ???)
-        this->service_entry (get_opt.opt_arg ());
-        break;
-      case 's':                 // Set testing duration.
-        this->sleep_time (ACE_OS::atoi (get_opt.opt_arg ()));
-        break;
-      case 'T':                 // Enable/disable tracing.
-#if defined (ACE_HAS_TRACE)
-        if (ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_TEXT("ON")) == 0)
-          ACE_Trace::start_tracing ();
-        else if (ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_TEXT("OFF")) == 0)
-          ACE_Trace::stop_tracing ();
-#endif /* ACE_HAS_TRACE */
-        break;
-      case 't':                 // Set # of threads contending the lock.
-        this->thr_count (ACE_OS::atoi (get_opt.opt_arg ()));
-        break;
-      case 'u':                 // Not used.  (use udp.)
-        this->_udp = 1;
-        break;
-      case 'v':                 // Not used.  (set display verbosely)
-        this->_verbosity = 1;
-        break;
-      case 'X':                 // Not used.  (Use xdr conversion.)
-        this->_xdr = ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_TEXT("ON")) == 0;
-        break;
-      case 'Z':                 // Not used.  (Do zero copy.)
-        this->_zero_copy = ACE_OS::strcasecmp (get_opt.opt_arg (), ACE_TEXT("ON")) == 0;
-        break;
-      default:
-        ACE_DEBUG ((LM_INFO,
-                   "%s\n"
-                   "\t[-a] (send acknowledgement)\n"
-                   "\t[-A] address of pipe [%s]\n"
-                   "\t[-B] (THR_BOUND)\n"
-                   "\t[-c] + number of logical connections\n"
-                   "\t[-c] - number of physical connections\n"
-                   "\t[-C] (enable checksumming)\n"
-                   "\t[-d] (enable debugging)\n"
-                   "\t[-D] (THR_DETACHED)\n"
-                   "\t[-e] (eager exit)\n"
-                   "\t[-F] (free memory)\n"
-                   "\t[-g] (generate data)\n"
-                   "\t[-H] high water mark\n"
-                   "\t[-i] number of test iterations [%d]\n"
-                   "\t[-L] low water mark\n"
-                   "\t[-m] mapped file\n"
-                   "\t[-M] message size\n"
-                   "\t[-n] number of LWPs\n"
-                   "\t[-N] (THR_NEW_LWP)\n"
-                   "\t[-p] (print benchmark summary)\n"
-                   "\t[-P] number of consecutive ports\n"
-                   "\t[-s] sleep time\n"
-                   "\t[-S] service entry\n"
-                   "\t[-t] number of threads [%d]\n"
-                   "\t[-T] (enable tracing)\n"
-                   "\t[-u] (UDP) \n"
-                   "\t[-v] (verbose) \n"
-                   "\t[-X] (enable xdr conversion)\n"
-                   "\t[-Z] (enable zero-copy driver)\n%a",
-                   argv[0],
-                   this->pipe_addr (),
-                   this->iterations (),
-                   this->thr_count (),
-                   1));
-        /* NOTREACHED */
-        break;
-      }
-
-  if (this->do_print_summary ())
-    ACE_DEBUG ((LM_INFO,
-                  "%8d = total iterations\n"
-                  "%8d = logical connections\n"
-                  "%8d = physical connections\n"
-                  "%8d = message_size\n"
-                  "%8d = calculated checksum\n"
-                  "%8d = perform xdr conversion\n"
-                  "%8d = number of LWPs requested\n"
-                  "%8d = number of LWPs used\n",
-                  this->iterations (),
-                  this->logical_connections (),
-                  this->physical_connections (),
-                  this->msg_size (),
-                  this->do_checksum () != 0,
-                  this->do_xdr() != 0,
-                  this->n_lwps (),
-               ACE_Thread::getconcurrency ()));
-  else if (this->verbose ())
-    ACE_DEBUG ((LM_INFO,
-                "%8d = total iterations\n"
-                "%8d = logical connections\n"
-                "%8d = physical connections\n"
-                "%8d = thread count\n"
-                "%8d = low water mark\n"
-                "%8d = high water mark\n"
-                "%8d = message_size\n"
-                "%8d = initial queue length\n"
-                "%8d = consecutive ports\n"
-                "%8d = calculated checksum\n"
-                "%8d = perform xdr conversion\n"
-                "%8d = zero-copy driver\n"
-                "%8d = free dynamic memory\n"
-                "%8d = print summary only\n"
-                "%8d = eager exit\n"
-                "%8d = UDP\n"
-                "%8d = send ack\n"
-                "%8d = THR_DETACHED\n"
-                "%8d = THR_BOUND\n"
-                "%8d = THR_NEW_LWP\n"
-                "%8d = sleep time\n",
-                this->iterations (),
-                this->logical_connections (),
-                this->physical_connections (),
-                this->thr_count (),
-                this->low_water_mark (),
-                this->high_water_mark (),
-                this->msg_size (),
-                this->initial_queue_length (),
-                this->consecutive_ports (),
-                this->do_checksum () != 0,
-                this->do_xdr() != 0,
-                this->do_zero_copy () != 0,
-                this->do_delete () != 0,
-                this->do_print_summary () != 0,
-                this->do_eager_exit () != 0,
-                this->do_udp () != 0,
-                this->do_ack () != 0,
-                (this->t_flags () & THR_DETACHED) != 0,
-                (this->t_flags () & THR_BOUND) != 0,
-                (this->t_flags () & THR_NEW_LWP) != 0,
-                this->sleep_time ()));
-}
-
-void
-Performance_Test_Options::print_results (void)
-{
-  ACE_Profile_Timer::ACE_Elapsed_Time et;
-  this->_itimer.elapsed_time (et);
-
-  ACE_Profile_Timer::Rusage rusage;
-  this->_itimer.elapsed_rusage (rusage);
-
-  size_t total    = this->count ();
-  double nbytes   = total * this->msg_size ();
-  double cpu_time = et.user_time + et.system_time;
-
-#if 0
-  mutex_timer.print_total ("ACE_Thread_Mutex overhead:", mutex_counter, 2);
-  condition_timer.print_total ("ACE_Condition overhead:", condition_counter, 2);
-  ACE_DEBUG ((LM_INFO,
-                "%8d (number of ACE_Thread_Mutex operations)\n"
-                "%8d (number of ACE_Condition operations)",
-             mutex_counter, condition_counter));
-#endif /* NDEBUG */
-
-  if (this->do_print_summary ())
-    {
-#if defined (ACE_HAS_PRUSAGE_T)
-      ACE_DEBUG ((LM_INFO,
-                  "\n%8d PEs\n"
-                  "%8.2f Mbit/sec\n"
-                  "%8d (voluntary context switches)\n"
-                  "%8d (involuntary context switches)\n"
-                  "%8d (total context switches)\n"
-                  "%8d.%d sec (wait-cpu time)\n"
-                  "%8d.%d sec (user lock wait sleep time)\n"
-                  "%8d.%d sec (all other sleep time)\n"
-                  "%8d (major page faults)\n"
-                  "%8d (minor page faults)\n"
-                  "%8d (number of LWPs)\n",
-                  this->thr_count (),
-                  (nbytes / et.real_time) * 8.0 / 1024.0 / 1024.0,
-                  rusage.pr_vctx,
-                  rusage.pr_ictx,
-                  rusage.pr_vctx + rusage.pr_ictx,
-                  rusage.pr_wtime.tv_sec, rusage.pr_wtime.tv_nsec / 1000000,
-                  rusage.pr_ltime.tv_sec, rusage.pr_ltime.tv_nsec / 1000000,
-                  rusage.pr_slptime.tv_sec, rusage.pr_slptime.tv_nsec / 1000000,
-                  rusage.pr_majf,
-                  rusage.pr_minf,
-                  ACE_Thread::getconcurrency ()));
-#elif defined (ACE_HAS_GETRUSAGE) && !defined (ACE_WIN32)
-      ACE_DEBUG ((LM_INFO,
-                  "\n%8d PEs\n"
-                  "%8.2f Mbit/sec\n"
-                  "%8d (voluntary context switches)\n"
-                  "%8d (involuntary context switches)\n"
-                  "%8d (total context switches)\n"
-                  "%8d.%d sec (user time)\n"
-                  "%8d.%d sec (system time)\n"
-                  "%8d (major page faults)\n"
-                  "%8d (minor page faults)\n"
-                  "%8d (number of LWPs)\n",
-                  this->thr_count (),
-                  (nbytes / et.real_time) * 8.0 / 1024.0 / 1024.0,
-                  rusage.ru_nvcsw,
-                  rusage.ru_nivcsw,
-                  rusage.ru_nvcsw + rusage.ru_nivcsw,
-                  rusage.ru_utime.tv_sec, rusage.ru_utime.tv_usec / 1000000,
-                  rusage.ru_stime.tv_sec, rusage.ru_stime.tv_usec / 1000000,
-                  rusage.ru_majflt,
-                  rusage.ru_minflt,
-                  ACE_Thread::getconcurrency ()));
-#elif defined (ACE_HAS_GETRUSAGE) && defined (ACE_WIN32)
-      // Need more stuff for Win32.
-      ACE_DEBUG ((LM_INFO,
-                  "\n%8d PEs\n"
-                  "%8.2f Mbit/sec\n"
-                  "%8d (number of LWPs)\n",
-                  this->thr_count (),
-                  (nbytes / et.real_time) * 8.0 / 1024.0 / 1024.0,
-                  ACE_Thread::getconcurrency ()));
-#endif /* ACE_HAS_PRUSAGE_T */
-    }
-  else
-    {
-      ACE_DEBUG ((LM_INFO,
-                  "\ntotal work = %d\n"
-                  "(Only interpret the next two statistics for throughput tests)\n"
-                  "%f bytes in %.2f real seconds = %.2f Mbit/sec\n"
-                  "%f bytes in %.2f CPU seconds = %.2f Mbit/sec\n",
-                  total,
-                  nbytes, et.real_time, (nbytes / et.real_time) * 8.0 / 1024.0 / 1024.0,
-                  nbytes, cpu_time, (nbytes / cpu_time) * 8.0 / 1024.0 / 1024.0));
-
-#if defined (ACE_HAS_PRUSAGE_T)
-      ACE_DEBUG ((LM_INFO,
-                  "%8d = lwpid\n"
-                  "%8d = lwp count\n"
-                  "%8d = minor page faults\n"
-                  "%8d = major page faults\n"
-                  "%8d = input blocks\n"
-                  "%8d = output blocks\n"
-                  "%8d = messages sent\n"
-                  "%8d = messages received\n"
-                  "%8d = signals received\n"
-                  "%8ds, %dms = wait-cpu (latency) time\n"
-                  "%8ds, %dms = user lock wait sleep time\n"
-                  "%8ds, %dms = all other sleep time\n"
-                  "%8d = voluntary context switches\n"
-                  "%8d = involuntary context switches\n"
-                  "%8d = total context switches\n"
-                  "%8d = system calls\n"
-                  "%8d = chars read/written\n"
-                  "%8d = number of LWPs\n"
-                  "---------------------\n"
-                  "real time   = %.3f\n"
-                  "user time   = %.3f\n"
-                  "system time = %.3f\n"
-                  "---------------------\n",
-                  rusage.pr_lwpid,
-                  rusage.pr_count,
-                  rusage.pr_minf,
-                  rusage.pr_majf,
-                  rusage.pr_inblk,
-                  rusage.pr_oublk,
-                  rusage.pr_msnd,
-                  rusage.pr_mrcv,
-                  rusage.pr_sigs,
-                  rusage.pr_wtime.tv_sec, rusage.pr_wtime.tv_nsec / 1000000,
-                  rusage.pr_ltime.tv_sec, rusage.pr_ltime.tv_nsec / 1000000,
-                  rusage.pr_slptime.tv_sec, rusage.pr_slptime.tv_nsec / 1000000,
-                  rusage.pr_vctx,
-                  rusage.pr_ictx,
-                  rusage.pr_vctx + rusage.pr_ictx,
-                  rusage.pr_sysc,
-                  rusage.pr_ioch,
-                  ACE_Thread::getconcurrency (),
-                  et.real_time, et.user_time, et.system_time));
-#elif defined (ACE_HAS_GETRUSAGE) && !defined (ACE_WIN32)
-      ACE_DEBUG ((LM_INFO,
-                  "%8d = minor page faults\n"
-                  "%8d = major page faults\n"
-                  "%8d = input blocks\n"
-                  "%8d = output blocks\n"
-                  "%8d = messages sent\n"
-                  "%8d = messages received\n"
-                  "%8d = signals received\n"
-                  "%8d = voluntary context switches\n"
-                  "%8d = involuntary context switches\n"
-                  "%8d = total context switches\n"
-                  "%8d = number of LWPs\n"
-                  "---------------------\n"
-                  "real time   = %.3f\n"
-                  "user time   = %.3f\n"
-                  "system time = %.3f\n"
-                  "---------------------\n",
-                  rusage.ru_minflt,
-                  rusage.ru_majflt,
-                  rusage.ru_inblock,
-                  rusage.ru_oublock,
-                  rusage.ru_msgsnd,
-                  rusage.ru_msgrcv,
-                  rusage.ru_nsignals,
-                  rusage.ru_nvcsw,
-                  rusage.ru_nivcsw,
-                  rusage.ru_nvcsw + rusage.ru_nivcsw,
-                  ACE_Thread::getconcurrency (),
-                  et.real_time, et.user_time, et.system_time));
-#elif defined (ACE_HAS_GETRUSAGE) && defined (ACE_WIN32)
-      // need to write more dump ops for rusage on Win32
-      ACE_DEBUG ((LM_INFO,
-                  "%8d = number of LWPs\n"
-                  "---------------------\n"
-                  "real time   = %.3f\n"
-                  "user time   = %.3f\n"
-                  "system time = %.3f\n"
-                  "---------------------\n",
-                  ACE_Thread::getconcurrency (),
-                  et.real_time, et.user_time, et.system_time));
-#endif /* ACE_HAS_PRUSAGE_T */
-    }
-  if (performance_test_options.do_eager_exit ())
-    ACE_OS::_exit (0);
-}
-#endif /* ACE_HAS_THREADS */
-
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-#if defined(ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
-template class ACE_Atomic_Op<ACE_Thread_Mutex, size_t>;
-template class ACE_Atomic_Op_Ex<ACE_Thread_Mutex, size_t>;
-#endif /* ACE_MT_SAFE */
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#if defined(ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
-#pragma instantiate ACE_Atomic_Op<ACE_Thread_Mutex, size_t>
-#pragma instantiate ACE_Atomic_Op_Ex<ACE_Thread_Mutex, size_t>
-#endif /* ACE_MT_SAFE */
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test_Options.h b/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test_Options.h
deleted file mode 100644
index 8d38e4634ca..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test_Options.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/* -*- C++ -*- */
-// $Id$
-
-// Option manager for performance tests.
-
-#ifndef _PERFORMANCE_TEST_OPTIONS_H
-#define _PERFORMANCE_TEST_OPTIONS_H
-
-#include "ace/config-all.h"
-
-#if !defined (ACE_LACKS_PRAGMA_ONCE)
-# pragma once
-#endif /* ACE_LACKS_PRAGMA_ONCE */
-
-#include "ace/Profile_Timer.h"
-#include "ace/Log_Msg.h"
-#include "ace/Thread_Manager.h"
-#include "ace/Atomic_Op.h"
-#include "ace/svc_export.h"
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Performance_Test_Options
-{
-public:
-  Performance_Test_Options (void);
-  void   parse_args (int argc, ACE_TCHAR *argv[]);
-
-  void   init (void);
-
-  void   start_timer (void);
-  void   stop_timer (void);
-
-  void   thr_count (size_t count);
-  size_t thr_count (void);
-
-  void   pipe_addr (ACE_TCHAR pipe[]);
-  ACE_TCHAR *pipe_addr (void);
-
-  void   mapped_file (ACE_TCHAR filename[]);
-  ACE_TCHAR *mapped_file (void);
-
-  void   service_entry (ACE_TCHAR *service_entry);
-  ACE_TCHAR *service_entry (void);
-
-  void   sleep_time (size_t count);
-  size_t sleep_time (void);
-
-  void   logical_connections (size_t count);
-  size_t logical_connections (void);
-
-  void   physical_connections (size_t count);
-  size_t physical_connections (void);
-
-  void   consecutive_ports (size_t count);
-  size_t consecutive_ports (void);
-
-  void   initial_queue_length (size_t length);
-  size_t initial_queue_length (void);
-
-  void   high_water_mark (size_t size);
-  size_t high_water_mark (void);
-
-  void   low_water_mark (size_t size);
-  size_t low_water_mark (void);
-
-  void   msg_size (size_t size);
-  size_t msg_size (void);
-
-  void   iterations (size_t n);
-  size_t iterations (void);
-
-  void   n_lwps (size_t n);
-  size_t n_lwps (void);
-
-  void   t_flags (long flag);
-  long   t_flags (void);
-
-  size_t count (void);
-
-  int    debug (void);
-  int    verbose (void);
-  int    do_checksum (void);
-  int    do_generate (void);
-  int    do_ack (void);
-  int    do_delete (void);
-  int    do_eager_exit (void);
-  int    do_print_summary (void);
-  int    do_udp (void);
-  int    do_xdr (void);
-  int    do_zero_copy (void);
-  void   print_results (void);
-
-  ACE_Atomic_Op<ACE_Thread_Mutex, size_t> msg_count;        // Keep track of number of messages atomically.
-  int *thr_work_count;  // Count activity per-thread.
-  int thr_wc_size;           // Max number of threads.
-
-private:
-  ACE_Profile_Timer _itimer;            // Keep track of time.
-  ACE_TCHAR     *_service_entry;        // Name of the shared object file and shared object.
-  ACE_TCHAR     *_mapped_file;          // Name of the mapped file.
-  ACE_TCHAR     *_pipe_addr;            // Name of the STREAM pipe.
-  size_t        _sleep_time;            // Time to sleep.
-  size_t        _n_lwps;                // Number of LWPs.
-  size_t        _thr_count;             // Number of threads to spawn.
-  long          _t_flags;               // Flags to thr_create().
-  size_t        _high_water_mark;       // ACE_Queue high water mark.
-  size_t        _low_water_mark;        // ACE_Queue low water mark.
-  size_t        _msg_size;              // Size of a message.
-  size_t        _initial_queue_length;  // Initial number of items in the queue.
-  size_t        _logical_connections;   // Number of logical connections.
-  size_t        _physical_connections;  // Number of physical connections.
-  size_t        _iterations;            // Number of iterations to run the test program.
-  int           _generate;              // Generate the data.
-  int           _udp;                   // Use UDP format.
-  int           _debugging;             // Extra debugging info.
-  int           _verbosity;             // Extra verbose messages.
-  int           _ack;                   // Do an acknowledgement.
-  int           _checksum;              // Is checksumming enabled?.
-  int           _xdr;                   // Is xdr conversion enabled?.
-  int           _free_memory;           // Are we freeing up memory?.
-  int           _zero_copy;             // Implement a zero-copy driver?.
-  int           _print_summary;         // Print a summary of the results only.
-  int           _consecutive_ports;     // Number of consecutive messages from same port.
-  int           _eager_exit;            // Exit eagerly, without cleaning up.
-};
-
-// Make this available to any code that wants to see it!
-extern ACE_Svc_Export Performance_Test_Options performance_test_options;
-
-#include "Performance_Test_Options.i"
-#endif /* ACE_HAS_THREADS */
-#endif /* _PERFORMANCE_TEST_OPTIONS_H */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test_Options.i b/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test_Options.i
deleted file mode 100644
index 6856edfa3cd..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/Performance_Test_Options.i
+++ /dev/null
@@ -1,269 +0,0 @@
-/* -*- C++ -*- */
-// $Id$
-
-/* Option manager for ustreams */
-
-#include "ace/Get_Opt.h"
-
-// Since this is only included in the .h file, these should be
-// remain inline, not ACE_INLINE.
-// FUZZ: disable check_for_inline
-
-
-inline int
-Performance_Test_Options::do_print_summary (void)
-{
-  return this->_print_summary;
-}
-
-inline int
-Performance_Test_Options::do_udp (void)
-{
-  return this->_udp;
-}
-
-inline void
-Performance_Test_Options::start_timer (void)
-{
-  this->_itimer.start ();
-}
-
-inline void
-Performance_Test_Options::stop_timer (void)
-{
-  this->_itimer.stop ();
-}
-
-inline int
-Performance_Test_Options::do_generate (void)
-{
-  return this->_generate;
-}
-
-inline int
-Performance_Test_Options::do_ack (void)
-{
-  return this->_ack;
-}
-
-inline int
-Performance_Test_Options::do_eager_exit (void)
-{
-  return this->_eager_exit;
-}
-
-inline int
-Performance_Test_Options::do_zero_copy (void)
-{
-  return this->_zero_copy;
-}
-
-inline int
-Performance_Test_Options::do_checksum (void)
-{
-  return this->_checksum;
-}
-
-inline int
-Performance_Test_Options::do_delete (void)
-{
-  return this->_free_memory;
-}
-
-inline int
-Performance_Test_Options::do_xdr (void)
-{
-  return this->_xdr;
-}
-
-inline void
-Performance_Test_Options::n_lwps (size_t count)
-{
-  this->_n_lwps = count;
-}
-
-inline size_t
-Performance_Test_Options::n_lwps (void)
-{
-  return this->_n_lwps;
-}
-
-inline void
-Performance_Test_Options::pipe_addr (ACE_TCHAR *pipe)
-{
-  this->_pipe_addr = pipe;
-}
-
-inline ACE_TCHAR *
-Performance_Test_Options::pipe_addr (void)
-{
-  return this->_pipe_addr;
-}
-
-inline void
-Performance_Test_Options::service_entry (ACE_TCHAR *pipe)
-{
-  this->_service_entry = pipe;
-}
-
-inline ACE_TCHAR *
-Performance_Test_Options::service_entry (void)
-{
-  return this->_service_entry;
-}
-
-inline void
-Performance_Test_Options::mapped_file (ACE_TCHAR *filename)
-{
-  this->_mapped_file = filename;
-}
-
-inline ACE_TCHAR *
-Performance_Test_Options::mapped_file (void)
-{
-  return this->_mapped_file;
-}
-
-inline void
-Performance_Test_Options::sleep_time (size_t count)
-{
-  this->_sleep_time = count;
-}
-
-inline size_t
-Performance_Test_Options::sleep_time (void)
-{
-  return this->_sleep_time;
-}
-
-inline void
-Performance_Test_Options::thr_count (size_t count)
-{
-  this->_thr_count = count;
-}
-
-inline size_t
-Performance_Test_Options::thr_count (void)
-{
-  return this->_thr_count;
-}
-
-inline void
-Performance_Test_Options::consecutive_ports (size_t count)
-{
-  this->_consecutive_ports = count;
-}
-
-inline size_t
-Performance_Test_Options::consecutive_ports (void)
-{
-  return this->_consecutive_ports;
-}
-
-inline void
-Performance_Test_Options::logical_connections (size_t count)
-{
-  this->_logical_connections = count;
-}
-
-inline size_t
-Performance_Test_Options::logical_connections (void)
-{
-  return this->_logical_connections;
-}
-
-inline void
-Performance_Test_Options::physical_connections (size_t count)
-{
-  this->_physical_connections = count;
-}
-
-inline size_t
-Performance_Test_Options::physical_connections (void)
-{
-  return this->_physical_connections;
-}
-
-inline void
-Performance_Test_Options::initial_queue_length (size_t length)
-{
-  this->_initial_queue_length = length;
-}
-
-inline size_t
-Performance_Test_Options::initial_queue_length (void)
-{
-  return this->_initial_queue_length;
-}
-
-inline void
-Performance_Test_Options::high_water_mark (size_t size)
-{
-  this->_high_water_mark = size;
-}
-
-inline size_t
-Performance_Test_Options::high_water_mark (void)
-{
-  return this->_high_water_mark;
-}
-
-inline void
-Performance_Test_Options::low_water_mark (size_t size)
-{
-  this->_low_water_mark = size;
-}
-
-inline size_t
-Performance_Test_Options::low_water_mark (void)
-{
-  return this->_low_water_mark;
-}
-
-inline void
-Performance_Test_Options::msg_size (size_t size)
-{
-  this->_msg_size = size;
-}
-
-inline size_t
-Performance_Test_Options::msg_size (void)
-{
-  return this->_msg_size;
-}
-
-inline void
-Performance_Test_Options::iterations (size_t n)
-{
-  this->_iterations = n;
-}
-
-inline size_t
-Performance_Test_Options::iterations (void)
-{
-  return this->_iterations;
-}
-
-inline void
-Performance_Test_Options::t_flags (long flag)
-{
-  this->_t_flags |= flag;
-}
-
-inline long
-Performance_Test_Options::t_flags (void)
-{
-  return this->_t_flags;
-}
-
-inline int
-Performance_Test_Options::debug (void)
-{
-  return this->_debugging;
-}
-
-inline int
-Performance_Test_Options::verbose (void)
-{
-  return this->_verbosity;
-}
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/README b/performance-tests/Synch-Benchmarks/Perf_Test/README
deleted file mode 100644
index 28f1f160e8a..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/README
+++ /dev/null
@@ -1,76 +0,0 @@
-The files in this directory support controlled benchmarking of the ACE
-synchronization mechanisms.
-
-  These mechanisms include:
-
-	. Mutexes
-	. Reader/writer locks
-	. Condition variables
-	. Semaphores
-        . Tokens
-        . Adaptive lockings
-
-There are additional tests that measure the memory bandwidth under the
-following conditions:
-
-	. User memory-to-memory copying of data within a single thread
- 	. User memory-to-kernel-to-user memory copying via pipes
-	  between separate processes, as well as between separate
-	  threads in the same process
-
-There are many options available for this module that can be put into
-svc.conf files.  See the Performance_Test_Options.[Chi] file for more
-details.  Some reasonable options to use to run the tests are:
-
- -v -B -s 15
- -v -n 4 -t 4 -s 15
-
-You should experiment with other options as you see fit.  Note that on
-Solaris, you should always make sure that you have more than 1 LWP (by
-using either the -B or the -n options) since otherwise the program may
-get into an infinite loop due to the semantics of SunOS unbound
-threads... (This may no longer be the case.)
-
-
-Available Options in Performance_Test module:
-=============================================
-
-Thread Creation:
-----------------
-      -B:    Create thread with THR_BOUND
-      -D:    Create thread with THR_DETACHED
-      -N:    Create thread with flag THR_NEW_LWP
-      -n:    Set # of lwp's (default is 0)
-      -t:    Set # of threads contending the lock (default is 4)
-
-Run Test:
----------
-      -s:    Set testing duration (in seconds, default is 100)
-      -T:    Enable/disable tracing.
-
-Misc:
------
-      -p:    Toggle whether summary is printed
-      -e:    Perform eager exit (without cleaning up)
-      -M:    Set message size in pipe_[proc|thr]_test
-
-Reserved Flags:
----------------
-      -a:    Not used.  (do_ack ???)
-      -A:    Not used.  (set rendezvous point)
-      -c:    Not used.  (# of connections)
-      -C:    Not used.  (Toggle calculate checksum)
-      -d:    Not used.  (Enable debugging)
-      -F:    Not used.  (Free memory)
-      -g:    Not used.  (generate data ??)
-      -H:    Not used.  (set high water mark)
-      -i:    Not used.  (# of iterations)
-      -L:    Not used.  (set low water mark)
-      -l:    Not used.  (set initial queue length)
-      -m:    Not used.  (set mapped file name)
-      -P:    Not used.  (set consecutive ports)
-      -S:    Not used.  (set service_entry ???)
-      -u:    Not used.  (use udp)
-      -v:    Not used.  (set display verbosely)
-      -X:    Not used.  (Use xdr conversion)
-      -Z:    Not used.  (Do zero copy)
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/Synch_Benchmarks_Perf_Test.mpc b/performance-tests/Synch-Benchmarks/Perf_Test/Synch_Benchmarks_Perf_Test.mpc
deleted file mode 100644
index e5e86e69dea..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/Synch_Benchmarks_Perf_Test.mpc
+++ /dev/null
@@ -1,9 +0,0 @@
-// -*- MPC -*-
-// $Id$
-
-project : aceexe {
-  after    += Synch_Lib
-  libs     += Synch_Lib
-  libpaths += ../Synch_Lib
-  includes += ..
-}
\ No newline at end of file
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/adaptive_mutex_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/adaptive_mutex_test.cpp
deleted file mode 100644
index 4a72ec2ac90..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/adaptive_mutex_test.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "ace/Log_Msg.h"
-#include "Adaptive_Lock_Performance_Test_Base.h"
-#include "ace/Lock_Adapter_T.h"
-
-ACE_RCSID(Synch_Benchmarks, adaptive_mutex_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Adaptive_Mutex_Test : public Adaptive_Lock_Performance_Test_Base
-{
-public:
-  virtual int init (int, ACE_TCHAR *[]);
-};
-
-int
-Adaptive_Mutex_Test::init (int, ACE_TCHAR *[])
-{
-  ACE_Lock *lock;
-  ACE_NEW_RETURN (lock,
-                  ACE_Lock_Adapter<ACE_Thread_Mutex> (),
-                  -1);
-
-  return this->set_lock (lock);
-}
-
-ACE_SVC_FACTORY_DECLARE (Adaptive_Mutex_Test)
-ACE_SVC_FACTORY_DEFINE  (Adaptive_Mutex_Test)
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class ACE_Lock_Adapter<ACE_Thread_Mutex>;
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate ACE_Lock_Adapter<ACE_Thread_Mutex>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/adaptive_recursive_lock_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/adaptive_recursive_lock_test.cpp
deleted file mode 100644
index a439127e9c4..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/adaptive_recursive_lock_test.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "ace/Log_Msg.h"
-#include "Adaptive_Lock_Performance_Test_Base.h"
-#include "ace/Lock_Adapter_T.h"
-#include "ace/Recursive_Thread_Mutex.h"
-
-ACE_RCSID(Synch_Benchmarks, adaptive_recursive_lock_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Adaptive_Recursive_Lock_Test : public Adaptive_Lock_Performance_Test_Base
-{
-public:
-  virtual int init (int, ACE_TCHAR *[]);
-};
-
-int
-Adaptive_Recursive_Lock_Test::init (int, ACE_TCHAR *[])
-{
-  ACE_Lock *lock;
-  ACE_NEW_RETURN (lock,
-                  ACE_Lock_Adapter<ACE_Recursive_Thread_Mutex> (),
-                  -1);
-
-  return this->set_lock (lock);
-}
-
-ACE_SVC_FACTORY_DECLARE (Adaptive_Recursive_Lock_Test)
-ACE_SVC_FACTORY_DEFINE  (Adaptive_Recursive_Lock_Test)
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class ACE_Lock_Adapter<ACE_Recursive_Thread_Mutex>;
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate ACE_Lock_Adapter<ACE_Recursive_Thread_Mutex>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/adaptive_sema_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/adaptive_sema_test.cpp
deleted file mode 100644
index 605d4ffb338..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/adaptive_sema_test.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "ace/Log_Msg.h"
-#include "Adaptive_Lock_Performance_Test_Base.h"
-#include "ace/Semaphore.h"
-#include "ace/Lock_Adapter_T.h"
-
-ACE_RCSID(Synch_Benchmarks, adaptive_sema_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Adaptive_Sema_Test : public Adaptive_Lock_Performance_Test_Base
-{
-public:
-  virtual int init (int, ACE_TCHAR *[]);
-
-private:
-  static ACE_Semaphore sema;
-};
-
-ACE_Semaphore Adaptive_Sema_Test::sema (1);
-
-int
-Adaptive_Sema_Test::init (int, ACE_TCHAR *[])
-{
-  ACE_Lock *lock;
-  ACE_NEW_RETURN (lock,
-                  ACE_Lock_Adapter<ACE_Semaphore> (Adaptive_Sema_Test::sema),
-                  -1);
-
-  return this->set_lock (lock);
-}
-
-ACE_SVC_FACTORY_DECLARE (Adaptive_Sema_Test)
-ACE_SVC_FACTORY_DEFINE  (Adaptive_Sema_Test)
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class ACE_Lock_Adapter<ACE_Semaphore>;
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate ACE_Lock_Adapter<ACE_Semaphore>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/condb_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/condb_test.cpp
deleted file mode 100644
index 432f741b9e7..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/condb_test.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "Performance_Test_Options.h"
-#include "Benchmark_Performance.h"
-
-ACE_RCSID(Synch_Benchmarks, condb_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Cond_Brdcast_Test : public Benchmark_Performance
-{
-public:
-  virtual int svc (void);
-
-private:
-  static ACE_Thread_Mutex mutex;
-  static int resources;
-
-  static ACE_Condition_Thread_Mutex notfull;
-  static ACE_Condition_Thread_Mutex notempty;
-};
-
-ACE_Thread_Mutex Cond_Brdcast_Test::mutex;
-int Cond_Brdcast_Test::resources;
-ACE_Condition_Thread_Mutex Cond_Brdcast_Test::notfull (Cond_Brdcast_Test::mutex);
-ACE_Condition_Thread_Mutex Cond_Brdcast_Test::notempty (Cond_Brdcast_Test::mutex);
-
-int
-Cond_Brdcast_Test::svc (void)
-{
-  int ni = this->thr_id ();
-  synch_count = 2;
-
-  // Special case for first thread...
-  if (ni == 4)
-    while (!this->done ())
-      {
-	mutex.acquire ();
-	while (resources > 0)
-	  notfull.wait ();
-	performance_test_options.thr_work_count[ni]++;
-	resources = performance_test_options.thr_count () - 1;
-	buffer++;
-	notempty.broadcast ();
-	mutex.release ();
-      }
-  else
-    while (!this->done ())
-      {
-	mutex.acquire ();
-	while (resources == 0)
-	  notempty.wait ();
-	performance_test_options.thr_work_count[ni]++;
-	buffer++;
-	if (--resources == 0)
-	  notfull.signal ();
-	mutex.release ();
-      }
-
-  /* NOTREACHED */
-  return 0;
-}
-
-ACE_SVC_FACTORY_DECLARE (Cond_Brdcast_Test)
-ACE_SVC_FACTORY_DEFINE  (Cond_Brdcast_Test)
-
-// ACE_Service_Object_Type cbt (&cond_brdcast_test, "Condition_Broadcast_Test");
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/conds_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/conds_test.cpp
deleted file mode 100644
index a930727861b..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/conds_test.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "Performance_Test_Options.h"
-#include "Benchmark_Performance.h"
-
-ACE_RCSID(Synch_Benchmarks, conds_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Cond_Signal_Test : public Benchmark_Performance
-{
-public:
-  virtual int svc (void);
-
-private:
-  static ACE_Thread_Mutex mutex;
-  static int resources;
-
-  static ACE_Condition_Thread_Mutex notfull;
-  static ACE_Condition_Thread_Mutex notempty;
-};
-
-ACE_Thread_Mutex Cond_Signal_Test::mutex;
-int Cond_Signal_Test::resources;
-ACE_Condition_Thread_Mutex Cond_Signal_Test::notfull (Cond_Signal_Test::mutex);
-ACE_Condition_Thread_Mutex Cond_Signal_Test::notempty (Cond_Signal_Test::mutex);
-
-int
-Cond_Signal_Test::svc (void)
-{
-  int ni = this->thr_id ();
-  synch_count = 2;
-
-  // This is a horrible hack and only works for Solaris threads.  This
-  // clearly needs to change...
-  if (ni == 4)
-    while (!this->done ())
-      {
-	mutex.acquire ();
-
-	while (resources > 0)
-	  notfull.wait ();
-
-	performance_test_options.thr_work_count[ni]++;
-	resources = performance_test_options.thr_count () - 1;
-	buffer++;
-	notempty.signal ();
-	mutex.release ();
-      }
-  else
-    while (!this->done ())
-      {
-	mutex.acquire ();
-	while (resources == 0)
-	  notempty.wait ();
-	performance_test_options.thr_work_count[ni]++;
-	buffer++;
-	if (--resources == 0)
-	  notfull.signal ();
-	mutex.release ();
-      }
-
-  /* NOTREACHED */
-  return 0;
-}
-
-ACE_SVC_FACTORY_DECLARE (Cond_Signal_Test)
-ACE_SVC_FACTORY_DEFINE  (Cond_Signal_Test)
-
-// ACE_Service_Object_Type cst (&cond_signal_test, "Condition_Signal_Test");
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/context_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/context_test.cpp
deleted file mode 100644
index fc4fa0dc26d..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/context_test.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "Performance_Test_Options.h"
-#include "Benchmark_Performance.h"
-
-ACE_RCSID(Synch_Benchmarks, context_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Context_Test : public Benchmark_Performance
-{
-public:
-  virtual int svc (void);
-};
-
-int
-Context_Test::svc (void)
-{
-  int ni = this->thr_id ();
-
-  synch_count = 1;
-
-  while (!this->done ())
-    {
-      ACE_Thread::yield ();
-      performance_test_options.thr_work_count[ni]++;
-    }
-
-  /* NOTREACHED */
-  return 0;
-}
-
-ACE_SVC_FACTORY_DECLARE (Context_Test)
-ACE_SVC_FACTORY_DEFINE  (Context_Test)
-
-// ACE_Service_Object_Type ct (&context_test, "Context_Test");
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/guard_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/guard_test.cpp
deleted file mode 100644
index e1824f3d4ac..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/guard_test.cpp
+++ /dev/null
@@ -1,124 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "ace/Guard_T.h"
-#include "ace/Log_Msg.h"
-#include "Performance_Test_Options.h"
-#include "Benchmark_Performance.h"
-
-ACE_RCSID(Synch_Benchmarks, mutex_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Guard_Test : public Benchmark_Performance
-{
-public:
-  enum
-  {                             // svc.conf options
-    TEST_ACE_GUARD,             // -g
-    TEST_ACE_THREAD_MUTEX_GUARD // -t
-  };
-
-  virtual int svc (void);
-  virtual int init (int, ACE_TCHAR *[]);
-
-  void test_guard (int);
-#if defined (ACE_USES_OBSOLETE_GUARD_CLASSES)
-  void test_thread_guard (int);
-#endif /* ACE_USES_OBSOLETE_GUARD_CLASSES */
-private:
-  static int guard_type_;
-  static ACE_Thread_Mutex mutex_;
-};
-
-int Guard_Test::guard_type_ = Guard_Test::TEST_ACE_GUARD;
-ACE_Thread_Mutex Guard_Test::mutex_;
-
-int
-Guard_Test::init (int argc, ACE_TCHAR *argv[])
-{
-  ACE_Get_Opt getopt (argc, argv, ACE_TEXT("gt"));
-  int c;
-
-  while ((c = getopt()) != -1)
-    {
-      switch (c)
-        {
-#if defined (ACE_USES_OBSOLETE_GUARD_CLASSES)
-        case 't':
-          Guard_Test::guard_type_ = Guard_Test::TEST_ACE_THREAD_MUTEX_GUARD;
-          break;
-#endif /* ACE_USES_OBSOLETE_GUARD_CLASSES */
-        case 'g':
-          Guard_Test::guard_type_ = Guard_Test::TEST_ACE_GUARD;
-          break;
-        default:
-          ACE_ERROR_RETURN ((LM_ERROR,
-                             "Invalid option\n"), -1);
-        }
-    }
-  return 0;
-}
-
-int
-Guard_Test::svc (void)
-{
-  // Extract out the unique thread-specific value to be used as an
-  // index...
-  int ni = this->thr_id ();
-  synch_count = 2;
-
-  switch (Guard_Test::guard_type_)
-    {
-    case Guard_Test::TEST_ACE_GUARD:
-      this->test_guard (ni);
-      break;
-#if defined (ACE_USES_OBSOLETE_GUARD_CLASSES)
-    case Guard_Test::TEST_ACE_THREAD_MUTEX_GUARD:
-      this->test_thread_guard (ni);
-      break;
-#endif /* ACE_USES_OBSOLETE_GUARD_CLASSES */
-    default:
-      return -1;
-    }
-  return 0;
-}
-
-void
-Guard_Test::test_guard (int ni)
-{
-  while (!this->done ())
-    {
-      {
-        ACE_GUARD (ACE_Thread_Mutex, _ace_mon, Guard_Test::mutex_);
-
-        performance_test_options.thr_work_count[ni]++;
-        buffer++;
-      }
-    }
-}
-
-#if defined (ACE_USES_OBSOLETE_GUARD_CLASSES)
-# define ACE_THREAD_GUARD(OBJ,LOCK) \
-  ACE_Thread_Mutex_Guard OBJ (LOCK); \
-    if (OBJ.locked () == 0) return;
-
-void
-Guard_Test::test_thread_guard (int ni)
-{
-  while (!this->done ())
-    {
-      {
-        ACE_THREAD_GUARD (_ace_mon, Guard_Test::mutex_);
-
-        performance_test_options.thr_work_count[ni]++;
-        buffer++;
-      }
-    }
-}
-#endif /* ACE_USES_OBSOLETE_GUARD_CLASSES */
-ACE_SVC_FACTORY_DECLARE (Guard_Test)
-ACE_SVC_FACTORY_DEFINE  (Guard_Test)
-
-// ACE_Service_Object_Type mut (&mutex_test, "Guard_Test");
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/memory_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/memory_test.cpp
deleted file mode 100644
index 9d0bcd6c7d1..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/memory_test.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "ace/OS_NS_string.h"
-#include "ace/Log_Msg.h"
-#include "Performance_Test_Options.h"
-#include "Benchmark_Performance.h"
-
-ACE_RCSID(Synch_Benchmarks, memory_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Memory_Test : public Benchmark_Performance
-{
-public:
-  virtual int svc (void);
-};
-
-int
-Memory_Test::svc (void)
-{
-  int ni = this->thr_id ();
-  size_t length = performance_test_options.msg_size ();
-  char	 *from  = new char[length];
-  char	 *to    = new char[length];
-
-  synch_count = 1;
-
-  while (!this->done ())
-    {
-      ACE_OS::memcpy (to, from, length);
-      performance_test_options.thr_work_count[ni]++;
-    }
-  /* NOTREACHED */
-  return 0;
-}
-
-ACE_SVC_FACTORY_DECLARE (Memory_Test)
-ACE_SVC_FACTORY_DEFINE  (Memory_Test)
-
-// ACE_Service_Object_Type mt (&memory_test, "Memory_Test");
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/mutex_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/mutex_test.cpp
deleted file mode 100644
index c1e0a1e0ad0..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/mutex_test.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "Performance_Test_Options.h"
-#include "Benchmark_Performance.h"
-
-ACE_RCSID(Synch_Benchmarks, mutex_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Mutex_Test : public Benchmark_Performance
-{
-public:
-  virtual int svc (void);
-
-private:
-  static ACE_Thread_Mutex mutex;
-};
-
-ACE_Thread_Mutex Mutex_Test::mutex;
-
-int
-Mutex_Test::svc (void)
-{
-  // Extract out the unique thread-specific value to be used as an
-  // index...
-  int ni = this->thr_id ();
-  synch_count = 2;
-
-  while (!this->done ())
-    {
-      mutex.acquire ();
-      performance_test_options.thr_work_count[ni]++;
-      buffer++;
-      mutex.release ();
-    }
-  /* NOTREACHED */
-  return 0;
-}
-
-ACE_SVC_FACTORY_DECLARE (Mutex_Test)
-ACE_SVC_FACTORY_DEFINE  (Mutex_Test)
-
-// ACE_Service_Object_Type mut (&mutex_test, "Mutex_Test");
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/pipe_proc_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/pipe_proc_test.cpp
deleted file mode 100644
index 10bed9b88f3..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/pipe_proc_test.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "ace/OS_NS_stdio.h"
-#include "ace/OS_NS_unistd.h"
-#include "Performance_Test_Options.h"
-#include "Benchmark_Performance.h"
-
-ACE_RCSID(Synch_Benchmarks, pipe_proc_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Pipe_Proc_Test : public Benchmark_Performance
-{
-public:
-  int init (int, ACE_TCHAR **);
-  virtual int svc (void);
-
-private:
-  ACE_HANDLE pipe_handles[2];
-
-  void reader (ACE_HANDLE handle);
-};
-
-int
-Pipe_Proc_Test::init (int, ACE_TCHAR **)
-{
-  synch_count = 1;
-
-  if (ACE_OS::pipe (this->pipe_handles) == -1)
-    ACE_OS::perror (ACE_TEXT("pipe")), ACE_OS::exit (1);
-
-  switch (ACE_OS::fork ())
-    {
-    case -1:
-      ACE_OS::perror (ACE_TEXT("fork")), ACE_OS::exit (1);
-    case 0:
-      this->reader (pipe_handles[0]);
-      /* NOTREACHED */
-      break;
-    default:
-      break;
-    }
-  return 1;
-}
-
-void
-Pipe_Proc_Test::reader (ACE_HANDLE handle)
-{
-  int  ni = this->thr_id ();
-  int length = performance_test_options.msg_size ();
-  char *to;
-
-  ACE_NEW (to, char[length]);
-
-  while (ACE_OS::read (handle, to, length) > 0)
-    performance_test_options.thr_work_count[ni]++;
-}
-
-
-int
-Pipe_Proc_Test::svc (void)
-{
-  ssize_t length = performance_test_options.msg_size ();
-  int ni = this->thr_id ();
-  ACE_HANDLE handle = this->pipe_handles[1];
-  char *from;
-
-  ACE_NEW_RETURN (from, char[length], -1);
-
-  while (!this->done ())
-    if (ACE_OS::write (handle, from, length) == length)
-      performance_test_options.thr_work_count[ni]++;
-    else
-      ACE_OS::perror (ACE_TEXT("write"));
-
-  ACE_OS::close (this->pipe_handles[0]);
-  ACE_OS::close (this->pipe_handles[1]);
-  return 0;
-}
-
-ACE_SVC_FACTORY_DECLARE (Pipe_Proc_Test)
-ACE_SVC_FACTORY_DEFINE  (Pipe_Proc_Test)
-
-// ACE_Service_Object_Type ppt (&pipe_proc_test, "Pipe_Proc_Test");
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/pipe_thr_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/pipe_thr_test.cpp
deleted file mode 100644
index 895b5a846fe..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/pipe_thr_test.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "ace/OS_NS_stdio.h"
-#include "ace/OS_NS_unistd.h"
-#include "ace/Thread_Manager.h"
-#include "Performance_Test_Options.h"
-#include "Benchmark_Performance.h"
-
-ACE_RCSID(Synch_Benchmarks, pipe_thr_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Pipe_Thr_Test : public Benchmark_Performance
-{
-public:
-  virtual int init (int, ACE_TCHAR **);
-  virtual int svc (void);
-
-private:
-  ACE_HANDLE pipe_handles[2];
-
-  static void *reader (Pipe_Thr_Test *);
-};
-
-void *
-Pipe_Thr_Test::reader (Pipe_Thr_Test *t)
-{
-  ACE_HANDLE handle = t->pipe_handles[0];
-  int ni = t->thr_id ();
-  size_t length = performance_test_options.msg_size ();
-  char *to;
-  ACE_NEW_RETURN (to, char[length], 0);
-
-  while (ACE_OS::read (handle, to, length) > 0)
-    performance_test_options.thr_work_count[ni]++;
-
-  return 0;
-}
-
-int
-Pipe_Thr_Test::init (int, ACE_TCHAR **)
-{
-  synch_count = 1;
-
-  if (ACE_OS::pipe (this->pipe_handles) == -1)
-    ACE_OS::perror (ACE_TEXT("pipe")), ACE_OS::exit (1);
-
-  if (ACE_Thread_Manager::instance ()->spawn
-      (ACE_THR_FUNC (Pipe_Thr_Test::reader),
-       (void *) this, performance_test_options.t_flags ()) == -1)
-    ACE_OS::perror (ACE_TEXT("thr_create")), ACE_OS::exit (1);
-
-  return 1;
-}
-
-int
-Pipe_Thr_Test::svc (void)
-{
-  ssize_t length = performance_test_options.msg_size ();
-  ACE_HANDLE handle = this->pipe_handles[1];
-  char *from;
-  ACE_NEW_RETURN (from, char[length], -1);
-
-  while (!this->done ())
-    if (ACE_OS::write (handle, from, length) != length)
-      ACE_OS::perror (ACE_TEXT("write"));
-
-  ACE_OS::close (this->pipe_handles[0]);
-  ACE_OS::close (this->pipe_handles[1]);
-
-  return 0;
-}
-
-ACE_SVC_FACTORY_DECLARE (Pipe_Thr_Test)
-ACE_SVC_FACTORY_DEFINE  (Pipe_Thr_Test)
-
-// ACE_Service_Object_Type ptt (&pipe_thr_test, "Pipe_Thr_Test");
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/recursive_lock_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/recursive_lock_test.cpp
deleted file mode 100644
index 6246835ee88..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/recursive_lock_test.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "ace/Recursive_Thread_Mutex.h"
-#include "Performance_Test_Options.h"
-#include "Benchmark_Performance.h"
-
-ACE_RCSID(Synch_Benchmarks, recursive_lock_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Recursive_Lock_Test : public Benchmark_Performance
-{
-public:
-  virtual int svc (void);
-
-private:
-  static ACE_Recursive_Thread_Mutex mutex;
-};
-
-ACE_Recursive_Thread_Mutex Recursive_Lock_Test::mutex;
-
-int
-Recursive_Lock_Test::svc (void)
-{
-  int ni = this->thr_id ();
-  synch_count = 2;
-
-  while (!this->done ())
-    {
-      this->mutex.acquire ();
-      performance_test_options.thr_work_count[ni]++;
-      buffer++;
-      this->mutex.release ();
-    }
-  /* NOTREACHED */
-  return 0;
-}
-
-ACE_SVC_FACTORY_DECLARE (Recursive_Lock_Test)
-ACE_SVC_FACTORY_DEFINE  (Recursive_Lock_Test)
-
-// ACE_Service_Object_Type rlt (&recursive_lock_test, "Recursive_Lock_Test");
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/rwrd_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/rwrd_test.cpp
deleted file mode 100644
index a0eb5c6cff8..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/rwrd_test.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "ace/RW_Mutex.h"
-#include "Performance_Test_Options.h"
-#include "Benchmark_Performance.h"
-
-ACE_RCSID(Synch_Benchmarks, rwrd_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export RWRD_Test : public Benchmark_Performance
-{
-public:
-  virtual int svc (void);
-
-private:
-  static ACE_RW_Mutex rw_lock;
-};
-
-ACE_RW_Mutex RWRD_Test::rw_lock;
-
-int
-RWRD_Test::svc (void)
-{
-  int ni = this->thr_id ();
-  synch_count = 2;
-
-  while (!this->done ())
-    {
-      rw_lock.acquire_read ();
-      performance_test_options.thr_work_count[ni]++;
-      buffer++;
-      rw_lock.release ();
-    }
-
-  /* NOTREACHED */
-  return 0;
-}
-
-ACE_SVC_FACTORY_DECLARE (RWRD_Test)
-ACE_SVC_FACTORY_DEFINE  (RWRD_Test)
-
-// ACE_Service_Object_Type rwrdt (&rwrd_test, "RWRD_Mutex_Test");
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/rwwr_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/rwwr_test.cpp
deleted file mode 100644
index 1c7a25eae1f..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/rwwr_test.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "ace/RW_Mutex.h"
-#include "Performance_Test_Options.h"
-#include "Benchmark_Performance.h"
-
-ACE_RCSID(Synch_Benchmarks, rwwr_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export RWWR_Test : public Benchmark_Performance
-{
-public:
-  virtual int svc (void);
-
-private:
-  static ACE_RW_Mutex rw_lock;
-};
-
-ACE_RW_Mutex RWWR_Test::rw_lock;
-
-int
-RWWR_Test::svc (void)
-{
-  int ni = this->thr_id ();
-  synch_count = 2;
-
-  while (!this->done ())
-    {
-      rw_lock.acquire_write ();
-      performance_test_options.thr_work_count[ni]++;
-      buffer++;
-      rw_lock.release ();
-    }
-
-  /* NOTREACHED */
-  return 0;
-}
-
-ACE_SVC_FACTORY_DECLARE (RWWR_Test)
-ACE_SVC_FACTORY_DEFINE  (RWWR_Test)
-
-// ACE_Service_Object_Type rwwrt (&rwwr_test, "RWWR_Mutext_Test");
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/sema_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/sema_test.cpp
deleted file mode 100644
index 9f1d7657139..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/sema_test.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "Performance_Test_Options.h"
-#include "Benchmark_Performance.h"
-#include "ace/Semaphore.h"
-
-ACE_RCSID(Synch_Benchmarks, sema_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Sema_Test : public Benchmark_Performance
-{
-public:
-  virtual int svc (void);
-
-private:
-  static ACE_Semaphore sema;
-};
-
-ACE_Semaphore Sema_Test::sema (1);
-
-int
-Sema_Test::svc (void)
-{
-  int ni      = this->thr_id ();
-  synch_count = 2;
-
-  while (!this->done ())
-    {
-      sema.acquire ();
-      performance_test_options.thr_work_count[ni]++;
-      buffer++;
-      sema.release ();
-    }
-
-  /* NOTREACHED */
-  return 0;
-}
-
-ACE_SVC_FACTORY_DECLARE (Sema_Test)
-ACE_SVC_FACTORY_DEFINE  (Sema_Test)
-
-// ACE_Service_Object_Type semt (&sema_test, "Semaphore_Test");
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/sysvsema_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/sysvsema_test.cpp
deleted file mode 100644
index 5899e4f1a75..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/sysvsema_test.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "ace/SV_Semaphore_Simple.h"
-#include "Performance_Test_Options.h"
-#include "Benchmark_Performance.h"
-
-ACE_RCSID(Synch_Benchmarks, sysvsema_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export SYSVSema_Test : public Benchmark_Performance
-{
-public:
-  virtual int init (int, ACE_TCHAR *[]);
-  virtual int fini (void);
-  virtual int svc (void);
-
-private:
-  static ACE_SV_Semaphore_Simple *sema;
-};
-
-
-ACE_SV_Semaphore_Simple *SYSVSema_Test::sema = 0;
-
-int
-SYSVSema_Test::init (int, ACE_TCHAR *[])
-{
-#if defined (ACE_HAS_SYSV_IPC)
-  ACE_NEW_RETURN (SYSVSema_Test::sema, ACE_SV_Semaphore_Simple ((key_t) 1234), -1);
-  return 0;
-#else
-  ACE_ERROR_RETURN ((LM_ERROR, "SysV Semaphore not supported on this platform.\n"), -1);
-#endif /* ACE_HAS_SYSV_IPC */
-}
-
-int
-SYSVSema_Test::fini (void)
-{
-  delete SYSVSema_Test::sema;
-  return 0;
-}
-
-int
-SYSVSema_Test::svc (void)
-{
-  int ni      = this->thr_id ();
-  synch_count = 2;
-
-  while (!this->done ())
-    {
-      SYSVSema_Test::sema->acquire ();
-      performance_test_options.thr_work_count[ni]++;
-      buffer++;
-      SYSVSema_Test::sema->release ();
-    }
-
-  SYSVSema_Test::sema->remove ();
-  /* NOTREACHED */
-  return 0;
-}
-
-ACE_SVC_FACTORY_DECLARE (SYSVSema_Test)
-ACE_SVC_FACTORY_DEFINE  (SYSVSema_Test)
-
-// ACE_Service_Object_Type st (&sysvsema_test, "SYSVSema_Test");
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Perf_Test/token_test.cpp b/performance-tests/Synch-Benchmarks/Perf_Test/token_test.cpp
deleted file mode 100644
index fe66740feca..00000000000
--- a/performance-tests/Synch-Benchmarks/Perf_Test/token_test.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-// $Id$
-
-#define  ACE_BUILD_SVC_DLL
-#include "ace/Token.h"
-#include "Performance_Test_Options.h"
-#include "Benchmark_Performance.h"
-
-ACE_RCSID(Synch_Benchmarks, token_test, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-class ACE_Svc_Export Token_Test : public Benchmark_Performance
-{
-public:
-  virtual int svc (void);
-
-private:
-  static ACE_Token token;
-};
-
-ACE_Token Token_Test::token;
-
-int
-Token_Test::svc (void)
-{
-  // Extract out the unique thread-specific value to be used as an
-  // index...
-  int ni = this->thr_id ();
-  synch_count = 2;
-
-  while (!this->done ())
-    {
-      token.acquire ();
-      performance_test_options.thr_work_count[ni]++;
-      buffer++;
-      token.release ();
-    }
-  /* NOTREACHED */
-  return 0;
-}
-
-ACE_SVC_FACTORY_DECLARE (Token_Test)
-ACE_SVC_FACTORY_DEFINE  (Token_Test)
-
-// ACE_Service_Object_Type tok (&token_test, "Token_Test");
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/README b/performance-tests/Synch-Benchmarks/README
deleted file mode 100644
index c902ecab244..00000000000
--- a/performance-tests/Synch-Benchmarks/README
+++ /dev/null
@@ -1,46 +0,0 @@
-This directory contains a program for benchmarking various
-synchronization and concurrent programming mechanisms in ACE.
-
-To build the program, do a make on the top level Makefile (or,
-on NT, open Synch_Tests.dsw and build evey project in it.)
-There are several modules which perform different benchmarking
-measurements in subdirectories.  Here is a short description of all
-the subdirectories:
-
-  Synch_lib:    This directory contains interface definitions required
-                by both main program (synch_driver) and other modules.
-  Base_Test:    This directory contains a set of baseline tests.  They
-                measure the time to obtain a lock without contension,
-                or trying to objtain a lock with contension.
-  Perf_Test:    This directory contains a set of performance tests.
-                They measure the opeation performed by spawning a
-                bunch of threads and let these threads compete with
-                each other in obtaining a lock.
-
-There'll always be a "Method" object in each module subdirectory.
-They defines the method used in benchmarking and usually takes some
-options which can be defined in the 'svc.conf' file.  Beside from this
-"Method" object, there are also a lot of "Test" objects that define
-the mechanism to be tested.
-
-Executing the program:  the synch_driver performs various benchmarking
-according to the "script" defined in 'svc.conf' file.  All command
-line options applicable to ACE's Service_Config class can be used.
-
-The entries in svc.conf file are always in groups.  Each group
-consists of several svc.conf entries.  The first entry in each group
-is the "Method" entry which defines the methodology used in the test.
-The rest of the entries are "Test" entries which define the mechanism
-to be test using the "Method".
-
-At this moment, you can not have entries with the same object (either
-"Method" object or "Test" object) in one svc.conf file.  Therefore, at
-this moment, there can only be two groups in the svc.conf.  Of them,
-each "Test" can only be performed once.  Therefore, there's no way to
-benchmark using the same method with differnt configurations within
-the same svc.conf file.  However, this can be easily overcome by
-defining multiple svc.conf files and invoking the synch_driver with
-different svc.conf file.
-
-There'll be more detailed description about how a "Method" object can
-be configured in respective subdirectory.
\ No newline at end of file
diff --git a/performance-tests/Synch-Benchmarks/Synch_Benchmarks.mpc b/performance-tests/Synch-Benchmarks/Synch_Benchmarks.mpc
deleted file mode 100644
index 5c1492dc75b..00000000000
--- a/performance-tests/Synch-Benchmarks/Synch_Benchmarks.mpc
+++ /dev/null
@@ -1,11 +0,0 @@
-// -*- MPC -*-
-// $Id$
-
-project : aceexe {
-  after    += Synch_Lib
-  libs     += Synch_Lib
-  libpaths += Synch_Lib
-  source_files {
-    synch_driver.cpp
-  }
-}
\ No newline at end of file
diff --git a/performance-tests/Synch-Benchmarks/Synch_Lib/Benchmark_Base.cpp b/performance-tests/Synch-Benchmarks/Synch_Lib/Benchmark_Base.cpp
deleted file mode 100644
index 720e5fb8b29..00000000000
--- a/performance-tests/Synch-Benchmarks/Synch_Lib/Benchmark_Base.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-// $Id$
-
-#if !defined (SYNCHLIB_BUILD_DLL)
-#define  SYNCHLIB_BUILD_DLL
-#endif /* SYNCHLIB_BUILD_DLL */
-
-#include "ace/Log_Msg.h"
-#include "Benchmark_Base.h"
-
-ACE_RCSID(Synch_Benchmarks, Benchmark_Base, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-
-// Initialize the static variables.
-/* static */
-
-Benchmark_Base::Benchmark_Base (int type)
-  : benchmark_type_ (type)
-{
-}
-
-int
-Benchmark_Base::benchmark_type (void)
-{
-  return this->benchmark_type_;
-}
-
-int
-Benchmark_Base::thr_id (void)
-{
-#if defined (ACE_HAS_PTHREADS) || defined (ACE_HAS_DCETHREADS) || defined (VXWORKS)
-  // This invokes the thread-specific storage smart pointer.
-  return this->id_->thr_id ();
-#else
-  return ACE_Thread::self ();
-#endif /* ACE_HAS_PTHREADS || ACE_HAS_DCETHREADS || VXWORKS */
-}
-
-Benchmark_Method_Base::Benchmark_Method_Base (void)
-  : Benchmark_Base (Benchmark_Base::METHOD)
-{
-}
-
-int
-Benchmark_Method_Base::exec (ACE_Service_Repository_Iterator *sri)
-{
-  sri->advance ();
-  for (const ACE_Service_Type *sr;
-       sri->next (sr) != 0;
-       sri->advance ())
-    {
-      // This would greatly benefit from RTTI typesafe downcasting...
-      const ACE_Service_Type_Impl *type = sr->type ();
-      const void *obj = type->object ();
-      ACE_Service_Object *so = (ACE_Service_Object *) obj;
-      Benchmark_Base *bp = (Benchmark_Base *) so;
-
-      if (this->valid_test_object (bp))
-        {
-
-          ACE_DEBUG ((LM_DEBUG, "\nstarting up %s\n", sr->name ()));
-
-          int notused = this->pre_run_test (bp) == 0 && this->run_test () == 0 &&
-            this->post_run_test () == 0;
-          notused = notused;
-        }
-      else
-        return 0;
-    }
-  return 0;
-}
-
-#if defined (ACE_HAS_PTHREADS) || defined (ACE_HAS_DCETHREADS) || defined (VXWORKS)
-/* static */
-MT_INT Thr_ID::thread_id_ (0);
-
-Thr_ID::Thr_ID (void)
-  : thr_id_ (++Thr_ID::thread_id_)
-{
-}
-
-int
-Thr_ID::thr_id (void)
-{
-  return this->thr_id_;
-}
-
-void
-Thr_ID::thr_id (int i)
-{
-  this->thr_id_ = i;
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class ACE_TSS<Thr_ID>;
-template class ACE_Atomic_Op<ACE_Thread_Mutex, int>;
-template class ACE_Atomic_Op_Ex<ACE_Thread_Mutex, int>;
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate ACE_TSS<Thr_ID>
-#pragma instantiate ACE_Atomic_Op<ACE_Thread_Mutex, int>
-#pragma instantiate ACE_Atomic_Op_Ex<ACE_Thread_Mutex, int>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-#endif /* ACE_HAS_PTHREADS || ACE_HAS_DCETHREADS || VXWORKS */
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/Synch-Benchmarks/Synch_Lib/Benchmark_Base.h b/performance-tests/Synch-Benchmarks/Synch_Lib/Benchmark_Base.h
deleted file mode 100644
index 1737d45b36f..00000000000
--- a/performance-tests/Synch-Benchmarks/Synch_Lib/Benchmark_Base.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/* -*- C++ -*- */
-// $Id$
-
-/* Defines the base class used to dynamically link in the benchmark tests */
-
-#ifndef ACE_BENCHMARK_BASE_H
-# define ACE_BENCHMARK_BASE_H
-
-# include "ace/Service_Config.h"
-
-#if !defined (ACE_LACKS_PRAGMA_ONCE)
-# pragma once
-#endif /* ACE_LACKS_PRAGMA_ONCE */
-
-# include "ace/Service_Repository.h"
-# include "ace/Service_Types.h"
-# include "ace/Atomic_Op.h"
-# include "export_mac.h"
-# include "ace/TSS_T.h"
-
-# if defined (ACE_HAS_THREADS)
-
-#   if defined (ACE_HAS_PTHREADS) || defined (ACE_HAS_DCETHREADS) || defined (VXWORKS)
-
-typedef ACE_Atomic_Op<ACE_Thread_Mutex, int> MT_INT;
-
-class Thr_ID
-  // TITLE
-  //   A simple class that provides a thread-specific value in order
-  //   to compensate for POSIX Pthreads.
-  //
-  // DESCRIPTION
-  //   Pthreads are too lame to have a sensible scalar values for the
-  //   thread id (unlike Solaris threads).   Therefore, we have to
-  //   emulate this ourselves with this class (gag).
-{
-public:
-  Thr_ID (void);
-  int thr_id (void);
-  void thr_id (int);
-
-private:
-  int thr_id_;
-  static MT_INT thread_id_;
-};
-#   endif /* ACE_HAS_PTHREADS || ACE_HAS_DCETHREADS || VXWORKS */
-
-class SYNCHLIB_Export Benchmark_Base : public ACE_Service_Object
-{
-  // = TITLE
-  //     Base class for all benchmarking objects.
-  //
-  // = DESCRIPTION
-  //     This class is the base class for all benchmarking
-  //     classes.  Its major functionalities are to privide RTTI
-  //     information and to define other common methods all
-  //     benchmarking classes should support.
-public:
-  enum {
-    BENCHMARK_BASE,
-    METHOD,
-    BASELINE,
-    PERFORMANCE
-  };
-
-  int benchmark_type (void);
-  // RTTI information of this module.
-
-  int thr_id (void);
-  // Returns our thread id;
-
-protected:
-  Benchmark_Base (int type = BENCHMARK_BASE);
-  // Default ctor.
-
-  int benchmark_type_;
-  // Store the RTTI info of this module.
-
-#   if defined (ACE_HAS_PTHREADS) || defined (ACE_HAS_DCETHREADS) || defined (VXWORKS)
-  ACE_TSS <Thr_ID> id_;
-  // Keeps track of our "virtual" thread id...
-#   endif /* ACE_HAS_PTHREADS || ACE_HAS_DCETHREADS || VXWORKS */
-};
-
-class SYNCHLIB_Export Benchmark_Method_Base : public Benchmark_Base
-{
-  // = TITLE
-  //     This class identifies itself as Benmarking Method class.
-  //     It defines a method as of how the test is setup and measured.
-public:
-  int exec (ACE_Service_Repository_Iterator *sri);
-  // Run the test and advanced the service repository iterator
-
-  virtual int pre_run_test (Benchmark_Base *bp) = 0;
-  // Before running the real test.  Subclasses implement this method
-  // to dictate how the test is performed.
-
-  virtual int run_test (void) = 0;
-  // Run the real test.  Subclasses implement this method to
-  // dictate how the test is performed.
-
-  virtual int post_run_test (void) = 0;
-  // After running the real test.  Subclasses implement this method to
-  // dictate how the test is performed.
-
-  virtual int valid_test_object (Benchmark_Base *) = 0;
-  // Check if we got a valid test to perform.
-
-protected:
-  Benchmark_Method_Base (void);
-};
-
-# endif /* ACE_HAS_THREADS */
-#endif /* ACE_BENCHMARK_BASE_H */
diff --git a/performance-tests/Synch-Benchmarks/Synch_Lib/README b/performance-tests/Synch-Benchmarks/Synch_Lib/README
deleted file mode 100644
index f17fe39234a..00000000000
--- a/performance-tests/Synch-Benchmarks/Synch_Lib/README
+++ /dev/null
@@ -1,4 +0,0 @@
-This subdirectory contains a library that defines the interface used
-by all benchmarking modules.  The library is required by all modules
-and the synch_driver.  If you want to develop your own benchmarking
-module, this directory provides a starting point.
diff --git a/performance-tests/Synch-Benchmarks/Synch_Lib/Synch_Benchmarks_Synch_Lib.mpc b/performance-tests/Synch-Benchmarks/Synch_Lib/Synch_Benchmarks_Synch_Lib.mpc
deleted file mode 100644
index 0cf7df2601e..00000000000
--- a/performance-tests/Synch-Benchmarks/Synch_Lib/Synch_Benchmarks_Synch_Lib.mpc
+++ /dev/null
@@ -1,7 +0,0 @@
-// -*- MPC -*-
-// $Id$
-
-project(Synch_Lib) : aceexe {
-  sharedname = Synch_Lib
-  dynamicflags += SYNCHLIB_BUILD_DLL
-}
\ No newline at end of file
diff --git a/performance-tests/Synch-Benchmarks/Synch_Lib/export_mac.h b/performance-tests/Synch-Benchmarks/Synch_Lib/export_mac.h
deleted file mode 100644
index e4e6be63334..00000000000
--- a/performance-tests/Synch-Benchmarks/Synch_Lib/export_mac.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// -*- C++ -*-
-// $Id$
-// Definition for Win32 Export directives.
-// This file is generated automatically by
-// ${ACE_ROOT}/GenExportH.BAT
-// ------------------------------
-#if !defined (SYNCHLIB_EXPORT_H)
-#define SYNCHLIB_EXPORT_H
-
-#include "ace/config-all.h"
-
-#if defined (ACE_AS_STATIC_LIBS) && !defined (SYNCHLIB_HAS_DLL)
-#  define SYNCHLIB_HAS_DLL 0
-#endif /* ACE_AS_STATIC_LIBS && ! TEST_HAS_DLL */
-
-#if !defined (SYNCHLIB_HAS_DLL)
-#define SYNCHLIB_HAS_DLL 1
-#endif /* !SYNCHLIB_HAS_DLL */
-
-#if defined (SYNCHLIB_HAS_DLL)
-#  if (SYNCHLIB_HAS_DLL == 1)
-#    if defined (SYNCHLIB_BUILD_DLL)
-#      define SYNCHLIB_Export ACE_Proper_Export_Flag
-#      define SYNCHLIB_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T)
-#    else
-#      define SYNCHLIB_Export ACE_Proper_Import_Flag
-#      define SYNCHLIB_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T)
-#    endif /* SYNCHLIB_BUILD_DLL */
-#  else
-#    define SYNCHLIB_Export
-#    define SYNCHLIB_SINGLETON_DECLARATION(T)
-#  endif   /* ! SYNCHLIB_HAS_DLL == 1 */
-#else
-#  define SYNCHLIB_Export
-#  define SYNCHLIB_SINGLETON_DECLARATION(T)
-#endif     /* SYNCHLIB_HAS_DLL */
-
-#endif     /* SYNCHLIB_EXPORT_H */
-// End of auto generated file.
-
diff --git a/performance-tests/Synch-Benchmarks/benchmarks b/performance-tests/Synch-Benchmarks/benchmarks
deleted file mode 100644
index 5b3a6644bc5..00000000000
--- a/performance-tests/Synch-Benchmarks/benchmarks
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/bin/csh -f
-
-echo "Memory test = 512, 40M"
-./memory_test -i 80000 -M 512
-echo "Memory test = 1024, 40M"
-./memory_test -i 40000 -M 1024
-echo "Memory test = 2048, 40M"
-./memory_test -i 20000 -M 2048
-echo "Memory test = 4096, 40M"
-./memory_test -i 10000 -M 4096
-
-echo "Pipe test = 512, 40M"
-./pipe_test -i 80000 -M 512
-echo "Pipe test = 1024, 40M"
-./pipe_test -i 40000 -M 1024
-echo "Pipe test = 2048, 40M"
-./pipe_test -i 20000 -M 2048
-echo "Pipe test = 4096, 40M"
-./pipe_test -i 10000 -M 4096
diff --git a/performance-tests/Synch-Benchmarks/context.c b/performance-tests/Synch-Benchmarks/context.c
deleted file mode 100644
index a5a6e577b12..00000000000
--- a/performance-tests/Synch-Benchmarks/context.c
+++ /dev/null
@@ -1,73 +0,0 @@
-/* $Id$ */
-#include <stdio.h>
-// @(#)context.c	1.1	10/18/96
-
-#include <stdlib.h>
-#include <thread.h>
-
-#define NSLEEP 100
-#define TMAX 2
-int count[TMAX];
-
-void *
-work (void *n)
-{
-  int ni = (int) n;
-
-  while (1)
-    {
-      thr_yield ();
-      count[ni]++;
-    }
-  return 0;
-}
-
-main (int argc, char *argv[])
-{
-  int ncorr, t1arg, t0arg, orig_ncorr;
-  thread_t tid1, tid0;
-  float rate;
-
-  if (argc != 6)
-    {
-      printf ("usage: %s t0_bound t0_new_lwp t1_bound t1_new_lwp ncorr\n", argv[0]);
-      exit (1);
-    }
-  t0arg = THR_DETACHED;
-  if (atoi (argv[1]))
-    t0arg |= THR_BOUND;
-  if (atoi (argv[2]))
-    t0arg |= THR_NEW_LWP;
-
-  t1arg = THR_DETACHED;
-  if (atoi (argv[3]))
-    t1arg |= THR_BOUND;
-  if (atoi (argv[4]))
-    t1arg |= THR_NEW_LWP;
-
-  ncorr = atoi (argv[5]);
-
-  if (thr_create (NULL, 0, work, 0, t0arg, &tid0) != 0)
-    perror ("couldn't create thread 0");
-  if (thr_create (NULL, 0, work, (void *) 1, t1arg, &tid1) != 0)
-    perror ("couldn't create thread 1");
-
-  orig_ncorr = thr_getconcurrency ();
-  if (ncorr)
-    thr_setconcurrency (ncorr);
-  sleep (NSLEEP);
-  rate = (count[0] + count[1]) / ((float) NSLEEP);
-    printf ("\n------------------------------------------------------------------------\n");
-  printf ("t0arg 0x%x (%s, %s, %s)\nt1arg 0x%x (%s, %s, %s)\ncount[0] %d count[1] %d\n\
-ncorr_orig %d ncorr_set %d ncorr_end %d rate %.3f per_cxt %.2f usec\n",
-	  t0arg,
-	  (t0arg & THR_DETACHED) ? "THR_DETACHED" : "Not Detached",
-	  (t0arg & THR_BOUND) ? "THR_BOUND" : "Not Bound",
-	  (t0arg & THR_NEW_LWP) ? "THR_NEW_LWP" : "No New_LWP",
-	  t1arg,
-	  (t1arg & THR_DETACHED) ? "THR_DETACHED" : "Not Detached",
-	  (t1arg & THR_BOUND) ? "THR_BOUND" : "Not Bound",
-	  (t1arg & THR_NEW_LWP) ? "THR_NEW_LWP" : "No New_LWP",
-	  count[0], count[1],
-	  orig_ncorr, ncorr, thr_getconcurrency (), rate, 1.0e6 / rate);
-}
diff --git a/performance-tests/Synch-Benchmarks/context.csh b/performance-tests/Synch-Benchmarks/context.csh
deleted file mode 100644
index 867611f07e1..00000000000
--- a/performance-tests/Synch-Benchmarks/context.csh
+++ /dev/null
@@ -1,16 +0,0 @@
-#/bin/csh -f
-time ./context 0 0 0 0 0
-time ./context 0 0 0 0 2
-time ./context 0 0 0 0 3
-
-time ./context 1 0 1 0 0
-time ./context 1 0 1 0 2
-time ./context 1 0 1 0 3
-
-time ./context 0 1 0 1 0
-time ./context 0 1 0 1 2
-time ./context 0 1 0 1 3
-
-time ./context 1 1 1 1 0
-time ./context 1 1 1 1 2
-time ./context 1 1 1 1 3
diff --git a/performance-tests/Synch-Benchmarks/orig-results b/performance-tests/Synch-Benchmarks/orig-results
deleted file mode 100644
index 9d4389005f1..00000000000
--- a/performance-tests/Synch-Benchmarks/orig-results
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
-   --------------------- results -------------------------------------
-   t0arg 0x40 (THR_DETACHED, Not Bound, No New_LWP)
-   t1arg 0x40 (THR_DETACHED, Not Bound, No New_LWP)
-   count[0] 2222061 count[1] 2222061
-   ncorr_orig 1 ncorr_set 0 ncorr_end 2 rate 22070.520 per_cxt 45.31 usec
-
-   ------------------------------------------------------------------------
-   t0arg 0x40 (THR_DETACHED, Not Bound, No New_LWP)
-   t1arg 0x40 (THR_DETACHED, Not Bound, No New_LWP)
-   count[0] 3979311 count[1] 3824273
-   ncorr_orig 1 ncorr_set 2 ncorr_end 2 rate 38975.535 per_cxt 25.66 usec
-
-   ------------------------------------------------------------------------
-   t0arg 0x40 (THR_DETACHED, Not Bound, No New_LWP)
-   t1arg 0x40 (THR_DETACHED, Not Bound, No New_LWP)
-   count[0] 4173290 count[1] 3690153
-   ncorr_orig 1 ncorr_set 3 ncorr_end 3 rate 39134.219 per_cxt 25.55 usec
-
-   ------------------------------------------------------------------------
-   t0arg 0x41 (THR_DETACHED, THR_BOUND, No New_LWP)
-   t1arg 0x41 (THR_DETACHED, THR_BOUND, No New_LWP)
-   count[0] 1376594 count[1] 1404050
-   ncorr_orig 1 ncorr_set 0 ncorr_end 1 rate 13902.920 per_cxt 71.93 usec
-
-   ------------------------------------------------------------------------
-   t0arg 0x41 (THR_DETACHED, THR_BOUND, No New_LWP)
-   t1arg 0x41 (THR_DETACHED, THR_BOUND, No New_LWP)
-   count[0] 1522495 count[1] 1550889
-   ncorr_orig 1 ncorr_set 2 ncorr_end 2 rate 15366.580 per_cxt 65.08 usec
-
-   ------------------------------------------------------------------------
-   t0arg 0x41 (THR_DETACHED, THR_BOUND, No New_LWP)
-   t1arg 0x41 (THR_DETACHED, THR_BOUND, No New_LWP)
-   count[0] 1282030 count[1] 1265453
-   ncorr_orig 1 ncorr_set 3 ncorr_end 3 rate 12737.125 per_cxt 78.51 usec
-
-   ------------------------------------------------------------------------
-   t0arg 0x42 (THR_DETACHED, Not Bound, THR_NEW_LWP)
-   t1arg 0x42 (THR_DETACHED, Not Bound, THR_NEW_LWP)
-   count[0] 3892994 count[1] 3981143
-   ncorr_orig 3 ncorr_set 0 ncorr_end 3 rate 39273.352 per_cxt 25.46 usec
-
-   ------------------------------------------------------------------------
-   t0arg 0x42 (THR_DETACHED, Not Bound, THR_NEW_LWP)
-   t1arg 0x42 (THR_DETACHED, Not Bound, THR_NEW_LWP)
-   count[0] 4008638 count[1] 3882986
-   ncorr_orig 3 ncorr_set 2 ncorr_end 2 rate 39415.660 per_cxt 25.37 usec
-
-   ------------------------------------------------------------------------
-   t0arg 0x42 (THR_DETACHED, Not Bound, THR_NEW_LWP)
-   t1arg 0x42 (THR_DETACHED, Not Bound, THR_NEW_LWP)
-   count[0] 3859767 count[1] 3998157
-   ncorr_orig 3 ncorr_set 3 ncorr_end 3 rate 39145.160 per_cxt 25.55 usec
-
-   ------------------------------------------------------------------------
-   t0arg 0x43 (THR_DETACHED, THR_BOUND, THR_NEW_LWP)
-   t1arg 0x43 (THR_DETACHED, THR_BOUND, THR_NEW_LWP)
-   count[0] 1557142 count[1] 1588775
-   ncorr_orig 3 ncorr_set 0 ncorr_end 3 rate 15729.235 per_cxt 63.58 usec
-
-   ------------------------------------------------------------------------
-   t0arg 0x43 (THR_DETACHED, THR_BOUND, THR_NEW_LWP)
-   t1arg 0x43 (THR_DETACHED, THR_BOUND, THR_NEW_LWP)
-   count[0] 1570636 count[1] 1579111
-   ncorr_orig 3 ncorr_set 2 ncorr_end 3 rate 15748.395 per_cxt 63.50 usec
-
-   ------------------------------------------------------------------------
-   t0arg 0x43 (THR_DETACHED, THR_BOUND, THR_NEW_LWP)
-   t1arg 0x43 (THR_DETACHED, THR_BOUND, THR_NEW_LWP)
-   count[0] 1414198 count[1] 1371431
-   ncorr_orig 3 ncorr_set 3 ncorr_end 3 rate 13927.800 per_cxt 71.80 usec
- */
diff --git a/performance-tests/Synch-Benchmarks/results/.no_prune b/performance-tests/Synch-Benchmarks/results/.no_prune
deleted file mode 100644
index b5bcdc481b9..00000000000
--- a/performance-tests/Synch-Benchmarks/results/.no_prune
+++ /dev/null
@@ -1 +0,0 @@
-"Do not prune me."
diff --git a/performance-tests/Synch-Benchmarks/run_tests.pl b/performance-tests/Synch-Benchmarks/run_tests.pl
deleted file mode 100755
index 1ef43e69298..00000000000
--- a/performance-tests/Synch-Benchmarks/run_tests.pl
+++ /dev/null
@@ -1,131 +0,0 @@
-eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
-    & eval 'exec perl -S $0 $argv:q'
-    if 0;
-
-# $Id$
-
-$EXE = "synch_driver";
-$Win32 = 0;
-if ($^O eq "MSWin32")
-{
-    $Win32 = 1;
-}
-
-$debug = 0;
-$name = "release";
-$result_dir = "results";
-$svcconf_dir = "svcconf";
-$conf_ext = ".conf";
-
-@Null_List = ();
-
-# This is called "baseline"
-@Baseline_List = ("base_acquire",
-                  "base_tryacquire",
-                  "base_acquire_read",
-                  "base_tryacquire_read",
-                  "base_acquire_write",
-                  "base_tryacquire_write");
-
-# this is called "perf_thrno"
-@Perf_Thr_Number_List = ("perf_t1",
-                         "perf_t2",
-                         "perf_t4",
-                         "perf_t8",
-                         "perf_t16",
-                         "perf_t32",
-                         "perf_t64");
-
-@Target = @Null_List;
-
-while ( $#ARGV >= 0  &&  $ARGV[0] =~ /^-/ )
-{
-    if ($ARGV[0] eq '-d')       # Run debug mode
-    {
-        $name = "debug";
-    }
-    elsif ($ARGV[0] eq '-p')    # Debug perl script
-    {
-        $debug = 1;
-        print "debug perl scirpt\n";
-    }
-    elsif ($ARGV[0] eq '-D')    # Subdir name to put the result
-    {
-        shift;
-        $result_dir = $ARGV[0];
-    }
-    elsif ($ARGV[0] eq '-S')    # Subdir to svc.conf files.
-    {
-        shift;
-        $svcconf_dir = $ARGV[0];
-    }
-    elsif ($ARGV[0] eq '-N')    # Specify test name.
-    {
-        shift;
-        if ($ARGV[0] eq "baseline")
-        {
-            @Target = @Baseline_List;
-        }
-        elsif ($ARGV[0] eq "perf_thrno")
-        {
-            @Target = @Perf_Thr_Number_List;
-        }
-        else
-        {
-            die "Unknown test \"$ARGV[0]\"\n";
-        }
-    }
-    else
-    {
-        warn "$0:  unknown option $ARGV[0]\n";
-        die $usage;
-    }
-    shift;
-}
-
-die "You must specify a test to run\n" if (scalar (@Target) == 0);
-
-if ($Win32 != 0)
-{
-    $execname = "$name\\$EXE";
-    $DIR_SEPARATOR = '\\';
-}
-else
-{
-    $execname = "./$EXE";       # Notice that on UNIX, you much build
-                                # Debug/Release program explicitly
-                                # before running the script.
-    $DIR_SEPARATOR = '/';
-}
-
-for ($Cntr = 0; $Cntr < scalar (@Target); $Cntr++)
-{
-    $Redirect_Output = "$result_dir$DIR_SEPARATOR$Target[$Cntr].$name";
-    if ($debug != 0)             # Only redirect output in actual run
-    {
-        print "Redirectling output to $Redirect_Output\n";
-    }
-    else
-    {
-        open STDOUT, "> $Redirect_Output";
-        open STDERR, ">&STDOUT";
-    }
-
-    @args = ("$execname",
-             "-f",
-             "$svcconf_dir$DIR_SEPARATOR$Target[$Cntr]$conf_ext");
-
-    if ($debug != 0)
-    {
-        print "Debug mode: Executing -- ";
-        for ($args_c = 0; $args_c < scalar (@args); $args_c ++)
-        {
-            print "$args[$args_c] ";
-        }
-        print "\n";
-    }
-    else
-    {
-        system (@args);
-    }
-}
diff --git a/performance-tests/Synch-Benchmarks/svcconf/base_acquire.conf b/performance-tests/Synch-Benchmarks/svcconf/base_acquire.conf
deleted file mode 100644
index 2727bac4e73..00000000000
--- a/performance-tests/Synch-Benchmarks/svcconf/base_acquire.conf
+++ /dev/null
@@ -1,20 +0,0 @@
-# $Id$
-# Benchmark baseline acquire operation.
-
-dynamic Baseline_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Test() ""
-dynamic Baseline_Base_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Base_Test() "-i 10000000"
-dynamic Baseline_Null_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Null_Mutex_Test() "-i 10000000"
-dynamic Baseline_Adaptive_Null_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Null_Mutex_Test() "-i 10000000"
-dynamic Baseline_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Mutex_Test() "-i 10000000"
-dynamic Baseline_RW_Thread_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Thread_Mutex_Test() "-i 10000000"
-dynamic Baseline_RW_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Mutex_Test() "-i 10000000"
-dynamic Baseline_Process_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Process_Mutex_Test() "-i 10000000"
-dynamic Baseline_RW_Process_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Process_Mutex_Test() "-i 10000000"
-dynamic Baseline_Adaptive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Mutex_Test() "-i 10000000"
-dynamic Baseline_Adaptive_RW_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_RW_Mutex_Test() "-i 10000000"
-dynamic Baseline_Recursive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Recursive_Mutex_Test() "-i 10000000"
-dynamic Baseline_Adaptive_Recursive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Recursive_Mutex_Test() "-i 10000000"
-dynamic Baseline_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Semaphore_Test() "-i 10000000"
-dynamic Baseline_Process_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Process_Semaphore_Test() "-i 10000000"
-dynamic Baseline_Null_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Null_Semaphore_Test() "-i 10000000"
-dynamic Baseline_Token_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Token_Test() "-i 10000000"
diff --git a/performance-tests/Synch-Benchmarks/svcconf/base_acquire_read.conf b/performance-tests/Synch-Benchmarks/svcconf/base_acquire_read.conf
deleted file mode 100644
index 9e25160b8d8..00000000000
--- a/performance-tests/Synch-Benchmarks/svcconf/base_acquire_read.conf
+++ /dev/null
@@ -1,20 +0,0 @@
-# $Id$
-# Benchmark baseline acquire operation.
-
-dynamic Baseline_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Test() ""
-dynamic Baseline_Base_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Base_Test() "-i 10000000 -r"
-dynamic Baseline_Null_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Null_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Adaptive_Null_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Null_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_RW_Thread_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Thread_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_RW_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Process_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Process_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_RW_Process_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Process_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Adaptive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Adaptive_RW_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_RW_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Recursive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Recursive_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Adaptive_Recursive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Recursive_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Semaphore_Test() "-i 10000000 -r"
-dynamic Baseline_Process_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Process_Semaphore_Test() "-i 10000000 -r"
-dynamic Baseline_Null_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Null_Semaphore_Test() "-i 10000000 -r"
-dynamic Baseline_Token_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Token_Test() "-i 10000000 -r"
diff --git a/performance-tests/Synch-Benchmarks/svcconf/base_acquire_write.conf b/performance-tests/Synch-Benchmarks/svcconf/base_acquire_write.conf
deleted file mode 100644
index 147e04574ca..00000000000
--- a/performance-tests/Synch-Benchmarks/svcconf/base_acquire_write.conf
+++ /dev/null
@@ -1,20 +0,0 @@
-# $Id$
-# Benchmark baseline acquire operation.
-
-dynamic Baseline_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Test() ""
-dynamic Baseline_Base_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Base_Test() "-i 10000000 -w"
-dynamic Baseline_Null_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Null_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Adaptive_Null_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Null_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_RW_Thread_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Thread_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_RW_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Process_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Process_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_RW_Process_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Process_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Adaptive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Adaptive_RW_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_RW_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Recursive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Recursive_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Adaptive_Recursive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Recursive_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Semaphore_Test() "-i 10000000 -w"
-dynamic Baseline_Process_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Process_Semaphore_Test() "-i 10000000 -w"
-dynamic Baseline_Null_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Null_Semaphore_Test() "-i 10000000 -w"
-dynamic Baseline_Token_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Token_Test() "-i 10000000 -w"
diff --git a/performance-tests/Synch-Benchmarks/svcconf/base_tryacquire.conf b/performance-tests/Synch-Benchmarks/svcconf/base_tryacquire.conf
deleted file mode 100644
index 91f78275ffa..00000000000
--- a/performance-tests/Synch-Benchmarks/svcconf/base_tryacquire.conf
+++ /dev/null
@@ -1,20 +0,0 @@
-# $Id$
-# Benchmark baseline tryacquire operation.
-
-dynamic Baseline_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Test() "-t -v"
-dynamic Baseline_Base_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Base_Test() "-i 10000000"
-dynamic Baseline_Null_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Null_Mutex_Test() "-i 10000000"
-dynamic Baseline_Adaptive_Null_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Null_Mutex_Test() "-i 10000000"
-dynamic Baseline_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Mutex_Test() "-i 10000000"
-dynamic Baseline_RW_Thread_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Thread_Mutex_Test() "-i 10000000"
-dynamic Baseline_RW_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Mutex_Test() "-i 10000000"
-dynamic Baseline_Process_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Process_Mutex_Test() "-i 10000000"
-dynamic Baseline_RW_Process_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Process_Mutex_Test() "-i 10000000"
-dynamic Baseline_Adaptive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Mutex_Test() "-i 10000000"
-dynamic Baseline_Adaptive_RW_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_RW_Mutex_Test() "-i 10000000"
-dynamic Baseline_Recursive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Recursive_Mutex_Test() "-i 10000000"
-dynamic Baseline_Adaptive_Recursive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Recursive_Mutex_Test() "-i 10000000"
-dynamic Baseline_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Semaphore_Test() "-i 10000000"
-dynamic Baseline_Process_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Process_Semaphore_Test() "-i 10000000"
-dynamic Baseline_Null_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Null_Semaphore_Test() "-i 10000000"
-dynamic Baseline_Token_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Token_Test() "-i 10000000"
diff --git a/performance-tests/Synch-Benchmarks/svcconf/base_tryacquire_read.conf b/performance-tests/Synch-Benchmarks/svcconf/base_tryacquire_read.conf
deleted file mode 100644
index d300b3b462f..00000000000
--- a/performance-tests/Synch-Benchmarks/svcconf/base_tryacquire_read.conf
+++ /dev/null
@@ -1,20 +0,0 @@
-# $Id$
-# Benchmark baseline tryacquire operation.
-
-dynamic Baseline_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Test() "-t -v"
-dynamic Baseline_Base_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Base_Test() "-i 10000000 -r"
-dynamic Baseline_Null_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Null_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Adaptive_Null_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Null_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_RW_Thread_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Thread_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_RW_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Process_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Process_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_RW_Process_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Process_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Adaptive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Adaptive_RW_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_RW_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Recursive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Recursive_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Adaptive_Recursive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Recursive_Mutex_Test() "-i 10000000 -r"
-dynamic Baseline_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Semaphore_Test() "-i 10000000 -r"
-dynamic Baseline_Process_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Process_Semaphore_Test() "-i 10000000 -r"
-dynamic Baseline_Null_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Null_Semaphore_Test() "-i 10000000 -r"
-dynamic Baseline_Token_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Token_Test() "-i 10000000 -r"
diff --git a/performance-tests/Synch-Benchmarks/svcconf/base_tryacquire_write.conf b/performance-tests/Synch-Benchmarks/svcconf/base_tryacquire_write.conf
deleted file mode 100644
index d220d4ecbd5..00000000000
--- a/performance-tests/Synch-Benchmarks/svcconf/base_tryacquire_write.conf
+++ /dev/null
@@ -1,20 +0,0 @@
-# $Id$
-# Benchmark baseline tryacquire operation.
-
-dynamic Baseline_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Test() "-t -v"
-dynamic Baseline_Base_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Base_Test() "-i 10000000 -w"
-dynamic Baseline_Null_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Null_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Adaptive_Null_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Null_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_RW_Thread_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Thread_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_RW_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Process_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Process_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_RW_Process_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_RW_Process_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Adaptive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Adaptive_RW_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_RW_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Recursive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Recursive_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Adaptive_Recursive_Mutex_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Adaptive_Recursive_Mutex_Test() "-i 10000000 -w"
-dynamic Baseline_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Semaphore_Test() "-i 10000000 -w"
-dynamic Baseline_Process_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Process_Semaphore_Test() "-i 10000000 -w"
-dynamic Baseline_Null_Semaphore_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Null_Semaphore_Test() "-i 10000000 -w"
-dynamic Baseline_Token_Test Service_Object * Base_Test/Base_Test:_make_Baseline_Token_Test() "-i 10000000 -w"
diff --git a/performance-tests/Synch-Benchmarks/svcconf/perf_t1.conf b/performance-tests/Synch-Benchmarks/svcconf/perf_t1.conf
deleted file mode 100644
index 1c4c2ad2f01..00000000000
--- a/performance-tests/Synch-Benchmarks/svcconf/perf_t1.conf
+++ /dev/null
@@ -1,32 +0,0 @@
-# Dynamically configure all the tests
-
-dynamic Performance_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Performance_Test() "-s 60 -N -B -t 1"
-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()
-dynamic Semaphore_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Sema_Test()
-dynamic Adaptive_Semaphore_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Adaptive_Sema_Test()
-dynamic RWRD_Mutex_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_RWRD_Test()
-dynamic RWWR_Mutex_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_RWWR_Test()
-dynamic Token_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Token_Test()
diff --git a/performance-tests/Synch-Benchmarks/svcconf/perf_t16.conf b/performance-tests/Synch-Benchmarks/svcconf/perf_t16.conf
deleted file mode 100644
index f50ae6f4544..00000000000
--- a/performance-tests/Synch-Benchmarks/svcconf/perf_t16.conf
+++ /dev/null
@@ -1,32 +0,0 @@
-# Dynamically configure all the tests
-
-dynamic Performance_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Performance_Test() "-s 60 -N -B -t 16"
-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()
-dynamic Semaphore_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Sema_Test()
-dynamic Adaptive_Semaphore_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Adaptive_Sema_Test()
-dynamic RWRD_Mutex_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_RWRD_Test()
-dynamic RWWR_Mutex_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_RWWR_Test()
-dynamic Token_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Token_Test()
diff --git a/performance-tests/Synch-Benchmarks/svcconf/perf_t2.conf b/performance-tests/Synch-Benchmarks/svcconf/perf_t2.conf
deleted file mode 100644
index cc08f483a73..00000000000
--- a/performance-tests/Synch-Benchmarks/svcconf/perf_t2.conf
+++ /dev/null
@@ -1,32 +0,0 @@
-# Dynamically configure all the tests
-
-dynamic Performance_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Performance_Test() "-s 60 -N -B -t 2"
-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()
-dynamic Semaphore_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Sema_Test()
-dynamic Adaptive_Semaphore_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Adaptive_Sema_Test()
-dynamic RWRD_Mutex_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_RWRD_Test()
-dynamic RWWR_Mutex_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_RWWR_Test()
-dynamic Token_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Token_Test()
diff --git a/performance-tests/Synch-Benchmarks/svcconf/perf_t32.conf b/performance-tests/Synch-Benchmarks/svcconf/perf_t32.conf
deleted file mode 100644
index c12d3dc752b..00000000000
--- a/performance-tests/Synch-Benchmarks/svcconf/perf_t32.conf
+++ /dev/null
@@ -1,32 +0,0 @@
-# Dynamically configure all the tests
-
-dynamic Performance_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Performance_Test() "-s 60 -N -B -t 32"
-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()
-dynamic Semaphore_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Sema_Test()
-dynamic Adaptive_Semaphore_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Adaptive_Sema_Test()
-dynamic RWRD_Mutex_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_RWRD_Test()
-dynamic RWWR_Mutex_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_RWWR_Test()
-dynamic Token_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Token_Test()
diff --git a/performance-tests/Synch-Benchmarks/svcconf/perf_t4.conf b/performance-tests/Synch-Benchmarks/svcconf/perf_t4.conf
deleted file mode 100644
index 2d6661d36e1..00000000000
--- a/performance-tests/Synch-Benchmarks/svcconf/perf_t4.conf
+++ /dev/null
@@ -1,32 +0,0 @@
-# Dynamically configure all the tests
-
-dynamic Performance_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Performance_Test() "-s 60 -N -B -t 4"
-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()
-dynamic Semaphore_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Sema_Test()
-dynamic Adaptive_Semaphore_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Adaptive_Sema_Test()
-dynamic RWRD_Mutex_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_RWRD_Test()
-dynamic RWWR_Mutex_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_RWWR_Test()
-dynamic Token_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Token_Test()
diff --git a/performance-tests/Synch-Benchmarks/svcconf/perf_t64.conf b/performance-tests/Synch-Benchmarks/svcconf/perf_t64.conf
deleted file mode 100644
index 0bf358d0191..00000000000
--- a/performance-tests/Synch-Benchmarks/svcconf/perf_t64.conf
+++ /dev/null
@@ -1,32 +0,0 @@
-# Dynamically configure all the tests
-
-dynamic Performance_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Performance_Test() "-s 60 -N -B -t 64"
-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()
-dynamic Semaphore_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Sema_Test()
-dynamic Adaptive_Semaphore_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Adaptive_Sema_Test()
-dynamic RWRD_Mutex_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_RWRD_Test()
-dynamic RWWR_Mutex_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_RWWR_Test()
-dynamic Token_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Token_Test()
diff --git a/performance-tests/Synch-Benchmarks/svcconf/perf_t8.conf b/performance-tests/Synch-Benchmarks/svcconf/perf_t8.conf
deleted file mode 100644
index cbfe7062fa8..00000000000
--- a/performance-tests/Synch-Benchmarks/svcconf/perf_t8.conf
+++ /dev/null
@@ -1,32 +0,0 @@
-# Dynamically configure all the tests
-
-dynamic Performance_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Performance_Test() "-s 60 -N -B -t 8"
-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()
-dynamic Semaphore_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Sema_Test()
-dynamic Adaptive_Semaphore_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Adaptive_Sema_Test()
-dynamic RWRD_Mutex_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_RWRD_Test()
-dynamic RWWR_Mutex_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_RWWR_Test()
-dynamic Token_Test
-        Service_Object *
-        Perf_Test/Perf_Test:_make_Token_Test()
diff --git a/performance-tests/Synch-Benchmarks/svcconf/svc.conf b/performance-tests/Synch-Benchmarks/svcconf/svc.conf
deleted file mode 100644
index ec2d85fbcbf..00000000000
--- a/performance-tests/Synch-Benchmarks/svcconf/svc.conf
+++ /dev/null
@@ -1,29 +0,0 @@
-# Dynamically configure all the tests
-
-dynamic Performance_Test
-        Service_Object
-        *
-        Perf_Test/Perf_Test:_make_Performance_Test()
-        "-s 3 -t 4"
-dynamic Mutex_Test Service_Object
-        *
-        Perf_Test/Perf_Test:_make_Mutex_Test()
-#dynamic Guard_Test Service_Object * Perf_Test/Perf_Test:_make_Guard_Test() "-g"
-#dynamic SYSVSema_Test Service_Object * Perf_Test/Perf_Test:_make_SYSVSema_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()
-#dynamic Semaphore_Test Service_Object * Perf_Test/Perf_Test:_make_Sema_Test()
-#dynamic Adaptive_Semaphore_Test Service_Object * Perf_Test/Perf_Test:_make_Adaptive_Sema_Test()
-#dynamic RWRD_Mutex_Test Service_Object * Perf_Test/Perf_Test:_make_RWRD_Test()
-#dynamic RWWR_Mutex_Test Service_Object * Perf_Test/Perf_Test:_make_RWWR_Test()
-#dynamic Token_Test Service_Object * Perf_Test/Perf_Test:_make_Token_Test()
-#dynamic SYSVSema_Test Service_Object * Perf_Test/Perf_Test:_make_SYSVSema_Test()
-#dynamic Context_Test Service_Object * Perf_Test/Perf_Test:_make_Context_Test()
-# dynamic Memory_Test Service_Object  * Perf_Test/Perf_Test:_make_Memory_Test()
-#dynamic Pipe_Thr_Test Service_Object * Perf_Test/Perf_Test:_make_Pipe_Thr_Test()
-# dynamic Pipe_Proc_Test Service_Object * Perf_Test/Perf_Test:_make_Pipe_Proc_Test()
-# The following two tests don't work correctly yet...
-#dynamic Condition_Broadcast_Test Service_Object * Perf_Test/Perf_Test:_make_Cond_Brdcast_Test()
-#dynamic Condition_Signal_Test Service_Object * Perf_Test/Perf_Test:_make_Cond_Signal_Test()
diff --git a/performance-tests/Synch-Benchmarks/synch_driver.cpp b/performance-tests/Synch-Benchmarks/synch_driver.cpp
deleted file mode 100644
index eca2f6cecb0..00000000000
--- a/performance-tests/Synch-Benchmarks/synch_driver.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-// $Id$
-
-// Driver program that measures the performance of synchronization
-// mechanisms provided by ACE and the underlying OS.
-
-#include "ace/Log_Msg.h"
-#include "ace/Service_Config.h"
-#include "ace/Service_Repository.h"
-#include "Synch_Lib/Benchmark_Base.h"
-
-ACE_RCSID(Synch_Benchmarks, synch_driver, "$Id$")
-
-#if defined (ACE_HAS_THREADS)
-int
-ACE_TMAIN (int argc, ACE_TCHAR *argv[])
-{
-  ACE_Service_Config::open (argc, argv);
-  ACE_Service_Repository_Iterator sri (*ACE_Service_Repository::instance ());
-
-  // Iteratively execute each service loaded in from the svc.conf
-  // file.
-
-  for (const ACE_Service_Type *sr;
-       sri.next (sr) != 0; )
-    {
-      // This would greatly benefit from RTTI typesafe downcasting...
-      const ACE_Service_Type_Impl *type = sr->type ();
-      const void *obj = type->object ();
-      ACE_Service_Object *so = (ACE_Service_Object *) obj;
-      Benchmark_Base *bb = (Benchmark_Base *) so;
-
-      if (bb->benchmark_type () == Benchmark_Base::METHOD)
-        {
-          Benchmark_Method_Base *bm = (Benchmark_Method_Base *) bb;
-
-          ACE_DEBUG ((LM_DEBUG, "\n\nExecuting %s\n", sr->name ()));
-
-          bm->exec (&sri);
-        }
-      else
-        sri.advance ();
-    }
-  return 0;
-}
-#else
-int
-ACE_TMAIN (int, ACE_TCHAR *[])
-{
-  ACE_ERROR_RETURN ((LM_ERROR,
-		     "This test requires the platform to have threads\n"), -1);
-}
-#endif /* ACE_HAS_THREADS */
diff --git a/performance-tests/TCP/README b/performance-tests/TCP/README
deleted file mode 100644
index ac486524c78..00000000000
--- a/performance-tests/TCP/README
+++ /dev/null
@@ -1,17 +0,0 @@
-// $Id$
-
-udp_test sends TCP messages and records round-trip latency.  The client
-records the latencies and provides nice summary statistics.  The server
-simply echos packets back to the client.
-
-To run:
-  1) On server host:
-     % ./tcp_test -s
-
-  2) On client host:
-     % ./tcp_test -i 10000 <server host>
-
-The -i option specifies the number of samples (packets to send).
-Other command line options are available:  ./tcp_test -? to
-list them.
-
diff --git a/performance-tests/TCP/TCP.mpc b/performance-tests/TCP/TCP.mpc
deleted file mode 100644
index ca6b8ee6622..00000000000
--- a/performance-tests/TCP/TCP.mpc
+++ /dev/null
@@ -1,5 +0,0 @@
-// -*- MPC -*-
-// $Id$
-
-project : aceexe {
-}
\ No newline at end of file
diff --git a/performance-tests/TCP/run_test.pl b/performance-tests/TCP/run_test.pl
deleted file mode 100755
index 34c4f416c39..00000000000
--- a/performance-tests/TCP/run_test.pl
+++ /dev/null
@@ -1,34 +0,0 @@
-eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
-     & eval 'exec perl -S $0 $argv:q'
-     if 0;
-
-# $Id$
-# -*- perl -*-
-
-use lib '../../bin';
-use PerlACE::Run_Test;
-
-$SV = new PerlACE::Process ("tcp_test", "-s");
-$CL = new PerlACE::Process ("tcp_test", "-c localhost -i 50000 -b 64");
-
-$status = 0;
-
-$SV->Spawn ();
-
-sleep 5;
-
-$client = $CL->SpawnWaitKill (60);
-
-$server = $SV->WaitKill (5);
-
-if ($server != 0) {
-    print "ERROR: server returned $server\n";
-    $status = 1;
-}
-
-if ($client != 0) {
-    print "ERROR: client returned $client\n";
-    $status = 1;
-}
-
-exit $status;
diff --git a/performance-tests/TCP/tcp_test.cpp b/performance-tests/TCP/tcp_test.cpp
deleted file mode 100644
index 182914e14b7..00000000000
--- a/performance-tests/TCP/tcp_test.cpp
+++ /dev/null
@@ -1,692 +0,0 @@
-// $Id$
-
-// ============================================================================
-//
-// = LIBRARY
-//    performance-tests/TCP
-//
-// = FILENAME
-//   tcp_test.cpp
-//
-// = DESCRIPTION
-//   Measures TCP round-trip performance.
-//
-// = AUTHORS
-//   Based on udp_test by Fred Kuhns and David L. Levine
-//   Modified by Carlos O'Ryan and Nanbor Wang.
-//
-// ============================================================================
-
-#include "ace/Reactor.h"
-#include "ace/Select_Reactor.h"
-#include "ace/TP_Reactor.h"
-#include "ace/SOCK_Stream.h"
-#include "ace/SOCK_Acceptor.h"
-#include "ace/SOCK_Connector.h"
-#include "ace/INET_Addr.h"
-#include "ace/ACE.h"
-#include "ace/Get_Opt.h"
-#include "ace/High_Res_Timer.h"
-#include "ace/Thread_Manager.h"
-#include "ace/Sched_Params.h"
-#include "ace/Stats.h"
-#include "ace/Sample_History.h"
-#include "ace/OS_main.h"
-#include "ace/OS_NS_arpa_inet.h"
-#include "ace/OS_NS_ctype.h"
-#include "ace/OS_NS_errno.h"
-#include "ace/OS_NS_string.h"
-#include "ace/OS_NS_unistd.h"
-
-// FUZZ: disable check_for_math_include
-#include <math.h>
-
-ACE_RCSID(TCP, tcp_test, "$Id$")
-
-// Global variables (evil).
-static const u_short DEFPORT = 5050;
-static const int MAXPKTSZ = 65536;
-static const int DEFPKTSZ = 64;
-static const int DEFITERATIONS = 1000;
-static const int DEFINTERVAL = 0;
-static const int DEFAULT_THRNO = 10;
-
-static char sbuf[MAXPKTSZ];
-static char rbuf[MAXPKTSZ];
-
-static int usdelay = DEFINTERVAL;
-static int bufsz = DEFPKTSZ;
-static int VERBOSE = 0;
-static int dump_history = 0;
-static int svr_thrno = DEFAULT_THRNO;
-static int server = 0;
-static int client = 0;
-static int nsamples = DEFITERATIONS;
-static int so_bufsz = 0;
-static u_int use_reactor = 0;
-static int usecs = 0;
-
-enum {
-  SELECT = 1,
-    TP,
-    WFMO
-};
-
-
-static void
-usage (void)
-{
-  ACE_ERROR ((LM_ERROR,
-              "tcp_test\n"
-              "  [-v]          (Verbose)\n"
-              "  [-h] (dump all the samples)\n"
-              "  [-m message size]\n"
-              "  [-i iterations]\n"
-              "  [-I usdelay]\n"
-              "  [-b socket bufsz] \n"
-              "  [-p port]\n"
-              "  [-s]\n"
-              "  [-c]\n"
-              //              "  [-x max_sample_allowed]\n"
-              "  [-t number of threads]\n"
-              "  [-a to use the ACE Select reactor]\n"
-              "  [-x to use the ACE TP reactor]\n"
-              "  [-w to use the ACE WFMO reactor]\n"
-              "  targethost \n"));
-}
-
-// ****************************************************************
-
-class Client : public ACE_Event_Handler
-{
-public:
-  Client (const ACE_INET_Addr &remote_addr);
-
-  virtual ~Client (void);
-
-  // = Override <ACE_Event_Handler> methods.
-  virtual ACE_HANDLE get_handle (void) const;
-  virtual int handle_input (ACE_HANDLE);
-  virtual int handle_close (ACE_HANDLE handle,
-                            ACE_Reactor_Mask close_mask);
-
-  int send (const char *buf, size_t len);
-  // Send the <buf> to the server.
-
-  int get_response (char *buf, size_t len);
-  // Wait for the response.
-
-  int run (void);
-  // Send messages to server and record statistics.
-
-  int shutdown (void);
-  // Send shutdown message to server.
-
-private:
-  ACE_SOCK_Stream endpoint_;
-  // To send messages and receive responses.
-
-  ACE_INET_Addr remote_addr_;
-  // The address to send messages to.
-
-  ACE_UNIMPLEMENTED_FUNC (Client (void))
-  ACE_UNIMPLEMENTED_FUNC (Client (const Client &))
-  ACE_UNIMPLEMENTED_FUNC (Client &operator= (const Client &))
-};
-
-Client::Client (const ACE_INET_Addr &remote_addr)
-  : remote_addr_ (remote_addr)
-{
-  ACE_SOCK_Connector connector;
-  if (connector.connect (this->endpoint_, remote_addr) == -1)
-    {
-      ACE_ERROR ((LM_ERROR, "Client - %p\n",
-                  "connect failed"));
-    }
-
-  if (use_reactor)
-    {
-      if (ACE_Reactor::instance ()->register_handler
-          (this, ACE_Event_Handler::READ_MASK) == -1)
-        ACE_ERROR ((LM_ERROR,
-                    "ACE_Reactor::register_handler: Client\n"));
-    }
-}
-
-Client::~Client (void)
-{
-}
-
-ACE_HANDLE
-Client::get_handle (void) const
-{
-  return this->endpoint_.get_handle ();
-}
-
-int
-Client::handle_input (ACE_HANDLE)
-{
-  char buf[BUFSIZ];
-
-  ssize_t n = this->endpoint_.recv (buf, sizeof buf);
-
-  if (n == -1)
-    ACE_ERROR ((LM_ERROR,
-                "%p\n",
-                "handle_input"));
-  else
-    ACE_DEBUG ((LM_DEBUG,
-                "(%P|%t) buf of size %d = %*s\n",
-                n,
-                n,
-                buf));
-
-  return 0;
-}
-
-int
-Client::handle_close (ACE_HANDLE,
-                      ACE_Reactor_Mask)
-{
-  this->endpoint_.close ();
-  return 0;
-}
-
-int
-Client::send (const char *buf, size_t len)
-{
-  return this->endpoint_.send (buf, len);
-}
-
-int
-Client::get_response (char *buf, size_t len)
-{
-  return this->endpoint_.recv (buf, len);
-}
-
-int
-Client::run (void)
-{
-  ACE_OS::memset (sbuf, 0, bufsz);
-  ACE_OS::memset (rbuf, 0, bufsz);
-
-  for (int j = 0; j != 100; ++j)
-    {
-      if (this->send (sbuf, bufsz) <= 0)
-        ACE_ERROR_RETURN ((LM_ERROR, "(%P) %p\n", "send"), -1);
-
-      //      ssize_t n;
-      if ((this->get_response (rbuf, bufsz)) <= 0)
-        ACE_ERROR_RETURN ((LM_ERROR, "(%P) %p\n", "get_response"), -1);
-    }
-
-  ACE_Sample_History history (nsamples);
-
-  ACE_hrtime_t test_start = ACE_OS::gethrtime ();
-  for (int i = 0; i != nsamples; ++i)
-    {
-      if (usecs != 0)
-        {
-          ACE_Time_Value tv (0, usecs);
-          ACE_OS::sleep (tv);
-        }
-
-      ACE_hrtime_t start = ACE_OS::gethrtime ();
-      if (this->send (sbuf, bufsz) <= 0)
-        ACE_ERROR_RETURN ((LM_ERROR, "(%P) %p\n", "send"), -1);
-
-      //      ssize_t n;
-      if ((this->get_response (rbuf, bufsz)) <= 0)
-        ACE_ERROR_RETURN ((LM_ERROR, "(%P) %p\n", "get_response"), -1);
-
-      ACE_hrtime_t end = ACE_OS::gethrtime ();
-
-      history.sample (end - start);
-
-      if (VERBOSE && i % 500 == 0)
-        {
-          ACE_DEBUG ((LM_DEBUG,
-                      "Send %d / %d events\n", i, nsamples));
-        }
-    }
-  ACE_hrtime_t test_end = ACE_OS::gethrtime ();
-
-  ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor ();
-
-  if (dump_history)
-    {
-      history.dump_samples (ACE_TEXT("HISTORY"), gsf);
-    }
-
-  ACE_Basic_Stats latency;
-  history.collect_basic_stats (latency);
-  latency.dump_results (ACE_TEXT("Client"), gsf);
-  ACE_Throughput_Stats::dump_throughput (ACE_TEXT("Client"),
-                                         gsf,
-                                         test_end - test_start,
-                                         latency.samples_count ());
-
-
-  return 0;
-}
-
-int
-Client::shutdown (void)
-{
-  const char buf = 'S';
-  int n = this->endpoint_.send (&buf, 1u);
-
-  if (use_reactor)
-    {
-      if (ACE_Reactor::instance ()->remove_handler
-          (this, ACE_Event_Handler::READ_MASK) == -1)
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "ACE_Reactor::remove_handler: Client\n"),
-                          -1);
-    }
-
-  return n;
-}
-
-// ****************************************************************
-
-class Server : public ACE_Event_Handler
-{
-public:
-  Server (const ACE_INET_Addr &addr);
-
-  virtual ~Server (void);
-
-  // = Override <ACE_Event_Handler> methods.
-  virtual ACE_HANDLE get_handle (void) const;
-  virtual int handle_input (ACE_HANDLE);
-  virtual int handle_close (ACE_HANDLE handle,
-                            ACE_Reactor_Mask close_mask);
-
-private:
-  ACE_SOCK_Stream endpoint_;
-  // Receives datagrams.
-
-  ACE_UNIMPLEMENTED_FUNC (Server (void))
-  ACE_UNIMPLEMENTED_FUNC (Server (const Server &))
-  ACE_UNIMPLEMENTED_FUNC (Server &operator= (const Server &))
-};
-
-Server::Server (const ACE_INET_Addr &addr)
-{
-  ACE_SOCK_Acceptor acceptor;
-
-  if (acceptor.open (addr, 1) == -1)
-    ACE_DEBUG ((LM_DEBUG, "%p\n", "open"));
-
-  ACE_DEBUG ((LM_DEBUG, "Listening on %s:%d\n",
-              addr.get_host_name (),
-              addr.get_port_number ()));
-  if (acceptor.accept (this->endpoint_) == -1)
-    ACE_ERROR ((LM_ERROR, "Server::Server %p\n",
-                "accept failed"));
-
-  if (use_reactor)
-    {
-      if (ACE_Reactor::instance ()->register_handler
-          (this,
-           ACE_Event_Handler::READ_MASK) == -1)
-        ACE_ERROR ((LM_ERROR,
-                    "ACE_Reactor::register_handler: Server\n"));
-    }
-
-#if !defined (ACE_LACKS_SOCKET_BUFSIZ)
-  if (so_bufsz != 0)
-    {
-      if (this->endpoint_.set_option (SOL_SOCKET,
-                                      SO_SNDBUF,
-                                      (void *) &so_bufsz,
-                                      sizeof (so_bufsz)) == -1
-          && errno != ENOTSUP)
-        ACE_ERROR ((LM_ERROR, "Server::Server: SO_SNDBUF %p\n",
-                    "set_option failed"));
-      else if (this->endpoint_.set_option (SOL_SOCKET,
-                                           SO_RCVBUF,
-                                           (void *) &so_bufsz,
-                                           sizeof (so_bufsz)) == -1
-               && errno != ENOTSUP)
-        ACE_ERROR ((LM_ERROR, "Server::Server: SO_RCVBUF %p\n",
-                    "set_option failed"));
-    }
-#endif /* !ACE_LACKS_SOCKET_BUFSIZ */
-  if (acceptor.close () == -1)
-    ACE_ERROR ((LM_ERROR, "Server::Server %p\n",
-                "close failed"));
-}
-
-Server::~Server (void)
-{
-  this->endpoint_.close ();
-}
-
-ACE_HANDLE
-Server::get_handle (void) const
-{
-  return this->endpoint_.get_handle ();
-}
-
-int
-Server::handle_input (ACE_HANDLE)
-{
-  char buf[BUFSIZ];
-
-  ssize_t n = this->endpoint_.recv (buf, bufsz);
-
-  if (n == -1)
-    ACE_DEBUG ((LM_ERROR,
-                "%p\n",
-                "handle_input: recv"));
-
-  // Send the message back as the response.
-  if (this->endpoint_.send (buf, n) == n)
-    {
-      if (n == 1 && buf[0] == 'S')
-        {
-          if (!use_reactor)
-            {
-              // Indicate done by returning 1.
-              return 1;
-            }
-
-          if (ACE_Reactor::instance ()->remove_handler
-              (this, ACE_Event_Handler::READ_MASK) == -1)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "ACE_Reactor::remove_handler: server\n"),
-                              -1);
-
-          ACE_Reactor::end_event_loop ();
-        }
-
-      return 0;
-    }
-
-  ACE_DEBUG ((LM_ERROR,
-              "%p\n",
-              "handle_input: send"));
-  return -1;
-}
-
-int
-Server::handle_close (ACE_HANDLE,
-                      ACE_Reactor_Mask)
-{
-  this->endpoint_.close ();
-
-  return 0;
-}
-
-static ACE_THR_FUNC_RETURN
-thread_pool_worker (void *)
-{
-  // Server thread function.
-
-  while (!ACE_Reactor::event_loop_done ())
-    {
-      if (ACE_Reactor::instance ()->handle_events () == -1)
-        ACE_ERROR ((LM_ERROR,
-                    ACE_TEXT ("(%t) %p\n"),
-                    ACE_TEXT ("Error handling events")));
-    }
-
-  return 0;
-}
-
-int
-run_server (ACE_INET_Addr &addr)
-{
-  if (use_reactor)
-    {
-      ACE_Reactor *new_reactor = 0;
-
-      switch (use_reactor)
-        {
-        case SELECT:
-          {
-            ACE_Select_Reactor *sr = new ACE_Select_Reactor ();
-            new_reactor = new ACE_Reactor (sr, 1);
-          }
-          break;
-        case TP:
-          {
-            ACE_TP_Reactor *sr = new ACE_TP_Reactor ();
-            new_reactor = new ACE_Reactor (sr, 1);
-          }
-          break;
-        case WFMO:
-#if defined (ACE_WIN32)
-
-#else
-
-#endif /* ACE_WIN32 */
-        default:
-          ACE_ERROR_RETURN ((LM_ERROR, "Invalid reactor type selected\n"), -1);
-        }
-      ACE_Reactor::instance (new_reactor, 1);
-    }
-
-  Server server (addr);
-
-  if (!use_reactor)
-    {
-      // Handle input in the current thread.
-      // This is actually equivalent to thread-per-connection model.
-      while (server.handle_input (0) != 1)
-        continue;
-    }
-  else
-    {
-      switch (use_reactor)
-        {
-        case SELECT:
-          // Run the reactor event loop.
-          ACE_Reactor::run_event_loop ();
-          break;
-        case TP:
-          ACE_Thread_Manager::instance ()->spawn_n (svr_thrno,
-                                                    thread_pool_worker);
-          ACE_Thread_Manager::instance ()->wait ();
-          break;
-        case WFMO:
-          break;
-        default:
-          break; // won't happen here.
-        }
-    }
-
-  return 0;
-}
-
-int
-ACE_TMAIN (int argc, ACE_TCHAR *argv[])
-{
-  int c, dstport = DEFPORT;
-  int priority =
-    (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
-     + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
-  priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO,
-                                              priority);
-  // Enable FIFO scheduling, e.g., RT scheduling class on Solaris.
-
-  if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO,
-                                              priority,
-                                              ACE_SCOPE_PROCESS)) != 0)
-    {
-      if (ACE_OS::last_error () == EPERM)
-        {
-          ACE_DEBUG ((LM_DEBUG,
-                      "server (%P|%t): user is not superuser, "
-                      "test runs in time-shared class\n"));
-        }
-      else
-        ACE_ERROR ((LM_ERROR,
-                    "server (%P|%t): sched_params failed\n"));
-    }
-
-
-  ACE_Get_Opt getopt (argc, argv, ACE_TEXT("hxwvb:I:p:sci:m:at:"));
-
-  while ((c = getopt ()) != -1)
-    {
-      switch ((char) c)
-        {
-        case 'v':
-          VERBOSE = 1;
-          break;
-
-        case 'h':
-          dump_history = 1;
-          break;
-
-        case 'm':
-          bufsz = ACE_OS::atoi (getopt.opt_arg ());
-
-          if (bufsz <= 0)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "\nMessage size must be greater than 0!\n\n"),
-                              1);
-          else if (bufsz > BUFSIZ)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "\nbufsz must be <= %d\n",
-                               BUFSIZ),
-                              1);
-
-        case 'i':
-          nsamples = ACE_OS::atoi (getopt.opt_arg ());
-          if (nsamples <= 0)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "\nIterations must be greater than 0!\n\n"),
-                              1);
-          break;
-
-        case 'a':
-          use_reactor = SELECT;
-          break;
-
-        case 'x':
-          use_reactor = TP;
-          break;
-
-        case 'w':
-#if defined (ACE_WIN32)
-          use_reactor = WFMO;
-          break;
-#else
-          ACE_ERROR_RETURN ((LM_ERROR, "WFMO_Reactor is not supported\n"), -1);
-#endif /* ACE_WIN32 */
-
-        case 'b':
-          so_bufsz = ACE_OS::atoi (getopt.opt_arg ());
-
-          if (so_bufsz <= 0)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "\nInvalid socket buffer size!\n\n"),
-                              1);
-          break;
-
-        case 'I':
-          usdelay = ACE_OS::atoi (getopt.opt_arg ());
-
-          if (usdelay < 0)
-            {
-              usdelay = 0;
-              ACE_ERROR_RETURN ((LM_ERROR,
-                                 "%s: bad usdelay: %s\n",
-                                 argv[0],
-                                 getopt.opt_arg ()),
-                                1);
-            }
-          break;
-
-        case 'p':
-          dstport = ACE_OS::atoi (getopt.opt_arg ());
-          if (dstport <= 0)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "\nInvalid port number!\n\n"),
-                              1);
-          break;
-        case 't':
-          svr_thrno = ACE_OS::atoi (getopt.opt_arg ());
-
-          if (svr_thrno <= 0)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "\nInvalid server thread number!\n\n"),
-                              1);
-          break;
-
-        case 'c':
-          server = 0;
-          client = 1;
-          break;
-        case 's':
-          client = 0;
-          server = 1;
-          break;
-        default:
-          usage ();
-          return 1;
-        }
-    }
-
-  if (getopt.opt_ind () >= argc && client || argc == 1)
-    {
-      usage ();
-      return 1;
-    }
-
-  ACE_INET_Addr addr (dstport);
-
-  if (server)
-    return run_server (addr);
-
-  if ((u_int) bufsz < sizeof (ACE_hrtime_t))
-    ACE_ERROR_RETURN ((LM_ERROR,
-                       "\nbufsz must be >= %d\n",
-                       sizeof (ACE_hrtime_t)),
-                      1);
-
-  ACE_INET_Addr remote_addr;
-
-  if (ACE_OS::ace_isdigit(argv[getopt.opt_ind ()][0]))
-    {
-      if (remote_addr.set (dstport,
-                           (ACE_UINT32) ACE_OS::inet_addr
-                           (ACE_TEXT_ALWAYS_CHAR(argv[getopt.opt_ind ()]))) == -1)
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "invalid IP address: %s\n",
-                           argv[getopt.opt_ind ()]),
-                          1);
-    }
-  else
-    {
-      if (remote_addr.set (dstport, argv[getopt.opt_ind ()]) == -1)
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "invalid IP address: %s\n",
-                           argv[getopt.opt_ind ()]),
-                          1);
-    }
-  getopt.opt_ind ()++;
-
-  ACE_DEBUG ((LM_DEBUG, "Connecting to %s:%d\n",
-              remote_addr.get_host_name (),
-              remote_addr.get_port_number ()));
-
-  Client client (remote_addr);
-
-  ACE_DEBUG ((LM_DEBUG,
-              "\nSending %d byte packets to %s:%d "
-              "with so_bufsz = %d\n\n",
-              bufsz,
-              addr.get_host_name (),
-              dstport,
-              so_bufsz));
-
-  client.run ();
-  client.shutdown ();
-
-  return 0;
-}
diff --git a/performance-tests/TTCP/ACE-C++/How_to_run_tests b/performance-tests/TTCP/ACE-C++/How_to_run_tests
deleted file mode 100644
index 1346a745504..00000000000
--- a/performance-tests/TTCP/ACE-C++/How_to_run_tests
+++ /dev/null
@@ -1,29 +0,0 @@
-// ACE version
-//
-//
-
-// HOSTNAMES:
-// for our tests, encip1-tango.cs.wustl.edu was the receiver hostname used for atm transfers
-//                tango.cs.wustl.edu was the receiver hostname used for ethernet transfers
-// substitute the proper receiver hostname for your system.
-
-// Results:
-// These examples show the result files being stored in a /results directory off
-// the current path.  This can be set to whatever you like.
-
-// ATM with 64k receiver buffers
-Receiver_Host: repeat 100 server -r -s -fm -p 10002 -b 65536
-Sender_Host: run_test 64 encip1-tango.cs.wustl.edu ./results/ace.atm.64 10002
-	 or: client -fm -s -t -l 1048576 -n 100 -h encip1-tango.cs.wustl.edu -L ./results/ace.atm.64 -p 10002
-
-// ATM with 8k receiver buffers
-Receiver_Host: repeat 100 wrapper-new-ttcp -r -s -fm -p 10002
-Sender_Host: run_test 64 encip1-tango.cs.wustl.edu ./results/ace.atm.8 10002
-
-// ETHERNET with 64k receiver buffers
-Receiver_Host: repeat 100 wrapper-new-ttcp -r -s -fm -p 10002 -b 65536
-Sender_Host: run_test 64 tango.cs.wustl.edu ./results/ace.ethernet.64 10002
-
-// ETHERNET with 8k receiver buffers
-Receiver_Host: repeat 100 wrapper-new-ttcp -r -s -fm -p 10002
-Sender_Host: run_test 64 tango.cs.wustl.edu ./results/ace.ethernet.8 10002
diff --git a/performance-tests/TTCP/ACE-C++/run_test b/performance-tests/TTCP/ACE-C++/run_test
deleted file mode 100644
index e07e6ed0c80..00000000000
--- a/performance-tests/TTCP/ACE-C++/run_test
+++ /dev/null
@@ -1,35 +0,0 @@
-# test_run 64 enatm0-kavita.cs.wustl.edu title 10002
-# repeat 100 wrapper-new-ttcp -r -s -fm -p 10002 -b 65536
-#!/bin/csh -f
-if ($#argv != 4) then
-	echo "Usage: sclt <Max msg size> <destination> <TitleOfThisTest> <port>" $4
-	exit 1
-endif
-#
-@ msize=1024
-@ limit= ($argv[1] * 1024)
-#echo $limit
-#echo $msize 
-echo "Iteration#" 1 ": wrapper-new-ttcp -fm -s -t -l" $msize "-h" $2 "-L" $3 "-p" $4
-wrapper-new-ttcp -fm -s -t -l $msize -h $2 -x -L $3 -p $4
-sleep 1
-set flag=0
-while ($msize <= $limit)
-  if ($flag == 0) goto label
-     echo "Iteration#" 1 ": wrapper-new-ttcp -fm -s -t -l" $msize "-h" $2 "-x -L" $3 "-p" $4
-     wrapper-new-ttcp -fm -s -t -l $msize -h $2 -x -L $3 -p $4
-     sleep 1
- label:
-  set flag=1
-  foreach i (2 3 4 5)
-	echo "Iteration#" $i ": wrapper-new-ttcp -fm -s -t -l" $msize "-h" $2 "-L " $3 "-p" $4
- 	wrapper-new-ttcp -fm -s -t -l $msize -h $2 -L $3 -p $4
-	sleep 1
-  end
-	echo "---------------------------"
-	@ msize = ($msize * 2)
-end 
-
-echo " "
-echo "Done at:" 
-date
diff --git a/performance-tests/TTCP/ACE-C++/wrapper-new-ttcp.cpp b/performance-tests/TTCP/ACE-C++/wrapper-new-ttcp.cpp
deleted file mode 100644
index 975048a4a7e..00000000000
--- a/performance-tests/TTCP/ACE-C++/wrapper-new-ttcp.cpp
+++ /dev/null
@@ -1,956 +0,0 @@
-// $Id$
-
-/*
- *    T T C P . C
- *
- * Test TCP connection.  Makes a connection on port 5001
- * and transfers fabricated buffers or data copied from stdin.
- *
- * Usable on 4.2, 4.3, and 4.1a systems by defining one of
- * BSD42 BSD43 (BSD41a)
- * Machines using System V with BSD sockets should define SYSV.
- *
- * Modified for operation under 4.2BSD, 18 Dec 84
- *      T.C. Slattery, USNA
- * Minor improvements, Mike Muuss and Terry Slattery, 16-Oct-85.
- * Modified in 1989 at Silicon Graphics, Inc.
- *      catch SIGPIPE to be able to print stats when receiver has died
- *      for tcp, don't look for sentinel during reads to allow small transfers
- *      increased default buffer size to 8K, nbuf to 2K to transfer 16MB
- *      moved default port to 5001, beyond IPPORT_USERRESERVED
- *      make sinkmode default because it is more popular,
- *              -s now means don't sink/source
- *      count number of read/write system calls to see effects of
- *              blocking from full socket buffers
- *      for tcp, -D option turns off buffered writes (sets TCP_NODELAY sockopt)
- *      buffer alignment options, -A and -O
- *      print stats in a format that's a bit easier to use with grep & awk
- *      for SYSV, mimic BSD routines to use most of the existing timing code
- * Modified by Steve Miller of the University of Maryland, College Park
- *      -b sets the socket buffer size (SO_SNDBUF/SO_RCVBUF)
- * Modified Sept. 1989 at Silicon Graphics, Inc.
- *      restored -s sense at request of tcs@brl
- * Modified Oct. 1991 at Silicon Graphics, Inc.
- *      use getopt(3) for option processing, add -f and -T options.
- *      SGI IRIX 3.3 and 4.0 releases don't need #define SYSV.
- * Modified Aug.1993 at University Paderborn, Germany
- *  some SVR4 changes and time functions changed to itimer() calls
- * Modified by Douglas C. Schmidt September 28, 1994
- *  added support for testing UNIX domain socket performance
- * Modified by Tim Harrison May, 1995
- *  added support for ACE wrappers
- * Distribution Status -
- *      Public Domain.  Distribution Unlimited.
- */
-
-/* #define BSD43 */
-/* #define BSD42 */
-/* #define BSD41a */
-// #define SYSV /* required on SGI IRIX releases before 3.3 */
-
-#include "ace/Log_Msg.h"
-#include "ace/SOCK_Connector.h"
-#include "ace/SOCK_Acceptor.h"
-
-#include <stdio.h>
-#include <signal.h>
-#include <ctype.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <malloc.h>
-#include <string.h>
-#include <stdlib.h>
-#include <memory.h>
-#include <netinet/tcp.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <sys/time.h>		/* struct itimerval */
-#include <limits.h>
-#include <sys/un.h>
-#include <unistd.h>
-
-ACE_SOCK_Connector connector_factory;
-ACE_SOCK_Acceptor acceptor_factory;
-ACE_INET_Addr address;
-
-#if defined(SYSV)
-#define bcopy(b1,b2,n)  memcpy(b2,b1,n)
-#define bzero(b1,n)             memset(b1,0,n)
-#include <sys/times.h>
-#include <sys/param.h>
-
-struct rusage
-  {
-    struct timeval ru_utime, ru_stime;
-  };
-#define RUSAGE_SELF 0
-
-#else
-#include <sys/resource.h>
-#endif
-
-struct sockaddr_in sinme;
-struct sockaddr_un sunme;
-struct sockaddr_in sinhim;
-struct sockaddr_un sunhim;
-struct sockaddr_in frominet;
-struct sockaddr_un fromunix;
-
-struct Session_Control_Message
-{
-  long nbuf_;
-  // number of buffers that will be sent this round.
-  long size_;
-  // size of the buffers that will be sent
-} session_control_buf;
-
-struct Data_Control_Message
-{
-  long size_;
-  char data_;
-} *message_buf;
-
-int fromlen;
-int domain = PF_INET;           /* Default is to use Internet domain sockets. */
-char *domainname;		/* Rendezvous address for UNIX domain sockets. */
-int fd;				/* fd of network socket */
-
-int data_buf_len = 1024 * 1024 * 2;  // length of data portion
-long total_msg_len; // length of entire message
-char *data_buf; // pointer to data portion
-int nbuf = 2 * 1024;		/* number of buffers to send in sinkmode */
-
-int bufoffset = 0;		/* align buffer to this */
-int bufalign = 16 * 1024;	/* modulo this */
-
-int udp = 0;			/* 0 = tcp, !0 = udp */
-int options = 0;		/* socket options */
-int one = 1;			/* for 4.3 BSD style setsockopt() */
-short port = 5001;		/* TCP port number */
-char *host;                     /* ptr to name of host */
-int trans;			/* 0=receive, !0=transmit mode */
-int sinkmode = 0;		/* 0=normal I/O, !0=sink/source mode */
-int verbose = 0;		/* 0=print basic info, 1=print cpu rate, proc
-				 * resource usage. */
-int nodelay = 0;		/* set TCP_NODELAY socket option */
-int b_flag = 0;			/* use mread() */
-int sockbufsize = 0;		/* socket buffer size to use */
-char fmt = 'K';			/* output format: k = kilobits, K = kilobytes,
-				 *  m = megabits, M = megabytes,
-				 *  g = gigabits, G = gigabytes */
-int touchdata = 0;		/* access data after reading */
-
-struct hostent *addr;
-extern int errno;
-extern int optind;
-extern char *optarg;
-
-char Usage[] = "\
-Usage: ttcp -t [-options] host [ < in ]\n\
-       ttcp -r [-options > out]\n\
-Common options:\n\
-        -l ##   length of bufs read from or written to network (default 8192)\n\
-        -u      use UDP instead of TCP\n\
-	-U      use UNIX domain sockets instead of Internet domain sockets\n\
-        -p ##   port number to send to or listen at (default 5001)\n\
-        -s      -t: source a pattern to network\n\
-                -r: sink (discard) all data from network\n\
-        -A      align the start of buffers to this modulus (default 16384)\n\
-        -O      start buffers at this offset from the modulus (default 0)\n\
-        -v      verbose: print more statistics\n\
-        -d      set SO_DEBUG socket option\n\
-        -b ##   set socket buffer size (if supported)\n\
-        -f X    format for rate: k,K = kilo{bit,byte}; m,M = mega; g,G = giga\n\
-Options specific to -t:\n\
-        -n##    number of source bufs written to network (default 2048)\n\
-        -D      don't buffer TCP writes (sets TCP_NODELAY socket option)\n\
-Options specific to -r:\n\
-        -B      for -s, only output full blocks as specified by -l (for TAR)\n\
-        -T      \"touch\": access each byte as it's read\n\
-";
-
-char stats[128];
-unsigned long nbytes;		/* bytes on net */
-unsigned long numCalls = 0;		/* # of I/O system calls */
-double cput, realt;		/* user, real time (seconds) */
-
-void err (char *s);
-void mes (char *s);
-void pattern (register char *cp, register int cnt);
-char *outfmt (double b);
-void prep_timer (void);
-double read_timer (char *str, int len);
-static void prusage (register struct rusage *r0, struct rusage *r1, struct timeval *e, struct timeval *b, char *outp);
-static void tvadd (struct timeval *tsum, struct timeval *t0, struct timeval *t1);
-static void tvsub (struct timeval *tdiff, struct timeval *t1, struct timeval *t0);
-static void psecs (long l, register char *cp);
-void delay (int us);
-int mread (int fd, register char *bufp, unsigned n);
-int Nread (ACE_SOCK_Stream &s, void *buf, int count);
-int Nwrite (ACE_SOCK_Stream &s, void *buf, int count);
-
-#if !defined (__cplusplus)
-typedef void (*SIG_TYP)();
-#else
-typedef void (*SIG_TYP)(int);
-#endif
-
-#ifdef SVR4
-void
-sigpipe (int foo)
-#else
-void
-sigpipe ()
-#endif
-{
-}
-
-void sigpipe(int foo)
-{
-   printf("Caught signal %d\n", foo);
-}
-
-char *title = 0;
-int new_line = 0;
-
-int
-main (int argc, char *argv[])
-{
-  ACE_SOCK_Stream connection_stream;
-  int c;
-
-  printf("HZ = %d\n", HZ);
-  if (argc < 2)
-    goto usage;
-
-  while ((c = getopt (argc, argv, "drstU:uvBDTb:f:l:n:p:A:O:L:xh:")) != -1)
-    {
-      switch (c)
-	{
-
-	case 'h':
-	  host = optarg;
-          break;
-	case 'x':
-	  new_line = 1;
-	  break;
-	case 'L':
-	  title = optarg;
-	  break;
-	case 'B':
-	  b_flag = 1;
-	  break;
-	case 't':
-	  trans = 1;
-	  break;
-	case 'r':
-	  trans = 0;
-	  break;
-	case 'd':
-	  options |= SO_DEBUG;
-	  break;
-	case 'D':
-#ifdef TCP_NODELAY
-	  nodelay = 1;
-#else
-	  fprintf (stderr,
-		   "ttcp: -D option ignored: TCP_NODELAY socket option not supported\n");
-#endif
-	  break;
-	case 'n':
-	  nbuf = atoi (optarg);
-	  break;
-	case 'l':
-	  data_buf_len = atoi (optarg);
-	  break;
-	case 's':
-	  sinkmode = !sinkmode;
-	  break;
-	case 'p':
-	  port = atoi (optarg);
-	  break;
-        case 'U':
-	  domain = PF_UNIX;
-	  domainname = optarg;
-	  break;
-	case 'u':
-	  udp = 1;
-	  break;
-	case 'v':
-	  verbose = 1;
-	  break;
-	case 'A':
-	  bufalign = atoi (optarg);
-	  break;
-	case 'O':
-	  bufoffset = atoi (optarg);
-	  break;
-	case 'b':
-#if defined(SO_SNDBUF) || defined(SO_RCVBUF)
-	  sockbufsize = atoi (optarg);
-#else
-	  fprintf (stderr, "ttcp: -b option ignored: SO_SNDBUF/SO_RCVBUF socket options not supported\n");
-#endif
-	  break;
-	case 'f':
-	  fmt = *optarg;
-	  break;
-	case 'T':
-	  touchdata = 1;
-	  break;
-
-	default:
-	  goto usage;
-	}
-    }
-
-  /* if transmitter, create remote address to transmit to.  */
-
-  if (trans)
-    {
-      if (address.set (port, host) == -1)
-	perror ("address.set"), exit (1);
-    }
-
-  /* else, receiver create address to listen on */
-  else
-    {
-      address.set (port);
-    }
-
-  total_msg_len = sizeof (long) + data_buf_len;
-
-  // allocate the buffer
-  message_buf = (Data_Control_Message *) malloc (total_msg_len);
-  if (message_buf == 0)
-    err ("malloc");
-
-//  if (bufalign != 0)
-//    message_buf += (bufalign - ((int) message_buf % bufalign) + bufoffset) % bufalign;
-
-  // let's go ahead and set the control message for every send right now
-  message_buf->size_ = data_buf_len;
-
-  session_control_buf.nbuf_ = nbuf;
-  session_control_buf.size_ = data_buf_len;
-
-  //
-  // print out option values for trans and receiver
-  //
-
-  if (trans)
-    {
-      fprintf (stdout,
-	       "ttcp-t: data_buf_len=%d, nbuf=%d, align=%d/%d, port=%d",
-	       data_buf_len, nbuf, bufalign, bufoffset, port);
-      if (sockbufsize)
-	fprintf (stdout, ", sockbufsize=%d", sockbufsize);
-      fprintf (stdout, "  %s  -> %s\n",
-	       domain == PF_INET ? (udp ? "udp" : "tcp") : "unix",
-	       host == 0 ? domainname : host);
-    }
-  else // receiver
-    {
-      fprintf (stdout,
-	       "ttcp-r: data_buf_len=%d, nbuf=%d, align=%d/%d, port=%d",
-	       data_buf_len, nbuf, bufalign, bufoffset, port);
-      if (sockbufsize)
-	fprintf (stdout, ", sockbufsize=%d", sockbufsize);
-      fprintf (stdout, "  %s\n", domain == PF_INET ? (udp ? "udp" : "tcp") : "unix");
-    }
-
-  mes ("socket");
-
-  //
-  // connect and accept
-  //
-
-  if (!udp)
-    {
-      signal (SIGPIPE, (SIG_TYP) sigpipe);
-
-      /* the transmitter will set options and connect to receiver */
-      if (trans)
-	{
-	  // turn off weird ack things
-	  if (nodelay)
-	    {
-	      struct protoent *p = getprotobyname ("tcp");
-
-	      if (p && connection_stream.set_option (p->p_proto,
-						     TCP_NODELAY,
-						     (char *)& one,
-						     sizeof (one)))
-		err ("setsockopt: nodelay");
-	      mes ("nodelay");
-	    }
-	  if (connector_factory.connect (connection_stream, address) == -1)
-	    perror ("connection failed"), exit (1);
-	  fprintf (stdout,
-		   "ttcp-t: data_buf_len=%d, nbuf=%d, align=%d/%d, port=%d",
-		   data_buf_len, nbuf, bufalign, bufoffset, port);
-
-	  if (sockbufsize)
-	    {
-	      if (connection_stream.set_option (SOL_SOCKET,
-						SO_SNDBUF,
-						(char *) &sockbufsize,
-						sizeof sockbufsize) == -1)
-		err ("acceptor_factory.set_option");
-	      mes ("sndbuf");
-	    }
-	}
-
-      /* receiver will listen for connections from the transmitter */
-      else
-	{
-	  if (acceptor_factory.open (address, 1) == -1)
-	    perror ("acceptor open"), exit (1);
-
-	  if (sockbufsize)
-		{
-		  if (connection_stream.set_option (SOL_SOCKET,
-						   SO_RCVBUF,
-						   (char *) &sockbufsize,
-						   sizeof sockbufsize) == -1)
-		    err ("acceptor_factory.set_option");
-		  mes ("rcvbuf");
-		}
-
-	  ACE_INET_Addr remote_address;
-
-	  if (acceptor_factory.accept (connection_stream,
-				       (ACE_Addr *) &remote_address) == -1)
-	    perror ("acceptor accept"), exit (1);
-
-	  // set the window size
-
-	  fprintf (stderr, "ttcp-r: accept from %s\n", remote_address.get_host_name());
-	}
-    }
-
-  //
-  // start timer
-  //
-
-  errno = 0;
-  if (trans)
-    {
-      pattern (& (message_buf->data_), data_buf_len);
-      prep_timer ();
-
-      ACE_DEBUG ((LM_DEBUG, "Sending session control message"
-		  " nbuf %d, size %d\n", session_control_buf.nbuf_,
-		  session_control_buf.size_));
-      if (connection_stream.send_n ((char *) &session_control_buf,
-				    sizeof (Session_Control_Message))
-	  != sizeof (Session_Control_Message))
-	ACE_ERROR_RETURN ((LM_ERROR, "%p send session control failed\n",
-			   "ttcp"), -1);
-
-      long ack;
-      int send_result;
-      while (nbuf--)
-	{
-	  send_result = connection_stream.send_n ((char *) message_buf, total_msg_len);
-	  if (send_result != total_msg_len)
-	    ACE_ERROR_RETURN ((LM_ERROR, "%p only sent %d of %d bytes on call %d\n",
-			       "ttcp", send_result, total_msg_len, numCalls + 1), -1);
-	  numCalls++;
-	  nbytes += data_buf_len;
-
-	  if (connection_stream.recv_n ((char *) &ack, sizeof ack)
-	      != sizeof ack)
-	    ACE_ERROR_RETURN ((LM_ERROR, "%p recv of ack failed\n",
-			       "ttcp"), -1);
-
-	  if (ack != data_buf_len)
-	    ACE_DEBUG ((LM_DEBUG, "received ack for only %d bytes\n", ack));
-	}
-        printf("Client finished. \n");
-    }
-  else
-    {
-      prep_timer ();
-
-      if (connection_stream.recv_n ((char *) &session_control_buf,
-				    sizeof (Session_Control_Message))
-	  != sizeof (Session_Control_Message))
-	ACE_ERROR_RETURN ((LM_ERROR, "%p recv session control failed\n",
-			   "ttcp"), -1);
-
-      ACE_DEBUG ((LM_DEBUG, "received session control message"
-		  " nbuf %d, size %d\n", session_control_buf.nbuf_,
-		  session_control_buf.size_));
-
-      nbuf = session_control_buf.nbuf_;
-      // ignore session_control_buf.size_ for now
-
-      long cnt;
-
-      while (nbuf--)
-	{
-	  if (connection_stream.recv_n ((char *) message_buf, sizeof (long))
-	      != sizeof (long))
-	    ACE_ERROR_RETURN ((LM_ERROR, "%p recv data control failed\n",
-			       "ttcp"), -1);
-
-	  cnt = connection_stream.recv_n (& (message_buf->data_), message_buf->size_);
-	  if (cnt != message_buf->size_)
-	    ACE_ERROR_RETURN ((LM_ERROR, "recv data failed\n"), -1);
-
-	  numCalls++;
-	  nbytes += cnt;
-
-	  if (connection_stream.send_n ((char *) &cnt, sizeof cnt)
-	      != sizeof cnt)
-	    ACE_ERROR_RETURN ((LM_ERROR, "%p send ack failed\n",
-			       "ttcp"), -1);
-	}
-        printf("Server finished. \n");
-    }
-
-  /*  if (errno)
-    err ("IO");
-    */
-  //
-  // stop the timer
-  //
-
-  (void) read_timer (stats, sizeof (stats));
-  if (udp && trans)
-    {
-      (void) Nwrite (connection_stream, message_buf, 4);	/* rcvr end */
-      (void) Nwrite (connection_stream, message_buf, 4);	/* rcvr end */
-      (void) Nwrite (connection_stream, message_buf, 4);	/* rcvr end */
-      (void) Nwrite (connection_stream, message_buf, 4);	/* rcvr end */
-    }
-  if (cput <= 0.0)
-    cput = 0.001;
-  if (realt <= 0.0)
-    realt = 0.001;
-
-#if defined (LM_RESULTS)
-  if (trans && (title != 0))
-    {
-      double tmp;
-      FILE *fd;
-      char filename[BUFSIZ];
-      ACE_OS::sprintf (filename, "%s.results", title);
-      fd = fopen(filename,"a+");
-      if (new_line)
-	fprintf(fd,"\n  -l %ldk \t", data_buf_len/1024);
-      tmp = ((double) nbytes) / realt;
-      fprintf(fd,"%.2f ", tmp * 8.0 / 1024.0 / 1024.0);
-      fclose(fd);
-    }
-#endif
-
-  fprintf (stdout,
-	   "ttcp%s: %ld bytes in %.2f real seconds = %s/sec +++\n",
-	   trans ? "-t" : "-r",
-	   nbytes, realt, outfmt (((double) nbytes) / realt));
-  if (verbose)
-    {
-      fprintf (stdout,
-	       "ttcp%s: %ld bytes in %.2f CPU seconds = %s/cpu sec\n",
-	       trans ? "-t" : "-r",
-	       nbytes, cput, outfmt (((double) nbytes) / cput));
-    }
-  fprintf (stdout,
-	   "ttcp%s: %d I/O calls, msec/call = %.2f, calls/sec = %.2f\n",
-	   trans ? "-t" : "-r",
-	   numCalls,
-	   1024.0 * realt / ((double) numCalls),
-	   ((double) numCalls) / realt);
-  fprintf (stdout, "ttcp%s: %s\n", trans ? "-t" : "-r", stats);
-  if (verbose)
-    {
-      fprintf (stdout,
-	       "ttcp%s: buffer address %#x\n",
-	       trans ? "-t" : "-r",
-	       message_buf);
-    }
-  exit (0);
-
-usage:
-  fprintf (stderr, Usage);
-  return 1;
-}
-
-void
-err (char *s)
-{
-  fprintf (stderr, "ttcp%s: ", trans ? "-t" : "-r");
-  perror (s);
-  fprintf (stderr, "errno=%d\n", errno);
-  exit (1);
-}
-
-void
-mes (char *s)
-{
-  fprintf (stderr, "ttcp%s: %s\n", trans ? "-t" : "-r", s);
-}
-
-void
-pattern (register char *cp, register int cnt)
-{
-  register char c;
-  c = 0;
-  while (cnt-- > 0)
-    {
-      while (!isprint ((c & 0x7F)))
-	c++;
-      *cp++ = (c++ & 0x7F);
-    }
-}
-
-char *
-outfmt (double b)
-{
-  static char obuf[50];
-  switch (fmt)
-    {
-    case 'G':
-      sprintf (obuf, "%.2f GB", b / 1024.0 / 1024.0 / 1024.0);
-      break;
-    default:
-    case 'K':
-      sprintf (obuf, "%.2f KB", b / 1024.0);
-      break;
-    case 'M':
-      sprintf (obuf, "%.2f MB", b / 1024.0 / 1024.0);
-      break;
-    case 'g':
-      sprintf (obuf, "%.2f Gbit", b * 8.0 / 1024.0 / 1024.0 / 1024.0);
-      break;
-    case 'k':
-      sprintf (obuf, "%.2f Kbit", b * 8.0 / 1024.0);
-      break;
-    case 'm':
-      sprintf (obuf, "%.2f Mbit", b * 8.0 / 1024.0 / 1024.0);
-      break;
-    }
-  return obuf;
-}
-
-static struct itimerval itime0;	/* Time at which timing started */
-static struct rusage ru0;	/* Resource utilization at the start */
-
-#if defined(SYSV)
-/*ARGSUSED */
-static void
-getrusage (int ignored, register struct rusage *ru)
-{
-  struct tms buf;
-
-  times (&buf);
-
-  /* Assumption: HZ <= 2147 (LONG_MAX/1000000) */
-  ru->ru_stime.tv_sec = buf.tms_stime / HZ;
-  ru->ru_stime.tv_usec = ((buf.tms_stime % HZ) * 1000000) / HZ;
-  ru->ru_utime.tv_sec = buf.tms_utime / HZ;
-  ru->ru_utime.tv_usec = ((buf.tms_utime % HZ) * 1000000) / HZ;
-}
-
-#endif /* SYSV */
-/*
- *                    P R E P _ T I M E R
- */
-void
-prep_timer ()
-{
-  itime0.it_interval.tv_sec = 0;
-  itime0.it_interval.tv_usec = 0;
-  //  itime0.it_value.tv_sec = LONG_MAX / 22;	/* greatest possible value , itimer() count backwards */
-  itime0.it_value.tv_sec = 3600;
-  itime0.it_value.tv_usec = 0;
-
-
-  getrusage (RUSAGE_SELF, &ru0);
-  fprintf(stdout, "\n");
-  fprintf(stdout, "beginning user time = %d sec and %d usec\n", ru0.ru_utime.tv_sec, ru0.ru_utime.tv_usec);
-  fprintf(stdout, "beginning sys time = %d sec and %d usec\n", ru0.ru_stime.tv_sec, ru0.ru_stime.tv_usec);
-
-  /* Init REAL Timer */
-  if (setitimer (ITIMER_REAL, &itime0, NULL))
-    {
-      perror ("Setting 'itimer' REAL failed");
-      return;
-    }
-  fprintf(stdout, "Beginning transaction time = %d sec and %d usec\n", itime0.it_value.tv_sec, itime0.it_value.tv_usec);
-}
-
-/*
- *                    R E A D _ T I M E R
- *
- */
-double
-read_timer (char *str, int len)
-{
-  struct itimerval itimedol;
-  struct rusage ru1;
-  struct timeval td;
-  struct timeval tend, tstart;
-  char line[132];
-
-  getrusage (RUSAGE_SELF, &ru1);
-  fprintf(stdout, "final user time = %d sec and %d usec\n", ru1.ru_utime.tv_sec, ru1.ru_utime.tv_usec);
-  fprintf(stdout, "final sys time = %d sec and %d usec\n", ru1.ru_stime.tv_sec, ru1.ru_stime.tv_usec);
-
-  if (getitimer (ITIMER_REAL, &itimedol))
-    {
-      perror ("Getting 'itimer' REAL failed");
-      return (0.0);
-
-    }
-  fprintf(stdout, "End transaction time = %d sec and %d usec\n", itimedol.it_value.tv_sec, itimedol.it_value.tv_usec);
-  prusage (&ru0, &ru1, &itime0.it_value, &itimedol.it_value, line);
-  (void) strncpy (str, line, len);
-
-  /* Get real time */
-  tvsub (&td, &itime0.it_value, &itimedol.it_value);
-  realt = td.tv_sec + ((double) td.tv_usec) / 1000000;
-
-  /* Get CPU time (user+sys) */
-  tvadd (&tend, &ru1.ru_utime, &ru1.ru_stime);
-  tvadd (&tstart, &ru0.ru_utime, &ru0.ru_stime);
-  tvsub (&td, &tend, &tstart);
-  cput = td.tv_sec + ((double) td.tv_usec) / 1000000;
-  if (cput < 0.00001)
-    cput = 0.00001;
-  return (cput);
-}
-
-static void
-prusage (register struct rusage *r0, struct rusage *r1, 
-	 struct timeval *b, struct timeval *e,  char *outp)
-{
-  struct timeval tdiff;
-  register time_t t;
-  register char *cp;
-  register int i;
-  int ms;
-
-  t = (r1->ru_utime.tv_sec - r0->ru_utime.tv_sec) * 1000 +
-    (r1->ru_utime.tv_usec - r0->ru_utime.tv_usec) / 100000 +
-    (r1->ru_stime.tv_sec - r0->ru_stime.tv_sec) * 1000 +
-    (r1->ru_stime.tv_usec - r0->ru_stime.tv_usec) / 100000;
-  ms = -((e->tv_sec - b->tv_sec) * 1000 + (e->tv_usec - b->tv_usec) / 1000);/* in milliseconds */
-
-#define END(x)  {while(*x) x++;}
-#if defined(SYSV)
-  cp = "%Uuser %Ssys %Ereal %P";
-#else
-#if defined(sgi)		/* IRIX 3.3 will show 0 for %M,%F,%R,%C */
-  cp = "%Uuser %Ssys %Ereal %P %Mmaxrss %F+%Rpf %Ccsw";
-#else
-  cp = "%Uutime %Sstime %Edtime %P cpu occupancy";
-  /*  cp = "%Uuser %Ssys %Ereal %P %Xi+%Dd %Mmaxrss %F+%Rpf %Ccsw";*/
-#endif
-#endif
-  for (; *cp; cp++)
-    {
-      if (*cp != '%')
-	*outp++ = *cp;
-      else if (cp[1])
-	switch (*++cp)
-	  {
-
-	  case 'U':
-	    tvsub (&tdiff, &r1->ru_utime, &r0->ru_utime);
-	    /*	    sprintf (outp, "%d.%01d", tdiff.tv_sec, tdiff.tv_usec);*/
-            sprintf (outp, "%f", (tdiff.tv_sec + tdiff.tv_usec/1000000.0));
-	    END (outp);
-	    break;
-
-	  case 'S':
-	    tvsub (&tdiff, &r1->ru_stime, &r0->ru_stime);
-	    /*	    sprintf (outp, "%d.%01d", tdiff.tv_sec, tdiff.tv_usec);*/
-            sprintf (outp, "%f", (tdiff.tv_sec + tdiff.tv_usec/1000000.0));
-	    END (outp);
-	    break;
-
-	  case 'E':
-	    psecs (ms / 1000, outp);
-	    END (outp);
-	    break;
-
-	  case 'P':
-	    sprintf (outp, "%f%%",  (t * 100.0 / ((ms ? ms : 1))));
-	    END (outp);
-	    break;
-
-#if !defined(SYSV)
-	  case 'W':
-	    i = r1->ru_nswap - r0->ru_nswap;
-	    sprintf (outp, "%d", i);
-	    END (outp);
-	    break;
-
-	  case 'X':
-	    sprintf (outp, "%d", t == 0 ? 0 : (r1->ru_ixrss - r0->ru_ixrss) / t);
-	    END (outp);
-	    break;
-
-	  case 'D':
-	    sprintf (outp, "%d", t == 0 ? 0 :
-		     (r1->ru_idrss + r1->ru_isrss - (r0->ru_idrss + r0->ru_isrss)) / t);
-	    END (outp);
-	    break;
-
-	  case 'K':
-	    sprintf (outp, "%d", t == 0 ? 0 :
-		     ((r1->ru_ixrss + r1->ru_isrss + r1->ru_idrss) -
-		      (r0->ru_ixrss + r0->ru_idrss + r0->ru_isrss)) / t);
-	    END (outp);
-	    break;
-
-	  case 'M':
-	    sprintf (outp, "%d", r1->ru_maxrss / 2);
-	    END (outp);
-	    break;
-
-	  case 'F':
-	    sprintf (outp, "%d", r1->ru_majflt - r0->ru_majflt);
-	    END (outp);
-	    break;
-
-	  case 'R':
-	    sprintf (outp, "%d", r1->ru_minflt - r0->ru_minflt);
-	    END (outp);
-	    break;
-
-	  case 'I':
-	    sprintf (outp, "%d", r1->ru_inblock - r0->ru_inblock);
-	    END (outp);
-	    break;
-
-	  case 'O':
-	    sprintf (outp, "%d", r1->ru_oublock - r0->ru_oublock);
-	    END (outp);
-	    break;
-	  case 'C':
-	    sprintf (outp, "%d+%d", r1->ru_nvcsw - r0->ru_nvcsw,
-		     r1->ru_nivcsw - r0->ru_nivcsw);
-	    END (outp);
-	    break;
-#endif /* !SYSV */
-	  }
-    }
-  *outp = '\0';
-}
-
-static void
-tvadd (struct timeval *tsum, struct timeval *t0, struct timeval *t1)
-{
-
-  tsum->tv_sec = t0->tv_sec + t1->tv_sec;
-  tsum->tv_usec = t0->tv_usec + t1->tv_usec;
-  if (tsum->tv_usec > 1000000)
-    tsum->tv_sec++, tsum->tv_usec -= 1000000;
-}
-
-static void
-tvsub (struct timeval *tdiff, struct timeval *t1, struct timeval *t0)
-{
-
-  tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
-  tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
-  if (tdiff->tv_usec < 0)
-    tdiff->tv_sec--, tdiff->tv_usec += 1000000;
-}
-
-static void
-psecs (long l, register char *cp)
-{
-  register int i;
-
-  i = l / 3600;
-  if (i)
-    {
-      sprintf (cp, "%d hours", i);
-      END (cp);
-      i = l % 3600;
-      sprintf (cp, "%d minutes ", (i / 60));
-      sprintf (cp, "%d seconds ", (i % 60));
-      END (cp);
-    }
-  else
-    {
-      i = l;
-      sprintf (cp, "%d minutes ", i / 60);
-      END (cp);
-    }
-  i %= 60;
-  *cp++ = ':';
-  sprintf (cp, "%d seconds ", i);
-}
-
-/*
- *                    N R E A D
- */
-int
-Nread (ACE_SOCK_Stream &s, void *buf, int count)
-{
-  numCalls++;
-  return (s.recv (buf, count));
-}
-
-/*
- *                    N W R I T E
- */
-int
-Nwrite (ACE_SOCK_Stream &s, void *buf, int count)
-{
-  numCalls++;
-  return s.send (buf, count);
-}
-
-void
-delay (int us)
-{
-  struct timeval tv;
-
-  tv.tv_sec = 0;
-  tv.tv_usec = us;
-  (void) select (1, (fd_set *) 0, (fd_set *) 0, (fd_set *) 0, &tv);
-}
-
-/*
- *                    M R E A D
- *
- * This function performs the function of a read(II) but will
- * call read(II) multiple times in order to get the requested
- * number of characters.  This can be necessary because
- * network connections don't deliver data with the same
- * grouping as it is written with.  Written by Robert S. Miles, BRL.
- */
-int
-mread (int fd, register char *bufp, unsigned n)
-{
-  register unsigned count = 0;
-  register int nread;
-
-  do
-    {
-      nread = read (fd, bufp, n - count);
-      numCalls++;
-      if (nread < 0)
-	{
-	  perror ("ttcp_mread");
-	  return (-1);
-	}
-      if (nread == 0)
-	return ((int) count);
-      count += (unsigned) nread;
-      bufp += nread;
-    }
-  while (count < n);
-
-  return ((int) count);
-}
-
diff --git a/performance-tests/TTCP/C/How_to_run_tests b/performance-tests/TTCP/C/How_to_run_tests
deleted file mode 100644
index c08a515a5af..00000000000
--- a/performance-tests/TTCP/C/How_to_run_tests
+++ /dev/null
@@ -1,30 +0,0 @@
-// C version
-//
-//
-
-// HOSTNAMES:
-// for our tests, enatm0-tango.cs.wustl.edu was the receiver hostname used for atm transfers
-//                tango.cs.wustl.edu was the receiver hostname used for ethernet transfers
-// substitute the proper receiver hostname for your system.
-
-// Results:
-// These examples show the result files being stored in a /results directory off
-// the current path.  This can be set to whatever you like.
-
-// ATM with 32k receiver buffers
-Receiver_Host: repeat 100 server -r -s -fm -p 10002 -b 65536
-Sender_Host: run_test 64 encip1-tango.cs.wustl.edu ./results/ace.atm.64 10002
-	 or: client -fm -s -t -l 1048576 -n 100 -h encip1-tango.cs.wustl.edu -L ./results/ace.atm.64 -p 10002
-
-// ATM with 8k receiver buffers
-Receiver_Host: repeat 100 new-ttcp -r -s -fm -p 10002
-Sender_Host: run_test 64 enatm0-tango.cs.wustl.edu ./results/c.atm.8 10002
-
-// ETHERNET with 64k receiver buffers
-Receiver_Host: repeat 100 new-ttcp -r -s -fm -p 10002 -b 65536
-Sender_Host: run_test 64 tango.cs.wustl.edu ./results/c.ethernet.64 10002
-
-// ETHERNET with 8k receiver buffers
-Receiver_Host: repeat 100 new-ttcp -r -s -fm -p 10002
-Sender_Host: run_test 64 tango.cs.wustl.edu ./results/c.ethernet.8 10002
-
diff --git a/performance-tests/TTCP/C/README b/performance-tests/TTCP/C/README
deleted file mode 100644
index 0da8b3d8010..00000000000
--- a/performance-tests/TTCP/C/README
+++ /dev/null
@@ -1,35 +0,0 @@
-
-		TTCP for c_version and ACE-wrappers
-		----------------------------------------------------
-
-This is the super-readme file for the "ttcp" code. This directory
-contains the C and ACE-wrappers versions of ttcp code. To compile the
-code, you have to do the following:
-
-1. You should have ACE installed in your system and configured
-   correctly. (see the reference manual for installation and
-   configuration procedure) 
-
-2. Copy this directory (ttcp) in the same directory structure to your
-   disk space. 
-
-3. setup the following environment parameters (before compilation stage):
-   ACE_ROOT, LD_LIBRARY_PATH.
-
-For example:
-ACE_ROOT=/project/adaptive/ACE_wrappers
-LD_LIBRARY_PATH=/project/adaptive/ACE_wrappers/build/SunOS5.4/ace
-
-4. Do make (using GNU make) in this directory level. This will create
-   the executable ttcp target code for each ttcp version.
-
-5. Read the README or How_to_run_tests file existing in each directory
-   to know how to use the  executable.
-
-6. Have fun.
-
-Ehab S. Al-Shaer
-6/30/1995
-
-
-
diff --git a/performance-tests/TTCP/C/new-ttcp.cpp b/performance-tests/TTCP/C/new-ttcp.cpp
deleted file mode 100644
index a897f5b39a3..00000000000
--- a/performance-tests/TTCP/C/new-ttcp.cpp
+++ /dev/null
@@ -1,970 +0,0 @@
-// $Id$
-
-/*
- *    T T C P . C
- *
- * Test TCP connection.  Makes a connection on port 5001
- * and transfers fabricated buffers or data copied from stdin.
- *
- * Usable on 4.2, 4.3, and 4.1a systems by defining one of
- * BSD42 BSD43 (BSD41a)
- * Machines using System V with BSD sockets should define SYSV.
- *
- * Modified for operation under 4.2BSD, 18 Dec 84
- *      T.C. Slattery, USNA
- * Minor improvements, Mike Muuss and Terry Slattery, 16-Oct-85.
- * Modified in 1989 at Silicon Graphics, Inc.
- *      catch SIGPIPE to be able to print stats when receiver has died 
- *      for tcp, don't look for sentinel during reads to allow small transfers
- *      increased default buffer size to 8K, nbuf to 2K to transfer 16MB
- *      moved default port to 5001, beyond IPPORT_USERRESERVED
- *      make sinkmode default because it is more popular, 
- *              -s now means don't sink/source 
- *      count number of read/write system calls to see effects of 
- *              blocking from full socket buffers
- *      for tcp, -D option turns off buffered writes (sets TCP_NODELAY sockopt)
- *      buffer alignment options, -A and -O
- *      print stats in a format that's a bit easier to use with grep & awk
- *      for SYSV, mimic BSD routines to use most of the existing timing code
- * Modified by Steve Miller of the University of Maryland, College Park
- *      -b sets the socket buffer size (SO_SNDBUF/SO_RCVBUF)
- * Modified Sept. 1989 at Silicon Graphics, Inc.
- *      restored -s sense at request of tcs@brl
- * Modified Oct. 1991 at Silicon Graphics, Inc.
- *      use getopt(3) for option processing, add -f and -T options.
- *      SGI IRIX 3.3 and 4.0 releases don't need #define SYSV.
- * Modified Aug.1993 at University Paderborn, Germany
- *  some SVR4 changes and time functions changed to itimer() calls
- * Modified by Douglas C. Schmidt September 28, 1994
- *  added support for testing UNIX domain socket performance
- * Modified by Tim Harrison May, 1995
- *  added support for ACE wrappers
- * Distribution Status -
- *      Public Domain.  Distribution Unlimited.
- */
-
-/* #define BSD43 */
-/* #define BSD42 */
-/* #define BSD41a */
-#define SYSV /* required on SGI IRIX releases before 3.3 */
-
-#include "ace/Log_Msg.h"
-#include "ace/SOCK_Connector.h"
-#include "ace/SOCK_Acceptor.h"
-
-#include <stdio.h>
-#include <signal.h>
-#include <ctype.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <malloc.h>
-#include <string.h>
-#include <stdlib.h>
-#include <memory.h>
-#include <netinet/tcp.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <sys/time.h>		/* struct itimerval */
-#include <limits.h>
-#include <sys/un.h>
-#include <unistd.h>
-
-ACE_SOCK_Connector connector_factory;
-ACE_SOCK_Acceptor acceptor_factory;
-ACE_INET_Addr address;
-
-#if defined(SYSV)
-#define bcopy(b1,b2,n)  memcpy(b2,b1,n)
-#define bzero(b1,n)             memset(b1,0,n)
-#include <sys/times.h>
-#include <sys/param.h>
-struct rusage
-  {
-    struct timeval ru_utime, ru_stime;
-  };
-#define RUSAGE_SELF 0
-
-#else
-#include <sys/resource.h>
-#endif
-
-ACE_RCSID(C, new_ttcp, "$Id$")
-
-struct sockaddr_in sinme;
-struct sockaddr_un sunme;
-struct sockaddr_in sinhim;
-struct sockaddr_un sunhim;
-struct sockaddr_in frominet;
-struct sockaddr_un fromunix;
-
-int send_n (const void *buf, int len);
-int recv_n (void *buf, int len);
-int connection_descriptor;
-
-struct Session_Control_Message
-{
-  long nbuf_; 
-  // number of buffers that will be sent this round.
-  long size_;
-  // size of the buffers that will be sent
-} session_control_buf;
-
-struct Data_Control_Message
-{
-  long size_;
-  char data_;
-} *message_buf;
-
-int fromlen;
-int domain = PF_INET;           /* Default is to use Internet domain sockets. */
-char *domainname;		/* Rendezvous address for UNIX domain sockets. */
-int fd;				/* fd of network socket */
-
-int data_buf_len = 1024 * 1024 * 2;  // length of data portion
-long total_msg_len; // length of entire message
-char *data_buf; // pointer to data portion
-int nbuf = 2 * 1024;		/* number of buffers to send in sinkmode */
-
-int bufoffset = 0;		/* align buffer to this */
-int bufalign = 16 * 1024;	/* modulo this */
-
-int udp = 0;			/* 0 = tcp, !0 = udp */
-int options = 0;		/* socket options */
-int one = 1;			/* for 4.3 BSD style setsockopt() */
-short port = 5001;		/* TCP port number */
-char *host;                     /* ptr to name of host */
-int trans;			/* 0=receive, !0=transmit mode */
-int sinkmode = 0;		/* 0=normal I/O, !0=sink/source mode */
-int verbose = 0;		/* 0=print basic info, 1=print cpu rate, proc
-				 * resource usage. */
-int nodelay = 0;		/* set TCP_NODELAY socket option */
-int b_flag = 0;			/* use mread() */
-int sockbufsize = 0;		/* socket buffer size to use */
-char fmt = 'K';			/* output format: k = kilobits, K = kilobytes,
-				 *  m = megabits, M = megabytes, 
-				 *  g = gigabits, G = gigabytes */
-int touchdata = 0;		/* access data after reading */
-
-struct hostent *addr;
-extern int errno;
-extern int optind;
-extern char *optarg;
-
-char Usage[] = "\
-Usage: ttcp -t [-options] host [ < in ]\n\
-       ttcp -r [-options > out]\n\
-Common options:\n\
-        -l ##   length of bufs read from or written to network (default 8192)\n\
-        -u      use UDP instead of TCP\n\
-	-U      use UNIX domain sockets instead of Internet domain sockets\n\
-        -p ##   port number to send to or listen at (default 5001)\n\
-        -s      -t: source a pattern to network\n\
-                -r: sink (discard) all data from network\n\
-        -A      align the start of buffers to this modulus (default 16384)\n\
-        -O      start buffers at this offset from the modulus (default 0)\n\
-        -v      verbose: print more statistics\n\
-        -d      set SO_DEBUG socket option\n\
-        -b ##   set socket buffer size (if supported)\n\
-        -f X    format for rate: k,K = kilo{bit,byte}; m,M = mega; g,G = giga\n\
-Options specific to -t:\n\
-        -n##    number of source bufs written to network (default 2048)\n\
-        -D      don't buffer TCP writes (sets TCP_NODELAY socket option)\n\
-Options specific to -r:\n\
-        -B      for -s, only output full blocks as specified by -l (for TAR)\n\
-        -T      \"touch\": access each byte as it's read\n\
-";
-
-char stats[128];
-unsigned long nbytes;		/* bytes on net */
-unsigned long numCalls = 0;		/* # of I/O system calls */
-double cput, realt;		/* user, real time (seconds) */
-
-void err (char *s);
-void mes (char *s);
-void pattern (register char *cp, register int cnt);
-char *outfmt (double b);
-static void getrusage (int ignored, register struct rusage *ru);
-void prep_timer (void);
-double read_timer (char *str, int len);
-static void prusage (register struct rusage *r0, struct rusage *r1, struct timeval *e, struct timeval *b, char *outp);
-static void tvadd (struct timeval *tsum, struct timeval *t0, struct timeval *t1);
-static void tvsub (struct timeval *tdiff, struct timeval *t1, struct timeval *t0);
-static void psecs (long l, register char *cp);
-void delay (int us);
-int mread (int fd, register char *bufp, unsigned n);
-int Nread (ACE_SOCK_Stream &s, void *buf, int count);
-int Nwrite (ACE_SOCK_Stream &s, void *buf, int count);
-
-#if !defined (__cplusplus)
-typedef void (*SIG_TYP)(); 
-#endif 
-
-#ifdef SVR4
-void
-sigpipe (int foo)
-#else
-void
-sigpipe ()
-#endif
-{
-}
-
-char *title = 0;
-int new_line = 0;
-
-int
-main (int argc, char *argv[])
-{
-  ACE_SOCK_Stream connection_stream;
-  unsigned long addr_tmp;
-  int c;
-
-  if (argc < 2)
-    goto usage;
-
-  while ((c = getopt (argc, argv, "drstU:uvBDTb:f:l:n:p:A:O:L:xh:")) != -1)
-    {
-      switch (c)
-	{
-
-	case 'h':
-	  host = optarg;
-          break;
-	case 'x':
-	  new_line = 1;
-	  break;
-	case 'L':
-	  title = optarg;
-	  break;
-	case 'B':
-	  b_flag = 1;
-	  break;
-	case 't':
-	  trans = 1;
-	  break;
-	case 'r':
-	  trans = 0;
-	  break;
-	case 'd':
-	  options |= SO_DEBUG;
-	  break;
-	case 'D':
-#ifdef TCP_NODELAY
-	  nodelay = 1;
-#else
-	  fprintf (stderr,
-		   "ttcp: -D option ignored: TCP_NODELAY socket option not supported\n");
-#endif
-	  break;
-	case 'n':
-	  nbuf = atoi (optarg);
-	  break;
-	case 'l':
-	  data_buf_len = atoi (optarg);
-	  break;
-	case 's':
-	  sinkmode = !sinkmode;
-	  break;
-	case 'p':
-	  port = atoi (optarg);
-	  break;
-        case 'U':
-	  domain = PF_UNIX;
-	  domainname = optarg;
-	  break;
-	case 'u':
-	  udp = 1;
-	  break;
-	case 'v':
-	  verbose = 1;
-	  break;
-	case 'A':
-	  bufalign = atoi (optarg);
-	  break;
-	case 'O':
-	  bufoffset = atoi (optarg);
-	  break;
-	case 'b':
-#if defined(SO_SNDBUF) || defined(SO_RCVBUF)
-	  sockbufsize = atoi (optarg);
-#else
-	  fprintf (stderr, "ttcp: -b option ignored: SO_SNDBUF/SO_RCVBUF socket options not supported\n");
-#endif
-	  break;
-	case 'f':
-	  fmt = *optarg;
-	  break;
-	case 'T':
-	  touchdata = 1;
-	  break;
-
-	default:
-	  goto usage;
-	}
-    }
-
-  /* if transmitter, create remote address to transmit to.  */
-
-  if (trans)
-    {
-      if (address.set (port, host) == -1)
-	perror ("address.set"), exit (1);
-    }
-
-  /* else, receiver create address to listen on */
-  else
-    {
-      address.set (port);
-    }
-
-  total_msg_len = sizeof (long) + data_buf_len;
-
-  // allocate the buffer
-  message_buf = (Data_Control_Message *) malloc (total_msg_len);
-  if (message_buf == 0)
-    err ("malloc");
-
-//  if (bufalign != 0)
-//    message_buf += (bufalign - ((int) message_buf % bufalign) + bufoffset) % bufalign;
-
-  // let's go ahead and set the control message for every send right now
-  message_buf->size_ = data_buf_len;
-
-  session_control_buf.nbuf_ = nbuf;
-  session_control_buf.size_ = data_buf_len;
-
-  //
-  // print out option values for trans and receiver
-  //
-
-  if (trans)
-    {
-      fprintf (stdout,
-	       "ttcp-t: data_buf_len=%d, nbuf=%d, align=%d/%d, port=%d",
-	       data_buf_len, nbuf, bufalign, bufoffset, port);
-      if (sockbufsize)
-	fprintf (stdout, ", sockbufsize=%d", sockbufsize);
-      fprintf (stdout, "  %s  -> %s\n", 
-	       domain == PF_INET ? (udp ? "udp" : "tcp") : "unix", 
-	       host == 0 ? domainname : host);
-    }
-  else // receiver
-    {
-      fprintf (stdout,
-	       "ttcp-r: data_buf_len=%d, nbuf=%d, align=%d/%d, port=%d",
-	       data_buf_len, nbuf, bufalign, bufoffset, port);
-      if (sockbufsize)
-	fprintf (stdout, ", sockbufsize=%d", sockbufsize);
-      fprintf (stdout, "  %s\n", domain == PF_INET ? (udp ? "udp" : "tcp") : "unix");
-    }
-
-  mes ("socket");
-
-  // 
-  // connect and accept
-  //
-
-  if (!udp)
-    {
-      signal (SIGPIPE, (SIG_TYP) sigpipe);
-
-      /* the transmitter will set options and connect to receiver */
-      if (trans)
-	{
-	  if (connector_factory.connect (connection_stream, address) == -1)
-	    perror ("connection failed"), exit (1);
-	  fprintf (stdout,
-		   "ttcp-t: data_buf_len=%d, nbuf=%d, align=%d/%d, port=%d",
-		   data_buf_len, nbuf, bufalign, bufoffset, port);
-
-	  // turn off weird ack things
-	  if (nodelay)
-	    {
-	      struct protoent *p = getprotobyname ("tcp");
-
-	      if (p && connection_stream.set_option (p->p_proto,
-						     TCP_NODELAY,
-						     (char *)& one, 
-						     sizeof (one)))
-		err ("setsockopt: nodelay");
-	      mes ("nodelay");
-	    }
-	  if (sockbufsize)
-	    {
-	      if (connection_stream.set_option (SOL_SOCKET,
-						SO_SNDBUF,
-						(char *) &sockbufsize,
-						sizeof sockbufsize) == -1)
-		err ("acceptor_factory.set_option");
-	      mes ("sndbuf");
-	    }
-	}
-
-      /* receiver will listen for connections from the transmitter */
-      else
-	{
-	  if (acceptor_factory.open (address, 1) == -1)
-	    perror ("acceptor open"), exit (1);
-
-	  ACE_INET_Addr remote_address;
-
-	  if (acceptor_factory.accept (connection_stream, 
-				       (ACE_Addr *) &remote_address) == -1)
-	    perror ("acceptor accept"), exit (1);
-
-	  // set the window size
-	  if (sockbufsize)
-		{
-		  if (connection_stream.set_option (SOL_SOCKET,
-						   SO_RCVBUF,
-						   (char *) &sockbufsize,
-						   sizeof sockbufsize) == -1)
-		    err ("acceptor_factory.set_option");
-		  mes ("rcvbuf");
-		}
-
-	  fprintf (stderr, "ttcp-r: accept from %s\n", remote_address.get_host_name());
-	}
-    }
-
-  //
-  // start timer
-  //
-
-  errno = 0;
-
-  // used in send_n and recv_n
-  connection_descriptor = connection_stream.get_handle ();
-
-  if (trans)
-    {
-      pattern (& (message_buf->data_), data_buf_len);
-      prep_timer ();
-
-      ACE_DEBUG ((LM_DEBUG, "Sending session control message"
-		  " nbuf %d, size %d\n", session_control_buf.nbuf_,
-		  session_control_buf.size_));
-      if (send_n ((char *) &session_control_buf,
-		  sizeof (Session_Control_Message))
-	  != sizeof (Session_Control_Message))
-	ACE_ERROR_RETURN ((LM_ERROR, "%p send session control failed\n",
-			   "ttcp"), -1);
-
-      long ack;
-      int send_result;
-      while (nbuf--)
-	{
-	  send_result = send_n ((char *) message_buf, total_msg_len);
-	  if (send_result != total_msg_len)
-	    ACE_ERROR_RETURN ((LM_ERROR, "%p only sent %d of %d bytes on call %d\n",
-			       "ttcp", send_result, total_msg_len, numCalls + 1), -1);
-	  numCalls++;
-	  nbytes += data_buf_len;
-
-	  if (recv_n ((char *) &ack, sizeof ack) != sizeof ack)
-	    ACE_ERROR_RETURN ((LM_ERROR, "%p recv of ack failed\n",
-			       "ttcp"), -1);
-	  
-	  if (ack != data_buf_len)
-	    ACE_DEBUG ((LM_DEBUG, "received ack for only %d bytes\n", ack));
-	}
-    }
-  else
-    {
-      prep_timer ();
-
-      if (recv_n ((char *) &session_control_buf,
-		  sizeof (Session_Control_Message)) != sizeof (Session_Control_Message))
-	ACE_ERROR_RETURN ((LM_ERROR, "%p recv session control failed\n",
-			   "ttcp"), -1);
-
-      ACE_DEBUG ((LM_DEBUG, "received session control message"
-		  " nbuf %d, size %d\n", session_control_buf.nbuf_,
-		  session_control_buf.size_));
-
-      nbuf = session_control_buf.nbuf_;
-      // ignore session_control_buf.size_ for now
-
-      long cnt;
-
-      while (nbuf--)
-	{
-	  if (recv_n ((char *) message_buf, sizeof (long)) != sizeof (long))
-	    ACE_ERROR_RETURN ((LM_ERROR, "%p recv data control failed\n",
-			       "ttcp"), -1);
-
-	  cnt = recv_n (& (message_buf->data_), message_buf->size_);
-	  if (cnt != message_buf->size_)
-	    ACE_ERROR_RETURN ((LM_ERROR, "recv data failed\n"), -1);
-
-	  numCalls++;
-	  nbytes += cnt;
-
-	  if (send_n ((char *) &cnt, sizeof cnt) != sizeof cnt)
-	    ACE_ERROR_RETURN ((LM_ERROR, "%p send ack failed\n",
-			       "ttcp"), -1);
-	}
-    }
-
-  if (errno)
-    err ("IO");
-
-  //
-  // stop the timer
-  //
-
-  (void) read_timer (stats, sizeof (stats));
-  if (udp && trans)
-    {
-      (void) Nwrite (connection_stream, message_buf, 4);	/* rcvr end */
-      (void) Nwrite (connection_stream, message_buf, 4);	/* rcvr end */
-      (void) Nwrite (connection_stream, message_buf, 4);	/* rcvr end */
-      (void) Nwrite (connection_stream, message_buf, 4);	/* rcvr end */
-    }
-  if (cput <= 0.0)
-    cput = 0.001;
-  if (realt <= 0.0)
-    realt = 0.001;
-
-#if defined (LM_RESULTS)
-  if (trans && (title != 0))
-    {
-      double tmp;
-      FILE *fd;
-      char filename[BUFSIZ];
-      ACE_OS::sprintf (filename, "%s.results", title);
-      fd = fopen(filename,"a+");
-      if (new_line)
-	fprintf(fd,"\n  -l %ldk \t", data_buf_len/1024);
-      tmp = ((double) nbytes) / realt;
-      fprintf(fd,"%.2f ", tmp * 8.0 / 1024.0 / 1024.0);
-      fclose(fd);
-    }
-#endif
-
-  fprintf (stdout,
-	   "ttcp%s: %ld bytes in %.2f real seconds = %s/sec +++\n",
-	   trans ? "-t" : "-r",
-	   nbytes, realt, outfmt (((double) nbytes) / realt));
-  if (verbose)
-    {
-      fprintf (stdout,
-	       "ttcp%s: %ld bytes in %.2f CPU seconds = %s/cpu sec\n",
-	       trans ? "-t" : "-r",
-	       nbytes, cput, outfmt (((double) nbytes) / cput));
-    }
-  fprintf (stdout,
-	   "ttcp%s: %d I/O calls, msec/call = %.2f, calls/sec = %.2f\n",
-	   trans ? "-t" : "-r",
-	   numCalls,
-	   1024.0 * realt / ((double) numCalls),
-	   ((double) numCalls) / realt);
-  fprintf (stdout, "ttcp%s: %s\n", trans ? "-t" : "-r", stats);
-  if (verbose)
-    {
-      fprintf (stdout,
-	       "ttcp%s: buffer address %#x\n",
-	       trans ? "-t" : "-r",
-	       message_buf);
-    }
-  exit (0);
-
-usage:
-  fprintf (stderr, Usage);
-  return 1;
-}
-
-int 
-send_n (const void *buf, int len)
-{
-  size_t bytes_written;
-  int	 n;
-
-  for (bytes_written = 0; bytes_written < len; bytes_written += n)
-    if ((n = write (connection_descriptor, (const char *) buf + bytes_written, 
-		    len - bytes_written)) == -1)
-      return -1;
-
-  return bytes_written;
-}
-
-int
-recv_n (void *buf, int len)
-{
-  size_t bytes_read;
-  int	 n;
-
-  for (bytes_read = 0; bytes_read < len; bytes_read += n)
-    if ((n = read (connection_descriptor, (char *) buf + bytes_read, 
-		   len - bytes_read)) == -1)
-      return -1;
-    else if (n == 0)
-      break;
-
-  return bytes_read;      
-}
-
-void
-err (char *s)
-{
-  fprintf (stderr, "ttcp%s: ", trans ? "-t" : "-r");
-  perror (s);
-  fprintf (stderr, "errno=%d\n", errno);
-  exit (1);
-}
-
-void
-mes (char *s)
-{
-  fprintf (stderr, "ttcp%s: %s\n", trans ? "-t" : "-r", s);
-}
-
-void
-pattern (register char *cp, register int cnt)
-{
-  register char c;
-  c = 0;
-  while (cnt-- > 0)
-    {
-      while (!isprint ((c & 0x7F)))
-	c++;
-      *cp++ = (c++ & 0x7F);
-    }
-}
-
-char *
-outfmt (double b)
-{
-  static char obuf[50];
-  switch (fmt)
-    {
-    case 'G':
-      sprintf (obuf, "%.2f GB", b / 1024.0 / 1024.0 / 1024.0);
-      break;
-    default:
-    case 'K':
-      sprintf (obuf, "%.2f KB", b / 1024.0);
-      break;
-    case 'M':
-      sprintf (obuf, "%.2f MB", b / 1024.0 / 1024.0);
-      break;
-    case 'g':
-      sprintf (obuf, "%.2f Gbit", b * 8.0 / 1024.0 / 1024.0 / 1024.0);
-      break;
-    case 'k':
-      sprintf (obuf, "%.2f Kbit", b * 8.0 / 1024.0);
-      break;
-    case 'm':
-      sprintf (obuf, "%.2f Mbit", b * 8.0 / 1024.0 / 1024.0);
-      break;
-    }
-  return obuf;
-}
-
-static struct itimerval itime0;	/* Time at which timing started */
-static struct rusage ru0;	/* Resource utilization at the start */
-
-#if defined(SYSV)
-/*ARGSUSED */
-static void
-getrusage (int ignored, register struct rusage *ru)
-{
-  struct tms buf;
-
-  times (&buf);
-
-  /* Assumption: HZ <= 2147 (LONG_MAX/1000000) */
-  ru->ru_stime.tv_sec = buf.tms_stime / HZ;
-  ru->ru_stime.tv_usec = ((buf.tms_stime % HZ) * 1000000) / HZ;
-  ru->ru_utime.tv_sec = buf.tms_utime / HZ;
-  ru->ru_utime.tv_usec = ((buf.tms_utime % HZ) * 1000000) / HZ;
-}
-
-#endif /* SYSV */
-/*
- *                    P R E P _ T I M E R
- */
-void
-prep_timer ()
-{
-  itime0.it_interval.tv_sec = 0;
-  itime0.it_interval.tv_usec = 0;
-  itime0.it_value.tv_sec = LONG_MAX / 22;	/* greatest possible value , itimer() count backwards */
-  itime0.it_value.tv_usec = 0;
-
-
-  getrusage (RUSAGE_SELF, &ru0);
-
-  /* Init REAL Timer */
-  if (setitimer (ITIMER_REAL, &itime0, NULL))
-    {
-      perror ("Setting 'itimer' REAL failed");
-      return;
-    }
-
-}
-
-/*
- *                    R E A D _ T I M E R
- * 
- */
-double
-read_timer (char *str, int len)
-{
-  struct itimerval itimedol;
-  struct rusage ru1;
-  struct timeval td;
-  struct timeval tend, tstart;
-  char line[132];
-
-  getrusage (RUSAGE_SELF, &ru1);
-
-  if (getitimer (ITIMER_REAL, &itimedol))
-    {
-      perror ("Getting 'itimer' REAL failed");
-      return (0.0);
-    }
-
-  prusage (&ru0, &ru1, &itime0.it_value, &itimedol.it_value, line);
-  (void) strncpy (str, line, len);
-
-  /* Get real time */
-  tvsub (&td, &itime0.it_value, &itimedol.it_value);
-  realt = td.tv_sec + ((double) td.tv_usec) / 1000000;
-
-  /* Get CPU time (user+sys) */
-  tvadd (&tend, &ru1.ru_utime, &ru1.ru_stime);
-  tvadd (&tstart, &ru0.ru_utime, &ru0.ru_stime);
-  tvsub (&td, &tend, &tstart);
-  cput = td.tv_sec + ((double) td.tv_usec) / 1000000;
-  if (cput < 0.00001)
-    cput = 0.00001;
-  return (cput);
-}
-
-static void
-prusage (register struct rusage *r0, struct rusage *r1, 
-	 struct timeval *e, struct timeval *b, char *outp)
-{
-  struct timeval tdiff;
-  register time_t t;
-  register char *cp;
-  register int i;
-  int ms;
-
-  t = (r1->ru_utime.tv_sec - r0->ru_utime.tv_sec) * 100 +
-    (r1->ru_utime.tv_usec - r0->ru_utime.tv_usec) / 10000 +
-    (r1->ru_stime.tv_sec - r0->ru_stime.tv_sec) * 100 +
-    (r1->ru_stime.tv_usec - r0->ru_stime.tv_usec) / 10000;
-  ms = (e->tv_sec - b->tv_sec) * 100 + (e->tv_usec - b->tv_usec) / 10000;
-
-#define END(x)  {while(*x) x++;}
-#if defined(SYSV)
-  cp = "%Uuser %Ssys %Ereal %P";
-#else
-#if defined(sgi)		/* IRIX 3.3 will show 0 for %M,%F,%R,%C */
-  cp = "%Uuser %Ssys %Ereal %P %Mmaxrss %F+%Rpf %Ccsw";
-#else
-  cp = "%Uuser %Ssys %Ereal %P %Xi+%Dd %Mmaxrss %F+%Rpf %Ccsw";
-#endif
-#endif
-  for (; *cp; cp++)
-    {
-      if (*cp != '%')
-	*outp++ = *cp;
-      else if (cp[1])
-	switch (*++cp)
-	  {
-
-	  case 'U':
-	    tvsub (&tdiff, &r1->ru_utime, &r0->ru_utime);
-	    sprintf (outp, "%d.%01d", tdiff.tv_sec, tdiff.tv_usec / 100000);
-	    END (outp);
-	    break;
-
-	  case 'S':
-	    tvsub (&tdiff, &r1->ru_stime, &r0->ru_stime);
-	    sprintf (outp, "%d.%01d", tdiff.tv_sec, tdiff.tv_usec / 100000);
-	    END (outp);
-	    break;
-
-	  case 'E':
-	    psecs (ms / 100, outp);
-	    END (outp);
-	    break;
-
-	  case 'P':
-	    sprintf (outp, "%d%%", (int) (t * 100 / ((ms ? ms : 1))));
-	    END (outp);
-	    break;
-
-#if !defined(SYSV)
-	  case 'W':
-	    i = r1->ru_nswap - r0->ru_nswap;
-	    sprintf (outp, "%d", i);
-	    END (outp);
-	    break;
-
-	  case 'X':
-	    sprintf (outp, "%d", t == 0 ? 0 : (r1->ru_ixrss - r0->ru_ixrss) / t);
-	    END (outp);
-	    break;
-
-	  case 'D':
-	    sprintf (outp, "%d", t == 0 ? 0 :
-		     (r1->ru_idrss + r1->ru_isrss - (r0->ru_idrss + r0->ru_isrss)) / t);
-	    END (outp);
-	    break;
-
-	  case 'K':
-	    sprintf (outp, "%d", t == 0 ? 0 :
-		     ((r1->ru_ixrss + r1->ru_isrss + r1->ru_idrss) -
-		      (r0->ru_ixrss + r0->ru_idrss + r0->ru_isrss)) / t);
-	    END (outp);
-	    break;
-
-	  case 'M':
-	    sprintf (outp, "%d", r1->ru_maxrss / 2);
-	    END (outp);
-	    break;
-
-	  case 'F':
-	    sprintf (outp, "%d", r1->ru_majflt - r0->ru_majflt);
-	    END (outp);
-	    break;
-
-	  case 'R':
-	    sprintf (outp, "%d", r1->ru_minflt - r0->ru_minflt);
-	    END (outp);
-	    break;
-
-	  case 'I':
-	    sprintf (outp, "%d", r1->ru_inblock - r0->ru_inblock);
-	    END (outp);
-	    break;
-
-	  case 'O':
-	    sprintf (outp, "%d", r1->ru_oublock - r0->ru_oublock);
-	    END (outp);
-	    break;
-	  case 'C':
-	    sprintf (outp, "%d+%d", r1->ru_nvcsw - r0->ru_nvcsw,
-		     r1->ru_nivcsw - r0->ru_nivcsw);
-	    END (outp);
-	    break;
-#endif /* !SYSV */
-	  }
-    }
-  *outp = '\0';
-}
-
-static void
-tvadd (struct timeval *tsum, struct timeval *t0, struct timeval *t1)
-{
-
-  tsum->tv_sec = t0->tv_sec + t1->tv_sec;
-  tsum->tv_usec = t0->tv_usec + t1->tv_usec;
-  if (tsum->tv_usec > 1000000)
-    tsum->tv_sec++, tsum->tv_usec -= 1000000;
-}
-
-static void
-tvsub (struct timeval *tdiff, struct timeval *t1, struct timeval *t0)
-{
-
-  tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
-  tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
-  if (tdiff->tv_usec < 0)
-    tdiff->tv_sec--, tdiff->tv_usec += 1000000;
-}
-
-static void
-psecs (long l, register char *cp)
-{
-  register int i;
-
-  i = l / 3600;
-  if (i)
-    {
-      sprintf (cp, "%d:", i);
-      END (cp);
-      i = l % 3600;
-      sprintf (cp, "%d%d", (i / 60) / 10, (i / 60) % 10);
-      END (cp);
-    }
-  else
-    {
-      i = l;
-      sprintf (cp, "%d", i / 60);
-      END (cp);
-    }
-  i %= 60;
-  *cp++ = ':';
-  sprintf (cp, "%d%d", i / 10, i % 10);
-}
-
-/*
- *                    N R E A D
- */
-int
-Nread (ACE_SOCK_Stream &s, void *buf, int count)
-{
-  numCalls++;
-  return (s.recv (buf, count));
-}
-
-/*
- *                    N W R I T E
- */
-int
-Nwrite (ACE_SOCK_Stream &s, void *buf, int count)
-{
-  numCalls++;
-  return s.send (buf, count);
-}
-
-void
-delay (int us)
-{
-  struct timeval tv;
-
-  tv.tv_sec = 0;
-  tv.tv_usec = us;
-  (void) select (1, (fd_set *) 0, (fd_set *) 0, (fd_set *) 0, &tv);
-}
-
-/*
- *                    M R E A D
- *
- * This function performs the function of a read(II) but will
- * call read(II) multiple times in order to get the requested
- * number of characters.  This can be necessary because
- * network connections don't deliver data with the same
- * grouping as it is written with.  Written by Robert S. Miles, BRL.
- */
-int
-mread (int fd, register char *bufp, unsigned n)
-{
-  register unsigned count = 0;
-  register int nread;
-
-  do
-    {
-      nread = read (fd, bufp, n - count);
-      numCalls++;
-      if (nread < 0)
-	{
-	  perror ("ttcp_mread");
-	  return (-1);
-	}
-      if (nread == 0)
-	return ((int) count);
-      count += (unsigned) nread;
-      bufp += nread;
-    }
-  while (count < n);
-
-  return ((int) count);
-}
diff --git a/performance-tests/TTCP/C/run_test b/performance-tests/TTCP/C/run_test
deleted file mode 100644
index 9a4fa346ad3..00000000000
--- a/performance-tests/TTCP/C/run_test
+++ /dev/null
@@ -1,35 +0,0 @@
-# test_run 64 enatm0-kavita.cs.wustl.edu title 10002
-# repeat 100 new-ttcp -r -s -fm -p 10002 -b 65536
-#!/bin/csh -f
-if ($#argv != 4) then
-	echo "Usage: sclt <Max msg size> <destination> <TitleOfThisTest> <port>" $4
-	exit 1
-endif
-#
-@ msize=1024
-@ limit= ($argv[1] * 1024)
-#echo $limit
-#echo $msize 
-echo "Iteration#" 1 ": new-ttcp -fm -s -t -l" $msize "-h" $2 "-x -L" $3 "-p" $4
-new-ttcp -fm -s -t -l $msize -h $2 -x -L $3 -p $4
-sleep 1
-set flag=0
-while ($msize <= $limit)
-  if ($flag == 0) goto label
-     echo "Iteration#" 1 ": new-ttcp -fm -s -t -l" $msize "-h" $2 "-x -L" $3 "-p" $4
-     new-ttcp -fm -s -t -l $msize -h $2 -x -L $3 -p $4
-     sleep 1
- label:
-  set flag=1
-  foreach i (2 3 4 5)
-	echo "Iteration#" $i ": new-ttcp -fm -s -t -l" $msize "-h" $2 "-L" $3 "-p" $4
- 	new-ttcp -fm -s -t -l $msize -h $2 -L $3 -p $4
-	sleep 1
-  end
-	echo "---------------------------"
-	@ msize = ($msize * 2)
-end 
-
-echo " "
-echo "Done at:" 
-date
diff --git a/performance-tests/UDP/README b/performance-tests/UDP/README
deleted file mode 100644
index f2eb3308e1e..00000000000
--- a/performance-tests/UDP/README
+++ /dev/null
@@ -1,17 +0,0 @@
-// $Id$
-
-udp_test sends UDP packets and records round-trip latency.  The client
-records the latencies and provides nice summary statistics.  The server
-simply echos packets back to the client.
-
-To run:
-  1) On server host:
-     % ./udp_test -r
-
-  2) On client host:
-     % ./udp_test -t -n 1000 <server host>
-
-The -n option specifies the number of samples (packets to send).
-Other command line options are available:  ./udp_test -? to
-list them.
-
diff --git a/performance-tests/UDP/UDP.mpc b/performance-tests/UDP/UDP.mpc
deleted file mode 100644
index b145e73b879..00000000000
--- a/performance-tests/UDP/UDP.mpc
+++ /dev/null
@@ -1,8 +0,0 @@
-// -*- MPC -*-
-// $Id$
-
-project : aceexe {
-  verbatim(gnuace, local) {
-    LDLIBS += $(MATHLIB)
-  }
-}
diff --git a/performance-tests/UDP/run_test.pl b/performance-tests/UDP/run_test.pl
deleted file mode 100755
index 638b8c18c99..00000000000
--- a/performance-tests/UDP/run_test.pl
+++ /dev/null
@@ -1,34 +0,0 @@
-eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
-     & eval 'exec perl -S $0 $argv:q'
-     if 0;
-
-# $Id$
-# -*- perl -*-
-
-use lib '../../bin';
-use PerlACE::Run_Test;
-
-$SV = new PerlACE::Process ("udp_test", "-r");
-$CL = new PerlACE::Process ("udp_test", "-t -n 10000 localhost");
-
-$status = 0;
-
-$SV->Spawn ();
-
-sleep 5;
-
-$client = $CL->SpawnWaitKill (60);
-
-$server = $SV->WaitKill (5);
-
-if ($server != 0) {
-    print "ERROR: server returned $server\n";
-    $status = 1;
-}
-
-if ($client != 0) {
-    print "ERROR: client returned $client\n";
-    $status = 1;
-}
-
-exit $status;
diff --git a/performance-tests/UDP/udp_test.cpp b/performance-tests/UDP/udp_test.cpp
deleted file mode 100644
index 449c998f3ae..00000000000
--- a/performance-tests/UDP/udp_test.cpp
+++ /dev/null
@@ -1,759 +0,0 @@
-// $Id$
-
-// ============================================================================
-//
-// = LIBRARY
-//    performance-tests/UDP
-//
-// = FILENAME
-//    udp_test.cpp
-//
-// = DESCRIPTION
-//    Measures UDP round-trip performance.
-//
-// = AUTHORS
-//    Fred Kuhns and David L. Levine
-//
-// ============================================================================
-
-#include "ace/OS_main.h"
-#include "ace/Reactor.h"
-#include "ace/SOCK_Dgram.h"
-#include "ace/INET_Addr.h"
-#include "ace/ACE.h"
-#include "ace/Get_Opt.h"
-#include "ace/High_Res_Timer.h"
-#include "ace/Log_Msg.h"
-#include "ace/OS_NS_stdio.h"
-#include "ace/OS_NS_ctype.h"
-#include "ace/OS_NS_arpa_inet.h"
-#include "ace/OS_NS_string.h"
-#include "ace/os_include/os_netdb.h"
-#include "ace/OS_NS_unistd.h"
-
-// FUZZ: disable check_for_math_include
-#include <math.h>
-
-ACE_RCSID(UDP, udp_test, "$Id$")
-
-// Global variables (evil).
-static const u_short DEFPORT = 5050;
-static const int MAXPKTSZ = 65536;
-static const int DEFPKTSZ = 64;
-static const int DEFITERATIONS = 1000;
-static const int DEFINTERVAL = 1000; // 1000 usecs.
-static const int DEFWINDOWSZ = 10; // 10 microsecond.
-static char SendBuf[MAXPKTSZ];
-static char RxBuf[MAXPKTSZ];
-static ACE_TCHAR **cmd;
-static ACE_TCHAR datafile[MAXHOSTNAMELEN];
-
-static ACE_UINT32 nsamples = DEFITERATIONS;
-static int usdelay = DEFINTERVAL;
-static int bufsz = DEFPKTSZ;
-static int window = DEFWINDOWSZ;
-static int VERBOSE = 0;
-static int logfile = 0;
-static int server = 0;
-static int client = 0;
-static u_int use_reactor = 0;
-ACE_hrtime_t max_allow = 0;
-ACE_hrtime_t total_ltime;
-ACE_hrtime_t ltime;
-
-static void
-usage (void)
-{
-  ACE_ERROR ((LM_ERROR,
-              "%s\n"
-              "[-w window_size]\n"
-              "  [-f datafile] (creates datafile.samp and datafile.dist)\n"
-              "  [-v]          (Verbose)\n"
-              "  [-b send_bufsz]\n"
-              "  [-n nsamples]\n"
-              "  [-I usdelay]\n"
-              "  [-s so_bufsz] \n"
-              "  [-p port]\n"
-              "  [-t]\n"
-              "  [-r]\n"
-              "  [-x max_sample_allowed]\n"
-              "  [-a to use the ACE reactor]\n"
-              "  targethost \n",
-              *cmd));
-}
-
-static ACE_hrtime_t *Samples;
-static u_int *Dist;
-static ACE_TCHAR sumfile[30];
-static ACE_TCHAR distfile[30];
-static ACE_TCHAR sampfile[30];
-
-class Client : public ACE_Event_Handler
-{
-public:
-  Client (const ACE_INET_Addr &addr,
-          const ACE_INET_Addr &remote_addr);
-
-  virtual ~Client (void);
-
-  // = Override <ACE_Event_Handler> methods.
-  virtual ACE_HANDLE get_handle (void) const;
-  virtual int handle_input (ACE_HANDLE);
-  virtual int handle_close (ACE_HANDLE handle,
-                            ACE_Reactor_Mask close_mask);
-
-  int send (const char *buf, size_t len);
-  // Send the <buf> to the server.
-
-  int get_response (char *buf, size_t len);
-  // Wait for the response.
-
-  int run (void);
-  // Send messages to server and record statistics.
-
-  int shutdown (void);
-  // Send shutdown message to server.
-
-private:
-  ACE_SOCK_Dgram endpoint_;
-  // To send messages and receive responses.
-
-  ACE_INET_Addr remote_addr_;
-  // The address to send messages to.
-
-  ACE_UNIMPLEMENTED_FUNC (Client (void))
-  ACE_UNIMPLEMENTED_FUNC (Client (const Client &))
-  ACE_UNIMPLEMENTED_FUNC (Client &operator= (const Client &))
-};
-
-Client::Client (const ACE_INET_Addr &addr,
-                const ACE_INET_Addr &remote_addr)
-  : endpoint_ (addr),
-    remote_addr_ (remote_addr)
-{
-  if (use_reactor)
-    {
-      if (ACE_Reactor::instance ()->register_handler
-          (this, ACE_Event_Handler::READ_MASK) == -1)
-        ACE_ERROR ((LM_ERROR,
-                    "ACE_Reactor::register_handler: Client\n"));
-    }
-}
-
-Client::~Client (void)
-{
-}
-
-ACE_HANDLE
-Client::get_handle (void) const
-{
-  return endpoint_.get_handle ();
-}
-
-int
-Client::handle_input (ACE_HANDLE)
-{
-  char buf[BUFSIZ];
-  ACE_INET_Addr from_addr;
-
-  ssize_t n = endpoint_.recv (buf, sizeof buf, from_addr);
-
-  if (n == -1)
-    ACE_ERROR ((LM_ERROR,
-                "%p\n",
-                "handle_input"));
-  else
-    ACE_DEBUG ((LM_DEBUG,
-                "(%P|%t) buf of size %d = %*s\n",
-                n,
-                n,
-                buf));
-
-  return 0;
-}
-
-int
-Client::handle_close (ACE_HANDLE,
-                      ACE_Reactor_Mask)
-{
-  this->endpoint_.close ();
-  return 0;
-}
-
-int
-Client::send (const char *buf, size_t len)
-{
-  return this->endpoint_.send (buf, len, remote_addr_);
-}
-
-int
-Client::get_response (char *buf, size_t len)
-{
-  ACE_INET_Addr addr;
-  return this->endpoint_.recv (buf, len, addr);
-}
-
-int
-Client::run (void)
-{
-  int ndist = 0;
-  int i;
-  int j;
-  int n;
-  int maxindx = 0;
-  int minindx = 0;
-  char *sbuf = SendBuf;
-  char *rbuf = RxBuf;
-
-  ACE_High_Res_Timer timer;
-  ACE_hrtime_t sample;
-
-#if defined (ACE_LACKS_FLOATING_POINT)
-  ACE_hrtime_t sample_mean;
-#else  /* ! ACE_LACKS_FLOATING_POINT */
-  int d;
-  double std_dev = 0.0;
-  double std_err = 0.0;
-  double sample_mean = 0.0;
-#endif /* ! ACE_LACKS_FLOATING_POINT */
-
-  int                tracking_last_over = 0;
-  ACE_High_Res_Timer since_over;
-  ACE_hrtime_t psum = 0;
-  ACE_hrtime_t sum = 0;
-  ACE_hrtime_t max = 0;
-  ACE_hrtime_t min = (ACE_hrtime_t) (u_int) -1;
-  FILE *sumfp = 0;
-  FILE *distfp = 0;
-  FILE *sampfp = 0;
-  pid_t *pid = (pid_t *) sbuf;
-  int *seq = (int *) (sbuf + sizeof (int));
-
-  ACE_OS::memset (sbuf, 0, bufsz);
-  ACE_OS::memset (rbuf, 0, bufsz);
-
-  *pid = ACE_OS::getpid ();
-  *seq = 0;
-
-  ACE_DEBUG ((LM_DEBUG,
-              "PID = %d, Starting SEQ = %d\n",
-              *pid,
-              *seq));
-
-  // Allocate memory to hold samples.
-  Samples = (ACE_hrtime_t *) ACE_OS::calloc (nsamples,
-                                             sizeof (ACE_hrtime_t));
-
-  for (i = -1, *seq = 0, j = 0;
-       i < (ACE_INT32) nsamples;
-       (*seq)++, i++, j++, timer.reset ())
-    {
-      timer.start ();
-      if (send (sbuf, bufsz) <= 0)
-        ACE_ERROR_RETURN ((LM_ERROR, "(%P) %p\n", "send"), -1);
-
-      if ((n = get_response (rbuf, bufsz)) <= 0)
-        ACE_ERROR_RETURN ((LM_ERROR, "(%P) %p\n", "get_response"), -1);
-
-      timer.stop ();
-
-      if (n <= 0)
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "\nTrouble receiving from socket!\n\n"),
-                          -1);
-
-      timer.elapsed_time (sample);     // in nanoseconds.
-
-      if (i < 0 )
-        {
-#ifndef ACE_LACKS_LONGLONG_T
-          ACE_DEBUG ((LM_DEBUG,
-                      "Ignoring first sample of %u usecs\n",
-                       (ACE_UINT32) (sample)));
-#else
-          ACE_DEBUG ((LM_DEBUG,
-                      "Ignoring first sample of %u usecs\n",
-                      (ACE_UINT32) (sample.lo())));
-#endif
-          continue;
-        }
-      else if (max_allow > 0  &&  sample > max_allow)
-        {
-          ACE_DEBUG ((LM_DEBUG, "Sample # %i = "
-                      "%u msec is over the limit (%u)!\n",
-                      i,
-                      (ACE_UINT32) (sample / (ACE_UINT32) 1000000),
-                      (ACE_UINT32) (max_allow / (ACE_UINT32) 1000000)));
-
-          if (tracking_last_over)
-            {
-              since_over.stop ();
-              ACE_Time_Value over_time;
-              since_over.elapsed_time (over_time);
-              ACE_DEBUG ((LM_DEBUG,
-                          "\tTime since last over = %u msec!\n",
-                          over_time.msec ()));
-              since_over.reset ();
-            }
-
-          tracking_last_over = 1;
-          since_over.start ();
-          i--;
-          continue;
-        }
-
-      Samples[i] = sample;
-      sum += sample;
-
-      if (min == (ACE_hrtime_t) (u_int) -1)
-        {
-          min = sample;
-          minindx = i;
-        }
-      if (sample > max)
-        {
-          max = sample;
-          maxindx = i;
-        }
-      if (sample < min)
-        {
-          min = sample;
-          minindx = i;
-        }
-
-      if (VERBOSE)
-        {
-          psum += sample;
-          if (j == 500)
-            {
-              ACE_DEBUG ((LM_DEBUG,
-                          "(%i) Partial (running) mean %u usecs\n",
-                          i + 1,
-                          (ACE_UINT32) (psum / (ACE_UINT32) (1000 * 500))));
-              j = 0;
-              psum = 0;
-            }
-        }
-    }
-
-#if defined (ACE_LACKS_FLOATING_POINT)
-  sample_mean = sum / nsamples;
-#else  /* ! ACE_LACKS_FLOATING_POINT */
-  sample_mean = ((double) ACE_U64_TO_U32 (sum)) / (double) nsamples;
-#endif /* ! ACE_LACKS_FLOATING_POINT */
-
-  if (logfile)
-    {
-      ACE_OS::sprintf (sumfile, ACE_TEXT("%s.sum"), datafile);
-      ACE_OS::sprintf (distfile, ACE_TEXT("%s.dist"), datafile);
-      ACE_OS::sprintf (sampfile, ACE_TEXT("%s.samp"), datafile);
-
-      distfp = ACE_OS::fopen(distfile, ACE_TEXT("w"));
-
-      if (distfp == NULL)
-        {
-          ACE_DEBUG ((LM_DEBUG,
-                      "Unable to open dist file!\n\n"));
-          logfile = 0;
-        }
-      if (logfile && (sampfp = ACE_OS::fopen (sampfile, ACE_TEXT("w"))) == NULL)
-        {
-          ACE_OS::fclose (distfp);
-          ACE_DEBUG ((LM_DEBUG,
-                      "Unable to open sample file!\n\n"));
-          logfile = 0;
-        }
-      if (logfile && (sumfp = ACE_OS::fopen (sumfile, ACE_TEXT("w"))) == NULL)
-        {
-          ACE_OS::fclose (distfp);
-          ACE_OS::fclose (sampfp);
-          ACE_DEBUG ((LM_DEBUG,
-                      "Unable to open sample file!\n\n"));
-          logfile = 0;
-        }
-    }
-
-  if (window)
-    {
-      window = window * 1000; // convert to nsec.
-      ndist = (int)((max-min) / window) + 1;
-      Dist = (u_int *) ACE_OS::calloc (ndist,
-                                       sizeof (u_int));
-    }
-
-#if ! defined (ACE_LACKS_FLOATING_POINT)
-  for (i = 0; i < (ACE_INT32) nsamples; i++)
-    {
-      std_dev += ((double) ACE_U64_TO_U32 (Samples[i]) - sample_mean) *
-        ((double) ACE_U64_TO_U32 (Samples[i]) - sample_mean);
-      d = (int)((Samples[i] - min)/window);
-
-      if (d < 0 || d > ndist)
-        {
-          ACE_DEBUG ((LM_DEBUG,
-                      "\nError indexing into dist array %d (%d)\n\n",
-                      d,
-                      ndist));
-          ACE_OS::exit (1);
-        }
-      Dist[d] += 1;
-      if (logfile)
-        ACE_OS::fprintf (sampfp,
-                         "%u\n",
-                         ACE_U64_TO_U32 (Samples[i]));
-    }
-#endif /* ACE_LACKS_FLOATING_POINT */
-
-  if (logfile)
-    {
-      ACE_hrtime_t tmp;
-      tmp = min + (window / 2);
-
-      for (i = 0; i < ndist; i++)
-        {
-          ACE_OS::fprintf (distfp,
-                           "%u %d\n",
-                           (ACE_UINT32) (tmp / (ACE_UINT32) 1000),
-                           Dist[i]);
-          tmp += window;
-        }
-    }
-
-#if defined (ACE_LACKS_FLOATING_POINT)
-  ACE_DEBUG ((LM_DEBUG,
-              "\nResults for %i samples (usec):\n"
-              "\tSample Mean = %u,\n"
-              "\tSample Max = %u, Max index = %u,\n"
-              "\tSample Min = %u, Min index = %u,\n",
-              nsamples,
-              (ACE_UINT32) (sample_mean / (ACE_UINT32) 1000),
-              (ACE_UINT32) (max / (ACE_UINT32) 1000),
-              maxindx,
-              (ACE_UINT32) (min / (ACE_UINT32) 1000),
-              minindx));
-#else  /* ! ACE_LACKS_FLOATING_POINT */
-  std_dev = (double) sqrt (std_dev / (double) (nsamples - 1.0));
-  std_err = (double) std_dev / sqrt ((double) nsamples);
-
-  ACE_DEBUG ((LM_DEBUG,
-              "\nResults for %i samples (usec):\n"
-              "\tSample Mean = %f,\n"
-              "\tSample Max = %u, Max index = %d,\n"
-              "\tSample Min = %u, Min index = %d,\n"
-              "\tStandard Deviation = %f,\n"
-              "\tStandard Error = %f\n",
-              nsamples,
-              sample_mean / 1000.0,
-              (u_int) (max / (ACE_UINT32) 1000),
-              maxindx,
-              (u_int) (min / (ACE_UINT32) 1000),
-              minindx,
-              std_dev / 1000.0,
-              std_err / 1000.0));
-
-  if (logfile)
-    {
-      ACE_OS::fprintf (sumfp,
-                       "Command executed: \n");
-      for (; *cmd; cmd++)
-        ACE_OS::fprintf (sumfp,
-                         "%s ",
-                         *cmd);
-      ACE_OS::fprintf (sumfp,
-                       "\n");
-
-      ACE_OS::fprintf (sumfp,
-                       "\nResults for %i samples (usec):"
-                       "\tSample Mean = %f,\n"
-                       "\tSample Max = %u, Max index = %d,\n"
-                       "\tSample Min = %u, Min index = %d,\n"
-                       "\tStandard Deviation = %f,\n"
-                       "\tStandard Error = %f\n",
-                       nsamples,
-                       sample_mean / 1000.0,
-                       (ACE_UINT32) (max / (ACE_UINT32) 1000),
-                       maxindx,
-                       (ACE_UINT32) (min / (ACE_UINT32) 1000),
-                       minindx,
-                       std_dev / 1000.0,
-                       std_err / 1000.0);
-    }
-#endif /* ! ACE_LACKS_FLOATING_POINT */
-
-  return 0;
-}
-
-int
-Client::shutdown (void)
-{
-  const char buf = 'S';
-  const int n = endpoint_.send (&buf, 1u, remote_addr_);
-
-  if (use_reactor)
-    {
-      if (ACE_Reactor::instance ()->remove_handler
-          (this, ACE_Event_Handler::READ_MASK) == -1)
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "ACE_Reactor::remove_handler: Client\n"),
-                          -1);
-    }
-
-  return n;
-}
-
-class Server : public ACE_Event_Handler
-{
-public:
-  Server (const ACE_INET_Addr &addr);
-
-  virtual ~Server (void);
-
-  // = Override <ACE_Event_Handler> methods.
-  virtual ACE_HANDLE get_handle (void) const;
-  virtual int handle_input (ACE_HANDLE);
-  virtual int handle_close (ACE_HANDLE handle,
-                            ACE_Reactor_Mask close_mask);
-
-private:
-  ACE_SOCK_Dgram endpoint_;
-  // Receives datagrams.
-
-  ACE_UNIMPLEMENTED_FUNC (Server (void))
-  ACE_UNIMPLEMENTED_FUNC (Server (const Server &))
-  ACE_UNIMPLEMENTED_FUNC (Server &operator= (const Server &))
-};
-
-Server::Server (const ACE_INET_Addr &addr)
-  :  endpoint_ (addr)
-{
-  if (use_reactor)
-    {
-      if (ACE_Reactor::instance ()->register_handler
-          (this,
-           ACE_Event_Handler::READ_MASK) == -1)
-        ACE_ERROR ((LM_ERROR,
-                    "ACE_Reactor::register_handler: Server\n"));
-    }
-}
-
-Server::~Server (void)
-{
-}
-
-ACE_HANDLE
-Server::get_handle (void) const
-{
-  return endpoint_.get_handle ();
-}
-
-int
-Server::handle_input (ACE_HANDLE)
-{
-  char buf[BUFSIZ];
-  ACE_INET_Addr from_addr;
-
-  ssize_t n = endpoint_.recv (buf, sizeof buf, from_addr);
-
-  if (n == -1)
-    ACE_DEBUG ((LM_ERROR,
-                "%p\n",
-                "handle_input: recv"));
-
-  // Send the message back as the response.
-  if (endpoint_.send (buf, n, from_addr) == n)
-    {
-      if (n == 1 && buf[0] == 'S')
-        {
-          if (use_reactor)
-            {
-              if (ACE_Reactor::instance ()->remove_handler
-                  (this, ACE_Event_Handler::READ_MASK) == -1)
-                ACE_ERROR_RETURN ((LM_ERROR,
-                                   "ACE_Reactor::remove_handler: server\n"),
-                                  -1);
-
-              ACE_Reactor::end_event_loop ();
-            }
-          else
-            {
-              // Indicate done by returning 1.
-              return 1;
-            }
-        }
-
-      return 0;
-    }
-  else
-    {
-      ACE_DEBUG ((LM_ERROR,
-                  "%p\n",
-                  "handle_input: send"));
-      return -1;
-    }
-}
-
-int
-Server::handle_close (ACE_HANDLE,
-                      ACE_Reactor_Mask)
-{
-  endpoint_.close ();
-
-  return 0;
-}
-
-int
-ACE_TMAIN (int argc, ACE_TCHAR *argv[])
-{
-  int c, dstport = DEFPORT;
-  int so_bufsz = 0;
-
-  cmd = argv;
-
-  ACE_Get_Opt getopt (argc, argv, ACE_TEXT("x:w:f:vs:I:p:rtn:b:a"));
-
-  while ((c = getopt ()) != -1)
-    {
-      switch ((char) c)
-        {
-        case 'x':
-          max_allow = ACE_OS::atoi (getopt.opt_arg ());
-          break;
-        case 'w':
-          window = ACE_OS::atoi (getopt.opt_arg ());
-          if (window < 0)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "Invalid window!\n\n"),
-                              1);
-          break;
-        case 'f':
-          ACE_OS::strcpy (datafile, getopt.opt_arg ());
-          logfile = 1;
-          break;
-        case 'v':
-          VERBOSE = 1;
-          break;
-        case 'b':
-          bufsz = ACE_OS::atoi (getopt.opt_arg ());
-
-          if (bufsz <= 0)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "\nBuffer size must be greater than 0!\n\n"),
-                              1);
-
-        case 'n':
-          nsamples = ACE_OS::atoi (getopt.opt_arg ());
-          if (nsamples <= 0)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "\nIterations must be greater than 0!\n\n"),
-                              1);
-          break;
-        case 'a':
-          use_reactor = 1;
-          break;
-        case 's':
-          so_bufsz = ACE_OS::atoi (getopt.opt_arg ());
-
-          if (so_bufsz <= 0)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "\nInvalid socket buffer size!\n\n"),
-                              1);
-          break;
-        case 'I':
-          usdelay = ACE_OS::atoi (getopt.opt_arg ());
-
-          if (usdelay == 0)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "%s: bad usdelay: %s\n",
-                               argv[0],
-                               getopt.opt_arg ()),
-                              1);
-          break;
-        case 'p':
-          dstport = ACE_OS::atoi (getopt.opt_arg ());
-          if (dstport <= 0)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "\nInvalid port number!\n\n"),
-                              1);
-          break;
-        case 't':
-          server = 0;
-          client = 1;
-          break;
-        case 'r':
-          client = 0;
-          server = 1;
-          break;
-        default:
-          usage ();
-          return 1;
-        }
-    }
-
-  if (getopt.opt_ind () >= argc && client || argc == 1)
-    {
-      usage ();
-      return 1;
-    }
-
-  ACE_INET_Addr addr (server ? dstport : dstport + 1);
-
-  if (server)
-    {
-      Server server (addr);
-
-      if (use_reactor)
-        {
-          ACE_Reactor::run_event_loop ();
-        }
-      else
-        {
-          // Handle input in the current thread.
-          while (server.handle_input (0) != 1)
-            continue;
-        }
-    }
-  else
-    {
-      if ((u_int) bufsz < sizeof (ACE_hrtime_t))
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "\nbufsz must be >= %d\n",
-                           sizeof (ACE_hrtime_t)),
-                          1);
-      ACE_INET_Addr remote_addr;
-
-      if (ACE_OS::ace_isdigit(argv[getopt.opt_ind ()][0]))
-        {
-          if (remote_addr.set (dstport,
-                               (ACE_UINT32) ACE_OS::inet_addr
-                                 (ACE_TEXT_ALWAYS_CHAR(argv[getopt.opt_ind ()]))) == -1)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "invalid IP address: %s\n",
-                               argv[getopt.opt_ind ()]),
-                              1);
-        }
-      else
-        {
-          if (remote_addr.set (dstport, argv[getopt.opt_ind ()]) == -1)
-            ACE_ERROR_RETURN ((LM_ERROR,
-                               "invalid IP address: %s\n",
-                               argv[getopt.opt_ind ()]),
-                              1);
-        }
-      getopt.opt_ind ()++;
-
-      Client client (addr, remote_addr);
-
-      ACE_DEBUG ((LM_DEBUG,
-                  "\nSending %d byte packets to %s:%d "
-                  "with so_bufsz = %d\n\n",
-                  bufsz,
-                  addr.get_host_name (),
-                  dstport,
-                  so_bufsz));
-
-      client.run ();
-      client.shutdown ();
-    }
-
-  return 0;
-}
diff --git a/performance-tests/perf.mwc b/performance-tests/perf.mwc
deleted file mode 100644
index dd297256b34..00000000000
--- a/performance-tests/perf.mwc
+++ /dev/null
@@ -1,5 +0,0 @@
-// -*- MPC -*-
-// $Id$
-
-workspace {
-}