Thu Apr 4 23:15:58 UTC 2013 Phil Mesnier <mesnier_p@ociweb.com>

25 files changed, 1287 insertions, 203 deletions

diff --git a/TAO/ChangeLog_Asynch_ImR b/TAO/ChangeLog_Asynch_ImR
index f6f8056ee4d..e251b4811c6 100644
--- a/TAO/ChangeLog_Asynch_ImR
+++ b/TAO/ChangeLog_Asynch_ImR
@@ -1,3 +1,38 @@
+Thu Apr  4 23:15:58 UTC 2013  Phil Mesnier  <mesnier_p@ociweb.com>
+
+        * orbsvcs/ImplRepo_Service/AsyncAccessManager.cpp:
+        * orbsvcs/ImplRepo_Service/Forwarder.h:
+        * orbsvcs/ImplRepo_Service/Forwarder.cpp:
+        * orbsvcs/ImplRepo_Service/INS_Locator.h:
+        * orbsvcs/ImplRepo_Service/INS_Locator.cpp:
+        * orbsvcs/ImplRepo_Service/ImR_Locator_i.h:
+        * orbsvcs/ImplRepo_Service/ImR_Locator_i.cpp:
+        * orbsvcs/ImplRepo_Service/LiveCheck.cpp:
+        * orbsvcs/ImplRepo_Service/Locator_Repository.h:
+        * orbsvcs/ImplRepo_Service/Locator_Repository.cpp:
+
+        * tao/Adapter.h:
+
+        * tao/DynamicInterface/AMH_DSI_Response_Handler.cpp:
+
+        * tao/IORTable/IORTable.h:
+        * tao/IORTable/IORTable.mpc:
+        * tao/IORTable/IORTable.pidl:
+        * tao/IORTable/IOR_Table_Impl.h:
+        * tao/IORTable/IOR_Table_Impl.cpp:
+        * tao/IORTable/Locate_ResponseHandler.h:
+        * tao/IORTable/Locate_ResponseHandler.inl:
+        * tao/IORTable/Locate_ResponseHandler.cpp:
+        * tao/IORTable/Table_Adapter.h:
+        * tao/IORTable/Table_Adapter.cpp:
+
+        * tao/Messaging/AMH_Response_Handler.h:
+        * tao/Messaging/AMH_Response_Handler.cpp:
+
+          Adding support for an asynchronous IORTable locator. This commit
+          also contains a lot of intermediate debugging artifacts. It still
+          crashes. Committing for easy distribution to other test hosts.
+
 Wed Apr  3 14:20:28 UTC 2013  Phil Mesnier  <mesnier_p@ociweb.com>
 
         * orbsvcs/ImplRepo_Service/ImR_Locator_i.cpp:
diff --git a/TAO/orbsvcs/ImplRepo_Service/AsyncAccessManager.cpp b/TAO/orbsvcs/ImplRepo_Service/AsyncAccessManager.cpp
index db60df4d9fb..5a713f9efbe 100644
--- a/TAO/orbsvcs/ImplRepo_Service/AsyncAccessManager.cpp
+++ b/TAO/orbsvcs/ImplRepo_Service/AsyncAccessManager.cpp
@@ -20,11 +20,15 @@ AsyncAccessManager::AsyncAccessManager (const Server_Info &info,
    refcount_(1),
    lock_()
 {
+  ACE_DEBUG ((LM_DEBUG,"AAM(%x), ctor, name = %s\n",
+              this, info.name.c_str()));
   this->info_ = new Server_Info (info);
 }
 
 AsyncAccessManager::~AsyncAccessManager (void)
 {
+  ACE_DEBUG ((LM_DEBUG, "AAM (%x): dtor, name = %s\n", this,
+              info_->name.c_str()));
   delete this->info_;
 }
 
@@ -38,6 +42,8 @@ bool
 AsyncAccessManager::has_server (const char *s)
 {
   int result = ACE_OS::strcmp (this->info_->name.c_str(),s);
+  ACE_DEBUG ((LM_DEBUG, "AAM (%x): has_server test, my name = %s, s = %s result = %d\n",
+              this, info_->name.c_str(), s, result));
   return result == 0;
 }
 
@@ -48,6 +54,13 @@ AsyncAccessManager::add_interest (ImR_ResponseHandler *rh)
     ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->lock_);
     this->rh_list_.push_back (rh);
   }
+  if (this->locator_.debug() > 0)
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  ACE_TEXT ("(%P|%t) AsyncAccessManager::add_interest: ")
+                  ACE_TEXT ("server = <%C>, status = %d count = %d\n"),
+                  this->info_->name.c_str(), this->status_, this->rh_list_.size()));
+    }
 
   if (this->status_ == AAM_SERVER_READY || this->status_ == AAM_SERVER_STARTED_RUNNING)
     {
@@ -55,6 +68,10 @@ AsyncAccessManager::add_interest (ImR_ResponseHandler *rh)
         {
           this->status_ = AAM_SERVER_READY;
           this->final_state();
+          ACE_DEBUG ((LM_DEBUG,
+                      ACE_TEXT ("(%P|%t) AsyncAccessManager::add_interest: ")
+                      ACE_TEXT ("server = <%C>, server is alive\n"),
+                      this->info_->name.c_str()));
           return;
         }
     }
@@ -86,11 +103,24 @@ AsyncAccessManager::add_interest (ImR_ResponseHandler *rh)
             }
         }
     }
