Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/ncbimtx_8cpp_source.html below:

NCBI C++ ToolKit: src/corelib/ncbimtx.cpp Source File

s_WriteMutexEvent(

* mutex_ptr,

* message);

s_WriteMutexEvent(

* mutex_ptr,

* message)

= O_WRONLY | O_APPEND | O_CREAT;

*

= getenv(

);

str_os << mutex_ptr <<

write(handle, str_os.str(), str_os.pcount());

str_os.rdbuf()->freeze(

);

SSystemFastMutex::InitializeHandle(

)

InitializeSRWLock(&m_Handle);

InitializeCriticalSection(&m_Handle);

);

(pthread_mutex_init(&m_Handle, 0) != 0) {

memset(&m_Handle, 0,

(m_Handle));

);

SSystemFastMutex::DestroyHandle(

)

DeleteCriticalSection(&m_Handle);

SSystemFastMutex::InitializeStatic(

)

eMutexUninitialized:

eMutexInitialized:

(0,

);

m_Magic = eMutexInitialized;

SSystemFastMutex::InitializeDynamic(

)

m_Magic = eMutexInitialized;

SSystemFastMutex::Destroy(

)

(IsInitialized(),

);

m_Magic = eMutexUninitialized;

SSystemFastMutex::ThrowUninitialized(

)

SSystemFastMutex::ThrowLockFailed(

)

SSystemFastMutex::ThrowUnlockFailed(

)

SSystemFastMutex::ThrowTryLockFailed(

)

);

SSystemMutex::Destroy(

)

