开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
ncbimtx.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：30k
源码类别：

生物技术

开发平台：

C/C++

ncbimtx.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: ncbimtx.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/03 19:28:17  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.17
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: ncbimtx.cpp,v 1000.2 2004/06/03 19:28:17 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author:  Denis Vakatov, Aleksey Grichenko
  36.  *
  37.  * File Description:
  38.  *   Multi-threading -- fast mutexes
  39.  *
  40.  *   MUTEX:
  41.  *      CInternalMutex   -- platform-dependent mutex functionality
  42.  *
  43.  */
  45. #include <ncbi_pch.hpp>
  46. #include <corelib/ncbimtx.hpp>
  47. #include <corelib/ncbi_limits.h>
  48. #include "ncbidbg_p.hpp"
  49. #include <stdio.h>
  50. #include <algorithm>
  51. #ifdef NCBI_POSIX_THREADS
  52. #  include <sys/time.h> // for gettimeofday()
  53. #endif
  56. #define STACK_THRESHOLD (1024)
  59. BEGIN_NCBI_SCOPE
  62. /////////////////////////////////////////////////////////////////////////////
  63. //  CInternalMutex::
  64. //
  66. void SSystemFastMutex::InitializeHandle(void)
  67. {
  68.     // Create platform-dependent mutex handle
  69. #if defined(NCBI_WIN32_THREADS)
  70.     xncbi_Validate((m_Handle = CreateMutex(NULL, FALSE, NULL)) != NULL,
  71.                    "Mutex creation failed");
  72. #elif defined(NCBI_POSIX_THREADS)
  73.     xncbi_Validate(pthread_mutex_init(&m_Handle, 0) == 0,
  74.                    "Mutex creation failed");
  75. #endif
  76. }
  78. void SSystemFastMutex::DestroyHandle(void)
  79. {
  80.     // Destroy system mutex handle
  81. #if defined(NCBI_WIN32_THREADS)
  82.     xncbi_Verify(CloseHandle(m_Handle) != 0);
  83. #elif defined(NCBI_POSIX_THREADS)
  84.     xncbi_Verify(pthread_mutex_destroy(&m_Handle) == 0);
  85. #endif
  86. }
  88. void SSystemFastMutex::InitializeStatic(void)
  89. {
  90. #if !defined(NCBI_NO_THREADS)
  91.     switch ( m_Magic ) {
  92.     case eMutexUninitialized: // ok
  93.         break;
  94.     case eMutexInitialized:
  95.         xncbi_Validate(0, "Double initialization of mutex");
  96.         break;
  97.     default:
  98.         xncbi_Validate(0, "SSystemFastMutex::m_Magic contains invalid value");
  99.         break;
  100.     }
  102.     InitializeHandle();
  103. #endif
  105.     m_Magic = eMutexInitialized;
  106. }
  109. void SSystemFastMutex::InitializeDynamic(void)
  110. {
  111. #if !defined(NCBI_NO_THREADS)
  112.     InitializeHandle();
  113. #endif
  115.     m_Magic = eMutexInitialized;
  116. }
  119. void SSystemFastMutex::Destroy(void)
  120. {
  121. #if !defined(NCBI_NO_THREADS)
  122.     xncbi_Validate(IsInitialized(), "Destruction of uninitialized mutex");
  123. #endif
  125.     m_Magic = eMutexUninitialized;
  127.     DestroyHandle();
  128. }
  130. void SSystemFastMutex::ThrowUninitialized(void)
  131. {
  132.     NCBI_THROW(CMutexException, eUninitialized, "Mutex uninitialized");
  133. }
  135. void SSystemFastMutex::ThrowLockFailed(void)
  136. {
  137.     NCBI_THROW(CMutexException, eLock, "Mutex lock failed");
  138. }
  140. void SSystemFastMutex::ThrowUnlockFailed(void)
  141. {
  142.     NCBI_THROW(CMutexException, eUnlock, "Mutex unlock failed");
  143. }
  145. void SSystemFastMutex::ThrowTryLockFailed(void)
  146. {
  147.     NCBI_THROW(CMutexException, eTryLock,
  148.                "Mutex check (TryLock) failed");
  149. }
  151. void SSystemMutex::Destroy(void)
  152. {
  153.     xncbi_Validate(m_Count == 0, "Destruction of locked mutex");
  154.     m_Mutex.Destroy();
  155. }
  157. #if !defined(NCBI_NO_THREADS)
  158. void SSystemMutex::Lock(void)
  159. {
  160.     m_Mutex.CheckInitialized();
  162.     CThreadSystemID owner = CThreadSystemID::GetCurrent();
  163.     if ( m_Count > 0 && m_Owner.Is(owner) ) {
  164.         // Don't lock twice, just increase the counter
  165.         m_Count++;
  166.         return;
  167.     }
  169.     // Lock the mutex and remember the owner
  170.     m_Mutex.Lock();
  171.     assert(m_Count == 0);
  172.     m_Owner.Set(owner);
  173.     m_Count = 1;
  174. }
  176. bool SSystemMutex::TryLock(void)
  177. {
  178.     m_Mutex.CheckInitialized();
  180.     CThreadSystemID owner = CThreadSystemID::GetCurrent();
  181.     if ( m_Count > 0 && m_Owner.Is(owner) ) {
  182.         // Don't lock twice, just increase the counter
  183.         m_Count++;
  184.         return true;
  185.     }
  187.     // If TryLock is successful, remember the owner
  188.     if ( m_Mutex.TryLock() ) {
  189.         assert(m_Count == 0);
  190.         m_Owner.Set(owner);
  191.         m_Count = 1;
  192.         return true;
  193.     }
  195.     // Cannot lock right now
  196.     return false;
  197. }
  199. void SSystemMutex::Unlock(void)
  200. {
  201.     m_Mutex.CheckInitialized();
  203.     // No unlocks by threads other than owner.
  204.     // This includes no unlocks of unlocked mutex.
  205.     CThreadSystemID owner = CThreadSystemID::GetCurrent();
  206.     if ( m_Count == 0 || m_Owner.IsNot(owner) ) {
  207.         ThrowNotOwned();
  208.     }
  210.     // No real unlocks if counter > 1, just decrease it
  211.     if (--m_Count > 0) {
  212.         return;
  213.     }
  215.     assert(m_Count == 0);
  216.     // This was the last lock - clear the owner and unlock the mutex
  217.     m_Mutex.Unlock();
  218. }
  219. #endif
  221. void SSystemMutex::ThrowNotOwned(void)
  222. {
  223.     NCBI_THROW(CMutexException, eOwner,
  224.                "Mutex is not owned by current thread");
  225. }
  228. #if defined(NEED_AUTO_INITIALIZE_MUTEX)
  230. const char* kInitMutexName = "NCBI_CAutoInitializeStaticMutex";
  232. void CAutoInitializeStaticFastMutex::Initialize(void)
  233. {
  234.     if ( m_Mutex.IsInitialized() ) {
  235.         return;
  236.     }
  237.     TSystemMutex init_mutex = CreateMutex(NULL, FALSE, kInitMutexName);
  238.     assert(init_mutex);
  239.     assert(WaitForSingleObject(init_mutex, INFINITE) == WAIT_OBJECT_0);
  240.     if ( !m_Mutex.IsInitialized() ) {
  241.         m_Mutex.InitializeStatic();
  242.     }
  243.     assert(ReleaseMutex(init_mutex));
  244.     assert(m_Mutex.IsInitialized());
  245.     CloseHandle(init_mutex);
  246. }
  248. void CAutoInitializeStaticMutex::Initialize(void)
  249. {
  250.     if ( m_Mutex.IsInitialized() ) {
  251.         return;
  252.     }
  253.     TSystemMutex init_mutex = CreateMutex(NULL, FALSE, kInitMutexName);
  254.     assert(init_mutex);
  255.     assert(WaitForSingleObject(init_mutex, INFINITE) == WAIT_OBJECT_0);
  256.     if ( !m_Mutex.IsInitialized() ) {
  257.         m_Mutex.InitializeStatic();
  258.     }
  259.     assert(ReleaseMutex(init_mutex));
  260.     assert(m_Mutex.IsInitialized());
  261.     CloseHandle(init_mutex);
  262. }
  264. #endif
  266. const char* CMutexException::GetErrCodeString(void) const
  267. {
  268.     switch (GetErrCode()) {
  269.     case eLock:    return "eLock";
  270.     case eUnlock:  return "eUnlock";
  271.     case eTryLock: return "eTryLock";
  272.     case eOwner:   return "eOwner";
  273.     case eUninitialized:  return "eUninitialized";
  274.     default:       return CException::GetErrCodeString();
  275.     }
  276. }
  278. /////////////////////////////////////////////////////////////////////////////
  279. //  CInternalRWLock::
  280. //
  282. #if defined(NCBI_WIN32_THREADS)
  284. class CWindowsHandle
  285. {
  286. public:
  287.     CWindowsHandle(HANDLE h = NULL) : m_Handle(h) {}
  288.     CWindowsHandle(HANDLE h, const char* errorMessage) : m_Handle(h)
  289.     {
  290.         xncbi_Validate(h != NULL, errorMessage);
  291.     }
  292.     ~CWindowsHandle(void) { Close(); }
  294.     void Close(void)
  295.     {
  296.         if ( m_Handle != NULL ) {
  297.             CloseHandle(m_Handle);
  298.             m_Handle = NULL;
  299.         }
  300.     }
  302.     void Set(HANDLE h)
  303.     {
  304.         Close();
  305.         m_Handle = h;
  306.     }
  307.     void Set(HANDLE h, const char* errorMessage)
  308.     {
  309.         xncbi_Validate(h != NULL, errorMessage);
  310.         Set(h);        
  311.     }
  313.     operator HANDLE(void) const { return m_Handle; }
  315. protected:
  316.     HANDLE m_Handle;
  318. private:
  319.     CWindowsHandle(const CWindowsHandle& h);
  320.     CWindowsHandle& operator=(const CWindowsHandle& h);
  321. };
  323. class CWindowsSemaphore : public CWindowsHandle
  324. {
  325. public:
  326.     CWindowsSemaphore(LONG initialCount = 0, LONG maximumCount = INFINITE)
  327.         : CWindowsHandle(CreateSemaphore(NULL,
  328.                                          initialCount, maximumCount,
  329.                                          NULL),
  330.                          "CreateSemaphore() failed")
  331.     {
  332.     }
  334.     LONG Release(LONG add = 1)
  335.     {
  336.         LONG prev_sema;
  337.         xncbi_Validate(ReleaseSemaphore(*this, add, &prev_sema),
  338.                        "CWindowsSemaphore::Release() failed");
  339.         return prev_sema;
  340.     }
  341. };
  343. #endif
  345. #if defined(NCBI_POSIX_THREADS)
  347. class CPthreadCond
  348. {
  349. public:
  350.     CPthreadCond(void)
  351.         : m_Initialized(pthread_cond_init(&m_Handle, 0) != 0)
  352.     {
  353.     }
  354.     ~CPthreadCond(void)
  355.     {
  356.         if ( m_Initialized ) {
  357.             pthread_cond_destroy(&m_Handle);
  358.         }
  359.     }
  361.     operator pthread_cond_t*(void) { return &m_Handle; }
  362.     operator pthread_cond_t&(void) { return m_Handle; }
  364. protected:
  365.     pthread_cond_t  m_Handle;
  366.     bool            m_Initialized;
  367. };
  369. #endif
  371. class CInternalRWLock
  372. {
  373. public:
  374.     CInternalRWLock(void);
  376.     // Platform-dependent RW-lock data
  377. #if defined(NCBI_WIN32_THREADS)
  378.     CWindowsSemaphore   m_Rsema;
  379.     CWindowsSemaphore   m_Wsema;
  380.     CFastMutex          m_Mutex;
  381. #elif defined(NCBI_POSIX_THREADS)
  382.     CPthreadCond        m_Rcond;
  383.     CPthreadCond        m_Wcond;
  384.     CFastMutex          m_Mutex;
  385. #endif
  386. };
  388. inline
  389. CInternalRWLock::CInternalRWLock(void)
  390. #if defined(NCBI_WIN32_THREADS)
  391.     : m_Rsema(1, 1), m_Wsema(1, 1)
  392. #endif
  393. {
  394. }
  396. /////////////////////////////////////////////////////////////////////////////
  397. //  CRWLock::
  398. //
  400. CRWLock::CRWLock(void)
  401.     : m_RW(new CInternalRWLock),
  402.       m_Count(0)
  403. {
  404. #if defined(_DEBUG)
  405.     m_Readers.reserve(16);
  406. #endif
  407. }
  410. CRWLock::~CRWLock(void)
  411. {
  412. }
  415. void CRWLock::ReadLock(void)
  416. {
  417. #if defined(NCBI_NO_THREADS)
  418.     return;
  419. #else
  420.     // Lock mutex now, unlock before exit.
  421.     // (in fact, it will be unlocked by the waiting function for a while)
  422.     CFastMutexGuard guard(m_RW->m_Mutex);
  423.     CThreadSystemID self_id = CThreadSystemID::GetCurrent();
  424.     if ( m_Count < 0 ) {
  425.         if ( m_Owner.Is(self_id) ) {
  426.             // if W-locked by the same thread - update W-counter
  427.             m_Count--;
  428.         }
  429.         else {
  430.             // W-locked by another thread
  431. #if defined(NCBI_WIN32_THREADS)
  432.             HANDLE obj[2];
  433.             DWORD  wait_res;
  434.             obj[0] = m_RW->m_Mutex.GetHandle();
  435.             obj[1] = m_RW->m_Rsema;
  437.             xncbi_Validate(ReleaseMutex(m_RW->m_Mutex.GetHandle()),
  438.                            "CRWLock::ReadLock() - release mutex error");
  439.             wait_res = WaitForMultipleObjects(2, obj, TRUE, INFINITE);
  440.             xncbi_Validate(wait_res >= WAIT_OBJECT_0  &&
  441.                            wait_res < WAIT_OBJECT_0 + 2,
  442.                            "CRWLock::ReadLock() - R-lock waiting error");
  443.             // Success, check the semaphore
  444.             xncbi_Validate(m_RW->m_Rsema.Release() == 0,
  445.                            "CRWLock::ReadLock() - invalid R-semaphore state");
  446.             if (m_Count == 0) {
  447.                 xncbi_Validate(WaitForSingleObject(m_RW->m_Wsema,
  448.                                                    0) == WAIT_OBJECT_0,
  449.                                "CRWLock::ReadLock() - "
  450.                                "failed to lock W-semaphore");
  451.             }
  452. #elif defined(NCBI_POSIX_THREADS)
  453.             while (m_Count < 0) {
  454.                 xncbi_Validate(pthread_cond_wait(m_RW->m_Rcond,
  455.                                                  m_RW->m_Mutex.GetHandle())
  456.                                == 0,
  457.                                "CRWLock::ReadLock() - R-lock waiting error");
  458.             }
  459. #else
  460.             // Can not be already W-locked by another thread without MT
  461.             xncbi_Validate(0,
  462.                            "CRWLock::ReadLock() - "
  463.                            "weird R-lock error in non-MT mode");
  464. #endif
  465.             xncbi_Validate(m_Count >= 0,
  466.                            "CRWLock::ReadLock() - invalid readers counter");
  467.             m_Count++;
  468.         }
  469.     }
  470.     else {
  471. #if defined(NCBI_WIN32_THREADS)
  472.         if (m_Count == 0) {
  473.             // Unlocked
  474.             // Lock against writers
  475.             xncbi_Validate(WaitForSingleObject(m_RW->m_Wsema, 0)
  476.                            == WAIT_OBJECT_0,
  477.                            "CRWLock::ReadLock() - "
  478.                            "can not lock W-semaphore");
  479.         }
  480. #endif
  481.         m_Count++;
  482.     }
  484. #if defined(_DEBUG)
  485.     // Remember new reader
  486.     if (m_Count > 0) {
  487.         m_Readers.push_back(self_id);
  488.     }
  489. #endif
  490. #endif
  491. }
  494. bool CRWLock::TryReadLock(void)
  495. {
  496. #if defined(NCBI_NO_THREADS)
  497.     return true;
  498. #else
  500.     CFastMutexGuard guard(m_RW->m_Mutex);
  501.     CThreadSystemID self_id = CThreadSystemID::GetCurrent();
  503.     if (m_Count < 0) {
  504.         if ( m_Owner.IsNot(self_id) ) {
  505.             // W-locked by another thread
  506.             return false;
  507.         }
  508.         else {
  509.             // W-locked, try to set R after W if in the same thread
  510.             m_Count--;
  511.             return true;
  512.         }
  513.     }
  515.     // Unlocked - do R-lock
  516. #if defined(NCBI_WIN32_THREADS)
  517.     if (m_Count == 0) {
  518.         // Lock W-semaphore in MSWIN
  519.         xncbi_Validate(WaitForSingleObject(m_RW->m_Wsema, 0)
  520.                        == WAIT_OBJECT_0,
  521.                        "CRWLock::TryReadLock() - "
  522.                        "can not lock W-semaphore");
  523.     }
  524. #endif
  525.     m_Count++;
  526. #if defined(_DEBUG)
  527.     m_Readers.push_back(self_id);
  528. #endif
  529.     return true;
  530. #endif
  531. }
  534. void CRWLock::WriteLock(void)
  535. {
  536. #if defined(NCBI_NO_THREADS)
  537.     return;
  538. #else
  539.     CFastMutexGuard guard(m_RW->m_Mutex);
  540.     CThreadSystemID self_id = CThreadSystemID::GetCurrent();
  542.     if ( m_Count < 0 && m_Owner.Is(self_id) ) {
  543.         // W-locked by the same thread
  544.         m_Count--;
  545.     }
  546.     else {
  547.         // Unlocked or RW-locked by another thread
  549.         // Look in readers - must not be there
  550.         xncbi_Validate(find(m_Readers.begin(), m_Readers.end(), self_id)
  551.                        == m_Readers.end(),
  552.                        "CRWLock::WriteLock() - "
  553.                        "attempt to set W-after-R lock");
  555. #if defined(NCBI_WIN32_THREADS)
  556.         HANDLE obj[3];
  557.         obj[0] = m_RW->m_Rsema;
  558.         obj[1] = m_RW->m_Wsema;
  559.         obj[2] = m_RW->m_Mutex.GetHandle();
  560.         DWORD wait_res;
  561.         if (m_Count == 0) {
  562.             // Unlocked - lock both semaphores
  563.             wait_res = WaitForMultipleObjects(2, obj, TRUE, 0);
  564.             xncbi_Validate(wait_res >= WAIT_OBJECT_0  &&
  565.                            wait_res < WAIT_OBJECT_0+2,
  566.                            "CRWLock::WriteLock() - "
  567.                            "error locking R&W-semaphores");
  568.         }
  569.         else {
  570.             // Locked by another thread - wait for unlock
  571.             xncbi_Validate(ReleaseMutex(m_RW->m_Mutex.GetHandle()),
  572.                            "CRWLock::ReadLock() - release mutex error");
  573.             wait_res = WaitForMultipleObjects(3, obj, TRUE, INFINITE);
  574.             xncbi_Validate(wait_res >= WAIT_OBJECT_0  &&
  575.                            wait_res < WAIT_OBJECT_0+3,
  576.                            "CRWLock::WriteLock() - "
  577.                            "error locking R&W-semaphores");
  578.         }
  579. #elif defined(NCBI_POSIX_THREADS)
  580.         while (m_Count != 0) {
  581.             xncbi_Validate(pthread_cond_wait(m_RW->m_Wcond,
  582.                                              m_RW->m_Mutex.GetHandle()) == 0,
  583.                            "CRWLock::WriteLock() - "
  584.                            "error locking R&W-conditionals");
  585.         }
  586. #endif
  587.         xncbi_Validate(m_Count >= 0,
  588.                        "CRWLock::WriteLock() - invalid readers counter");
  589.         m_Count = -1;
  590.         m_Owner.Set(self_id);
  591.     }
  593.     // No readers allowed
  594.     _ASSERT(m_Readers.empty());
  595. #endif
  596. }
  599. bool CRWLock::TryWriteLock(void)
  600. {
  601. #if defined(NCBI_NO_THREADS)
  602.     return true;
  603. #else
  605.     CFastMutexGuard guard(m_RW->m_Mutex);
  606.     CThreadSystemID self_id = CThreadSystemID::GetCurrent();
  608.     if ( m_Count < 0 ) {
  609.         // W-locked
  610.         if ( m_Owner.IsNot(self_id) ) {
  611.             // W-locked by another thread
  612.             return false;
  613.         }
  614.         // W-locked by same thread
  615.         m_Count--;
  616.     }
  617.     else if ( m_Count > 0 ) {
  618.         // R-locked
  619.         return false;
  620.     }
  621.     else {
  622.         // Unlocked - do W-lock
  623. #if defined(NCBI_WIN32_THREADS)
  624.         // In MSWIN lock semaphores
  625.         HANDLE obj[2];
  626.         obj[0] = m_RW->m_Rsema;
  627.         obj[1] = m_RW->m_Wsema;
  628.         DWORD wait_res;
  629.         wait_res = WaitForMultipleObjects(2, obj, TRUE, 0);
  630.         xncbi_Validate(wait_res >= WAIT_OBJECT_0  &&
  631.                        wait_res < WAIT_OBJECT_0 + 2,
  632.                        "CRWLock::TryWriteLock() - "
  633.                        "error locking R&W-semaphores");
  634. #endif
  635.         m_Count = -1;
  636.         m_Owner.Set(self_id);
  637.     }
  639.     // No readers allowed
  640.     _ASSERT(m_Readers.empty());
  642.     return true;
  643. #endif
  644. }
  647. void CRWLock::Unlock(void)
  648. {
  649. #if defined(NCBI_NO_THREADS)
  650.     return;
  651. #else
  653.     CFastMutexGuard guard(m_RW->m_Mutex);
  654.     CThreadSystemID self_id = CThreadSystemID::GetCurrent();
  656.     if (m_Count < 0) {
  657.         // Check it is R-locked or W-locked by the same thread
  658.         xncbi_Validate(m_Owner.Is(self_id),
  659.                        "CRWLock::Unlock() - "
  660.                        "RWLock is locked by another thread");
  661.         if ( ++m_Count == 0 ) {
  662.             // Unlock the last W-lock
  663. #if defined(NCBI_WIN32_THREADS)
  664.             xncbi_Validate(m_RW->m_Rsema.Release() == 0,
  665.                            "CRWLock::Unlock() - invalid R-semaphore state");
  666.             xncbi_Validate(m_RW->m_Wsema.Release() == 0,
  667.                            "CRWLock::Unlock() - invalid R-semaphore state");
  668. #elif defined(NCBI_POSIX_THREADS)
  669.             xncbi_Validate(pthread_cond_broadcast(m_RW->m_Rcond) == 0,
  670.                            "CRWLock::Unlock() - error signalling unlock");
  671.             xncbi_Validate(pthread_cond_signal(m_RW->m_Wcond) == 0,
  672.                            "CRWLock::Unlock() - error signalling unlock");
  673. #endif
  674.         }
  675. #if defined(_DEBUG)
  676.         // Check if the unlocking thread is in the owners list
  677.         _ASSERT(find(m_Readers.begin(), m_Readers.end(), self_id)
  678.                == m_Readers.end());
  679. #endif
  680.     }
  681.     else {
  682.         xncbi_Validate(m_Count != 0,
  683.                        "CRWLock::Unlock() - RWLock is not locked");
  684.         if ( --m_Count == 0 ) {
  685.             // Unlock the last R-lock
  686. #if defined(NCBI_WIN32_THREADS)
  687.             xncbi_Validate(m_RW->m_Wsema.Release() == 0,
  688.                            "CRWLock::Unlock() - invalid W-semaphore state");
  689. #elif defined(NCBI_POSIX_THREADS)
  690.             xncbi_Validate(pthread_cond_signal(m_RW->m_Wcond) == 0,
  691.                            "CRWLock::Unlock() - error signaling unlock");
  692. #endif
  693.         }
  694. #if defined(_DEBUG)
  695.         // Check if the unlocking thread is in the owners list
  696.         vector<CThreadSystemID>::iterator found =
  697.             find(m_Readers.begin(), m_Readers.end(), self_id);
  698.         _ASSERT(found != m_Readers.end());
  699.         m_Readers.erase(found);
  700.         if ( m_Count == 0 ) {
  701.             _ASSERT(m_Readers.empty());
  702.         }
  703. #endif
  704.     }
  705. #endif
  706. }
  711. /////////////////////////////////////////////////////////////////////////////
  712. //  SEMAPHORE
  713. //
  716. // Platform-specific representation (or emulation) of semaphore
  717. struct SSemaphore
  718. {
  719. #if defined(NCBI_POSIX_THREADS)
  720.     unsigned int     max_count;
  721.     unsigned int     count; 
  722.     unsigned int     wait_count;  // # of threads currently waiting on the sema
  723.     pthread_mutex_t  mutex;
  724.     pthread_cond_t   cond;
  726. #elif defined(NCBI_WIN32_THREADS)
  727.     HANDLE           sem;
  728. #else
  729.     unsigned int     max_count;
  730.     unsigned int     count;
  731. #endif
  732. };
  735. CSemaphore::CSemaphore(unsigned int init_count, unsigned int max_count)
  736. {
  737.     xncbi_Validate(max_count != 0,
  738.                    "CSemaphore::CSemaphore() - max_count passed zero");
  739.     xncbi_Validate(init_count <= max_count,
  740.                    "CSemaphore::CSemaphore() - init_count "
  741.                    "greater than max_count");
  743.     m_Sem = new SSemaphore;
  744.     auto_ptr<SSemaphore> auto_sem(m_Sem);
  746. #if defined(NCBI_POSIX_THREADS)
  747.     m_Sem->max_count = max_count;
  748.     m_Sem->count     = init_count;
  749.     m_Sem->wait_count = 0;
  751.     xncbi_Validate(pthread_mutex_init(&m_Sem->mutex, 0) == 0,
  752.                    "CSemaphore::CSemaphore() - pthread_mutex_init() failed");
  753.     xncbi_Validate(pthread_cond_init(&m_Sem->cond, 0) == 0,
  754.                    "CSemaphore::CSemaphore() - pthread_cond_init() failed");
  756. #elif defined(NCBI_WIN32_THREADS)
  757.     m_Sem->sem = CreateSemaphore(NULL, init_count, max_count, NULL);
  758.     xncbi_Validate(m_Sem->sem != NULL,
  759.                    "CSemaphore::CSemaphore() - CreateSemaphore() failed");
  761. #else
  762.     m_Sem->max_count = max_count;
  763.     m_Sem->count     = init_count;
  764. #endif
  766.     auto_sem.release();
  767. }
  770. CSemaphore::~CSemaphore(void)
  771. {
  772. #if defined(NCBI_POSIX_THREADS)
  773.     _ASSERT(m_Sem->wait_count == 0);
  774.     xncbi_Verify(pthread_mutex_destroy(&m_Sem->mutex) == 0);
  775.     xncbi_Verify(pthread_cond_destroy(&m_Sem->cond)  == 0);
  777. #elif defined(NCBI_WIN32_THREADS)
  778.     xncbi_Verify( CloseHandle(m_Sem->sem) );
  779. #endif
  781.     delete m_Sem;
  782. }
  785. void CSemaphore::Wait(void)
  786. {
  787. #if defined(NCBI_POSIX_THREADS)
  788.     xncbi_Validate(pthread_mutex_lock(&m_Sem->mutex) == 0,
  789.                    "CSemaphore::Wait() - pthread_mutex_lock() failed");
  791.     if (m_Sem->count != 0) {
  792.         m_Sem->count--;
  793.     }
  794.     else {
  795.         m_Sem->wait_count++;
  796.         do {
  797.             if (pthread_cond_wait(&m_Sem->cond, &m_Sem->mutex) != 0) {
  798.                 xncbi_Validate(pthread_mutex_unlock(&m_Sem->mutex) == 0,
  799.                                "CSemaphore::Wait() - "
  800.                                "pthread_cond_wait() and "
  801.                                "pthread_mutex_unlock() failed");
  802.                 xncbi_Validate(0,
  803.                                "CSemaphore::Wait() - "
  804.                                "pthread_cond_wait() failed");
  805.             }
  806.         } while (m_Sem->count == 0);
  807.         m_Sem->wait_count--;
  808.         m_Sem->count--;
  809.     }
  811.     xncbi_Validate(pthread_mutex_unlock(&m_Sem->mutex) == 0,
  812.                    "CSemaphore::Wait() - pthread_mutex_unlock() failed");
  814. #elif defined(NCBI_WIN32_THREADS)
  815.     xncbi_Validate(WaitForSingleObject(m_Sem->sem, INFINITE) == WAIT_OBJECT_0,
  816.                    "CSemaphore::Wait() - WaitForSingleObject() failed");
  818. #else
  819.     xncbi_Validate(m_Sem->count != 0,
  820.                    "CSemaphore::Wait() - "
  821.                    "wait with zero count in one-thread mode(?!)");
  822.     m_Sem->count--;
  823. #endif
  824. }
  826. #if defined(NCBI_NO_THREADS)
  827. # define NCBI_THREADS_ARG(arg) 
  828. #else
  829. # define NCBI_THREADS_ARG(arg) arg
  830. #endif
  832. bool CSemaphore::TryWait(unsigned int NCBI_THREADS_ARG(timeout_sec),
  833.                          unsigned int NCBI_THREADS_ARG(timeout_nsec))
  834. {
  835. #if defined(NCBI_POSIX_THREADS)
  836.     xncbi_Validate(pthread_mutex_lock(&m_Sem->mutex) == 0,
  837.                    "CSemaphore::TryWait() - pthread_mutex_lock() failed");
  839.     bool retval = false;
  840.     if (m_Sem->count != 0) {
  841.         m_Sem->count--;
  842.         retval = true;
  843.     }
  844.     else if (timeout_sec > 0  ||  timeout_nsec > 0) {
  845. # ifdef NCBI_OS_SOLARIS
  846.         // arbitrary limit of 100Ms (~3.1 years) -- supposedly only for
  847.         // native threads, but apparently also for POSIX threads :-/
  848.         if (timeout_sec >= 100 * 1000 * 1000) {
  849.             timeout_sec  = 100 * 1000 * 1000;
  850.             timeout_nsec = 0;
  851.         }
  852. # endif
  853.         static const unsigned int kBillion = 1000 * 1000 * 1000;
  854.         struct timeval  now;
  855.         struct timespec timeout = { 0, 0 };
  856.         gettimeofday(&now, 0);
  857.         // timeout_sec added below to avoid overflow
  858.         timeout.tv_sec  = now.tv_sec;
  859.         timeout.tv_nsec = now.tv_usec * 1000 + timeout_nsec;
  860.         if ((unsigned int)timeout.tv_nsec >= kBillion) {
  861.             timeout.tv_sec  += timeout.tv_nsec / kBillion;
  862.             timeout.tv_nsec %= kBillion;
  863.         }
  864.         if (timeout_sec > (unsigned int)(kMax_Int - timeout.tv_sec)) {
  865.             // Max out rather than overflowing
  866.             timeout.tv_sec  = kMax_Int;
  867.             timeout.tv_nsec = kBillion - 1;
  868.         } else {
  869.             timeout.tv_sec += timeout_sec;
  870.         }
  871.         
  872.         m_Sem->wait_count++;
  873.         do {
  874.             int status = pthread_cond_timedwait(&m_Sem->cond, &m_Sem->mutex,
  875.                                                 &timeout);
  876.             if (status == ETIMEDOUT) {
  877.                 break;
  878.             } else if (status != 0  &&  status != EINTR) {
  879.                 // EINVAL, presumably?
  880.                 xncbi_Validate(pthread_mutex_unlock(&m_Sem->mutex) == 0,
  881.                                "CSemaphore::TryWait() - "
  882.                                "pthread_cond_timedwait() and "
  883.                                "pthread_mutex_unlock() failed");
  884.                 xncbi_Validate(0, "CSemaphore::TryWait() - "
  885.                                "pthread_cond_timedwait() failed");
  886.             }
  887.         } while (m_Sem->count == 0);
  888.         m_Sem->wait_count--;
  889.         m_Sem->count--;
  890.         retval = true;
  891.     }
  893.     xncbi_Validate(pthread_mutex_unlock(&m_Sem->mutex) == 0,
  894.                    "CSemaphore::TryWait() - pthread_mutex_unlock() failed");
  896.     return retval;
  898. #elif defined(NCBI_WIN32_THREADS)
  899.     DWORD timeout_msec; // DWORD == unsigned long
  900.     if (timeout_sec >= kMax_ULong / 1000) {
  901.         timeout_msec = kMax_ULong;
  902.     } else {
  903.         timeout_msec = timeout_sec * 1000 + timeout_nsec / (1000 * 1000);
  904.     }
  905.     DWORD res = WaitForSingleObject(m_Sem->sem, timeout_msec);
  906.     xncbi_Validate(res == WAIT_OBJECT_0  ||  res == WAIT_TIMEOUT,
  907.                    "CSemaphore::TryWait() - WaitForSingleObject() failed");
  908.     return (res == WAIT_OBJECT_0);
  910. #else
  911.     if (m_Sem->count == 0)
  912.         return false;
  913.     m_Sem->count--;
  914.     return true;
  915. #endif
  916. }
  919. void CSemaphore::Post(unsigned int count)
  920. {
  921.     if (count == 0)
  922.         return;
  924. #if defined (NCBI_POSIX_THREADS)
  925.     xncbi_Validate(pthread_mutex_lock(&m_Sem->mutex) == 0,
  926.                    "CSemaphore::Post() - pthread_mutex_lock() failed");
  928.     if (m_Sem->count > kMax_UInt - count  ||
  929.         m_Sem->count + count > m_Sem->max_count) {
  930.         xncbi_Validate(pthread_mutex_unlock(&m_Sem->mutex) == 0,
  931.                        "CSemaphore::Post() - "
  932.                        "attempt to exceed max_count and "
  933.                        "pthread_mutex_unlock() failed");
  934.         xncbi_Validate(m_Sem->count <= kMax_UInt - count,
  935.                        "CSemaphore::Post() - "
  936.                        "would result in counter > MAX_UINT");
  937.         xncbi_Validate(m_Sem->count + count <= m_Sem->max_count,
  938.                        "CSemaphore::Post() - attempt to exceed max_count");
  939.         _TROUBLE;
  940.     }
  942.     // Signal some (or all) of the threads waiting on this semaphore
  943.     int err_code = 0;
  944.     if (m_Sem->count + count >= m_Sem->wait_count) {
  945.         err_code = pthread_cond_broadcast(&m_Sem->cond);
  946.     } else {
  947.         // Do not use broadcast here to avoid waking up more threads
  948.         // than really needed...
  949.         for (unsigned int n_sig = 0;  n_sig < count;  n_sig++) {
  950.             err_code = pthread_cond_signal(&m_Sem->cond);
  951.             if (err_code != 0) {
  952.                 err_code = pthread_cond_broadcast(&m_Sem->cond);
  953.                 break;
  954.             }
  955.         }
  956.     }
  958.     // Success
  959.     if (err_code == 0) {
  960.         m_Sem->count += count;
  961.         xncbi_Validate(pthread_mutex_unlock(&m_Sem->mutex) == 0,
  962.                        "CSemaphore::Post() - pthread_mutex_unlock() failed");
  963.         return;
  964.     }
  966.     // Error
  967.     xncbi_Validate(pthread_mutex_unlock(&m_Sem->mutex) == 0,
  968.                    "CSemaphore::Post() - "
  969.                    "pthread_cond_signal/broadcast() and "
  970.                    "pthread_mutex_unlock() failed");
  971.     xncbi_Validate(0,
  972.                    "CSemaphore::Post() - "
  973.                    "pthread_cond_signal/broadcast() failed");
  975. #elif defined(NCBI_WIN32_THREADS)
  976.     xncbi_Validate(ReleaseSemaphore(m_Sem->sem, count, NULL),
  977.                    "CSemaphore::Post() - ReleaseSemaphore() failed");
  979. #else
  980.     xncbi_Validate(m_Sem->count + count <= m_Sem->max_count,
  981.                    "CSemaphore::Post() - attempt to exceed max_count");
  982.     m_Sem->count += count;
  983. #endif
  984. }
  986. END_NCBI_SCOPE
  989. /*
  990.  * ===========================================================================
  991.  * $Log: ncbimtx.cpp,v $
  992.  * Revision 1000.2  2004/06/03 19:28:17  gouriano
  993.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.17
  994.  *
  995.  * Revision 1.17  2004/06/02 16:27:06  ucko
  996.  * SSystemFastMutex::InitializeDynamic: drop gratuituous and potentially
  997.  * error-prone check for double initialization after discussion with
  998.  * Eugene Vasilchenko.
  999.  *
  1000.  * Revision 1.16  2004/05/14 13:59:27  gorelenk
  1001.  * Added include of ncbi_pch.hpp
  1002.  *
  1003.  * Revision 1.15  2003/09/29 20:45:54  ivanov
  1004.  * CAutoInitializeStatic[Fast]Mutex:  changed method of initialization for static mutexes on MS Windows (by Eugene Vasilchenko)
  1005.  *
  1006.  * Revision 1.14  2003/09/17 17:56:47  vasilche
  1007.  * Fixed volatile methods of CThreadSystemID.
  1008.  *
  1009.  * Revision 1.13  2003/09/17 15:20:46  vasilche
  1010.  * Moved atomic counter swap functions to separate file.
  1011.  * Added CRef<>::AtomicResetFrom(), CRef<>::AtomicReleaseTo() methods.
  1012.  *
  1013.  * Revision 1.12  2003/09/02 19:03:59  vasilche
  1014.  * Removed debug abort().
  1015.  *
  1016.  * Revision 1.11  2003/09/02 16:08:49  vasilche
  1017.  * Fixed race condition with optimization on some compilers - added 'volatile'.
  1018.  * Moved mutex Lock/Unlock methods out of inline section - they are quite complex.
  1019.  *
  1020.  * Revision 1.10  2003/05/06 16:12:24  vasilche
  1021.  * Added check for mutexes located in stack.
  1022.  *
  1023.  * Revision 1.9  2002/09/24 18:29:53  vasilche
  1024.  * Removed TAB symbols. Removed unused arg warning in single thread mode.
  1025.  *
  1026.  * Revision 1.8  2002/09/23 13:47:23  vasilche
  1027.  * Made static mutex structures POD-types on Win32
  1028.  *
  1029.  * Revision 1.7  2002/09/20 18:46:24  vasilche
  1030.  * Fixed volatile incompatibility on Win32
  1031.  *
  1032.  * Revision 1.6  2002/09/19 20:24:08  vasilche
  1033.  * Replace missing std::count() by std::find()
  1034.  *
  1035.  * Revision 1.5  2002/09/19 20:05:42  vasilche
  1036.  * Safe initialization of static mutexes
  1037.  *
  1038.  * Revision 1.4  2002/07/11 14:18:27  gouriano
  1039.  * exceptions replaced by CNcbiException-type ones
  1040.  *
  1041.  * Revision 1.3  2002/04/11 21:08:02  ivanov
  1042.  * CVS log moved to end of the file
  1043.  *
  1044.  * Revision 1.2  2001/12/13 19:45:36  gouriano
  1045.  * added xxValidateAction functions
  1046.  *
  1047.  * Revision 1.1  2001/03/26 20:31:13  vakatov
  1048.  * Initial revision (moved code from "ncbithr.cpp")
  1049.  *
  1050.  * ===========================================================================
  1051.  */