+
+  ACE_DEBUG ((LM_DEBUG,
+              ACE_TEXT ("(%P|%t) AsyncAccessManager::add_interest: ")
+              ACE_TEXT ("server = <%C>, status = %d returning\n"),
+              this->info_->name.c_str(), this->status_));
 }
 
 void
 AsyncAccessManager::final_state (void)
 {
+  if (this->locator_.debug() > 0)
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  ACE_TEXT ("(%P|%t) AsyncAccessManager::final_state: ")
+                  ACE_TEXT ("status = %d, server = <%C> list size = %d\n"),
+                  this->status_, this->info_->name.c_str(), rh_list_.size()));
+    }
+
   for (size_t i = 0; i < this->rh_list_.size(); i++)
     {
       ImR_ResponseHandler *rh = this->rh_list_[i];
@@ -98,6 +128,8 @@ AsyncAccessManager::final_state (void)
         {
           if (this->status_ == AAM_SERVER_READY)
             {
+              ACE_DEBUG ((LM_DEBUG,
+                          ACE_TEXT ("(%P|%t) AsyncAccessManager::final_state calling send_ior\n")));
               rh->send_ior (this->info_->partial_ior.c_str());
             }
           else
@@ -153,6 +185,13 @@ AsyncAccessManager::status (AAM_Status s)
 void
 AsyncAccessManager::activator_replied (bool success)
 {
+  // if (this->locator_.debug() > 0)
+  //   {
+      ACE_DEBUG ((LM_DEBUG,
+                  ACE_TEXT ("(%P|%t) AsyncAccessManager::activator_replied: ")
+                  ACE_TEXT ("success = %d, status = %d\n"),
+                  success, this->status_));
+      // }
   if (success)
     {
       this->status (AAM_WAIT_FOR_RUNNING);
@@ -174,6 +213,13 @@ AsyncAccessManager::server_is_shutting_down (void)
 void
 AsyncAccessManager::server_is_running (const char *partial_ior)
 {
+  // if (this->locator_.debug() > 0)
+  //   {
+      ACE_DEBUG ((LM_DEBUG,
+                  ACE_TEXT ("(%P|%t) AsyncAccessManager::server_is_running: ")
+                  ACE_TEXT ("name = %C, status = %d\n"),
+                  this->info_->name.c_str(), this->status_));
+    // }
   this->status (AAM_WAIT_FOR_ALIVE);
   this->info_->partial_ior = partial_ior;
 
@@ -273,12 +319,15 @@ AsyncAccessManager::add_ref (void)
 {
   ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, mon, this->lock_, 0);
   ++this->refcount_;
+
+  ACE_DEBUG ((LM_DEBUG, "AAM (%x): add_ref count now = %d\n", this, this->refcount_));
   return this;
 }
 
 void
 AsyncAccessManager::remove_ref (void)
 {
+  ACE_DEBUG ((LM_DEBUG, "AAM (%x): remove_ref count pre decr = %d\n", this, this->refcount_));
   ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->lock_);
   if (--this->refcount_ == 0)
     {
@@ -292,20 +341,24 @@ AsyncAccessManager::remove_ref (void)
 AsyncAccessManager_ptr::AsyncAccessManager_ptr (void)
   : val_ (0)
 {
+  ACE_DEBUG ((LM_DEBUG,"AAM_Ptr (%x) ctor default\n", this));
 }
 
 AsyncAccessManager_ptr::AsyncAccessManager_ptr (AsyncAccessManager *aam)
   :val_ (aam)
 {
+  ACE_DEBUG ((LM_DEBUG,"AAM_Ptr (%x) ctor taking ownership of aam = %x\n", this, aam));
 }
 
 AsyncAccessManager_ptr::AsyncAccessManager_ptr (const AsyncAccessManager_ptr &aam_ptr)
   :val_ (aam_ptr.clone())
 {
+  ACE_DEBUG ((LM_DEBUG,"AAM_Ptr (%x) ctor taking ownership of aam_clone = %x\n", this, val_));
 }
 
 AsyncAccessManager_ptr::~AsyncAccessManager_ptr (void)
 {
+  ACE_DEBUG ((LM_DEBUG,"AAM_Ptr (%x) dtor releasing %x\n", this, val_));
   if (val_ != 0)
     {
       val_->remove_ref();
@@ -315,6 +368,8 @@ AsyncAccessManager_ptr::~AsyncAccessManager_ptr (void)
 AsyncAccessManager_ptr &
 AsyncAccessManager_ptr::operator= (const AsyncAccessManager_ptr &aam_ptr)
 {
+  ACE_DEBUG ((LM_DEBUG,"AAM_Ptr (%x) assignment releasing %x, taking ownership of aam_clone = %x\n", this, val_, *aam_ptr));
+
   if (val_ != *aam_ptr)
     {
       if (val_ != 0)
@@ -329,6 +384,7 @@ AsyncAccessManager_ptr::operator= (const AsyncAccessManager_ptr &aam_ptr)
 AsyncAccessManager_ptr &
 AsyncAccessManager_ptr::operator= (AsyncAccessManager *aam)
 {
+  ACE_DEBUG ((LM_DEBUG,"AAM_Ptr (%x) assignment releasing %x, taking ownership of aam = %x\n", this, val_, aam));
   if (val_ != aam)
     {
       if (val_ != 0)
@@ -459,16 +515,20 @@ AsyncLiveListener::AsyncLiveListener (const char *server,
    pinger_ (pinger),
    status_ (LS_UNKNOWN)
 {
+  ACE_DEBUG ((LM_DEBUG, "AsyncLiveListener ctor, this = %x\n", this));
 }
 
 AsyncLiveListener::~AsyncLiveListener (void)
 {
+  ACE_DEBUG ((LM_DEBUG, "AsyncLiveListener dtor, this = %x\n", this));
 }
 
 bool
 AsyncLiveListener::start (void)
 {
   bool rtn = this->pinger_.add_listener (this);
+  ACE_DEBUG ((LM_DEBUG,
+              "AsyncLiveListener::start, add_listener returned %d\n", rtn));
   if (!rtn)
     delete this;
   return rtn;
@@ -484,6 +544,8 @@ AsyncLiveListener::status_changed (LiveStatus status)
     }
   else
     {
+      ACE_DEBUG ((LM_DEBUG,
+                  "AsyncLiveListener::status_changed, status = %d, deleting(%x)\n", status, this));
       this->aam_->ping_replied (status);
       delete this;
     }
diff --git a/TAO/orbsvcs/ImplRepo_Service/Forwarder.cpp b/TAO/orbsvcs/ImplRepo_Service/Forwarder.cpp
index b242d737989..4be5dec24f0 100644
--- a/TAO/orbsvcs/ImplRepo_Service/Forwarder.cpp
+++ b/TAO/orbsvcs/ImplRepo_Service/Forwarder.cpp
@@ -191,56 +191,56 @@ ImR_DSI_ResponseHandler::send_ior (const char *pior)
 
   // Check that the returned ior is the expected partial ior with
   // missing ObjectKey.
-  if (ior.find ("corbaloc:") != 0 || ior[ior.length () - 1] != '/')
+  if (ior.find ("corbaloc:") == 0 && ior[ior.length () -1] == '/')
     {
-      ACE_ERROR ((LM_ERROR,
-                  ACE_TEXT ("ImR_ResponseHandler::send_ior (): Invalid corbaloc ior.\n")
-                  ACE_TEXT ("\t<%s>\n"),
-                  ior.c_str()));
-
-      CORBA::OBJECT_NOT_EXIST ex (CORBA::SystemException::_tao_minor_code
-                                  ( TAO_IMPLREPO_MINOR_CODE, 0),
-                                  CORBA::COMPLETED_NO);
-      TAO_AMH_DSI_Exception_Holder h(&ex);
-      this->resp_->invoke_excep(&h);
-      delete this;
-      return;
-    }
+      ior += this->key_str_.in();
 
-  ior += this->key_str_.in();
+      CORBA::Object_var forward_obj =
+        this->orb_->string_to_object (ior.c_str ());
 
-  CORBA::Object_var forward_obj =
-    this->orb_->string_to_object (ior.c_str ());
-
-  if (!CORBA::is_nil (forward_obj.in ()))
-    {
-      CORBA::Exception *fwd = new PortableServer::ForwardRequest (forward_obj.in ());
-      TAO_AMH_DSI_Exception_Holder h(fwd);
-      this->resp_->invoke_excep(&h);
-      delete this;
+      if (!CORBA::is_nil (forward_obj.in ()))
+        {
+          this->resp_->invoke_location_forward(forward_obj.in(), true);
+          delete this;
+          return;
+        }
+      else
+        {
+          ACE_ERROR ((LM_ERROR,
+                      ACE_TEXT ("ImR_DSI_ResponseHandler::send_ior (): Forward_to ")
+                      ACE_TEXT ("reference is nil.\n")));
+        }
     }
   else
     {
       ACE_ERROR ((LM_ERROR,
-                  ACE_TEXT ("ImR_DSI_ResponseHandler::send_ior (): Forward_to ")
-                  ACE_TEXT ("reference is nil.\n")));
-
-      CORBA::Exception *ex = new CORBA::OBJECT_NOT_EXIST (CORBA::SystemException::_tao_minor_code
-                                                          ( TAO_IMPLREPO_MINOR_CODE, 0),
-                                                          CORBA::COMPLETED_NO);
-      TAO_AMH_DSI_Exception_Holder h(ex);
-      this->resp_->invoke_excep(&h);
-      delete this;
+                  ACE_TEXT ("ImR_ResponseHandler::send_ior (): Invalid corbaloc ior.\n")
+                  ACE_TEXT ("\t<%s>\n"),
+                  ior.c_str()));
     }
+
+  this->invoke_excep_i (new CORBA::OBJECT_NOT_EXIST
+                        (CORBA::SystemException::_tao_minor_code
+                         ( TAO_IMPLREPO_MINOR_CODE, 0),
+                         CORBA::COMPLETED_NO));
 }
 
 void
-ImR_DSI_ResponseHandler::send_exception (CORBA::Exception *)
+ImR_DSI_ResponseHandler::invoke_excep_i (CORBA::Exception *ex)
 {
-  CORBA::Exception *ex = new CORBA::TRANSIENT (CORBA::SystemException::_tao_minor_code
-                                               ( TAO_IMPLREPO_MINOR_CODE, 0),
-                                               CORBA::COMPLETED_NO);
   TAO_AMH_DSI_Exception_Holder h(ex);
-  resp_->invoke_excep(&h);
+  this->resp_->invoke_excep(&h);
   delete this;
 }
+
+void
+ImR_DSI_ResponseHandler::send_exception (CORBA::Exception *ex)
+{
+  //discard the exception, always throw a transient:
+  delete ex;
+
+  this->invoke_excep_i (new CORBA::TRANSIENT
+                        (CORBA::SystemException::_tao_minor_code
+                         (TAO_IMPLREPO_MINOR_CODE, 0),
+                         CORBA::COMPLETED_NO));
+}
diff --git a/TAO/orbsvcs/ImplRepo_Service/Forwarder.h b/TAO/orbsvcs/ImplRepo_Service/Forwarder.h
index 6a1bf51f838..cc5b91aa674 100644
--- a/TAO/orbsvcs/ImplRepo_Service/Forwarder.h
+++ b/TAO/orbsvcs/ImplRepo_Service/Forwarder.h
@@ -60,6 +60,8 @@ public:
   void send_exception (CORBA::Exception *ex);
 
 private:
+  void invoke_excep_i (CORBA::Exception *ex);
+
   CORBA::String_var key_str_;
   CORBA::String_var server_name_;
   CORBA::ORB_var orb_;
diff --git a/TAO/orbsvcs/ImplRepo_Service/INS_Locator.cpp b/TAO/orbsvcs/ImplRepo_Service/INS_Locator.cpp
index fb50d46c937..eb8dcdb7f12 100644
--- a/TAO/orbsvcs/ImplRepo_Service/INS_Locator.cpp
+++ b/TAO/orbsvcs/ImplRepo_Service/INS_Locator.cpp
@@ -13,6 +13,7 @@
 #include "INS_Locator.h"
 #include "ImR_Locator_i.h"
 #include "tao/ORB_Constants.h"
+#include "tao/ORB_Core.h"
 
 INS_Locator::INS_Locator (ImR_Locator_i& loc)
 : imr_locator_ (loc)
@@ -25,112 +26,82 @@ INS_Locator::locate (const char* object_key)
   ACE_ASSERT (object_key != 0);
   try
     {
-      ACE_CString key (object_key);
-      ssize_t poaidx = key.find ('/');
-      if (poaidx >= 0)
-      {
-        key = key.substring (0, poaidx);
-      }
-
-      if (imr_locator_.debug () > 0)
-        ACE_DEBUG ((LM_DEBUG,
-                    ACE_TEXT ("ImR: Activating server <%s>.\n"),
-                    key.c_str ()));
-
       CORBA::String_var located =
-        this->imr_locator_.activate_server_by_object (key.c_str ());
+        this->imr_locator_.activate_server_by_object (object_key);
+      return located._retn();
+    }
+  catch (CORBA::Exception &)
+    {
+      throw CORBA::TRANSIENT (CORBA::SystemException::_tao_minor_code
+                              (TAO_IMPLREPO_MINOR_CODE, 0),
+                              CORBA::COMPLETED_NO);
+    }
+}
 
-      ACE_CString tmp = located.in ();
-      tmp += object_key;
+void
+INS_Locator::async_locate (::IORTable::Locate_ResponseHandler handler,
+                           const char* object_key)
+{
+  ACE_ASSERT (object_key != 0);
 
-      if (imr_locator_.debug () > 0)
-        ACE_DEBUG ((LM_DEBUG,
-                    ACE_TEXT ("ImR: Forwarding invocation on <%s> to <%s>\n"),
-                    key.c_str (), tmp.c_str()));
+  if (imr_locator_.debug () > 0)
+    ACE_DEBUG ((LM_DEBUG,
+                ACE_TEXT ("ImR: Activating server <%s> asynchronously .\n"),
+                object_key));
 
-      return CORBA::string_dup (tmp.c_str ());
-    }
-  catch (const ImplementationRepository::CannotActivate&)
+  Server_Info_Ptr si;
+  ACE_CString key;
+  ACE_CString full (object_key);
+  if (this->imr_locator_.split_key (full, key, si))
     {
-      throw CORBA::TRANSIENT (
-        CORBA::SystemException::_tao_minor_code (
-          TAO_IMPLREPO_MINOR_CODE,
-          0),
-        CORBA::COMPLETED_NO);
+      ImR_ResponseHandler *rh;
+      ACE_NEW (rh, INS_Loc_ResponseHandler (key.c_str(), handler));
+      this->imr_locator_.activate_server_by_info (si, rh);
     }
-  catch (const ImplementationRepository::NotFound&)
+  else
     {
-      ACE_CString objkey (object_key);
+      ACE_DEBUG ((LM_DEBUG, "async_locate: split key failed!\n"));
 
-      // check to see if there are more slashes beyond the first one
-      ssize_t poaidx2 = objkey.rfind ('/');
-      ssize_t poaidx1 = objkey.find ('/');
-      if (poaidx1 <= 0 || poaidx2 <= 0 || poaidx1 == poaidx2)
-        {
-          throw CORBA::TRANSIENT (
-            CORBA::SystemException::_tao_minor_code (
-              TAO_IMPLREPO_MINOR_CODE,
-              0),
-            CORBA::COMPLETED_NO);
-        }
+      handler->raise_excep (CORBA::TRANSIENT (CORBA::SystemException::_tao_minor_code
+                                              (TAO_IMPLREPO_MINOR_CODE, 0),
+                                              CORBA::COMPLETED_NO));
+    }
+}
 
-      // remove the data field beyond the last delimiter
-      // which is assumed to be the object id.
-      ACE_CString key2 = objkey.substring(0, poaidx2);
-      while (poaidx2 > poaidx1)
-        {
-          try
-            {
-              if (imr_locator_.debug () > 0)
-                {
-                  ACE_DEBUG ((LM_DEBUG,
-                    ACE_TEXT ("ImR: Try activating server using <%s>.\n"),
-                    key2.c_str ()));
-                }
 
-              CORBA::String_var located =
-                this->imr_locator_.activate_server_by_object (key2.c_str ());
+//----------------------------------------------------------------------------------------
+INS_Loc_ResponseHandler::INS_Loc_ResponseHandler (const char *key,
+                            ::IORTable::Locate_ResponseHandler handler)
+  : key_(key),
+    rh_ (handler)
+{
+  CORBA::ORB_var orb = rh_->orb_core()->orb();
+  ACE_DEBUG ((LM_DEBUG, "INS_Loc_ResponseHandler ctor, rh_ = %x, orb = %x\n",
+              rh_.ptr(), orb.ptr()));
+}
 
-              ACE_CString tmp = located.in ();
-              tmp += object_key;
+void
+INS_Loc_ResponseHandler::send_ior (const char *pior)
+{
+  CORBA::ORB_var orb = rh_->orb_core()->orb();
+  ACE_DEBUG ((LM_DEBUG, "INS_Loc_ResponseHandler send_ior, rh_ = %x, orb = %x, key = %s\n",
+              rh_.ptr(), orb.ptr(), key_.c_str()));
 
-              if (imr_locator_.debug () > 0)
-                {
-                  ACE_DEBUG ((LM_DEBUG,
-                              ACE_TEXT ("ImR: Forwarding invocation on <%s> ")
-                              ACE_TEXT ("to <%s>\n"), key2.c_str (), tmp.c_str()));
-                }
+  ACE_CString ior = pior;
+  ior += key_;
+  rh_->forward_ior (ior.c_str(), false);
+  delete this;
+}
 
-              return CORBA::string_dup (tmp.c_str ());
-            }
-          catch (const ImplementationRepository::CannotActivate&)
-            {
-              throw CORBA::TRANSIENT (
-                CORBA::SystemException::_tao_minor_code (
-                  TAO_IMPLREPO_MINOR_CODE,
-                  0),
-                CORBA::COMPLETED_NO);
-            }
-          catch (const ImplementationRepository::NotFound&)
-            {
-              poaidx2 = key2.rfind ('/');
-              if (poaidx2 > poaidx1)
-                {
-                  // continue to try again
-                  key2 = key2.substring(0, poaidx2);
-                  continue;
-                }
-              else
-                {
-                  break;
-                }
-            }
-        } // while()
+void
+INS_Loc_ResponseHandler::send_exception (CORBA::Exception *ex)
+{
+  ACE_DEBUG ((LM_DEBUG, "INS_Loc_ResponseHandler send_exception, rh_ = %x\n",
+              rh_.ptr()));
 
-      //  No match is found
-      throw CORBA::TRANSIENT (CORBA::SystemException::_tao_minor_code (
-                                TAO_IMPLREPO_MINOR_CODE,
-                                0),
-                              CORBA::COMPLETED_NO);
-    }
+  delete ex;
+  rh_->raise_excep (CORBA::TRANSIENT (CORBA::SystemException::_tao_minor_code
+                                              (TAO_IMPLREPO_MINOR_CODE, 0),
+                                              CORBA::COMPLETED_NO));
+  delete this;
 }
diff --git a/TAO/orbsvcs/ImplRepo_Service/INS_Locator.h b/TAO/orbsvcs/ImplRepo_Service/INS_Locator.h
index 1e892df895f..3aee6001873 100644
--- a/TAO/orbsvcs/ImplRepo_Service/INS_Locator.h
+++ b/TAO/orbsvcs/ImplRepo_Service/INS_Locator.h
@@ -22,10 +22,25 @@
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
 #include "tao/LocalObject.h"
-
+#include "ImR_ResponseHandler.h"
+#include "tao/IORTable/Locate_ResponseHandler.h"
 
 class ImR_Locator_i;
 
+class INS_Loc_ResponseHandler : public ImR_ResponseHandler
+{
+public:
+  INS_Loc_ResponseHandler (const char *key, ::IORTable::Locate_ResponseHandler rh);
+
+  // dummy implementations used for internal operations
+  virtual void send_ior (const char *pior);
+  virtual void send_exception (CORBA::Exception *ex);
+
+private:
+  ACE_CString key_;
+  TAO_AMH_Locate_ResponseHandler_var rh_;
+};
+
 /**
  * @class INS_Locator
  *
@@ -35,7 +50,7 @@ class ImR_Locator_i;
  * to dynamically receive a IOR to forward in response to an INS request.
  */
 class INS_Locator
-  : public virtual IORTable::Locator,
+  : public virtual IORTable::AsyncLocator,
     public virtual ::CORBA::LocalObject
 {
 public:
@@ -43,6 +58,8 @@ public:
 
   /// Locate the appropriate IOR.
   char* locate (const char *object_key);
+  void async_locate (::IORTable::Locate_ResponseHandler handler,
+                     const char *object_key);
 
 private:
   ImR_Locator_i& imr_locator_;
diff --git a/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.cpp b/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.cpp
index 6036d21b820..55c4fa3d0c5 100644
--- a/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.cpp
+++ b/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.cpp
@@ -405,6 +405,29 @@ ImR_Locator_i::notify_child_death
   _tao_rh->notify_child_death ();
 }
 
+char*
+ImR_Locator_i::activate_server_by_name (const char* name, bool manual_start)
+{
+  ImR_SyncResponseHandler rh ("", this->orb_.in());
+  this->activate_server_by_name (name, manual_start, &rh);
+  return rh.wait_for_result ();
+}
+
+char*
+ImR_Locator_i::activate_server_by_object (const char* object_name)
+{
+  Server_Info_Ptr si;
+  ACE_CString key;
+  ACE_CString full (object_name);
+  if (this->split_key (full, key, si))
+    {
+      ImR_SyncResponseHandler rh (key.c_str(), this->orb_.in());
+      this->activate_server_by_info (si, &rh);
+      return rh.wait_for_result ();
+    }
+  throw ImplementationRepository::NotFound();
+}
+
 void
 ImR_Locator_i::activate_server
 (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
@@ -424,6 +447,40 @@ ImR_Locator_i::activate_server
   activate_server_by_name (server, true, rh);
 }
 
+bool
+ImR_Locator_i::get_info_for_name (const char* name, Server_Info_Ptr &si)
+{
+  ACE_CString serverKey;
+  ACE_CString server_id;
+  bool jacorb_server = false;
+  this->parse_id (name, server_id, serverKey, jacorb_server);
+  si = this->repository_->get_server (serverKey);
+  return !si.null();
+}
+
+bool
+ImR_Locator_i::split_key (ACE_CString &full, ACE_CString &key, Server_Info_Ptr &si)
+{
+  key = full;
+  if (this->get_info_for_name (full.c_str(), si))
+    {
+      return true;
+    }
+
+  ACE_CString::size_type pos = full.rfind ('/');
+  while (pos != ACE_CString::npos)
+    {
+      ACE_CString server = full.substring (0, pos);
+      if (this->get_info_for_name (server.c_str (), si))
+        {
+          return true;
+        }
+      pos = server.rfind ('/');
+    }
+
+  return false;
+}
+
 void
 ImR_Locator_i::activate_server_by_name (const char* name, bool manual_start,
                                         ImR_ResponseHandler *rh)
@@ -432,59 +489,24 @@ ImR_Locator_i::activate_server_by_name (const char* name, bool manual_start,
   // servers unless manual_start=true
   ACE_ASSERT (name != 0);
 
-  ACE_CString serverKey;
-  ACE_CString server_id;
-  bool jacorb_server = false;
-  this->parse_id (name, server_id, serverKey, jacorb_server);
-  UpdateableServerInfo info (this->repository_.get(), serverKey);
-  if (info.null ())
+  Server_Info_Ptr si;
+  if (!this->get_info_for_name(name, si))
     {
-      ACE_ERROR ((
-        LM_ERROR,
-        ACE_TEXT ("ImR: Cannot find info for server <%C>\n"),
-        name));
-      throw ImplementationRepository::NotFound ();
+      rh->send_exception ( new ImplementationRepository::NotFound );
+      return;
     }
 
-  //MDM
-  info.edit()->start_count = 0;
+  UpdateableServerInfo info (this->repository_.get(), si, true);
 
   this->activate_server_i (info, manual_start, rh);
 }
 
-char*
-ImR_Locator_i::activate_server_by_name (const char* name, bool manual_start)
-{
-  ImR_SyncResponseHandler rh (this->orb_.in());
-  this->activate_server_by_name (name, manual_start, &rh);
-  return rh.wait_for_result ();
-}
-
-char*
-ImR_Locator_i::activate_server_by_object (const char* object_name)
+void
+ImR_Locator_i::activate_server_by_info (const Server_Info_Ptr &si,
+                                        ImR_ResponseHandler *rh)
 {
-  ACE_ASSERT (object_name != 0);
-
-  // We assume that the first part of the object name is the server name.
-  // So a name of foo/bar means that the server name is foo.
-  ACE_CString server_name (object_name);
-  ACE_CString::size_type pos = server_name.find ('/');
-  if (pos != ACE_CString::npos)
-    {
-      try
-        {
-          return activate_server_by_name (object_name, false);
-        }
-      catch (ImplementationRepository::NotFound&)
-        {
-          server_name = server_name.substr (pos + 1);
-          return activate_server_by_name (server_name.c_str (), false);
-        }
-    }
-  else
-    {
-      return activate_server_by_name (server_name.c_str (), false);
-    }
+  UpdateableServerInfo info (this->repository_.get(), si, true);
+  this->activate_server_i (info, false, rh);
 }
 
 void
@@ -498,7 +520,8 @@ ImR_Locator_i::activate_server_i (UpdateableServerInfo& info,
       AsyncAccessManager *aam_raw;
       ACE_NEW (aam_raw, AsyncAccessManager (*info, manual_start, *this));
       aam = aam_raw;
-      this->aam_set_.insert (aam);
+      int result = this->aam_set_.insert (aam);
+      ACE_DEBUG ((LM_DEBUG, "ImR_Locator_i::activate_server_i(PC) insert_aam returned %d\n", result));
     }
   else
     {
@@ -508,10 +531,13 @@ ImR_Locator_i::activate_server_i (UpdateableServerInfo& info,
           AsyncAccessManager *aam_raw;
           ACE_NEW (aam_raw, AsyncAccessManager (*info, manual_start, *this));
           aam = aam_raw;
-          this->aam_set_.insert_tail (aam);
+          ACE_DEBUG ((LM_DEBUG, "ImR_Locator_i::activate_server_i calling insert_aam size = %d\n", aam_set_.size()));
+          int result = this->aam_set_.insert_tail (aam);
+          ACE_DEBUG ((LM_DEBUG, "ImR_Locator_i::activate_server_i after insert_aam size = %d returned %d\n", aam_set_.size(), result));
         }
     }
   aam->add_interest (rh);
+  ACE_DEBUG ((LM_DEBUG, "ImR_Locator_i::activate_server_i returning\n"));
 }
 
 CORBA::Object_ptr
@@ -593,7 +619,7 @@ ImR_Locator_i::add_or_update_server
   ACE_CString serverKey;
   ACE_CString server_id;
   bool jacorb_server = false;
-  this->parse_id(server, server_id, serverKey, jacorb_server);
+  this->parse_id (server, server_id, serverKey, jacorb_server);
   UpdateableServerInfo info(this->repository_.get(), serverKey);
   if (info.null ())
     {
@@ -655,10 +681,10 @@ ImR_Locator_i::add_or_update_server
 }
 
 void
-ImR_Locator_i::parse_id(const char* id,
-                        ACE_CString& server_id,
-                        ACE_CString& name,
-                        bool& jacorb_server)
+ImR_Locator_i::parse_id (const char* id,
+                         ACE_CString& server_id,
+                         ACE_CString& name,
+                         bool& jacorb_server)
 {
   const char *pos = ACE_OS::strchr (id, ':');
   if (pos)
@@ -925,7 +951,8 @@ ImR_Locator_i::server_is_running
       ACE_NEW (aam_raw, AsyncAccessManager (*temp_info, true, *this));
       AsyncAccessManager_ptr aam (aam_raw);
       aam->started_running ();
-      this->aam_set_.insert (aam);
+      int result = this->aam_set_.insert (aam);
+      ACE_DEBUG ((LM_DEBUG, "ImR_Locator_i::server_is_running insert_aam returned %d\n", result));
     }
   else
     {
@@ -953,11 +980,14 @@ ImR_Locator_i::server_is_running
         aam->server_is_running (partial_ior);
       else
         {
+          ACE_DEBUG ((LM_DEBUG, "Server_Is_Running, %s not found in aam set\n",
+                      name.c_str()));
           AsyncAccessManager *aam_raw;
           ACE_NEW (aam_raw, AsyncAccessManager (*info, true, *this));
           AsyncAccessManager_ptr aam (aam_raw);
           aam->started_running ();
-          this->aam_set_.insert (aam);
+          int result = this->aam_set_.insert (aam);
+          ACE_DEBUG ((LM_DEBUG, "ImR_Locator_i::server_is_running insert_aam returned %d\n", result));
         }
     }
   _tao_rh->server_is_running ();
@@ -1315,18 +1345,24 @@ ImR_Locator_i::root_poa (void)
 void
 ImR_Locator_i::remove_aam (AsyncAccessManager_ptr &aam)
 {
-  this->aam_set_.remove (aam);
+  ACE_DEBUG ((LM_DEBUG, "ImR_Locator_i::remove_aam calling remove\n"));
+  int result = this->aam_set_.remove (aam);
+  ACE_DEBUG ((LM_DEBUG, "ImR_Locator_i::remove_aam, remove returned %d\n", result));
+
 }
 
 AsyncAccessManager *
 ImR_Locator_i::find_aam (const char *name)
 {
+  ACE_DEBUG ((LM_DEBUG, "ImR_Locator_i::find_aam called for %s, set size = %d\n", name, aam_set_.size()));
+
   for (AAM_Set::ITERATOR i = this->aam_set_.begin();
        i != this->aam_set_.end();
        ++i)
     {
       if ((*i)->has_server (name))
         {
+          ACE_DEBUG ((LM_DEBUG, "ImR_Locator_i::find_aam add ref and return\n"));
           return (*i)->add_ref();
         }
     }
@@ -1386,8 +1422,9 @@ SyncListener::status_changed (LiveStatus status)
 
 //---------------------------------------------------------------------------
 
-ImR_SyncResponseHandler::ImR_SyncResponseHandler (CORBA::ORB_ptr orb)
+ImR_SyncResponseHandler::ImR_SyncResponseHandler (const char *objkey, CORBA::ORB_ptr orb)
   :excep_ (0),
+   key_ (objkey),
    orb_ (CORBA::ORB::_duplicate (orb))
 {
 }
@@ -1399,7 +1436,10 @@ ImR_SyncResponseHandler::~ImR_SyncResponseHandler (void)
 void
 ImR_SyncResponseHandler::send_ior (const char *pior)
 {
-  this->result_ = pior;
+  ACE_DEBUG ((LM_DEBUG,"ImR_SyncResponseHandler send_ior called\n"));
+  ACE_CString full (pior);
+  full += this->key_;
+  this->result_ = full.c_str();
 }
 
 void
@@ -1439,6 +1479,7 @@ ImR_Loc_ResponseHandler::~ImR_Loc_ResponseHandler (void)
 void
 ImR_Loc_ResponseHandler::send_ior (const char *)
 {
+  ACE_DEBUG ((LM_DEBUG,"ImR_Loc_ResponseHandler send_ior called, opid = %d\n", op_id_));
   switch (this->op_id_)
     {
     case LOC_ACTIVATE_SERVER:
diff --git a/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.h b/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.h
index 409347df184..40ffd1c289d 100644
--- a/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.h
+++ b/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.h
@@ -123,15 +123,19 @@ public:
     (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
      const char * name);
 
-  // Used by the INS_Locator to start a sever given an object name
+  // Used by the INS_Locator to start a sever given an object name synchronously
   char* activate_server_by_object (const char* object_name);
   char* activate_server_by_name (const char * name, bool manual_start);
 
-  // Helper function also used by the Forwarder
+  // Asynchronous versions, used by both INS_Locator and Forwarder
+  void activate_server_by_info (const Server_Info_Ptr &si,
+                                ImR_ResponseHandler *rh);
 
-  void  activate_server_by_name (const char * name,
-                                 bool manual_start,
-                                 ImR_ResponseHandler *rh);
+  void activate_server_by_name (const char * name,
+                                bool manual_start,
+                                ImR_ResponseHandler *rh);
+
+  bool split_key (ACE_CString &full, ACE_CString &key, Server_Info_Ptr &si);
 
   // interfaces to aid with collaboration
 
@@ -144,6 +148,8 @@ public:
 
 private:
 
+  bool get_info_for_name (const char *name, Server_Info_Ptr &si);
+
   void  activate_server_i (UpdateableServerInfo& info,
                            bool manual_start,
                            ImR_ResponseHandler *rh);
@@ -231,7 +237,7 @@ class SyncListener : public LiveListener
 class ImR_SyncResponseHandler : public ImR_ResponseHandler
 {
 public:
-  ImR_SyncResponseHandler (CORBA::ORB_ptr orb);
+  ImR_SyncResponseHandler (const char *key, CORBA::ORB_ptr orb);
   virtual ~ImR_SyncResponseHandler (void);
 
   virtual void send_ior (const char *pior);
@@ -242,6 +248,7 @@ public:
 private:
   CORBA::String_var result_;
   CORBA::Exception *excep_;
+  ACE_CString key_;
   CORBA::ORB_var orb_;
 };
 
diff --git a/TAO/orbsvcs/ImplRepo_Service/LiveCheck.cpp b/TAO/orbsvcs/ImplRepo_Service/LiveCheck.cpp
index ccfb7affe78..8e560694b7c 100644
--- a/TAO/orbsvcs/ImplRepo_Service/LiveCheck.cpp
+++ b/TAO/orbsvcs/ImplRepo_Service/LiveCheck.cpp
@@ -71,6 +71,7 @@ LiveEntry::add_listener (LiveListener* ll)
 {
   ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->lock_);
   this->listeners_.insert (ll);
+  //  ACE_DEBUG ((LM_DEBUG, "LiveEntry(%s)::add_listener\n", this->server_.c_str()));
 }
 
 LiveStatus
@@ -100,7 +101,12 @@ LiveEntry::status (LiveStatus l)
       this->retry_count_ = 0;
       ACE_Time_Value now (ACE_High_Res_Timer::gettimeofday_hr());
       this->next_check_ = now + owner_->ping_interval();
+      ACE_DEBUG ((LM_DEBUG, "LiveEntry(%s)::status updating next check to now + %d ms\n",
+                  this->server_.c_str(),
+                  owner_->ping_interval().msec()));
     }
+  ACE_DEBUG ((LM_DEBUG, "LiveEntry(%s)::status updating listeners, size = %d\n",
+              this->server_.c_str(), this->listeners_.size()));
 
   Listen_Set remove;
 
@@ -139,6 +145,8 @@ LiveEntry::status (LiveStatus l)
 
   if (this->listeners_.size() > 0)
     {
+      ACE_DEBUG ((LM_DEBUG, "LiveEntry(%s)::status requesting new ping\n",
+                  this->server_.c_str()));
       this->owner_->schedule_ping (this);
     }
 }
@@ -155,22 +163,30 @@ LiveEntry::do_ping (PortableServer::POA_ptr poa)
   ACE_Time_Value now (ACE_High_Res_Timer::gettimeofday_hr());
   if (this->liveliness_ == LS_PING_AWAY || this->listeners_.size() == 0)
     {
+      ACE_DEBUG ((LM_DEBUG, "LiveEntry(%s)::do_ping, ping_away_ is %d, listeners size = %d\n",
+                  this->server_.c_str(), (this->liveliness_ == LS_PING_AWAY), this->listeners_.size()));
       return false;
     }
 
   if (this->next_check_ > now || this->liveliness_ == LS_DEAD)
     {
       ACE_Time_Value diff = next_check_ - now;
+      ACE_DEBUG ((LM_DEBUG, "LiveEntry(%s)::do_ping, too soon = %d, nc = %d, now = %d,  come back in %d ms, status = %d\n",
+                  this->server_.c_str(), (this->next_check_ > now), this->next_check_.msec(), now.msec(), diff.msec(), liveliness_));
       return false;
     }
 
   switch (this->liveliness_)
     {
     case LS_UNKNOWN:
+      ACE_DEBUG ((LM_DEBUG, "LiveEntry(%s)::do_ping, unknown, seting next_check_ to now\n",
+                  this->server_.c_str()));
       this->next_check_ = now;
       break;
     case LS_ALIVE:
     case LS_TIMEDOUT:
+      ACE_DEBUG ((LM_DEBUG, "LiveEntry(%s)::do_ping, alive or timed out, seting next_check_ to ping interval\n",
+                  this->server_.c_str()));
       this->next_check_ = now + owner_->ping_interval();
       break;
     case LS_TRANSIENT:
@@ -179,10 +195,14 @@ LiveEntry::do_ping (PortableServer::POA_ptr poa)
         if (ms != -1)
           {
             ACE_Time_Value next (ms / 1000, (ms % 1000) * 1000);
+            ACE_DEBUG ((LM_DEBUG, "LiveEntry(%s)::do_ping, transient, adding %d ms (should be %d)\n",
+                        this->server_.c_str(), next.msec(), ms));
             this->next_check_ = now + next;
           }
         else
           {
+            ACE_DEBUG ((LM_DEBUG, "LiveEntry(%s)::do_ping, transient, but no next\n",
+                        this->server_.c_str()));
             return false;
           }
       }
@@ -195,6 +215,8 @@ LiveEntry::do_ping (PortableServer::POA_ptr poa)
     this->liveliness_ = LS_PING_AWAY;
     this->retry_count_++;
   }
+  ACE_DEBUG ((LM_DEBUG, "LiveEntry(%s)::do_ping, sending ping, retry count = %d\n",
+              this->server_.c_str(), retry_count_));
   PortableServer::ServantBase_var callback = new PingReceiver (this, poa);
   PortableServer::ObjectId_var oid = poa->activate_object (callback.in());
   CORBA::Object_var obj = poa->id_to_reference (oid.in());
@@ -220,6 +242,7 @@ PingReceiver::~PingReceiver (void)
 void
 PingReceiver::ping (void)
 {
+  ACE_DEBUG ((LM_DEBUG, "PingReceiver::ping\n"));
   this->entry_->status (LS_ALIVE);
   PortableServer::ObjectId_var oid = this->poa_->servant_to_id (this);
   poa_->deactivate_object (oid.in());
@@ -230,6 +253,7 @@ PingReceiver::ping_excep (Messaging::ExceptionHolder * excep_holder)
 {
   try
     {
+      ACE_DEBUG ((LM_DEBUG, "PingReceiver::ping_excep\n"));
       excep_holder->raise_exception ();
     }
   catch (CORBA::TRANSIENT &ex)
@@ -288,6 +312,8 @@ void
 LiveCheck::init (CORBA::ORB_ptr orb,
                  const ACE_Time_Value &pi )
 {
+  ACE_DEBUG ((LM_DEBUG, "LiveCheck::init (), ping interval = %d ms\n",
+              pi.msec()));
   this->ping_interval_ = pi;
   ACE_Reactor *r = orb->orb_core()->reactor();
   this->reactor (r);
@@ -311,12 +337,14 @@ LiveCheck::ping_interval (void) const
 
 int
 LiveCheck::handle_timeout (const ACE_Time_Value &,
-                           const void */*tok*/)
+                           const void *tok)
 {
-  //  long token = reinterpret_cast<long>(tok);
+  long token = reinterpret_cast<long>(tok);
   if (!this->running_)
     return -1;
 
+  ACE_DEBUG ((LM_DEBUG, "LiveCheck::handle_timeout (tok = %d) entry_map.size = %d\n",
+              token, this->entry_map_.current_size()));
   bool want_reping = false;
   ACE_Time_Value next;
   LiveEntryMap::iterator the_end = this->entry_map_.end();
@@ -395,6 +423,8 @@ LiveCheck::handle_timeout (const ACE_Time_Value &,
       ACE_Time_Value now (ACE_High_Res_Timer::gettimeofday_hr());
       ACE_Time_Value delay = next - now;
       ++this->token_;
+      ACE_DEBUG ((LM_DEBUG, "LiveCheck::handle_timeout schdeuling next (tok = %d) - in %d ms \n",
+                  this->token_, delay.msec()));
       this->reactor()->schedule_timer (this, reinterpret_cast<void *>(this->token_), delay);
     }
 
@@ -450,6 +480,9 @@ LiveCheck::add_per_client_listener (LiveListener *l,
       entry->add_listener (l);
 
       ++this->token_;
+      ACE_DEBUG ((LM_DEBUG,
+                  "LiveCheck::add_per_client_listener schdeuling next (tok = %d) now\n",
+                  this->token_));
       this->reactor()->schedule_timer (this,
                                        reinterpret_cast<void *>(this->token_),
                                        ACE_Time_Value::zero);
@@ -486,6 +519,9 @@ LiveCheck::schedule_ping (LiveEntry *entry)
   LiveStatus status = entry->status();
   if (status == LS_PING_AWAY || status == LS_DEAD)
     {
+      ACE_DEBUG ((LM_DEBUG,
+                  "LiveCheck::schedule_ping ignoring, status = %d\n",
+                  status));
       return;
     }
 
@@ -494,6 +530,9 @@ LiveCheck::schedule_ping (LiveEntry *entry)
   ++this->token_;
   if (next <= now)
     {
+      ACE_DEBUG ((LM_DEBUG,
+                  "LiveCheck::schedule_ping (tok = %d) - immediate \n",
+                  this->token_));
       this->reactor()->schedule_timer (this,
                                        reinterpret_cast<void *>(this->token_),
                                        ACE_Time_Value::zero);
@@ -501,6 +540,9 @@ LiveCheck::schedule_ping (LiveEntry *entry)
   else
     {
       ACE_Time_Value delay = next - now;
+      ACE_DEBUG ((LM_DEBUG,
+                  "LiveCheck::schedule_ping (tok = %d) - in %dms \n",
+                  this->token_, delay.msec()));
       this->reactor()->schedule_timer (this,
                                        reinterpret_cast<void *>(this->token_),
                                        delay);
diff --git a/TAO/orbsvcs/ImplRepo_Service/Locator_Repository.cpp b/TAO/orbsvcs/ImplRepo_Service/Locator_Repository.cpp
index 9dcc0d4383b..fd18d93299d 100644
--- a/TAO/orbsvcs/ImplRepo_Service/Locator_Repository.cpp
+++ b/TAO/orbsvcs/ImplRepo_Service/Locator_Repository.cpp
@@ -444,11 +444,17 @@ UpdateableServerInfo::UpdateableServerInfo (
 }
 
 UpdateableServerInfo::UpdateableServerInfo (Locator_Repository* repo,
-                                           const Server_Info_Ptr& si)
+                                            const Server_Info_Ptr& si,
+                                            bool reset_start_count)
 : repo_(repo),
   si_(si),
   needs_update_(false)
 {
+  if (reset_start_count)
+    {
+      needs_update_ = repo_ != 0;
+      si_->start_count = 0;
+    }
 }
 
 UpdateableServerInfo::UpdateableServerInfo (const Server_Info& si)
diff --git a/TAO/orbsvcs/ImplRepo_Service/Locator_Repository.h b/TAO/orbsvcs/ImplRepo_Service/Locator_Repository.h
index f9ab1888e63..d38a66525a5 100644
--- a/TAO/orbsvcs/ImplRepo_Service/Locator_Repository.h
+++ b/TAO/orbsvcs/ImplRepo_Service/Locator_Repository.h
@@ -214,7 +214,9 @@ public:
   /// constructor
   /// @param repo the repo to report updates to
   /// @param si an already retrieved Server_Info_Ptr
-  UpdateableServerInfo(Locator_Repository* repo, const Server_Info_Ptr& si);
+  UpdateableServerInfo(Locator_Repository* repo,
+                       const Server_Info_Ptr& si,
+                       bool reset_start_count = false);
 
   /// constructor (no repo updates will be performed)
   /// @param si a Server_Info to create a non-stored Server_Info_Ptr from
diff --git a/TAO/tao/Adapter.h b/TAO/tao/Adapter.h
index 6a0fd845adc..c0185c7e32a 100644
--- a/TAO/tao/Adapter.h
+++ b/TAO/tao/Adapter.h
@@ -86,7 +86,12 @@ public:
 
     /// Forward the request to another object reference, this decouples
     /// the ORB from the PortableServer::ForwardRequest exception
-    DS_FORWARD
+    DS_FORWARD,
+
+    /// The request will be forwarded, but using an async call to locate
+    /// the target. Some other entity will actually complete the forward
+    /// or fail.
+    DS_DEFERRED_FORWARD
   };
 
   /// Return the name, i.e. the object id used to resolve it in the
diff --git a/TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.cpp b/TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.cpp
index 82d61a2c887..85634b6c6e1 100644
--- a/TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.cpp
+++ b/TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.cpp
@@ -289,6 +289,7 @@ TAO_AMH_DSI_Exception_Holder::_tao_unmarshal (
 void
 TAO_AMH_DSI_Exception_Holder::raise_invoke ()
 {
+  auto_ptr< ::CORBA::Exception> safety (this->exception_);
   this->exception_->_raise ();
 }
 
diff --git a/TAO/tao/IORTable/IORTable.h b/TAO/tao/IORTable/IORTable.h
index 7bae99afdb1..f29071c3d3f 100644
--- a/TAO/tao/IORTable/IORTable.h
+++ b/TAO/tao/IORTable/IORTable.h
@@ -40,6 +40,7 @@ TAO_Requires_IORTable_Initializer = TAO_IORTable_Initializer::init ();
 TAO_END_VERSIONED_NAMESPACE_DECL
 
 #define TAO_IORTABLE_SAFE_INCLUDE
+#include "tao/IORTable/Locate_ResponseHandler.h"
 #include "tao/IORTable/IORTableC.h"
 #undef TAO_IORTABLE_SAFE_INCLUDE
 
diff --git a/TAO/tao/IORTable/IORTable.mpc b/TAO/tao/IORTable/IORTable.mpc
index 7ab07c8d446..b2dd0ab5d6f 100644
--- a/TAO/tao/IORTable/IORTable.mpc
+++ b/TAO/tao/IORTable/IORTable.mpc
@@ -17,7 +17,7 @@ project(*core_idl) : tao_versioning_idl_defaults, install {
   }
 }
 
-project(IORTable) : taolib, tao_output, install, taoidldefaults {
+project(IORTable) : taolib, portableserver, dynamicinterface, tao_output, install, taoidldefaults {
   after       += *core_idl
   sharedname   = TAO_IORTable
   dynamicflags += TAO_IORTable_BUILD_DLL
diff --git a/TAO/tao/IORTable/IORTable.pidl b/TAO/tao/IORTable/IORTable.pidl
index 3725767eaf7..0088477dcd6 100644
--- a/TAO/tao/IORTable/IORTable.pidl
+++ b/TAO/tao/IORTable/IORTable.pidl
@@ -64,6 +64,20 @@ module IORTable
     string locate (in string object_key)
       raises (NotFound);
   };
+
+  /// Callback interface to locate object keys dynamically
+  /**
+   * The application can provide a callback interface to locate object
+   * keys dynamically.
+   */
+  native Locate_ResponseHandler;
+  local interface AsyncLocator : Locator
+  {
+    /// Uses AMH semantics to send IOR for @a object_key via the supplied
+    /// response handler
+    void async_locate (in Locate_ResponseHandler rh, in string object_key);
+
+  };
 };
 
 #endif /* TAO_IORTABLE_IORTABLE_PIDL */
diff --git a/TAO/tao/IORTable/IOR_Table_Impl.cpp b/TAO/tao/IORTable/IOR_Table_Impl.cpp
index 64e1ead30b5..664e60231eb 100644
--- a/TAO/tao/IORTable/IOR_Table_Impl.cpp
+++ b/TAO/tao/IORTable/IOR_Table_Impl.cpp
@@ -8,6 +8,8 @@
  */
 
 #include "tao/IORTable/IOR_Table_Impl.h"
+#include "tao/PortableServer/ForwardRequestC.h"
+#include "tao/DynamicInterface/AMH_DSI_Response_Handler.h"
 #include "ace/Guard_T.h"
 
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
@@ -43,6 +45,7 @@ TAO::Objref_Traits <TAO_IOR_Table_Impl>::marshal (const TAO_IOR_Table_Impl_ptr,
 }
 
 TAO_IOR_Table_Impl::TAO_IOR_Table_Impl (void)
+  : use_async_(false)
 {
 }
 
@@ -68,6 +71,32 @@ TAO_IOR_Table_Impl::find (const char *object_key)
 }
 
 void
+TAO_IOR_Table_Impl::async_find (::IORTable::Locate_ResponseHandler handler,
+                                const char *object_key)
+{
+  // We don't want the lock held during locate, so make it go out
+  // of scope before then.
+  {
+    ACE_CString key (object_key);
+    ACE_CString ior;
+    TAO_AMH_Locate_ResponseHandler_var rh = handler;
+    ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->lock_);
+    if (this->map_.find (key, ior) == 0)
+      {
+        rh->forward_ior (ior.c_str(), false);
+        return;
+      }
+    if (CORBA::is_nil (this->async_locator_.in ()))
+      {
+        rh->raise_excep (IORTable::NotFound ());
+        return;
+      }
+  }
+
+  this->async_locator_->async_locate (handler, object_key);
+}
+
+void
 TAO_IOR_Table_Impl::bind (const char * object_key, const char * IOR)
 {
   ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->lock_);
@@ -95,6 +124,8 @@ TAO_IOR_Table_Impl::set_locator (IORTable::Locator_ptr locator)
 {
   ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->lock_);
   this->locator_ = IORTable::Locator::_duplicate (locator);
+  this->async_locator_ = IORTable::AsyncLocator::_narrow (locator);
+  this->use_async_ = !CORBA::is_nil (this->async_locator_.in());
 }
 
 TAO_END_VERSIONED_NAMESPACE_DECL
diff --git a/TAO/tao/IORTable/IOR_Table_Impl.h b/TAO/tao/IORTable/IOR_Table_Impl.h
index 275a4dd3eea..19c24eb0dda 100644
--- a/TAO/tao/IORTable/IOR_Table_Impl.h
+++ b/TAO/tao/IORTable/IOR_Table_Impl.h
@@ -54,9 +54,17 @@ public:
   /// Constructor
   TAO_IOR_Table_Impl (void);
 
+  bool async_available (void) const
+  {
+    return this->use_async_;
+  }
+
   /// Find the object, using the locator if it is not on the table.
   char *find (const char *object_key);
 
+  void async_find (::IORTable::Locate_ResponseHandler rh,
+                   const char *object_key);
+
   /**
    * @name The IORTable::Table methods
    *
@@ -83,6 +91,8 @@ private:
 
   /// The locator
   IORTable::Locator_var locator_;
+  IORTable::AsyncLocator_var async_locator_;
+  bool use_async_;
 
   /// Synchronization
   TAO_SYNCH_MUTEX lock_;
diff --git a/TAO/tao/IORTable/Locate_ResponseHandler.cpp b/TAO/tao/IORTable/Locate_ResponseHandler.cpp
new file mode 100644
index 00000000000..4f72e2142c0
--- /dev/null
+++ b/TAO/tao/IORTable/Locate_ResponseHandler.cpp
@@ -0,0 +1,418 @@
+// -*- C++ -*-
+//=============================================================================
+/**
+ *  @file    Locate_ResponseHandler.cpp
+ *
+ *  $Id$
+ *
+ *  @author Phil Mesnier <mesnier_p@ociweb>
+ */
+//=============================================================================
+
+#include "Locate_ResponseHandler.h"
+#if 0
+#include "tao/DynamicInterface/Request.h"
+#include "tao/DynamicInterface/ExceptionList.h"
+#include "tao/DynamicInterface/DII_Invocation.h"
+#include "tao/DynamicInterface/Server_Request.h"
+#endif
+
+#include "tao/Exception.h"
+#include "tao/ORB_Core.h"
+#include "tao/GIOP_Utils.h"
+#include "tao/PortableServer/Root_POA.h"
+//#include "tao/Valuetype/ValueFactory.h"
+#include "tao/Object.h"
+#include "tao/Pluggable_Messaging_Utils.h"
+//#include "tao/AnyTypeCode/Any_Impl.h"
+
+#if !defined (__ACE_INLINE__)
+# include "Locate_ResponseHandler.inl"
+#endif /* ! __ACE_INLINE__ */
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+#if 0
+const char*
+TAO_AMH_DSI_Exception_Holder::_tao_obv_static_repository_id ()
+{
+  return "IDL:TAO_AMH_DSI_Exception_Holder:1.0";
+}
+
+TAO_AMH_DSI_Exception_Holder::TAO_AMH_DSI_Exception_Holder (CORBA::Exception *ex)
+  : exception_ (ex)
+{
+}
+
+TAO_AMH_DSI_Exception_Holder::~TAO_AMH_DSI_Exception_Holder ()
+{
+}
+
+void
+tao_TAO_AMH_DSI_Exception_Holder_add_ref (TAO_AMH_DSI_Exception_Holder * p)
+{
+  CORBA::add_ref (p);
+}
+
+void
+tao_TAO_AMH_DSI_Exception_Holder_remove_ref (TAO_AMH_DSI_Exception_Holder * p)
+{
+  CORBA::remove_ref (p);
+}
+
+
+TAO_AMH_DSI_Exception_Holder_var::TAO_AMH_DSI_Exception_Holder_var (void)
+  : ptr_ (0)
+{
+}
+
+TAO_AMH_DSI_Exception_Holder_var::TAO_AMH_DSI_Exception_Holder_var (
+    TAO_AMH_DSI_Exception_Holder * p)
+  : ptr_ (p)
+{
+}
+
+TAO_AMH_DSI_Exception_Holder_var::TAO_AMH_DSI_Exception_Holder_var (
+    const TAO_AMH_DSI_Exception_Holder * p)
+  : ptr_ (const_cast<TAO_AMH_DSI_Exception_Holder *> (p))
+{
+}
+
+TAO_AMH_DSI_Exception_Holder *
+TAO_AMH_DSI_Exception_Holder_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder_var::TAO_AMH_DSI_Exception_Holder_var (
+    const TAO_AMH_DSI_Exception_Holder_var & p)
+{
+  CORBA::add_ref (p.ptr ());
+  this->ptr_ = p.ptr ();
+}
+
+TAO_AMH_DSI_Exception_Holder_var::~TAO_AMH_DSI_Exception_Holder_var (void)
+{
+  CORBA::remove_ref (this->ptr_);
+}
+
+TAO_AMH_DSI_Exception_Holder_var &
+TAO_AMH_DSI_Exception_Holder_var::operator= (TAO_AMH_DSI_Exception_Holder *p)
+{
+  CORBA::remove_ref (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+TAO_AMH_DSI_Exception_Holder_var &
+TAO_AMH_DSI_Exception_Holder_var::operator= (
+    const TAO_AMH_DSI_Exception_Holder_var & p)
+{
+  if (this != &p)
+    {
+      CORBA::remove_ref (this->ptr_);
+      TAO_AMH_DSI_Exception_Holder *tmp = p.ptr ();
+      CORBA::add_ref (tmp);
+      this->ptr_ = tmp;
+    }
+
+  return *this;
+}
+
+TAO_AMH_DSI_Exception_Holder_var::operator const TAO_AMH_DSI_Exception_Holder* (
+    ) const // cast
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder_var::operator TAO_AMH_DSI_Exception_Holder*& ()
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder *
+TAO_AMH_DSI_Exception_Holder_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder *
+TAO_AMH_DSI_Exception_Holder_var::in (void) const
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder *&
+TAO_AMH_DSI_Exception_Holder_var::inout (void)
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder *&
+TAO_AMH_DSI_Exception_Holder_var::out (void)
+{
+  CORBA::remove_ref (this->ptr_);
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder *
+TAO_AMH_DSI_Exception_Holder_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  TAO_AMH_DSI_Exception_Holder* tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+void
+TAO_AMH_DSI_Exception_Holder_var::tao_add_ref (TAO_AMH_DSI_Exception_Holder *p)
+{
+  CORBA::add_ref (p);
+}
+
+void
+TAO_AMH_DSI_Exception_Holder_var::tao_remove_ref (
+    TAO_AMH_DSI_Exception_Holder *p)
+{
+  CORBA::remove_ref (p);
+}
+
+TAO_AMH_DSI_Exception_Holder_out::TAO_AMH_DSI_Exception_Holder_out (
+    TAO_AMH_DSI_Exception_Holder * &p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+TAO_AMH_DSI_Exception_Holder_out::TAO_AMH_DSI_Exception_Holder_out (
+     TAO_AMH_DSI_Exception_Holder_var & p)
+  : ptr_ (p.out ())
+{
+  CORBA::remove_ref (this->ptr_);
+  this->ptr_ = 0;
+}
+
+TAO_AMH_DSI_Exception_Holder_out::TAO_AMH_DSI_Exception_Holder_out (
+    const TAO_AMH_DSI_Exception_Holder_out &p)
+  : ptr_ (const_cast<TAO_AMH_DSI_Exception_Holder_out&> (p).ptr_)
+{}
+
+TAO_AMH_DSI_Exception_Holder_out &
+TAO_AMH_DSI_Exception_Holder_out::operator= (
+    const TAO_AMH_DSI_Exception_Holder_out &p)
+{
+  this->ptr_ = const_cast<TAO_AMH_DSI_Exception_Holder_out &> (p).ptr_;
+  return *this;
+}
+
+TAO_AMH_DSI_Exception_Holder_out &
+TAO_AMH_DSI_Exception_Holder_out::operator= (
+    const TAO_AMH_DSI_Exception_Holder_var &p)
+{
+  TAO_AMH_DSI_Exception_Holder *tmp = p.ptr ();
+  CORBA::add_ref (tmp);
+  this->ptr_ = tmp;
+  return *this;
+}
+
+TAO_AMH_DSI_Exception_Holder_out &
+TAO_AMH_DSI_Exception_Holder_out::operator= (TAO_AMH_DSI_Exception_Holder *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+TAO_AMH_DSI_Exception_Holder_out::operator TAO_AMH_DSI_Exception_Holder*& ()
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder *&
+TAO_AMH_DSI_Exception_Holder_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder *
+TAO_AMH_DSI_Exception_Holder_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder *
+TAO_AMH_DSI_Exception_Holder::_downcast (CORBA::ValueBase * v)
+{
+  return dynamic_cast < TAO_AMH_DSI_Exception_Holder * >(v);
+}
+
+const char *
+TAO_AMH_DSI_Exception_Holder::_tao_obv_repository_id (void) const
+{
+  return this->_tao_obv_static_repository_id ();
+}
+
+void
+TAO_AMH_DSI_Exception_Holder::_tao_any_destructor (void *_tao_void_pointer)
+{
+  TAO_AMH_DSI_Exception_Holder *tmp =
+    static_cast<TAO_AMH_DSI_Exception_Holder *> (_tao_void_pointer);
+  delete tmp;
+}
+
+CORBA::Boolean
+TAO_AMH_DSI_Exception_Holder::_tao_unmarshal (
+    TAO_InputCDR &strm,
+    TAO_AMH_DSI_Exception_Holder *&new_object)
+{
+  ::CORBA::ValueBase *base = 0;
+  ::CORBA::Boolean is_indirected = 0;
+  ::CORBA::Boolean is_null_object = 0;
+  ::CORBA::Boolean const retval =
+    ::CORBA::ValueBase::_tao_unmarshal_pre (
+        strm,
+        base,
+        TAO_AMH_DSI_Exception_Holder::_tao_obv_static_repository_id (),
+        is_null_object,
+        is_indirected
+      );
+
+  ::CORBA::ValueBase_var owner (base);
+
+  if (!retval)
+    return 0;
+
+  if (is_null_object)
+    return 1;
+
+  if (!is_indirected && base != 0 && ! base->_tao_unmarshal_v (strm))
+    return 0;
+
+
+  // Now base must be null or point to the unmarshaled object.
+  // Align the pointer to the right subobject.
+  new_object = TAO_AMH_DSI_Exception_Holder::_downcast (base);
+  if (is_indirected)
+    new_object->_add_ref ();
+
+  owner._retn ();
+  return 1;
+}
+
+void
+TAO_AMH_DSI_Exception_Holder::raise_invoke ()
+{
+  this->exception_->_raise ();
+}
+#endif
+
+// The pseudo-object _nil method.
+TAO_AMH_Locate_ResponseHandler_ptr
+TAO_AMH_Locate_ResponseHandler::_nil (void)
+{
+  return (TAO_AMH_Locate_ResponseHandler_ptr) 0;
+}
+
+
+TAO_AMH_Locate_ResponseHandler::TAO_AMH_Locate_ResponseHandler (
+    TAO_ServerRequest & sr)
+  : TAO_AMH_Response_Handler ()
+{
+  this->init (sr,0);
+}
+
+TAO_AMH_Locate_ResponseHandler::~TAO_AMH_Locate_ResponseHandler (void)
+{
+}
+
+void
+TAO_AMH_Locate_ResponseHandler::raise_excep (const CORBA::Exception &ex)
+{
+  this->_tao_rh_send_exception (ex);
+}
+
+void
+TAO_AMH_Locate_ResponseHandler::forward_ior (const char *ior, CORBA::Boolean is_perm)
+{
+  CORBA::ORB_var orb = this->orb_core_->orb();
+  CORBA::Object_var fwd = orb->string_to_object (ior);
+  this->_tao_rh_send_location_forward (fwd, is_perm);
+}
+
+
+void *
+TAO_AMH_Locate_ResponseHandler::_downcast (const char *)
+{
+  return this;
+}
+
+TAO_AMH_Locate_ResponseHandler_ptr
+TAO_AMH_Locate_ResponseHandler::_narrow (CORBA::Object_ptr obj)
+{
+  return TAO_AMH_Locate_ResponseHandler::_unchecked_narrow (obj);
+}
+
+TAO_AMH_Locate_ResponseHandler_ptr
+TAO_AMH_Locate_ResponseHandler::_unchecked_narrow (CORBA::Object_ptr obj)
+{
+  if (CORBA::is_nil (obj))
+    return TAO_AMH_Locate_ResponseHandler::_nil ();
+
+  return dynamic_cast < TAO_AMH_Locate_ResponseHandler_ptr > (obj);
+}
+
+const char*
+TAO_AMH_Locate_ResponseHandler::_interface_repository_id (void) const
+{
+  return 0;
+}
+
+#if 0
+
+CORBA::TypeCode_ptr
+TAO_AMH_DSI_Exception_Holder::_tao_type (void) const
+{
+  return 0;
+}
+
+void
+TAO_AMH_DSI_Exception_Holder::_tao_obv_truncatable_repo_ids (
+    Repository_Id_List &) const
+{
+}
+
+CORBA::Boolean
+TAO_AMH_DSI_Exception_Holder::_tao_match_formal_type (ptrdiff_t ) const
+{
+  return false;
+}
+
+CORBA::Boolean
+TAO_AMH_DSI_Exception_Holder::_tao_marshal_v (TAO_OutputCDR &) const
+{
+  return true;
+}
+
+CORBA::Boolean
+TAO_AMH_DSI_Exception_Holder::_tao_unmarshal_v (TAO_InputCDR &)
+{
+  return true;
+}
+
+CORBA::Boolean
+TAO_AMH_DSI_Exception_Holder::_tao_marshal__Test_TAO_AMH_DSI_Exception_Holder (
+    TAO_OutputCDR &)
+{
+  return true;
+}
+
+CORBA::Boolean
+TAO_AMH_DSI_Exception_Holder::_tao_unmarshal__Test_TAO_AMH_DSI_Exception_Holder (
+    TAO_InputCDR &)
+{
+  return true;
+}
+
+#endif
+
+TAO_END_VERSIONED_NAMESPACE_DECL
diff --git a/TAO/tao/IORTable/Locate_ResponseHandler.h b/TAO/tao/IORTable/Locate_ResponseHandler.h
new file mode 100644
index 00000000000..49d9f69ce2f
--- /dev/null
+++ b/TAO/tao/IORTable/Locate_ResponseHandler.h
@@ -0,0 +1,272 @@
+// -*- C++ -*-
+
+
+//=============================================================================
+/**
+ *  @file    Locate_ResponseHandler.h
+ *
+ *  $Id$
+ *
+ *  @author Phil Mesnier <mesnier_p@ociweb>
+ */
+//=============================================================================
+
+
+#ifndef TAO_LOCATE_RESPONSEHANDLER_H
+#define TAO_LOCATE_RESPONSEHANDLER_H
+
+#include /**/ "ace/pre.h"
+
+#include "tao/orbconf.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "iortable_export.h"
+#include "tao/Versioned_Namespace.h"
+#include "tao/Messaging/AMH_Response_Handler.h"
+#include "tao/Valuetype/ValueBase.h"
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+namespace CORBA
+{
+  class Exception;
+}
+
+class TAO_AMH_Locate_ResponseHandler;
+typedef
+typedef TAO_AMH_Locate_ResponseHandler *TAO_AMH_Locate_ResponseHandler_ptr;
+
+/**
+ * @class TAO_AMH_Locate_ResponseHandler_var
+ *
+ * @brief The T_var class for response handler
+ *
+ * As any other pseudo object, this class has a T_var class too.
+ *
+ */
+class TAO_IORTable_Export TAO_AMH_Locate_ResponseHandler_var
+{
+public:
+  TAO_AMH_Locate_ResponseHandler_var (void);
+  TAO_AMH_Locate_ResponseHandler_var (TAO_AMH_Locate_ResponseHandler_ptr);
+  TAO_AMH_Locate_ResponseHandler_var (
+      const TAO_AMH_Locate_ResponseHandler_var &);
+  ~TAO_AMH_Locate_ResponseHandler_var (void);
+
+  TAO_AMH_Locate_ResponseHandler_var &operator= (
+      TAO_AMH_Locate_ResponseHandler_ptr);
+  TAO_AMH_Locate_ResponseHandler_var &operator= (
+      const TAO_AMH_Locate_ResponseHandler_var &);
+  TAO_AMH_Locate_ResponseHandler_ptr operator-> (void) const;
+
+  operator const TAO_AMH_Locate_ResponseHandler_ptr &() const;
+  operator TAO_AMH_Locate_ResponseHandler_ptr &();
+
+  TAO_AMH_Locate_ResponseHandler_ptr in (void) const;
+  TAO_AMH_Locate_ResponseHandler_ptr &inout (void);
+  TAO_AMH_Locate_ResponseHandler_ptr &out (void);
+  TAO_AMH_Locate_ResponseHandler_ptr _retn (void);
+  TAO_AMH_Locate_ResponseHandler_ptr ptr (void) const;
+
+private:
+  TAO_AMH_Locate_ResponseHandler_ptr ptr_;
+};
+
+#if 0
+class TAO_AMH_Locate_Exception_Holder;
+typedef TAO_AMH_Locate_Exception_Holder *TAO_AMH_Locate_Exception_Holder_ptr;
+
+/**
+ * @class TAO_AMH_Locate_Exception_Holder_var
+ *
+ * @brief The T_var class for exception holder
+ *
+ * As any other pseudo object, this class has a T_var class too.
+ *
+ */
+class TAO_IORTable_Export TAO_AMH_Locate_Exception_Holder_var
+{
+public:
+  TAO_AMH_Locate_Exception_Holder_var (void);
+  TAO_AMH_Locate_Exception_Holder_var (TAO_AMH_Locate_Exception_Holder*);
+  TAO_AMH_Locate_Exception_Holder_var (const TAO_AMH_Locate_Exception_Holder*);
+  TAO_AMH_Locate_Exception_Holder_var (const TAO_AMH_Locate_Exception_Holder_var &);
+  ~TAO_AMH_Locate_Exception_Holder_var (void);
+
+  TAO_AMH_Locate_Exception_Holder_var &operator= (TAO_AMH_Locate_Exception_Holder*);
+  TAO_AMH_Locate_Exception_Holder_var &operator= (
+      const TAO_AMH_Locate_Exception_Holder_var &);
+  TAO_AMH_Locate_Exception_Holder* operator-> (void) const;
+
+  operator const TAO_AMH_Locate_Exception_Holder* () const;
+  operator TAO_AMH_Locate_Exception_Holder*& ();
+
+  TAO_AMH_Locate_Exception_Holder* in (void) const;
+  TAO_AMH_Locate_Exception_Holder*& inout (void);
+  TAO_AMH_Locate_Exception_Holder*& out (void);
+  TAO_AMH_Locate_Exception_Holder* _retn (void);
+  TAO_AMH_Locate_Exception_Holder* ptr (void) const;
+
+  // Hooks used by template sequence and valuetype manager classes
+  // for non-defined forward declared valuetypes.
+  static void tao_add_ref (TAO_AMH_Locate_Exception_Holder *);
+  static void tao_remove_ref (TAO_AMH_Locate_Exception_Holder *);
+
+private:
+  TAO_AMH_Locate_Exception_Holder* ptr_;
+};
+
+/**
+ * @class TAO_AMH_Locate_Exception_Holder_out
+ *
+ * @brief The T_out class for exception holder
+ *
+ */
+class TAO_IORTable_Export TAO_AMH_Locate_Exception_Holder_out
+{
+public:
+  TAO_AMH_Locate_Exception_Holder_out (TAO_AMH_Locate_Exception_Holder* &);
+  TAO_AMH_Locate_Exception_Holder_out (TAO_AMH_Locate_Exception_Holder_var &);
+  TAO_AMH_Locate_Exception_Holder_out (const TAO_AMH_Locate_Exception_Holder_out &);
+  TAO_AMH_Locate_Exception_Holder_out &operator= (
+      const TAO_AMH_Locate_Exception_Holder_out &);
+  TAO_AMH_Locate_Exception_Holder_out &operator= (
+      const TAO_AMH_Locate_Exception_Holder_var &);
+  TAO_AMH_Locate_Exception_Holder_out &operator= (
+      TAO_AMH_Locate_Exception_Holder*);
+  operator TAO_AMH_Locate_Exception_Holder*& ();
+  TAO_AMH_Locate_Exception_Holder*& ptr (void);
+  TAO_AMH_Locate_Exception_Holder* operator-> (void);
+
+private:
+  TAO_AMH_Locate_Exception_Holder* &ptr_;
+};
+
+/**
+ * @class TAO_AMH_Locate_Exception_Holder
+ *
+ * @brief This is the class for holding exception.
+ *
+ */
+class TAO_IORTable_Export TAO_AMH_Locate_Exception_Holder
+  : public virtual CORBA::DefaultValueRefCountBase,
+    public virtual CORBA::ValueBase
+{
+public:
+  typedef TAO_AMH_Locate_Exception_Holder_var _var_type;
+  TAO_AMH_Locate_Exception_Holder (CORBA::Exception *ex);
+
+  virtual ~TAO_AMH_Locate_Exception_Holder (void);
+
+  static TAO_AMH_Locate_Exception_Holder* _downcast ( CORBA::ValueBase* );
+
+  static CORBA::Boolean _tao_unmarshal ( TAO_InputCDR &,
+                                         TAO_AMH_Locate_Exception_Holder *& );
+  virtual const char* _tao_obv_repository_id (void) const;
+  static const char* _tao_obv_static_repository_id (void);
+
+  static void _tao_any_destructor (void *);
+
+  virtual void raise_invoke ( );
+
+  CORBA::TypeCode_ptr _tao_type (void) const;
+  void _tao_obv_truncatable_repo_ids (Repository_Id_List &) const;
+  CORBA::Boolean _tao_match_formal_type (ptrdiff_t ) const;
+
+protected:
+  TAO_AMH_Locate_Exception_Holder (void);
+  ///  *** Terrible Hack ? ***
+  virtual CORBA::Boolean _tao_marshal_v (TAO_OutputCDR &) const;
+  virtual CORBA::Boolean _tao_unmarshal_v (TAO_InputCDR &);
+
+private:
+  TAO_AMH_Locate_Exception_Holder (const TAO_AMH_Locate_Exception_Holder &);
+  void operator= (const TAO_AMH_Locate_Exception_Holder &);
+  CORBA::Exception *exception_;
+
+protected:
+  virtual CORBA::Boolean _tao_marshal__Test_TAO_AMH_Locate_Exception_Holder (
+              TAO_OutputCDR &);
+  virtual CORBA::Boolean _tao_unmarshal__Test_TAO_AMH_Locate_Exception_Holder (
+              TAO_InputCDR &);
+};
+
+#endif
+
+/**
+ * @class TAO_AMH_Locate_ResponseHandler
+ *
+ * @brief This is the main class for DSI using AMH.
+ *
+ * With ordinary DSI, the POA calls _dispatch, which in turn calls invoke
+ * on the DSI handler. Invoke completely handles the request, and packages
+ * the result in the request object so that it can be marshalled and sent
+ * back to the caller.
+ *
+ * With the AMH variation, the DSI handler's invoke method starts the
+ * processing, but delegates the result packaging to a response handler.
+ * This way, if the invocation takes a long time, or involves blocking
+ * calls, then the result handling can be managed by another thread.
+ * This is particularly useful for gateway implementations, where the
+ * middle tier should not have to block waiting for replies.
+ *
+ * As this is built on the CORBA object model, there are separate classes
+ * representing the interface and the implementation.
+ *
+ */
+class TAO_IORTable_Export TAO_AMH_Locate_ResponseHandler
+  : public virtual TAO_AMH_Response_Handler
+{
+public:
+  typedef TAO_AMH_Locate_ResponseHandler_ptr _ptr_type;
+  typedef TAO_AMH_Locate_ResponseHandler_var _var_type;
+
+  TAO_AMH_Locate_ResponseHandler (TAO_ServerRequest &sr);
+  ~TAO_AMH_Locate_ResponseHandler (void);
+
+  virtual void raise_excep (const CORBA::Exception &ex);
+
+  virtual void forward_ior (const char *ior, CORBA::Boolean is_perm);
+
+  /// Returns a CORBA::Object_ptr for the target object.
+  CORBA::Object_ptr _this ();
+
+  /// CORBA Object related methods
+  static TAO_AMH_Locate_ResponseHandler* _duplicate (
+             TAO_AMH_Locate_ResponseHandler_ptr);
+  static TAO_AMH_Locate_ResponseHandler* _nil (void);
+  static TAO_AMH_Locate_ResponseHandler* _narrow (CORBA::Object_ptr);
+  static TAO_AMH_Locate_ResponseHandler* _unchecked_narrow (CORBA::Object_ptr);
+
+protected:
+
+  /// Return 0.  Should never be used.
+  virtual const char *_interface_repository_id (void) const;
+
+  /// Simply returns "this"
+  virtual void *_downcast (const char *repository_id);
+
+private:
+  TAO_ORB_Core *orb_core_;
+};
+
+
+namespace IORTable
+{
+  // satisfy the native type requirement for the asnyc locate interface
+  typedef const TAO_AMH_Locate_ResponseHandler_var &Locate_ResponseHandler;
+
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+#if defined (__ACE_INLINE__)
+# include "Locate_ResponseHandler.inl"
+#endif /* __ACE_INLINE__ */
+
+#include /**/ "ace/post.h"
+
+#endif /* TAO_LOCATE_RESPONSEHANDLER_H */
diff --git a/TAO/tao/IORTable/Locate_ResponseHandler.inl b/TAO/tao/IORTable/Locate_ResponseHandler.inl
new file mode 100644
index 00000000000..ea0497f7d37
--- /dev/null
+++ b/TAO/tao/IORTable/Locate_ResponseHandler.inl
@@ -0,0 +1,112 @@
+// -*- C++ -*-
+// $Id$
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+ACE_INLINE TAO_AMH_Locate_ResponseHandler_ptr
+TAO_AMH_Locate_ResponseHandler::_duplicate (TAO_AMH_Locate_ResponseHandler_ptr x)
+{
+  if (x != 0)
+    {
+      x->_add_ref ();
+    }
+
+  return x;
+}
+
+
+// Inline operations for class TAO_AMH_Locate_ResponseHandler_var
+ACE_INLINE
+TAO_AMH_Locate_ResponseHandler_var::TAO_AMH_Locate_ResponseHandler_var (void)
+  : ptr_ (TAO_AMH_Locate_ResponseHandler::_nil ())
+{
+}
+
+ACE_INLINE
+TAO_AMH_Locate_ResponseHandler_var::TAO_AMH_Locate_ResponseHandler_var (TAO_AMH_Locate_ResponseHandler_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+TAO_AMH_Locate_ResponseHandler_var::~TAO_AMH_Locate_ResponseHandler_var (void)
+{
+  CORBA::release(ptr_);
+}
+
+ACE_INLINE TAO_AMH_Locate_ResponseHandler_ptr
+TAO_AMH_Locate_ResponseHandler_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+TAO_AMH_Locate_ResponseHandler_var::TAO_AMH_Locate_ResponseHandler_var (const TAO_AMH_Locate_ResponseHandler_var &p)
+  : ptr_ (TAO_AMH_Locate_ResponseHandler::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE TAO_AMH_Locate_ResponseHandler_var &
+TAO_AMH_Locate_ResponseHandler_var::operator= (TAO_AMH_Locate_ResponseHandler_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE TAO_AMH_Locate_ResponseHandler_var &
+TAO_AMH_Locate_ResponseHandler_var::operator= (const TAO_AMH_Locate_ResponseHandler_var &p)
+{
+  if (this != &p)
+    {
+      CORBA::release (this->ptr_);
+      this->ptr_ = TAO_AMH_Locate_ResponseHandler::_duplicate (p.ptr ());
+    }
+  return *this;
+}
+
+ACE_INLINE
+TAO_AMH_Locate_ResponseHandler_var::operator const TAO_AMH_Locate_ResponseHandler_ptr &() const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+TAO_AMH_Locate_ResponseHandler_var::operator TAO_AMH_Locate_ResponseHandler_ptr &()
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_AMH_Locate_ResponseHandler_ptr
+TAO_AMH_Locate_ResponseHandler_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_AMH_Locate_ResponseHandler_ptr
+TAO_AMH_Locate_ResponseHandler_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_AMH_Locate_ResponseHandler_ptr &
+TAO_AMH_Locate_ResponseHandler_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_AMH_Locate_ResponseHandler_ptr &
+TAO_AMH_Locate_ResponseHandler_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = TAO_AMH_Locate_ResponseHandler::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_AMH_Locate_ResponseHandler_ptr
+TAO_AMH_Locate_ResponseHandler_var::_retn (void)
+{
+  // yield ownership
+  TAO_AMH_Locate_ResponseHandler_ptr val = this->ptr_;
+  this->ptr_ = TAO_AMH_Locate_ResponseHandler::_nil ();
+  return val;
+}
+TAO_END_VERSIONED_NAMESPACE_DECL
diff --git a/TAO/tao/IORTable/Table_Adapter.cpp b/TAO/tao/IORTable/Table_Adapter.cpp
index 34634eae681..994ead28bdd 100644
--- a/TAO/tao/IORTable/Table_Adapter.cpp
+++ b/TAO/tao/IORTable/Table_Adapter.cpp
@@ -9,6 +9,8 @@
 
 #include "tao/IORTable/Table_Adapter.h"
 #include "tao/IORTable/IOR_Table_Impl.h"
+#include "tao/IORTable/Locate_ResponseHandler.h"
+
 #include "tao/ORB_Core.h"
 #include "tao/Server_Strategy_Factory.h"
 #include "tao/Object.h"
@@ -93,6 +95,15 @@ TAO_Table_Adapter::dispatch (TAO::ObjectKey &key,
     rootref = this->root_;
   }
 
+  if (this->root_->async_available ())
+    {
+      // construct a callback handler
+      TAO_AMH_Locate_ResponseHandler_var rh;
+      ACE_NEW_RETURN (rh, TAO_AMH_Locate_ResponseHandler (request), DS_MISMATCHED_KEY);
+      this->find_object (rh, key);
+      return 0;
+    }
+
   if (this->find_object (key, forward_to))
     {
       request.forward_location (forward_to);
@@ -189,6 +200,16 @@ TAO_Table_Adapter::find_object (TAO::ObjectKey &key,
   return true;
 }
 
+
+void
+TAO_Table_Adapter::find_object (IORTable::Locate_ResponseHandler rh,
+                                TAO::ObjectKey &key)
+{
+  CORBA::String_var object_key;
+  TAO::ObjectKey::encode_sequence_to_string (object_key.out (), key);
+  root_->async_find (rh, object_key.in ());
+}
+
 // ****************************************************************
 
 TAO_Table_Adapter_Factory::TAO_Table_Adapter_Factory (void)
diff --git a/TAO/tao/IORTable/Table_Adapter.h b/TAO/tao/IORTable/Table_Adapter.h
index b0bef6fc05b..73b3a6d10b8 100644
--- a/TAO/tao/IORTable/Table_Adapter.h
+++ b/TAO/tao/IORTable/Table_Adapter.h
@@ -65,6 +65,10 @@ private:
   bool find_object (TAO::ObjectKey &key,
                     CORBA::Object_out forward_to);
 
+  void find_object (::IORTable::Locate_ResponseHandler rh,
+                    TAO::ObjectKey &key);
+
+
   /// The ORB Core we belong to
   TAO_ORB_Core &orb_core_;
 
diff --git a/TAO/tao/Messaging/AMH_Response_Handler.cpp b/TAO/tao/Messaging/AMH_Response_Handler.cpp
index bf2ea0b9bbd..8ef72f378fe 100644
--- a/TAO/tao/Messaging/AMH_Response_Handler.cpp
+++ b/TAO/tao/Messaging/AMH_Response_Handler.cpp
@@ -77,6 +77,7 @@ TAO_AMH_Response_Handler::init(TAO_ServerRequest &server_request,
   response_expected_  = server_request.response_expected_;
   transport_ = server_request.transport ();
   orb_core_ = server_request.orb_core ();
+  ACE_DEBUG ((LM_DEBUG, "AMH_Response_Handler::init, orb_core_ = %x\n", orb_core_));
   allocator_ = allocator;
 
   TAO_GIOP_Message_Version v;
@@ -86,6 +87,12 @@ TAO_AMH_Response_Handler::init(TAO_ServerRequest &server_request,
   this->transport_->add_reference ();
 }
 
+TAO_ORB_Core *
+TAO_AMH_Response_Handler::orb_core (void) const
+{
+  return this->orb_core_;
+}
+
 void
 TAO_AMH_Response_Handler::_tao_rh_init_reply (void)
 {
diff --git a/TAO/tao/Messaging/AMH_Response_Handler.h b/TAO/tao/Messaging/AMH_Response_Handler.h
index 12261a60cfa..0b4218679ae 100644
--- a/TAO/tao/Messaging/AMH_Response_Handler.h
+++ b/TAO/tao/Messaging/AMH_Response_Handler.h
@@ -89,6 +89,8 @@ public:
   virtual void _remove_ref (void);
   //@}
 
+  TAO_ORB_Core *orb_core (void) const;
+
 protected:
 
   /// Sets up the various parameters in anticipation of returning a reply
@@ -106,6 +108,7 @@ protected:
   void _tao_rh_send_location_forward (CORBA::Object_ptr fwd,
                                       CORBA::Boolean is_perm);
 
+
   /// The outgoing CDR stream
   /**
    * The IDL-generated ResponseHandler implementations used this field