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 (void)
  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 (void)
  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 (void) 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 (void)
 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 ACE_Mutex_Invariants::ACE_Mutex_Invariants (void)
 229 : owners_ (0)
 230 {
 231 }
 232
 233 int
 234 ACE_Mutex_Invariants::acquired (void)
 235 {
 236   if (++owners_ > 1)
 237     {
 238       owners_ = 42;
 239       return 0;
 240     }
 241   else
 242     return 1;
 243 }
 244
 245 void
 246 ACE_Mutex_Invariants::releasing (void)
 247 {
 248   if (owners_ == 1)
 249     --owners_;
 250 }
 251
 252 ACE_Mutex_Invariants::ACE_Mutex_Invariants (const ACE_Mutex_Invariants &rhs)
 253 : owners_ (rhs.owners_)
 254 {
 255 }
 256
 257 void
 258 ACE_Mutex_Invariants::operator= (const ACE_Mutex_Invariants &rhs)
 259 {
 260   owners_ = rhs.owners_;
 261 }
 262
 263 void
 264 ACE_Mutex_Invariants::dump (void) const
 265 {
 266 #if defined (ACE_HAS_DUMP)
 267   ACE_TRACE ("ACE_Mutex_Invariants::dump");
 268   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 269   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("owners_ = %d\n"), owners_));
 270   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 271 #endif /* ACE_HAS_DUMP */
 272 }
 273
 274 // **************************************************
 275 // **************************************************
 276 // **************************************************
 277
 278 ACE_RWLock_Invariants::ACE_RWLock_Invariants (void)
 279 : writers_ (0),
 280   readers_ (0)
 281 {
 282 }
 283
 284 int
 285 ACE_RWLock_Invariants::writer_acquired (void)
 286 {
 287   if (readers_ > 0)
 288     {
 289       writers_ = readers_ = 42;
 290       return 0;
 291     }
 292   else if (++writers_ > 1)
 293     {
 294       writers_ = readers_ = 42;
 295       return 0;
 296     }
 297   else
 298     return 1;
 299 }
 300
 301 int
 302 ACE_RWLock_Invariants::reader_acquired (void)
 303 {
 304   if (writers_ > 0)
 305     {
 306       writers_ = readers_ = 42;
 307       return 0;
 308     }
 309   else
 310     {
 311       ++readers_;
 312       return 1;
 313     }
 314 }
 315
 316 void
 317 ACE_RWLock_Invariants::releasing (void)
 318 {
 319   if (writers_ == 1)
 320     writers_ = 0;
 321   else if (readers_ > 0)
 322     --readers_;
 323 }
 324
 325 ACE_RWLock_Invariants::ACE_RWLock_Invariants (const ACE_RWLock_Invariants &rhs)
 326 : writers_ (rhs.writers_),
 327   readers_ (rhs.readers_)
 328 {
 329 }
 330
 331 void
 332 ACE_RWLock_Invariants::operator= (const ACE_RWLock_Invariants &rhs)
 333 {
 334   writers_ = rhs.writers_;
 335   readers_ = rhs.readers_;
 336 }
 337
 338 void
 339 ACE_RWLock_Invariants::dump (void) const
 340 {
 341 #if defined (ACE_HAS_DUMP)
 342   ACE_TRACE ("ACE_RWLock_Invariants::dump");
 343   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
 344   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("writers_ = %d readers_ = %d\n"),
 345               writers_, readers_));
 346   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 347 #endif /* ACE_HAS_DUMP */
 348 }
 349
 350 ACE_END_VERSIONED_NAMESPACE_DECL
 351
 352 #endif /* ACE_HAS_TOKENS_LIBRARY */