diff --git a/build/threads.jam b/build/threads.jam index 3ba679de..f5914125 100644 --- a/build/threads.jam +++ b/build/threads.jam @@ -22,6 +22,7 @@ : ## requirements ## : $(BOOST_ROOT) multi $(pthreads-win32) + <*>-w-8004 ## default build ## : ; diff --git a/src/condition.cpp b/src/condition.cpp index acd1676e..ae3ddfdc 100644 --- a/src/condition.cpp +++ b/src/condition.cpp @@ -40,31 +40,31 @@ condition_impl::condition_impl() { m_gate = reinterpret_cast(CreateSemaphore(0, 1, 1, 0)); m_queue = reinterpret_cast(CreateSemaphore(0, 0, - std::numeric_limits::max(), - 0)); + std::numeric_limits::max(), + 0)); m_mutex = reinterpret_cast(CreateMutex(0, 0, 0)); if (!m_gate || !m_queue || !m_mutex) - { - int res = 0; - if (m_gate) { - res = CloseHandle(reinterpret_cast(m_gate)); - assert(res); - } - if (m_queue) - { - res = CloseHandle(reinterpret_cast(m_queue)); - assert(res); - } - if (m_mutex) - { - res = CloseHandle(reinterpret_cast(m_mutex)); - assert(res); - } + int res = 0; + if (m_gate) + { + res = CloseHandle(reinterpret_cast(m_gate)); + assert(res); + } + if (m_queue) + { + res = CloseHandle(reinterpret_cast(m_queue)); + assert(res); + } + if (m_mutex) + { + res = CloseHandle(reinterpret_cast(m_mutex)); + assert(res); + } - throw thread_resource_error(); - } + throw thread_resource_error(); + } } condition_impl::~condition_impl() @@ -87,47 +87,47 @@ void condition_impl::notify_one() assert(res == WAIT_OBJECT_0); if (m_waiting != 0) // the m_gate is already closed - { - if (m_blocked == 0) { - res = ReleaseMutex(reinterpret_cast(m_mutex)); - assert(res); - return; - } + if (m_blocked == 0) + { + res = ReleaseMutex(reinterpret_cast(m_mutex)); + assert(res); + return; + } - ++m_waiting; - --m_blocked; - signals = 1; - } - else - { - res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); - assert(res == WAIT_OBJECT_0); - if (m_blocked > m_gone) - { - if (m_gone != 0) - { - m_blocked -= m_gone; - m_gone = 0; - } - signals = m_waiting = 1; + ++m_waiting; --m_blocked; + signals = 1; } - else + else { - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); - assert(res); + res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); + assert(res == WAIT_OBJECT_0); + if (m_blocked > m_gone) + { + if (m_gone != 0) + { + m_blocked -= m_gone; + m_gone = 0; + } + signals = m_waiting = 1; + --m_blocked; + } + else + { + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); + assert(res); + } } - } res = ReleaseMutex(reinterpret_cast(m_mutex)); assert(res); if (signals) - { - res = ReleaseSemaphore(reinterpret_cast(m_queue), signals, 0); - assert(res); - } + { + res = ReleaseSemaphore(reinterpret_cast(m_queue), signals, 0); + assert(res); + } } void condition_impl::notify_all() @@ -139,47 +139,47 @@ void condition_impl::notify_all() assert(res == WAIT_OBJECT_0); if (m_waiting != 0) // the m_gate is already closed - { - if (m_blocked == 0) { - res = ReleaseMutex(reinterpret_cast(m_mutex)); - assert(res); - return; - } + if (m_blocked == 0) + { + res = ReleaseMutex(reinterpret_cast(m_mutex)); + assert(res); + return; + } - m_waiting += (signals = m_blocked); - m_blocked = 0; - } - else - { - res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); - assert(res == WAIT_OBJECT_0); - if (m_blocked > m_gone) - { - if (m_gone != 0) - { - m_blocked -= m_gone; - m_gone = 0; - } - signals = m_waiting = m_blocked; + m_waiting += (signals = m_blocked); m_blocked = 0; } - else + else { - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); - assert(res); + res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); + assert(res == WAIT_OBJECT_0); + if (m_blocked > m_gone) + { + if (m_gone != 0) + { + m_blocked -= m_gone; + m_gone = 0; + } + signals = m_waiting = m_blocked; + m_blocked = 0; + } + else + { + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); + assert(res); + } } - } res = ReleaseMutex(reinterpret_cast(m_mutex)); assert(res); if (signals) - { - res = ReleaseSemaphore(reinterpret_cast(m_queue), signals, - 0); - assert(res); - } + { + res = ReleaseSemaphore(reinterpret_cast(m_queue), signals, + 0); + assert(res); + } } void condition_impl::enter_wait() @@ -206,47 +206,47 @@ void condition_impl::do_wait() was_waiting = m_waiting; was_gone = m_gone; if (was_waiting != 0) - { - if (--m_waiting == 0) { - if (m_blocked != 0) - { - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, - 0); // open m_gate - assert(res); - was_waiting = 0; - } - else if (m_gone != 0) - m_gone = 0; + if (--m_waiting == 0) + { + if (m_blocked != 0) + { + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, + 0); // open m_gate + assert(res); + was_waiting = 0; + } + else if (m_gone != 0) + m_gone = 0; + } } - } else if (++m_gone == (std::numeric_limits::max() / 2)) - { - // timeout occured, normalize the m_gone count - // this may occur if many calls to wait with a timeout are made and - // no call to notify_* is made - res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); - assert(res == WAIT_OBJECT_0); - m_blocked -= m_gone; - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); - assert(res); - m_gone = 0; - } + { + // timeout occured, normalize the m_gone count + // this may occur if many calls to wait with a timeout are made and + // no call to notify_* is made + res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); + assert(res == WAIT_OBJECT_0); + m_blocked -= m_gone; + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); + assert(res); + m_gone = 0; + } res = ReleaseMutex(reinterpret_cast(m_mutex)); assert(res); if (was_waiting == 1) - { - for (/**/ ; was_gone; --was_gone) { - // better now than spurious later - res = WaitForSingleObject(reinterpret_cast(m_queue), - INFINITE); - assert(res == WAIT_OBJECT_0); + for (/**/ ; was_gone; --was_gone) + { + // better now than spurious later + res = WaitForSingleObject(reinterpret_cast(m_queue), + INFINITE); + assert(res == WAIT_OBJECT_0); + } + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); + assert(res); } - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); - assert(res); - } } bool condition_impl::do_timed_wait(const xtime& xt) @@ -255,25 +255,25 @@ bool condition_impl::do_timed_wait(const xtime& xt) unsigned int res = 0; for (;;) - { - int milliseconds; - to_duration(xt, milliseconds); - - res = WaitForSingleObject(reinterpret_cast(m_queue), - milliseconds); - assert(res != WAIT_FAILED && res != WAIT_ABANDONED); - ret = (res == WAIT_OBJECT_0); - - if (res == WAIT_TIMEOUT) { - xtime cur; - xtime_get(&cur, TIME_UTC); - if (xtime_cmp(xt, cur) > 0) - continue; - } + int milliseconds; + to_duration(xt, milliseconds); - break; - } + res = WaitForSingleObject(reinterpret_cast(m_queue), + milliseconds); + assert(res != WAIT_FAILED && res != WAIT_ABANDONED); + ret = (res == WAIT_OBJECT_0); + + if (res == WAIT_TIMEOUT) + { + xtime cur; + xtime_get(&cur, TIME_UTC); + if (xtime_cmp(xt, cur) > 0) + continue; + } + + break; + } unsigned was_waiting=0; unsigned was_gone=0; @@ -283,54 +283,54 @@ bool condition_impl::do_timed_wait(const xtime& xt) was_waiting = m_waiting; was_gone = m_gone; if (was_waiting != 0) - { - if (!ret) // timeout { - if (m_blocked != 0) - --m_blocked; - else - ++m_gone; // count spurious wakeups + if (!ret) // timeout + { + if (m_blocked != 0) + --m_blocked; + else + ++m_gone; // count spurious wakeups + } + if (--m_waiting == 0) + { + if (m_blocked != 0) + { + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, + 0); // open m_gate + assert(res); + was_waiting = 0; + } + else if (m_gone != 0) + m_gone = 0; + } } - if (--m_waiting == 0) - { - if (m_blocked != 0) - { - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, - 0); // open m_gate - assert(res); - was_waiting = 0; - } - else if (m_gone != 0) - m_gone = 0; - } - } else if (++m_gone == (std::numeric_limits::max() / 2)) - { - // timeout occured, normalize the m_gone count - // this may occur if many calls to wait with a timeout are made and - // no call to notify_* is made - res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); - assert(res == WAIT_OBJECT_0); - m_blocked -= m_gone; - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); - assert(res); - m_gone = 0; - } + { + // timeout occured, normalize the m_gone count + // this may occur if many calls to wait with a timeout are made and + // no call to notify_* is made + res = WaitForSingleObject(reinterpret_cast(m_gate), INFINITE); + assert(res == WAIT_OBJECT_0); + m_blocked -= m_gone; + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); + assert(res); + m_gone = 0; + } res = ReleaseMutex(reinterpret_cast(m_mutex)); assert(res); if (was_waiting == 1) - { - for (/**/ ; was_gone; --was_gone) { - // better now than spurious later - res = WaitForSingleObject(reinterpret_cast(m_queue), - INFINITE); - assert(res == WAIT_OBJECT_0); + for (/**/ ; was_gone; --was_gone) + { + // better now than spurious later + res = WaitForSingleObject(reinterpret_cast(m_queue), + INFINITE); + assert(res == WAIT_OBJECT_0); + } + res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); + assert(res); } - res = ReleaseSemaphore(reinterpret_cast(m_gate), 1, 0); - assert(res); - } return ret; } @@ -399,20 +399,20 @@ condition_impl::condition_impl() lStatus = MPCreateSemaphore(ULONG_MAX, 0, &m_queue); if(lStatus != noErr || !m_gate || !m_queue) - { - if (m_gate) { - lStatus = MPDeleteSemaphore(m_gate); - assert(lStatus == noErr); - } - if (m_queue) - { - lStatus = MPDeleteSemaphore(m_queue); - assert(lStatus == noErr); - } + if (m_gate) + { + lStatus = MPDeleteSemaphore(m_gate); + assert(lStatus == noErr); + } + if (m_queue) + { + lStatus = MPDeleteSemaphore(m_queue); + assert(lStatus == noErr); + } - throw thread_resource_error(); - } + throw thread_resource_error(); + } } condition_impl::~condition_impl() @@ -430,51 +430,51 @@ void condition_impl::notify_one() OSStatus lStatus = noErr; lStatus = safe_enter_critical_region(m_mutex, kDurationForever, - m_mutex_mutex); + m_mutex_mutex); assert(lStatus == noErr); if (m_waiting != 0) // the m_gate is already closed - { - if (m_blocked == 0) { - lStatus = MPExitCriticalRegion(m_mutex); - assert(lStatus == noErr); - return; - } + if (m_blocked == 0) + { + lStatus = MPExitCriticalRegion(m_mutex); + assert(lStatus == noErr); + return; + } - ++m_waiting; - --m_blocked; - } - else - { - lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); - assert(lStatus == noErr); - if (m_blocked > m_gone) - { - if (m_gone != 0) - { - m_blocked -= m_gone; - m_gone = 0; - } - signals = m_waiting = 1; + ++m_waiting; --m_blocked; } - else + else { - lStatus = MPSignalSemaphore(m_gate); + lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); assert(lStatus == noErr); - } + if (m_blocked > m_gone) + { + if (m_gone != 0) + { + m_blocked -= m_gone; + m_gone = 0; + } + signals = m_waiting = 1; + --m_blocked; + } + else + { + lStatus = MPSignalSemaphore(m_gate); + assert(lStatus == noErr); + } - lStatus = MPExitCriticalRegion(m_mutex); - assert(lStatus == noErr); - - while (signals) - { - lStatus = MPSignalSemaphore(m_queue); + lStatus = MPExitCriticalRegion(m_mutex); assert(lStatus == noErr); - --signals; + + while (signals) + { + lStatus = MPSignalSemaphore(m_queue); + assert(lStatus == noErr); + --signals; + } } - } } void condition_impl::notify_all() @@ -483,51 +483,51 @@ void condition_impl::notify_all() OSStatus lStatus = noErr; lStatus = safe_enter_critical_region(m_mutex, kDurationForever, - m_mutex_mutex); + m_mutex_mutex); assert(lStatus == noErr); if (m_waiting != 0) // the m_gate is already closed - { - if (m_blocked == 0) { - lStatus = MPExitCriticalRegion(m_mutex); - assert(lStatus == noErr); - return; - } + if (m_blocked == 0) + { + lStatus = MPExitCriticalRegion(m_mutex); + assert(lStatus == noErr); + return; + } - m_waiting += (signals = m_blocked); - m_blocked = 0; - } - else - { - lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); - assert(lStatus == noErr); - if (m_blocked > m_gone) - { - if (m_gone != 0) - { - m_blocked -= m_gone; - m_gone = 0; - } - signals = m_waiting = m_blocked; + m_waiting += (signals = m_blocked); m_blocked = 0; } - else + else { - lStatus = MPSignalSemaphore(m_gate); + lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); assert(lStatus == noErr); - } + if (m_blocked > m_gone) + { + if (m_gone != 0) + { + m_blocked -= m_gone; + m_gone = 0; + } + signals = m_waiting = m_blocked; + m_blocked = 0; + } + else + { + lStatus = MPSignalSemaphore(m_gate); + assert(lStatus == noErr); + } - lStatus = MPExitCriticalRegion(m_mutex); - assert(lStatus == noErr); - - while (signals) - { - lStatus = MPSignalSemaphore(m_queue); + lStatus = MPExitCriticalRegion(m_mutex); assert(lStatus == noErr); - --signals; + + while (signals) + { + lStatus = MPSignalSemaphore(m_queue); + assert(lStatus == noErr); + --signals; + } } - } } void condition_impl::enter_wait() @@ -550,50 +550,50 @@ void condition_impl::do_wait() unsigned was_gone=0; lStatus = safe_enter_critical_region(m_mutex, kDurationForever, - m_mutex_mutex); + m_mutex_mutex); assert(lStatus == noErr); was_waiting = m_waiting; was_gone = m_gone; if (was_waiting != 0) - { - if (--m_waiting == 0) { - if (m_blocked != 0) - { - lStatus = MPSignalSemaphore(m_gate); // open m_gate - assert(lStatus == noErr); - was_waiting = 0; - } - else if (m_gone != 0) - m_gone = 0; + if (--m_waiting == 0) + { + if (m_blocked != 0) + { + lStatus = MPSignalSemaphore(m_gate); // open m_gate + assert(lStatus == noErr); + was_waiting = 0; + } + else if (m_gone != 0) + m_gone = 0; + } } - } else if (++m_gone == (std::numeric_limits::max() / 2)) - { - // timeout occured, normalize the m_gone count - // this may occur if many calls to wait with a timeout are made and - // no call to notify_* is made - lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); - assert(lStatus == noErr); - m_blocked -= m_gone; - lStatus = MPSignalSemaphore(m_gate); - assert(lStatus == noErr); - m_gone = 0; - } + { + // timeout occured, normalize the m_gone count + // this may occur if many calls to wait with a timeout are made and + // no call to notify_* is made + lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); + assert(lStatus == noErr); + m_blocked -= m_gone; + lStatus = MPSignalSemaphore(m_gate); + assert(lStatus == noErr); + m_gone = 0; + } lStatus = MPExitCriticalRegion(m_mutex); assert(lStatus == noErr); if (was_waiting == 1) - { - for (/**/ ; was_gone; --was_gone) { - // better now than spurious later - lStatus = safe_wait_on_semaphore(m_queue, kDurationForever); + for (/**/ ; was_gone; --was_gone) + { + // better now than spurious later + lStatus = safe_wait_on_semaphore(m_queue, kDurationForever); + assert(lStatus == noErr); + } + lStatus = MPSignalSemaphore(m_gate); assert(lStatus == noErr); } - lStatus = MPSignalSemaphore(m_gate); - assert(lStatus == noErr); - } } bool condition_impl::do_timed_wait(const xtime& xt) @@ -611,57 +611,57 @@ bool condition_impl::do_timed_wait(const xtime& xt) unsigned was_gone=0; lStatus = safe_enter_critical_region(m_mutex, kDurationForever, - m_mutex_mutex); + m_mutex_mutex); assert(lStatus == noErr); was_waiting = m_waiting; was_gone = m_gone; if (was_waiting != 0) - { - if (!ret) // timeout { - if (m_blocked != 0) - --m_blocked; - else - ++m_gone; // count spurious wakeups + if (!ret) // timeout + { + if (m_blocked != 0) + --m_blocked; + else + ++m_gone; // count spurious wakeups + } + if (--m_waiting == 0) + { + if (m_blocked != 0) + { + lStatus = MPSignalSemaphore(m_gate); // open m_gate + assert(lStatus == noErr); + was_waiting = 0; + } + else if (m_gone != 0) + m_gone = 0; + } } - if (--m_waiting == 0) - { - if (m_blocked != 0) - { - lStatus = MPSignalSemaphore(m_gate); // open m_gate - assert(lStatus == noErr); - was_waiting = 0; - } - else if (m_gone != 0) - m_gone = 0; - } - } else if (++m_gone == (std::numeric_limits::max() / 2)) - { - // timeout occured, normalize the m_gone count - // this may occur if many calls to wait with a timeout are made and - // no call to notify_* is made - lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); - assert(lStatus == noErr); - m_blocked -= m_gone; - lStatus = MPSignalSemaphore(m_gate); - assert(lStatus == noErr); - m_gone = 0; - } + { + // timeout occured, normalize the m_gone count + // this may occur if many calls to wait with a timeout are made and + // no call to notify_* is made + lStatus = safe_wait_on_semaphore(m_gate, kDurationForever); + assert(lStatus == noErr); + m_blocked -= m_gone; + lStatus = MPSignalSemaphore(m_gate); + assert(lStatus == noErr); + m_gone = 0; + } lStatus = MPExitCriticalRegion(m_mutex); assert(lStatus == noErr); if (was_waiting == 1) - { - for (/**/ ; was_gone; --was_gone) { - // better now than spurious later - lStatus = safe_wait_on_semaphore(m_queue, kDurationForever); + for (/**/ ; was_gone; --was_gone) + { + // better now than spurious later + lStatus = safe_wait_on_semaphore(m_queue, kDurationForever); + assert(lStatus == noErr); + } + lStatus = MPSignalSemaphore(m_gate); assert(lStatus == noErr); } - lStatus = MPSignalSemaphore(m_gate); - assert(lStatus == noErr); - } return ret; } diff --git a/src/mutex.cpp b/src/mutex.cpp index 819ac201..887406e5 100644 --- a/src/mutex.cpp +++ b/src/mutex.cpp @@ -36,11 +36,11 @@ mutex::mutex() : m_mutex(0) { try { - m_mutex = reinterpret_cast(new CRITICAL_SECTION); - } - catch (...) - { - } + m_mutex = reinterpret_cast(new CRITICAL_SECTION); + } + catch (...) + { + } if (!m_mutex) throw thread_resource_error(); InitializeCriticalSection(reinterpret_cast(m_mutex)); diff --git a/src/recursive_mutex.cpp b/src/recursive_mutex.cpp index 3b9a2635..8301fd84 100644 --- a/src/recursive_mutex.cpp +++ b/src/recursive_mutex.cpp @@ -31,7 +31,7 @@ namespace boost { #if defined(BOOST_HAS_WINTHREADS) recursive_mutex::recursive_mutex() - : m_count(0), m_mutex(0) + : m_mutex(0), m_count(0) { try { diff --git a/src/threadmon.cpp b/src/threadmon.cpp index 2cb6d6e0..5e823733 100644 --- a/src/threadmon.cpp +++ b/src/threadmon.cpp @@ -44,7 +44,7 @@ registered_handlers registry; #endif extern "C" -BOOL WINAPI DllMain(HANDLE module, DWORD reason, LPVOID) +BOOL WINAPI DllMain(HANDLE /*module*/, DWORD reason, LPVOID) { switch (reason) { diff --git a/src/timeconv.inl b/src/timeconv.inl index 001dcccf..fd9f7cbb 100644 --- a/src/timeconv.inl +++ b/src/timeconv.inl @@ -100,7 +100,7 @@ inline void to_duration(boost::xtime xt, int& milliseconds) xt.nsec += NANOSECONDS_PER_SECOND; --xt.sec; } - milliseconds = ((xt.sec - cur.sec) * MILLISECONDS_PER_SECOND) + + milliseconds = (int)((xt.sec - cur.sec) * MILLISECONDS_PER_SECOND) + (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MILLISECOND/2)) / NANOSECONDS_PER_MILLISECOND); } @@ -117,7 +117,7 @@ inline void to_microduration(const boost::xtime& xt, int& microseconds) microseconds = 0; else { - microseconds = ((xt.sec - cur.sec) * MICROSECONDS_PER_SECOND) + + microseconds = (int)((xt.sec - cur.sec) * MICROSECONDS_PER_SECOND) + (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MICROSECOND/2)) / NANOSECONDS_PER_MICROSECOND); }