(lock != eNormal) {

AcquireSRWLockExclusive(&m_Handle);

EnterCriticalSection(&m_Handle);

(WaitForSingleObject(m_Handle, INFINITE) != WAIT_OBJECT_0) {

( pthread_mutex_lock(&m_Handle) != 0 ) {

SSystemFastMutex::TryLock(

)

TryAcquireSRWLockExclusive(&m_Handle) != 0;

TryEnterCriticalSection(&m_Handle) != 0;

status = WaitForSingleObject(m_Handle, 0);

(status == WAIT_OBJECT_0) {

(status != WAIT_TIMEOUT) {

ThrowTryLockFailed();

status = pthread_mutex_trylock(&m_Handle);

(status != EBUSY) {

ThrowTryLockFailed();

(lock != eNormal) {

ReleaseSRWLockExclusive(&m_Handle);

LeaveCriticalSection(&m_Handle);

( !ReleaseMutex(m_Handle) ) {

( pthread_mutex_unlock(&m_Handle) != 0 ) {

m_Mutex.CheckInitialized();

= m_Count.load(memory_order_acquire);

(

> 0 && m_Owner.load(memory_order_relaxed) == owner ) {

m_Count.store(++

, memory_order_release);

m_Owner.store(owner, memory_order_relaxed);

m_Count.store(1, memory_order_release);

SSystemMutex::TryLock(

)

m_Mutex.CheckInitialized();

= m_Count.load(memory_order_acquire);

(

> 0 && m_Owner.load(memory_order_relaxed) == owner ) {

m_Count.store(++

, memory_order_release);

( m_Mutex.TryLock() ) {

(m_Count.load(memory_order_relaxed) == 0);

m_Owner.store(owner, memory_order_relaxed);

m_Count.store(1, memory_order_release);

m_Mutex.CheckInitialized();

= m_Count.load(memory_order_acquire);

(

== 0 || m_Owner.load(memory_order_relaxed) != owner ) {

m_Count.store(--

, memory_order_release);

m_Mutex.Unlock(lock);

SSystemMutex::ThrowNotOwned(

)

);

* kInitMutexName =

;

init_mutex = CreateMutex(

,

, kInitMutexName);

(!s_InitMutexHandle || s_InitMutexHandle == init_mutex);

s_InitMutexHandle = init_mutex;

(mutex == s_InitMutexHandle);

s_GetInitMutexHandle(

)

s_ReleaseInitMutexHandle(

mutex)

CAutoInitializeStaticFastMutex::Initialize(

)

( m_Mutex.IsInitialized() ) {

init_mutex = s_GetInitMutexHandle();

WaitForSingleObject(init_mutex, INFINITE) == WAIT_OBJECT_0);

( !m_Mutex.IsInitialized() ) {

m_Mutex.InitializeStatic();

(m_Mutex.IsInitialized());

s_ReleaseInitMutexHandle(init_mutex);

CAutoInitializeStaticMutex::Initialize(

)

( m_Mutex.IsInitialized() ) {

init_mutex = s_GetInitMutexHandle();

WaitForSingleObject(init_mutex, INFINITE) == WAIT_OBJECT_0);

( !m_Mutex.IsInitialized() ) {

m_Mutex.InitializeStatic();

(m_Mutex.IsInitialized());

s_ReleaseInitMutexHandle(init_mutex);

:

;

:

;

:

;

CWindowsHandle(

h =

) : m_Handle(h) {}

CWindowsHandle(

h,

* errorMessage) : m_Handle(h)

~CWindowsHandle(

) { Close(); }

( m_Handle !=

) {

CloseHandle(m_Handle);

Set(

h,

* errorMessage)

GetHandle(

)

{

m_Handle; }

(

)

{

m_Handle; }

CWindowsHandle(

CWindowsHandle& h);

CWindowsHandle& operator=(

CWindowsHandle& h);

CWindowsSemaphore :

CWindowsHandle

CWindowsSemaphore(LONG initialCount = 0, LONG maximumCount = INFINITE)

: CWindowsHandle(CreateSemaphore(

,

initialCount, maximumCount,

)

LONG Release(LONG add = 1)

);

pthread_cond_t*(void) {

&

; }

pthread_cond_t&(void) {

; }

CWindowsSemaphore m_Rsema;

CWindowsSemaphore m_Rsema2;

CWindowsSemaphore m_Wsema;

: m_Rsema(1, 1), m_Rsema2(1, 1), m_Wsema(1, 1)

: m_Owner(0), m_Count(0), m_WaitingWriters(0), m_TrackReaders(

)

m_TrackReaders =

;

m_FavorWriters = (

& fFavorWriters) != 0;

m_TrackReaders = m_FavorWriters = (

& fFavorWriters) != 0;

(m_TrackReaders) {

m_Readers.reserve(16);

vector<TThreadSystemID>::const_iterator

CRWLock::x_TryWriteLock()

CRWLock::x_TryReadLock()

CWin32MutexHandleGuard

CWin32MutexHandleGuard(

mutex);

~CWin32MutexHandleGuard(

);

CWin32MutexHandleGuard::CWin32MutexHandleGuard(

mutex)

WaitForSingleObject(m_Handle, INFINITE);

CWin32MutexHandleGuard::~CWin32MutexHandleGuard(

)

ReleaseMutex(m_Handle);

(

old_val = *

; ; old_val = *

) {

cur_val = InterlockedCompareExchange(

, new_val, old_val);

(cur_val == old_val) {

(

old_val = *

; old_val >

; old_val = *

) {

new_val = old_val + 1;

cur_val = InterlockedCompareExchange(

, new_val, old_val);

(cur_val == old_val) {

(

old_val = *

; old_val <

; old_val = *

) {

new_val = old_val + 1;

cur_val = InterlockedCompareExchange(

, new_val, old_val);

(cur_val == old_val) {

(

old_val = *

; old_val <

; old_val = *

) {

new_val = old_val - 1;

cur_val = InterlockedCompareExchange(

, new_val, old_val);

(cur_val == old_val) {

(

old_val = *

; old_val >

; old_val = *

) {

new_val = old_val - 1;

cur_val = InterlockedCompareExchange(

, new_val, old_val);

(cur_val == old_val) {

(!m_TrackReaders && x_TryReadLock()) {

unique_lock<mutex> lck( m_Mtx);

}

(!x_TryReadLock());

(m_TrackReaders) {

CWin32MutexHandleGuard guard(

->m_Mutex);

obj[0] =

->m_Mutex.GetHandle();

obj[1] =

->m_Rsema;

obj[2] =

->m_Rsema2;

ReleaseMutex(

->m_Mutex.GetHandle()),

);

WaitForMultipleObjects(3, obj,

, INFINITE)-WAIT_OBJECT_0;

);

&&

->m_Rsema2.Release() == 0,

);

);

pthread_cond_wait(

->m_Rcond,

->m_Mutex.GetHandle()), 0,

);

);

);

);

(!m_TrackReaders && x_TryReadLock()) {

unique_lock<mutex> lck( m_Mtx);

(!x_TryReadLock()) {

(m_TrackReaders) {

CWin32MutexHandleGuard guard(

->m_Mutex);

);

( timeout.

() ) {

(!m_TrackReaders && x_TryReadLock()) {

sec=0, nanosec=0;

timeout.

(&sec, &nanosec);

chrono::time_point<chrono::steady_clock> to = chrono::steady_clock::now() + chrono::seconds(sec) + chrono::nanoseconds(nanosec);

cv_status res = cv_status::no_timeout;

unique_lock<mutex> lck( m_Mtx);

(res == cv_status::timeout) {

res = m_Cv.wait_until(lck, to);

}

(!x_TryReadLock());

(m_TrackReaders) {

CWin32MutexHandleGuard guard(

->m_Mutex);

obj[0] =

->m_Mutex.GetHandle();

obj[1] =

->m_Rsema;

obj[2] =

->m_Rsema2;

ReleaseMutex(

->m_Mutex.GetHandle()),

);

WaitForMultipleObjects(3, obj,

, timeout_msec);

(wait_res == WAIT_TIMEOUT) {

wait_res -= WAIT_OBJECT_0;

);

&&

->m_Rsema2.Release() == 0,

);

0) == WAIT_OBJECT_0,

);

res = pthread_cond_timedwait(

->m_Rcond,

->m_Mutex.GetHandle(), &ts);

(res == ETIMEDOUT) {

);

);

);

);

(x_TryWriteLock()) {

unique_lock<mutex> lck( m_Mtx);

(!m_TrackReaders || !x_HasReader(self_id));

(m_FavorWriters) {

(!x_TryWriteLock()) {

(m_FavorWriters) {

CWin32MutexHandleGuard guard(

->m_Mutex);

);

obj[0] =

->m_Rsema;

obj[1] =

->m_Wsema;

obj[2] =

->m_Mutex.GetHandle();

WaitForMultipleObjects(2, obj,

, 0)-WAIT_OBJECT_0;

);

);

ReleaseMutex(

->m_Mutex.GetHandle()),

);

WaitForMultipleObjects(3, obj,

, INFINITE)-WAIT_OBJECT_0;

);

);

pthread_cond_wait(

->m_Wcond,

->m_Mutex.GetHandle()), 0,

);

);

(!x_TryWriteLock()) {

CWin32MutexHandleGuard guard(

->m_Mutex);

obj[0] =

->m_Rsema;

obj[1] =

->m_Wsema;

WaitForMultipleObjects(2, obj,

, 0) - WAIT_OBJECT_0;

);

( timeout.

() ) {

(x_TryWriteLock()) {

sec=0, nanosec=0;

timeout.

(&sec, &nanosec);

chrono::time_point<chrono::steady_clock> to = chrono::steady_clock::now() + chrono::seconds(sec) + chrono::nanoseconds(nanosec);

cv_status res = cv_status::no_timeout;

unique_lock<mutex> lck( m_Mtx);

(res == cv_status::timeout) {

(m_FavorWriters) {

(!(

=

== 0) && res == cv_status::no_timeout) {

res = m_Cv.wait_until(lck, to);

(m_FavorWriters) {

}

(!x_TryWriteLock());

CWin32MutexHandleGuard guard(

->m_Mutex);

);

obj[0] =

->m_Rsema;

obj[1] =

->m_Wsema;

obj[2] =

->m_Mutex.GetHandle();

WaitForMultipleObjects(2, obj,

, 0)-WAIT_OBJECT_0;

);

);

ReleaseMutex(

->m_Mutex.GetHandle()),

);

WaitForMultipleObjects(3, obj,

, timeout_msec);

(wait_res == WAIT_TIMEOUT) {

CWin32MutexHandleGuard counter_guard(

->m_Mutex);

);

wait_res -= WAIT_OBJECT_0;

);

);

(

!= 0 && res != ETIMEDOUT ) {

res = pthread_cond_timedwait(

->m_Wcond,

->m_Mutex.GetHandle(), &ts);

(res == ETIMEDOUT) {

);

);

unique_lock<mutex> lck( m_Mtx

);

(m_TrackReaders) {

.erase( x_FindReader(self_id) );

}

(

!= 0) {

CWin32MutexHandleGuard guard(

->m_Mutex);

);

);

);

pthread_cond_broadcast(

->m_Rcond), 0,

);

pthread_cond_signal(

->m_Wcond), 0,

);

);

);

pthread_cond_signal(

->m_Wcond), 0,

);

vector<TThreadSystemID>::iterator found =

;

: m_Max(max_count), m_Count(init_count)

max_count =

(max_count, (

)LONG_MAX);

);

);

unique_ptr<SSemaphore> auto_sem(

);

(pthread_mutex_init(&

->

, 0) != 0) {

);

(pthread_cond_init(&

->

, 0) != 0) {

pthread_cond_init(&

->

, 0), 0,

);

->sem = CreateSemaphore(

, init_count, max_count,

);

dwErr = GetLastError();

);

CSemaphore::x_TryAcquire(

)

unique_lock<mutex> lck(m_Mtx);

(!x_TryAcquire()) {

);

(status != 0 && status != EINTR) {

);

);

);

);

);

