diff options
Diffstat (limited to 'plugins/CryptoPP/crypto/wait.cpp')
| -rw-r--r-- | plugins/CryptoPP/crypto/wait.cpp | 397 |
1 files changed, 397 insertions, 0 deletions
diff --git a/plugins/CryptoPP/crypto/wait.cpp b/plugins/CryptoPP/crypto/wait.cpp new file mode 100644 index 0000000000..e4bae04faa --- /dev/null +++ b/plugins/CryptoPP/crypto/wait.cpp @@ -0,0 +1,397 @@ +// wait.cpp - written and placed in the public domain by Wei Dai
+
+#include "pch.h"
+#include "wait.h"
+#include "misc.h"
+
+#ifdef SOCKETS_AVAILABLE
+
+#ifdef USE_BERKELEY_STYLE_SOCKETS
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <unistd.h>
+#endif
+
+NAMESPACE_BEGIN(CryptoPP)
+
+unsigned int WaitObjectContainer::MaxWaitObjects()
+{
+#ifdef USE_WINDOWS_STYLE_SOCKETS
+ return MAXIMUM_WAIT_OBJECTS * (MAXIMUM_WAIT_OBJECTS-1);
+#else
+ return FD_SETSIZE;
+#endif
+}
+
+WaitObjectContainer::WaitObjectContainer(WaitObjectsTracer* tracer)
+ : m_tracer(tracer), m_eventTimer(Timer::MILLISECONDS)
+ , m_sameResultCount(0), m_noWaitTimer(Timer::MILLISECONDS)
+{
+ Clear();
+ m_eventTimer.StartTimer();
+}
+
+void WaitObjectContainer::Clear()
+{
+#ifdef USE_WINDOWS_STYLE_SOCKETS
+ m_handles.clear();
+#else
+ m_maxFd = 0;
+ FD_ZERO(&m_readfds);
+ FD_ZERO(&m_writefds);
+#endif
+ m_noWait = false;
+ m_firstEventTime = 0;
+}
+
+inline void WaitObjectContainer::SetLastResult(LastResultType result)
+{
+ if (result == m_lastResult)
+ m_sameResultCount++;
+ else
+ {
+ m_lastResult = result;
+ m_sameResultCount = 0;
+ }
+}
+
+void WaitObjectContainer::DetectNoWait(LastResultType result, CallStack const& callStack)
+{
+ if (result == m_lastResult && m_noWaitTimer.ElapsedTime() > 1000)
+ {
+ if (m_sameResultCount > m_noWaitTimer.ElapsedTime())
+ {
+ if (m_tracer)
+ {
+ std::string desc = "No wait loop detected - m_lastResult: ";
+ desc.append(IntToString(m_lastResult)).append(", call stack:");
+ for (CallStack const* cs = &callStack; cs; cs = cs->Prev())
+ desc.append("\n- ").append(cs->Format());
+ m_tracer->TraceNoWaitLoop(desc);
+ }
+ try { throw 0; } catch (...) {} // help debugger break
+ }
+
+ m_noWaitTimer.StartTimer();
+ m_sameResultCount = 0;
+ }
+}
+
+void WaitObjectContainer::SetNoWait(CallStack const& callStack)
+{
+ DetectNoWait(LASTRESULT_NOWAIT, CallStack("WaitObjectContainer::SetNoWait()", &callStack));
+ m_noWait = true;
+}
+
+void WaitObjectContainer::ScheduleEvent(double milliseconds, CallStack const& callStack)
+{
+ if (milliseconds <= 3)
+ DetectNoWait(LASTRESULT_SCHEDULED, CallStack("WaitObjectContainer::ScheduleEvent()", &callStack));
+ double thisEventTime = m_eventTimer.ElapsedTimeAsDouble() + milliseconds;
+ if (!m_firstEventTime || thisEventTime < m_firstEventTime)
+ m_firstEventTime = thisEventTime;
+}
+
+#ifdef USE_WINDOWS_STYLE_SOCKETS
+
+struct WaitingThreadData
+{
+ bool waitingToWait, terminate;
+ HANDLE startWaiting, stopWaiting;
+ const HANDLE *waitHandles;
+ unsigned int count;
+ HANDLE threadHandle;
+ DWORD threadId;
+ DWORD* error;
+};
+
+WaitObjectContainer::~WaitObjectContainer()
+{
+ try // don't let exceptions escape destructor
+ {
+ if (!m_threads.empty())
+ {
+ HANDLE threadHandles[MAXIMUM_WAIT_OBJECTS];
+ unsigned int i;
+ for (i=0; i<m_threads.size(); i++)
+ {
+ WaitingThreadData &thread = *m_threads[i];
+ while (!thread.waitingToWait) // spin until thread is in the initial "waiting to wait" state
+ Sleep(0);
+ thread.terminate = true;
+ threadHandles[i] = thread.threadHandle;
+ }
+ PulseEvent(m_startWaiting);
+ ::WaitForMultipleObjects((DWORD)m_threads.size(), threadHandles, TRUE, INFINITE);
+ for (i=0; i<m_threads.size(); i++)
+ CloseHandle(threadHandles[i]);
+ CloseHandle(m_startWaiting);
+ CloseHandle(m_stopWaiting);
+ }
+ }
+ catch (...)
+ {
+ }
+}
+
+
+void WaitObjectContainer::AddHandle(HANDLE handle, CallStack const& callStack)
+{
+ DetectNoWait(m_handles.size(), CallStack("WaitObjectContainer::AddHandle()", &callStack));
+ m_handles.push_back(handle);
+}
+
+DWORD WINAPI WaitingThread(LPVOID lParam)
+{
+ std::auto_ptr<WaitingThreadData> pThread((WaitingThreadData *)lParam);
+ WaitingThreadData &thread = *pThread;
+ std::vector<HANDLE> handles;
+
+ while (true)
+ {
+ thread.waitingToWait = true;
+ ::WaitForSingleObject(thread.startWaiting, INFINITE);
+ thread.waitingToWait = false;
+
+ if (thread.terminate)
+ break;
+ if (!thread.count)
+ continue;
+
+ handles.resize(thread.count + 1);
+ handles[0] = thread.stopWaiting;
+ std::copy(thread.waitHandles, thread.waitHandles+thread.count, handles.begin()+1);
+
+ DWORD result = ::WaitForMultipleObjects((DWORD)handles.size(), &handles[0], FALSE, INFINITE);
+
+ if (result == WAIT_OBJECT_0)
+ continue; // another thread finished waiting first, so do nothing
+ SetEvent(thread.stopWaiting);
+ if (!(result > WAIT_OBJECT_0 && result < WAIT_OBJECT_0 + handles.size()))
+ {
+ assert(!"error in WaitingThread"); // break here so we can see which thread has an error
+ *thread.error = ::GetLastError();
+ }
+ }
+
+ return S_OK; // return a value here to avoid compiler warning
+}
+
+void WaitObjectContainer::CreateThreads(unsigned int count)
+{
+ size_t currentCount = m_threads.size();
+ if (currentCount == 0)
+ {
+ m_startWaiting = ::CreateEvent(NULL, TRUE, FALSE, NULL);
+ m_stopWaiting = ::CreateEvent(NULL, TRUE, FALSE, NULL);
+ }
+
+ if (currentCount < count)
+ {
+ m_threads.resize(count);
+ for (size_t i=currentCount; i<count; i++)
+ {
+ m_threads[i] = new WaitingThreadData;
+ WaitingThreadData &thread = *m_threads[i];
+ thread.terminate = false;
+ thread.startWaiting = m_startWaiting;
+ thread.stopWaiting = m_stopWaiting;
+ thread.waitingToWait = false;
+ thread.threadHandle = CreateThread(NULL, 0, &WaitingThread, &thread, 0, &thread.threadId);
+ }
+ }
+}
+
+bool WaitObjectContainer::Wait(unsigned long milliseconds)
+{
+ if (m_noWait || (m_handles.empty() && !m_firstEventTime))
+ {
+ SetLastResult(LASTRESULT_NOWAIT);
+ return true;
+ }
+
+ bool timeoutIsScheduledEvent = false;
+
+ if (m_firstEventTime)
+ {
+ double timeToFirstEvent = SaturatingSubtract(m_firstEventTime, m_eventTimer.ElapsedTimeAsDouble());
+
+ if (timeToFirstEvent <= milliseconds)
+ {
+ milliseconds = (unsigned long)timeToFirstEvent;
+ timeoutIsScheduledEvent = true;
+ }
+
+ if (m_handles.empty() || !milliseconds)
+ {
+ if (milliseconds)
+ Sleep(milliseconds);
+ SetLastResult(timeoutIsScheduledEvent ? LASTRESULT_SCHEDULED : LASTRESULT_TIMEOUT);
+ return timeoutIsScheduledEvent;
+ }
+ }
+
+ if (m_handles.size() > MAXIMUM_WAIT_OBJECTS)
+ {
+ // too many wait objects for a single WaitForMultipleObjects call, so use multiple threads
+ static const unsigned int WAIT_OBJECTS_PER_THREAD = MAXIMUM_WAIT_OBJECTS-1;
+ unsigned int nThreads = (unsigned int)((m_handles.size() + WAIT_OBJECTS_PER_THREAD - 1) / WAIT_OBJECTS_PER_THREAD);
+ if (nThreads > MAXIMUM_WAIT_OBJECTS) // still too many wait objects, maybe implement recursive threading later?
+ throw Err("WaitObjectContainer: number of wait objects exceeds limit");
+ CreateThreads(nThreads);
+ DWORD error = S_OK;
+
+ for (unsigned int i=0; i<m_threads.size(); i++)
+ {
+ WaitingThreadData &thread = *m_threads[i];
+ while (!thread.waitingToWait) // spin until thread is in the initial "waiting to wait" state
+ Sleep(0);
+ if (i<nThreads)
+ {
+ thread.waitHandles = &m_handles[i*WAIT_OBJECTS_PER_THREAD];
+ thread.count = UnsignedMin(WAIT_OBJECTS_PER_THREAD, m_handles.size() - i*WAIT_OBJECTS_PER_THREAD);
+ thread.error = &error;
+ }
+ else
+ thread.count = 0;
+ }
+
+ ResetEvent(m_stopWaiting);
+ PulseEvent(m_startWaiting);
+
+ DWORD result = ::WaitForSingleObject(m_stopWaiting, milliseconds);
+ if (result == WAIT_OBJECT_0)
+ {
+ if (error == S_OK)
+ return true;
+ else
+ throw Err("WaitObjectContainer: WaitForMultipleObjects in thread failed with error " + IntToString(error));
+ }
+ SetEvent(m_stopWaiting);
+ if (result == WAIT_TIMEOUT)
+ {
+ SetLastResult(timeoutIsScheduledEvent ? LASTRESULT_SCHEDULED : LASTRESULT_TIMEOUT);
+ return timeoutIsScheduledEvent;
+ }
+ else
+ throw Err("WaitObjectContainer: WaitForSingleObject failed with error " + IntToString(::GetLastError()));
+ }
+ else
+ {
+#if TRACE_WAIT
+ static Timer t(Timer::MICROSECONDS);
+ static unsigned long lastTime = 0;
+ unsigned long timeBeforeWait = t.ElapsedTime();
+#endif
+ DWORD result = ::WaitForMultipleObjects((DWORD)m_handles.size(), &m_handles[0], FALSE, milliseconds);
+#if TRACE_WAIT
+ if (milliseconds > 0)
+ {
+ unsigned long timeAfterWait = t.ElapsedTime();
+ OutputDebugString(("Handles " + IntToString(m_handles.size()) + ", Woke up by " + IntToString(result-WAIT_OBJECT_0) + ", Busied for " + IntToString(timeBeforeWait-lastTime) + " us, Waited for " + IntToString(timeAfterWait-timeBeforeWait) + " us, max " + IntToString(milliseconds) + "ms\n").c_str());
+ lastTime = timeAfterWait;
+ }
+#endif
+ if (result >= WAIT_OBJECT_0 && result < WAIT_OBJECT_0 + m_handles.size())
+ {
+ if (result == m_lastResult)
+ m_sameResultCount++;
+ else
+ {
+ m_lastResult = result;
+ m_sameResultCount = 0;
+ }
+ return true;
+ }
+ else if (result == WAIT_TIMEOUT)
+ {
+ SetLastResult(timeoutIsScheduledEvent ? LASTRESULT_SCHEDULED : LASTRESULT_TIMEOUT);
+ return timeoutIsScheduledEvent;
+ }
+ else
+ throw Err("WaitObjectContainer: WaitForMultipleObjects failed with error " + IntToString(::GetLastError()));
+ }
+}
+
+#else // #ifdef USE_WINDOWS_STYLE_SOCKETS
+
+void WaitObjectContainer::AddReadFd(int fd, CallStack const& callStack) // TODO: do something with callStack
+{
+ FD_SET(fd, &m_readfds);
+ m_maxFd = STDMAX(m_maxFd, fd);
+}
+
+void WaitObjectContainer::AddWriteFd(int fd, CallStack const& callStack) // TODO: do something with callStack
+{
+ FD_SET(fd, &m_writefds);
+ m_maxFd = STDMAX(m_maxFd, fd);
+}
+
+bool WaitObjectContainer::Wait(unsigned long milliseconds)
+{
+ if (m_noWait || (!m_maxFd && !m_firstEventTime))
+ return true;
+
+ bool timeoutIsScheduledEvent = false;
+
+ if (m_firstEventTime)
+ {
+ double timeToFirstEvent = SaturatingSubtract(m_firstEventTime, m_eventTimer.ElapsedTimeAsDouble());
+ if (timeToFirstEvent <= milliseconds)
+ {
+ milliseconds = (unsigned long)timeToFirstEvent;
+ timeoutIsScheduledEvent = true;
+ }
+ }
+
+ timeval tv, *timeout;
+
+ if (milliseconds == INFINITE_TIME)
+ timeout = NULL;
+ else
+ {
+ tv.tv_sec = milliseconds / 1000;
+ tv.tv_usec = (milliseconds % 1000) * 1000;
+ timeout = &tv;
+ }
+
+ int result = select(m_maxFd+1, &m_readfds, &m_writefds, NULL, timeout);
+
+ if (result > 0)
+ return true;
+ else if (result == 0)
+ return timeoutIsScheduledEvent;
+ else
+ throw Err("WaitObjectContainer: select failed with error " + errno);
+}
+
+#endif
+
+// ********************************************************
+
+std::string CallStack::Format() const
+{
+ return m_info;
+}
+
+std::string CallStackWithNr::Format() const
+{
+ return std::string(m_info) + " / nr: " + IntToString(m_nr);
+}
+
+std::string CallStackWithStr::Format() const
+{
+ return std::string(m_info) + " / " + std::string(m_z);
+}
+
+bool Waitable::Wait(unsigned long milliseconds, CallStack const& callStack)
+{
+ WaitObjectContainer container;
+ GetWaitObjects(container, callStack); // reduce clutter by not adding this func to stack
+ return container.Wait(milliseconds);
+}
+
+NAMESPACE_END
+
+#endif
|