panda3d/panda/src/pipeline/reMutexDirect.I

/**
 * PANDA 3D SOFTWARE
 * Copyright (c) Carnegie Mellon University.  All rights reserved.
 *
 * All use of this software is subject to the terms of the revised BSD
 * license.  You should have received a copy of this license along
 * with this source code in a file named "LICENSE."
 *
 * @file reMutexDirect.I
 * @author drose
 * @date 2006-02-13
 */

/**
 *
 */
INLINE ReMutexDirect::
ReMutexDirect()
#ifndef HAVE_REMUTEXTRUEIMPL
  : _cvar_impl(_lock_impl)
#endif
{
#ifndef HAVE_REMUTEXTRUEIMPL
  _locking_thread = nullptr;
  _lock_count = 0;
#endif
}

/**
 * Alias for acquire() to match C++11 semantics.
 * @see acquire()
 */
INLINE void ReMutexDirect::
lock() {
  TAU_PROFILE("void ReMutexDirect::acquire()", " ", TAU_USER);
#ifdef HAVE_REMUTEXTRUEIMPL
  _impl.lock();
#else
  ((ReMutexDirect *)this)->do_lock();
#endif  // HAVE_REMUTEXTRUEIMPL
}

/**
 * Alias for try_acquire() to match C++11 semantics.
 * @see try_acquire()
 */
INLINE bool ReMutexDirect::
try_lock() {
  TAU_PROFILE("void ReMutexDirect::try_acquire()", " ", TAU_USER);
#ifdef HAVE_REMUTEXTRUEIMPL
  return _impl.try_lock();
#else
  return ((ReMutexDirect *)this)->do_try_lock();
#endif  // HAVE_REMUTEXTRUEIMPL
}

/**
 * Alias for release() to match C++11 semantics.
 * @see release()
 */
INLINE void ReMutexDirect::
unlock() {
  TAU_PROFILE("void ReMutexDirect::unlock()", " ", TAU_USER);
#ifdef HAVE_REMUTEXTRUEIMPL
  _impl.unlock();
#else
  ((ReMutexDirect *)this)->do_unlock();
#endif  // HAVE_REMUTEXTRUEIMPL
}

/**
 * Grabs the reMutex if it is available.  If it is not available, blocks until
 * it becomes available, then grabs it.  In either case, the function does not
 * return until the reMutex is held; you should then call unlock().
 *
 * This method is considered const so that you can lock and unlock const
 * reMutexes, mainly to allow thread-safe access to otherwise const data.
 *
 * Also see ReMutexHolder.
 */
INLINE void ReMutexDirect::
acquire() const {
  TAU_PROFILE("void ReMutexDirect::acquire()", " ", TAU_USER);
#ifdef HAVE_REMUTEXTRUEIMPL
  _impl.lock();
#else
  ((ReMutexDirect *)this)->do_lock();
#endif  // HAVE_REMUTEXTRUEIMPL
}

/**
 * This variant on acquire() accepts the current thread as a parameter, if it
 * is already known, as an optimization.
 */
INLINE void ReMutexDirect::
acquire(Thread *current_thread) const {
  TAU_PROFILE("void ReMutexDirect::acquire(Thread *)", " ", TAU_USER);
#ifdef HAVE_REMUTEXTRUEIMPL
  _impl.lock();
#else
  ((ReMutexDirect *)this)->do_lock(current_thread);
#endif  // HAVE_REMUTEXTRUEIMPL
}

/**
 * Returns immediately, with a true value indicating the mutex has been
 * acquired, and false indicating it has not.
 *
 * @deprecated Python users should use acquire(False), C++ users try_lock()
 */
INLINE bool ReMutexDirect::
try_acquire() const {
  TAU_PROFILE("void ReMutexDirect::acquire(bool)", " ", TAU_USER);
#ifdef HAVE_REMUTEXTRUEIMPL
  return _impl.try_lock();
#else
  return ((ReMutexDirect *)this)->do_try_lock();
#endif  // HAVE_REMUTEXTRUEIMPL
}