unique_lock<mutex> lck(m_Mtx);

x_TryAcquire();

(x_TryAcquire()) {

(timeout_sec == 0 && timeout_nsec == 0) {

x_TryAcquire();

chrono::time_point<chrono::steady_clock> to = chrono::steady_clock::now() + chrono::seconds(timeout_sec) + chrono::nanoseconds(timeout_nsec);

cv_status res = cv_status::no_timeout;

(!x_TryAcquire()) {

res = m_Cv.wait_until(lck, to);

(res == cv_status::timeout) {

);

retval =

;

(timeout_sec > 0 || timeout_nsec > 0) {

(timeout_sec >= 100 * 1000 * 1000) {

timeout_sec = 100 * 1000 * 1000;

kBillion = 1000 * 1000 * 1000;

timespec timeout = { 0, 0 };

timeout.tv_sec = now.tv_sec;

timeout.tv_nsec = now.tv_usec * 1000 + timeout_nsec;

((

)timeout.tv_nsec >= kBillion) {

timeout.tv_sec += timeout.tv_nsec / kBillion;

timeout.tv_nsec %= kBillion;

(timeout_sec > (

)(

- timeout.tv_sec)) {

timeout.tv_nsec = kBillion - 1;

timeout.tv_sec += timeout_sec;

(status == ETIMEDOUT) {

}

(status != 0 && status != EINTR) {

);

);

);

(timeout_sec >= kMax_ULong / 1000) {

timeout_msec = kMax_ULong;

timeout_msec = timeout_sec * 1000 + timeout_nsec / (1000 * 1000);

res = WaitForSingleObject(

->sem, timeout_msec);

);

(res == WAIT_OBJECT_0);

unique_lock<mutex> lck( m_Mtx);

);

);

);

);

err_code = pthread_cond_broadcast(&

->

);

(

n_sig = 0; n_sig <

; n_sig++) {

err_code = pthread_cond_signal(&

->

);

(err_code != 0) {

err_code = pthread_cond_broadcast(&

->

);

(err_code == 0) {

);

);

);

);

);

