TAO/tests/POA/Reference_Counting/test.cpp

   1 #include "HelloS.h"
   2
   3 class Hello_impl :
   4   virtual public POA_Hello
   5 {
   6 public:
   7   Hello_impl ()
   8   {
   9     ACE_DEBUG ((LM_DEBUG, "Hello_impl::Hello_impl()\n"));
  10   }
  11
  12   ~Hello_impl ()
  13   {
  14     ACE_DEBUG ((LM_DEBUG, "Hello_impl::~Hello_impl()\n"));
  15   }
  16
  17   virtual void moo (
  18     )
  19   {
  20   }
  21 };
  22
  23 CORBA::ULong
  24 getRefCount (PortableServer::ServantBase * sb)
  25 {
  26   return sb->_refcount_value ();
  27 }
  28
  29 int
  30 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
  31 {
  32   try
  33     {
  34       CORBA::ORB_var orb =
  35         CORBA::ORB_init (argc, argv);
  36
  37       CORBA::Object_var poa_object =
  38         orb->resolve_initial_references("RootPOA");
  39
  40       PortableServer::POA_var poa =
  41         PortableServer::POA::_narrow (poa_object.in ());
  42
  43       if (CORBA::is_nil (poa.in ()))
  44         ACE_ERROR_RETURN ((LM_ERROR,
  45                            " (%P|%t) Panic: nil RootPOA\n"),
  46                           1);
  47
  48       Hello_impl * h = 0;
  49       ACE_NEW_RETURN (h,Hello_impl, 1);
  50
  51       CORBA::ULong before_act = h->_refcount_value ();
  52
  53       ACE_DEBUG ((LM_DEBUG, "Before activation: %d\n", before_act));
  54
  55       PortableServer::ObjectId_var oid = poa->activate_object (h);
  56
  57       CORBA::ULong after_act = h->_refcount_value ();
  58
  59       ACE_DEBUG ((LM_DEBUG, "After activation: %d\n", after_act));
  60         {
  61           /*
  62            * C++ Language Mapping (formal/03-06-03), section 1.37.3 (Servant
  63            * Memory Management Considerations), first bullet on page 1-136:
  64            *
  65            *   POA::id_to_servant returns a Servant. The POA invokes _add_ref
  66            *   once on the Servant before returning it; the caller of
  67            *   id_to_servant is responsible for invoking _remove_ref on the
  68            *   returned servant when it is finished with it.
  69            */
  70
  71           CORBA::ULong refCountBeforeIdToServant =
  72             h->_refcount_value ();
  73
  74           ACE_DEBUG ((LM_DEBUG, "Before id_to_servant:  %d\n", refCountBeforeIdToServant));
  75
  76           PortableServer::ServantBase_var srv = poa->id_to_servant (oid.in());
  77
  78           CORBA::ULong refCountAfterIdToServant =
  79             srv->_refcount_value ();
  80
  81           ACE_DEBUG ((LM_DEBUG, "After id_to_servant:  %d\n", refCountAfterIdToServant));
  82
  83            /*
  84            * According to the above quote, this assertion shall be true.
  85            */
  86           ACE_ASSERT (refCountAfterIdToServant == refCountBeforeIdToServant + 1);
  87
  88           /*
  89            * At the end of this scope, "srv" is destructed, which decrements
  90            * the servant's reference count.
  91            */
  92         }
  93
  94       CORBA::ULong before_deact = h->_refcount_value ();
  95
  96       ACE_DEBUG ((LM_DEBUG, "Before deactivate_object: %d\n", before_deact));
  97
  98       poa->deactivate_object (oid.in());
  99
 100       /*
 101        * Because id_to_servant did not increment the reference count, but
 102        * the reference count was decremented by the "srv" destructor, the
 103        * reference count, using TAO 1.4.5, is now 0, and the servant has
 104        * been destructed. So the following will crash, despite being
 105        * correct.
 106        */
 107
 108       CORBA::ULong after_deact = h->_refcount_value ();
 109
 110       ACE_DEBUG ((LM_DEBUG, "After deactivate_object: %d\n", after_deact));
 111
 112       h->_remove_ref ();
 113
 114       orb->shutdown (true);
 115
 116       orb->destroy ();
 117     }
 118   catch (const CORBA::Exception& ex)
 119     {
 120       ex._tao_print_exception ("Exception caught:");
 121       return 1;
 122     }
 123
 124   return 0;
 125 }