src/Utils/ReaderWriterLock.cpp

   1 /*********************************************************************
   2 CReaderWriterLock: A simple and fast reader-writer lock class in C++
   3 has characters of .NET ReaderWriterLock class
   4 Copyright (C) 2006 Quynh Nguyen Huu
   5
   6 This library is free software; you can redistribute it and/or
   7 modify it under the terms of the GNU Lesser General Public
   8 License as published by the Free Software Foundation; either
   9 version 2.1 of the License, or (at your option) any later version.
  10
  11 This library is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 Lesser General Public License for more details.
  15
  16 Email questions, comments or suggestions to quynhnguyenhuu@gmail.com
  17 *********************************************************************/
  18
  19 #include "stdafx.h"
  20 #include <crtdbg.h>
  21 #include "ReaderWriterLock.h"
  22
  23 /////////////////////////////////////////////////////////////////
  24 // Following macros make this file can be used in non-MFC project
  25 #ifndef ASSERT
  26 // Define ASSERT macro
  27 #   define ASSERT _ASSERT
  28
  29 // Define VERIFY macro
  30 #   ifdef _DEBUG
  31 #       define VERIFY ASSERT
  32 #       define DEBUG_ONLY(f) ((void)(f))
  33 #   else
  34 #       define VERIFY(f) ((void)(f))
  35 #       define DEBUG_ONLY(f)
  36 #   endif
  37 #endif
  38
  39 ///////////////////////////////////////////////////////
  40 // CReaderWriterLockNonReentrance implementation
  41
  42 CReaderWriterLockNonReentrance::CReaderWriterLockNonReentrance() noexcept
  43 {
  44         SecureZeroMemory(this, sizeof(*this));
  45 #if (_WIN32_WINNT >= 0x0403)
  46         InitializeCriticalSectionAndSpinCount(&m_cs, READER_WRITER_SPIN_COUNT);
  47 #else
  48         InitializeCriticalSection(&m_cs);
  49 #endif
  50 }
  51
  52 CReaderWriterLockNonReentrance::~CReaderWriterLockNonReentrance()
  53 {
  54         _ASSERT(!m_hSafeToReadEvent && !m_hSafeToWriteEvent);
  55         DeleteCriticalSection(&m_cs);
  56 }
  57
  58 bool CReaderWriterLockNonReentrance::_ReaderWait(ULONGLONG dwTimeout) noexcept
  59 {
  60         bool blCanRead;
  61
  62         ++m_iNumOfReaderWaiting;
  63         if (!m_hSafeToReadEvent)
  64                 m_hSafeToReadEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
  65
  66         if(INFINITE == dwTimeout) // INFINITE is a special value
  67         {
  68                 while (0 != m_iNumOfWriter)
  69                 {
  70                         LeaveCS();
  71                         WaitForSingleObject(m_hSafeToReadEvent, INFINITE);
  72                         // There might be one or more Writers entered, that's
  73                         // why we need loop here
  74                         EnterCS();
  75                 }
  76
  77                 ++m_iNumOfReaderEntered;
  78                 blCanRead = TRUE;
  79         }
  80         else
  81         {
  82                 LeaveCS();
  83
  84                 ULONGLONG const dwBeginTime = GetTickCount64();
  85                 ULONGLONG dwConsumedTime = 0;
  86
  87                 while(TRUE)
  88                 {
  89                         blCanRead = (WAIT_OBJECT_0 == WaitForSingleObject(m_hSafeToReadEvent, static_cast<DWORD>(dwTimeout - dwConsumedTime)));
  90
  91                         EnterCS();
  92
  93                         if(0 == m_iNumOfWriter)
  94                         {
  95                                 // Regardless timeout or not, there is no Writer
  96                                 // So it's safe to be Reader right now
  97                                 ++m_iNumOfReaderEntered;
  98                                 blCanRead = TRUE;
  99                                 break;
 100                         }
 101
 102                         if (!blCanRead)
 103                         {
 104                                 // Timeout after waiting
 105                                 break;
 106                         }
 107
 108                         // There are some Writers have just entered
 109                         // So leave CS and prepare to try again
 110                         LeaveCS();
 111
 112                         dwConsumedTime = GetTickCount64() - dwBeginTime;
 113                         if(dwConsumedTime > dwTimeout)
 114                         {
 115                                 // Don't worry why the code here looks stupid
 116                                 // Because this case rarely happens, it's better
 117                                 //  to optimize code for the usual case
 118                                 blCanRead = FALSE;
 119                                 EnterCS();
 120                                 break;
 121                         }
 122                 }
 123         }
 124
 125         if(0==--m_iNumOfReaderWaiting)
 126         {
 127                 CloseHandle(m_hSafeToReadEvent);
 128                 m_hSafeToReadEvent = nullptr;
 129         }
 130
 131         return blCanRead;
 132 }
 133
 134 void CReaderWriterLockNonReentrance::_ReaderRelease() noexcept
 135 {
 136         INT _iNumOfReaderEntered = --m_iNumOfReaderEntered;
 137         _ASSERT(0 <= _iNumOfReaderEntered);
 138
 139         if (0 == _iNumOfReaderEntered && m_hSafeToWriteEvent)
 140         {
 141                 SetEvent(m_hSafeToWriteEvent);
 142         }
 143 }
 144
 145 bool CReaderWriterLockNonReentrance::_WriterWaitAndLeaveCSIfSuccess(ULONGLONG dwTimeout) noexcept
 146 {
 147         //EnterCS();
 148         _ASSERT(0 != dwTimeout);
 149
 150         // Increase Writer-counter & reset Reader-event if necessary
 151         INT _iNumOfWriter = ++m_iNumOfWriter;
 152         if (_iNumOfWriter == 1 && m_hSafeToReadEvent)
 153         {
 154                 ResetEvent(m_hSafeToReadEvent);
 155         }
 156
 157         if (!m_hSafeToWriteEvent)
 158         {
 159                 m_hSafeToWriteEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
 160         }
 161         LeaveCS();
 162
 163         bool blCanWrite = (WAIT_OBJECT_0 == WaitForSingleObject(m_hSafeToWriteEvent, static_cast<DWORD>(dwTimeout)));
 164         if (!blCanWrite)
 165         {
 166                 // Undo what we changed after timeout
 167                 EnterCS();
 168                 if(0 == --m_iNumOfWriter)
 169                 {
 170                         CloseHandle(m_hSafeToWriteEvent);
 171                         m_hSafeToWriteEvent = nullptr;
 172
 173                         if(0 == m_iNumOfReaderEntered)
 174                         {
 175                                 // Although it was timeout, it's still safe to be writer now
 176                                 ++m_iNumOfWriter;
 177                                 LeaveCS();
 178                                 blCanWrite = TRUE;
 179                         }
 180                         else if(m_hSafeToReadEvent)
 181                         {
 182                                 SetEvent(m_hSafeToReadEvent);
 183                         }
 184                 }
 185         }
 186         return blCanWrite;
 187 }
 188
 189 bool CReaderWriterLockNonReentrance::_UpgradeToWriterLockAndLeaveCS(ULONGLONG dwTimeout) noexcept
 190 {
 191         _ASSERT(m_iNumOfReaderEntered > 0);
 192
 193         if(0 == dwTimeout)
 194         {
 195                 LeaveCS();
 196                 return FALSE;
 197         }
 198
 199         --m_iNumOfReaderEntered;
 200         bool blCanWrite = _WriterWaitAndLeaveCSIfSuccess(dwTimeout);
 201         if (!blCanWrite)
 202         {
 203                 // Now analyze why it was failed to have suitable action
 204                 if(0 == m_iNumOfWriter)
 205                 {
 206                         _ASSERT(0 < m_iNumOfReaderEntered);
 207                         // There are some readers still owning the lock
 208                         // It's safe to be a reader again after failure
 209                         ++m_iNumOfReaderEntered;
 210                 }
 211                 else
 212                 {
 213                         // Reach to here, it's NOT safe to be a reader immediately
 214                         _ReaderWait(INFINITE);
 215                         if(1 == m_iNumOfReaderEntered)
 216                         {
 217                                 // After wait, now it's safe to be writer
 218                                 _ASSERT(0 == m_iNumOfWriter);
 219                                 m_iNumOfReaderEntered = 0;
 220                                 m_iNumOfWriter = 1;
 221                                 blCanWrite = TRUE;
 222                         }
 223                 }
 224                 LeaveCS();
 225         }
 226
 227         return blCanWrite;
 228 }
 229
 230 void CReaderWriterLockNonReentrance::_WriterRelease(bool blDowngrade) noexcept
 231 {
 232         _ASSERT(0 == m_iNumOfReaderEntered);
 233
 234         if(blDowngrade)
 235         {
 236                 ++m_iNumOfReaderEntered;
 237         }
 238
 239         if(0 == --m_iNumOfWriter)
 240         {
 241                 if (m_hSafeToWriteEvent)
 242                 {
 243                         CloseHandle(m_hSafeToWriteEvent);
 244                         m_hSafeToWriteEvent = nullptr;
 245                 }
 246
 247                 if(m_hSafeToReadEvent)
 248                 {
 249                         SetEvent(m_hSafeToReadEvent);
 250                 }
 251         }
 252         else
 253         {
 254                 //////////////////////////////////////////////////////////////////////////
 255                 // Some WRITERs are queued
 256                 _ASSERT(m_iNumOfWriter > 0 && m_hSafeToWriteEvent);
 257
 258                 if (!blDowngrade)
 259                 {
 260                         SetEvent(m_hSafeToWriteEvent);
 261                 }
 262         }
 263 }
 264
 265 bool CReaderWriterLockNonReentrance::AcquireReaderLock(DWORD dwTimeout) noexcept
 266 {
 267         bool blCanRead;
 268
 269         EnterCS();
 270         if(0 == m_iNumOfWriter)
 271         {
 272                 // Enter successful without wait
 273                 ++m_iNumOfReaderEntered;
 274                 blCanRead = TRUE;
 275         }
 276         else
 277         {
 278                 blCanRead = (dwTimeout)? _ReaderWait(dwTimeout) : FALSE;
 279         }
 280         LeaveCS();
 281
 282         return blCanRead;
 283 }
 284
 285 void CReaderWriterLockNonReentrance::ReleaseReaderLock() noexcept
 286 {
 287         EnterCS();
 288         _ReaderRelease();
 289         LeaveCS();
 290 }
 291
 292 bool CReaderWriterLockNonReentrance::AcquireWriterLock(DWORD dwTimeout) noexcept
 293 {
 294         bool blCanWrite ;
 295
 296         EnterCS();
 297         if(0 == (m_iNumOfWriter | m_iNumOfReaderEntered))
 298         {
 299                 ++m_iNumOfWriter;
 300                 blCanWrite = TRUE;
 301         }
 302         else if(0 == dwTimeout)
 303         {
 304                 blCanWrite = FALSE;
 305         }
 306         else
 307         {
 308                 blCanWrite = _WriterWaitAndLeaveCSIfSuccess(dwTimeout);
 309                 if(blCanWrite)
 310                 {
 311                         return TRUE;
 312                 }
 313         }
 314
 315         LeaveCS();
 316         return blCanWrite;
 317 }
 318
 319 void CReaderWriterLockNonReentrance::ReleaseWriterLock() noexcept
 320 {
 321         EnterCS();
 322         _WriterRelease(FALSE);
 323         LeaveCS();
 324 }
 325
 326 void CReaderWriterLockNonReentrance::DowngradeFromWriterLock() noexcept
 327 {
 328         EnterCS();
 329         _WriterRelease(TRUE);
 330         LeaveCS();
 331 }
 332
 333 bool CReaderWriterLockNonReentrance::UpgradeToWriterLock(DWORD dwTimeout) noexcept
 334 {
 335         EnterCS();
 336         return _UpgradeToWriterLockAndLeaveCS(dwTimeout);
 337 }
 338
 339 // END CReaderWriterLockNonReentrance implementation
 340 ///////////////////////////////////////////////////////
 341
 342 ///////////////////////////////////////////////////////
 343 // CReaderWriterLock implementation
 344
 345 #define READER_RECURRENCE_UNIT 0x00000001
 346 #define READER_RECURRENCE_MASK 0x0000FFFF
 347 #define WRITER_RECURRENCE_UNIT 0x00010000
 348
 349 CReaderWriterLock::CReaderWriterLock()
 350 {
 351 }
 352
 353 CReaderWriterLock::~CReaderWriterLock()
 354 {
 355 }
 356
 357 bool CReaderWriterLock::AcquireReaderLock(DWORD dwTimeout) noexcept
 358 {
 359         const DWORD dwCurrentThreadId = GetCurrentThreadId();
 360
 361         m_impl.EnterCS();
 362         CMapThreadToState::iterator ite = m_map.find(dwCurrentThreadId);
 363
 364         if(ite != m_map.end())
 365         {
 366                 //////////////////////////////////////////////////////////////////////////
 367                 // Current thread was already a WRITER or READER
 368                 _ASSERT(0 < ite->second);
 369                 ite->second += READER_RECURRENCE_UNIT;
 370                 m_impl.LeaveCS();
 371
 372                 return TRUE;
 373         }
 374
 375         if(0 == m_impl.m_iNumOfWriter)
 376         {
 377                 // There is NO WRITER on this RW object
 378                 // Current thread is going to be a READER
 379                 ++m_impl.m_iNumOfReaderEntered;
 380                 m_map.emplace(dwCurrentThreadId, READER_RECURRENCE_UNIT);
 381
 382                 m_impl.LeaveCS();
 383                 return TRUE;
 384         }
 385
 386         if(0 == dwTimeout)
 387         {
 388                 m_impl.LeaveCS();
 389                 return FALSE;
 390         }
 391
 392         bool blCanRead = m_impl._ReaderWait(dwTimeout);
 393         if(blCanRead)
 394         {
 395                 m_map.emplace(dwCurrentThreadId, READER_RECURRENCE_UNIT);
 396         }
 397         m_impl.LeaveCS();
 398
 399         return blCanRead;
 400 }
 401
 402 void CReaderWriterLock::ReleaseReaderLock() noexcept
 403 {
 404         const DWORD dwCurrentThreadId = GetCurrentThreadId();
 405         m_impl.EnterCS();
 406
 407         CMapThreadToState::iterator ite = m_map.find(dwCurrentThreadId);
 408         _ASSERT( (ite != m_map.end()) && (READER_RECURRENCE_MASK & ite->second));
 409
 410         const DWORD dwThreadState = (ite->second -= READER_RECURRENCE_UNIT);
 411         if(0 == dwThreadState)
 412         {
 413                 m_map.erase(ite);
 414                 m_impl._ReaderRelease();
 415         }
 416         m_impl.LeaveCS();
 417 }
 418
 419 bool CReaderWriterLock::AcquireWriterLock(DWORD dwTimeout) noexcept
 420 {
 421         const DWORD dwCurrentThreadId = GetCurrentThreadId();
 422         bool blCanWrite;
 423
 424         m_impl.EnterCS();
 425         CMapThreadToState::iterator ite = m_map.find(dwCurrentThreadId);
 426
 427         if(ite != m_map.end())
 428         {
 429                 _ASSERT(0 < ite->second);
 430
 431                 if(ite->second >= WRITER_RECURRENCE_UNIT)
 432                 {
 433                         // Current thread was already a WRITER
 434                         ite->second += WRITER_RECURRENCE_UNIT;
 435                         m_impl.LeaveCS();
 436                         return TRUE;
 437                 }
 438
 439                 // Current thread was already a READER
 440                 _ASSERT(1 <= m_impl.m_iNumOfReaderEntered);
 441                 if(1 == m_impl.m_iNumOfReaderEntered)
 442                 {
 443                         // This object is owned by ONLY current thread for READ
 444                         // There might be some threads queued to be WRITERs
 445                         // but for effectiveness (higher throughput), we allow current
 446                         // thread upgrading to be WRITER right now
 447                         m_impl.m_iNumOfReaderEntered = 0;
 448                         ++m_impl.m_iNumOfWriter;
 449                         ite->second += WRITER_RECURRENCE_UNIT;
 450                         m_impl.LeaveCS();
 451                         return TRUE;
 452                 }
 453
 454                 // Try upgrading from reader to writer
 455                 blCanWrite = m_impl._UpgradeToWriterLockAndLeaveCS(dwTimeout);
 456                 if(blCanWrite)
 457                 {
 458                         m_impl.EnterCS();
 459                         ite = m_map.find(dwCurrentThreadId);
 460                         ite->second += WRITER_RECURRENCE_UNIT;
 461                         m_impl.LeaveCS();
 462                 }
 463         }
 464         else
 465         {
 466                 if(0 == (m_impl.m_iNumOfWriter | m_impl.m_iNumOfReaderEntered))
 467                 {
 468                         // This RW object is not owned by any thread
 469                         // --> it's safe to make this thread to be WRITER
 470                         ++m_impl.m_iNumOfWriter;
 471                         m_map.emplace(dwCurrentThreadId, WRITER_RECURRENCE_UNIT);
 472                         m_impl.LeaveCS();
 473                         return TRUE;
 474                 }
 475
 476                 if(0 == dwTimeout)
 477                 {
 478                         m_impl.LeaveCS();
 479                         return FALSE;
 480                 }
 481
 482                 blCanWrite = m_impl._WriterWaitAndLeaveCSIfSuccess(dwTimeout);
 483                 if(blCanWrite)
 484                 {
 485                         m_impl.EnterCS();
 486                         m_map.emplace(dwCurrentThreadId, WRITER_RECURRENCE_UNIT);
 487                 }
 488                 m_impl.LeaveCS();
 489         }
 490
 491         return blCanWrite;
 492 }
 493
 494 void CReaderWriterLock::ReleaseWriterLock() noexcept
 495 {
 496         const DWORD dwCurrentThreadId = GetCurrentThreadId();
 497         m_impl.EnterCS();
 498
 499         CMapThreadToState::iterator ite = m_map.find(dwCurrentThreadId);
 500         _ASSERT( (ite != m_map.end()) && (WRITER_RECURRENCE_UNIT <= ite->second));
 501
 502         const DWORD dwThreadState = (ite->second -= WRITER_RECURRENCE_UNIT);
 503         if(0 == dwThreadState)
 504         {
 505                 m_map.erase(ite);
 506                 m_impl._WriterRelease(FALSE);
 507         }
 508         else if (WRITER_RECURRENCE_UNIT > dwThreadState)
 509         {
 510                 // Down-grading from writer to reader
 511                 m_impl._WriterRelease(TRUE);
 512         }
 513         m_impl.LeaveCS();
 514 }
 515
 516 void CReaderWriterLock::ReleaseAllLocks() noexcept
 517 {
 518         const DWORD dwCurrentThreadId = GetCurrentThreadId();
 519
 520         m_impl.EnterCS();
 521         CMapThreadToState::iterator ite = m_map.find(dwCurrentThreadId);
 522         if(ite != m_map.end())
 523         {
 524                 const DWORD dwThreadState = ite->second;
 525                 m_map.erase(ite);
 526                 if(WRITER_RECURRENCE_UNIT <= dwThreadState)
 527                 {
 528                         m_impl._WriterRelease(FALSE);
 529                 }
 530                 else
 531                 {
 532                         _ASSERT(0 < dwThreadState);
 533                         m_impl._ReaderRelease();
 534                 }
 535         }
 536         m_impl.LeaveCS();
 537 }
 538
 539 DWORD CReaderWriterLock::GetCurrentThreadStatus() const noexcept
 540 {
 541         DWORD dwThreadState;
 542         const DWORD dwCurrentThreadId = GetCurrentThreadId();
 543
 544         m_impl.EnterCS();
 545         CMapThreadToState::const_iterator ite = m_map.find(dwCurrentThreadId);
 546         if(ite != m_map.end())
 547         {
 548                 dwThreadState = ite->second;
 549                 m_impl.LeaveCS();
 550                 _ASSERT(dwThreadState > 0);
 551         }
 552         else
 553         {
 554                 dwThreadState = 0;
 555                 m_impl.LeaveCS();
 556         }
 557
 558         return dwThreadState;
 559 }
 560
 561 void CReaderWriterLock::GetCurrentThreadStatus(DWORD* lpdwReaderLockCounter,
 562         DWORD* lpdwWriterLockCounter) const noexcept
 563 {
 564         const DWORD dwThreadState = GetCurrentThreadStatus();
 565
 566         if (lpdwReaderLockCounter)
 567                 *lpdwReaderLockCounter = (dwThreadState & READER_RECURRENCE_MASK);
 568
 569         if (lpdwWriterLockCounter)
 570                 *lpdwWriterLockCounter = (dwThreadState / WRITER_RECURRENCE_UNIT);
 571 }