AcquireSRWLockShared(&m_Lock);

ReleaseSRWLockShared(&m_Lock);

AcquireSRWLockExclusive(&m_Lock);

ReleaseSRWLockExclusive(&m_Lock);

lstn->OnLockAcquired(

);

lstn->OnLockReleased(

);

holder->

(lock, typ);

: m_Factory(factory)

<<

);

<<

);

other_type = 1 - lock_type;

holder->m_LockAcquired =

;

holder->x_OnLockAcquired();

(save_acquired) {

first_next->m_LockAcquired =

;

(next_hldr->m_Type != next_type)

next_hldr->m_LockAcquired =

;

next_holders.push_back(next_hldr);

THoldersList::iterator it

(save_acquired) {

first_next->x_OnLockAcquired();

(*it)->x_OnLockAcquired();

InitializeConditionVariable(&m_ConditionVar);

res = pthread_cond_init(&m_ConditionVar,

);

);

);

);

);

);

);

);

);

(

);

);

(SSystemFastMutex& mutex,

& deadline)

res = SleepConditionVariableSRW(&

, &mutex.m_Handle, timeout_msec, 0);

res = SleepConditionVariableCS(&

, &mutex.m_Handle, timeout_msec);

err_code = GetLastError();

(err_code == ERROR_TIMEOUT || err_code == WAIT_TIMEOUT)

);

