ACE/ace/Token_Invariants.cpp

   1 #include "ace/Token_Invariants.h"
   2
   3 #if defined (ACE_HAS_TOKENS_LIBRARY)
   4
   5 #include "ace/Object_Manager.h"
   6 #include "ace/os_include/os_typeinfo.h"
   7
   8 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   9
  10 ACE_Token_Invariant_Manager *ACE_Token_Invariant_Manager::instance_ = 0;
  11
  12 ACE_Token_Invariant_Manager *
  13 ACE_Token_Invariant_Manager::instance ()
  14 {
  15   ACE_TRACE ("ACE_Token_Invariant_Manager::instance");
  16
  17   // Perform the Double-Check pattern...
  18   if (instance_ == 0)
  19     {
  20       ACE_MT (ACE_TOKEN_CONST::MUTEX *lock =
  21         ACE_Managed_Object<ACE_TOKEN_CONST::MUTEX>::get_preallocated_object
  22           (ACE_Object_Manager::ACE_TOKEN_INVARIANTS_CREATION_LOCK);
  23         ACE_GUARD_RETURN (ACE_TOKEN_CONST::MUTEX, ace_mon, *lock, 0));
  24
  25       if (instance_ == 0)
  26         {
  27           ACE_NEW_RETURN (instance_,
  28                           ACE_Token_Invariant_Manager,
  29                           0);
  30           // Register for destruction with ACE_Object_Manager.
  31           ACE_Object_Manager::at_exit (instance_, 0, typeid (instance_).name ());
  32         }
  33     }
  34
  35   return instance_;
  36 }
  37
  38 ACE_Token_Invariant_Manager::ACE_Token_Invariant_Manager ()
  39 {
  40   ACE_TRACE ("ACE_Token_Invariant_Manager::ACE_Token_Invariant_Manager");
  41 }
  42
  43 int
  44 ACE_Token_Invariant_Manager::mutex_acquired (const ACE_TCHAR *token_name)
  45 {
  46   ACE_TRACE ("ACE_Token_Invariant_Manager::mutex_acquired");
  47
  48   ACE_GUARD_RETURN (ACE_TOKEN_CONST::MUTEX, ace_mon, this->lock_, -1);
  49
  50   ACE_Mutex_Invariants *inv = 0;
  51   if (this->get_mutex (token_name, inv) == -1)
  52     return -1;
  53
  54   return inv->acquired ();
  55 }
  56
  57 int
  58 ACE_Token_Invariant_Manager::acquired (const ACE_Token_Proxy *proxy)
  59 {
  60   ACE_TRACE ("ACE_Token_Invariant_Manager::acquired");
  61
  62   // Reach into the proxy to find the token type.
  63   if (proxy->token_->type () == ACE_Tokens::MUTEX)
  64     return this->mutex_acquired (proxy->name ());
  65   else // ACE_Tokens::RWLOCK.
  66     {
  67       if (proxy->type () == ACE_RW_Token::READER)
  68         return this->reader_acquired (proxy->name ());
  69       else // ACE_RW_Token::WRITER.
  70         return this->writer_acquired (proxy->name ());
  71     }
  72 }
  73
  74 void
  75 ACE_Token_Invariant_Manager::releasing (const ACE_Token_Proxy *proxy)
  76 {
  77   ACE_TRACE ("ACE_Token_Invariant_Manager::releasing");
  78
  79   // Reach into the proxy to find the token type.
  80   if (proxy->token_->type () == ACE_Tokens::MUTEX)
  81     this->mutex_releasing (proxy->name ());
  82   else // ACE_Tokens::RWLOCK.
  83     this->rwlock_releasing (proxy->name ());
  84 }
  85
  86 void
  87 ACE_Token_Invariant_Manager::mutex_releasing (const ACE_TCHAR *token_name)
  88 {
  89   ACE_TRACE ("ACE_Token_Invariant_Manager::mutex_releasing");
  90   ACE_GUARD (ACE_TOKEN_CONST::MUTEX, ace_mon, this->lock_);
  91
  92   ACE_Mutex_Invariants *inv = 0;
  93   if (this->get_mutex (token_name, inv) == 0)
  94     inv->releasing ();
  95 }
  96
  97 int
  98 ACE_Token_Invariant_Manager::reader_acquired (const ACE_TCHAR *token_name)
  99 {
 100   ACE_TRACE ("ACE_Token_Invariant_Manager::reader_acquired");
 101   ACE_GUARD_RETURN (ACE_TOKEN_CONST::MUTEX, ace_mon, this->lock_, -1);
 102
 103   ACE_RWLock_Invariants *inv = 0;
 104   if (this->get_rwlock (token_name, inv) == -1)
 105     return -1;
 106
 107   return inv->reader_acquired ();
 108 }
 109
 110 int
 111 ACE_Token_Invariant_Manager::writer_acquired (const ACE_TCHAR *token_name)
 112 {
 113   ACE_TRACE ("ACE_Token_Invariant_Manager::writer_acquired");
 114
 115   ACE_GUARD_RETURN (ACE_TOKEN_CONST::MUTEX, ace_mon, this->lock_, -1);
 116
 117   ACE_RWLock_Invariants *inv = 0;
 118   if (this->get_rwlock (token_name, inv) == -1)
 119     return -1;
 120
 121   return inv->writer_acquired ();
 122 }
 123
 124 void
 125 ACE_Token_Invariant_Manager::rwlock_releasing (const ACE_TCHAR *token_name)
 126 {
 127   ACE_TRACE ("ACE_Token_Invariant_Manager::rwlock_releasing");
 128
 129   ACE_GUARD (ACE_TOKEN_CONST::MUTEX, ace_mon, this->lock_);
 130
 131   ACE_RWLock_Invariants *inv = 0;
 132   if (this->get_rwlock (token_name, inv) == 0)
 133     inv->releasing ();
 134 }
 135
 136 void
 137 ACE_Token_Invariant_Manager::dump () const
 138 {
 139 #if defined (ACE_HAS_DUMP)
 140   ACE_TRACE ("ACE_Token_Invariant_Manager::dump");
 141   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 142   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("mutex_collection_:\n")));
 143   mutex_collection_.dump ();
 144   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("rwlock_collection_:\n")));
 145   rwlock_collection_.dump ();
 146   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 147 #endif /* ACE_HAS_DUMP */
 148 }
 149
 150
 151 int
 152 ACE_Token_Invariant_Manager::get_mutex (const ACE_TCHAR *token_name,
 153                                         ACE_Mutex_Invariants *&inv)
 154 {
 155   ACE_TRACE ("ACE_Token_Invariant_Manager::get_mutex");
 156   TOKEN_NAME name (token_name);
 157   if (mutex_collection_.find (name, inv) == -1)
 158     // We did not find one in the collection.
 159     {
 160       ACE_Mutex_Invariants *new_invariant;
 161
 162       ACE_NEW_RETURN (new_invariant,
 163                       ACE_Mutex_Invariants,
 164                       -1);
 165       if (mutex_collection_.bind (name, new_invariant) == -1)
 166         {
 167           delete new_invariant;
 168           return -1;
 169         }
 170
 171       if (mutex_collection_.find (name, inv) == -1)
 172         // We did not find one in the collection.
 173         return -1;
 174     }
 175
 176   return 0;
 177 }
 178
 179 int
 180 ACE_Token_Invariant_Manager::get_rwlock (const ACE_TCHAR *token_name,
 181                                          ACE_RWLock_Invariants *&inv)
 182 {
 183   ACE_TRACE ("ACE_Token_Invariant_Manager::get_rwlock");
 184   TOKEN_NAME name (token_name);
 185   if (rwlock_collection_.find (name, inv) == -1)
 186     // We did not find one in the collection.
 187     {
 188       ACE_RWLock_Invariants *new_invariant;
 189
 190       ACE_NEW_RETURN (new_invariant,
 191                       ACE_RWLock_Invariants,
 192                       -1);
 193       if (rwlock_collection_.bind (name, new_invariant) == -1)
 194         return -1;
 195
 196       if (rwlock_collection_.find (name, inv) == -1)
 197         // We did not find one in the collection.
 198         return -1;
 199     }
 200
 201   return 0;
 202 }
 203
 204
 205 ACE_Token_Invariant_Manager::~ACE_Token_Invariant_Manager ()
 206 {
 207   ACE_TRACE ("ACE_Token_Invariant_Manager::~ACE_Token_Invariant_Manager");
 208
 209   MUTEX_COLLECTION::ITERATOR iterator (mutex_collection_);
 210
 211   for (MUTEX_COLLECTION::ENTRY *temp = 0;
 212        iterator.next (temp) != 0;
 213        iterator.advance ())
 214     delete temp->int_id_;
 215
 216   RWLOCK_COLLECTION::ITERATOR iterator2 (rwlock_collection_);
 217
 218   for (RWLOCK_COLLECTION::ENTRY *temp2 = 0;
 219        iterator2.next (temp2) != 0;
 220        iterator2.advance ())
 221     delete temp2->int_id_;
 222 }
 223
 224 // **************************************************
 225 // **************************************************
 226 // **************************************************
 227
 228 int
 229 ACE_Mutex_Invariants::acquired ()
 230 {
 231   if (++owners_ > 1)
 232     {
 233       owners_ = 42;
 234       return 0;
 235     }
 236   else
 237     return 1;
 238 }
 239
 240 void
 241 ACE_Mutex_Invariants::releasing ()
 242 {
 243   if (owners_ == 1)
 244     --owners_;
 245 }
 246
 247 void
 248 ACE_Mutex_Invariants::dump () const
 249 {
 250 #if defined (ACE_HAS_DUMP)
 251   ACE_TRACE ("ACE_Mutex_Invariants::dump");
 252   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 253   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("owners_ = %d\n"), owners_));
 254   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 255 #endif /* ACE_HAS_DUMP */
 256 }
 257
 258 // **************************************************
 259
 260 int
 261 ACE_RWLock_Invariants::writer_acquired ()
 262 {
 263   if (readers_ > 0)
 264     {
 265       writers_ = readers_ = 42;
 266       return 0;
 267     }
 268   else if (++writers_ > 1)
 269     {
 270       writers_ = readers_ = 42;
 271       return 0;
 272     }
 273   else
 274     return 1;
 275 }
 276
 277 int
 278 ACE_RWLock_Invariants::reader_acquired ()
 279 {
 280   if (writers_ > 0)
 281     {
 282       writers_ = readers_ = 42;
 283       return 0;
 284     }
 285   else
 286     {
 287       ++readers_;
 288       return 1;
 289     }
 290 }
 291
 292 void
 293 ACE_RWLock_Invariants::releasing ()
 294 {
 295   if (writers_ == 1)
 296     writers_ = 0;
 297   else if (readers_ > 0)
 298     --readers_;
 299 }
 300
 301 void
 302 ACE_RWLock_Invariants::dump () const
 303 {
 304 #if defined (ACE_HAS_DUMP)
 305   ACE_TRACE ("ACE_RWLock_Invariants::dump");
 306   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 307   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("writers_ = %d readers_ = %d\n"),
 308               writers_, readers_));
 309   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 310 #endif /* ACE_HAS_DUMP */
 311 }
 312
 313 ACE_END_VERSIONED_NAMESPACE_DECL
 314
 315 #endif /* ACE_HAS_TOKENS_LIBRARY */