ChangeLogTag:Tue Jan 29 21:09:12 2002 Oliver Kellogg <oliver.kellogg@sysde.eads.net>

98 files changed, 3714 insertions, 560 deletions

diff --git a/TAO/performance-tests/AMI_Latency/Roundtrip.cpp b/TAO/performance-tests/AMI_Latency/Roundtrip.cpp
new file mode 100644
index 00000000000..c9e68d98406
--- /dev/null
+++ b/TAO/performance-tests/AMI_Latency/Roundtrip.cpp
@@ -0,0 +1,26 @@
+//
+// $Id$
+//
+#include "Roundtrip.h"
+
+ACE_RCSID(AMI_Latency, Roundtrip, "$Id$")
+
+Roundtrip::Roundtrip (CORBA::ORB_ptr orb)
+  : orb_ (CORBA::ORB::_duplicate (orb))
+{
+}
+
+Test::Timestamp
+Roundtrip::test_method (Test::Timestamp send_time
+                        ACE_ENV_ARG_DECL_NOT_USED)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return send_time;
+}
+
+void
+Roundtrip::shutdown (ACE_ENV_SINGLE_ARG_DECL)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER);
+}
diff --git a/TAO/performance-tests/AMI_Latency/Roundtrip.h b/TAO/performance-tests/AMI_Latency/Roundtrip.h
new file mode 100644
index 00000000000..efef33dd7e6
--- /dev/null
+++ b/TAO/performance-tests/AMI_Latency/Roundtrip.h
@@ -0,0 +1,46 @@
+//
+// $Id$
+//
+
+#ifndef ROUNDTRIP_H
+#define ROUNDTRIP_H
+#include "ace/pre.h"
+
+#include "TestS.h"
+
+#if defined (_MSC_VER)
+# if (_MSC_VER >= 1200)
+#  pragma warning(push)
+# endif /* _MSC_VER >= 1200 */
+# pragma warning (disable:4250)
+#endif /* _MSC_VER */
+
+/// Implement the Test::Roundtrip interface
+class Roundtrip
+  : public virtual POA_Test::Roundtrip
+  , public virtual PortableServer::RefCountServantBase
+{
+public:
+  /// Constructor
+  Roundtrip (CORBA::ORB_ptr orb);
+
+  // = The skeleton methods
+  virtual Test::Timestamp test_method (Test::Timestamp send_time
+                                       ACE_ENV_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+private:
+  /// Use an ORB reference to conver strings to objects and shutdown
+  /// the application.
+  CORBA::ORB_var orb_;
+};
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma warning(pop)
+#endif /* _MSC_VER */
+
+#include "ace/post.h"
+#endif /* ROUNDTRIP_H */
diff --git a/TAO/performance-tests/AMI_Latency/Roundtrip_Handler.cpp b/TAO/performance-tests/AMI_Latency/Roundtrip_Handler.cpp
new file mode 100644
index 00000000000..5f0061601e4
--- /dev/null
+++ b/TAO/performance-tests/AMI_Latency/Roundtrip_Handler.cpp
@@ -0,0 +1,75 @@
+//
+// $Id$
+//
+#include "Roundtrip_Handler.h"
+
+ACE_RCSID(AMI_Latency, Roundtrip, "$Id$")
+
+Roundtrip_Handler::Roundtrip_Handler (int expected_callbacks)
+  : pending_callbacks_ (expected_callbacks)
+{
+}
+
+int
+Roundtrip_Handler::pending_callbacks (void) const
+{
+  return this->pending_callbacks_;
+}
+
+void
+Roundtrip_Handler::dump_results (ACE_UINT32 gsf)
+{
+  this->latency_stats_.dump_results ("AMI Latency", gsf);
+}
+
+void
+Roundtrip_Handler::test_method (Test::Timestamp send_time
+                                ACE_ENV_ARG_DECL_NOT_USED)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->pending_callbacks_--;
+
+  ACE_hrtime_t now = ACE_OS::gethrtime ();
+  this->latency_stats_.sample (now - send_time);
+}
+
+void
+Roundtrip_Handler::test_method_excep (Test::AMI_RoundtripExceptionHolder *holder
+                                      ACE_ENV_ARG_DECL)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  ACE_TRY
+    {
+      this->pending_callbacks_--;
+      holder->raise_test_method (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "test_method:");
+    }
+  ACE_ENDTRY;
+}
+
+void
+Roundtrip_Handler::shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+}
+
+void
+Roundtrip_Handler::shutdown_excep (Test::AMI_RoundtripExceptionHolder *holder
+                                   ACE_ENV_ARG_DECL)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  ACE_TRY
+    {
+      holder->raise_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "shutdown:");
+    }
+  ACE_ENDTRY;
+}
diff --git a/TAO/performance-tests/AMI_Latency/Roundtrip_Handler.h b/TAO/performance-tests/AMI_Latency/Roundtrip_Handler.h
new file mode 100644
index 00000000000..ae777f50f20
--- /dev/null
+++ b/TAO/performance-tests/AMI_Latency/Roundtrip_Handler.h
@@ -0,0 +1,61 @@
+//
+// $Id$
+//
+
+#ifndef ROUNDTRIP_HANDLER_H
+#define ROUNDTRIP_HANDLER_H
+#include "ace/pre.h"
+
+#include "TestS.h"
+#include "ace/Basic_Stats.h"
+
+#if defined (_MSC_VER)
+# if (_MSC_VER >= 1200)
+#  pragma warning(push)
+# endif /* _MSC_VER >= 1200 */
+# pragma warning (disable:4250)
+#endif /* _MSC_VER */
+
+/// Implement the Test::Roundtrip interface
+class Roundtrip_Handler
+  : public virtual POA_Test::AMI_RoundtripHandler
+  , public virtual PortableServer::RefCountServantBase
+{
+public:
+  /// Constructor
+  Roundtrip_Handler (int expected_callbacks);
+
+  /// Return the number of pending callbacks
+  int pending_callbacks (void) const;
+
+  /// Dump the results
+  void dump_results (ACE_UINT32 gsf);
+
+  // = The skeleton methods
+  virtual void test_method (Test::Timestamp send_time
+                            ACE_ENV_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+  virtual void test_method_excep (Test::AMI_RoundtripExceptionHolder *holder
+                                  ACE_ENV_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+  virtual void shutdown_excep (Test::AMI_RoundtripExceptionHolder *holder
+                               ACE_ENV_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+private:
+  /// The number of callbacks not received yet
+  int pending_callbacks_;
+
+  /// Collect the latency results
+  ACE_Basic_Stats latency_stats_;
+};
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma warning(pop)
+#endif /* _MSC_VER */
+
+#include "ace/post.h"
+#endif /* ROUNDTRIP_H */
diff --git a/TAO/performance-tests/AMI_Latency/Server_Task.cpp b/TAO/performance-tests/AMI_Latency/Server_Task.cpp
new file mode 100644
index 00000000000..6df92f32a3f
--- /dev/null
+++ b/TAO/performance-tests/AMI_Latency/Server_Task.cpp
@@ -0,0 +1,24 @@
+//
+// $Id$
+//
+#include "Server_Task.h"
+
+ACE_RCSID(AMI_Latency, Server_Task, "$Id$")
+
+Server_Task::Server_Task (CORBA::ORB_ptr orb)
+  : orb_ (CORBA::ORB::_duplicate (orb))
+{
+}
+
+int
+Server_Task::svc (void)
+{
+  ACE_DECLARE_NEW_CORBA_ENV;
+  ACE_TRY
+    {
+      this->orb_->run (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCHANY {} ACE_ENDTRY;
+  return 0;
+}
diff --git a/TAO/performance-tests/AMI_Latency/client.cpp b/TAO/performance-tests/AMI_Latency/client.cpp
new file mode 100644
index 00000000000..0d396c4b67b
--- /dev/null
+++ b/TAO/performance-tests/AMI_Latency/client.cpp
@@ -0,0 +1,185 @@
+// $Id$
+
+#include "Roundtrip_Handler.h"
+#include "tao/debug.h"
+#include "ace/Get_Opt.h"
+#include "ace/High_Res_Timer.h"
+#include "ace/Sched_Params.h"
+#include "ace/Stats.h"
+
+ACE_RCSID(AMI_Latency, client, "$Id$")
+
+const char *ior = "file://test.ior";
+
+ACE_hrtime_t throughput_base;
+
+int niterations = 1000;
+
+int
+parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "k:i:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'k':
+        ior = get_opts.opt_arg ();
+        break;
+
+      case 'i':
+        niterations = ACE_OS::atoi (get_opts.opt_arg ());
+        break;
+
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-k <ior> "
+                           "-i <niterations> "
+                           "-p <period (msecs)> "
+                           "-b <burst size> "
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int priority =
+    (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
+     + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
+  // 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_TRY_NEW_ENV
+    {
+      CORBA::ORB_var orb =
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::Object_var poa_object =
+        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (CORBA::is_nil (poa_object.in ()))
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           " (%P|%t) Unable to initialize the POA.\n"),
+                          1);
+
+      PortableServer::POA_var root_poa =
+        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      PortableServer::POAManager_var poa_manager =
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (parse_args (argc, argv) != 0)
+        return 1;
+
+      CORBA::Object_var object =
+        orb->string_to_object (ior ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      Test::Roundtrip_var roundtrip =
+        Test::Roundtrip::_narrow (object.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (CORBA::is_nil (roundtrip.in ()))
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "Nil Test::Roundtrip reference <%s>\n",
+                           ior),
+                          1);
+
+      for (int j = 0; j < 100; ++j)
+        {
+          ACE_hrtime_t start = 0;
+          (void) roundtrip->test_method (start ACE_ENV_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+        }
+
+      Roundtrip_Handler *roundtrip_handler_impl;
+      ACE_NEW_RETURN (roundtrip_handler_impl,
+                      Roundtrip_Handler (niterations),
+                      1);
+      PortableServer::ServantBase_var owner_transfer(roundtrip_handler_impl);
+
+      Test::AMI_RoundtripHandler_var roundtrip_handler =
+        roundtrip_handler_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      ACE_hrtime_t test_start = ACE_OS::gethrtime ();
+
+      for (int i = 0; i != niterations; ++i)
+         {
+           // Invoke asynchronous operation....
+           roundtrip->sendc_test_method (roundtrip_handler.in (),
+                                         ACE_OS::gethrtime ()
+                                         ACE_ENV_ARG_PARAMETER);
+           if (orb->work_pending (ACE_ENV_SINGLE_ARG_PARAMETER))
+              orb->perform_work (ACE_ENV_SINGLE_ARG_PARAMETER);
+
+           ACE_TRY_CHECK;
+         }
+
+       ACE_Time_Value tv (0, 2000);
+
+       while (roundtrip_handler_impl->pending_callbacks ())
+         {
+           orb->perform_work (tv ACE_ENV_ARG_PARAMETER);
+           ACE_TRY_CHECK;
+         }
+
+      ACE_hrtime_t test_end = ACE_OS::gethrtime ();
+
+      ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
+      ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor ();
+      ACE_DEBUG ((LM_DEBUG, "done\n"));
+
+      roundtrip_handler_impl->dump_results (gsf);
+
+      ACE_Throughput_Stats::dump_throughput ("Total", gsf,
+                                             test_end - test_start,
+                                             niterations);
+
+      roundtrip->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught: ");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/performance-tests/AMI_Latency/server.cpp b/TAO/performance-tests/AMI_Latency/server.cpp
new file mode 100644
index 00000000000..74498dc13e0
--- /dev/null
+++ b/TAO/performance-tests/AMI_Latency/server.cpp
@@ -0,0 +1,155 @@
+// $Id$
+
+#include "Roundtrip.h"
+#include "Server_Task.h"
+#include "ace/Get_Opt.h"
+#include "ace/Sched_Params.h"
+
+#include "tao/Strategies/advanced_resource.h"
+
+ACE_RCSID(AMI_Latency, server, "$Id$")
+
+const char *ior_output_file = "test.ior";
+int nthreads = 4;
+
+int
+parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "o:n:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'o':
+        ior_output_file = get_opts.opt_arg ();
+        break;
+
+      case 'n':
+        nthreads = ACE_OS::atoi (get_opts.opt_arg ());
+        break;
+
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-o <iorfile> "
+                           "-n <nthreads> "
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  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);
+
+  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_TRY_NEW_ENV
+    {
+      CORBA::ORB_var orb =
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::Object_var poa_object =
+        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (CORBA::is_nil (poa_object.in ()))
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           " (%P|%t) Unable to initialize the POA.\n"),
+                          1);
+
+      PortableServer::POA_var root_poa =
+        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      PortableServer::POAManager_var poa_manager =
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (parse_args (argc, argv) != 0)
+        return 1;
+
+      Roundtrip *roundtrip_impl;
+      ACE_NEW_RETURN (roundtrip_impl,
+                      Roundtrip (orb.in ()),
+                      1);
+      PortableServer::ServantBase_var owner_transfer(roundtrip_impl);
+
+      Test::Roundtrip_var roundtrip =
+        roundtrip_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::String_var ior =
+        orb->object_to_string (roundtrip.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      // If the ior_output_file exists, output the ior to it
+      FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
+      if (output_file == 0)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "Cannot open output file for writing IOR: %s",
+                           ior_output_file),
+                          1);
+      ACE_OS::fprintf (output_file, "%s", ior.in ());
+      ACE_OS::fclose (output_file);
+
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      Server_Task server_task (orb.in ());
+      if (server_task.activate (THR_NEW_LWP | THR_JOINABLE,
+                                nthreads) != 0)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "Cannot activate server threads\n"),
+                          1);
+
+      server_task.thr_mgr ()->wait ();
+
+      ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
+
+      ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
+
+      root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/performance-tests/Callback/Callback_i.cpp b/TAO/performance-tests/Callback/Callback_i.cpp
index f86c6f605cb..83e357965ce 100644
--- a/TAO/performance-tests/Callback/Callback_i.cpp
+++ b/TAO/performance-tests/Callback/Callback_i.cpp
@@ -18,7 +18,7 @@ Callback_i::done (void)
 void
 Callback_i::response (Test::TimeStamp time_stamp,
                       const Test::Payload &
-                      TAO_ENV_ARG_DECL_NOT_USED)
+                      ACE_ENV_ARG_DECL_NOT_USED)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_hrtime_t now = ACE_OS::gethrtime ();
diff --git a/TAO/performance-tests/Callback/Callback_i.h b/TAO/performance-tests/Callback/Callback_i.h
index 95b9850ee4e..b3423a573b0 100644
--- a/TAO/performance-tests/Callback/Callback_i.h
+++ b/TAO/performance-tests/Callback/Callback_i.h
@@ -23,7 +23,7 @@ public:
   //@{
   void response (Test::TimeStamp,
                  const Test::Payload &
-                 TAO_ENV_ARG_DECL_NOT_USED)
+                 ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException));
   //@}
 
diff --git a/TAO/performance-tests/Callback/Server_i.cpp b/TAO/performance-tests/Callback/Server_i.cpp
index 67c2780de3e..a4cc4de2484 100644
--- a/TAO/performance-tests/Callback/Server_i.cpp
+++ b/TAO/performance-tests/Callback/Server_i.cpp
@@ -10,7 +10,7 @@ ACE_RCSID(Callback, Server_i, "$Id$")
 
 void
 Server_i::set_callback (Test::Callback_ptr callback
-                        TAO_ENV_ARG_DECL_NOT_USED)
+                        ACE_ENV_ARG_DECL_NOT_USED)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   this->callback_ = Test::Callback::_duplicate (callback);
@@ -19,17 +19,17 @@ Server_i::set_callback (Test::Callback_ptr callback
 void
 Server_i::request (Test::TimeStamp time_stamp,
                    const Test::Payload &payload
-                   TAO_ENV_ARG_DECL)
+                   ACE_ENV_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   if (CORBA::is_nil (this->callback_.in ()))
     return;
 
-  this->callback_->response (time_stamp, payload TAO_ENV_ARG_PARAMETER);
+  this->callback_->response (time_stamp, payload ACE_ENV_ARG_PARAMETER);
 }
 
 void
-Server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+Server_i::shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   this->done_ = 1;
diff --git a/TAO/performance-tests/Callback/Server_i.h b/TAO/performance-tests/Callback/Server_i.h
index 5cf73c65ce7..60887393721 100644
--- a/TAO/performance-tests/Callback/Server_i.h
+++ b/TAO/performance-tests/Callback/Server_i.h
@@ -18,15 +18,15 @@ public:
   /// Implement the CORBA methods
   //@{
   void set_callback (Test::Callback_ptr callback
-                     TAO_ENV_ARG_DECL_NOT_USED)
+                     ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
   void request (Test::TimeStamp,
                 const Test::Payload &
-                TAO_ENV_ARG_DECL_NOT_USED)
+                ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+  void shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
   //@}
diff --git a/TAO/performance-tests/Callback/client.cpp b/TAO/performance-tests/Callback/client.cpp
index e8af409d5a4..56743477b20 100644
--- a/TAO/performance-tests/Callback/client.cpp
+++ b/TAO/performance-tests/Callback/client.cpp
@@ -73,17 +73,17 @@ main (int argc, char *argv [])
   ACE_TRY_NEW_ENV
     {
       CORBA::ORB_var orb =
-        CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER);
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::Object_var manager_object =
         orb->resolve_initial_references ("ORBPolicyManager"
-                                         TAO_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::PolicyManager_var policy_manager =
         CORBA::PolicyManager::_narrow (manager_object.in ()
-                                       TAO_ENV_ARG_PARAMETER);
+                                       ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::Any sync_scope;
@@ -94,15 +94,15 @@ main (int argc, char *argv [])
       policy_list[0] =
         orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
                             sync_scope
-                            TAO_ENV_ARG_PARAMETER);
+                            ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
       policy_manager->set_policy_overrides (policy_list,
                                             CORBA::SET_OVERRIDE
-                                            TAO_ENV_ARG_PARAMETER);
+                                            ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::Object_var poa_object =
-        orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER);
+        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (poa_object.in ()))
@@ -111,14 +111,14 @@ main (int argc, char *argv [])
                           1);
 
       PortableServer::POA_var root_poa =
-        PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER);
+        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POAManager_var poa_manager =
-        root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER);
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER);
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (parse_args (argc, argv) != 0)
@@ -126,11 +126,11 @@ main (int argc, char *argv [])
 
       // Get the event channel object reference
       CORBA::Object_var object =
