src/AsyncFramework/WaitableEvent.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2009 by Stefan Fuhrmann                                 *
   3  *   stefanfuhrmann@alice-dsl.de                                           *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (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                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include "stdafx.h"
  22 #include "WaitableEvent.h"
  23 #include "CriticalSection.h"
  24
  25 namespace async
  26 {
  27
  28 // recycler for OS constructs
  29
  30 namespace
  31 {
  32     class CWaitableEventPool
  33     {
  34     private:
  35
  36         // multi-threading sync.
  37
  38         CCriticalSection mutex;
  39
  40         // allocated, currently usused handles
  41
  42         std::vector<HANDLE> handles;
  43
  44         // flag indicating that this instance has not been destroyed, yet
  45
  46         volatile LONG alive;
  47
  48         // construction / destruction:
  49         // free all handles upon destruction at latest
  50
  51         CWaitableEventPool();
  52         ~CWaitableEventPool();
  53
  54     public:
  55
  56         // Meyer's singleton
  57
  58         static CWaitableEventPool* GetInstance();
  59
  60         // recycling interface:
  61         // alloc at request
  62
  63         HANDLE Alloc();
  64         void AutoAlloc (HANDLE& handle);
  65         void Release (HANDLE event);
  66         void Clear();
  67     };
  68
  69     // construction / destruction:
  70
  71     CWaitableEventPool::CWaitableEventPool()
  72         : alive (TRUE)
  73     {
  74     }
  75
  76     CWaitableEventPool::~CWaitableEventPool()
  77     {
  78         Clear();
  79         InterlockedExchange (&alive, FALSE);
  80     }
  81
  82     // Meyer's singleton
  83
  84     CWaitableEventPool* CWaitableEventPool::GetInstance()
  85     {
  86         static CWaitableEventPool instance;
  87         return &instance;
  88     }
  89
  90     // recycling interface:
  91     // alloc at request
  92
  93     HANDLE CWaitableEventPool::Alloc()
  94     {
  95         if (InterlockedCompareExchange (&alive, TRUE, TRUE))
  96         {
  97             CCriticalSectionLock lock (mutex);
  98             if (!handles.empty())
  99             {
 100                 HANDLE result = handles.back();
 101                 handles.pop_back();
 102                 return result;
 103             }
 104         }
 105
 106         return CreateEvent (NULL, TRUE, FALSE, NULL);
 107     }
 108
 109     void CWaitableEventPool::AutoAlloc (HANDLE& handle)
 110     {
 111         if (handle != NULL)
 112             return;
 113
 114         if (InterlockedCompareExchange (&alive, TRUE, TRUE))
 115         {
 116             CCriticalSectionLock lock (mutex);
 117             if (!handles.empty())
 118             {
 119                 handle = handles.back();
 120                 handles.pop_back();
 121                 return;
 122             }
 123         }
 124
 125         handle = CreateEvent (NULL, TRUE, FALSE, NULL);
 126     }
 127
 128     void CWaitableEventPool::Release (HANDLE event)
 129     {
 130         ResetEvent (event);
 131         if (InterlockedCompareExchange (&alive, TRUE, TRUE))
 132         {
 133             CCriticalSectionLock lock (mutex);
 134             handles.push_back (event);
 135         }
 136         else
 137         {
 138             CloseHandle (event);
 139         }
 140     }
 141
 142     void CWaitableEventPool::Clear()
 143     {
 144         CCriticalSectionLock lock (mutex);
 145
 146         while (!handles.empty())
 147             CloseHandle (Alloc());
 148     }
 149 }
 150
 151 // construction / destruction: manage event handle
 152
 153 COneShotEvent::COneShotEvent()
 154     : event (NULL)
 155     , state (FALSE)
 156 {
 157 }
 158
 159 COneShotEvent::~COneShotEvent()
 160 {
 161     if (event != NULL)
 162         CWaitableEventPool::GetInstance()->Release (event);
 163 }
 164
 165 // eventing interface
 166
 167 void COneShotEvent::Set()
 168 {
 169     if (InterlockedExchange (&state, TRUE) == FALSE)
 170         if (event != NULL)
 171             SetEvent (event);
 172 }
 173
 174 bool COneShotEvent::Test() const
 175 {
 176     return state == TRUE;
 177 }
 178
 179 void COneShotEvent::WaitFor()
 180 {
 181     if (state == FALSE)
 182     {
 183         CWaitableEventPool::GetInstance()->AutoAlloc (event);
 184         if (state == FALSE)
 185             WaitForSingleObject (event, INFINITE);
 186     }
 187 }
 188
 189 bool COneShotEvent::WaitForEndOrTimeout(DWORD milliSeconds)
 190 {
 191     if (state == FALSE)
 192     {
 193         CWaitableEventPool::GetInstance()->AutoAlloc (event);
 194         return WaitForSingleObject (event, milliSeconds) == WAIT_OBJECT_0;
 195     }
 196
 197     return true;
 198 }
 199
 200 // construction / destruction: manage event handle
 201
 202 CWaitableEvent::CWaitableEvent()
 203     : event (CWaitableEventPool::GetInstance()->Alloc())
 204 {
 205 }
 206
 207 CWaitableEvent::~CWaitableEvent()
 208 {
 209     CWaitableEventPool::GetInstance()->Release (event);
 210 }
 211
 212 // eventing interface
 213
 214 void CWaitableEvent::Set()
 215 {
 216     SetEvent (event);
 217 }
 218
 219 void CWaitableEvent::Reset()
 220 {
 221     ResetEvent (event);
 222 }
 223
 224 bool CWaitableEvent::Test() const
 225 {
 226     return WaitForSingleObject (event, 0) == WAIT_OBJECT_0;
 227 }
 228
 229 void CWaitableEvent::WaitFor()
 230 {
 231     WaitForSingleObject (event, INFINITE);
 232 }
 233
 234 bool CWaitableEvent::WaitForEndOrTimeout(DWORD milliSeconds)
 235 {
 236     return WaitForSingleObject (event, milliSeconds) == WAIT_OBJECT_0;
 237 }
 238
 239
 240 }