res = pthread_cond_timedwait(&

, &mutex.m_Handle, &ts);

);

);

);

SSystemMutex& sys_mtx = mutex;

(sys_mtx.m_Count != 1) {

);

);

sys_mtx.Unlock(SSystemFastMutex::ePseudo);

sys_mtx.Lock(SSystemFastMutex::ePseudo);

SSystemFastMutex& sys_mtx = mutex;

sys_mtx.

(SSystemFastMutex::ePseudo);

sys_mtx.Lock(SSystemFastMutex::ePseudo);

);

);

);

);

CConditionVariableException –.

Object factory for simple creation and deletion of the object with one parameter passed to object's c...

~CQuickAndDirtySamePointerGuard()

bool DetectedDifferentPointers(void)

volatile TPointer & m_GuardedPtr

CAtomicCounter & m_AtomicCounter

CQuickAndDirtySamePointerGuard(CAtomicCounter &atomic_counter, TPointer volatile &guarded_ptr, TPointer new_ptr)

Default implementation of IRWLockHolder_Factory.

THolderPool m_Pool

Implementation of CRWLockHolder objects pool.

CObjFactory_NewParam< CRWLockHolder, CRWLockHolder_Pool * > THolderPoolFactory

virtual ~CRWLockHolder_Pool(void)

CObjPool< CRWLockHolder, THolderPoolFactory > THolderPool

virtual void DeleteHolder(CRWLockHolder *holder)

Free unnecessary (and unreferenced by anybody) CRWLockHolder object.

virtual CRWLockHolder * CreateHolder(CYieldingRWLock *lock, ERWLockType typ)

Obtain new CRWLockHolder object for given CYieldingRWLock and necessary lock type.

Holder of the lock inside CYieldingRWLock.

CTimeout – Timeout interval.

Read/write lock without blocking calls.

Interface for factory creating CRWLockHolder objects.

static const char * expected[]

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

TValue Add(int delta) THROWS_NONE

Atomically add value (=delta), and return new counter value.

TValue Get(void) const THROWS_NONE

Get atomic counter value.

#define NCBI_TROUBLE(mess)

#define ERR_POST_X(err_subcode, message)

Error posting with default error code and given error subcode.

#define ERR_POST(message)

Error posting with file, line number information but without error codes.

void Critical(CExceptionArgs_Base &args)

void Error(CExceptionArgs_Base &args)

#define NCBI_THROW(exception_class, err_code, message)

Generic macro to throw an exception, given the exception class, error code and message string.

TErrCode GetErrCode(void) const

virtual const char * GetErrCodeString(void) const

Get error code interpreted as text.

static mode_t MakeModeT(TMode user_mode, TMode group_mode, TMode other_mode, TSpecialModeBits special)

Construct mode_t value from permission modes.

@ fWrite

Write permission.

bool NotNull(void) const THROWS_NONE

Check if pointer is not null – same effect as NotEmpty().

bool Referenced(void) const THROWS_NONE

Check if object is referenced.

void Return(TObjType *obj)

Return object to the pool for future use.

TObjType * Get(void)

Get object from the pool, create if necessary.

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

#define NCBI_SCHED_YIELD()