-        orb->string_to_object (ior TAO_ENV_ARG_PARAMETER);
+        orb->string_to_object (ior ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       Test::Server_var server =
-        Test::Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER);
+        Test::Server::_narrow (object.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
       if (CORBA::is_nil (server.in ()))
         {
@@ -143,10 +143,10 @@ main (int argc, char *argv [])
 
       Callback_i callback_i (iterations);
 
-      Test::Callback_var callback = callback_i._this (TAO_ENV_SINGLE_ARG_PARAMETER);
+      Test::Callback_var callback = callback_i._this (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      server->set_callback (callback.in () TAO_ENV_ARG_PARAMETER);
+      server->set_callback (callback.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ACE_DEBUG ((LM_DEBUG, "Connected callback\n"));
@@ -158,7 +158,7 @@ main (int argc, char *argv [])
       while (!callback_i.done () || !task.done ())
         {
           ACE_Time_Value tv (1, 0);
-          orb->run (tv TAO_ENV_ARG_PARAMETER);
+          orb->run (tv ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
       ACE_hrtime_t end = ACE_OS::gethrtime ();
@@ -188,15 +188,15 @@ main (int argc, char *argv [])
                                              end - start,
                                              stats.samples_count ());
 
-      server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
+      server->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::ObjectId_var id =
-        root_poa->servant_to_id (&callback_i TAO_ENV_ARG_PARAMETER);
+        root_poa->servant_to_id (&callback_i ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
-      root_poa->deactivate_object (id.in () TAO_ENV_ARG_PARAMETER);
+      root_poa->deactivate_object (id.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
-      orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCH (CORBA::Exception, ex)
@@ -270,7 +270,7 @@ Task::svc (void)
       for (;;)
         {
           Test::TimeStamp creation = ACE_OS::gethrtime ();
-          this->server_->request (creation, payload TAO_ENV_ARG_PARAMETER);
+          this->server_->request (creation, payload ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           // ACE_Time_Value tv (0, 5000);
diff --git a/TAO/performance-tests/Callback/server.cpp b/TAO/performance-tests/Callback/server.cpp
index cd0cec3d909..cd7874e13a7 100644
--- a/TAO/performance-tests/Callback/server.cpp
+++ b/TAO/performance-tests/Callback/server.cpp
@@ -42,17 +42,17 @@ main (int argc, char *argv [])
   ACE_TRY_NEW_ENV
     {
       CORBA::ORB_var orb =
-        CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER);
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::Object_var manager_object =
         orb->resolve_initial_references ("ORBPolicyManager"
-                                         TAO_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::PolicyManager_var policy_manager =
         CORBA::PolicyManager::_narrow (manager_object.in ()
-                                       TAO_ENV_ARG_PARAMETER);
+                                       ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::Any sync_scope;
@@ -63,15 +63,15 @@ main (int argc, char *argv [])
       policy_list[0] =
         orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
                             sync_scope
-                            TAO_ENV_ARG_PARAMETER);
+                            ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
       policy_manager->set_policy_overrides (policy_list,
                                             CORBA::SET_OVERRIDE
-                                            TAO_ENV_ARG_PARAMETER);
+                                            ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::Object_var poa_object =
-        orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER);
+        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (poa_object.in ()))
@@ -80,14 +80,14 @@ main (int argc, char *argv [])
                           1);
 
       PortableServer::POA_var root_poa =
-        PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER);
+        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POAManager_var poa_manager =
-        root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER);
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER);
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (parse_args (argc, argv) != 0)
@@ -95,11 +95,11 @@ main (int argc, char *argv [])
 
       Server_i server_i;
 
-      Test::Server_var server = server_i._this (TAO_ENV_SINGLE_ARG_PARAMETER);
+      Test::Server_var server = server_i._this (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::String_var str =
-        orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER);
+        orb->object_to_string (server.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (ior_file_name != 0)
@@ -117,16 +117,16 @@ main (int argc, char *argv [])
       while (!server_i.done ())
         {
           ACE_Time_Value tv (1, 0);
-          orb->run (tv TAO_ENV_ARG_PARAMETER);
+          orb->run (tv ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
 
       PortableServer::ObjectId_var id =
-        root_poa->servant_to_id (&server_i TAO_ENV_ARG_PARAMETER);
-      root_poa->deactivate_object (id.in () TAO_ENV_ARG_PARAMETER);
+        root_poa->servant_to_id (&server_i ACE_ENV_ARG_PARAMETER);
+      root_poa->deactivate_object (id.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCH (CORBA::Exception, ex)
diff --git a/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.cpp b/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.cpp
index 09a07be02fd..4c17c253c65 100644
--- a/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.cpp
+++ b/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.cpp
@@ -201,7 +201,7 @@ DII_Cubit_Client::init (int argc, char **argv)
       this->orb_var_ = CORBA::ORB_init (this->argc_,
                                         this->argv_,
                                         "internet"
-                                        TAO_ENV_ARG_PARAMETER);
+                                        ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Parse command line and verify parameters.
@@ -214,12 +214,12 @@ DII_Cubit_Client::init (int argc, char **argv)
       // Get a factory object reference from the factory IOR.
       this->factory_var_ =
         this->orb_var_->string_to_object (this->factory_IOR_
-                                          TAO_ENV_ARG_PARAMETER);
+                                          ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Get a Cubit object with a DII request on the Cubit factory.
       CORBA::Request_var mc_req (this->factory_var_->_request ("make_cubit"
-                                                               TAO_ENV_ARG_PARAMETER));
+                                                               ACE_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -233,7 +233,7 @@ DII_Cubit_Client::init (int argc, char **argv)
 
       // Invoke the <make_cubit> operation to ask the Cubit factory
       // for a Cubit object.
-      mc_req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
+      mc_req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Extract the returned object reference from the request.
@@ -388,7 +388,7 @@ DII_Cubit_Client::cube_short_dii (void)
     {
       // Create the request ...
       CORBA::Request_var req (this->obj_var_->_request ("cube_short"
-                                                        TAO_ENV_ARG_PARAMETER));
+                                                        ACE_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -402,7 +402,7 @@ DII_Cubit_Client::cube_short_dii (void)
 
       this->call_count_++;
 
-      req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
+      req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       req->return_value () >>= ret_short;
@@ -432,7 +432,7 @@ DII_Cubit_Client::cube_long_dii (void)
     {
       // Create the request ...
       CORBA::Request_var req (this->obj_var_->_request ("cube_long"
-                                                        TAO_ENV_ARG_PARAMETER));
+                                                        ACE_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -446,7 +446,7 @@ DII_Cubit_Client::cube_long_dii (void)
 
       this->call_count_++;
 
-      req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
+      req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);
 
       ACE_TRY_CHECK;
 
@@ -477,7 +477,7 @@ DII_Cubit_Client::cube_octet_dii (void)
     {
       // Create the request ...
       CORBA::Request_var req (this->obj_var_->_request ("cube_octet"
-                                                        TAO_ENV_ARG_PARAMETER));
+                                                        ACE_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -493,7 +493,7 @@ DII_Cubit_Client::cube_octet_dii (void)
       // Invoke, check for an exception and verify the result.
       this->call_count_++;
 
-      req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
+      req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);
 
       ACE_TRY_CHECK;
 
@@ -525,7 +525,7 @@ DII_Cubit_Client::cube_union_dii (void)
     {
       // Create the request ...
       CORBA::Request_var req (this->obj_var_->_request ("cube_union"
-                                                        TAO_ENV_ARG_PARAMETER));
+                                                        ACE_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -545,7 +545,7 @@ DII_Cubit_Client::cube_union_dii (void)
 
       this->call_count_++;
 
-      req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
+      req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);
 
       ACE_TRY_CHECK;
 
@@ -580,7 +580,7 @@ DII_Cubit_Client::cube_struct_dii (void)
     {
       // Create the request ...
       CORBA::Request_var req (this->obj_var_->_request ("cube_struct"
-                                                        TAO_ENV_ARG_PARAMETER));
+                                                        ACE_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -599,7 +599,7 @@ DII_Cubit_Client::cube_struct_dii (void)
 
       this->call_count_++;
 
-      req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
+      req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);
 
       ACE_TRY_CHECK;
 
@@ -632,7 +632,7 @@ DII_Cubit_Client::cube_octet_seq_dii (int length)
     {
       // Create the request ...
       CORBA::Request_var req (this->obj_var_->_request ("cube_octet_sequence"
-                                                         TAO_ENV_ARG_PARAMETER));
+                                                         ACE_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -652,7 +652,7 @@ DII_Cubit_Client::cube_octet_seq_dii (int length)
 
       this->call_count_++;
 
-      req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
+      req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);
 
       ACE_TRY_CHECK;
 
@@ -693,7 +693,7 @@ DII_Cubit_Client::cube_long_seq_dii (int length)
     {
       // Create the request ...
       CORBA::Request_var req (this->obj_var_->_request ("cube_long_sequence"
-                                                        TAO_ENV_ARG_PARAMETER));
+                                                        ACE_ENV_ARG_PARAMETER));
 
       ACE_TRY_CHECK;
 
@@ -714,7 +714,7 @@ DII_Cubit_Client::cube_long_seq_dii (int length)
 
       this->call_count_++;
 
-      req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER);
+      req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);
 
       ACE_TRY_CHECK;
 
@@ -822,12 +822,12 @@ DII_Cubit_Client::run (void)
       if (this->shutdown_)
         {
           CORBA::Request_var req (this->obj_var_->_request ("shutdown"
-                                                            TAO_ENV_ARG_PARAMETER));
+                                                            ACE_ENV_ARG_PARAMETER));
 
           ACE_TRY_CHECK;
 
           // Cubit::shutdown () is a oneway operation.
-          req->send_oneway (TAO_ENV_SINGLE_ARG_PARAMETER);
+          req->send_oneway (ACE_ENV_SINGLE_ARG_PARAMETER);
 
           ACE_TRY_CHECK;
 
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.cpp
index 3f9d51cff0b..cd4c2b57d43 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.cpp
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.cpp
@@ -382,7 +382,7 @@ Cubit_Client::check_enabled (u_int mask) const
 // Exercise the union.  Cube a union.
 
 void
-Cubit_Client::cube_union (TAO_ENV_SINGLE_ARG_DECL)
+Cubit_Client::cube_union (ACE_ENV_SINGLE_ARG_DECL)
 {
   ACE_TRY
     {
@@ -398,7 +398,7 @@ Cubit_Client::cube_union (TAO_ENV_SINGLE_ARG_DECL)
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_UNION_START);
 
         r = this->cubit_->cube_union (u
-                                      TAO_ENV_ARG_PARAMETER);
+                                      ACE_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -426,7 +426,7 @@ Cubit_Client::cube_union (TAO_ENV_SINGLE_ARG_DECL)
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_UNION_START);
 
         r = this->cubit_->cube_union (u
-                                      TAO_ENV_ARG_PARAMETER);
+                                      ACE_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -459,7 +459,7 @@ Cubit_Client::cube_union (TAO_ENV_SINGLE_ARG_DECL)
 
 void
 Cubit_Client::cube_short (int i
-                          TAO_ENV_ARG_DECL)
+                          ACE_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -471,7 +471,7 @@ Cubit_Client::cube_short (int i
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_SHORT_START);
 
         ret_short = cubit_->cube_short (arg_short
-                                        TAO_ENV_ARG_PARAMETER);
+                                        ACE_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -510,12 +510,12 @@ Cubit_Client::cube_short (int i
 
 void
 Cubit_Client::cube_oneway (int
-                           TAO_ENV_ARG_DECL)
+                           ACE_ENV_ARG_DECL)
 {
   ACE_TRY
     {
       ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_ONEWAY_START);
-      this->cubit_->cube_oneway (TAO_ENV_SINGLE_ARG_PARAMETER);
+      this->cubit_->cube_oneway (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
       this->call_count_++;
     }
@@ -531,12 +531,12 @@ Cubit_Client::cube_oneway (int
 
 void
 Cubit_Client::cube_void (int
-                         TAO_ENV_ARG_DECL)
+                         ACE_ENV_ARG_DECL)
 {
   ACE_TRY
     {
       ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_VOID_START);
-      this->cubit_->cube_void (TAO_ENV_SINGLE_ARG_PARAMETER);
+      this->cubit_->cube_void (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
       this->call_count_++;
     }
@@ -554,7 +554,7 @@ Cubit_Client::cube_void (int
 
 void
 Cubit_Client::cube_octet (int i
-                          TAO_ENV_ARG_DECL)
+                          ACE_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -566,7 +566,7 @@ Cubit_Client::cube_octet (int i
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_OCTET_START);
 
         ret_octet = this->cubit_->cube_octet (arg_octet
-                                              TAO_ENV_ARG_PARAMETER);
+                                              ACE_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -606,7 +606,7 @@ Cubit_Client::cube_octet (int i
 
 void
 Cubit_Client::cube_long (int i
-                         TAO_ENV_ARG_DECL)
+                         ACE_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -618,7 +618,7 @@ Cubit_Client::cube_long (int i
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_LONG_START);
 
         ret_long = this->cubit_->cube_long (arg_long
-                                            TAO_ENV_ARG_PARAMETER);
+                                            ACE_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -661,7 +661,7 @@ Cubit_Client::cube_long (int i
 
 void
 Cubit_Client::cube_struct (int i
-                           TAO_ENV_ARG_DECL)
+                           ACE_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -679,7 +679,7 @@ Cubit_Client::cube_struct (int i
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_STRUCT_START);
 
         ret_struct = this->cubit_->cube_struct (arg_struct
-                                                TAO_ENV_ARG_PARAMETER);
+                                                ACE_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -718,7 +718,7 @@ Cubit_Client::cube_struct (int i
 void
 Cubit_Client::cube_long_sequence (int,
                                   int l
-                                  TAO_ENV_ARG_DECL)
+                                  ACE_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -746,7 +746,7 @@ Cubit_Client::cube_long_sequence (int,
 
         this->cubit_->cube_long_sequence (input,
                                           vout
-                                          TAO_ENV_ARG_PARAMETER);
+                                          ACE_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -791,7 +791,7 @@ Cubit_Client::cube_long_sequence (int,
 void
 Cubit_Client::cube_octet_sequence (int,
                                    int l
-                                   TAO_ENV_ARG_DECL)
+                                   ACE_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -820,7 +820,7 @@ Cubit_Client::cube_octet_sequence (int,
 
         this->cubit_->cube_octet_sequence (input,
                                            vout
-                                           TAO_ENV_ARG_PARAMETER);
+                                           ACE_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -866,7 +866,7 @@ Cubit_Client::cube_octet_sequence (int,
 void
 Cubit_Client::cube_many_sequence (int,
                                   int l
-                                  TAO_ENV_ARG_DECL)
+                                  ACE_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -902,7 +902,7 @@ Cubit_Client::cube_many_sequence (int,
 
         this->cubit_->cube_many_sequence (input,
                                           vout
-                                          TAO_ENV_ARG_PARAMETER);
+                                          ACE_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -951,7 +951,7 @@ void
 Cubit_Client::cube_rti_data (int,
                              int numUpdates,
                              int numAttrs
-                             TAO_ENV_ARG_DECL)
+                             ACE_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -1022,7 +1022,7 @@ Cubit_Client::cube_rti_data (int,
 
         this->cubit_->cube_rti_data (input,
                                      vout
-                                     TAO_ENV_ARG_PARAMETER);
+                                     ACE_ENV_ARG_PARAMETER);
       }
 
       ACE_TRY_CHECK;
@@ -1054,7 +1054,7 @@ Cubit_Client::cube_rti_data (int,
 
 void
 Cubit_Client::cube_any (int i
-                        TAO_ENV_ARG_DECL)
+                        ACE_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -1069,7 +1069,7 @@ Cubit_Client::cube_any (int i
       {
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_ANY_START);
         ret_any = this->cubit_->cube_any (arg_any
-                                          TAO_ENV_ARG_PARAMETER);
+                                          ACE_ENV_ARG_PARAMETER);
       }
       ACE_TRY_CHECK;
 
@@ -1114,7 +1114,7 @@ Cubit_Client::cube_any (int i
 
 void
 Cubit_Client::cube_any_struct (int i
-                               TAO_ENV_ARG_DECL)
+                               ACE_ENV_ARG_DECL)
 {
   ACE_TRY
     {
@@ -1134,7 +1134,7 @@ Cubit_Client::cube_any_struct (int i
       {
         ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_ANY_STRUCT_START);
         ret_any = this->cubit_->cube_any_struct (arg_any
-                                                 TAO_ENV_ARG_PARAMETER);
+                                                 ACE_ENV_ARG_PARAMETER);
       }
       ACE_TRY_CHECK;
 
@@ -1246,7 +1246,7 @@ Cubit_Client::run ()
 
   // Show the results one type at a time.
 
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       // VOID
@@ -1259,7 +1259,7 @@ Cubit_Client::run ()
           for (i = 0; i < this->loop_count_; ++i)
             {
               this->cube_void (i
-                               TAO_ENV_ARG_PARAMETER);
+                               ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1280,7 +1280,7 @@ Cubit_Client::run ()
           for (i = 0; i < this->loop_count_; ++i)
             {
               this->cube_short (i
-                                TAO_ENV_ARG_PARAMETER);
+                                ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1301,7 +1301,7 @@ Cubit_Client::run ()
           for (i = 0; i < this->loop_count_; ++i)
             {
               this->cube_octet (i
-                                TAO_ENV_ARG_PARAMETER);
+                                ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1322,7 +1322,7 @@ Cubit_Client::run ()
           for (i = 0; i < this->loop_count_; ++i)
             {
               this->cube_long (i
-                               TAO_ENV_ARG_PARAMETER);
+                               ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1342,7 +1342,7 @@ Cubit_Client::run ()
           for (i = 0; i < this->loop_count_; ++i)
             {
               this->cube_struct (i
-                                 TAO_ENV_ARG_PARAMETER);
+                                 ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1362,7 +1362,7 @@ Cubit_Client::run ()
 
           for (i = 0; i < this->loop_count_; ++i)
             {
-              this->cube_union (TAO_ENV_SINGLE_ARG_PARAMETER);
+              this->cube_union (ACE_ENV_SINGLE_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1384,7 +1384,7 @@ Cubit_Client::run ()
             {
               this->cube_long_sequence (this->loop_count_,
                                         4
-                                        TAO_ENV_ARG_PARAMETER);
+                                        ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1406,7 +1406,7 @@ Cubit_Client::run ()
             {
               this->cube_long_sequence (this->loop_count_,
                                         1024
-                                        TAO_ENV_ARG_PARAMETER);
+                                        ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1433,7 +1433,7 @@ Cubit_Client::run ()
                 {
                   this->cube_octet_sequence (this->loop_count_,
                                              bytes_in_octet_sequence_
-                                             TAO_ENV_ARG_PARAMETER);
+                                             ACE_ENV_ARG_PARAMETER);
                   ACE_TRY_CHECK;
                 }
             }
@@ -1443,7 +1443,7 @@ Cubit_Client::run ()
                 {
                   this->cube_octet_sequence (this->loop_count_,
                                              16
-                                             TAO_ENV_ARG_PARAMETER);
+                                             ACE_ENV_ARG_PARAMETER);
                   ACE_TRY_CHECK;
                 }
             }
@@ -1466,7 +1466,7 @@ Cubit_Client::run ()
             {
               this->cube_octet_sequence (this->loop_count_,
                                          4096
-                                         TAO_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1488,7 +1488,7 @@ Cubit_Client::run ()
             {
               this->cube_many_sequence (this->loop_count_,
                                         4
-                                        TAO_ENV_ARG_PARAMETER);
+                                        ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1510,7 +1510,7 @@ Cubit_Client::run ()
             {
               this->cube_many_sequence (this->loop_count_,
                                         1024
-                                        TAO_ENV_ARG_PARAMETER);
+                                        ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1531,15 +1531,15 @@ Cubit_Client::run ()
           for (i = 0; i < this->loop_count_; ++i)
             {
               this->cube_short (i
-                                TAO_ENV_ARG_PARAMETER);
+                                ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
 
               this->cube_octet (i
-                                TAO_ENV_ARG_PARAMETER);
+                                ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
 
               this->cube_long (i
-                               TAO_ENV_ARG_PARAMETER);
+                               ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1561,7 +1561,7 @@ Cubit_Client::run ()
               this->cube_rti_data (this->loop_count_,
                                    2,
                                    5
-                                   TAO_ENV_ARG_PARAMETER);
+                                   ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1582,7 +1582,7 @@ Cubit_Client::run ()
           for (i = 0; i < this->loop_count_; ++i)
             {
               this->cube_oneway (i
-                                 TAO_ENV_ARG_PARAMETER);
+                                 ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1603,7 +1603,7 @@ Cubit_Client::run ()
           for (i = 0; i < this->loop_count_; ++i)
             {
               this->cube_any (i
-                              TAO_ENV_ARG_PARAMETER);
+                              ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
@@ -1623,7 +1623,7 @@ Cubit_Client::run ()
           for (i = 0; i < this->loop_count_; ++i)
             {
               this->cube_any_struct (i
-                                     TAO_ENV_ARG_PARAMETER);
+                                     ACE_ENV_ARG_PARAMETER);
 
               ACE_TRY_CHECK;
             }
@@ -1636,7 +1636,7 @@ Cubit_Client::run ()
         }
 
       this->shutdown_server (this->shutdown_
-                             TAO_ENV_ARG_PARAMETER);
+                             ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -1651,7 +1651,7 @@ Cubit_Client::run ()
 
 int
 Cubit_Client::shutdown_server (int do_shutdown
-                               TAO_ENV_ARG_DECL)
+                               ACE_ENV_ARG_DECL)
 {
   if (do_shutdown)
     {
@@ -1660,7 +1660,7 @@ Cubit_Client::shutdown_server (int do_shutdown
 
       ACE_TRY_EX(NOT_COLLOCATED)
         {
-          this->cubit_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
+          this->cubit_->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK_EX (NOT_COLLOCATED);
         }
       ACE_CATCHANY
@@ -1714,7 +1714,7 @@ Cubit_Client::init (int argc, char **argv)
       this->orb_ = CORBA::ORB_init (this->argc_,
                                     this->argv_,
                                     "internet"
-                                    TAO_ENV_ARG_PARAMETER);
+                                    ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Parse command line and verify parameters.
@@ -1744,12 +1744,12 @@ Cubit_Client::init (int argc, char **argv)
 
       CORBA::Object_var factory_object =
         this->orb_->string_to_object (this->cubit_factory_key_
-                                      TAO_ENV_ARG_PARAMETER);
+                                      ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       this->factory_ =
         Cubit_Factory::_narrow (factory_object.in()
-                                TAO_ENV_ARG_PARAMETER);
+                                ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (this->factory_.in ()))
@@ -1765,7 +1765,7 @@ Cubit_Client::init (int argc, char **argv)
 
       // Now retrieve the Cubit obj ref corresponding to the key.
       this->cubit_ =
-        this->factory_->make_cubit (TAO_ENV_SINGLE_ARG_PARAMETER);
+        this->factory_->make_cubit (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (this->cubit_.in ()))
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.h b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.h
index 4cddf3da4bd..54d2244eaaa 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.h
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.h
@@ -82,59 +82,59 @@ private:
                     ACE_Profile_Timer::ACE_Elapsed_Time &elapsed_time);
   // Prints the time stats.
 
-  void cube_union (TAO_ENV_SINGLE_ARG_DECL);
+  void cube_union (ACE_ENV_SINGLE_ARG_DECL);
   // Exercise the union.  Cube a union.
 
   void cube_struct (int i
-                    TAO_ENV_ARG_DECL);
+                    ACE_ENV_ARG_DECL);
   // calculate the cube from a struct.
 
   void cube_long (int i
-                  TAO_ENV_ARG_DECL);
+                  ACE_ENV_ARG_DECL);
   // calculate the cube from a long.
 
   void cube_oneway (int i
-                    TAO_ENV_ARG_DECL);
+                    ACE_ENV_ARG_DECL);
   // Oneway operation test.
 
   void cube_void (int i
-                  TAO_ENV_ARG_DECL);
+                  ACE_ENV_ARG_DECL);
   // Twoway operation test.
 
   void cube_octet (int i
-                   TAO_ENV_ARG_DECL);
+                   ACE_ENV_ARG_DECL);
   // Cube an octet.
 
   void cube_short (int i
-                   TAO_ENV_ARG_DECL);
+                   ACE_ENV_ARG_DECL);
   // Cube a short.
 
   void cube_long_sequence (int i, int l
-                           TAO_ENV_ARG_DECL);
+                           ACE_ENV_ARG_DECL);
   // Cube a sequence <l> is the length of the sequence.
 
   void cube_octet_sequence (int i, int l
-                            TAO_ENV_ARG_DECL);
+                            ACE_ENV_ARG_DECL);
   // Cube a sequence of octets, <l> is the length of the sequence.
 
   void cube_many_sequence (int i, int l
-                           TAO_ENV_ARG_DECL);
+                           ACE_ENV_ARG_DECL);
   // Cube a sequence of manys, <l> is the length of the sequence.
 
   void cube_rti_data (int i, int numUpdates, int numAttrs
-                      TAO_ENV_ARG_DECL);
+                      ACE_ENV_ARG_DECL);
   // Cube a sequence <l> is the length of the sequence.
 
   void cube_any_struct (int i
-                    TAO_ENV_ARG_DECL);
+                    ACE_ENV_ARG_DECL);
   // calculate the cube from a struct in an any.
 
   void cube_any (int i
-                 TAO_ENV_ARG_DECL);
+                 ACE_ENV_ARG_DECL);
   // calculate the cube from a long in an any.
 
   int shutdown_server (int do_shutdown
-                       TAO_ENV_ARG_DECL);
+                       ACE_ENV_ARG_DECL);
   // Invoke the method with <do_shutdown> != 0 to shutdown the server.
 
   int argc_;
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.cpp
index 9e39a72109b..539f14720cb 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.cpp
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.cpp
@@ -56,14 +56,14 @@ Cubit_Server::parse_args (void)
 int
 Cubit_Server::init (int argc,
                     char** argv
-                    TAO_ENV_ARG_DECL_NOT_USED TAO_ENV_SINGLE_ARG_PARAMETER)
+                    ACE_ENV_ARG_DECL_NOT_USED ACE_ENV_SINGLE_ARG_PARAMETER)
 {
   // Call the init of <TAO_ORB_Manager> to initialize the ORB and
   // create a child POA under the root POA.
   if (this->orb_manager_.init_child_poa (argc,
                                          argv,
                                          "child_poa"
-                                         TAO_ENV_ARG_PARAMETER) == -1)
+                                         ACE_ENV_ARG_PARAMETER) == -1)
     ACE_ERROR_RETURN ((LM_ERROR,
                        "%p\n",
                        "init_child_poa"),
@@ -89,7 +89,7 @@ Cubit_Server::init (int argc,
   this->factory_id_ =
     this->orb_manager_.activate_under_child_poa ("factory",
                                                  this->factory_impl_
-                                                 TAO_ENV_ARG_PARAMETER);
+                                                 ACE_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (-1);
 
   ACE_DEBUG ((LM_DEBUG,
@@ -108,9 +108,9 @@ Cubit_Server::init (int argc,
 }
 
 int
-Cubit_Server::run (TAO_ENV_SINGLE_ARG_DECL)
+Cubit_Server::run (ACE_ENV_SINGLE_ARG_DECL)
 {
-  if (this->orb_manager_.run (TAO_ENV_SINGLE_ARG_PARAMETER) == -1)
+  if (this->orb_manager_.run (ACE_ENV_SINGLE_ARG_PARAMETER) == -1)
     ACE_ERROR_RETURN ((LM_ERROR,
                        "Cubit_Server::run"),
                       -1);
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.h b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.h
index d31269dd6ee..5f5bb1419d4 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.h
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.h
@@ -52,10 +52,10 @@ public:
 
   int init (int argc,
             char **argv
-            TAO_ENV_ARG_DECL);
+            ACE_ENV_ARG_DECL);
   // Initialize the Cubit_Server state - parsing arguments and ...
 
-  int run (TAO_ENV_SINGLE_ARG_DECL);
+  int run (ACE_ENV_SINGLE_ARG_DECL);
   // Run the orb
 
 private:
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.cpp
index 6eca9eb5f98..d3c6cc45515 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.cpp
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.cpp
@@ -126,10 +126,10 @@ Cubit_Factory_i::~Cubit_Factory_i (void)
 }
 
 Cubit_ptr
-Cubit_Factory_i::make_cubit (TAO_ENV_SINGLE_ARG_DECL)
+Cubit_Factory_i::make_cubit (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  return my_cubit_._this (TAO_ENV_SINGLE_ARG_PARAMETER);
+  return my_cubit_._this (ACE_ENV_SINGLE_ARG_PARAMETER);
 }
 
 void
@@ -152,7 +152,7 @@ Cubit_i::~Cubit_i (void)
 }
 
 PortableServer::POA_ptr
-Cubit_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+Cubit_i::_default_POA (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
   return PortableServer::POA::_duplicate (this->poa_.in ());
 }
@@ -164,14 +164,14 @@ Cubit_i::set_default_poa (PortableServer::POA_ptr poa)
 }
 
 void
-Cubit_i::cube_oneway (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+Cubit_i::cube_oneway (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_ONEWAY_START);
 }
 
 void
-Cubit_i::cube_void (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+Cubit_i::cube_void (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_VOID_START);
@@ -181,7 +181,7 @@ Cubit_i::cube_void (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
 
 CORBA::Octet
 Cubit_i::cube_octet (CORBA::Octet o
-                     TAO_ENV_ARG_DECL_NOT_USED)
+                     ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_OCTET_START);
@@ -193,7 +193,7 @@ Cubit_i::cube_octet (CORBA::Octet o
 
 CORBA::Short
 Cubit_i::cube_short (CORBA::Short s
-                     TAO_ENV_ARG_DECL_NOT_USED)
+                     ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_SHORT_START);
@@ -205,7 +205,7 @@ Cubit_i::cube_short (CORBA::Short s
 
 CORBA::Long
 Cubit_i::cube_long (CORBA::Long l
-                    TAO_ENV_ARG_DECL_NOT_USED)
+                    ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_LONG_START);
@@ -217,7 +217,7 @@ Cubit_i::cube_long (CORBA::Long l
 
 Cubit::Many
 Cubit_i::cube_struct (const Cubit::Many &values
-                      TAO_ENV_ARG_DECL_NOT_USED)
+                      ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_STRUCT_START);
@@ -235,7 +235,7 @@ Cubit_i::cube_struct (const Cubit::Many &values
 
 Cubit::oneof
 Cubit_i::cube_union (const Cubit::oneof &values
-                     TAO_ENV_ARG_DECL_NOT_USED)
+                     ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_UNION_START);
@@ -269,7 +269,7 @@ Cubit_i::cube_union (const Cubit::oneof &values
 void
 Cubit_i::cube_long_sequence (const Cubit::long_seq &input,
                              Cubit::long_seq_out output
-                             TAO_ENV_ARG_DECL_NOT_USED)
+                             ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_LONG_SEQUENCE_START);
@@ -296,7 +296,7 @@ Cubit_i::cube_long_sequence (const Cubit::long_seq &input,
 void
 Cubit_i::cube_octet_sequence (const Cubit::octet_seq &input,
                               Cubit::octet_seq_out output
-                              TAO_ENV_ARG_DECL_NOT_USED)
+                              ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_OCTET_SEQUENCE_START);
@@ -337,7 +337,7 @@ Cubit_i::cube_octet_sequence (const Cubit::octet_seq &input,
 void
 Cubit_i::cube_many_sequence (const Cubit::many_seq & input,
                              Cubit::many_seq_out output
-                             TAO_ENV_ARG_DECL_NOT_USED)
+                             ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_MANY_SEQUENCE_START);
@@ -371,7 +371,7 @@ Cubit_i::cube_many_sequence (const Cubit::many_seq & input,
 void
 Cubit_i::cube_rti_data (const Cubit::RtiPacket &input,
                         Cubit::RtiPacket_out output
-                        TAO_ENV_ARG_DECL_NOT_USED)
+                        ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_LONG_SEQUENCE_START);
@@ -403,7 +403,7 @@ Cubit_i::cube_rti_data (const Cubit::RtiPacket &input,
 
 CORBA::Any *
 Cubit_i::cube_any (const CORBA::Any & any
-                   TAO_ENV_ARG_DECL_NOT_USED)
+                   ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_ANY_START);
@@ -420,7 +420,7 @@ Cubit_i::cube_any (const CORBA::Any & any
 
 CORBA::Any *
 Cubit_i::cube_any_struct (const CORBA::Any & any
-                          TAO_ENV_ARG_DECL_NOT_USED)
+                          ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_ANY_STRUCT_START);
@@ -439,7 +439,7 @@ Cubit_i::cube_any_struct (const CORBA::Any & any
 
 // Shutdown.
 
-void Cubit_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+void Cubit_i::shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_DEBUG ((LM_DEBUG,
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.h b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.h
index 454be029601..517bd50068c 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.h
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.h
@@ -37,77 +37,77 @@ public:
   ~Cubit_i (void);
   // Destructor
 
-  virtual PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+  virtual PortableServer::POA_ptr _default_POA (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
   // Returns the default POA for this servant.
 
-  virtual void cube_oneway (TAO_ENV_SINGLE_ARG_DECL)
+  virtual void cube_oneway (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Test a oneway call.
 
-  virtual void cube_void (TAO_ENV_SINGLE_ARG_DECL)
+  virtual void cube_void (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Test a twoway call.
 
   virtual CORBA::Octet cube_octet (CORBA::Octet o
-                                   TAO_ENV_ARG_DECL)
+                                   ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube an octet
 
   virtual CORBA::Short cube_short (CORBA::Short s
-                                   TAO_ENV_ARG_DECL)
+                                   ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a short
 
   virtual CORBA::Long cube_long (CORBA::Long l
-                                 TAO_ENV_ARG_DECL)
+                                 ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a long
 
   virtual Cubit::Many cube_struct (const Cubit::Many &values
-                                   TAO_ENV_ARG_DECL)
+                                   ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a struct.
 
   virtual Cubit::oneof cube_union (const Cubit::oneof &values
-                                   TAO_ENV_ARG_DECL)
+                                   ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a union.
 
   virtual void cube_long_sequence (const Cubit::long_seq &input,
                                    Cubit::long_seq_out output
-                                   TAO_ENV_ARG_DECL)
+                                   ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a sequence.
 
   virtual void cube_octet_sequence (const Cubit::octet_seq &input,
                                     Cubit::octet_seq_out output
-                                    TAO_ENV_ARG_DECL)
+                                    ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube an octet sequence.
 
   virtual void cube_many_sequence (const Cubit::many_seq & input,
                                    Cubit::many_seq_out output
-                                   TAO_ENV_ARG_DECL)
+                                   ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube an Many sequence.
 
   virtual void cube_rti_data (const Cubit::RtiPacket &input,
                               Cubit::RtiPacket_out output
-                              TAO_ENV_ARG_DECL)
+                              ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a sequence.
 
   virtual CORBA::Any * cube_any (const CORBA::Any & any
-                                TAO_ENV_ARG_DECL)
+                                ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a long in an any
 
   virtual CORBA::Any * cube_any_struct (const CORBA::Any & any
-                                       TAO_ENV_ARG_DECL)
+                                       ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Cube a struct in an any
 
-  virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL)
+  virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Shutdown routine.
 
@@ -135,7 +135,7 @@ public:
   ~Cubit_Factory_i (void);
   // Destructor.
 
-  virtual Cubit_ptr make_cubit (TAO_ENV_SINGLE_ARG_DECL)
+  virtual Cubit_ptr make_cubit (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Make a cubit object.
 
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.cpp
index b988891d80a..aef78ddc350 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.cpp
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.cpp
@@ -44,14 +44,14 @@ svr_worker (void *arg)
     {
       int result = cubit_server.init (args.argc (),
                                       args.argv ()
-                                      TAO_ENV_ARG_PARAMETER);
+                                      ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (result == -1)
         return (void *) 1;
 
       barrier->server_init_.wait ();
-      cubit_server.run (TAO_ENV_SINGLE_ARG_PARAMETER);
+      cubit_server.run (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       barrier->client_fini_.wait ();
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.cpp
index af690c0ace4..b32c03b6451 100644
--- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.cpp
+++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.cpp
@@ -46,13 +46,13 @@ main (int argc, char *argv[])
               "\n\tIDL_Cubit: server\n\n"));
   ACE_TRY_NEW_ENV
     {
-      int ret = cubit_server.init (argc, argv TAO_ENV_ARG_PARAMETER);
+      int ret = cubit_server.init (argc, argv ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (ret == -1)
         return -1;
 
-      cubit_server.run (TAO_ENV_SINGLE_ARG_PARAMETER);
+      cubit_server.run (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ACE_OS::sleep (5);
diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Cubit_Task.cpp b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Cubit_Task.cpp
index 1105a5a099c..25363f792a3 100644
--- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Cubit_Task.cpp
+++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Cubit_Task.cpp
@@ -64,14 +64,14 @@ Cubit_Task::svc (void)
                        "Create Servants failed.\n"),
                       -1);
 
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       GLOBALS::instance ()->barrier_->wait ();
 
       // Handle requests for this object until we're killed, or one of
       // the methods asks us to exit.
-      int r = this->orb_manager_.run (TAO_ENV_SINGLE_ARG_PARAMETER);
+      int r = this->orb_manager_.run (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (r == -1)
@@ -84,7 +84,7 @@ Cubit_Task::svc (void)
       CORBA::ORB_var orb =
         this->orb_manager_.orb ();
 
-      orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -105,7 +105,7 @@ Cubit_Task::svc (void)
 int
 Cubit_Task::initialize_orb (void)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       ACE_ARGV args (this->orbargs_);
@@ -122,7 +122,7 @@ Cubit_Task::initialize_orb (void)
                                                  argv,
                                                  "persistent_poa",
                                                  orb_name
-                                                 TAO_ENV_ARG_PARAMETER);
+                                                 ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
       if (r == -1)
         return -1;
@@ -166,23 +166,23 @@ Cubit_Task::get_servant_ior (u_int index)
 int
 Cubit_Task::create_servants (void)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       CORBA::Object_var obj =
         this->orb_->resolve_initial_references ("RootPOA"
-                                                TAO_ENV_ARG_PARAMETER);
+                                                ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POA_var poa =
-        PortableServer::POA::_narrow (obj.in () TAO_ENV_ARG_PARAMETER);
+        PortableServer::POA::_narrow (obj.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POAManager_var manager =
-        poa->the_POAManager(TAO_ENV_SINGLE_ARG_PARAMETER);
+        poa->the_POAManager(ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      manager->activate(TAO_ENV_SINGLE_ARG_PARAMETER);
+      manager->activate(ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Create the array of cubit implementations.
@@ -232,13 +232,13 @@ Cubit_Task::create_servants (void)
           // some client.  Then release the object.
 
           Cubit_var cubit =
-            this->servants_[i]->_this (TAO_ENV_SINGLE_ARG_PARAMETER);
+            this->servants_[i]->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
 
           CORBA::String_var str =
             this->orb_->object_to_string (cubit.in ()
-                                          TAO_ENV_ARG_PARAMETER);
+                                          ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           this->servants_iors_[i] =
diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.cpp b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.cpp
index 824d3dbcabc..da15b9ad9b3 100644
--- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.cpp
+++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.cpp
@@ -553,7 +553,7 @@ Client::find_frequency (void)
 }
 
 CORBA::ORB_ptr
-Client::init_orb (TAO_ENV_SINGLE_ARG_DECL)
+Client::init_orb (ACE_ENV_SINGLE_ARG_DECL)
 {
   ACE_DEBUG ((LM_DEBUG,
               "I'm thread %t\n"));
@@ -583,7 +583,7 @@ Client::init_orb (TAO_ENV_SINGLE_ARG_DECL)
   CORBA::ORB_var orb = CORBA::ORB_init (argc,
                                         argv,
                                         orbid
-                                        TAO_ENV_ARG_PARAMETER);
+                                        ACE_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (CORBA::ORB::_nil ());
 
   if (this->id_ == 0)
@@ -613,7 +613,7 @@ Client::init_orb (TAO_ENV_SINGLE_ARG_DECL)
 }
 
 int
-Client::get_cubit (CORBA::ORB_ptr orb TAO_ENV_ARG_DECL)
+Client::get_cubit (CORBA::ORB_ptr orb ACE_ENV_ARG_DECL)
 {
   char *my_ior =
     this->ts_->use_utilization_test_ == 1
@@ -633,7 +633,7 @@ Client::get_cubit (CORBA::ORB_ptr orb TAO_ENV_ARG_DECL)
 
   CORBA::Object_var objref =
     orb->string_to_object (my_ior
-                           TAO_ENV_ARG_PARAMETER);
+                           ACE_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (-1);
 
   if (CORBA::is_nil (objref.in ()))
@@ -644,7 +644,7 @@ Client::get_cubit (CORBA::ORB_ptr orb TAO_ENV_ARG_DECL)
   // Narrow the CORBA::Object reference to the stub object,
   // checking the type along the way using _is_a.
   this->cubit_ = Cubit::_narrow (objref.in ()
-                                 TAO_ENV_ARG_PARAMETER);
+                                 ACE_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (-1);
 
   if (CORBA::is_nil (this->cubit_))
@@ -657,7 +657,7 @@ Client::get_cubit (CORBA::ORB_ptr orb TAO_ENV_ARG_DECL)
 
   CORBA::String_var str =
     orb->object_to_string (this->cubit_
-                           TAO_ENV_ARG_PARAMETER);
+                           ACE_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (-1);
 
   ACE_DEBUG ((LM_DEBUG,
@@ -670,18 +670,18 @@ Client::get_cubit (CORBA::ORB_ptr orb TAO_ENV_ARG_DECL)
 int
 Client::svc (void)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       // Initialize the ORB.
-      CORBA::ORB_var orb = this->init_orb (TAO_ENV_SINGLE_ARG_PARAMETER);
+      CORBA::ORB_var orb = this->init_orb (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Find the frequency of CORBA requests based on thread id.
       this->find_frequency ();
 
       // Get the cubit object from the file.
-      int r = this->get_cubit (orb.in () TAO_ENV_ARG_PARAMETER);
+      int r = this->get_cubit (orb.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
       if (r != 0)
         return r;
@@ -716,14 +716,14 @@ Client::svc (void)
         {
           ACE_DEBUG ((LM_DEBUG,
                       "(%t) CALLING SHUTDOWN() ON THE SERVANT\n"));
-          this->cubit_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
+          this->cubit_->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
 
       CORBA::release (this->cubit_);
       this->cubit_ = 0;
 
-      orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
@@ -746,7 +746,7 @@ Client::svc (void)
 int
 Client::cube_octet (void)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       this->call_count_++;
@@ -758,10 +758,10 @@ Client::cube_octet (void)
 
       if (this->ts_->use_utilization_test_ == 1 && this->ts_->remote_invocations_ == 0)
         ret_octet = this->cubit_impl_.cube_octet (arg_octet
-                                                  TAO_ENV_ARG_PARAMETER);
+                                                  ACE_ENV_ARG_PARAMETER);
       else
         ret_octet = this->cubit_->cube_octet (arg_octet
-                                              TAO_ENV_ARG_PARAMETER);
+                                              ACE_ENV_ARG_PARAMETER);
 
       STOP_QUANTIFY;
       ACE_TRY_CHECK;
@@ -792,7 +792,7 @@ Client::cube_octet (void)
 int
 Client::cube_short (void)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       this->call_count_++;
@@ -802,7 +802,7 @@ Client::cube_short (void)
 
       START_QUANTIFY;
       ret_short = this->cubit_->cube_short (arg_short
-                                            TAO_ENV_ARG_PARAMETER);
+                                            ACE_ENV_ARG_PARAMETER);
       STOP_QUANTIFY;
       ACE_TRY_CHECK;
       arg_short = arg_short * arg_short * arg_short;
@@ -829,7 +829,7 @@ Client::cube_short (void)
 int
 Client::cube_long (void)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       this->call_count_++;
@@ -839,7 +839,7 @@ Client::cube_long (void)
 
       START_QUANTIFY;
       ret_long = this->cubit_->cube_long (arg_long
-                                          TAO_ENV_ARG_PARAMETER);
+                                          ACE_ENV_ARG_PARAMETER);
       STOP_QUANTIFY;
       ACE_TRY_CHECK;
 
@@ -866,7 +866,7 @@ Client::cube_long (void)
 int
 Client::cube_struct (void)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
   ACE_TRY
     {
       Cubit::Many arg_struct;
@@ -880,7 +880,7 @@ Client::cube_struct (void)
 
       START_QUANTIFY;
       ret_struct = this->cubit_->cube_struct (arg_struct
-                                              TAO_ENV_ARG_PARAMETER);
+                                              ACE_ENV_ARG_PARAMETER);
       STOP_QUANTIFY;
       ACE_TRY_CHECK;
 
@@ -940,12 +940,12 @@ Client::make_request (void)
     }
   else
     {
-      TAO_ENV_DECLARE_NEW_ENV;
+      ACE_DECLARE_NEW_CORBA_ENV;
       ACE_TRY
         {
           this->call_count_++;
           START_QUANTIFY;
-          this->cubit_->noop (TAO_ENV_SINGLE_ARG_PARAMETER);
+          this->cubit_->noop (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
           STOP_QUANTIFY;
         }
diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.h b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.h
index 554ad87b619..cd169ebe4d0 100644
--- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.h
+++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.h
@@ -279,14 +279,14 @@ public:
   // cubed.
 
 private:
-  CORBA::ORB_ptr init_orb (TAO_ENV_SINGLE_ARG_DECL);
+  CORBA::ORB_ptr init_orb (ACE_ENV_SINGLE_ARG_DECL);
   // initialize the ORB.
 
   void read_ior (void);
   // reads the cubit ior from a file.
 
   int get_cubit (CORBA::ORB_ptr orb
-                 TAO_ENV_ARG_DECL);
+                 ACE_ENV_ARG_DECL);
   // gets the cubit object.
 
   int run_tests (void);
diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.cpp b/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.cpp
index 8de8568c427..0dbd9106a87 100644
--- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.cpp
+++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.cpp
@@ -19,7 +19,7 @@ Cubit_i::~Cubit_i (void)
 
 CORBA::Octet
 Cubit_i::cube_octet (CORBA::Octet o
-                     TAO_ENV_ARG_DECL_NOT_USED)
+                     ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   return (CORBA::Octet) (o * o * o);
@@ -27,7 +27,7 @@ Cubit_i::cube_octet (CORBA::Octet o
 
 CORBA::Short
 Cubit_i::cube_short (CORBA::Short s
-                     TAO_ENV_ARG_DECL_NOT_USED)
+                     ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   return (CORBA::Short) (s * s * s);
@@ -35,7 +35,7 @@ Cubit_i::cube_short (CORBA::Short s
 
 CORBA::Long
 Cubit_i::cube_long (CORBA::Long l
-                    TAO_ENV_ARG_DECL_NOT_USED)
+                    ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   return (CORBA::Long) (l * l * l);
@@ -43,7 +43,7 @@ Cubit_i::cube_long (CORBA::Long l
 
 Cubit::Many
 Cubit_i::cube_struct (const Cubit::Many &values
-                      TAO_ENV_ARG_DECL_NOT_USED)
+                      ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   Cubit::Many out_values;
@@ -56,13 +56,13 @@ Cubit_i::cube_struct (const Cubit::Many &values
 }
 
 void
-Cubit_i::noop (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+Cubit_i::noop (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   // does nothing.
 }
 
-void Cubit_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+void Cubit_i::shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_DEBUG ((LM_DEBUG,
@@ -71,7 +71,7 @@ void Cubit_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
 }
 
 PortableServer::POA_ptr
-Cubit_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+Cubit_i::_default_POA (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
   return PortableServer::POA::_duplicate (this->poa_.in ());
 }
diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.h b/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.h
index bc65208821d..eaa646cfb06 100644
--- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.h
+++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.h
@@ -30,29 +30,29 @@ public:
   ~Cubit_i (void);
 
   virtual CORBA::Octet cube_octet (CORBA::Octet o
-                                   TAO_ENV_ARG_DECL)
+                                   ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
   virtual CORBA::Short cube_short (CORBA::Short s
-                                   TAO_ENV_ARG_DECL)
+                                   ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
   virtual CORBA::Long cube_long (CORBA::Long l
-                                 TAO_ENV_ARG_DECL)
+                                 ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
   virtual Cubit::Many cube_struct (const Cubit::Many &values
-                                   TAO_ENV_ARG_DECL)
+                                   ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual void noop (TAO_ENV_SINGLE_ARG_DECL)
+  virtual void noop (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL)
+  virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
   virtual PortableServer::POA_ptr
-      _default_POA (TAO_ENV_SINGLE_ARG_DECL);
+      _default_POA (ACE_ENV_SINGLE_ARG_DECL);
   // The default POA
 
 protected:
diff --git a/TAO/performance-tests/DII_Latency/Roundtrip.cpp b/TAO/performance-tests/DII_Latency/Roundtrip.cpp
new file mode 100644
index 00000000000..df15cd65d8a
--- /dev/null
+++ b/TAO/performance-tests/DII_Latency/Roundtrip.cpp
@@ -0,0 +1,26 @@
+//
+// $Id$
+//
+#include "Roundtrip.h"
+
+ACE_RCSID(DII_Latency, Roundtrip, "$Id$")
+
+Roundtrip::Roundtrip (CORBA::ORB_ptr orb)
+  : orb_ (CORBA::ORB::_duplicate (orb))
+{
+}
+
+Test::Timestamp
+Roundtrip::test_method (Test::Timestamp send_time
+                        ACE_ENV_ARG_DECL_NOT_USED)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return send_time;
+}
+
+void
+Roundtrip::shutdown (ACE_ENV_SINGLE_ARG_DECL)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER);
+}
diff --git a/TAO/performance-tests/DII_Latency/Roundtrip.h b/TAO/performance-tests/DII_Latency/Roundtrip.h
new file mode 100644
index 00000000000..efef33dd7e6
--- /dev/null
+++ b/TAO/performance-tests/DII_Latency/Roundtrip.h
@@ -0,0 +1,46 @@
+//
+// $Id$
+//
+
+#ifndef ROUNDTRIP_H
+#define ROUNDTRIP_H
+#include "ace/pre.h"
+
+#include "TestS.h"
+
+#if defined (_MSC_VER)
+# if (_MSC_VER >= 1200)
+#  pragma warning(push)
+# endif /* _MSC_VER >= 1200 */
+# pragma warning (disable:4250)
+#endif /* _MSC_VER */
+
+/// Implement the Test::Roundtrip interface
+class Roundtrip
+  : public virtual POA_Test::Roundtrip
+  , public virtual PortableServer::RefCountServantBase
+{
+public:
+  /// Constructor
+  Roundtrip (CORBA::ORB_ptr orb);
+
+  // = The skeleton methods
+  virtual Test::Timestamp test_method (Test::Timestamp send_time
+                                       ACE_ENV_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+private:
+  /// Use an ORB reference to conver strings to objects and shutdown
+  /// the application.
+  CORBA::ORB_var orb_;
+};
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma warning(pop)
+#endif /* _MSC_VER */
+
+#include "ace/post.h"
+#endif /* ROUNDTRIP_H */
diff --git a/TAO/performance-tests/DII_Latency/client.cpp b/TAO/performance-tests/DII_Latency/client.cpp
new file mode 100644
index 00000000000..57935526269
--- /dev/null
+++ b/TAO/performance-tests/DII_Latency/client.cpp
@@ -0,0 +1,178 @@
+// $Id$
+
+#include "ace/Get_Opt.h"
+#include "ace/High_Res_Timer.h"
+#include "ace/Sched_Params.h"
+#include "ace/Stats.h"
+#include "ace/Sample_History.h"
+
+#include "tao/Strategies/advanced_resource.h"
+#include "tao/DynamicInterface/Request.h"
+
+ACE_RCSID(DII_Latency, client, "$Id$")
+
+const char *ior = "file://test.ior";
+int niterations = 100;
+int do_dump_history = 0;
+int do_shutdown = 1;
+
+int
+parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "hxk:i:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'h':
+        do_dump_history = 1;
+        break;
+
+      case 'x':
+        do_shutdown = 0;
+        break;
+
+      case 'k':
+        ior = get_opts.opt_arg ();
+        break;
+
+      case 'i':
+        niterations = ACE_OS::atoi (get_opts.opt_arg ());
+        break;
+
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-k <ior> "
+                           "-i <niterations> "
+                           "-x (disable shutdown) "
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int priority =
+    (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
+     + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
+  // 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,
+                      "client (%P|%t): user is not superuser, "
+                      "test runs in time-shared class\n"));
+        }
+      else
+        ACE_ERROR ((LM_ERROR,
+                    "client (%P|%t): sched_params failed\n"));
+    }
+
+  ACE_TRY_NEW_ENV
+    {
+      CORBA::ORB_var orb =
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (parse_args (argc, argv) != 0)
+        return 1;
+
+      CORBA::Object_var object =
+        orb->string_to_object (ior ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (CORBA::is_nil (object.in ()))
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "Nil CORBA::Object reference <%s>\n",
+                             ior),
+                            1);
+        }
+
+      for (int j = 0; j < 100; ++j)
+        {
+          CORBA::Request_var request =
+            object->_request ("test_method" ACE_ENV_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+
+          CORBA::ULongLong dummy = 0;
+          request->add_in_arg("send_time") <<= dummy;
+
+          request->set_return_type (CORBA::_tc_ulonglong);
+          request->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+        }
+
+      ACE_Sample_History history (niterations);
+
+      ACE_hrtime_t test_start = ACE_OS::gethrtime ();
+      for (int i = 0; i < niterations; ++i)
+        {
+          CORBA::ULongLong start = ACE_OS::gethrtime ();
+
+          CORBA::Request_var request =
+            object->_request ("test_method" ACE_ENV_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+
+          request->add_in_arg("send_time") <<= start;
+
+          request->set_return_type (CORBA::_tc_ulonglong);
+          request->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+
+          ACE_hrtime_t now = ACE_OS::gethrtime ();
+          history.sample (now - start);
+        }
+
+      ACE_hrtime_t test_end = ACE_OS::gethrtime ();
+
+      ACE_DEBUG ((LM_DEBUG, "test finished\n"));
+
+      ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
+      ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor ();
+      ACE_DEBUG ((LM_DEBUG, "done\n"));
+
+      if (do_dump_history)
+        {
+          history.dump_samples ("HISTORY", gsf);
+        }
+
+      ACE_Basic_Stats stats;
+      history.collect_basic_stats (stats);
+      stats.dump_results ("Total", gsf);
+
+      ACE_Throughput_Stats::dump_throughput ("Total", gsf,
+                                             test_end - test_start,
+                                             stats.samples_count ());
+
+      if (do_shutdown)
+        {
+          CORBA::Request_var request =
+            object->_request ("shutdown" ACE_ENV_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+
+          request->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+
+        }
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/performance-tests/DII_Latency/server.cpp b/TAO/performance-tests/DII_Latency/server.cpp
new file mode 100644
index 00000000000..e96f0ff595a
--- /dev/null
+++ b/TAO/performance-tests/DII_Latency/server.cpp
@@ -0,0 +1,136 @@
+// $Id$
+
+#include "Roundtrip.h"
+#include "ace/Get_Opt.h"
+#include "ace/Sched_Params.h"
+
+#include "tao/Strategies/advanced_resource.h"
+
+ACE_RCSID(Single_Threaded_Latency, server, "$Id$")
+
+const char *ior_output_file = "test.ior";
+
+int
+parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "o:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'o':
+        ior_output_file = get_opts.opt_arg ();
+        break;
+
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-o <iorfile>"
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  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_TRY_NEW_ENV
+    {
+      CORBA::ORB_var orb =
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::Object_var poa_object =
+        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (CORBA::is_nil (poa_object.in ()))
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           " (%P|%t) Unable to initialize the POA.\n"),
+                          1);
+
+      PortableServer::POA_var root_poa =
+        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      PortableServer::POAManager_var poa_manager =
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (parse_args (argc, argv) != 0)
+        return 1;
+
+      Roundtrip *roundtrip_impl;
+      ACE_NEW_RETURN (roundtrip_impl,
+                      Roundtrip (orb.in ()),
+                      1);
+      PortableServer::ServantBase_var owner_transfer(roundtrip_impl);
+
+      Test::Roundtrip_var roundtrip =
+        roundtrip_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::String_var ior =
+        orb->object_to_string (roundtrip.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      // If the ior_output_file exists, output the ior to it
+      FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
+      if (output_file == 0)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "Cannot open output file for writing IOR: %s",
+                           ior_output_file),
+                          1);
+      ACE_OS::fprintf (output_file, "%s", ior.in ());
+      ACE_OS::fclose (output_file);
+
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      orb->run (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
+
+      root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/performance-tests/DSI_Latency/Roundtrip.cpp b/TAO/performance-tests/DSI_Latency/Roundtrip.cpp
new file mode 100644
index 00000000000..6de5cfe047a
--- /dev/null
+++ b/TAO/performance-tests/DSI_Latency/Roundtrip.cpp
@@ -0,0 +1,97 @@
+//
+// $Id$
+//
+#include "Roundtrip.h"
+#include "tao/DynamicInterface/Server_Request.h"
+
+ACE_RCSID(Single_Threaded_Latency, Roundtrip, "$Id$")
+
+Roundtrip::Roundtrip (CORBA::ORB_ptr orb)
+  : orb_ (CORBA::ORB::_duplicate (orb))
+{
+}
+
+void
+Roundtrip::invoke (CORBA::ServerRequest_ptr request
+                   ACE_ENV_ARG_DECL)
+{
+  if (ACE_OS::strcmp ("shutdown", request->operation ()) == 0)
+    {
+      this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER);
+      ACE_CHECK;
+
+      return;
+    }
+
+  else if (ACE_OS::strcmp ("_is_a", request->operation ()) == 0)
+    {
+      CORBA::NVList_ptr list;
+      this->orb_->create_list (0, list ACE_ENV_ARG_PARAMETER);
+      ACE_CHECK;
+
+      CORBA::Any type_id (CORBA::_tc_string);
+      list->add_value ("type_id", type_id, CORBA::ARG_IN
+                       ACE_ENV_ARG_PARAMETER);
+      ACE_CHECK;
+
+      request->arguments (list ACE_ENV_ARG_PARAMETER);
+      ACE_CHECK;
+
+      CORBA::NamedValue_ptr nv = list->item (0 ACE_ENV_ARG_PARAMETER);
+      ACE_CHECK;
+
+      const char *arg;
+      *(nv->value ()) >>= arg;
+
+      CORBA::Boolean type_matches = 0;
+      if (ACE_OS::strcmp (arg, "IDL:Test/Roundtrip:1.0") == 0
+          || ACE_OS::strcmp (arg, "IDL:omg.org/CORBA/Object:1.0") == 0
+          || ACE_OS::strcmp (arg, "") == 0)
+        type_matches = 1;
+
+      CORBA::Any result;
+      result <<= CORBA::Any::from_boolean (type_matches);
+
+      request->set_result (result ACE_ENV_ARG_PARAMETER);
+      ACE_CHECK;
+
+      return;
+    }
+
+  else if (ACE_OS::strcmp ("test_method", request->operation ()) == 0)
+    {
+      CORBA::NVList_ptr list;
+      this->orb_->create_list (0, list ACE_ENV_ARG_PARAMETER);
+      ACE_CHECK;
+
+      CORBA::Any send_time (CORBA::_tc_ulonglong);
+      list->add_value ("send_time", send_time, CORBA::ARG_IN
+                       ACE_ENV_ARG_PARAMETER);
+      ACE_CHECK;
+
+      request->arguments (list ACE_ENV_ARG_PARAMETER);
+      ACE_CHECK;
+
+      CORBA::NamedValue_ptr nv = list->item (0 ACE_ENV_ARG_PARAMETER);
+      ACE_CHECK;
+
+      request->set_result (*(nv->value ()) ACE_ENV_ARG_PARAMETER);
+      ACE_CHECK;
+
+      return;
+    }
+
+  CORBA::Any bad_operation;
+  CORBA::BAD_OPERATION exception;
+  bad_operation <<= exception;
+  request->set_exception (bad_operation ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+}
+
+CORBA::RepositoryId
+Roundtrip::_primary_interface (const PortableServer::ObjectId &,
+                               PortableServer::POA_ptr
+                               ACE_ENV_ARG_DECL_NOT_USED)
+{
+  return CORBA::string_dup ("IDL:Test/Roundtrip:1.0");
+}
diff --git a/TAO/performance-tests/DSI_Latency/Roundtrip.h b/TAO/performance-tests/DSI_Latency/Roundtrip.h
new file mode 100644
index 00000000000..d795dcb56f1
--- /dev/null
+++ b/TAO/performance-tests/DSI_Latency/Roundtrip.h
@@ -0,0 +1,48 @@
+//
+// $Id$
+//
+
+#ifndef ROUNDTRIP_H
+#define ROUNDTRIP_H
+#include "ace/pre.h"
+
+#include "tao/DynamicInterface/Dynamic_Implementation.h"
+#include "tao/PortableServer/PortableServer.h"
+#include "tao/corba.h"
+
+#if defined (_MSC_VER)
+# if (_MSC_VER >= 1200)
+#  pragma warning(push)
+# endif /* _MSC_VER >= 1200 */
+# pragma warning (disable:4250)
+#endif /* _MSC_VER */
+
+/// Implement the Test::Roundtrip interface
+class Roundtrip
+  : public virtual PortableServer::DynamicImplementation
+  , public virtual PortableServer::RefCountServantBase
+{
+public:
+  /// Constructor
+  Roundtrip (CORBA::ORB_ptr orb);
+
+  // = The DSI methods
+  virtual void invoke (CORBA::ServerRequest_ptr request
+                       ACE_ENV_ARG_DECL);
+  virtual CORBA::RepositoryId _primary_interface (
+      const PortableServer::ObjectId &oid,
+      PortableServer::POA_ptr poa
+      ACE_ENV_ARG_DECL);
+
+private:
+  /// Use an ORB reference to conver strings to objects and shutdown
+  /// the application.
+  CORBA::ORB_var orb_;
+};
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma warning(pop)
+#endif /* _MSC_VER */
+
+#include "ace/post.h"
+#endif /* ROUNDTRIP_H */
diff --git a/TAO/performance-tests/DSI_Latency/client.cpp b/TAO/performance-tests/DSI_Latency/client.cpp
new file mode 100644
index 00000000000..2a264e91b43
--- /dev/null
+++ b/TAO/performance-tests/DSI_Latency/client.cpp
@@ -0,0 +1,163 @@
+// $Id$
+
+#include "TestC.h"
+#include "ace/Get_Opt.h"
+#include "ace/High_Res_Timer.h"
+#include "ace/Sched_Params.h"
+#include "ace/Stats.h"
+#include "ace/Sample_History.h"
+
+#include "tao/Strategies/advanced_resource.h"
+
+ACE_RCSID(DSI_Latency, client, "$Id$")
+
+const char *ior = "file://test.ior";
+int niterations = 100;
+int do_dump_history = 0;
+int do_shutdown = 1;
+
+int
+parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "hxk:i:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'h':
+        do_dump_history = 1;
+        break;
+
+      case 'x':
+        do_shutdown = 0;
+        break;
+
+      case 'k':
+        ior = get_opts.opt_arg ();
+        break;
+
+      case 'i':
+        niterations = ACE_OS::atoi (get_opts.opt_arg ());
+        break;
+
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-k <ior> "
+                           "-i <niterations> "
+                           "-x (disable shutdown) "
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int priority =
+    (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
+     + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
+  // 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,
+                      "client (%P|%t): user is not superuser, "
+                      "test runs in time-shared class\n"));
+        }
+      else
+        ACE_ERROR ((LM_ERROR,
+                    "client (%P|%t): sched_params failed\n"));
+    }
+
+  ACE_TRY_NEW_ENV
+    {
+      CORBA::ORB_var orb =
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (parse_args (argc, argv) != 0)
+        return 1;
+
+      CORBA::Object_var object =
+        orb->string_to_object (ior ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      Test::Roundtrip_var roundtrip =
+        Test::Roundtrip::_narrow (object.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (CORBA::is_nil (roundtrip.in ()))
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "Nil Test::Roundtrip reference <%s>\n",
+                             ior),
+                            1);
+        }
+
+      for (int j = 0; j < 100; ++j)
+        {
+          ACE_hrtime_t start = 0;
+          (void) roundtrip->test_method (start ACE_ENV_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+        }
+
+      ACE_Sample_History history (niterations);
+
+      ACE_hrtime_t test_start = ACE_OS::gethrtime ();
+      for (int i = 0; i < niterations; ++i)
+        {
+          ACE_hrtime_t start = ACE_OS::gethrtime ();
+
+          (void) roundtrip->test_method (start ACE_ENV_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+
+          ACE_hrtime_t now = ACE_OS::gethrtime ();
+          history.sample (now - start);
+        }
+
+      ACE_hrtime_t test_end = ACE_OS::gethrtime ();
+
+      ACE_DEBUG ((LM_DEBUG, "test finished\n"));
+
+      ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
+      ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor ();
+      ACE_DEBUG ((LM_DEBUG, "done\n"));
+
+      if (do_dump_history)
+        {
+          history.dump_samples ("HISTORY", gsf);
+        }
+
+      ACE_Basic_Stats stats;
+      history.collect_basic_stats (stats);
+      stats.dump_results ("Total", gsf);
+
+      ACE_Throughput_Stats::dump_throughput ("Total", gsf,
+                                             test_end - test_start,
+                                             stats.samples_count ());
+
+      if (do_shutdown)
+        {
+          roundtrip->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+        }
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/performance-tests/DSI_Latency/server.cpp b/TAO/performance-tests/DSI_Latency/server.cpp
new file mode 100644
index 00000000000..ebc70ade1d7
--- /dev/null
+++ b/TAO/performance-tests/DSI_Latency/server.cpp
@@ -0,0 +1,142 @@
+// $Id$
+
+#include "Roundtrip.h"
+#include "ace/Get_Opt.h"
+#include "ace/Sched_Params.h"
+
+#include "tao/Strategies/advanced_resource.h"
+
+ACE_RCSID(DSI_Latency, server, "$Id$")
+
+const char *ior_output_file = "test.ior";
+
+int
+parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "o:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'o':
+        ior_output_file = get_opts.opt_arg ();
+        break;
+
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-o <iorfile>"
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  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_TRY_NEW_ENV
+    {
+      CORBA::ORB_var orb =
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::Object_var poa_object =
+        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (CORBA::is_nil (poa_object.in ()))
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           " (%P|%t) Unable to initialize the POA.\n"),
+                          1);
+
+      PortableServer::POA_var root_poa =
+        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      PortableServer::POAManager_var poa_manager =
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (parse_args (argc, argv) != 0)
+        return 1;
+
+      Roundtrip *roundtrip_impl;
+      ACE_NEW_RETURN (roundtrip_impl,
+                      Roundtrip (orb.in ()),
+                      1);
+      PortableServer::ServantBase_var owner_transfer(roundtrip_impl);
+
+      PortableServer::ObjectId_var oid =
+        root_poa->activate_object (roundtrip_impl
+                                   ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::Object_var roundtrip =
+        root_poa->id_to_reference (oid.in ()
+                                   ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::String_var ior =
+        orb->object_to_string (roundtrip.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      // If the ior_output_file exists, output the ior to it
+      FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
+      if (output_file == 0)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "Cannot open output file for writing IOR: %s",
+                           ior_output_file),
+                          1);
+      ACE_OS::fprintf (output_file, "%s", ior.in ());
+      ACE_OS::fclose (output_file);
+
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      orb->run (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
+
+      root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/performance-tests/Deferred_Latency/Roundtrip.cpp b/TAO/performance-tests/Deferred_Latency/Roundtrip.cpp
new file mode 100644
index 00000000000..72f83576b44
--- /dev/null
+++ b/TAO/performance-tests/Deferred_Latency/Roundtrip.cpp
@@ -0,0 +1,26 @@
+//
+// $Id$
+//
+#include "Roundtrip.h"
+
+ACE_RCSID(Single_Threaded_Latency, Roundtrip, "$Id$")
+
+Roundtrip::Roundtrip (CORBA::ORB_ptr orb)
+  : orb_ (CORBA::ORB::_duplicate (orb))
+{
+}
+
+Test::Timestamp
+Roundtrip::test_method (Test::Timestamp send_time
+                        ACE_ENV_ARG_DECL_NOT_USED)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return send_time;
+}
+
+void
+Roundtrip::shutdown (ACE_ENV_SINGLE_ARG_DECL)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER);
+}
diff --git a/TAO/performance-tests/Deferred_Latency/Roundtrip.h b/TAO/performance-tests/Deferred_Latency/Roundtrip.h
new file mode 100644
index 00000000000..efef33dd7e6
--- /dev/null
+++ b/TAO/performance-tests/Deferred_Latency/Roundtrip.h
@@ -0,0 +1,46 @@
+//
+// $Id$
+//
+
+#ifndef ROUNDTRIP_H
+#define ROUNDTRIP_H
+#include "ace/pre.h"
+
+#include "TestS.h"
+
+#if defined (_MSC_VER)
+# if (_MSC_VER >= 1200)
+#  pragma warning(push)
+# endif /* _MSC_VER >= 1200 */
+# pragma warning (disable:4250)
+#endif /* _MSC_VER */
+
+/// Implement the Test::Roundtrip interface
+class Roundtrip
+  : public virtual POA_Test::Roundtrip
+  , public virtual PortableServer::RefCountServantBase
+{
+public:
+  /// Constructor
+  Roundtrip (CORBA::ORB_ptr orb);
+
+  // = The skeleton methods
+  virtual Test::Timestamp test_method (Test::Timestamp send_time
+                                       ACE_ENV_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+private:
+  /// Use an ORB reference to conver strings to objects and shutdown
+  /// the application.
+  CORBA::ORB_var orb_;
+};
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma warning(pop)
+#endif /* _MSC_VER */
+
+#include "ace/post.h"
+#endif /* ROUNDTRIP_H */
diff --git a/TAO/performance-tests/Deferred_Latency/client.cpp b/TAO/performance-tests/Deferred_Latency/client.cpp
new file mode 100644
index 00000000000..8aa94d94172
--- /dev/null
+++ b/TAO/performance-tests/Deferred_Latency/client.cpp
@@ -0,0 +1,203 @@
+// $Id$
+
+#include "TestC.h"
+
+#include "tao/DynamicInterface/Request.h"
+
+#include "tao/Strategies/advanced_resource.h"
+
+#include "ace/Get_Opt.h"
+#include "ace/Sched_Params.h"
+#include "ace/High_Res_Timer.h"
+#include "ace/Sched_Params.h"
+#include "ace/Stats.h"
+#include "ace/Sample_History.h"
+
+ACE_RCSID(Deferred_Latency, client, "$Id$")
+
+const char *ior = "file://test.ior";
+int niterations = 1000;
+int burst = 10;
+int do_shutdown = 1;
+int do_dump_history = 0;
+
+int
+parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "hxk:i:b:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'h':
+        do_dump_history = 1;
+        break;
+
+      case 'x':
+        do_shutdown = 0;
+        break;
+
+      case 'k':
+        ior = get_opts.opt_arg ();
+        break;
+
+      case 'i':
+        niterations = ACE_OS::atoi (get_opts.opt_arg ());
+        break;
+
+      case 'b':
+        burst = ACE_OS::atoi (get_opts.opt_arg ());
+        break;
+
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-k <ior> "
+                           "-i <niterations> "
+                           "-b <burst> "
+                           "-x (disable shutdown) "
+                           "-h (dump history) "
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int priority =
+    (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
+     + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
+  // 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,
+                      "client (%P|%t): user is not superuser, "
+                      "test runs in time-shared class\n"));
+        }
+      else
+        ACE_ERROR ((LM_ERROR,
+                    "client (%P|%t): sched_params failed\n"));
+    }
+
+  ACE_TRY_NEW_ENV
+    {
+      CORBA::ORB_var orb =
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (parse_args (argc, argv) != 0)
+        return 1;
+
+      CORBA::Object_var object =
+        orb->string_to_object (ior ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      Test::Roundtrip_var roundtrip =
+        Test::Roundtrip::_narrow (object.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (CORBA::is_nil (roundtrip.in ()))
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "Nil Test::Roundtrip reference <%s>\n",
+                             ior),
+                            1);
+        }
+
+      for (int j = 0; j < 100; ++j)
+        {
+          ACE_hrtime_t start = 0;
+          (void) roundtrip->test_method (start ACE_ENV_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+        }
+
+      ACE_Sample_History history (niterations);
+
+      ACE_hrtime_t test_start = ACE_OS::gethrtime ();
+
+      CORBA::Request_var *request;
+      ACE_NEW_RETURN (request, CORBA::Request_var[burst], 1);
+
+      for (int i = 0; i < niterations; ++i)
+        {
+          int j;
+
+          for (j = 0; j != burst; ++j)
+            {
+              CORBA::ULongLong start = ACE_OS::gethrtime ();
+
+              request[j] =
+                roundtrip->_request ("test_method"
+                                     ACE_ENV_ARG_PARAMETER);
+              ACE_TRY_CHECK;
+
+              request[j]->add_in_arg () <<= start;
+              request[j]->set_return_type (CORBA::_tc_ulonglong);
+
+              request[j]->send_deferred (ACE_ENV_SINGLE_ARG_PARAMETER);
+              ACE_TRY_CHECK;
+            }
+
+          for (j = 0; j != burst; ++j)
+            {
+              request[j]->get_response (ACE_ENV_SINGLE_ARG_PARAMETER);
+              ACE_TRY_CHECK;
+
+              CORBA::ULongLong retval;
+              if ((request[j]->return_value () >>= retval) == 1)
+                {
+                  ACE_hrtime_t now = ACE_OS::gethrtime ();
+                  history.sample (now - retval);
+                }
+            }
+        }
+      delete[] request;
+
+      ACE_hrtime_t test_end = ACE_OS::gethrtime ();
+
+      ACE_DEBUG ((LM_DEBUG, "test finished\n"));
+
+      ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
+      ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor ();
+      ACE_DEBUG ((LM_DEBUG, "done\n"));
+
+      if (do_dump_history)
+        {
+          history.dump_samples ("HISTORY", gsf);
+        }
+
+      ACE_Basic_Stats stats;
+      history.collect_basic_stats (stats);
+      stats.dump_results ("Total", gsf);
+
+      ACE_Throughput_Stats::dump_throughput ("Total", gsf,
+                                             test_end - test_start,
+                                             stats.samples_count ());
+
+      if (do_shutdown)
+        {
+          roundtrip->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+        }
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
+                           "Caught exception:");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/performance-tests/Deferred_Latency/server.cpp b/TAO/performance-tests/Deferred_Latency/server.cpp
new file mode 100644
index 00000000000..e96f0ff595a
--- /dev/null
+++ b/TAO/performance-tests/Deferred_Latency/server.cpp
@@ -0,0 +1,136 @@
+// $Id$
+
+#include "Roundtrip.h"
+#include "ace/Get_Opt.h"
+#include "ace/Sched_Params.h"
+
+#include "tao/Strategies/advanced_resource.h"
+
+ACE_RCSID(Single_Threaded_Latency, server, "$Id$")
+
+const char *ior_output_file = "test.ior";
+
+int
+parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "o:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'o':
+        ior_output_file = get_opts.opt_arg ();
+        break;
+
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-o <iorfile>"
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  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_TRY_NEW_ENV
+    {
+      CORBA::ORB_var orb =
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::Object_var poa_object =
+        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (CORBA::is_nil (poa_object.in ()))
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           " (%P|%t) Unable to initialize the POA.\n"),
+                          1);
+
+      PortableServer::POA_var root_poa =
+        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      PortableServer::POAManager_var poa_manager =
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (parse_args (argc, argv) != 0)
+        return 1;
+
+      Roundtrip *roundtrip_impl;
+      ACE_NEW_RETURN (roundtrip_impl,
+                      Roundtrip (orb.in ()),
+                      1);
+      PortableServer::ServantBase_var owner_transfer(roundtrip_impl);
+
+      Test::Roundtrip_var roundtrip =
+        roundtrip_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::String_var ior =
+        orb->object_to_string (roundtrip.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      // If the ior_output_file exists, output the ior to it
+      FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
+      if (output_file == 0)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "Cannot open output file for writing IOR: %s",
+                           ior_output_file),
+                          1);
+      ACE_OS::fprintf (output_file, "%s", ior.in ());
+      ACE_OS::fclose (output_file);
+
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      orb->run (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
+
+      root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/performance-tests/POA/Create_Reference/create_reference.cpp b/TAO/performance-tests/POA/Create_Reference/create_reference.cpp
index 286b7d6282c..e26b101e25e 100644
--- a/TAO/performance-tests/POA/Create_Reference/create_reference.cpp
+++ b/TAO/performance-tests/POA/Create_Reference/create_reference.cpp
@@ -75,7 +75,7 @@ set_rt_scheduling (void)
 void
 object_creation_test (PortableServer::POA_ptr poa,
                       int create_reference_with_id
-                      TAO_ENV_ARG_DECL)
+                      ACE_ENV_ARG_DECL)
 {
   ACE_DEBUG ((LM_DEBUG,
               "\nCreating %d object references with %s\n",
@@ -102,14 +102,14 @@ object_creation_test (PortableServer::POA_ptr poa,
           object =
             poa->create_reference_with_id (oid.in (),
                                            "IDL:Test/Simple:1.0"
-                                           TAO_ENV_ARG_PARAMETER);
+                                           ACE_ENV_ARG_PARAMETER);
           ACE_CHECK;
         }
       else
         {
           object =
             poa->create_reference ("IDL:Test/Simple:1.0"
-                                   TAO_ENV_ARG_PARAMETER);
+                                   ACE_ENV_ARG_PARAMETER);
           ACE_CHECK;
         }
 
@@ -136,12 +136,12 @@ main (int argc, char *argv[])
     {
       CORBA::ORB_var orb =
         CORBA::ORB_init (argc, argv, ""
-                         TAO_ENV_ARG_PARAMETER);
+                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::Object_var poa_object =
         orb->resolve_initial_references ("RootPOA"
-                                         TAO_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (poa_object.in ()))
@@ -151,14 +151,14 @@ main (int argc, char *argv[])
 
       PortableServer::POA_var root_poa =
         PortableServer::POA::_narrow (poa_object.in ()
-                                      TAO_ENV_ARG_PARAMETER);
+                                      ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POAManager_var poa_manager =
-        root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER);
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER);
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (parse_args (argc, argv) != 0)
@@ -168,32 +168,32 @@ main (int argc, char *argv[])
 
       policies[0] =
         root_poa->create_id_assignment_policy (PortableServer::USER_ID
-                                               TAO_ENV_ARG_PARAMETER);
+                                               ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POA_var child_poa =
         root_poa->create_POA ("TestPOA",
                               poa_manager.in (),
                               policies
-                              TAO_ENV_ARG_PARAMETER);
+                              ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       gsf = ACE_High_Res_Timer::global_scale_factor ();
 
       object_creation_test (root_poa.in (),
                             0  // POA::create_reference
-                            TAO_ENV_ARG_PARAMETER);
+                            ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       object_creation_test (child_poa.in (),
                             1  // POA::create_reference_with_id
-                            TAO_ENV_ARG_PARAMETER);
+                            ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER);
+      root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
diff --git a/TAO/performance-tests/POA/Demux/client.cpp b/TAO/performance-tests/POA/Demux/client.cpp
index 22f2bd9048f..9a013dadf0b 100644
--- a/TAO/performance-tests/POA/Demux/client.cpp
+++ b/TAO/performance-tests/POA/Demux/client.cpp
@@ -34,12 +34,12 @@ main (int argc, char *argv [])
   ACE_TRY_NEW_ENV;
     {
       int r = demux_test_client.init (argc, argv
-                                      TAO_ENV_ARG_PARAMETER);
+                                      ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
       if (r == -1)
         return -1;
 
-      demux_test_client.run (TAO_ENV_SINGLE_ARG_PARAMETER);
+      demux_test_client.run (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCH (CORBA::SystemException, sysex)
diff --git a/TAO/performance-tests/POA/Demux/demux_test_client.cpp b/TAO/performance-tests/POA/Demux/demux_test_client.cpp
index a11e1675aea..5ff3035ce57 100644
--- a/TAO/performance-tests/POA/Demux/demux_test_client.cpp
+++ b/TAO/performance-tests/POA/Demux/demux_test_client.cpp
@@ -45,7 +45,7 @@ Demux_Test_Client::~Demux_Test_Client (void)
 
 int
 Demux_Test_Client::init (int argc, char *argv []
-                         TAO_ENV_ARG_DECL)
+                         ACE_ENV_ARG_DECL)
 {
   this->argc_ = argc;
   this->argv_ = argv;
@@ -55,7 +55,7 @@ Demux_Test_Client::init (int argc, char *argv []
     {
       // get the underlying ORB
       this->orb_ =
-        CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER);
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK_EX (GET_ORB);
     }
   ACE_CATCHANY
@@ -102,13 +102,13 @@ Demux_Test_Client::init (int argc, char *argv []
         ACE_TRY_EX (IOR)
           {
             CORBA::Object_var objref = this->orb_->string_to_object (str
-                                                                     TAO_ENV_ARG_PARAMETER);
+                                                                     ACE_ENV_ARG_PARAMETER);
             ACE_TRY_CHECK_EX (IOR);
 
             // now narrow to Demux_Test object
 
             this->demux_test_[i][j] = Demux_Test::_narrow (objref.in ()
-                                                           TAO_ENV_ARG_PARAMETER);
+                                                           ACE_ENV_ARG_PARAMETER);
 
             ACE_TRY_CHECK_EX (IOR);
 
@@ -252,7 +252,7 @@ Demux_Test_Client::parse_args (void)
 
 // The main program for Demux_Test
 int
-Demux_Test_Client::run (TAO_ENV_SINGLE_ARG_DECL)
+Demux_Test_Client::run (ACE_ENV_SINGLE_ARG_DECL)
 {
   // open a temporary results file
   if ((this->result_fp_ = ACE_OS::fopen ("results.dat", "w")) == 0)
@@ -267,19 +267,19 @@ Demux_Test_Client::run (TAO_ENV_SINGLE_ARG_DECL)
       switch (this->is_)
         {
         case Demux_Test_Client::LINEAR:
-          (void) this->run_linear_test (TAO_ENV_SINGLE_ARG_PARAMETER);
+          (void) this->run_linear_test (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK_EX (RUN);
           break;
         case Demux_Test_Client::RANDOM:
-          (void) this->run_random_test (TAO_ENV_SINGLE_ARG_PARAMETER);
+          (void) this->run_random_test (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK_EX (RUN);
           break;
         case Demux_Test_Client::BEST:
-          (void) this->run_best_test (TAO_ENV_SINGLE_ARG_PARAMETER);
+          (void) this->run_best_test (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK_EX (RUN);
           break;
         case Demux_Test_Client::WORST:
-          (void) this->run_worst_test (TAO_ENV_SINGLE_ARG_PARAMETER);
+          (void) this->run_worst_test (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK_EX (RUN);
           break;
         }
@@ -301,7 +301,7 @@ Demux_Test_Client::run (TAO_ENV_SINGLE_ARG_DECL)
   ACE_TRY_EX (SHUTDOWN)
     {
       // call the shutdown method one the first object
-      this->demux_test_[0][0]->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
+      this->demux_test_[0][0]->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK_EX (SHUTDOWN);
     }
   ACE_CATCHANY
@@ -329,7 +329,7 @@ Demux_Test_Client::run (TAO_ENV_SINGLE_ARG_DECL)
 }
 
 int
-Demux_Test_Client::run_linear_test (TAO_ENV_SINGLE_ARG_DECL)
+Demux_Test_Client::run_linear_test (ACE_ENV_SINGLE_ARG_DECL)
 {
   CORBA::ULong j, k, l, m;
   ACE_hrtime_t start, end;
@@ -342,7 +342,7 @@ Demux_Test_Client::run_linear_test (TAO_ENV_SINGLE_ARG_DECL)
             start = ACE_OS::gethrtime ();
 
             // invoke the method
-            this->op_db_[l].op_ (this->demux_test_[j][k].in () TAO_ENV_ARG_PARAMETER);
+            this->op_db_[l].op_ (this->demux_test_[j][k].in () ACE_ENV_ARG_PARAMETER);
 
             end = ACE_OS::gethrtime ();
 
@@ -355,7 +355,7 @@ Demux_Test_Client::run_linear_test (TAO_ENV_SINGLE_ARG_DECL)
 }
 
 int
-Demux_Test_Client::run_random_test (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+Demux_Test_Client::run_random_test (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
   ACE_DEBUG ((LM_DEBUG,
               "ERROR : Random test\n"));
@@ -363,7 +363,7 @@ Demux_Test_Client::run_random_test (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
 }
 
 int
-Demux_Test_Client::run_best_test (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+Demux_Test_Client::run_best_test (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
   ACE_DEBUG ((LM_DEBUG,
               "ERROR : Best Test\n"));
@@ -371,7 +371,7 @@ Demux_Test_Client::run_best_test (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
 }
 
 int
-Demux_Test_Client::run_worst_test (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+Demux_Test_Client::run_worst_test (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
   ACE_DEBUG ((LM_DEBUG,
               "ERROR : Worst test\n"));
diff --git a/TAO/performance-tests/POA/Demux/demux_test_client.h b/TAO/performance-tests/POA/Demux/demux_test_client.h
index a6ed4afce27..7b0a3714f32 100644
--- a/TAO/performance-tests/POA/Demux/demux_test_client.h
+++ b/TAO/performance-tests/POA/Demux/demux_test_client.h
@@ -38,7 +38,7 @@ public:
     WORST
   };
 
-  typedef void (*OP_PTR) (Demux_Test_ptr TAO_ENV_ARG_DECL_NOT_USED);
+  typedef void (*OP_PTR) (Demux_Test_ptr ACE_ENV_ARG_DECL_NOT_USED);
 
   struct Operation_DB_Entry
   {
@@ -51,10 +51,10 @@ public:
   ~Demux_Test_Client (void);
   // DTOR
 
-  int init (int argc, char *argv [] TAO_ENV_ARG_DECL_WITH_DEFAULTS);
+  int init (int argc, char *argv [] ACE_ENV_ARG_DECL_WITH_DEFAULTS);
   // initialize the client test bed
 
-  int run (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+  int run (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
   // run the tests
 
 private:
@@ -65,16 +65,16 @@ private:
   int init_operation_db (void);
   // initialize the operation database
 
-  int run_linear_test (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+  int run_linear_test (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
   // run linear strategy
 
-  int run_random_test (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+  int run_random_test (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
   // run random strategy
 
-  int run_best_test (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+  int run_best_test (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
   // run best strategy (w.r.t to linear)
 
-  int run_worst_test (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+  int run_worst_test (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
   // run worst strategy (w.r.t to linear)
 
   int print_results (void);
diff --git a/TAO/performance-tests/POA/Demux/demux_test_client.i b/TAO/performance-tests/POA/Demux/demux_test_client.i
index 9a113cb2f85..0d2081ee78c 100644
--- a/TAO/performance-tests/POA/Demux/demux_test_client.i
+++ b/TAO/performance-tests/POA/Demux/demux_test_client.i
@@ -1,14 +1,14 @@
 //$Id$
 static void M302 (Demux_Test_ptr objref
-                  TAO_ENV_ARG_DECL)
+                  ACE_ENV_ARG_DECL)
 {
-  objref->M302 (TAO_ENV_SINGLE_ARG_PARAMETER);
+  objref->M302 (ACE_ENV_SINGLE_ARG_PARAMETER);
 }
 
 static void shutdown (Demux_Test_ptr objref
-                      TAO_ENV_ARG_DECL)
+                      ACE_ENV_ARG_DECL)
 {
-  objref->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
+  objref->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
 }
 
 int Demux_Test_Client::init_operation_db (void)
diff --git a/TAO/performance-tests/POA/Demux/demux_test_i.cpp b/TAO/performance-tests/POA/Demux/demux_test_i.cpp
index d20766f2711..c8810c36650 100644
--- a/TAO/performance-tests/POA/Demux/demux_test_i.cpp
+++ b/TAO/performance-tests/POA/Demux/demux_test_i.cpp
@@ -12,12 +12,12 @@ Demux_Test_i::Demux_Test_i (void)
 Demux_Test_i::~Demux_Test_i (void)
 {}
 
-void Demux_Test_i::M302 (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+void Demux_Test_i::M302 (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
 }
 
-void Demux_Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+void Demux_Test_i::shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   TAO_ORB_Core_instance ()->orb ()->shutdown ();
diff --git a/TAO/performance-tests/POA/Demux/demux_test_i.h b/TAO/performance-tests/POA/Demux/demux_test_i.h
index ffa9d017ec2..6d302340364 100644
--- a/TAO/performance-tests/POA/Demux/demux_test_i.h
+++ b/TAO/performance-tests/POA/Demux/demux_test_i.h
@@ -24,15 +24,15 @@ public:
   // dtor
 
   // Return the Default POA of this Servant
-  PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED/*env*/)
+  PortableServer::POA_ptr _default_POA (ACE_ENV_SINGLE_ARG_DECL_NOT_USED/*env*/)
     {
       return PortableServer::POA::_duplicate (this->poa_.in ());
     };
 
-  virtual void M302 (TAO_ENV_SINGLE_ARG_DECL)
+  virtual void M302 (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL)
+  virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
 private:
diff --git a/TAO/performance-tests/POA/Demux/demux_test_server.cpp b/TAO/performance-tests/POA/Demux/demux_test_server.cpp
index ec61f957ee0..52c2607319b 100644
--- a/TAO/performance-tests/POA/Demux/demux_test_server.cpp
+++ b/TAO/performance-tests/POA/Demux/demux_test_server.cpp
@@ -46,7 +46,7 @@ Demux_Test_Server::~Demux_Test_Server (void)
 
 int
 Demux_Test_Server::init (int argc, char *argv []
-                         TAO_ENV_ARG_DECL)
+                         ACE_ENV_ARG_DECL)
 {
   printf ("here\n");
 
@@ -58,7 +58,7 @@ Demux_Test_Server::init (int argc, char *argv []
     {
       // get the underlying ORB
       this->orb_ =
-        CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER);
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK_EX(GET_ORB);
     }
   ACE_CATCHANY
@@ -78,7 +78,7 @@ Demux_Test_Server::init (int argc, char *argv []
 
       temp =
         this->orb_->resolve_initial_references ("RootPOA"
-                                                TAO_ENV_ARG_PARAMETER);
+                                                ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK_EX(GET_ROOT_POA);
       if (CORBA::is_nil (temp.in ()))
         ACE_ERROR_RETURN ((LM_ERROR,
@@ -87,7 +87,7 @@ Demux_Test_Server::init (int argc, char *argv []
 
       this->root_poa_ =
         PortableServer::POA::_narrow (temp.in ()
-                                      TAO_ENV_ARG_PARAMETER);
+                                      ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK_EX (GET_ROOT_POA);
     }
   ACE_CATCHANY
@@ -104,7 +104,7 @@ Demux_Test_Server::init (int argc, char *argv []
     {
 
       this->poa_mgr_ =
-        this->root_poa_->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER);
+        this->root_poa_->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK_EX (GET_POA_MGR);
     }
   ACE_CATCHANY
@@ -147,7 +147,7 @@ Demux_Test_Server::init (int argc, char *argv []
 
           policies[0] =
             this->root_poa_->create_id_assignment_policy (PortableServer::USER_ID
-                                                          TAO_ENV_ARG_PARAMETER);
+                                                          ACE_ENV_ARG_PARAMETER);
         }
       else
         {
@@ -156,7 +156,7 @@ Demux_Test_Server::init (int argc, char *argv []
 
           policies[0] =
             this->root_poa_->create_id_assignment_policy (PortableServer::SYSTEM_ID
-                                                          TAO_ENV_ARG_PARAMETER);
+                                                          ACE_ENV_ARG_PARAMETER);
         }
 
       ACE_TRY_CHECK_EX (POLICY);
@@ -169,7 +169,7 @@ Demux_Test_Server::init (int argc, char *argv []
 
           policies[1] =
             this->root_poa_->create_lifespan_policy (PortableServer::TRANSIENT
-                                                     TAO_ENV_ARG_PARAMETER);
+                                                     ACE_ENV_ARG_PARAMETER);
         }
       else
         {
@@ -178,7 +178,7 @@ Demux_Test_Server::init (int argc, char *argv []
 
           policies[1] =
             this->root_poa_->create_lifespan_policy (PortableServer::PERSISTENT
-                                                     TAO_ENV_ARG_PARAMETER);
+                                                     ACE_ENV_ARG_PARAMETER);
         }
 
       ACE_TRY_CHECK_EX (POLICY);
@@ -230,7 +230,7 @@ Demux_Test_Server::init (int argc, char *argv []
           this->child_poa_[i] = prev_poa->create_POA (poa_name,
                                                       this->poa_mgr_.in (),
                                                       policies
-                                                      TAO_ENV_ARG_PARAMETER);
+                                                      ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK_EX (CREATE_POA);
         }
       ACE_CATCHANY
@@ -258,7 +258,7 @@ Demux_Test_Server::init (int argc, char *argv []
 
                   //id = this->child_poa_[i]->activate_object (&this->demux_test_[j],
                   id = this->child_poa_[i]->activate_object (demux_test_i_ptr
-                                                             TAO_ENV_ARG_PARAMETER);
+                                                             ACE_ENV_ARG_PARAMETER);
                   ACE_TRY_CHECK_EX (ACTIVATE_OBJ);
                 }
               ACE_CATCHANY
@@ -274,11 +274,11 @@ Demux_Test_Server::init (int argc, char *argv []
               ACE_TRY_EX (IOR)
                 {
                   CORBA::Object_var demux_var = this->child_poa_[i]->id_to_reference (id.in ()
-                                                                                      TAO_ENV_ARG_PARAMETER);
+                                                                                      ACE_ENV_ARG_PARAMETER);
                   ACE_TRY_CHECK_EX (IOR);
 
                   CORBA::String_var ior = this->orb_->object_to_string
-                    (demux_var.in () TAO_ENV_ARG_PARAMETER);
+                    (demux_var.in () ACE_ENV_ARG_PARAMETER);
 
                   ACE_TRY_CHECK_EX (IOR);
 
@@ -319,16 +319,16 @@ Demux_Test_Server::init (int argc, char *argv []
 
                   this->child_poa_[i]->activate_object_with_id (oid.in (),
                                                                 demux_test_i_ptr
-                                                                TAO_ENV_ARG_PARAMETER);
+                                                                ACE_ENV_ARG_PARAMETER);
                   ACE_TRY_CHECK;
 
                   // Get Object reference for demux_test_i impl object.
-                  CORBA::Object_var demux_var = demux_test_i_ptr->_this (TAO_ENV_SINGLE_ARG_PARAMETER);
+                  CORBA::Object_var demux_var = demux_test_i_ptr->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
 
                   ACE_TRY_CHECK;
 
                   CORBA::String_var ior = this->orb_->object_to_string
-                    (demux_var.in () TAO_ENV_ARG_PARAMETER);
+                    (demux_var.in () ACE_ENV_ARG_PARAMETER);
 
                   ACE_TRY_CHECK;
 
@@ -359,7 +359,7 @@ Demux_Test_Server::init (int argc, char *argv []
 
   ACE_TRY_EX (ACTIVATE)
     {
-      this->poa_mgr_->activate (TAO_ENV_SINGLE_ARG_PARAMETER);
+      this->poa_mgr_->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
 
       ACE_TRY_CHECK_EX (ACTIVATE);
     }
@@ -468,11 +468,11 @@ Demux_Test_Server::init_naming_service (void)
 
 // The main program for Demux_Test
 int
-Demux_Test_Server::run (TAO_ENV_SINGLE_ARG_DECL)
+Demux_Test_Server::run (ACE_ENV_SINGLE_ARG_DECL)
 {
   ACE_TRY
     {
-      this->orb_->run (TAO_ENV_SINGLE_ARG_PARAMETER);
+      this->orb_->run (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
diff --git a/TAO/performance-tests/POA/Demux/demux_test_server.h b/TAO/performance-tests/POA/Demux/demux_test_server.h
index b0cc927ed31..588119e4e98 100644
--- a/TAO/performance-tests/POA/Demux/demux_test_server.h
+++ b/TAO/performance-tests/POA/Demux/demux_test_server.h
@@ -39,10 +39,10 @@ public:
   ~Demux_Test_Server (void);
   // dtor
 
-  int run (TAO_ENV_SINGLE_ARG_DECL_NOT_USED);
+  int run (ACE_ENV_SINGLE_ARG_DECL_NOT_USED);
   // Execute client code.
 
-  int init (int argc, char **argv TAO_ENV_ARG_DECL_NOT_USED);
+  int init (int argc, char **argv ACE_ENV_ARG_DECL_NOT_USED);
   // Initialize the communication endpoint with server.
 
   int calculate_avg_latency (void);
diff --git a/TAO/performance-tests/POA/Demux/server.cpp b/TAO/performance-tests/POA/Demux/server.cpp
index 27014a37cff..629bb31cf5f 100644
--- a/TAO/performance-tests/POA/Demux/server.cpp
+++ b/TAO/performance-tests/POA/Demux/server.cpp
@@ -34,13 +34,13 @@ int main (int argc, char *argv [])
   ACE_TRY_NEW_ENV
     {
       int r =
-        demux_test_server.init (argc, argv TAO_ENV_ARG_PARAMETER);
+        demux_test_server.init (argc, argv ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (r == -1)
         return -1;
 
-      demux_test_server.run (TAO_ENV_SINGLE_ARG_PARAMETER);
+      demux_test_server.run (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCH (CORBA::SystemException, sysex)
diff --git a/TAO/performance-tests/POA/Implicit_Activation/Factory.cpp b/TAO/performance-tests/POA/Implicit_Activation/Factory.cpp
index 88490f1c62e..048928657c2 100644
--- a/TAO/performance-tests/POA/Implicit_Activation/Factory.cpp
+++ b/TAO/performance-tests/POA/Implicit_Activation/Factory.cpp
@@ -12,7 +12,7 @@ Factory::Factory (CORBA::ORB_ptr orb)
 }
 
 Test::Simple_ptr
-Factory::create_simple_object (TAO_ENV_SINGLE_ARG_DECL)
+Factory::create_simple_object (ACE_ENV_SINGLE_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   Simple *simple_impl;
@@ -23,12 +23,12 @@ Factory::create_simple_object (TAO_ENV_SINGLE_ARG_DECL)
 
   PortableServer::ServantBase_var owner_transfer(simple_impl);
 
-  return simple_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER);
+  return simple_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
 }
 
 void
-Factory::shutdown (TAO_ENV_SINGLE_ARG_DECL)
+Factory::shutdown (ACE_ENV_SINGLE_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER);
+  this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER);
 }
diff --git a/TAO/performance-tests/POA/Implicit_Activation/Factory.h b/TAO/performance-tests/POA/Implicit_Activation/Factory.h
index 69967f06580..52e9055f912 100644
--- a/TAO/performance-tests/POA/Implicit_Activation/Factory.h
+++ b/TAO/performance-tests/POA/Implicit_Activation/Factory.h
@@ -26,10 +26,10 @@ public:
 
   // = The skeleton methods
 
-  virtual Test::Simple_ptr create_simple_object (TAO_ENV_SINGLE_ARG_DECL)
+  virtual Test::Simple_ptr create_simple_object (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL)
+  virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
 private:
diff --git a/TAO/performance-tests/POA/Implicit_Activation/Simple.cpp b/TAO/performance-tests/POA/Implicit_Activation/Simple.cpp
index 6ff7ad5edb4..f15b8b826ff 100644
--- a/TAO/performance-tests/POA/Implicit_Activation/Simple.cpp
+++ b/TAO/performance-tests/POA/Implicit_Activation/Simple.cpp
@@ -10,16 +10,16 @@ Simple::Simple (void)
 }
 
 void
-Simple::destroy (TAO_ENV_SINGLE_ARG_DECL)
+Simple::destroy (ACE_ENV_SINGLE_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  PortableServer::POA_var poa = this->_default_POA (TAO_ENV_SINGLE_ARG_PARAMETER);
+  PortableServer::POA_var poa = this->_default_POA (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
 
   PortableServer::ObjectId_var oid =
-    poa->servant_to_id (this TAO_ENV_ARG_PARAMETER);
+    poa->servant_to_id (this ACE_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
-  poa->deactivate_object (oid.in () TAO_ENV_ARG_PARAMETER);
+  poa->deactivate_object (oid.in () ACE_ENV_ARG_PARAMETER);
   ACE_CHECK;
 }
diff --git a/TAO/performance-tests/POA/Implicit_Activation/Simple.h b/TAO/performance-tests/POA/Implicit_Activation/Simple.h
index a0a6059ef09..d3dffbde564 100644
--- a/TAO/performance-tests/POA/Implicit_Activation/Simple.h
+++ b/TAO/performance-tests/POA/Implicit_Activation/Simple.h
@@ -26,7 +26,7 @@ public:
 
   // = The skeleton methods
 
-  virtual void destroy (TAO_ENV_SINGLE_ARG_DECL)
+  virtual void destroy (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 };
 
diff --git a/TAO/performance-tests/POA/Implicit_Activation/client.cpp b/TAO/performance-tests/POA/Implicit_Activation/client.cpp
index d01a1f9bc01..14da618907c 100644
--- a/TAO/performance-tests/POA/Implicit_Activation/client.cpp
+++ b/TAO/performance-tests/POA/Implicit_Activation/client.cpp
@@ -80,18 +80,18 @@ main (int argc, char *argv[])
   ACE_TRY_NEW_ENV
     {
       CORBA::ORB_var orb =
-        CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER);
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (parse_args (argc, argv) != 0)
         return 1;
 
       CORBA::Object_var object =
-        orb->string_to_object (ior TAO_ENV_ARG_PARAMETER);
+        orb->string_to_object (ior ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       Test::Factory_var factory =
-        Test::Factory::_narrow (object.in () TAO_ENV_ARG_PARAMETER);
+        Test::Factory::_narrow (object.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (factory.in ()))
@@ -117,7 +117,7 @@ main (int argc, char *argv[])
           ACE_hrtime_t start = ACE_OS::gethrtime ();
 
           references[i] =
-            factory->create_simple_object (TAO_ENV_SINGLE_ARG_PARAMETER);
+            factory->create_simple_object (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           ACE_hrtime_t now = ACE_OS::gethrtime ();
@@ -141,7 +141,7 @@ main (int argc, char *argv[])
         {
           ACE_hrtime_t start = ACE_OS::gethrtime ();
 
-          references[j]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
+          references[j]->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           ACE_hrtime_t now = ACE_OS::gethrtime ();
@@ -160,7 +160,7 @@ main (int argc, char *argv[])
 
       if (do_shutdown)
         {
-          factory->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
+          factory->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
     }
diff --git a/TAO/performance-tests/POA/Implicit_Activation/collocated.cpp b/TAO/performance-tests/POA/Implicit_Activation/collocated.cpp
index 45be6a48f92..2a79b9ce374 100644
--- a/TAO/performance-tests/POA/Implicit_Activation/collocated.cpp
+++ b/TAO/performance-tests/POA/Implicit_Activation/collocated.cpp
@@ -72,11 +72,11 @@ main (int argc, char *argv[])
   ACE_TRY_NEW_ENV
     {
       CORBA::ORB_var orb =
-        CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER);
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::Object_var poa_object =
-        orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER);
+        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (poa_object.in ()))
@@ -85,14 +85,14 @@ main (int argc, char *argv[])
                           1);
 
       PortableServer::POA_var root_poa =
-        PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER);
+        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POAManager_var poa_manager =
-        root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER);
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER);
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (parse_args (argc, argv) != 0)
@@ -119,7 +119,7 @@ main (int argc, char *argv[])
           PortableServer::ServantBase_var owner_transfer(simple_impl);
 
           references[i] =
-            simple_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER);
+            simple_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           ACE_hrtime_t now = ACE_OS::gethrtime ();
@@ -143,7 +143,7 @@ main (int argc, char *argv[])
         {
           ACE_hrtime_t start = ACE_OS::gethrtime ();
 
-          references[j]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
+          references[j]->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           ACE_hrtime_t now = ACE_OS::gethrtime ();
@@ -160,10 +160,10 @@ main (int argc, char *argv[])
       destruction.collect_basic_stats (destruction_stats);
       destruction_stats.dump_results ("Destruction", gsf);
 
-      root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER);
+      root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
diff --git a/TAO/performance-tests/POA/Implicit_Activation/server.cpp b/TAO/performance-tests/POA/Implicit_Activation/server.cpp
index 97ae513f2e5..89252e82dbd 100644
--- a/TAO/performance-tests/POA/Implicit_Activation/server.cpp
+++ b/TAO/performance-tests/POA/Implicit_Activation/server.cpp
@@ -62,11 +62,11 @@ main (int argc, char *argv[])
   ACE_TRY_NEW_ENV
     {
       CORBA::ORB_var orb =
-        CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER);
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::Object_var poa_object =
-        orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER);
+        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (poa_object.in ()))
@@ -75,11 +75,11 @@ main (int argc, char *argv[])
                           1);
 
       PortableServer::POA_var root_poa =
-        PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER);
+        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POAManager_var poa_manager =
-        root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER);
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (parse_args (argc, argv) != 0)
@@ -92,11 +92,11 @@ main (int argc, char *argv[])
       PortableServer::ServantBase_var owner_transfer(factory_impl);
 
       Test::Factory_var factory =
-        factory_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER);
+        factory_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::String_var ior =
-        orb->object_to_string (factory.in () TAO_ENV_ARG_PARAMETER);
+        orb->object_to_string (factory.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // If the ior_output_file exists, output the ior to it
@@ -109,18 +109,18 @@ main (int argc, char *argv[])
       ACE_OS::fprintf (output_file, "%s", ior.in ());
       ACE_OS::fclose (output_file);
 
-      poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER);
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      orb->run (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->run (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
 
-      root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER);
+      root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
diff --git a/TAO/performance-tests/POA/Object_Creation_And_Registration/registration.cpp b/TAO/performance-tests/POA/Object_Creation_And_Registration/registration.cpp
index ecb844d0187..a0c3544bc95 100644
--- a/TAO/performance-tests/POA/Object_Creation_And_Registration/registration.cpp
+++ b/TAO/performance-tests/POA/Object_Creation_And_Registration/registration.cpp
@@ -243,7 +243,7 @@ private:
 
 void
 child_poa_testing (PortableServer::POA_ptr root_poa
-                   TAO_ENV_ARG_DECL)
+                   ACE_ENV_ARG_DECL)
 {
   // Policies for the child POA.
   CORBA::PolicyList policies (1);
@@ -252,7 +252,7 @@ child_poa_testing (PortableServer::POA_ptr root_poa
   // Id Assignment Policy
   policies[0] =
     root_poa->create_id_assignment_policy (PortableServer::USER_ID
-                                           TAO_ENV_ARG_PARAMETER);
+                                           ACE_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
   // Create the child POA under the RootPOA.
@@ -260,7 +260,7 @@ child_poa_testing (PortableServer::POA_ptr root_poa
     root_poa->create_POA ("child POA",
                           PortableServer::POAManager::_nil (),
                           policies
-                          TAO_ENV_ARG_PARAMETER);
+                          ACE_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
   // Create an array of servants
@@ -299,7 +299,7 @@ child_poa_testing (PortableServer::POA_ptr root_poa
         objects[i] =
           child_poa->create_reference_with_id (object_ids[i].in (),
                                                "IDL:test:1.0"
-                                               TAO_ENV_ARG_PARAMETER);
+                                               ACE_ENV_ARG_PARAMETER);
         ACE_CHECK;
       }
   }
@@ -314,7 +314,7 @@ child_poa_testing (PortableServer::POA_ptr root_poa
       {
         child_poa->activate_object_with_id (object_ids[i].in (),
                                             &servants[i]
-                                            TAO_ENV_ARG_PARAMETER);
+                                            ACE_ENV_ARG_PARAMETER);
         ACE_CHECK;
       }
   }
@@ -328,7 +328,7 @@ child_poa_testing (PortableServer::POA_ptr root_poa
     for (i = 0; i < iterations; i++)
       {
         child_poa->deactivate_object (object_ids[i].in ()
-                                      TAO_ENV_ARG_PARAMETER);
+                                      ACE_ENV_ARG_PARAMETER);
         ACE_CHECK;
       }
   }
@@ -342,7 +342,7 @@ child_poa_testing (PortableServer::POA_ptr root_poa
 int
 main (int argc, char **argv)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
 
   ACE_TRY
     {
@@ -350,7 +350,7 @@ main (int argc, char **argv)
       CORBA::ORB_var orb = CORBA::ORB_init (argc,
                                             argv,
                                             0
-                                            TAO_ENV_ARG_PARAMETER);
+                                            ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       int result = parse_args (argc, argv);
@@ -359,13 +359,13 @@ main (int argc, char **argv)
 
       // Obtain the RootPOA.
       CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA"
-                                                               TAO_ENV_ARG_PARAMETER);
+                                                               ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Get the POA_var object from Object_var.
       PortableServer::POA_var root_poa =
         PortableServer::POA::_narrow (obj.in ()
-                                      TAO_ENV_ARG_PARAMETER);
+                                      ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Create an array of servants
@@ -395,7 +395,7 @@ main (int argc, char **argv)
 
         for (i = 0; i < iterations; i++)
           {
-            objects[i] = servants[i]._this (TAO_ENV_SINGLE_ARG_PARAMETER);
+            objects[i] = servants[i]._this (ACE_ENV_SINGLE_ARG_PARAMETER);
             ACE_TRY_CHECK;
           }
       }
@@ -408,20 +408,20 @@ main (int argc, char **argv)
         for (i = 0; i < iterations; i++)
           {
             object_ids[i] = root_poa->servant_to_id (&servants[i]
-                                                     TAO_ENV_ARG_PARAMETER);
+                                                     ACE_ENV_ARG_PARAMETER);
             ACE_TRY_CHECK;
           }
       }
 
       // Create the child POA.
       child_poa_testing (root_poa.in ()
-                         TAO_ENV_ARG_PARAMETER);
+                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Destroy RootPOA.
       root_poa->destroy (1,
                          1
-                         TAO_ENV_ARG_PARAMETER);
+                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Cleanup
diff --git a/TAO/performance-tests/Pluggable/PP_Test_Client.cpp b/TAO/performance-tests/Pluggable/PP_Test_Client.cpp
index 060dcfb62f8..3f5332de63a 100644
--- a/TAO/performance-tests/Pluggable/PP_Test_Client.cpp
+++ b/TAO/performance-tests/Pluggable/PP_Test_Client.cpp
@@ -165,12 +165,12 @@ PP_Test_Client::parse_args (void)
 void
 PP_Test_Client::send_oneway (void)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
 
   ACE_TRY
     {
       ACE_FUNCTION_TIMEPROBE (PP_TEST_CLIENT_SEND_ONEWAY_START);
-      this->objref_->send_oneway (TAO_ENV_SINGLE_ARG_PARAMETER);
+      this->objref_->send_oneway (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
       this->call_count_++;
     }
@@ -190,12 +190,12 @@ PP_Test_Client::send_oneway (void)
 void
 PP_Test_Client::send_void (void)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
 
   ACE_TRY
     {
       ACE_FUNCTION_TIMEPROBE (PP_TEST_CLIENT_SEND_VOID_START);
-      this->objref_->send_void (TAO_ENV_SINGLE_ARG_PARAMETER);
+      this->objref_->send_void (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
       this->call_count_++;
     }
@@ -259,7 +259,7 @@ PP_Test_Client::run ()
 int
 PP_Test_Client::shutdown_server (int do_shutdown)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
 
   ACE_TRY
     {
@@ -268,7 +268,7 @@ PP_Test_Client::shutdown_server (int do_shutdown)
           ACE_DEBUG ((LM_DEBUG,
                       "shutdown on Pluggable_Test object\n"));
 
-          this->objref_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
+          this->objref_->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
 
           ACE_TRY_CHECK;
 
@@ -290,7 +290,7 @@ PP_Test_Client::shutdown_server (int do_shutdown)
 int
 PP_Test_Client::run_oneway (void)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
 
   ACE_TRY
     {
@@ -312,7 +312,7 @@ PP_Test_Client::run_oneway (void)
 
           ACE_FUNCTION_TIMEPROBE (PP_TEST_CLIENT_SERVER_SHUTDOWN_START);
 
-          this->objref_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
+          this->objref_->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           ACE_DEBUG ((LM_DEBUG,
@@ -333,7 +333,7 @@ PP_Test_Client::run_oneway (void)
 int
 PP_Test_Client::run_void (void)
 {
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
 
   ACE_TRY
     {
@@ -355,7 +355,7 @@ PP_Test_Client::run_void (void)
 
           ACE_FUNCTION_TIMEPROBE (PP_TEST_CLIENT_SERVER_SHUTDOWN_START);
 
-          this->objref_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
+          this->objref_->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           ACE_DEBUG ((LM_DEBUG,
@@ -404,7 +404,7 @@ PP_Test_Client::init (int argc, char **argv)
       this->orb_ = CORBA::ORB_init (this->argc_,
                                     this->argv_,
                                     "internet"
-                                    TAO_ENV_ARG_PARAMETER);
+                                    ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
       // Parse command line and verify parameters.
       if (this->parse_args () == -1)
@@ -422,12 +422,12 @@ PP_Test_Client::init (int argc, char **argv)
 
       CORBA::Object_var factory_object =
         this->orb_->string_to_object (this->factory_key_
-                                      TAO_ENV_ARG_PARAMETER);
+                                      ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       this->factory_ =
         Pluggable_Test_Factory::_narrow (factory_object.in()
-                                TAO_ENV_ARG_PARAMETER);
+                                ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (this->factory_.in ()))
@@ -444,7 +444,7 @@ PP_Test_Client::init (int argc, char **argv)
       // Now retrieve the Pluggable_Test obj ref corresponding to the key.
       ACE_FUNCTION_TIMEPROBE (PP_TEST_CLIENT_MAKE_PLUGGABLE_START);
 
-      this->objref_ = this->factory_->make_pluggable_test (TAO_ENV_SINGLE_ARG_PARAMETER);
+      this->objref_ = this->factory_->make_pluggable_test (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (this->objref_.in ()))
diff --git a/TAO/performance-tests/Pluggable/PP_Test_Server.cpp b/TAO/performance-tests/Pluggable/PP_Test_Server.cpp
index c52492bca10..a9cb9133e53 100644
--- a/TAO/performance-tests/Pluggable/PP_Test_Server.cpp
+++ b/TAO/performance-tests/Pluggable/PP_Test_Server.cpp
@@ -49,14 +49,14 @@ PP_Test_Server::parse_args (void)
 int
 PP_Test_Server::init (int argc,
                       char** argv
-                      TAO_ENV_ARG_DECL_NOT_USED TAO_ENV_SINGLE_ARG_PARAMETER)
+                      ACE_ENV_ARG_DECL_NOT_USED ACE_ENV_SINGLE_ARG_PARAMETER)
 {
   // Call the init of <TAO_ORB_Manager> to initialize the ORB and
   // create a child POA under the root POA.
   if (this->orb_manager_.init_child_poa (argc,
                                          argv,
                                          "child_poa"
-                                         TAO_ENV_ARG_PARAMETER) == -1)
+                                         ACE_ENV_ARG_PARAMETER) == -1)
     ACE_ERROR_RETURN ((LM_ERROR,
                        "%p\n",
                        "init_child_poa"),
@@ -79,7 +79,7 @@ PP_Test_Server::init (int argc,
   this->factory_id_ =
     this->orb_manager_.activate_under_child_poa ("factory",
                                                  this->factory_impl_
-                                                 TAO_ENV_ARG_PARAMETER);
+                                                 ACE_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (-1);
 
   ACE_DEBUG ((LM_DEBUG,
@@ -99,9 +99,9 @@ PP_Test_Server::init (int argc,
 }
 
 int
-PP_Test_Server::run (TAO_ENV_SINGLE_ARG_DECL_NOT_USED TAO_ENV_SINGLE_ARG_PARAMETER)
+PP_Test_Server::run (ACE_ENV_SINGLE_ARG_DECL_NOT_USED ACE_ENV_SINGLE_ARG_PARAMETER)
 {
-  int result = this->orb_manager_.run (TAO_ENV_SINGLE_ARG_PARAMETER);
+  int result = this->orb_manager_.run (ACE_ENV_SINGLE_ARG_PARAMETER);
 
   ACE_CHECK_RETURN (-1);
 
diff --git a/TAO/performance-tests/Pluggable/PP_Test_Server.h b/TAO/performance-tests/Pluggable/PP_Test_Server.h
index 4be6dcaf311..f655b98caf0 100644
--- a/TAO/performance-tests/Pluggable/PP_Test_Server.h
+++ b/TAO/performance-tests/Pluggable/PP_Test_Server.h
@@ -50,10 +50,10 @@ public:
 
   int init (int argc,
             char **argv
-            TAO_ENV_ARG_DECL);
+            ACE_ENV_ARG_DECL);
   // Initialize the server state - parsing arguments, etc.
 
-  int run (TAO_ENV_SINGLE_ARG_DECL);
+  int run (ACE_ENV_SINGLE_ARG_DECL);
   // Run the orb
 
 private:
diff --git a/TAO/performance-tests/Pluggable/PP_Test_i.cpp b/TAO/performance-tests/Pluggable/PP_Test_i.cpp
index 25664e6986d..ac057c96481 100644
--- a/TAO/performance-tests/Pluggable/PP_Test_i.cpp
+++ b/TAO/performance-tests/Pluggable/PP_Test_i.cpp
@@ -38,7 +38,7 @@ static const char *PP_Test_i_Timeprobe_Description[] =
 
 enum
 {
-  // Timeprobe description table start key 
+  // Timeprobe description table start key
   PP_TEST_I_SEND_ONEWAY_START = 10100,
   PP_TEST_I_SEND_ONEWAY_END,
 
@@ -72,11 +72,11 @@ Pluggable_Test_Factory_i::~Pluggable_Test_Factory_i (void)
 }
 
 Pluggable_Test_ptr
-Pluggable_Test_Factory_i::make_pluggable_test (TAO_ENV_SINGLE_ARG_DECL)
+Pluggable_Test_Factory_i::make_pluggable_test (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (PP_TEST_I_MAKE_PLUGGABLE_START);
-  return my_pluggable_test_._this (TAO_ENV_SINGLE_ARG_PARAMETER);
+  return my_pluggable_test_._this (ACE_ENV_SINGLE_ARG_PARAMETER);
 }
 
 // Constructor
@@ -95,7 +95,7 @@ PP_Test_i::~PP_Test_i (void)
 // Oneway send
 
 void
-PP_Test_i::send_oneway (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+PP_Test_i::send_oneway (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (PP_TEST_I_SEND_ONEWAY_START);
@@ -104,7 +104,7 @@ PP_Test_i::send_oneway (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
 // Twoway send
 
 void
-PP_Test_i::send_void (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+PP_Test_i::send_void (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (PP_TEST_I_SEND_VOID_START);
@@ -112,7 +112,7 @@ PP_Test_i::send_void (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
 
 // Shutdown.
 
-void PP_Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+void PP_Test_i::shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_DEBUG ((LM_DEBUG,
diff --git a/TAO/performance-tests/Pluggable/PP_Test_i.h b/TAO/performance-tests/Pluggable/PP_Test_i.h
index 2c439e97528..1e866bb103b 100644
--- a/TAO/performance-tests/Pluggable/PP_Test_i.h
+++ b/TAO/performance-tests/Pluggable/PP_Test_i.h
@@ -34,15 +34,15 @@ public:
   ~PP_Test_i (void);
   // Destructor
 
-  virtual void send_oneway (TAO_ENV_SINGLE_ARG_DECL)
+  virtual void send_oneway (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Test a oneway call.
 
-  virtual void send_void (TAO_ENV_SINGLE_ARG_DECL)
+  virtual void send_void (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Test a twoway call.
 
-  virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL)
+  virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Shutdown routine.
 
@@ -65,7 +65,7 @@ public:
   ~Pluggable_Test_Factory_i (void);
   // Destructor.
 
-  virtual Pluggable_Test_ptr make_pluggable_test (TAO_ENV_SINGLE_ARG_DECL)
+  virtual Pluggable_Test_ptr make_pluggable_test (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
   // Make a Pluggable Test object.
 
diff --git a/TAO/performance-tests/Pluggable/server.cpp b/TAO/performance-tests/Pluggable/server.cpp
index 99b513899e8..6d781f12420 100644
--- a/TAO/performance-tests/Pluggable/server.cpp
+++ b/TAO/performance-tests/Pluggable/server.cpp
@@ -15,13 +15,13 @@ main (int argc, char *argv[])
   ACE_DEBUG ((LM_DEBUG,
               "\n\tPluggable_Test: server\n\n"));
 
-  TAO_ENV_DECLARE_NEW_ENV;
+  ACE_DECLARE_NEW_CORBA_ENV;
 
   ACE_TRY
     {
       int status = pp_test_server.init (argc,
                                         argv
-                                        TAO_ENV_ARG_PARAMETER);
+                                        ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (status == -1)
@@ -32,7 +32,7 @@ main (int argc, char *argv[])
         }
       else
         {
-          pp_test_server.run (TAO_ENV_SINGLE_ARG_PARAMETER);
+          pp_test_server.run (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
     }
diff --git a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.cpp b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.cpp
index 3c40536d884..706289d63f9 100644
--- a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.cpp
+++ b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.cpp
@@ -12,7 +12,7 @@ ACE_RCSID(Latency, test_i, "$Id$")
 
 void
 Test_i::test_method (CORBA::Long id
-                     TAO_ENV_ARG_DECL_NOT_USED)
+                     ACE_ENV_ARG_DECL_NOT_USED)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   if (TAO_debug_level > 0)
@@ -23,16 +23,16 @@ Test_i::test_method (CORBA::Long id
 
 void
 Test_i::shutdown (const char *orb_id
-                  TAO_ENV_ARG_DECL_NOT_USED TAO_ENV_SINGLE_ARG_PARAMETER)
+                  ACE_ENV_ARG_DECL_NOT_USED ACE_ENV_SINGLE_ARG_PARAMETER)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   int argc = 0;
   CORBA::ORB_var orb = CORBA::ORB_init (argc,
                                         0,
                                         orb_id
-                                        TAO_ENV_ARG_PARAMETER);
+                                        ACE_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
-  orb->shutdown (0 TAO_ENV_ARG_PARAMETER);
+  orb->shutdown (0 ACE_ENV_ARG_PARAMETER);
   ACE_CHECK;
 }
diff --git a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.h b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.h
index a3d93fa6f2d..2a3de616b96 100644
--- a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.h
+++ b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.h
@@ -32,11 +32,11 @@ public:
 
   // = The Test methods.
   void test_method (CORBA::Long id
-                    TAO_ENV_ARG_DECL_NOT_USED)
+                    ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
   void shutdown (const char *orb_id
-                 TAO_ENV_ARG_DECL_NOT_USED)
+                 ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException));
 };
 
diff --git a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/client.cpp b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/client.cpp
index ab4e491160b..971444dd810 100644
--- a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/client.cpp
+++ b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/client.cpp
@@ -141,7 +141,7 @@ main (int argc, char *argv[])
       ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor ();
 
       CORBA::ORB_var orb =
-        CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER);
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (parse_args (argc, argv) != 0)
@@ -150,12 +150,12 @@ main (int argc, char *argv[])
       // Obtain Priority Mapping used by the ORB.
       CORBA::Object_var object =
         orb->resolve_initial_references ("PriorityMappingManager"
-                                         TAO_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       RTCORBA::PriorityMappingManager_var mapping_manager =
         RTCORBA::PriorityMappingManager::_narrow (object.in ()
-                                              TAO_ENV_ARG_PARAMETER);
+                                              ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (mapping_manager.in ()))
@@ -260,11 +260,11 @@ Client::svc (void)
                        priorities[this->id_]);
 
       CORBA::Object_var object =
-        orb_->string_to_object (ior TAO_ENV_ARG_PARAMETER);
+        orb_->string_to_object (ior ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       Test_var server =
-        Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER);
+        Test::_narrow (object.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (server.in ()))
@@ -282,11 +282,11 @@ Client::svc (void)
         {
           /* CORBA::PolicyList_var pols;
           server->_validate_connection (pols.out ()
-                                        TAO_ENV_ARG_PARAMETER);
+                                        ACE_ENV_ARG_PARAMETER);
           */
 
           server->test_method (this->id_
-                               TAO_ENV_ARG_PARAMETER);
+                               ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
 
@@ -301,7 +301,7 @@ Client::svc (void)
 
           // Invoke method.
           server->test_method (this->id_
-                               TAO_ENV_ARG_PARAMETER);
+                               ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           // Grab timestamp again.
@@ -320,7 +320,7 @@ Client::svc (void)
 
       /* char orb_name[50];
       ACE_OS::sprintf (orb_name, "%d", priorities[this->id_]);
-      server->shutdown (orb_name TAO_ENV_ARG_PARAMETER);
+      server->shutdown (orb_name ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;*/
     }
   ACE_CATCHANY
diff --git a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/server.cpp b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/server.cpp
index 3ed70825ae0..2b54912aca0 100644
--- a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/server.cpp
+++ b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/server.cpp
@@ -120,7 +120,7 @@ main (int argc, char *argv[])
       int argc_ = argc;
       for (int i = 0; i < argc; ++i)
         argv_[i] = argv[i];
-      orb = CORBA::ORB_init (argc_, argv_, "" TAO_ENV_ARG_PARAMETER);
+      orb = CORBA::ORB_init (argc_, argv_, "" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Parse the arguments.
@@ -130,12 +130,12 @@ main (int argc, char *argv[])
       // Obtain Priority Mapping used by the ORB.
       CORBA::Object_var object =
         orb->resolve_initial_references ("PriorityMappingManager"
-                                         TAO_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       RTCORBA::PriorityMappingManager_var mapping_manager =
         RTCORBA::PriorityMappingManager::_narrow (object.in ()
-                                              TAO_ENV_ARG_PARAMETER);
+                                              ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (mapping_manager.in ()))
@@ -214,11 +214,11 @@ Server::svc (void)
       char orb_name[64];
       ACE_OS::sprintf (orb_name, "%d", this->priority_);
       CORBA::ORB_var orb =
-        CORBA::ORB_init (argc_, argv_, orb_name TAO_ENV_ARG_PARAMETER);
+        CORBA::ORB_init (argc_, argv_, orb_name ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::Object_var poa_object =
-        orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER);
+        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (poa_object.in ()))
@@ -227,23 +227,23 @@ Server::svc (void)
                           1);
 
       PortableServer::POA_var root_poa =
-        PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER);
+        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POAManager_var poa_manager =
-        root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER);
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::ObjectId_var oid =
-        root_poa->activate_object (this->server_ TAO_ENV_ARG_PARAMETER);
+        root_poa->activate_object (this->server_ ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::Object_var obj =
-        root_poa->id_to_reference (oid.in () TAO_ENV_ARG_PARAMETER);
+        root_poa->id_to_reference (oid.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::String_var ior =
-        orb->object_to_string (obj.in () TAO_ENV_ARG_PARAMETER);
+        orb->object_to_string (obj.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ()));
@@ -266,10 +266,10 @@ Server::svc (void)
       ACE_OS::fclose (output_file);
 
       // Start orb event loop.
-      poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER);
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      orb->run (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->run (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
     }
diff --git a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/client.cpp b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/client.cpp
index febe0cde286..d128bcd1ae9 100644
--- a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/client.cpp
+++ b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/client.cpp
@@ -141,18 +141,18 @@ main (int argc, char *argv[])
       ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor ();
 
       CORBA::ORB_var orb =
-        CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER);
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (parse_args (argc, argv) != 0)
         return 1;
 
       CORBA::Object_var object =
-        orb->string_to_object (ior TAO_ENV_ARG_PARAMETER);
+        orb->string_to_object (ior ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       Test_var server =
-        Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER);
+        Test::_narrow (object.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (server.in ()))
@@ -165,12 +165,12 @@ main (int argc, char *argv[])
 
       // Obtain Priority Mapping used by the ORB.
       object = orb->resolve_initial_references ("PriorityMappingManager"
-                                                TAO_ENV_ARG_PARAMETER);
+                                                ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       RTCORBA::PriorityMappingManager_var mapping_manager =
         RTCORBA::PriorityMappingManager::_narrow (object.in ()
-                                              TAO_ENV_ARG_PARAMETER);
+                                              ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (mapping_manager.in ()))
@@ -222,7 +222,7 @@ main (int argc, char *argv[])
         }
       throughput.dump_results ("Aggregated", gsf);
 
-      server->shutdown ("" TAO_ENV_ARG_PARAMETER);
+      server->shutdown ("" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
     }
@@ -286,11 +286,11 @@ Client::svc (void)
         {
           /*    CORBA::PolicyList_var pols;
           server_->_validate_connection (pols.out ()
-                                         TAO_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
           */
 
           server_->test_method (this->id_
-                                TAO_ENV_ARG_PARAMETER);
+                                ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
 
@@ -305,7 +305,7 @@ Client::svc (void)
 
           // Invoke method.
           server_->test_method (this->id_
-                                TAO_ENV_ARG_PARAMETER);
+                                ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           // Grab timestamp again.
diff --git a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/server.cpp b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/server.cpp
index 5a7a5f2aea7..7b623eadc7e 100644
--- a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/server.cpp
+++ b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/server.cpp
@@ -59,11 +59,11 @@ main (int argc, char *argv[])
   ACE_TRY_NEW_ENV
     {
       CORBA::ORB_var orb =
-        CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER);
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::Object_var poa_object =
-        orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER);
+        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (poa_object.in ()))
@@ -72,11 +72,11 @@ main (int argc, char *argv[])
                           1);
 
       PortableServer::POA_var root_poa =
-        PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER);
+        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POAManager_var poa_manager =
-        root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER);
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (parse_args (argc, argv) != 0)
@@ -85,11 +85,11 @@ main (int argc, char *argv[])
       Test_i server_impl;
 
       Test_var server =
-        server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER);
+        server_impl._this (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::String_var ior =
-        orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER);
+        orb->object_to_string (server.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ()));
@@ -107,10 +107,10 @@ main (int argc, char *argv[])
           ACE_OS::fclose (output_file);
         }
 
-      poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER);
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      orb->run (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->run (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
diff --git a/TAO/performance-tests/RTCorba/Oneways/Reliable/client.cpp b/TAO/performance-tests/RTCorba/Oneways/Reliable/client.cpp
index 58b3e73585e..1f7ef7a756a 100644
--- a/TAO/performance-tests/RTCorba/Oneways/Reliable/client.cpp
+++ b/TAO/performance-tests/RTCorba/Oneways/Reliable/client.cpp
@@ -135,7 +135,7 @@ print_params (void)
 
 static void
 twoway_work_test (Test_ptr server
-                  TAO_ENV_ARG_DECL)
+                  ACE_ENV_ARG_DECL)
 {
 #if defined (USING_TIMERS)
   ACE_Throughput_Stats latency;
@@ -156,7 +156,7 @@ twoway_work_test (Test_ptr server
 #endif /* USING_TIMERS */
 
       server->twoway_work_test (work
-                                TAO_ENV_ARG_PARAMETER);
+                                ACE_ENV_ARG_PARAMETER);
       ACE_CHECK;
 
 #if defined (USING_TIMERS)
@@ -180,7 +180,7 @@ twoway_work_test (Test_ptr server
 
 static void
 oneway_work_test (Test_ptr server
-                  TAO_ENV_ARG_DECL)
+                  ACE_ENV_ARG_DECL)
 {
 #if defined (USING_TIMERS)
   ACE_Throughput_Stats latency;
@@ -201,7 +201,7 @@ oneway_work_test (Test_ptr server
 #endif /* USING_TIMERS */
 
       server->oneway_work_test (work
-                                TAO_ENV_ARG_PARAMETER);
+                                ACE_ENV_ARG_PARAMETER);
       ACE_CHECK;
 
 #if defined (USING_TIMERS)
@@ -225,7 +225,7 @@ oneway_work_test (Test_ptr server
 
 static void
 oneway_payload_test (Test_ptr server
-                     TAO_ENV_ARG_DECL)
+                     ACE_ENV_ARG_DECL)
 {
 #if defined (USING_TIMERS)
   ACE_Throughput_Stats latency;
@@ -249,7 +249,7 @@ oneway_payload_test (Test_ptr server
 #endif /* USING_TIMERS */
 
       server->oneway_payload_test (the_data
-                                   TAO_ENV_ARG_PARAMETER);
+                                   ACE_ENV_ARG_PARAMETER);
       ACE_CHECK;
 
 #if defined (USING_TIMERS)
@@ -432,7 +432,7 @@ main (int argc, char *argv[])
         CORBA::ORB_init (argc,
                          argv,
                          ""
-                         TAO_ENV_ARG_PARAMETER);
+                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Get the command line options.
@@ -445,30 +445,30 @@ main (int argc, char *argv[])
 
       CORBA::Object_var obj =
         orb->resolve_initial_references ("ORBPolicyManager"
-                                         TAO_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::PolicyManager_var policy_manager =
         CORBA::PolicyManager::_narrow (obj.in ()
-                                       TAO_ENV_ARG_PARAMETER);
+                                       ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       obj = orb->resolve_initial_references ("PolicyCurrent"
-                                             TAO_ENV_ARG_PARAMETER);
+                                             ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::PolicyCurrent_var policy_current =
         CORBA::PolicyCurrent::_narrow (obj.in ()
-                                       TAO_ENV_ARG_PARAMETER);
+                                       ACE_ENV_ARG_PARAMETER);
 
       ACE_TRY_CHECK;
 
       obj = orb->string_to_object (ior
-                                   TAO_ENV_ARG_PARAMETER);
+                                   ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       Test_var server = Test::_narrow (obj.in ()
-                                       TAO_ENV_ARG_PARAMETER);
+                                       ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Print testing parameters.
@@ -478,7 +478,7 @@ main (int argc, char *argv[])
       if (test_twoway)
         {
           twoway_work_test (server.in ()
-                            TAO_ENV_ARG_PARAMETER);
+                            ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
       else
@@ -495,7 +495,7 @@ main (int argc, char *argv[])
           sync_scope_policy_list[0] =
             orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
                                 sync_scope_any
-                                TAO_ENV_ARG_PARAMETER);
+                                ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           switch (level)
@@ -504,7 +504,7 @@ main (int argc, char *argv[])
               // Set the sync scope policy at the ORB level.
               policy_manager->set_policy_overrides (sync_scope_policy_list,
                                                     CORBA::ADD_OVERRIDE
-                                                    TAO_ENV_ARG_PARAMETER);
+                                                    ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
               break;
 
@@ -512,7 +512,7 @@ main (int argc, char *argv[])
               // Set the sync scope policy at the thread level.
               policy_current->set_policy_overrides (sync_scope_policy_list,
                                                     CORBA::ADD_OVERRIDE
-                                                    TAO_ENV_ARG_PARAMETER);
+                                                    ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
               break;
 
@@ -520,12 +520,12 @@ main (int argc, char *argv[])
               // Set the sync scope policy at the object level.
               obj = server->_set_policy_overrides (sync_scope_policy_list,
                                                    CORBA::ADD_OVERRIDE
-                                                   TAO_ENV_ARG_PARAMETER);
+                                                   ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
 
               // Get the new object reference with the updated policy.
               server = Test::_narrow (obj.in ()
-                                      TAO_ENV_ARG_PARAMETER);
+                                      ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
               break;
 
@@ -534,7 +534,7 @@ main (int argc, char *argv[])
           }
 
           // We are done with this policy.
-          sync_scope_policy_list[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
+          sync_scope_policy_list[0]->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           // Are we buffering the oneway requests?
@@ -558,32 +558,32 @@ main (int argc, char *argv[])
               buffering_constraint_policy_list[0] =
                 orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE,
                                     buffering_constraint_any
-                                    TAO_ENV_ARG_PARAMETER);
+                                    ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
 
               // Set up the constraints (at the object level).
               obj = server->_set_policy_overrides (buffering_constraint_policy_list,
                                                    CORBA::ADD_OVERRIDE
-                                                   TAO_ENV_ARG_PARAMETER);
+                                                   ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
 
               // We are done with this policy.
-              buffering_constraint_policy_list[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
+              buffering_constraint_policy_list[0]->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
               ACE_TRY_CHECK;
 
               // Get the new object reference with the updated policy.
               server = Test::_narrow (obj.in ()
-                                      TAO_ENV_ARG_PARAMETER);
+                                      ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
           // Run the oneway test.
           if (payload_test)
             oneway_payload_test (server.in ()
-                                 TAO_ENV_ARG_PARAMETER);
+                                 ACE_ENV_ARG_PARAMETER);
           else
             oneway_work_test (server.in ()
-                              TAO_ENV_ARG_PARAMETER);
+                              ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
 
@@ -592,7 +592,7 @@ main (int argc, char *argv[])
           ACE_DEBUG ((LM_DEBUG,
                       "\nShutting down server\n"));
 
-          server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
+          server->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
 
@@ -602,7 +602,7 @@ main (int argc, char *argv[])
       // static destructors to flush the queues, it will be too late.
       // Therefore, we use explicit destruction here and flush the
       // queues before main() ends.
-      orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
diff --git a/TAO/performance-tests/RTCorba/Oneways/Reliable/server.cpp b/TAO/performance-tests/RTCorba/Oneways/Reliable/server.cpp
index 89bc9f56bd4..b23da7d1bb9 100644
--- a/TAO/performance-tests/RTCorba/Oneways/Reliable/server.cpp
+++ b/TAO/performance-tests/RTCorba/Oneways/Reliable/server.cpp
@@ -95,7 +95,7 @@ main (int argc, char *argv[])
         CORBA::ORB_init (argc,
                          argv,
                          ""
-                         TAO_ENV_ARG_PARAMETER);
+                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // Get the command line options.
@@ -108,27 +108,27 @@ main (int argc, char *argv[])
 
       CORBA::Object_var poa_object =
         orb->resolve_initial_references ("RootPOA"
-                                         TAO_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POA_var root_poa =
         PortableServer::POA::_narrow (poa_object.in ()
-                                      TAO_ENV_ARG_PARAMETER);
+                                      ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POAManager_var poa_manager =
-        root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER);
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       Test_i server_impl (orb.in ());
 
       Test_var server =
-        server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER);
+        server_impl._this (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::String_var ior =
         orb->object_to_string (server.in ()
-                               TAO_ENV_ARG_PARAMETER);
+                               ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ACE_DEBUG ((LM_DEBUG,
@@ -149,17 +149,17 @@ main (int argc, char *argv[])
 
       ACE_OS::fclose (output_file);
 
-      poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER);
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      orb->run (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->run (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
 
       root_poa->destroy (1,
                          1
-                         TAO_ENV_ARG_PARAMETER);
+                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
diff --git a/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.cpp b/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.cpp
index 17c0cfa9726..3062b3b2402 100644
--- a/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.cpp
+++ b/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.cpp
@@ -11,7 +11,7 @@ ACE_RCSID(Reliable, test_i, "$Id$")
 
 void
 Test_i::oneway_work_test (CORBA::ULong work
-                          TAO_ENV_ARG_DECL_NOT_USED)
+                          ACE_ENV_ARG_DECL_NOT_USED)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   for (CORBA::ULong i = 0; i < work; i++)
@@ -25,14 +25,14 @@ Test_i::oneway_work_test (CORBA::ULong work
 
 void
 Test_i::oneway_payload_test (const Test::data &
-                             TAO_ENV_ARG_DECL_NOT_USED)
+                             ACE_ENV_ARG_DECL_NOT_USED)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
 }
 
 void
 Test_i::twoway_work_test (CORBA::ULong work
-                          TAO_ENV_ARG_DECL_NOT_USED)
+                          ACE_ENV_ARG_DECL_NOT_USED)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   for (CORBA::ULong i = 0; i < work; i++)
@@ -45,9 +45,9 @@ Test_i::twoway_work_test (CORBA::ULong work
 }
 
 void
-Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED TAO_ENV_SINGLE_ARG_PARAMETER)
+Test_i::shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED ACE_ENV_SINGLE_ARG_PARAMETER)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   this->orb_->shutdown (0
-                        TAO_ENV_ARG_PARAMETER);
+                        ACE_ENV_ARG_PARAMETER);
 }
diff --git a/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.h b/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.h
index 2ef26b8c187..0359d3c1fa3 100644
--- a/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.h
+++ b/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.h
@@ -32,18 +32,18 @@ public:
 
   // = The Test methods.
   void oneway_payload_test (const Test::data &d
-                            TAO_ENV_ARG_DECL_WITH_DEFAULTS)
+                            ACE_ENV_ARG_DECL_WITH_DEFAULTS)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
   void oneway_work_test (CORBA::ULong work
-                         TAO_ENV_ARG_DECL_WITH_DEFAULTS)
+                         ACE_ENV_ARG_DECL_WITH_DEFAULTS)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
   void twoway_work_test (CORBA::ULong work
-                         TAO_ENV_ARG_DECL_WITH_DEFAULTS)
+                         ACE_ENV_ARG_DECL_WITH_DEFAULTS)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  void shutdown (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
+  void shutdown (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
 private:
diff --git a/TAO/performance-tests/RTCorba/Thread_Pool/client.cpp b/TAO/performance-tests/RTCorba/Thread_Pool/client.cpp
index a45471a31a4..1c565863857 100644
--- a/TAO/performance-tests/RTCorba/Thread_Pool/client.cpp
+++ b/TAO/performance-tests/RTCorba/Thread_Pool/client.cpp
@@ -249,7 +249,7 @@ start_synchronization (test_ptr test,
         {
           test->method (work,
                         prime_number
-                        TAO_ENV_ARG_PARAMETER);
+                        ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
     }
@@ -358,7 +358,7 @@ max_throughput (test_ptr test,
   ACE_TRY_NEW_ENV
     {
       CORBA_priority =
-        current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER);
+        current->the_priority (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::Boolean result =
@@ -387,7 +387,7 @@ max_throughput (test_ptr test,
 
           test->method (work,
                         prime_number
-                        TAO_ENV_ARG_PARAMETER);
+                        ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           ++calls_made;
@@ -430,9 +430,9 @@ public:
 
   int svc (void);
   ACE_hrtime_t deadline_for_current_call (CORBA::ULong i);
-  void reset_priority (TAO_ENV_SINGLE_ARG_DECL);
+  void reset_priority (ACE_ENV_SINGLE_ARG_DECL);
   void print_stats (ACE_hrtime_t test_end);
-  int setup (TAO_ENV_SINGLE_ARG_DECL);
+  int setup (ACE_ENV_SINGLE_ARG_DECL);
   void missed_start_deadline (CORBA::ULong invocation);
   void missed_end_deadline (CORBA::ULong invocation);
 
@@ -483,18 +483,18 @@ Paced_Worker::Paced_Worker (ACE_Thread_Manager &thread_manager,
 }
 
 void
-Paced_Worker::reset_priority (TAO_ENV_SINGLE_ARG_DECL)
+Paced_Worker::reset_priority (ACE_ENV_SINGLE_ARG_DECL)
 {
   if (set_priority)
     {
       this->current_->the_priority (this->priority_
-                                    TAO_ENV_ARG_PARAMETER);
+                                    ACE_ENV_ARG_PARAMETER);
       ACE_CHECK;
     }
   else
     {
       this->current_->the_priority (continuous_worker_priority
-                                    TAO_ENV_ARG_PARAMETER);
+                                    ACE_ENV_ARG_PARAMETER);
       ACE_CHECK;
     }
 }
@@ -600,16 +600,16 @@ Paced_Worker::print_stats (ACE_hrtime_t test_end)
 }
 
 int
-Paced_Worker::setup (TAO_ENV_SINGLE_ARG_DECL)
+Paced_Worker::setup (ACE_ENV_SINGLE_ARG_DECL)
 {
   if (priority_setting == AFTER_THREAD_CREATION)
     {
-      this->reset_priority (TAO_ENV_SINGLE_ARG_PARAMETER);
+      this->reset_priority (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_CHECK_RETURN (-1);
     }
 
   this->CORBA_priority_ =
-    this->current_->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER);
+    this->current_->the_priority (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (-1);
 
   CORBA::Boolean result =
@@ -647,7 +647,7 @@ Paced_Worker::svc (void)
   ACE_TRY_NEW_ENV
     {
       int result =
-        this->setup (TAO_ENV_SINGLE_ARG_PARAMETER);
+        this->setup (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (result != 0)
@@ -671,7 +671,7 @@ Paced_Worker::svc (void)
 
           this->test_->method (work,
                                prime_number
-                               TAO_ENV_ARG_PARAMETER);
+                               ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           ACE_hrtime_t time_after_call =
@@ -725,7 +725,7 @@ public:
   int svc (void);
   void print_stats (ACE_Sample_History &history,
                     ACE_hrtime_t test_end);
-  int setup (TAO_ENV_SINGLE_ARG_DECL);
+  int setup (ACE_ENV_SINGLE_ARG_DECL);
   void print_collective_stats (void);
 
   test_var test_;
@@ -827,17 +827,17 @@ Continuous_Worker::print_collective_stats (void)
 }
 
 int
-Continuous_Worker::setup (TAO_ENV_SINGLE_ARG_DECL)
+Continuous_Worker::setup (ACE_ENV_SINGLE_ARG_DECL)
 {
   if (priority_setting == AFTER_THREAD_CREATION)
     {
       this->current_->the_priority (continuous_worker_priority
-                                    TAO_ENV_ARG_PARAMETER);
+                                    ACE_ENV_ARG_PARAMETER);
       ACE_CHECK_RETURN (-1);
     }
 
   this->CORBA_priority_ =
-    this->current_->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER);
+    this->current_->the_priority (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK_RETURN (-1);
 
   CORBA::Boolean result =
@@ -862,7 +862,7 @@ Continuous_Worker::svc (void)
       ACE_Sample_History history (this->iterations_);
 
       int result =
-        this->setup (TAO_ENV_SINGLE_ARG_PARAMETER);
+        this->setup (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (result != 0)
@@ -876,7 +876,7 @@ Continuous_Worker::svc (void)
 
           this->test_->method (work,
                                prime_number
-                               TAO_ENV_ARG_PARAMETER);
+                               ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           ACE_hrtime_t end = ACE_OS::gethrtime ();
@@ -911,7 +911,7 @@ main (int argc, char *argv[])
   ACE_TRY_NEW_ENV
     {
       CORBA::ORB_var orb =
-        CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER);
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       int result =
@@ -922,31 +922,31 @@ main (int argc, char *argv[])
       fudge_priorities (orb.in ());
 
       CORBA::Object_var object =
-        orb->string_to_object (ior TAO_ENV_ARG_PARAMETER);
+        orb->string_to_object (ior ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       test_var test =
-        test::_narrow (object.in () TAO_ENV_ARG_PARAMETER);
+        test::_narrow (object.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       object =
         orb->resolve_initial_references ("RTCurrent"
-                                         TAO_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       RTCORBA::Current_var current =
         RTCORBA::Current::_narrow (object.in ()
-                                   TAO_ENV_ARG_PARAMETER);
+                                   ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       object =
         orb->resolve_initial_references ("PriorityMappingManager"
-                                         TAO_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       RTCORBA::PriorityMappingManager_var mapping_manager =
         RTCORBA::PriorityMappingManager::_narrow (object.in ()
-                                                  TAO_ENV_ARG_PARAMETER);
+                                                  ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       RTCORBA::PriorityMapping &priority_mapping =
@@ -1145,7 +1145,7 @@ main (int argc, char *argv[])
 
       if (shutdown_server)
         {
-          test->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
+          test->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
     }
diff --git a/TAO/performance-tests/RTCorba/Thread_Pool/server.cpp b/TAO/performance-tests/RTCorba/Thread_Pool/server.cpp
index ba0290feaa6..1521f88ee83 100644
--- a/TAO/performance-tests/RTCorba/Thread_Pool/server.cpp
+++ b/TAO/performance-tests/RTCorba/Thread_Pool/server.cpp
@@ -22,13 +22,13 @@ public:
 
   void method (CORBA::ULong work,
                CORBA::ULong prime_number
-               TAO_ENV_ARG_DECL_NOT_USED)
+               ACE_ENV_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+  void shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL);
+  PortableServer::POA_ptr _default_POA (ACE_ENV_SINGLE_ARG_DECL);
 
 private:
   CORBA::ORB_var orb_;
@@ -45,7 +45,7 @@ test_i::test_i (CORBA::ORB_ptr orb,
 void
 test_i::method (CORBA::ULong work,
                 CORBA::ULong prime_number
-                TAO_ENV_ARG_DECL_NOT_USED)
+                ACE_ENV_ARG_DECL_NOT_USED)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   if (TAO_debug_level > 0)
@@ -60,17 +60,17 @@ test_i::method (CORBA::ULong work,
 }
 
 PortableServer::POA_ptr
-test_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED)
+test_i::_default_POA (ACE_ENV_SINGLE_ARG_DECL_NOT_USED)
 {
   return PortableServer::POA::_duplicate (this->poa_.in ());
 }
 
 void
-test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL)
+test_i::shutdown (ACE_ENV_SINGLE_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   this->orb_->shutdown (0
-                        TAO_ENV_ARG_PARAMETER);
+                        ACE_ENV_ARG_PARAMETER);
   ACE_CHECK;
 }
 
@@ -170,11 +170,11 @@ int
 write_ior_to_file (const char *ior_file,
                    CORBA::ORB_ptr orb,
                    CORBA::Object_ptr object
-                   TAO_ENV_ARG_DECL)
+                   ACE_ENV_ARG_DECL)
 {
   CORBA::String_var ior =
     orb->object_to_string (object
-                           TAO_ENV_ARG_PARAMETER);
+                           ACE_ENV_ARG_PARAMETER);
   ACE_CHECK_RETURN (-1);
 
   FILE *output_file =
@@ -205,47 +205,47 @@ main (int argc, char *argv[])
         CORBA::ORB_init (argc,
                          argv,
                          ""
-                         TAO_ENV_ARG_PARAMETER);
+                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       fudge_priorities (orb.in ());
 
       CORBA::Object_var object =
         orb->resolve_initial_references ("RootPOA"
-                                         TAO_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POA_var root_poa =
         PortableServer::POA::_narrow (object.in ()
-                                      TAO_ENV_ARG_PARAMETER);
+                                      ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POAManager_var poa_manager =
-        root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER);
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       object =
         orb->resolve_initial_references ("RTORB"
-                                         TAO_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       RTCORBA::RTORB_var rt_orb =
         RTCORBA::RTORB::_narrow (object.in ()
-                                 TAO_ENV_ARG_PARAMETER);
+                                 ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       object =
         orb->resolve_initial_references ("RTCurrent"
-                                         TAO_ENV_ARG_PARAMETER);
+                                         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       RTCORBA::Current_var current =
         RTCORBA::Current::_narrow (object.in ()
-                                   TAO_ENV_ARG_PARAMETER);
+                                   ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       default_thread_priority =
-        current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER);
+        current->the_priority (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       int result =
@@ -273,7 +273,7 @@ main (int argc, char *argv[])
                                              max_request_buffer_size,
                                              allow_borrowing,
                                              policies
-                                             TAO_ENV_ARG_PARAMETER);
+                                             ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
       else if (ACE_OS::strcmp (lanes_file, "empty-file") != 0)
@@ -290,7 +290,7 @@ main (int argc, char *argv[])
                                 max_request_buffer_size,
                                 allow_borrowing,
                                 policies
-                                TAO_ENV_ARG_PARAMETER);
+                                ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           if (result != 0)
@@ -301,7 +301,7 @@ main (int argc, char *argv[])
                                 bands_file,
                                 rt_orb.in (),
                                 policies
-                                TAO_ENV_ARG_PARAMETER);
+                                ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           if (result != 0)
@@ -321,13 +321,13 @@ main (int argc, char *argv[])
                                        allow_request_buffering,
                                        max_buffered_requests,
                                        max_request_buffer_size
-                                       TAO_ENV_ARG_PARAMETER);
+                                       ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           policies.length (policies.length () + 1);
           policies[policies.length () - 1] =
             rt_orb->create_threadpool_policy (threadpool_id
-                                              TAO_ENV_ARG_PARAMETER);
+                                              ACE_ENV_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           if (ACE_OS::strcmp (bands_file, "empty-file") != 0)
@@ -337,7 +337,7 @@ main (int argc, char *argv[])
                                     bands_file,
                                     rt_orb.in (),
                                     policies
-                                    TAO_ENV_ARG_PARAMETER);
+                                    ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
 
               if (result != 0)
@@ -349,21 +349,21 @@ main (int argc, char *argv[])
       policies[policies.length () - 1] =
         root_poa->create_implicit_activation_policy
         (PortableServer::IMPLICIT_ACTIVATION
-         TAO_ENV_ARG_PARAMETER);
+         ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       policies.length (policies.length () + 1);
       policies[policies.length () - 1] =
         rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED,
                                               default_thread_priority
-                                              TAO_ENV_ARG_PARAMETER);
+                                              ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POA_var poa =
         root_poa->create_POA ("RT POA",
                               poa_manager.in (),
                               policies
-                              TAO_ENV_ARG_PARAMETER);
+                              ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       test_i *servant =
@@ -374,26 +374,26 @@ main (int argc, char *argv[])
       ACE_UNUSED_ARG (safe_servant);
 
       test_var test =
-        servant->_this (TAO_ENV_SINGLE_ARG_PARAMETER);
+        servant->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       result =
         write_ior_to_file (ior_output_file,
                            orb.in (),
                            test.in ()
-                           TAO_ENV_ARG_PARAMETER);
+                           ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (result != 0)
         return result;
 
-      poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER);
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      orb->run (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->run (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
diff --git a/TAO/performance-tests/Single_Threaded_Latency/Roundtrip.cpp b/TAO/performance-tests/Single_Threaded_Latency/Roundtrip.cpp
new file mode 100644
index 00000000000..72f83576b44
--- /dev/null
+++ b/TAO/performance-tests/Single_Threaded_Latency/Roundtrip.cpp
@@ -0,0 +1,26 @@
+//
+// $Id$
+//
+#include "Roundtrip.h"
+
+ACE_RCSID(Single_Threaded_Latency, Roundtrip, "$Id$")
+
+Roundtrip::Roundtrip (CORBA::ORB_ptr orb)
+  : orb_ (CORBA::ORB::_duplicate (orb))
+{
+}
+
+Test::Timestamp
+Roundtrip::test_method (Test::Timestamp send_time
+                        ACE_ENV_ARG_DECL_NOT_USED)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return send_time;
+}
+
+void
+Roundtrip::shutdown (ACE_ENV_SINGLE_ARG_DECL)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER);
+}
diff --git a/TAO/performance-tests/Single_Threaded_Latency/Roundtrip.h b/TAO/performance-tests/Single_Threaded_Latency/Roundtrip.h
new file mode 100644
index 00000000000..efef33dd7e6
--- /dev/null
+++ b/TAO/performance-tests/Single_Threaded_Latency/Roundtrip.h
@@ -0,0 +1,46 @@
+//
+// $Id$
+//
+
+#ifndef ROUNDTRIP_H
+#define ROUNDTRIP_H
+#include "ace/pre.h"
+
+#include "TestS.h"
+
+#if defined (_MSC_VER)
+# if (_MSC_VER >= 1200)
+#  pragma warning(push)
+# endif /* _MSC_VER >= 1200 */
+# pragma warning (disable:4250)
+#endif /* _MSC_VER */
+
+/// Implement the Test::Roundtrip interface
+class Roundtrip
+  : public virtual POA_Test::Roundtrip
+  , public virtual PortableServer::RefCountServantBase
+{
+public:
+  /// Constructor
+  Roundtrip (CORBA::ORB_ptr orb);
+
+  // = The skeleton methods
+  virtual Test::Timestamp test_method (Test::Timestamp send_time
+                                       ACE_ENV_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+private:
+  /// Use an ORB reference to conver strings to objects and shutdown
+  /// the application.
+  CORBA::ORB_var orb_;
+};
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma warning(pop)
+#endif /* _MSC_VER */
+
+#include "ace/post.h"
+#endif /* ROUNDTRIP_H */
diff --git a/TAO/performance-tests/Single_Threaded_Latency/client.cpp b/TAO/performance-tests/Single_Threaded_Latency/client.cpp
new file mode 100644
index 00000000000..2d841b9909d
--- /dev/null
+++ b/TAO/performance-tests/Single_Threaded_Latency/client.cpp
@@ -0,0 +1,164 @@
+// $Id$
+
+#include "TestC.h"
+#include "ace/Get_Opt.h"
+#include "ace/High_Res_Timer.h"
+#include "ace/Sched_Params.h"
+#include "ace/Stats.h"
+#include "ace/Sample_History.h"
+
+#include "tao/Strategies/advanced_resource.h"
+
+ACE_RCSID(Single_Threaded_Latency, client, "$Id$")
+
+const char *ior = "file://test.ior";
+int niterations = 100;
+int do_dump_history = 0;
+int do_shutdown = 1;
+
+int
+parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "hxk:i:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'h':
+        do_dump_history = 1;
+        break;
+
+      case 'x':
+        do_shutdown = 0;
+        break;
+
+      case 'k':
+        ior = get_opts.opt_arg ();
+        break;
+
+      case 'i':
+        niterations = ACE_OS::atoi (get_opts.opt_arg ());
+        break;
+
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-k <ior> "
+                           "-i <niterations> "
+                           "-x (disable shutdown) "
+                           "-h (dump history) "
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int priority =
+    (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
+     + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
+  // 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,
+                      "client (%P|%t): user is not superuser, "
+                      "test runs in time-shared class\n"));
+        }
+      else
+        ACE_ERROR ((LM_ERROR,
+                    "client (%P|%t): sched_params failed\n"));
+    }
+
+  ACE_TRY_NEW_ENV
+    {
+      CORBA::ORB_var orb =
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (parse_args (argc, argv) != 0)
+        return 1;
+
+      CORBA::Object_var object =
+        orb->string_to_object (ior ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      Test::Roundtrip_var roundtrip =
+        Test::Roundtrip::_narrow (object.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (CORBA::is_nil (roundtrip.in ()))
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "Nil Test::Roundtrip reference <%s>\n",
+                             ior),
+                            1);
+        }
+
+      for (int j = 0; j < 100; ++j)
+        {
+          ACE_hrtime_t start = 0;
+          (void) roundtrip->test_method (start ACE_ENV_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+        }
+
+      ACE_Sample_History history (niterations);
+
+      ACE_hrtime_t test_start = ACE_OS::gethrtime ();
+      for (int i = 0; i < niterations; ++i)
+        {
+          ACE_hrtime_t start = ACE_OS::gethrtime ();
+
+          (void) roundtrip->test_method (start ACE_ENV_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+
+          ACE_hrtime_t now = ACE_OS::gethrtime ();
+          history.sample (now - start);
+        }
+
+      ACE_hrtime_t test_end = ACE_OS::gethrtime ();
+
+      ACE_DEBUG ((LM_DEBUG, "test finished\n"));
+
+      ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
+      ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor ();
+      ACE_DEBUG ((LM_DEBUG, "done\n"));
+
+      if (do_dump_history)
+        {
+          history.dump_samples ("HISTORY", gsf);
+        }
+
+      ACE_Basic_Stats stats;
+      history.collect_basic_stats (stats);
+      stats.dump_results ("Total", gsf);
+
+      ACE_Throughput_Stats::dump_throughput ("Total", gsf,
+                                             test_end - test_start,
+                                             stats.samples_count ());
+
+      if (do_shutdown)
+        {
+          roundtrip->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+        }
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/performance-tests/Single_Threaded_Latency/server.cpp b/TAO/performance-tests/Single_Threaded_Latency/server.cpp
new file mode 100644
index 00000000000..e96f0ff595a
--- /dev/null
+++ b/TAO/performance-tests/Single_Threaded_Latency/server.cpp
@@ -0,0 +1,136 @@
+// $Id$
+
+#include "Roundtrip.h"
+#include "ace/Get_Opt.h"
+#include "ace/Sched_Params.h"
+
+#include "tao/Strategies/advanced_resource.h"
+
+ACE_RCSID(Single_Threaded_Latency, server, "$Id$")
+
+const char *ior_output_file = "test.ior";
+
+int
+parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "o:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'o':
+        ior_output_file = get_opts.opt_arg ();
+        break;
+
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-o <iorfile>"
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  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_TRY_NEW_ENV
+    {
+      CORBA::ORB_var orb =
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::Object_var poa_object =
+        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (CORBA::is_nil (poa_object.in ()))
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           " (%P|%t) Unable to initialize the POA.\n"),
+                          1);
+
+      PortableServer::POA_var root_poa =
+        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      PortableServer::POAManager_var poa_manager =
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (parse_args (argc, argv) != 0)
+        return 1;
+
+      Roundtrip *roundtrip_impl;
+      ACE_NEW_RETURN (roundtrip_impl,
+                      Roundtrip (orb.in ()),
+                      1);
+      PortableServer::ServantBase_var owner_transfer(roundtrip_impl);
+
+      Test::Roundtrip_var roundtrip =
+        roundtrip_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::String_var ior =
+        orb->object_to_string (roundtrip.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      // If the ior_output_file exists, output the ior to it
+      FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
+      if (output_file == 0)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "Cannot open output file for writing IOR: %s",
+                           ior_output_file),
+                          1);
+      ACE_OS::fprintf (output_file, "%s", ior.in ());
+      ACE_OS::fclose (output_file);
+
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      orb->run (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
+
+      root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/performance-tests/Thread_Per_Connection_Latency/Client_Task.cpp b/TAO/performance-tests/Thread_Per_Connection_Latency/Client_Task.cpp
new file mode 100644
index 00000000000..09d15331436
--- /dev/null
+++ b/TAO/performance-tests/Thread_Per_Connection_Latency/Client_Task.cpp
@@ -0,0 +1,65 @@
+//
+// $Id$
+//
+#include "Client_Task.h"
+
+ACE_RCSID(Thread_Per_Connection_Latency, Client_Task, "$Id$")
+
+Client_Task::Client_Task (Test::Roundtrip_ptr roundtrip,
+                          int niterations)
+  : roundtrip_ (Test::Roundtrip::_duplicate (roundtrip))
+  , niterations_ (niterations)
+{
+}
+
+int
+Client_Task::svc (void)
+{
+  ACE_DECLARE_NEW_CORBA_ENV;
+  ACE_TRY
+    {
+      this->validate_connection (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      for (int i = 0; i != this->niterations_; ++i)
+        {
+          CORBA::ULongLong start = ACE_OS::gethrtime ();
+
+          (void) this->roundtrip_->test_method (start ACE_ENV_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+
+          ACE_hrtime_t now = ACE_OS::gethrtime ();
+          this->latency_.sample (now - start);
+        }
+    }
+  ACE_CATCHANY
+    {
+      return 0;
+    }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void
+Client_Task::accumulate_and_dump (ACE_Basic_Stats &totals,
+                                  const char *msg,
+                                  ACE_UINT32 gsf)
+{
+  totals.accumulate (this->latency_);
+  this->latency_.dump_results (msg, gsf);
+}
+
+void
+Client_Task::validate_connection (ACE_ENV_SINGLE_ARG_DECL)
+{
+  CORBA::ULongLong dummy = 0;
+  for (int i = 0; i != 100; ++i)
+    {
+      ACE_TRY
+        {
+          (void) this->roundtrip_->test_method (dummy ACE_ENV_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY {} ACE_ENDTRY;
+    }
+}
diff --git a/TAO/performance-tests/Thread_Per_Connection_Latency/Client_Task.h b/TAO/performance-tests/Thread_Per_Connection_Latency/Client_Task.h
new file mode 100644
index 00000000000..ffc4e9d6b6a
--- /dev/null
+++ b/TAO/performance-tests/Thread_Per_Connection_Latency/Client_Task.h
@@ -0,0 +1,46 @@
+//
+// $Id$
+//
+
+#ifndef CLIENT_TASK_H
+#define CLIENT_TASK_H
+#include "ace/pre.h"
+
+#include "TestC.h"
+#include "ace/Task.h"
+#include "ace/Basic_Stats.h"
+
+/// Implement the Test::Client_Task interface
+class Client_Task : public ACE_Task_Base
+{
+public:
+  /// Constructor
+  Client_Task (Test::Roundtrip_ptr roundtrip,
+               int niterations);
+
+  /// Add this thread results to the global numbers and print the
+  /// per-thread results.
+  void accumulate_and_dump (ACE_Basic_Stats &totals,
+                            const char *msg,
+                            ACE_UINT32 gsf);
+
+  /// The service method
+  virtual int svc (void);
+
+private:
+  /// Make sure that the current thread has a connection available.
+  void validate_connection (ACE_ENV_SINGLE_ARG_DECL);
+
+private:
+  /// The object reference used for this test
+  Test::Roundtrip_var roundtrip_;
+
+  /// The number of iterations
+  int niterations_;
+
+  /// Keep track of the latency (minimum, average, maximum and jitter)
+  ACE_Basic_Stats latency_;
+};
+
+#include "ace/post.h"
+#endif /* CLIENT_TASK_H */
diff --git a/TAO/performance-tests/Thread_Per_Connection_Latency/Roundtrip.cpp b/TAO/performance-tests/Thread_Per_Connection_Latency/Roundtrip.cpp
new file mode 100644
index 00000000000..2bc67948fd0
--- /dev/null
+++ b/TAO/performance-tests/Thread_Per_Connection_Latency/Roundtrip.cpp
@@ -0,0 +1,26 @@
+//
+// $Id$
+//
+#include "Roundtrip.h"
+
+ACE_RCSID(Single_Per_Connection_Latency, Roundtrip, "$Id$")
+
+Roundtrip::Roundtrip (CORBA::ORB_ptr orb)
+  : orb_ (CORBA::ORB::_duplicate (orb))
+{
+}
+
+Test::Timestamp
+Roundtrip::test_method (Test::Timestamp send_time
+                        ACE_ENV_ARG_DECL_NOT_USED)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return send_time;
+}
+
+void
+Roundtrip::shutdown (ACE_ENV_SINGLE_ARG_DECL)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER);
+}
diff --git a/TAO/performance-tests/Thread_Per_Connection_Latency/Roundtrip.h b/TAO/performance-tests/Thread_Per_Connection_Latency/Roundtrip.h
new file mode 100644
index 00000000000..efef33dd7e6
--- /dev/null
+++ b/TAO/performance-tests/Thread_Per_Connection_Latency/Roundtrip.h
@@ -0,0 +1,46 @@
+//
+// $Id$
+//
+
+#ifndef ROUNDTRIP_H
+#define ROUNDTRIP_H
+#include "ace/pre.h"
+
+#include "TestS.h"
+
+#if defined (_MSC_VER)
+# if (_MSC_VER >= 1200)
+#  pragma warning(push)
+# endif /* _MSC_VER >= 1200 */
+# pragma warning (disable:4250)
+#endif /* _MSC_VER */
+
+/// Implement the Test::Roundtrip interface
+class Roundtrip
+  : public virtual POA_Test::Roundtrip
+  , public virtual PortableServer::RefCountServantBase
+{
+public:
+  /// Constructor
+  Roundtrip (CORBA::ORB_ptr orb);
+
+  // = The skeleton methods
+  virtual Test::Timestamp test_method (Test::Timestamp send_time
+                                       ACE_ENV_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+private:
+  /// Use an ORB reference to conver strings to objects and shutdown
+  /// the application.
+  CORBA::ORB_var orb_;
+};
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma warning(pop)
+#endif /* _MSC_VER */
+
+#include "ace/post.h"
+#endif /* ROUNDTRIP_H */
diff --git a/TAO/performance-tests/Thread_Per_Connection_Latency/client.cpp b/TAO/performance-tests/Thread_Per_Connection_Latency/client.cpp
new file mode 100644
index 00000000000..69aac2b4ca5
--- /dev/null
+++ b/TAO/performance-tests/Thread_Per_Connection_Latency/client.cpp
@@ -0,0 +1,149 @@
+// $Id$
+
+#include "Client_Task.h"
+#include "ace/Get_Opt.h"
+#include "ace/High_Res_Timer.h"
+#include "ace/Sched_Params.h"
+#include "ace/Stats.h"
+
+#include "tao/Strategies/advanced_resource.h"
+
+ACE_RCSID(Thread_Per_Connection_Latency, client, "$Id$")
+
+const char *ior = "file://test.ior";
+int niterations = 1000;
+int do_shutdown = 1;
+
+int
+parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "xk:i:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'x':
+        do_shutdown = 0;
+        break;
+
+      case 'k':
+        ior = get_opts.opt_arg ();
+        break;
+
+      case 'i':
+        niterations = ACE_OS::atoi (get_opts.opt_arg ());
+        break;
+
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-k <ior> "
+                           "-i <niterations> "
+                           "-x (disable shutdown) "
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int priority =
+    (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
+     + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
+  // 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,
+                      "client (%P|%t): user is not superuser, "
+                      "test runs in time-shared class\n"));
+        }
+      else
+        ACE_ERROR ((LM_ERROR,
+                    "client (%P|%t): sched_params failed\n"));
+    }
+
+  ACE_TRY_NEW_ENV
+    {
+      CORBA::ORB_var orb =
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (parse_args (argc, argv) != 0)
+        return 1;
+
+      CORBA::Object_var object =
+        orb->string_to_object (ior ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      Test::Roundtrip_var roundtrip =
+        Test::Roundtrip::_narrow (object.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (CORBA::is_nil (roundtrip.in ()))
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "Nil Test::Roundtrip reference <%s>\n",
+                             ior),
+                            1);
+        }
+
+      ACE_DEBUG ((LM_DEBUG, "Starting threads\n"));
+
+      Client_Task task0(roundtrip.in (), niterations);
+      Client_Task task1(roundtrip.in (), niterations);
+      Client_Task task2(roundtrip.in (), niterations);
+      Client_Task task3(roundtrip.in (), niterations);
+
+      ACE_hrtime_t test_start = ACE_OS::gethrtime ();
+      task0.activate(THR_NEW_LWP | THR_JOINABLE);
+      task1.activate(THR_NEW_LWP | THR_JOINABLE);
+      task2.activate(THR_NEW_LWP | THR_JOINABLE);
+      task3.activate(THR_NEW_LWP | THR_JOINABLE);
+
+      task0.thr_mgr()->wait ();
+      ACE_hrtime_t test_end = ACE_OS::gethrtime ();
+
+      ACE_DEBUG ((LM_DEBUG, "Threads finished\n"));
+
+      ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
+      ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor ();
+      ACE_DEBUG ((LM_DEBUG, "done\n"));
+
+      ACE_Basic_Stats totals;
+      task0.accumulate_and_dump (totals, "Task[0]", gsf);
+      task1.accumulate_and_dump (totals, "Task[1]", gsf);
+      task2.accumulate_and_dump (totals, "Task[2]", gsf);
+      task3.accumulate_and_dump (totals, "Task[3]", gsf);
+
+      totals.dump_results ("Total", gsf);
+
+      ACE_Throughput_Stats::dump_throughput ("Total", gsf,
+                                             test_end - test_start,
+                                             totals.samples_count ());
+
+      if (do_shutdown)
+        {
+          roundtrip->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+        }
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/performance-tests/Thread_Per_Connection_Latency/server.cpp b/TAO/performance-tests/Thread_Per_Connection_Latency/server.cpp
new file mode 100644
index 00000000000..004ce70cebf
--- /dev/null
+++ b/TAO/performance-tests/Thread_Per_Connection_Latency/server.cpp
@@ -0,0 +1,136 @@
+// $Id$
+
+#include "Roundtrip.h"
+#include "ace/Get_Opt.h"
+#include "ace/Sched_Params.h"
+
+#include "tao/Strategies/advanced_resource.h"
+
+ACE_RCSID(Thread_Per_Connection_Latency, server, "$Id$")
+
+const char *ior_output_file = "test.ior";
+
+int
+parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "o:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'o':
+        ior_output_file = get_opts.opt_arg ();
+        break;
+
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-o <iorfile>"
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  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_TRY_NEW_ENV
+    {
+      CORBA::ORB_var orb =
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::Object_var poa_object =
+        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (CORBA::is_nil (poa_object.in ()))
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           " (%P|%t) Unable to initialize the POA.\n"),
+                          1);
+
+      PortableServer::POA_var root_poa =
+        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      PortableServer::POAManager_var poa_manager =
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (parse_args (argc, argv) != 0)
+        return 1;
+
+      Roundtrip *roundtrip_impl;
+      ACE_NEW_RETURN (roundtrip_impl,
+                      Roundtrip (orb.in ()),
+                      1);
+      PortableServer::ServantBase_var owner_transfer(roundtrip_impl);
+
+      Test::Roundtrip_var roundtrip =
+        roundtrip_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::String_var ior =
+        orb->object_to_string (roundtrip.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      // If the ior_output_file exists, output the ior to it
+      FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
+      if (output_file == 0)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "Cannot open output file for writing IOR: %s",
+                           ior_output_file),
+                          1);
+      ACE_OS::fprintf (output_file, "%s", ior.in ());
+      ACE_OS::fclose (output_file);
+
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      orb->run (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
+
+      root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/performance-tests/Thread_Pool_Latency/Client_Task.cpp b/TAO/performance-tests/Thread_Pool_Latency/Client_Task.cpp
new file mode 100644
index 00000000000..efb544633b2
--- /dev/null
+++ b/TAO/performance-tests/Thread_Pool_Latency/Client_Task.cpp
@@ -0,0 +1,65 @@
+//
+// $Id$
+//
+#include "Client_Task.h"
+
+ACE_RCSID(Thread_Pool_Latency, Client_Task, "$Id$")
+
+Client_Task::Client_Task (Test::Roundtrip_ptr roundtrip,
+                          int niterations)
+  : roundtrip_ (Test::Roundtrip::_duplicate (roundtrip))
+  , niterations_ (niterations)
+{
+}
+
+int
+Client_Task::svc (void)
+{
+  ACE_DECLARE_NEW_CORBA_ENV;
+  ACE_TRY
+    {
+      this->validate_connection (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      for (int i = 0; i != this->niterations_; ++i)
+        {
+          CORBA::ULongLong start = ACE_OS::gethrtime ();
+
+          (void) this->roundtrip_->test_method (start ACE_ENV_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+
+          ACE_hrtime_t now = ACE_OS::gethrtime ();
+          this->latency_.sample (now - start);
+        }
+    }
+  ACE_CATCHANY
+    {
+      return 0;
+    }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void
+Client_Task::accumulate_and_dump (ACE_Basic_Stats &totals,
+                                  const char *msg,
+                                  ACE_UINT32 gsf)
+{
+  totals.accumulate (this->latency_);
+  this->latency_.dump_results (msg, gsf);
+}
+
+void
+Client_Task::validate_connection (ACE_ENV_SINGLE_ARG_DECL)
+{
+  CORBA::ULongLong dummy = 0;
+  for (int i = 0; i != 100; ++i)
+    {
+      ACE_TRY
+        {
+          (void) this->roundtrip_->test_method (dummy ACE_ENV_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+        }
+      ACE_CATCHANY {} ACE_ENDTRY;
+    }
+}
diff --git a/TAO/performance-tests/Thread_Pool_Latency/Client_Task.h b/TAO/performance-tests/Thread_Pool_Latency/Client_Task.h
new file mode 100644
index 00000000000..ffc4e9d6b6a
--- /dev/null
+++ b/TAO/performance-tests/Thread_Pool_Latency/Client_Task.h
@@ -0,0 +1,46 @@
+//
+// $Id$
+//
+
+#ifndef CLIENT_TASK_H
+#define CLIENT_TASK_H
+#include "ace/pre.h"
+
+#include "TestC.h"
+#include "ace/Task.h"
+#include "ace/Basic_Stats.h"
+
+/// Implement the Test::Client_Task interface
+class Client_Task : public ACE_Task_Base
+{
+public:
+  /// Constructor
+  Client_Task (Test::Roundtrip_ptr roundtrip,
+               int niterations);
+
+  /// Add this thread results to the global numbers and print the
+  /// per-thread results.
+  void accumulate_and_dump (ACE_Basic_Stats &totals,
+                            const char *msg,
+                            ACE_UINT32 gsf);
+
+  /// The service method
+  virtual int svc (void);
+
+private:
+  /// Make sure that the current thread has a connection available.
+  void validate_connection (ACE_ENV_SINGLE_ARG_DECL);
+
+private:
+  /// The object reference used for this test
+  Test::Roundtrip_var roundtrip_;
+
+  /// The number of iterations
+  int niterations_;
+
+  /// Keep track of the latency (minimum, average, maximum and jitter)
+  ACE_Basic_Stats latency_;
+};
+
+#include "ace/post.h"
+#endif /* CLIENT_TASK_H */
diff --git a/TAO/performance-tests/Thread_Pool_Latency/Roundtrip.cpp b/TAO/performance-tests/Thread_Pool_Latency/Roundtrip.cpp
new file mode 100644
index 00000000000..6028512202c
--- /dev/null
+++ b/TAO/performance-tests/Thread_Pool_Latency/Roundtrip.cpp
@@ -0,0 +1,26 @@
+//
+// $Id$
+//
+#include "Roundtrip.h"
+
+ACE_RCSID(Thread_Pool_Latency, Roundtrip, "$Id$")
+
+Roundtrip::Roundtrip (CORBA::ORB_ptr orb)
+  : orb_ (CORBA::ORB::_duplicate (orb))
+{
+}
+
+Test::Timestamp
+Roundtrip::test_method (Test::Timestamp send_time
+                        ACE_ENV_ARG_DECL_NOT_USED)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return send_time;
+}
+
+void
+Roundtrip::shutdown (ACE_ENV_SINGLE_ARG_DECL)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER);
+}
diff --git a/TAO/performance-tests/Thread_Pool_Latency/Roundtrip.h b/TAO/performance-tests/Thread_Pool_Latency/Roundtrip.h
new file mode 100644
index 00000000000..efef33dd7e6
--- /dev/null
+++ b/TAO/performance-tests/Thread_Pool_Latency/Roundtrip.h
@@ -0,0 +1,46 @@
+//
+// $Id$
+//
+
+#ifndef ROUNDTRIP_H
+#define ROUNDTRIP_H
+#include "ace/pre.h"
+
+#include "TestS.h"
+
+#if defined (_MSC_VER)
+# if (_MSC_VER >= 1200)
+#  pragma warning(push)
+# endif /* _MSC_VER >= 1200 */
+# pragma warning (disable:4250)
+#endif /* _MSC_VER */
+
+/// Implement the Test::Roundtrip interface
+class Roundtrip
+  : public virtual POA_Test::Roundtrip
+  , public virtual PortableServer::RefCountServantBase
+{
+public:
+  /// Constructor
+  Roundtrip (CORBA::ORB_ptr orb);
+
+  // = The skeleton methods
+  virtual Test::Timestamp test_method (Test::Timestamp send_time
+                                       ACE_ENV_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+  virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL)
+    ACE_THROW_SPEC ((CORBA::SystemException));
+
+private:
+  /// Use an ORB reference to conver strings to objects and shutdown
+  /// the application.
+  CORBA::ORB_var orb_;
+};
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma warning(pop)
+#endif /* _MSC_VER */
+
+#include "ace/post.h"
+#endif /* ROUNDTRIP_H */
diff --git a/TAO/performance-tests/Thread_Pool_Latency/Worker_Thread.cpp b/TAO/performance-tests/Thread_Pool_Latency/Worker_Thread.cpp
new file mode 100644
index 00000000000..e485bb2b843
--- /dev/null
+++ b/TAO/performance-tests/Thread_Pool_Latency/Worker_Thread.cpp
@@ -0,0 +1,24 @@
+//
+// $Id$
+//
+#include "Worker_Thread.h"
+
+ACE_RCSID(Thread_Pool_Latency, Worker_Thread, "$Id$")
+
+Worker_Thread::Worker_Thread (CORBA::ORB_ptr orb)
+  : orb_ (CORBA::ORB::_duplicate (orb))
+{
+}
+
+int
+Worker_Thread::svc (void)
+{
+  ACE_DECLARE_NEW_CORBA_ENV;
+  ACE_TRY
+    {
+      this->orb_->run (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCHANY {} ACE_ENDTRY;
+  return 0;
+}
diff --git a/TAO/performance-tests/Thread_Pool_Latency/client.cpp b/TAO/performance-tests/Thread_Pool_Latency/client.cpp
new file mode 100644
index 00000000000..643f541a53f
--- /dev/null
+++ b/TAO/performance-tests/Thread_Pool_Latency/client.cpp
@@ -0,0 +1,149 @@
+// $Id$
+
+#include "Client_Task.h"
+#include "ace/Get_Opt.h"
+#include "ace/High_Res_Timer.h"
+#include "ace/Sched_Params.h"
+#include "ace/Stats.h"
+
+#include "tao/Strategies/advanced_resource.h"
+
+ACE_RCSID(Thread_Pool_Latency, client, "$Id$")
+
+const char *ior = "file://test.ior";
+int niterations = 1000;
+int do_shutdown = 1;
+
+int
+parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "xk:i:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'x':
+        do_shutdown = 0;
+        break;
+
+      case 'k':
+        ior = get_opts.opt_arg ();
+        break;
+
+      case 'i':
+        niterations = ACE_OS::atoi (get_opts.opt_arg ());
+        break;
+
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-k <ior> "
+                           "-i <niterations> "
+                           "-x (disable shutdown) "
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int priority =
+    (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
+     + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;
+  // 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,
+                      "client (%P|%t): user is not superuser, "
+                      "test runs in time-shared class\n"));
+        }
+      else
+        ACE_ERROR ((LM_ERROR,
+                    "client (%P|%t): sched_params failed\n"));
+    }
+
+  ACE_TRY_NEW_ENV
+    {
+      CORBA::ORB_var orb =
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (parse_args (argc, argv) != 0)
+        return 1;
+
+      CORBA::Object_var object =
+        orb->string_to_object (ior ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      Test::Roundtrip_var roundtrip =
+        Test::Roundtrip::_narrow (object.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (CORBA::is_nil (roundtrip.in ()))
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "Nil Test::Roundtrip reference <%s>\n",
+                             ior),
+                            1);
+        }
+
+      ACE_DEBUG ((LM_DEBUG, "Starting threads\n"));
+
+      Client_Task task0(roundtrip.in (), niterations);
+      Client_Task task1(roundtrip.in (), niterations);
+      Client_Task task2(roundtrip.in (), niterations);
+      Client_Task task3(roundtrip.in (), niterations);
+
+      ACE_hrtime_t test_start = ACE_OS::gethrtime ();
+      task0.activate(THR_NEW_LWP | THR_JOINABLE);
+      task1.activate(THR_NEW_LWP | THR_JOINABLE);
+      task2.activate(THR_NEW_LWP | THR_JOINABLE);
+      task3.activate(THR_NEW_LWP | THR_JOINABLE);
+
+      task0.thr_mgr()->wait ();
+      ACE_hrtime_t test_end = ACE_OS::gethrtime ();
+
+      ACE_DEBUG ((LM_DEBUG, "Threads finished\n"));
+
+      ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration...."));
+      ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor ();
+      ACE_DEBUG ((LM_DEBUG, "done\n"));
+
+      ACE_Basic_Stats totals;
+      task0.accumulate_and_dump (totals, "Task[0]", gsf);
+      task1.accumulate_and_dump (totals, "Task[1]", gsf);
+      task2.accumulate_and_dump (totals, "Task[2]", gsf);
+      task3.accumulate_and_dump (totals, "Task[3]", gsf);
+
+      totals.dump_results ("Total", gsf);
+
+      ACE_Throughput_Stats::dump_throughput ("Total", gsf,
+                                             test_end - test_start,
+                                             totals.samples_count ());
+
+      if (do_shutdown)
+        {
+          roundtrip->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
+          ACE_TRY_CHECK;
+        }
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/performance-tests/Thread_Pool_Latency/server.cpp b/TAO/performance-tests/Thread_Pool_Latency/server.cpp
new file mode 100644
index 00000000000..bcacaf713c2
--- /dev/null
+++ b/TAO/performance-tests/Thread_Pool_Latency/server.cpp
@@ -0,0 +1,139 @@
+// $Id$
+
+#include "Roundtrip.h"
+#include "Worker_Thread.h"
+#include "ace/Get_Opt.h"
+#include "ace/Sched_Params.h"
+
+#include "tao/Strategies/advanced_resource.h"
+
+ACE_RCSID(Thread_Pool_Latency, server, "$Id$")
+
+const char *ior_output_file = "test.ior";
+
+int
+parse_args (int argc, char *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, "o:");
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'o':
+        ior_output_file = get_opts.opt_arg ();
+        break;
+
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-o <iorfile>"
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates sucessful parsing of the command line
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  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_TRY_NEW_ENV
+    {
+      CORBA::ORB_var orb =
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::Object_var poa_object =
+        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (CORBA::is_nil (poa_object.in ()))
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           " (%P|%t) Unable to initialize the POA.\n"),
+                          1);
+
+      PortableServer::POA_var root_poa =
+        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      PortableServer::POAManager_var poa_manager =
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      if (parse_args (argc, argv) != 0)
+        return 1;
+
+      Roundtrip *roundtrip_impl;
+      ACE_NEW_RETURN (roundtrip_impl,
+                      Roundtrip (orb.in ()),
+                      1);
+      PortableServer::ServantBase_var owner_transfer(roundtrip_impl);
+
+      Test::Roundtrip_var roundtrip =
+        roundtrip_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      CORBA::String_var ior =
+        orb->object_to_string (roundtrip.in () ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      // If the ior_output_file exists, output the ior to it
+      FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
+      if (output_file == 0)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "Cannot open output file for writing IOR: %s",
+                           ior_output_file),
+                          1);
+      ACE_OS::fprintf (output_file, "%s", ior.in ());
+      ACE_OS::fclose (output_file);
+
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      Worker_Thread worker (orb.in ());
+
+      worker.activate (THR_NEW_LWP | THR_JOINABLE, 4, 1);
+      worker.thr_mgr ()->wait ();
+
+      ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
+
+      root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+    }
+  ACE_CATCHANY
+    {
+      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:");
+      return 1;
+    }
+  ACE_ENDTRY;
+
+  return 0;
+}
diff --git a/TAO/performance-tests/Throughput/Receiver.cpp b/TAO/performance-tests/Throughput/Receiver.cpp
index 05b0fe9a001..79ac824f5d4 100644
--- a/TAO/performance-tests/Throughput/Receiver.cpp
+++ b/TAO/performance-tests/Throughput/Receiver.cpp
@@ -18,7 +18,7 @@ Receiver::Receiver (void)
 
 void
 Receiver::receive_data (const Test::Message &the_message
-                        TAO_ENV_ARG_DECL_NOT_USED)
+                        ACE_ENV_ARG_DECL_NOT_USED)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_hrtime_t now = ACE_OS::gethrtime ();
@@ -45,7 +45,7 @@ Receiver::receive_data (const Test::Message &the_message
 }
 
 void
-Receiver::done (TAO_ENV_SINGLE_ARG_DECL)
+Receiver::done (ACE_ENV_SINGLE_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   if (this->message_count_ == 0)
@@ -87,12 +87,12 @@ Receiver::done (TAO_ENV_SINGLE_ARG_DECL)
 
   ACE_TRY
     {
-      PortableServer::POA_var poa = this->_default_POA (TAO_ENV_SINGLE_ARG_PARAMETER);
+      PortableServer::POA_var poa = this->_default_POA (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
       PortableServer::ObjectId_var oid =
-        poa->servant_to_id (this TAO_ENV_ARG_PARAMETER);
+        poa->servant_to_id (this ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
-      poa->deactivate_object (oid.in () TAO_ENV_ARG_PARAMETER);
+      poa->deactivate_object (oid.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY {} ACE_ENDTRY;
diff --git a/TAO/performance-tests/Throughput/Receiver.h b/TAO/performance-tests/Throughput/Receiver.h
index ab15144cacb..8217c7d6505 100644
--- a/TAO/performance-tests/Throughput/Receiver.h
+++ b/TAO/performance-tests/Throughput/Receiver.h
@@ -26,10 +26,10 @@ public:
 
   // = The skeleton methods
   virtual void receive_data (const Test::Message &message
-                             TAO_ENV_ARG_DECL)
+                             ACE_ENV_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual void done (TAO_ENV_SINGLE_ARG_DECL)
+  virtual void done (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
 private:
diff --git a/TAO/performance-tests/Throughput/Receiver_Factory.cpp b/TAO/performance-tests/Throughput/Receiver_Factory.cpp
index 059a7d3bd6b..c804588b9b6 100644
--- a/TAO/performance-tests/Throughput/Receiver_Factory.cpp
+++ b/TAO/performance-tests/Throughput/Receiver_Factory.cpp
@@ -12,7 +12,7 @@ Receiver_Factory::Receiver_Factory (CORBA::ORB_ptr orb)
 }
 
 Test::Receiver_ptr
-Receiver_Factory::create_receiver (TAO_ENV_SINGLE_ARG_DECL)
+Receiver_Factory::create_receiver (ACE_ENV_SINGLE_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   Receiver *receiver_impl;
@@ -22,12 +22,12 @@ Receiver_Factory::create_receiver (TAO_ENV_SINGLE_ARG_DECL)
   ACE_CHECK_RETURN (Test::Receiver::_nil ());
   PortableServer::ServantBase_var transfer_ownership(receiver_impl);
 
-  return receiver_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER);
+  return receiver_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
 }
 
 void
-Receiver_Factory::shutdown (TAO_ENV_SINGLE_ARG_DECL)
+Receiver_Factory::shutdown (ACE_ENV_SINGLE_ARG_DECL)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER);
+  this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER);
 }
diff --git a/TAO/performance-tests/Throughput/Receiver_Factory.h b/TAO/performance-tests/Throughput/Receiver_Factory.h
index 0b557ad4f09..05ef98836cb 100644
--- a/TAO/performance-tests/Throughput/Receiver_Factory.h
+++ b/TAO/performance-tests/Throughput/Receiver_Factory.h
@@ -25,10 +25,10 @@ public:
   Receiver_Factory (CORBA::ORB_ptr orb);
 
   // = The skeleton methods
-  virtual Test::Receiver_ptr create_receiver (TAO_ENV_SINGLE_ARG_DECL)
+  virtual Test::Receiver_ptr create_receiver (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
-  virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL)
+  virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL)
     ACE_THROW_SPEC ((CORBA::SystemException));
 
 private:
diff --git a/TAO/performance-tests/Throughput/client.cpp b/TAO/performance-tests/Throughput/client.cpp
index e5ffb8b70fa..9d879e772d0 100644
--- a/TAO/performance-tests/Throughput/client.cpp
+++ b/TAO/performance-tests/Throughput/client.cpp
@@ -64,18 +64,18 @@ main (int argc, char *argv[])
   ACE_TRY_NEW_ENV
     {
       CORBA::ORB_var orb =
-        CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER);
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (parse_args (argc, argv) != 0)
         return 1;
 
       CORBA::Object_var tmp =
-        orb->string_to_object(ior TAO_ENV_ARG_PARAMETER);
+        orb->string_to_object(ior ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       Test::Receiver_Factory_var receiver_factory =
-        Test::Receiver_Factory::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER);
+        Test::Receiver_Factory::_narrow(tmp.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (receiver_factory.in ()))
@@ -100,18 +100,18 @@ main (int argc, char *argv[])
           message.the_payload.length (message_size);
 
           Test::Receiver_var receiver =
-            receiver_factory->create_receiver (TAO_ENV_SINGLE_ARG_PARAMETER);
+            receiver_factory->create_receiver (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
 
           ACE_hrtime_t start = ACE_OS::gethrtime ();
           for (int i = 0; i != message_count; ++i)
             {
               message.message_id = i;
-              receiver->receive_data (message TAO_ENV_ARG_PARAMETER);
+              receiver->receive_data (message ACE_ENV_ARG_PARAMETER);
               ACE_TRY_CHECK;
             }
 
-          receiver->done (TAO_ENV_SINGLE_ARG_PARAMETER);
+          receiver->done (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
           ACE_hrtime_t elapsed_time = ACE_OS::gethrtime () - start;
 
@@ -140,11 +140,11 @@ main (int argc, char *argv[])
 
       if (do_shutdown)
         {
-          receiver_factory->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER);
+          receiver_factory->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER);
           ACE_TRY_CHECK;
         }
 
-      orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY
diff --git a/TAO/performance-tests/Throughput/server.cpp b/TAO/performance-tests/Throughput/server.cpp
index 467c3cbe003..68afc375a0d 100644
--- a/TAO/performance-tests/Throughput/server.cpp
+++ b/TAO/performance-tests/Throughput/server.cpp
@@ -39,11 +39,11 @@ main (int argc, char *argv[])
   ACE_TRY_NEW_ENV
     {
       CORBA::ORB_var orb =
-        CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER);
+        CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::Object_var poa_object =
-        orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER);
+        orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (poa_object.in ()))
@@ -52,11 +52,11 @@ main (int argc, char *argv[])
                           1);
 
       PortableServer::POA_var root_poa =
-        PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER);
+        PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       PortableServer::POAManager_var poa_manager =
-        root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER);
+        root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       if (parse_args (argc, argv) != 0)
@@ -69,11 +69,11 @@ main (int argc, char *argv[])
       PortableServer::ServantBase_var receiver_factory_owner_transfer(receiver_factory_impl);
 
       Test::Receiver_Factory_var receiver_factory =
-        receiver_factory_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER);
+        receiver_factory_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       CORBA::String_var ior =
-        orb->object_to_string (receiver_factory.in () TAO_ENV_ARG_PARAMETER);
+        orb->object_to_string (receiver_factory.in () ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       // If the ior_output_file exists, output the ior to it
@@ -86,18 +86,18 @@ main (int argc, char *argv[])
       ACE_OS::fprintf (output_file, "%s", ior.in ());
       ACE_OS::fclose (output_file);
 
-      poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER);
+      poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      orb->run (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->run (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
       ACE_DEBUG ((LM_DEBUG, "Server event loop finished\n"));
 
-      root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER);
+      root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER);
       ACE_TRY_CHECK;
 
-      orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER);
+      orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
       ACE_TRY_CHECK;
     }
   ACE_CATCHANY