mutex.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_SYSTEM_MUTEX_H
#define BALL_SYSTEM_MUTEX_H

#ifndef BALL_COMMON_GLOBAL_H
# include <BALL/COMMON/global.h>
#endif

#include <QtCore/QMutex>
#include <QtCore/QReadWriteLock>
#include <QtCore/QMutexLocker>
#include <QtCore/QReadLocker>
#include <QtCore/QWriteLocker>

#ifdef BALL_HAS_BOOST_THREAD
# include <boost/version.hpp>
# if BOOST_VERSION >= 103500
# include <boost/thread/mutex.hpp>
# define BALL_HAS_BOOST_MUTEX
# endif
#endif

#undef BALL_USE_THREAD_CHECKER_API
#ifdef BALL_USE_THREAD_CHECKER_API
# include <libittnotify.h>
#endif

#define BALL_DEFAULT_MUTEX_TYPE QMutex
#define BALL_DEFAULT_MUTEXLOCKER_TYPE QMutexLocker
#define BALL_DEFAULT_READWRITELOCK_TYPE QReadWriteLock
#define BALL_DEFAULT_READLOCKER_TYPE QReadLocker
#define BALL_DEFAULT_WRITELOCKER_TYPE QWriteLocker

namespace BALL
{
  template <class MutexType>
  class TMutex
    : public MutexType
  {
    public:
      TMutex(bool is_recursive = false)
        : MutexType()
      {}
  };

  template <>
  class TMutex<QMutex>
    : public QMutex
  {
    public:
      TMutex(bool is_recursive = false)
        : QMutex( is_recursive ? Recursive : NonRecursive )
      {
      }
  };

  template <class MutexLockerType, class MutexType>
  class TMutexLocker
    : public MutexLockerType
  {
    public:
      TMutexLocker(MutexType* mutex)
        : MutexLockerType(mutex)
      {}
  };

  template <class ReadWriteLockType>
  class TReadWriteLock
    : public ReadWriteLockType
  {
    public:
      TReadWriteLock(bool is_recursive = false)
        : ReadWriteLockType()
      {}
  };

  template <>
  class TReadWriteLock<QReadWriteLock>
    : public QReadWriteLock
  {
    public:
      TReadWriteLock(bool is_recursive = false)
// NOTE: Qt only supports non-recursive read write locks since version 4.4. Before that, they were always recursive.
#if (QT_VERSION >= QT_VERSION_CHECK(4, 4, 0))
        : QReadWriteLock( is_recursive ? Recursive : NonRecursive )
#else
        : QReadWriteLock()
#endif
      {
      }
  };

  template <class ReadLockerType, class ReadWriteLockType>
  class TReadLocker
    : public ReadLockerType
  {
    public:
      TReadLocker(ReadWriteLockType* lock)
        : ReadLockerType(lock)
      {}
  };

  template <class WriteLockerType, class ReadWriteLockType>
  class TWriteLocker
    : public WriteLockerType
  {
    public:
      TWriteLocker(ReadWriteLockType* lock)
        : WriteLockerType(lock)
      {}
  };



#ifdef BALL_HAS_BOOST_MUTEX
  // Boost-based mutexes only require a mapping of tryLock to try_lock.
  template <>
  class TMutex<boost::mutex>
    : public boost::mutex
  {
    public:
      TMutex()
        : boost::mutex()
      {}

      void lock()
      {
        return boost::mutex::lock();
      }

      bool tryLock()
      {
        return try_lock();
      }
  };

#endif


#ifdef BALL_USE_THREAD_CHECKER_API
  template <>
  class TMutex<QMutex>
    : public QMutex
  {
    public:
      TMutex()
        : QMutex()
      {
      }

      void lock()
      {
        __itt_notify_sync_prepare((void *)this);
        QMutex::lock();
        __itt_notify_sync_acquired((void*)this);
      }

      void unlock()
      {
        __itt_notify_sync_releasing((void *)this);
        QMutex::unlock();
      }

      bool tryLock()
      {
        __itt_notify_sync_prepare((void*)this);
        bool result = QMutex::tryLock();

        if (result)
          __itt_notify_sync_acquired((void*)this);
        else
          __itt_notify_sync_cancel((void*)this);

        return result;
      }
  };

  // TODO: similar instantiation for TReadWriteLock

#else
// required for visual studio
#ifdef BALL_COMPILER_MSVC
  //template class BALL_EXPORT TMutex<BALL_DEFAULT_MUTEX_TYPE>;
  //template class BALL_EXPORT TReadWriteLock<BALL_DEFAULT_READWRITELOCK_TYPE>;
  template class BALL_EXPORT TMutexLocker<BALL_DEFAULT_MUTEXLOCKER_TYPE, BALL_DEFAULT_MUTEX_TYPE>;
  template class BALL_EXPORT TReadLocker<BALL_DEFAULT_READLOCKER_TYPE, BALL_DEFAULT_READWRITELOCK_TYPE>;
  template class BALL_EXPORT TWriteLocker<BALL_DEFAULT_WRITELOCKER_TYPE, BALL_DEFAULT_READWRITELOCK_TYPE>;
#endif
#endif

  // the standard mutex to use
  typedef TMutex<BALL_DEFAULT_MUTEX_TYPE> Mutex;
  typedef TReadWriteLock<BALL_DEFAULT_READWRITELOCK_TYPE> ReadWriteLock;
  typedef TMutexLocker<BALL_DEFAULT_MUTEXLOCKER_TYPE, BALL_DEFAULT_MUTEX_TYPE> MutexLocker;
  typedef TReadLocker<BALL_DEFAULT_READLOCKER_TYPE, BALL_DEFAULT_READWRITELOCK_TYPE> ReadLocker;
  typedef TWriteLocker<BALL_DEFAULT_WRITELOCKER_TYPE, BALL_DEFAULT_READWRITELOCK_TYPE> WriteLocker;
}

#endif // BALL_SYSTEM_MUTEX_H