Fri Feb 15 19:25:53 UTC 2013 Phil Mesnier <mesnier_p@ociweb.com>

11 files changed, 351 insertions, 49 deletions

diff --git a/TAO/tests/Dynamic_TP/ORB_ThreadPool/Client.cpp b/TAO/tests/Dynamic_TP/ORB_ThreadPool/Client.cpp
index f2881d25d63..28960ed7903 100644
--- a/TAO/tests/Dynamic_TP/ORB_ThreadPool/Client.cpp
+++ b/TAO/tests/Dynamic_TP/ORB_ThreadPool/Client.cpp
@@ -7,15 +7,18 @@
 class MT_Requestor : public virtual ACE_Task_Base
 {
 public:
-  MT_Requestor (Test::Sleeper_ptr s);
+  MT_Requestor (Test::Middle_ptr m, CORBA::Short sec);
 
   virtual int svc (void);
 private:
-  Test::Sleeper_var sleeper_;
+  Test::Middle_var middle_;
+  CORBA::Short seconds_;
 };
 
-MT_Requestor::MT_Requestor (Test::Sleeper_ptr s)
-  : sleeper_ (Test::Sleeper::_duplicate (s))
+MT_Requestor::MT_Requestor (Test::Middle_ptr m, CORBA::Short sec)
+  : middle_ (Test::Middle::_duplicate (m)),
+    seconds_ (sec)
+
 {
 }
 
@@ -30,7 +33,7 @@ MT_Requestor::svc ()
                   retries));
       try
         {
-          this->sleeper_->delay();
+          this->middle_->call_delay(seconds_);
           ACE_DEBUG ((LM_DEBUG,
                       ACE_TEXT ("Client thread %t delay succeeded\n")));
           break;
@@ -46,14 +49,15 @@ MT_Requestor::svc ()
   return 0;
 }
 
-const ACE_TCHAR *ior = ACE_TEXT("file://server.ior");
+const ACE_TCHAR *ior = ACE_TEXT("file://middle.ior");
 bool do_shutdown = false;
+CORBA::Short sec = 2;
 int num_threads = 1;
 
 int
 parse_args (int argc, ACE_TCHAR *argv[])
 {
-  ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("k:n:x"));
+  ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("k:n:s:x"));
   int c;
 
   while ((c = get_opts ()) != -1)
@@ -65,6 +69,9 @@ parse_args (int argc, ACE_TCHAR *argv[])
       case 'n':
         num_threads = ACE_OS::atoi (get_opts.opt_arg ());
         break;
+      case 's':
+        sec = ACE_OS::atoi (get_opts.opt_arg ());
+        break;
       case 'x':
         do_shutdown = true;
         break;
@@ -98,24 +105,24 @@ ACE_TMAIN(int argc, ACE_TCHAR *argv[])
       CORBA::Object_var tmp =
         orb->string_to_object(ior);
 
-      Test::Sleeper_var sleeper =
-        Test::Sleeper::_narrow(tmp.in ());
+      Test::Middle_var middle =
+        Test::Middle::_narrow(tmp.in ());
 
-      if (CORBA::is_nil (sleeper.in ()))
+      if (CORBA::is_nil (middle.in ()))
         {
           ACE_ERROR_RETURN ((LM_DEBUG,
-                             "Nil Test::Sleeper reference <%s>\n",
+                             "Nil Test::Middle reference <%s>\n",
                              ior),
                             1);
         }
 
-      MT_Requestor requestor (sleeper.in());
+      MT_Requestor requestor (middle.in(), sec);
       requestor.activate (THR_NEW_LWP | THR_JOINABLE, num_threads);
       requestor.wait ();
 
       if (do_shutdown)
       {
-        sleeper->shutdown();
+        middle->shutdown();
       }
 
       orb->destroy ();
