OSGLock.h

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 *                                OpenSG                                     *
 *                                                                           *
 *                                                                           *
 *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
 *                                                                           *
 *                            www.opensg.org                                 *
 *                                                                           *
 *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
 *                                                                           *
\*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*\
 *                                License                                    *
 *                                                                           *
 * This library is free software; you can redistribute it and/or modify it   *
 * under the terms of the GNU Library General Public License as published    *
 * by the Free Software Foundation, version 2.                               *
 *                                                                           *
 * This library 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         *
 * Library General Public License for more details.                          *
 *                                                                           *
 * You should have received a copy of the GNU Library General Public         *
 * License along with this library; if not, write to the Free Software       *
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
 *                                                                           *
\*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*\
 *                                Changes                                    *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
\*---------------------------------------------------------------------------*/

#ifndef _OSGLOCK_H_
#define _OSGLOCK_H_
#ifdef __sgi
#pragma once
#endif

#include <OSGBase.h>
#include <OSGConfig.h>

#if ! defined (OSG_USE_PTHREADS)   && \
    ! defined (OSG_USE_SPROC)      && \
    ! defined (OSG_USE_WINTHREADS)
#error "No threading model defined,  check your system/compiler combination"
#endif

#include <OSGBaseTypes.h>
#include <OSGMPBase.h>

#if defined (OSG_USE_PTHREADS)
#include <pthread.h>
#endif

#if defined (OSG_USE_SPROC)
#include <ulocks.h>
#endif

OSG_BEGIN_NAMESPACE

static const UInt32 uiLockPoolSize = 32;
static const UInt32 uiLockPoolMask = 0x0f80;

template <class MPFieldT>
class MPFieldStore;

//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

class OSG_BASE_DLLMAPPING LockCommonBase : public MPBase
{
    /*==========================  PUBLIC  =================================*/

  public:

    /*=========================  PROTECTED  ===============================*/

  protected:

    typedef MPBase  Inherited;

            UInt32 _uiLockId;
  
    /*---------------------------------------------------------------------*/
    LockCommonBase(void);
    LockCommonBase(const Char8 *szName, UInt32 uiId);
    
    /*---------------------------------------------------------------------*/
    virtual ~LockCommonBase(void); 
    
    /*==========================  PRIVATE  ================================*/

  private:

    LockCommonBase  (const LockCommonBase &source);
    void operator = (const LockCommonBase &source);
};




//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

#if defined (OSG_USE_PTHREADS)

class PThreadLockBase : public LockCommonBase
{
    /*==========================  PUBLIC  =================================*/

  public :

    /*=========================  PROTECTED  ===============================*/

  protected:

    typedef LockCommonBase Inherited;
    
    /*---------------------------------------------------------------------*/
    PThreadLockBase(void);
    PThreadLockBase(const Char8 *szName, UInt32 uiId  );
    
    /*---------------------------------------------------------------------*/
    virtual ~PThreadLockBase(void); 

    /*---------------------------------------------------------------------*/
    bool init    (void);

    /*---------------------------------------------------------------------*/
    void shutdown(void);

    /*---------------------------------------------------------------------*/
    void aquire  (void);
    void release (void);
    bool request (void);
    
    /*==========================  PRIVATE  ================================*/

  private:
    
    friend class LockPool;

    pthread_mutex_t _pLowLevelLock;

    PThreadLockBase(const PThreadLockBase &source);
    void operator =(const PThreadLockBase &source);
};

typedef PThreadLockBase LockBase;

#endif /* OSG_USE_PTHREADS */




//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

#if defined (OSG_USE_SPROC)

class SprocLockBase : public LockCommonBase
{
    /*==========================  PUBLIC  =================================*/

  public :
    
    /*=========================  PROTECTED  ===============================*/

  protected:

    typedef LockCommonBase Inherited;

    /*---------------------------------------------------------------------*/
    SprocLockBase(void);
    SprocLockBase(const Char8 *szName, UInt32 uiId  );
    
    /*---------------------------------------------------------------------*/
    virtual ~SprocLockBase(void); 

    /*---------------------------------------------------------------------*/
    bool init    (void);

    /*---------------------------------------------------------------------*/
    void shutdown(void);
    
    /*---------------------------------------------------------------------*/
    void aquire  (void);
    void release (void);
    bool request (void);

    /*==========================  PRIVATE  ================================*/

  private:

    friend class LockPool;

//#define OSG_SPROC_USE_LOCK
#ifdef OSG_SPROC_USE_LOCK
    ulock_t  _pLowLevelLock;
#else
    usema_t *_pLowLevelSema;
#endif

