tbb::recursive_mutex::scoped_lock Class Reference

The scoped locking pattern. More...

#include <recursive_mutex.h>

Inheritance diagram for tbb::recursive_mutex::scoped_lock:

Collaboration diagram for tbb::recursive_mutex::scoped_lock:

Public Member Functions
	scoped_lock ()
	Construct lock that has not acquired a recursive_mutex. More...
	scoped_lock (recursive_mutex &mutex)
	Acquire lock on given mutex. More...
	~scoped_lock ()
	Release lock (if lock is held). More...
void	acquire (recursive_mutex &mutex)
	Acquire lock on given mutex. More...
bool	try_acquire (recursive_mutex &mutex)
	Try acquire lock on given recursive_mutex. More...
void	release ()
	Release lock. More...

Private Member Functions
void __TBB_EXPORTED_METHOD	internal_acquire (recursive_mutex &m)
	All checks from acquire using mutex.state were moved here. More...
bool __TBB_EXPORTED_METHOD	internal_try_acquire (recursive_mutex &m)
	All checks from try_acquire using mutex.state were moved here. More...
void __TBB_EXPORTED_METHOD	internal_release ()
	All checks from release using mutex.state were moved here. More...
Private Member Functions inherited from tbb::internal::no_copy
	no_copy ()
	Allow default construction. More...

Private Attributes
recursive_mutex *	my_mutex
	The pointer to the current recursive_mutex to work. More...

Friends
class	recursive_mutex

Detailed Description

The scoped locking pattern.

It helps to avoid the common problem of forgetting to release lock. It also nicely provides the "node" for queuing locks.

Definition at line 83 of file recursive_mutex.h.

Constructor & Destructor Documentation

scoped_lock() [1/2]

tbb::recursive_mutex::scoped_lock::scoped_lock ( )

inline

Construct lock that has not acquired a recursive_mutex.

Definition at line 86 of file recursive_mutex.h.

Referenced by tbb::recursive_mutex::lock().

: my_mutex(NULL) {};

Here is the caller graph for this function:

scoped_lock() [2/2]

tbb::recursive_mutex::scoped_lock::scoped_lock ( recursive_mutex &  mutex )

inline

Acquire lock on given mutex.

Definition at line 89 of file recursive_mutex.h.

References acquire(), and my_mutex.

                                              {
#if TBB_USE_ASSERT
            my_mutex = &mutex;
#endif /* TBB_USE_ASSERT */
            acquire( mutex );
        }

Here is the call graph for this function:

~scoped_lock()

tbb::recursive_mutex::scoped_lock::~scoped_lock ( )

inline

Release lock (if lock is held).

Definition at line 97 of file recursive_mutex.h.

References my_mutex, and release().

                       {
            if( my_mutex )
                release();
        }

Here is the call graph for this function:

Member Function Documentation

acquire()

void tbb::recursive_mutex::scoped_lock::acquire ( recursive_mutex &  mutex )

inline

Acquire lock on given mutex.

Definition at line 103 of file recursive_mutex.h.

References internal_acquire(), tbb::recursive_mutex::lock(), and my_mutex.

Referenced by scoped_lock().

                                               {
#if TBB_USE_ASSERT
            internal_acquire( mutex );
#else
            my_mutex = &mutex;
            mutex.lock();
#endif /* TBB_USE_ASSERT */
        }

Here is the call graph for this function:

Here is the caller graph for this function:

internal_acquire()

void tbb::recursive_mutex::scoped_lock::internal_acquire ( recursive_mutex &  m )

private

All checks from acquire using mutex.state were moved here.

Definition at line 26 of file recursive_mutex.cpp.

References __TBB_ASSERT, tbb::internal::handle_perror(), tbb::recursive_mutex::impl, and my_mutex.

Referenced by acquire().

                                                                      {
#if _WIN32||_WIN64
    switch( m.state ) {
      case INITIALIZED:
        // since we cannot look into the internal of the CriticalSection object
        // we won't know how many times the lock has been acquired, and thus
        // we won't know when we may safely set the state back to INITIALIZED
        // if we change the state to HELD as in mutex.cpp.  thus, we won't change
        // the state for recursive_mutex
        EnterCriticalSection( &m.impl );
        break;
      case DESTROYED:
        __TBB_ASSERT(false,"recursive_mutex::scoped_lock: mutex already destroyed");
        break;
      default:
        __TBB_ASSERT(false,"recursive_mutex::scoped_lock: illegal mutex state");
        break;
    }
#else
    int error_code = pthread_mutex_lock(&m.impl);
    if( error_code )
        tbb::internal::handle_perror(error_code,"recursive_mutex::scoped_lock: pthread_mutex_lock failed");
#endif /* _WIN32||_WIN64 */
    my_mutex = &m;
}