diff --git a/TAO/tests/Dynamic_TP/ORB_ThreadPool/Middle.cpp b/TAO/tests/Dynamic_TP/ORB_ThreadPool/Middle.cpp
new file mode 100644
index 00000000000..55f904e7488
--- /dev/null
+++ b/TAO/tests/Dynamic_TP/ORB_ThreadPool/Middle.cpp
@@ -0,0 +1,130 @@
+// $Id$
+
+#include "Test_i.h"
+#include "ace/Get_Opt.h"
+#include "ace/OS_NS_stdio.h"
+#include "ace/Thread_Manager.h"
+
+#include "tao/ORB_Core_TSS_Resources.h"
+#include "tao/ORB_Core.h"
+#include "tao/Dynamic_TP/DTP_Thread_Pool.h"
+
+const ACE_TCHAR *ior_output_file = ACE_TEXT ("middle.ior");
+const ACE_TCHAR *upstream_ior = ACE_TEXT ("file://server.ior");
+
+int
+parse_args (int argc, ACE_TCHAR *argv[])
+{
+  ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("k:o:"));
+  int c;
+
+  while ((c = get_opts ()) != -1)
+    switch (c)
+      {
+      case 'o':
+        ior_output_file = get_opts.opt_arg ();
+        break;
+      case 'k':
+        upstream_ior = get_opts.opt_arg ();
+        break;
+      case '?':
+      default:
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "usage:  %s "
+                           "-o <iorfile>"
+                           "-k <upstream_ior>"
+                           "\n",
+                           argv [0]),
+                          -1);
+      }
+  // Indicates successful parsing of the command line
+  return 0;
+}
+
+int
+ACE_TMAIN (int argc, ACE_TCHAR *argv[])
+{
+  try
+    {
+      CORBA::ORB_var orb =
+        CORBA::ORB_init (argc, argv);
+
+      CORBA::Object_var obj =
+        orb->resolve_initial_references("RootPOA");
+
+      PortableServer::POA_var root_poa =
+        PortableServer::POA::_narrow (obj.in ());
+
+      if (CORBA::is_nil (root_poa.in ()))
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           " (%P|%t) Middle panic: nil RootPOA\n"),
+                          1);
+
+      PortableServer::POAManager_var poa_manager =
+        root_poa->the_POAManager ();
+
+      if (parse_args (argc, argv) != 0)
+        return 1;
+
+      obj = orb->string_to_object (upstream_ior);
+      Test::Sleeper_var sleeper = Test::Sleeper::_narrow (obj.in ());
+
+      if (CORBA::is_nil (sleeper.in()))
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           " (%P|%t) Middle panic: nil sleeper reference\n"),
+                          1);
+
+
+      Middle_i *test_impl;
+      ACE_NEW_RETURN (test_impl, Middle_i (orb.in (), sleeper.in()), 1);
+      PortableServer::ServantBase_var owner_transfer(test_impl);
+      PortableServer::ObjectId_var id = root_poa->activate_object (test_impl);
+      obj = root_poa->id_to_reference (id.in ());
+
+      Test::Middle_var middle = Test::Middle::_narrow (obj.in ());
+      CORBA::String_var ior = orb->object_to_string (middle.in ());
+
+      ACE_DEBUG ((LM_DEBUG,"Middle calling poa_manager::activate()\n"));
+      poa_manager->activate ();
+
+      // Output the IOR to the <ior_output_file>
+      FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
+      if (output_file == 0)
+        ACE_ERROR_RETURN ((LM_ERROR,
+                           "Cannot open output file %s for writing IOR: %C",
+                           ior_output_file,
+                           ior.in ()),
+                              1);
+      ACE_OS::fprintf (output_file, "%s", ior.in ());
+      ACE_OS::fclose (output_file);
+
+      TAO_ORB_Core_TSS_Resources &tss =
+        *orb->orb_core ()->get_tss_resources ();
+
+      // The API calls it a lane but DTP Thread Pools
+      // are always a single lane.
+      TAO_DTP_Thread_Pool *pool =
+        static_cast <TAO_DTP_Thread_Pool *> (tss.lane_);
+
+      if (pool == 0)
+        {
+          ACE_DEBUG ((LM_DEBUG,"Middle calling orb->run()\n"));
+          orb->run ();
+        }
+      else
+        {
+          ACE_DEBUG ((LM_DEBUG,"Middle calling pool->wait()\n"));
+          pool->wait();
+        }
+
+      ACE_DEBUG ((LM_DEBUG, "(%P|%t) Middle - event loop finished\n"));
+      orb->destroy ();
+    }
+  catch (const CORBA::Exception& ex)
+    {
+      ex._tao_print_exception ("Middle Exception caught:");
+      return 1;
+    }
+
+  return 0;
+}
diff --git a/TAO/tests/Dynamic_TP/ORB_ThreadPool/ORB_ThreadPool.mpc b/TAO/tests/Dynamic_TP/ORB_ThreadPool/ORB_ThreadPool.mpc
index 5169bb86c7f..815a8f209dd 100644
--- a/TAO/tests/Dynamic_TP/ORB_ThreadPool/ORB_ThreadPool.mpc
+++ b/TAO/tests/Dynamic_TP/ORB_ThreadPool/ORB_ThreadPool.mpc
@@ -22,6 +22,21 @@ project(*Server): taoserver, dynamic_tp, avoids_corba_e_compact, avoids_corba_e_
 
 }
 
