TAO/tests/CollocationLockup/CollocationLockup.cpp

   1 /**
   2  * CollocationLockup.cpp
   3  * This is regression test against bug #2130.
   4  * It tests a deadlock between a thread making a collocated invocation
   5  * (which holds a lock on the ORB core and attempts to lock the POA) and a
   6  * thread activating a servant (which locks the POA and attempts to lock the
   7  * ORB core).
   8  *
   9  * This test was developed from a test submitted by Rick Marlborough for bug
  10  * #2297 and refined by Paul Calabrese.
  11  */
  12
  13 #include "ABS.h"
  14 #include "SimpleNamingServiceC.h"
  15
  16 #include "ace/Thread_Manager.h"
  17 #include "ace/SString.h"
  18
  19 namespace
  20 {
  21 #if defined (ACE_OPENVMS)
  22   // less threads on OpenVMS otherwise this test
  23   // (although working correctly) takes far too long.
  24   const size_t N_THREADS = 10;
  25 #else
  26   const size_t N_THREADS = 20;
  27 #endif
  28   const size_t N_ITERATIONS = 100;
  29 }
  30
  31 class A_i : public virtual POA_A
  32 {
  33 };
  34
  35 class B_i : public virtual POA_C
  36 {
  37 public:
  38   B_i (PortableServer::POA_ptr poa)
  39     : poa_ (PortableServer::POA::_duplicate (poa))
  40   {}
  41
  42   virtual A_ptr
  43   makeA ()
  44   {
  45     PortableServer::ServantBase_var servant = new A_i;
  46     PortableServer::ObjectId_var tmp = this->poa_->activate_object (servant.in());
  47     CORBA::Object_var obj = this->poa_->servant_to_reference (servant.in());
  48     return A::_narrow (obj.in ());
  49   }
  50
  51 private:
  52   PortableServer::POA_var poa_;
  53 };
  54
  55 // Thread for ORB->run()
  56 ACE_THR_FUNC_RETURN OrbRunThread (void*);
  57
  58 // Thread to run the test
  59 ACE_THR_FUNC_RETURN TestThread (void*);
  60
  61 int
  62 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
  63 {
  64   try
  65     {
  66       // Normal corba init
  67       CORBA::ORB_var Orb = CORBA::ORB_init (argc, argv);
  68
  69       CORBA::Object_var pPoaObj =
  70         Orb->resolve_initial_references ("RootPOA");
  71       PortableServer::POA_var Poa = PortableServer::POA::_narrow (pPoaObj.in ());
  72       PortableServer::POAManager_var pMgr = Poa->the_POAManager ();
  73       pMgr->activate ();
  74
  75       CORBA::Object_var pNSObj =
  76         Orb->resolve_initial_references ("SimpleNamingService");
  77       SimpleNamingService_var NameService =
  78         SimpleNamingService::_narrow (pNSObj.in ());
  79
  80       if (CORBA::is_nil (NameService.in ()))
  81         {
  82           ACE_DEBUG ((LM_ERROR,
  83                       "ERROR: Could not locate the Simple Naming Service\n"));
  84           return 1;
  85         }
  86
  87       ACE_Thread_Manager orb_thread;
  88       orb_thread.spawn (OrbRunThread, Orb.in (), THR_NEW_LWP | THR_DETACHED);
  89
  90       // Setup
  91       PortableServer::ServantBase_var servant = new B_i (Poa.in ());
  92       PortableServer::ObjectId_var tmp = Poa->activate_object (servant.in());
  93       CORBA::Object_var b = Poa->servant_to_reference (servant.in());
  94
  95       NameService->bind (b.in ());
  96
  97       //Start threads
  98       ACE_Thread_Manager threads;
  99       threads.spawn_n (N_THREADS, TestThread, NameService.in ());
 100       ACE_DEBUG ((LM_INFO, "All threads spawned.\n"));
 101
 102       threads.wait ();
 103
 104       Orb->shutdown (0);
 105       orb_thread.wait();
 106       Orb->destroy ();
 107     } //destructor of ACE_Thread_Manager = implicit join
 108   catch (const CORBA::Exception& ex)
 109     {
 110       ACE_DEBUG ((LM_ERROR, "Corba Exception: %s\n", ex._info ().c_str ()));
 111       return 1;
 112     }
 113
 114   return 0;
 115 }
 116
 117 ACE_THR_FUNC_RETURN
 118 OrbRunThread (void *arg)
 119 {
 120   CORBA::ORB_var Orb =
 121     CORBA::ORB::_duplicate (reinterpret_cast<CORBA::ORB_ptr> (arg));
 122
 123   try
 124     {
 125       Orb->run ();
 126     }
 127   catch (const CORBA::Exception& ex)
 128     {
 129       ACE_DEBUG ((LM_ERROR,
 130                   "In OrbRunThread: Corba Exception: %s\n",
 131                   ex._info ().c_str ()));
 132     }
 133   return 0;
 134 }
 135
 136 ACE_THR_FUNC_RETURN
 137 TestThread (void *arg)
 138 {
 139   SimpleNamingService_var NameService =
 140     SimpleNamingService::_duplicate (reinterpret_cast<SimpleNamingService_ptr> (arg));
 141
 142   try
 143     {
 144       for (size_t i (0); i < N_ITERATIONS; ++i)
 145         {
 146           CORBA::Object_var obj = NameService->resolve ();
 147           C_var b = C::_narrow (obj.in ());
 148           A_var tmp = b->makeA ();
 149           if (i % 50 == 0)
 150             ACE_DEBUG ((LM_INFO, "(%t) collocated call returned\n"));
 151         }
 152     }
 153   catch (const CORBA::Exception& ex)
 154     {
 155       ACE_DEBUG ((LM_ERROR,
 156                   "In TestThread: Corba Exception: %s\n",
 157                   ex._info ().c_str ()));
 158     }
 159   return 0;
 160 }