Here is the call graph for this function:

Here is the caller graph for this function:

internal_release()

void tbb::recursive_mutex::scoped_lock::internal_release ( )

private

All checks from release using mutex.state were moved here.

Definition at line 52 of file recursive_mutex.cpp.

References __TBB_ASSERT, __TBB_ASSERT_EX, tbb::recursive_mutex::impl, and my_mutex.

Referenced by release(), and tbb::recursive_mutex::unlock().

                                                  {
    __TBB_ASSERT( my_mutex, "recursive_mutex::scoped_lock: not holding a mutex" );
#if _WIN32||_WIN64
    switch( my_mutex->state ) {
      case INITIALIZED:
        LeaveCriticalSection( &my_mutex->impl );
        break;
      case DESTROYED:
        __TBB_ASSERT(false,"recursive_mutex::scoped_lock: mutex already destroyed");
        break;
      default:
        __TBB_ASSERT(false,"recursive_mutex::scoped_lock: illegal mutex state");
        break;
    }
#else
     int error_code = pthread_mutex_unlock(&my_mutex->impl);
     __TBB_ASSERT_EX(!error_code, "recursive_mutex::scoped_lock: pthread_mutex_unlock failed");
#endif /* _WIN32||_WIN64 */
     my_mutex = NULL;
}

Here is the caller graph for this function:

internal_try_acquire()

bool tbb::recursive_mutex::scoped_lock::internal_try_acquire ( recursive_mutex &  m )

private

All checks from try_acquire using mutex.state were moved here.

Definition at line 73 of file recursive_mutex.cpp.

References __TBB_ASSERT, tbb::recursive_mutex::impl, and my_mutex.

Referenced by try_acquire().

                                                                          {
#if _WIN32||_WIN64
    switch( m.state ) {
      case INITIALIZED:
        break;
      case DESTROYED:
        __TBB_ASSERT(false,"recursive_mutex::scoped_lock: mutex already destroyed");
        break;
      default:
        __TBB_ASSERT(false,"recursive_mutex::scoped_lock: illegal mutex state");
        break;
    }
#endif /* _WIN32||_WIN64 */
    bool result;
#if _WIN32||_WIN64
    result = TryEnterCriticalSection(&m.impl)!=0;
#else
    result = pthread_mutex_trylock(&m.impl)==0;
#endif /* _WIN32||_WIN64 */
    if( result )
        my_mutex = &m;
    return result;
}

Here is the caller graph for this function:

release()

void tbb::recursive_mutex::scoped_lock::release ( )

inline

Release lock.

Definition at line 125 of file recursive_mutex.h.

References internal_release(), my_mutex, and tbb::recursive_mutex::unlock().

Referenced by ~scoped_lock().

                       {
#if TBB_USE_ASSERT
            internal_release();
#else
            my_mutex->unlock();
            my_mutex = NULL;
#endif /* TBB_USE_ASSERT */
        }

Here is the call graph for this function:

Here is the caller graph for this function:

try_acquire()

bool tbb::recursive_mutex::scoped_lock::try_acquire ( recursive_mutex &  mutex )

inline

Try acquire lock on given recursive_mutex.

Definition at line 113 of file recursive_mutex.h.

References internal_try_acquire(), my_mutex, and tbb::recursive_mutex::try_lock().

                                                   {
#if TBB_USE_ASSERT
            return internal_try_acquire( mutex );
#else
            bool result = mutex.try_lock();
            if( result )
                my_mutex = &mutex;
            return result;
#endif /* TBB_USE_ASSERT */
        }

Here is the call graph for this function:

Friends And Related Function Documentation

recursive_mutex

friend class recursive_mutex

friend

Definition at line 147 of file recursive_mutex.h.

Member Data Documentation

my_mutex

recursive_mutex* tbb::recursive_mutex::scoped_lock::my_mutex

private

The pointer to the current recursive_mutex to work.

Definition at line 136 of file recursive_mutex.h.

Referenced by acquire(), internal_acquire(), internal_release(), internal_try_acquire(), release(), scoped_lock(), try_acquire(), tbb::recursive_mutex::unlock(), and ~scoped_lock().

---

The documentation for this class was generated from the following files:

• recursive_mutex.h
• recursive_mutex.cpp