+project(*Middle): taoserver, dynamic_tp, avoids_corba_e_compact, avoids_corba_e_micro {
+  exename=middle
+  after += *idl
+  Source_Files {
+    Test_i.cpp
+    Middle.cpp
+    TestC.cpp
+    TestS.cpp
+  }
+
+  IDL_Files {
+  }
+
+}
+
 project(*Client): taoclient, avoids_corba_e_compact, avoids_corba_e_micro {
   after += *idl
   Source_Files {
diff --git a/TAO/tests/Dynamic_TP/ORB_ThreadPool/Server.cpp b/TAO/tests/Dynamic_TP/ORB_ThreadPool/Server.cpp
index fc23726e81c..5ef46c0cdf3 100644
--- a/TAO/tests/Dynamic_TP/ORB_ThreadPool/Server.cpp
+++ b/TAO/tests/Dynamic_TP/ORB_ThreadPool/Server.cpp
@@ -52,7 +52,7 @@ ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 
       if (CORBA::is_nil (root_poa.in ()))
         ACE_ERROR_RETURN ((LM_ERROR,
-                           " (%P|%t) Panic: nil RootPOA\n"),
+                           " (%P|%t) Server panic: nil RootPOA\n"),
                           1);
 
       PortableServer::POAManager_var poa_manager =
@@ -61,8 +61,8 @@ ACE_TMAIN (int argc, ACE_TCHAR *argv[])
       if (parse_args (argc, argv) != 0)
         return 1;
 
-      Test_i *test_impl;
-      ACE_NEW_RETURN (test_impl, Test_i (orb.in ()), 1);
+      Sleeper_i *test_impl;
+      ACE_NEW_RETURN (test_impl, Sleeper_i (orb.in ()), 1);
       PortableServer::ServantBase_var owner_transfer(test_impl);
       PortableServer::ObjectId_var id = root_poa->activate_object (test_impl);
       CORBA::Object_var object = root_poa->id_to_reference (id.in ());
@@ -91,19 +91,23 @@ ACE_TMAIN (int argc, ACE_TCHAR *argv[])
       TAO_DTP_Thread_Pool *pool =
         static_cast <TAO_DTP_Thread_Pool *> (tss.lane_);
 
-#if 0
-      ACE_DEBUG ((LM_DEBUG,"Server calling orb::run()\n"));
-      orb->run ();
-#else
-      pool->wait();
-#endif
-
-      ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
+      if (pool == 0)
+        {
+          ACE_DEBUG ((LM_DEBUG,"Server calling orb->run()\n"));
+          orb->run ();
+        }
+      else
+        {
+          ACE_DEBUG ((LM_DEBUG,"Server calling pool->wait()\n"));
+          pool->wait();
+        }
+
+      ACE_DEBUG ((LM_DEBUG, "(%P|%t) Server - event loop finished\n"));
       orb->destroy ();
     }
   catch (const CORBA::Exception& ex)
     {
-      ex._tao_print_exception ("Exception caught:");
+      ex._tao_print_exception ("Server Exception caught:");
       return 1;
     }
 
