src/Utils/RWSection.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2008 - TortoiseSVN
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 #include "StdAfx.h"
  20 #include "RWSection.h"
  21
  22 CRWSection::CRWSection()
  23 {
  24         m_nWaitingReaders = m_nWaitingWriters = m_nActive = 0;
  25         m_hReaders = CreateSemaphore(NULL, 0, MAXLONG, NULL);
  26         m_hWriters = CreateSemaphore(NULL, 0, MAXLONG, NULL);
  27         InitializeCriticalSection(&m_cs);
  28 }
  29
  30 CRWSection::~CRWSection()
  31 {
  32 #ifdef _DEBUG
  33         if (m_nActive > 0)
  34                 DebugBreak();
  35 #endif
  36
  37         m_nWaitingReaders = m_nWaitingWriters = m_nActive = 0;
  38         DeleteCriticalSection(&m_cs);
  39         CloseHandle(m_hWriters);
  40         CloseHandle(m_hReaders);
  41 }
  42
  43 bool CRWSection::WaitToRead(DWORD waitTime)
  44 {
  45         EnterCriticalSection(&m_cs);
  46
  47         // Writers have priority
  48         BOOL fResourceWritePending = (m_nWaitingWriters || (m_nActive < 0));
  49
  50         if (fResourceWritePending)
  51         {
  52                 m_nWaitingReaders++;
  53         }
  54         else
  55         {
  56                 m_nActive++;
  57         }
  58
  59         LeaveCriticalSection(&m_cs);
  60
  61         if (fResourceWritePending)
  62         {
  63                 // wait until writer is finished
  64                 if (WaitForSingleObject(m_hReaders, waitTime) != WAIT_OBJECT_0)
  65                 {
  66                         EnterCriticalSection(&m_cs);
  67                         m_nWaitingReaders--;
  68                         LeaveCriticalSection(&m_cs);
  69                         return false;
  70                 }
  71         }
  72         return true;
  73 }
  74
  75 bool CRWSection::WaitToWrite(DWORD waitTime)
  76 {
  77         EnterCriticalSection(&m_cs);
  78
  79         BOOL fResourceOwned = (m_nActive != 0);
  80
  81         if (fResourceOwned)
  82         {
  83                 m_nWaitingWriters++;
  84         }
  85         else
  86         {
  87                 m_nActive = -1;
  88         }
  89
  90         LeaveCriticalSection(&m_cs);
  91
  92         if (fResourceOwned)
  93         {
  94                 if (WaitForSingleObject(m_hWriters, waitTime) != WAIT_OBJECT_0)
  95                 {
  96                         EnterCriticalSection(&m_cs);
  97                         m_nWaitingWriters--;
  98                         LeaveCriticalSection(&m_cs);
  99                         return false;
 100                 }
 101         }
 102         return true;
 103 }
 104
 105 void CRWSection::Done()
 106 {
 107         EnterCriticalSection(&m_cs);
 108
 109         if (m_nActive > 0)
 110         {
 111                 m_nActive--;
 112         }
 113         else
 114         {
 115                 m_nActive++;
 116         }
 117
 118         HANDLE hsem = NULL;
 119         LONG lCount = 1;
 120
 121         if (m_nActive == 0)
 122         {
 123                 // Note: If there are always writers waiting, then
 124                 // it's possible that a reader never gets access
 125                 // (reader starvation)
 126                 if (m_nWaitingWriters > 0)
 127                 {
 128                         m_nActive = -1;
 129                         m_nWaitingWriters--;
 130                         hsem = m_hWriters;
 131                 }
 132                 else if (m_nWaitingReaders > 0)
 133                 {
 134                         m_nActive = m_nWaitingReaders;
 135                         m_nWaitingReaders = 0;
 136                         hsem = m_hReaders;
 137                         lCount = m_nActive;
 138                 }
 139                 else
 140                 {
 141                         // no threads waiting, nothing to do
 142                 }
 143         }
 144
 145         LeaveCriticalSection(&m_cs);
 146
 147         if (hsem != NULL)
 148         {
 149                 ReleaseSemaphore(hsem, lCount, NULL);
 150         }
 151 }
 152