Lock.hh

//********************************************************************
//*** Thread/Lock.hh
//*** Copyright (c) 2003-2009 by Markus Winand <mws@fatalmind.com>
//*** $Id: Lock.hh,v 1.25 2009-03-02 14:16:46 mws Exp $
//********************************************************************
/*
This file is part of ResourcePool.

ResourcePool is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2 of 
the License, or (at your option) any later version.

ResourcePool is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with ResourcePool; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307  USA */

#ifndef INCLUDED_THREAD_LOCK_HH
#define INCLUDED_THREAD_LOCK_HH

#ifdef HAVE_CONFIG_H
#include "../config.h"
#endif

#ifndef INCLUDED_THREAD_LOCKFWD_HH
#include "LockFwd.hh"
#endif

#ifndef INCLUDED_CONDVARFWD_H
#include "CondVarFwd.hh"
#endif

#ifndef POSIX_TIMER_HH
#include "POSIX/timer.hh"
#endif

#ifndef INCLUDED_INT2TYPE_HH
#include "stdtools/Int2Type.hh"
#endif

#include <iosfwd>

// TODO: configure via configure ;)

#include "PosixMutex.hh"
#include "LinuxRecursivePosixMutexSpecialization.hh"

namespace fatalmind {

#ifdef HAVE_PTHREAD_MUTEXATTR_SETTYPE
#ifdef HAVE_PTHREAD_MUTEX_RECURSIVE_NP
#define HAVE_RECURSIVE_LOCK
template<class Statistics>
class RecursiveLock
: public PosixMutex<LinuxRecursivePosixMutexSpecialization, Statistics> {
};
#endif
#endif

#ifndef HAVE_RECURSIVE_LOCK
template <class Statistics = DefaultLockStatistics >
class RecursiveLock: public FastLock<Statistics> {
};
#endif

template<class Statistics>
class FastLock
: public PosixMutex<DefaultPosixMutexSpecialization, Statistics> {
};

template<class Statistics>
class NopLock {
    public:
        inline NopLock() {};
        inline void lock() {};
        inline void unlock() {};
        inline void singleThreaded();
};

template<class MutexType>
class NopCondVar: public MutexType {
    public:
        NopCondVar() {
        };
        inline void lock() {};
        inline void unlock() {};
        inline void wait() {};
        template<class TM>
        inline bool wait(const struct POSIX::timespec<TM>* timeout) {
            return false;
        }
        inline void signal() {};
        inline void broadcast() {};
};

template<class MutexType>
std::ostream& operator<<(std::ostream& os, const NopCondVar<MutexType>&) {
    return os;
}
template<class UsagePattern, class TimingPattern>
class LockStatistics: public UsagePattern, public TimingPattern {
};

class NopLockUsageStatistics {
    public:
        inline NopLockUsageStatistics() {};
        inline void stat_lock() {};
        inline void stat_unlock() {};
    friend 
        std::ostream& operator<<(std::ostream& o, const NopLockUsageStatistics& s);
};

class NopLockTimingStatistics {
    public:
        inline NopLockTimingStatistics() {};
        typedef nopTimer _timer_t;
        int _waittime;

    friend
        std::ostream& operator<<(std::ostream& o, const NopLockTimingStatistics& s);
};

} // namespace fatalmind


namespace fatalmind {

template<class Statistics>
struct MultiThreadedModel {
#ifdef HAVE_RECURSIVE_LOCK
    typedef PosixMutex<LinuxRecursivePosixMutexSpecialization, Statistics> RecursiveLock;
#endif
    typedef PosixMutex<DefaultPosixMutexSpecialization, Statistics> FastLock;
#ifdef HAVE_RECURSIVE_LOCK
    typedef CondVar<RecursiveLock> RecursiveCondVar;
#endif
    typedef CondVar<FastLock>      FastCondVar;
    static const bool isMultiThreaded = true;
    typedef Int2Type<true> Type;
};

template<class Statistics>
struct SingleThreadedModel {
    typedef NopLock<Statistics> RecursiveLock;
    typedef NopLock<Statistics> FastLock;
    typedef NopCondVar<RecursiveLock> RecursiveCondVar;
    typedef NopCondVar<FastLock>      FastCondVar;
    static const bool isMultiThreaded = false;
    typedef Int2Type<false> Type;
};



} // namespace fatalmind
#ifndef INCLUDED_CONDVAR_H
#include "CondVar.hh"
#endif

#endif

---