diff --git a/TAO/tests/Dynamic_TP/ORB_ThreadPool/Test.idl b/TAO/tests/Dynamic_TP/ORB_ThreadPool/Test.idl
index d2760fdd4be..63533c390fc 100644
--- a/TAO/tests/Dynamic_TP/ORB_ThreadPool/Test.idl
+++ b/TAO/tests/Dynamic_TP/ORB_ThreadPool/Test.idl
@@ -8,7 +8,7 @@ module Test
   /// A very simple interface
   interface Sleeper
   {
-    void delay ();
+    void delay (in short seconds);
 
     /// A method to shutdown the ORB
     /**
@@ -16,4 +16,13 @@ module Test
      */
     oneway void shutdown ();
   };
+
+  /// The client calls on middle which will then perform an upcall to sleeper
+  interface Middle
+  {
+    void call_delay (in short seconds);
+
+    oneway void shutdown ();
+  };
+
 };
diff --git a/TAO/tests/Dynamic_TP/ORB_ThreadPool/Test_i.cpp b/TAO/tests/Dynamic_TP/ORB_ThreadPool/Test_i.cpp
index 0a5eb7f8185..00c7345f6e1 100644
--- a/TAO/tests/Dynamic_TP/ORB_ThreadPool/Test_i.cpp
+++ b/TAO/tests/Dynamic_TP/ORB_ThreadPool/Test_i.cpp
@@ -4,21 +4,74 @@
 #include "Test_i.h"
 #include "ace/OS_NS_unistd.h"
 
-Test_i::Test_i (CORBA::ORB_ptr orb)
+Sleeper_i::Sleeper_i (CORBA::ORB_ptr orb)
   : orb_ (CORBA::ORB::_duplicate (orb))
 {
 }
 
 void
-Test_i::delay(void)
+Sleeper_i::delay(CORBA::Short sec)
 {
-  ACE_DEBUG ((LM_DEBUG, "(%P|%t) Test_i::delay called\n"));
-  ACE_OS::sleep (1);
-  ACE_DEBUG ((LM_DEBUG, "(%P|%t) Test_i::delay returning\n"));
+  ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) Sleeper_i::delay called\n")));
+  ACE_OS::sleep (sec);
+  ACE_DEBUG ((LM_DEBUG,
+              ACE_TEXT ("(%P|%t) Sleeper_i::delay returning\n")));
 }
 
 void
-Test_i::shutdown (void)
+Sleeper_i::shutdown (void)
 {
   this->orb_->shutdown (0);
 }