volatile unsigned int m_WaitingWriters

Number of writers waiting; zero if not keeping track.

ERWLockType

Type of locking provided by CYieldingRWLock.

ELockSemantics

This is for condition variables.

unique_ptr< CInternalRWLock > m_RW

Platform-dependent RW-lock data.

struct SSemaphore * m_Sem

System-specific semaphore data.

bool TryLock(void)

Attempt to lock the mutex and return TRUE if it succeeded or FALSE if mutex is locked by other thread...

CSemaphore(unsigned int init_count, unsigned int max_count)

Constructor.

void Lock(void)

Acquire mutex for the current thread with no nesting checks.

virtual const char * GetErrCodeString(void) const override

Translate from the error code value to its string representation.

void ReadUnlock(void)

Release read lock.

virtual ~CRWLockHolder(void)

~CConditionVariable(void)

void SignalSome(void)

Wake at least one of the threads that are currently waiting on this condition variable (if any thread...

ERWLockType m_Type

Type of lock held.

static bool IsSupported(void)

void Wait(void)

Wait on semaphore.

CFastMutex m_WriteLock

Mutex implementing write lock.

void ReadLock(void)

Read lock.

bool TryReadLock(void)

Try read lock.

void Reset(void)

Reset holder to be able to use it later (after calling Init() )

CSpinLock m_ObjLock

Main locking mutex for object operations.

TFlags m_Flags

Configuration flags.

void WriteUnlock(void)

Release write lock.

TRWLockHolderRef AcquireLock(ERWLockType lock_type)

General method to request read or write lock.

THoldersList m_LockWaits

Queue for waiting lock requests.

virtual CRWLockHolder * CreateHolder(CYieldingRWLock *lock, ERWLockType typ)=0

Obtain new CRWLockHolder object for given CYieldingRWLock and necessary lock type.

vector< TThreadSystemID > m_Readers

List of all readers or writers.

volatile long m_Count

Number of readers (if >0) or writers (if <0)

SSystemFastMutex *volatile m_WaitMutex

IRWLockHolder_Factory * m_Factory

Factory created the holder.

bool TryWriteLock(void)

Try write lock.

bool x_MayAcquireForReading(TThreadSystemID self_id)

bool x_WaitForSignal(SSystemFastMutex &mutex, const CDeadline &timeout)

virtual void DeleteThis(void)

"Delete" this holder after last reference was removed.

TListenersList m_Listeners

List of holder listeners.

IRWLockHolder_Factory * m_Factory

Factory creating CRWLockHolder objects.

void x_OnLockReleased(void)

Callback called at the moment when lock is released.

bool WaitForSignal(CMutex &mutex, const CDeadline &deadline=CDeadline::eInfinite)

Release mutex and lock the calling thread until the condition variable is signalled.

void SignalAll(void)

Wake all threads that are currently waiting on the condition variable.

pthread_mutex_t TSystemMutex

Define a platform independent system mutex.

CAtomicCounter_WithAutoInit m_WaitCounter

CRWLock(TFlags flags=0)

Constructor.

volatile TThreadSystemID m_Owner

Writer ID, one of the readers ID.

void Init(CYieldingRWLock *lock, ERWLockType typ)

Initialize holder for given CYieldingRWLock and necessary lock type.

void Unlock(void)

Unlock the mutex.

void ReadLock(void)

Acquire read lock.

void ReleaseLock(void)

Release the lock held or cancel request for the lock.

virtual void DeleteHolder(CRWLockHolder *holder)=0

Free unnecessary (and unreferenced by anybody) CRWLockHolder object.

CAtomicCounter m_LockCount

Number of read locks acquired or value of kWriteLockValue if write lock was acquired.

void x_ReleaseLock(CRWLockHolder *holder)

Main implementation releasing lock.

deque< TRWLockHolderRef > THoldersList

void Lock(void)

Lock the mutex.

list< TRWLockHolder_ListenerWeakRef > TListenersList

void x_OnLockAcquired(void)

Callback called at the moment when lock is granted.

void WriteLock(void)

Write lock.

int m_Locks[2]

Number of locks granted on this object by type.

CYieldingRWLock * m_Lock

Lock object the holder is assigned to.

void WriteLock(void)

Acquire write lock.

CONDITION_VARIABLE m_ConditionVar

pthread_t TThreadSystemID

Define platform-dependent thread ID type.

~CYieldingRWLock(void)

It is fatal error to destroy the object while some locks are pending.

bool TryWait(unsigned int timeout_sec=0, unsigned int timeout_nsec=0)

Timed wait.

virtual ~IRWLockHolder_Factory(void)

~CSemaphore(void)

Destructor.

void Post(unsigned int count=1)

Increment the semaphore by "count".

CSpinLock m_ObjLock

Mutex for operating listeners.

int TFlags

binary OR of EFlags

CYieldingRWLock(IRWLockHolder_Factory *factory=NULL)

Create read/write lock with custom holders factory.

~CRWLock(void)

Destructor.

virtual const char * GetErrCodeString(void) const override

Translate from the error code value to its string representation.

void *volatile m_Value

Flag showing if mutex is locked (non-NULL value) or unlocked (NULL value).

void Unlock(void)

Release mutex with no owner or nesting checks.

bool m_LockAcquired

Flag if lock was acquired.

static TThreadSystemID GetCurrentThreadSystemID(void)

Get the current thread ID.

void Unlock(void)

Release the RW-lock.

virtual ~IRWLockHolder_Listener(void)

@ fFavorWriters

Forbid further readers from acquiring the lock if any writers are waiting for it, to keep would-be wr...

@ eMutexLockCount

Mutex passed to WaitForSignal is not owned by the current thread.

@ eMutexOwner

Different mutexes were supplied for concurrent WaitForSignal operations on this condition variable.

@ eMutexDifferent

Condition variable is not supported on this platform.

@ eInvalidValue

Parameter of WaitForSignal function is invalid.

@ fTrackReaders

Keep track of which threads have read locks.

@ kWriteLockValue

Number in lock count showing that write lock is acquired.

@ eUninitialized

Uninitialized error.

@ eTryLock

Attempted lock error.

@ eOwner

Not owned error.

CNanoTimeout GetRemainingTime(void) const

Get time left to the expiration.

void GetNano(unsigned int *sec, unsigned int *nanosec) const

Get timeout in seconds and nanoseconds.

unsigned long GetAsMilliSeconds(void) const

Get as number of milliseconds.

bool IsInfinite(void) const

Check if the deadline is infinite.

void GetExpirationTime(time_t *sec, unsigned int *nanosec) const

Get the number of seconds and nanoseconds (since 1/1/1970).

#define HANDLE

An abstraction for a file handle.

Definition of all error codes used in corelib (xncbi.lib).

int gettimeofday(struct timeval *tp, void *unused)

#define TRUE

bool replacment for C indicating true.

#define FALSE

bool replacment for C indicating false.

void * SwapPointers(void *volatile *location, void *new_value)

#define xncbi_ValidateAndErrnoReport(expression, message)

#define xncbi_VerifyAndErrorReport(expression)

#define xncbi_ValidatePthread(expression, expected_value, message)

#define xncbi_Validate(expression, message)

Defines classes: CDirEntry, CFile, CDir, CSymLink, CMemoryFile, CFileUtil, CFileLock,...

void interlocked_set(volatile long *val, long new_val)

#define WRITE_MUTEX_EVENT(mutex, message)

bool interlocked_dec_min(volatile long *val, long min)

bool interlocked_dec_max(volatile long *val, long max)

void s_ThrowIfDifferentMutexes(CQuickAndDirtySamePointerGuard< SSystemFastMutex > &mutex_guard)

#define NCBI_THREADS_ARG(arg)

bool interlocked_inc_max(volatile long *val, long max)

bool interlocked_inc_min(volatile long *val, long min)

static CSafeStatic< CRWLockHolder_Pool > s_RWHolderPool

Default CRWLockHolder pool used in CYieldingRWLock.

Multi-threading – mutexes; rw-locks; semaphore.

atomic< unsigned int > count

atomic< unsigned int > wait_count

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4