/**
 * Returns immediately, with a true value indicating the mutex has been
 * acquired, and false indicating it has not.
 *
 * @deprecated Python users should use acquire(False), C++ users try_lock()
 */
INLINE bool ReMutexDirect::
try_acquire(Thread *current_thread) const {
  TAU_PROFILE("void ReMutexDirect::acquire(bool)", " ", TAU_USER);
#ifdef HAVE_REMUTEXTRUEIMPL
  return _impl.try_lock();
#else
  return ((ReMutexDirect *)this)->do_try_lock(current_thread);
#endif  // HAVE_REMUTEXTRUEIMPL
}

/**
 * This method increments the lock count, assuming the calling thread already
 * holds the lock.  After this call, release() will need to be called one
 * additional time to release the lock.
 *
 * This method really performs the same function as acquire(), but it offers a
 * potential (slight) performance benefit when the calling thread knows that
 * it already holds the lock.  It is an error to call this when the calling
 * thread does not hold the lock.
 */
INLINE void ReMutexDirect::
elevate_lock() const {
  TAU_PROFILE("void ReMutexDirect::elevate_lock()", " ", TAU_USER);
#ifdef HAVE_REMUTEXTRUEIMPL
  _impl.lock();
#else
  ((ReMutexDirect *)this)->do_elevate_lock();
#endif  // HAVE_REMUTEXTRUEIMPL
}

/**
 * Releases the reMutex.  It is an error to call this if the reMutex was not
 * already locked.
 *
 * This method is considered const so that you can lock and unlock const
 * reMutexes, mainly to allow thread-safe access to otherwise const data.
 */
INLINE void ReMutexDirect::
release() const {
  TAU_PROFILE("void ReMutexDirect::release()", " ", TAU_USER);
#ifdef HAVE_REMUTEXTRUEIMPL
  _impl.unlock();
#else
  ((ReMutexDirect *)this)->do_unlock();
#endif  // HAVE_REMUTEXTRUEIMPL
}

/**
 * Returns true if the current thread has locked the ReMutex, false otherwise.
 * This method is only intended for use in debugging, hence the method name;
 * in the ReMutexDirect case, it always returns true, since there's not a
 * reliable way to determine this otherwise.
 */
INLINE bool ReMutexDirect::
debug_is_locked() const {
  return true;
}

/**
 * The mutex name is only defined when compiling in DEBUG_THREADS mode.
 */
INLINE void ReMutexDirect::
set_name(const std::string &) {
}

/**
 * The mutex name is only defined when compiling in DEBUG_THREADS mode.
 */
INLINE void ReMutexDirect::
clear_name() {
}

/**
 * The mutex name is only defined when compiling in DEBUG_THREADS mode.
 */
INLINE bool ReMutexDirect::
has_name() const {
  return false;
}

/**
 * The mutex name is only defined when compiling in DEBUG_THREADS mode.
 */
INLINE std::string ReMutexDirect::
get_name() const {
  return std::string();
}

#ifndef HAVE_REMUTEXTRUEIMPL
/**
 * The private implementation of acquire(), for the case in which the
 * underlying lock system does not provide a reentrant mutex (and therefore we
 * have to build this functionality on top of the existing non-reentrant
 * mutex).
 */
INLINE void ReMutexDirect::
do_lock() {
  do_lock(Thread::get_current_thread());
}
#endif

#ifndef HAVE_REMUTEXTRUEIMPL
/**
 * The private implementation of acquire(false), for the case in which the
 * underlying lock system does not provide a reentrant mutex (and therefore we
 * have to build this functionality on top of the existing non-reentrant
 * mutex).
 */
INLINE bool ReMutexDirect::
do_try_lock() {
  return do_try_lock(Thread::get_current_thread());
}
#endif