+
+//-----------------------------------------------
+
+Middle_i::Middle_i (CORBA::ORB_ptr orb, Test::Sleeper_ptr s)
+  : orb_ (CORBA::ORB::_duplicate (orb)),
+    sleeper_ (Test::Sleeper::_duplicate (s))
+{
+}
+
+void
+Middle_i::call_delay(CORBA::Short sec)
+{
+  ACE_DEBUG ((LM_DEBUG,
+              ACE_TEXT ("(%P|%t) Middle_i::delay called\n")));
+
+  ACE_hthread_t thr;
+  ACE_Thread::self (thr);
+  bool recursive = false;
+  {
+    ACE_GUARD (ACE_Thread_Mutex, guard, this->lock_);
+    int result = this->threads_.insert (thr);
+    ACE_ASSERT (result != -1);
+    if (result == 1)
+      {
+        ACE_DEBUG ((LM_DEBUG,
+                    ACE_TEXT ("(%P|%t) Middle_i::call_delay, ")
+                    ACE_TEXT ("recursive upcall detected for thr = %d\n"),
+                    thr));
+        recursive = true;
+      }
+  }
+
+  this->sleeper_->delay(sec);
+
+  if (!recursive)
+    {
+      ACE_GUARD (ACE_Thread_Mutex, guard, this->lock_);
+      int result = this->threads_.remove (thr);
+      ACE_ASSERT (result != -1);
+    }
+
+  ACE_DEBUG ((LM_DEBUG,
+              ACE_TEXT("(%P|%t) Middle_i::delay returning recursive = %d\n"),
+              recursive));
+}
+
+void
+Middle_i::shutdown (void)
+{
+  sleeper_->shutdown ();
+  this->orb_->shutdown (0);
+}
diff --git a/TAO/tests/Dynamic_TP/ORB_ThreadPool/Test_i.h b/TAO/tests/Dynamic_TP/ORB_ThreadPool/Test_i.h
index 573d6c55b33..59ec8c154e5 100644
--- a/TAO/tests/Dynamic_TP/ORB_ThreadPool/Test_i.h
+++ b/TAO/tests/Dynamic_TP/ORB_ThreadPool/Test_i.h
@@ -7,16 +7,18 @@
 #include /**/ "ace/pre.h"
 
 #include "TestS.h"
+#include "ace/Synch.h"
+#include "ace/Unbounded_Set.h"
 
 /// Implement the Test::Sleeper interface
-class Test_i : public virtual POA_Test::Sleeper
+class Sleeper_i : public virtual POA_Test::Sleeper
 {
 public:
   /// Constructor
-  Test_i (CORBA::ORB_ptr orb);
+  Sleeper_i (CORBA::ORB_ptr orb);
 
   // = The skeleton methods
-  virtual void delay (void);
+  virtual void delay (CORBA::Short sec);
 
   virtual void shutdown (void);
 
@@ -25,5 +27,27 @@ private:
 
 };
 
+
+/// Implement the Test::Sleeper interface
+class Middle_i : public virtual POA_Test::Middle
+{
+public:
+  /// Constructor
+  Middle_i (CORBA::ORB_ptr orb, Test::Sleeper_ptr sleeper);
+
+  // = The skeleton methods
+  virtual void call_delay (CORBA::Short sec);
+
+  virtual void shutdown (void);
+
+private:
+  CORBA::ORB_var orb_;
+  Test::Sleeper_var sleeper_;
+
+  ACE_Thread_Mutex lock_;
+  ACE_Unbounded_Set<ACE_hthread_t> threads_;
+
+};
+
 #include /**/ "ace/post.h"
 #endif /* TEST_I_H */
diff --git a/TAO/tests/Dynamic_TP/ORB_ThreadPool/client.conf b/TAO/tests/Dynamic_TP/ORB_ThreadPool/client.conf
index 74326a5cbf4..ad3d58ebcb3 100644
--- a/TAO/tests/Dynamic_TP/ORB_ThreadPool/client.conf
+++ b/TAO/tests/Dynamic_TP/ORB_ThreadPool/client.conf
@@ -1,4 +1,4 @@
 # $Id$
 
-static Client_Strategy_Factory "-ORBTransportMuxStrategy"
+static Client_Strategy_Factory "-ORBTransportMuxStrategy exclusive"
 