    SprocLockBase(const SprocLockBase &source);
    void operator =(const SprocLockBase &source);
};

typedef SprocLockBase LockBase;

#endif /* OSG_USE_SPROC */




//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

#if defined (OSG_USE_WINTHREADS)

#if _WIN32_WINNT < 0x0400
#define OSG_WINLOCK_USE_MUTEX
#endif

class OSG_BASE_DLLMAPPING WinThreadLockBase : public LockCommonBase
{
    /*==========================  PUBLIC  =================================*/

  public :

    /*=========================  PROTECTED  ===============================*/

  protected:

    typedef LockCommonBase Inherited;
    
    /*---------------------------------------------------------------------*/
    WinThreadLockBase(void);
    WinThreadLockBase(const Char8 *szName, UInt32 uiId  );
    
    /*---------------------------------------------------------------------*/
    virtual ~WinThreadLockBase(void); 

    /*---------------------------------------------------------------------*/
    bool init    (void);

    /*---------------------------------------------------------------------*/
    void shutdown(void);

    /*---------------------------------------------------------------------*/
    void aquire  (void);
    void release (void);
    bool request (void);
    
    /*==========================  PRIVATE  ================================*/
  private:

    friend class LockPool;

#ifdef OSG_WINLOCK_USE_MUTEX
    Handle  _pMutex;
#else
    CRITICAL_SECTION _pCriticalSection;
#endif
  
    WinThreadLockBase(const WinThreadLockBase &source);
    void operator =(const WinThreadLockBase &source);
};

typedef WinThreadLockBase LockBase;

#endif /* OSG_USE_WINTHREADS */




//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

class OSG_BASE_DLLMAPPING Lock : public LockBase
{
    /*==========================  PUBLIC  =================================*/

  public:

    typedef MPLockType Type;

    /*---------------------------------------------------------------------*/
    static       Lock       *get         (const Char8 *szName);
    static       Lock       *find        (const Char8 *szName);

    static       Lock       *create      (      void         );

    static const MPLockType &getClassType(      void         ); 

    /*---------------------------------------------------------------------*/
    void aquire (void);
    void release(void);
    bool request(void);
    
    /*=========================  PROTECTED  ===============================*/

  protected:

    typedef LockBase    Inherited;

    static  MPLockType _type;
  
    /*---------------------------------------------------------------------*/
    static Lock *create(const Char8 *szName, UInt32 uiId);

    /*---------------------------------------------------------------------*/
    Lock(void);
    Lock(const Char8 *szName, UInt32 uiId);
    
    /*---------------------------------------------------------------------*/
    virtual ~Lock(void);

    /*==========================  PRIVATE  ================================*/

  private:

    friend class LockPool;
    friend class MPFieldStore<Lock>;

    Lock(const Lock &source);
    void operator =(const Lock &source);
};




//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

class OSG_BASE_DLLMAPPING LockPool : public LockCommonBase
{
    /*==========================  PUBLIC  =================================*/

  public:

    typedef MPLockPoolType Type;

    /*---------------------------------------------------------------------*/
    static LockPool *get   (const Char8 *szName);
    static LockPool *find  (const Char8 *szName);
    static LockPool *create(      void         );

    /*---------------------------------------------------------------------*/
    void aquire (void *keyP);
    void release(void *keyP);
    bool request(void *keyP);
    
    /*=========================  PROTECTED  ===============================*/

  protected:

    typedef LockCommonBase  Inherited;

    static  MPLockPoolType _type;

            Lock           _pLocks    [uiLockPoolSize];

#ifdef OSG_DEBUG_LOCK_STAT
            UInt32         _pLockStats[uiLockPoolSize];
#endif

    /*---------------------------------------------------------------------*/
    static LockPool *create(const Char8 *szName, UInt32 uiId);

    /*---------------------------------------------------------------------*/
    LockPool(const Char8 *szName, UInt32 uiId);
    
    /*---------------------------------------------------------------------*/
    virtual ~LockPool(void);
     
    /*---------------------------------------------------------------------*/
    bool init(void);

    /*---------------------------------------------------------------------*/
    void shutdown(void);
        
    /*==========================  PRIVATE  ================================*/

  private:

    friend class MPFieldStore<LockPool>;

    LockPool(const LockPool &source);
    void operator =(const LockPool &source);
};

OSG_END_NAMESPACE

#define OSGLOCK_HEADER_CVSID "@(#)$Id: $"

#endif /* _OSGLOCK_H_ */

---