diff --git a/TAO/tests/Dynamic_TP/ORB_ThreadPool/middle.conf b/TAO/tests/Dynamic_TP/ORB_ThreadPool/middle.conf
new file mode 100644
index 00000000000..4902b200c2f
--- /dev/null
+++ b/TAO/tests/Dynamic_TP/ORB_ThreadPool/middle.conf
@@ -0,0 +1,6 @@
+# $Id$
+
+dynamic DTP_Config Service_Object * TAO_Dynamic_TP:_make_TAO_DTP_Config() "-DTPName ORBPool -DTPMin 2 -DTPInit 2"
+ # -DTPMax 7 -DTPTimeout 30"
+dynamic DTP_ORB_Loader Service_Object * TAO_Dynamic_TP:_make_TAO_DTP_ORB_Loader() ""
+#static Client_Strategy_Factory "-ORBWaitStrategy MT_NOUPCALL"
diff --git a/TAO/tests/Dynamic_TP/ORB_ThreadPool/run_test.pl b/TAO/tests/Dynamic_TP/ORB_ThreadPool/run_test.pl
index 7bce5b75574..bd9c07d3d1f 100755
--- a/TAO/tests/Dynamic_TP/ORB_ThreadPool/run_test.pl
+++ b/TAO/tests/Dynamic_TP/ORB_ThreadPool/run_test.pl
@@ -9,29 +9,43 @@ use lib "$ENV{ACE_ROOT}/bin";
 use PerlACE::TestTarget;
 
 $status = 0;
-$threads = 10;
+$threads = 30;
+$delay = 2;
+
 $sdebug = "";
 $cdebug = "";
+$mdebug = "";
 foreach $i (@ARGV) {
     if ($i eq '-sdebug' || $i eq '-debug') {
         $sdebug = "-ORBDebuglevel 10 -ORBVerboseLogging 1";
     }
+    if ($i eq '-mdebug' || $i eq '-debug') {
+        $mdebug = "-ORBDebuglevel 10 -ORBVerboseLogging 1";
+    }
     if ($i eq '-cdebug' || $i eq '-debug') {
         $sdebug = "-ORBDebuglevel 10 -ORBVerboseLogging 1";
     }
 }
 
 my $server = PerlACE::TestTarget::create_target (1) || die "Create target 1 failed\n";
+my $middle = PerlACE::TestTarget::create_target (1) || die "Create target 1 failed\n";
 my $client = PerlACE::TestTarget::create_target (2) || die "Create target 2 failed\n";
 
-my $iorbase = "server.ior";
-my $server_iorfile = $server->LocalFile ($iorbase);
-my $client_iorfile = $client->LocalFile ($iorbase);
-$server->DeleteFile($iorbase);
-$client->DeleteFile($iorbase);
+my $siorbase = "server.ior";
+my $miorbase = "middle.ior";
+my $server_iorfile = $server->LocalFile ($siorbase);
+my $middle_ciorfile = $middle->LocalFile ($siorbase);
+my $middle_siorfile = $middle->LocalFile ($miorbase);
+my $client_iorfile = $client->LocalFile ($miorbase);
+$server->DeleteFile($siorbase);
+$middle->DeleteFile($siorbase);
+$middle->DeleteFile($miorbase);
+$client->DeleteFile($miorbase);
 
 $SV = $server->CreateProcess ("server", "$sdebug -ORBSvcConf server.conf -ORBDynamicThreadPoolName ORBPool -o $server_iorfile");
-$CL = $client->CreateProcess ("client", "$cdebug -ORBSvcConf client.conf -k file://$client_iorfile -n $threads -x");
+$MD = $middle->CreateProcess ("middle", "$mdebug -ORBSvcConf middle.conf -ORBDynamicThreadPoolName ORBPool -o $middle_siorfile -k file://$middle_ciorfile");
+$CL = $client->CreateProcess ("client", "$cdebug -ORBSvcConf client.conf -k file://$client_iorfile -n $threads -s $delay -x");
+
 $server_status = $SV->Spawn ();
 
 if ($server_status != 0) {
@@ -39,19 +53,49 @@ if ($server_status != 0) {
     exit 1;
 }
 
-if ($server->WaitForFileTimed ($iorbase,
+if ($server->WaitForFileTimed ($siorbase,
                                $server->ProcessStartWaitInterval()) == -1) {
     print STDERR "ERROR: cannot find file <$server_iorfile>\n";
     $SV->Kill (); $SV->TimedWait (1);
     exit 1;
 }
 
-if ($server->GetFile ($iorbase) == -1) {
+if ($server->GetFile ($siorbase) == -1) {
     print STDERR "ERROR: cannot retrieve file <$server_iorfile>\n";
     $SV->Kill (); $SV->TimedWait (1);
     exit 1;
 }
-if ($client->PutFile ($iorbase) == -1) {
+
+
+if ($middle->PutFile ($miorbase) == -1) {
+    print STDERR "ERROR: cannot set file <$middle_ciorfile>\n";
+    $SV->Kill (); $SV->TimedWait (1);
+    exit 1;
+}
+
+$middle_status = $MD->Spawn ();
+
+if ($middle_status != 0) {
+    print STDERR "ERROR: server returned $server_status\n";
+    exit 1;
+}
+
+if ($middle->WaitForFileTimed ($miorbase,
+                               $middle->ProcessStartWaitInterval()) == -1) {
+    print STDERR "ERROR: cannot find file <$server_iorfile>\n";
+    $MD->Kill (); $MD->TimedWait (1);
+    $SV->Kill (); $SV->TimedWait (1);
+    exit 1;
+}
+
+if ($middle->GetFile ($miorbase) == -1) {
+    print STDERR "ERROR: cannot retrieve file <$middle_siorfile>\n";
+    $MD->Kill (); $MD->TimedWait (1);
+    $SV->Kill (); $SV->TimedWait (1);
+    exit 1;
+}
+
+if ($client->PutFile ($miorbase) == -1) {
     print STDERR "ERROR: cannot set file <$client_iorfile>\n";
     $SV->Kill (); $SV->TimedWait (1);
     exit 1;
@@ -64,6 +108,13 @@ if ($client_status != 0) {
     $status = 1;
 }
 
+$middle_status = $MD->WaitKill ($middle->ProcessStopWaitInterval());
+
+if ($middle_status != 0) {
+    print STDERR "ERROR: middle returned $middle_status\n";
+    $status = 1;
+}
+
 $server_status = $SV->WaitKill ($server->ProcessStopWaitInterval());
 
 if ($server_status != 0) {
@@ -71,7 +122,9 @@ if ($server_status != 0) {
     $status = 1;
 }
 
-$server->DeleteFile($iorbase);
-$client->DeleteFile($iorbase);
+$server->DeleteFile($siorbase);
+$middle->DeleteFile($siorbase);
+$middle->DeleteFile($miorbase);
+$client->DeleteFile($miorbase);
 
 exit $status;
diff --git a/TAO/tests/Dynamic_TP/ORB_ThreadPool/server.conf b/TAO/tests/Dynamic_TP/ORB_ThreadPool/server.conf
index ec0ca59c0ed..846285b973e 100644
--- a/TAO/tests/Dynamic_TP/ORB_ThreadPool/server.conf
+++ b/TAO/tests/Dynamic_TP/ORB_ThreadPool/server.conf
@@ -1,4 +1,5 @@
 # $Id$
 
-dynamic DTP_Config Service_Object * TAO_Dynamic_TP:_make_TAO_DTP_Config() "-DTPName ORBPool -DTPMin 3 -DTPInit 4 -DTPMax 7 -DTPTimeout 30"
+dynamic DTP_Config Service_Object * TAO_Dynamic_TP:_make_TAO_DTP_Config() "-DTPName ORBPool -DTPMin 10 -DTPInit 20 -DTPTimeout 10"
+ # -DTPMax 7 -DTPTimeout 30"
 dynamic DTP_ORB_Loader Service_Object * TAO_Dynamic_TP:_make_TAO_DTP_ORB_Loader() ""