///////////////////////////////////////////////////////////////////////////////
|
// Copyright (C) 2002-2016, Open Design Alliance (the "Alliance").
|
// All rights reserved.
|
//
|
// This software and its documentation and related materials are owned by
|
// the Alliance. The software may only be incorporated into application
|
// programs owned by members of the Alliance, subject to a signed
|
// Membership Agreement and Supplemental Software License Agreement with the
|
// Alliance. The structure and organization of this software are the valuable
|
// trade secrets of the Alliance and its suppliers. The software is also
|
// protected by copyright law and international treaty provisions. Application
|
// programs incorporating this software must include the following statement
|
// with their copyright notices:
|
//
|
// This application incorporates Teigha(R) software pursuant to a license
|
// agreement with Open Design Alliance.
|
// Teigha(R) Copyright (C) 2002-2016 by Open Design Alliance.
|
// All rights reserved.
|
//
|
// By use of this software, its documentation or related materials, you
|
// acknowledge and accept the above terms.
|
///////////////////////////////////////////////////////////////////////////////
|
|
#ifndef _OD_MUTEX_H_
|
#define _OD_MUTEX_H_
|
|
#include "RootExport.h"
|
#include "TD_PackPush.h"
|
#ifdef OD_POSIX_THREADS
|
#include <pthread.h>
|
#elif defined(ODA_WINDOWS)
|
#ifndef WIN32_LEAN_AND_MEAN
|
#define WIN32_LEAN_AND_MEAN
|
#endif
|
#ifndef NOMINMAX
|
#define NOMINMAX
|
#endif
|
#include <windows.h>
|
#endif
|
|
/** \details
|
This class implements Mutex objects in a Teigha context.
|
|
\remarks
|
Mutex objects are used to synchronize between threads and across processes.
|
Library: TD_Root
|
<group Other_Classes>
|
*/
|
class FIRSTDLL_EXPORT OdMutex
|
{
|
#ifdef OD_POSIX_THREADS
|
pthread_mutex_t _mutex;
|
public:
|
OdMutex()
|
{
|
pthread_mutexattr_t attr;
|
pthread_mutexattr_init(&attr);
|
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
|
pthread_mutex_init(&_mutex, &attr);
|
pthread_mutexattr_destroy(&attr);
|
}
|
~OdMutex()
|
{
|
pthread_mutex_destroy((pthread_mutex_t*)&_mutex);
|
}
|
/** \details
|
Locks this Mutex object.
|
*/
|
void lock()
|
{
|
pthread_mutex_lock(&_mutex);
|
}
|
/** \details
|
Unlocks this Mutex object.
|
*/
|
void unlock()
|
{
|
pthread_mutex_unlock(&_mutex);
|
}
|
#elif (defined(ODA_WINDOWS)) && !defined(_WIN32_WCE) && !defined(_WINRT)
|
CRITICAL_SECTION _mutex;
|
public:
|
OdMutex()
|
{
|
InitializeCriticalSection(&_mutex);
|
}
|
~OdMutex()
|
{
|
DeleteCriticalSection(&_mutex);
|
}
|
/** \details
|
Locks this Mutex object.
|
*/
|
void lock()
|
{
|
EnterCriticalSection(&_mutex);
|
}
|
/** \details
|
Unlocks this Mutex object.
|
*/
|
void unlock()
|
{
|
LeaveCriticalSection(&_mutex);
|
}
|
#else
|
public:
|
OdMutex() {}
|
~OdMutex() {}
|
/** \details
|
Locks this Mutex object.
|
*/
|
void lock() {}
|
/** \details
|
Unlocks this Mutex object.
|
*/
|
void unlock() {}
|
#endif
|
};
|
|
/** \details
|
This class implements Mutex AutoLock objects in a Teigha context.
|
|
\remarks
|
Mutex objects are used to synchronize between threads and across processes.
|
|
MutexAutoLock objects automatically lock the specified OdMutex object
|
when constructed and unlock it when destroyed.
|
|
Library: TD_Root
|
<group Other_Classes>
|
*/
|
class OdMutexAutoLock
|
{
|
public:
|
/** \param mutex [in] Mutex to be Autolocked.
|
*/
|
OdMutexAutoLock(OdMutex& mutex) : m_Mutex(mutex)
|
{
|
m_Mutex.lock();
|
}
|
~OdMutexAutoLock()
|
{
|
m_Mutex.unlock();
|
}
|
private:
|
OdMutex& m_Mutex;
|
};
|
|
#ifndef TD_SINGLE_THREAD
|
#define TD_AUTOLOCK(Mutex) OdMutexAutoLock autoLock(Mutex);
|
#else
|
#define TD_AUTOLOCK(Mutex)
|
#endif
|
|
|
#ifndef TD_SINGLE_THREAD
|
#if defined(_MSC_VER) && _M_IX86 >= 400 && !defined(_WIN32_WCE)
|
// Intel486 platform with Microsoft compiler
|
#pragma warning(push)
|
#pragma warning(disable:4035)
|
#pragma warning(disable:4793)
|
inline int OdInterlockedExchange(volatile int* dest, int val)
|
{
|
__asm
|
{
|
mov edx, dest
|
mov eax, val
|
lock xchg [edx], eax
|
}
|
}
|
inline int OdInterlockedExchangeAdd(volatile int* dest, int incr)
|
{
|
__asm
|
{
|
mov edx, dest
|
mov eax, incr
|
lock xadd [edx], eax
|
}
|
}
|
inline int OdInterlockedIncrement(volatile int* dest)
|
{
|
__asm
|
{
|
mov edx, dest
|
mov eax, 1
|
lock xadd [edx], eax
|
inc eax
|
}
|
}
|
inline int OdInterlockedDecrement(volatile int* dest)
|
{
|
__asm
|
{
|
mov edx, dest
|
mov eax, -1
|
lock xadd [edx], eax
|
dec eax
|
}
|
}
|
#pragma warning(pop)
|
#elif (defined(_WIN32) || defined(_WIN64)) && !defined(_WIN32_WCE) && !defined(_WINRT)
|
// Windows platform with generic compiler - use interlocked functions from Win32 API
|
#define OdInterlockedExchange(dest, val) InterlockedExchange((LONG*)(dest), val)
|
#define OdInterlockedExchangeAdd(dest, incr) InterlockedExchangeAdd((LONG*)(dest), incr)
|
#define OdInterlockedIncrement(dest) InterlockedIncrement((LONG*)(dest))
|
#define OdInterlockedDecrement(dest) InterlockedDecrement((LONG*)(dest))
|
#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
|
// Intel platform with GCC compiler
|
inline int OdInterlockedExchange(volatile int* dest, int val)
|
{
|
int ret;
|
__asm__ __volatile__ (
|
"lock; xchgl %0, (%1)"
|
: "=r" (ret)
|
: "r" (dest), "0" (val)
|
: "memory");
|
return ret;
|
}
|
inline int OdInterlockedExchangeAdd(volatile int* dest, int incr)
|
{
|
int ret;
|
__asm__ __volatile__ (
|
"lock; xaddl %0, (%1)"
|
: "=r" (ret)
|
: "r" (dest), "0" (incr)
|
: "memory");
|
return ret;
|
}
|
inline int OdInterlockedIncrement(volatile int* dest)
|
{
|
return OdInterlockedExchangeAdd(dest, 1) + 1;
|
}
|
inline int OdInterlockedDecrement(volatile int* dest)
|
{
|
return OdInterlockedExchangeAdd(dest, -1) - 1;
|
}
|
#elif defined(__GNUC__) && defined(__POWERPC__)
|
// Macintosh PowerPC platform with GCC compiler
|
inline int OdInterlockedExchange(volatile int* dest, int val)
|
{
|
// Assembler code is taken from Wine 0.9.4 sources
|
// See http://cvs.winehq.org/cvsweb/wine/libs/port/interlocked.c?rev=1.7&content-type=text/x-cvsweb-markup
|
int ret = 0;
|
__asm__ __volatile__ (
|
"0: lwarx %0, 0, %1\n"
|
" stwcx. %2, 0, %1\n"
|
" bne- 0b\n"
|
" isync\n"
|
: "=&r"(ret)
|
: "r"(dest), "r"(val)
|
: "cr0", "memory", "r0");
|
return ret;
|
}
|
inline int OdInterlockedExchangeAdd(volatile int* dest, int incr)
|
{
|
// Assembler code is taken from Wine 0.9.4 sources
|
// See http://cvs.winehq.org/cvsweb/wine/libs/port/interlocked.c?rev=1.7&content-type=text/x-cvsweb-markup
|
int ret = 0;
|
int zero = 0;
|
__asm__ __volatile__ (
|
"0: lwarx %0, %3, %1\n"
|
" add %0, %2, %0\n"
|
" stwcx. %0, %3, %1\n"
|
" bne- 0b\n"
|
" isync\n"
|
: "=&r" (ret)
|
: "r"(dest), "r"(incr), "r"(zero)
|
: "cr0", "memory", "r0");
|
return ret - incr;
|
}
|
inline int OdInterlockedIncrement(volatile int* dest)
|
{
|
return OdInterlockedExchangeAdd(dest, 1) + 1;
|
}
|
inline int OdInterlockedDecrement(volatile int* dest)
|
{
|
return OdInterlockedExchangeAdd(dest, -1) - 1;
|
}
|
#elif defined(__APPLE__)
|
// iOS or Mac platform
|
#include <libkern/OSAtomic.h>
|
inline int OdInterlockedExchange(volatile int* dest, int val)
|
{
|
int oldValue = *dest;
|
while (!OSAtomicCompareAndSwapIntBarrier(oldValue, val, dest))
|
oldValue = *dest;
|
return oldValue;
|
}
|
inline int OdInterlockedExchangeAdd(volatile int* dest, int incr)
|
{
|
return OSAtomicAdd32Barrier(incr, dest) - incr;
|
}
|
inline int OdInterlockedIncrement(volatile int* dest)
|
{
|
return OSAtomicIncrement32Barrier(dest);
|
}
|
inline int OdInterlockedDecrement(volatile int* dest)
|
{
|
return OSAtomicDecrement32Barrier(dest);
|
}
|
#elif defined(ANDROID) && !defined(ANDROID_GOOGLE)
|
//TODO Android r10c NDK doesn't provide such functionality
|
// Android platform with GCC or MinGW compiler
|
#include <sys/atomics.h>
|
inline int OdInterlockedExchange(volatile int* dest, int val)
|
{
|
return __atomic_swap(val, dest);
|
}
|
inline int OdInterlockedExchangeAdd(volatile int* dest, int incr)
|
{
|
// There is no atomic instruction to add. This implementation isn't completely safe.
|
return __atomic_swap(*dest + incr, dest);
|
}
|
inline int OdInterlockedIncrement(volatile int* dest)
|
{
|
return __atomic_inc(dest) + 1;
|
}
|
inline int OdInterlockedDecrement(volatile int* dest)
|
{
|
return __atomic_dec(dest) - 1;
|
}
|
/*
|
#elif defined(__sun)
|
// sparc on Sun Studio compiler, solaris
|
#include <atomic.h>
|
inline int OdInterlockedExchange(volatile int* dest, int val)
|
{
|
return (int)atomic_swap_uint((volatile uint_t*)dest, (uint_t)val);
|
}
|
inline int OdInterlockedExchangeAdd(volatile int* dest, int incr)
|
{
|
return (int)atomic_add_int_nv((volatile uint_t*)dest, incr) - incr;
|
}
|
inline int OdInterlockedIncrement(volatile int* dest)
|
{
|
return (int)atomic_inc_uint_nv((volatile uint_t*)dest);
|
}
|
inline int OdInterlockedDecrement(volatile int* dest)
|
{
|
return (int)atomic_dec_uint_nv((volatile uint_t*)dest);
|
}
|
#elif defined (__hpux)
|
// HPUX (require libatomic: https://h20392.www2.hp.com/portal/swdepot/displayProductInfo.do?productNumber=Atomic)
|
#include <atomic.h>
|
inline int OdInterlockedExchange(volatile int* dest, int val)
|
{
|
return (int)atomic_swap_32((volatile uint32_t*)dest, (uint32_t)val);
|
}
|
inline int OdInterlockedExchangeAdd(volatile int* dest, int incr)
|
{
|
// There is no atomic instruction to add. This implementation isn't completely safe.
|
return (int)atomic_swap_32((volatile uint32_t*)dest, (uint32_t)(*desc + incr));
|
}
|
inline int OdInterlockedIncrement(volatile int* dest)
|
{
|
return (int)atomic_inc_32((volatile uint32_t*)dest) + 1;
|
}
|
inline int OdInterlockedDecrement(volatile int* dest)
|
{
|
return (int)atomic_dec_32((volatile uint32_t*)dest) - 1;
|
}*/
|
#else
|
// here should go other platforms
|
// synchronization is disabled if no atomic functions are defined
|
#define TD_SINGLE_THREAD
|
#endif //architecture
|
#endif //TD_SINGLE_THREAD
|
|
/** \details
|
This class implements reference counter with interlocked operations for Teigha objects.
|
|
Library: TD_Root
|
<group Other_Classes>
|
*/
|
#ifndef TD_SINGLE_THREAD
|
#ifdef _MANAGED
|
#pragma managed(push, off)
|
#endif
|
/** <group !!RECORDS_TD_APIRef>
|
*/
|
struct OdRefCounter
|
{
|
typedef int RefCounterType;
|
volatile RefCounterType _ref_count;
|
OdRefCounter& operator = (RefCounterType n) { _ref_count = 0; OdInterlockedExchange(&_ref_count, n); return *this; }
|
operator RefCounterType () const { return OdInterlockedExchangeAdd(const_cast<RefCounterType*>(&_ref_count), 0); }
|
RefCounterType operator ++ () { return OdInterlockedIncrement(&_ref_count); }
|
RefCounterType operator -- () { return OdInterlockedDecrement(&_ref_count); }
|
// 1 as default is not correct for all classes
|
// (see for example OdArrayBuffer, CAllocator)
|
OdRefCounter() : _ref_count(-1) {} // undefined
|
OdRefCounter(int n) : _ref_count(n) {}
|
};
|
|
/** <group !!RECORDS_TD_APIRef>
|
*/
|
struct OdVolatile
|
{
|
typedef int VolatileType;
|
volatile VolatileType _val;
|
OdVolatile& operator = (VolatileType n) { _val = 0; OdInterlockedExchange(&_val, n); return *this; }
|
operator VolatileType () const { return OdInterlockedExchangeAdd(const_cast<VolatileType*>(&_val), 0); }
|
VolatileType operator|=(VolatileType n) { return OdInterlockedExchange(&_val, _val|n); }
|
VolatileType operator&=(VolatileType n) { return OdInterlockedExchange(&_val, _val&n); }
|
OdVolatile() : _val(0) {}
|
OdVolatile(int n): _val(n) {}
|
};
|
|
#ifdef _MANAGED
|
#pragma managed(pop)
|
#endif
|
|
#else
|
typedef int OdRefCounter;
|
typedef int OdVolatile;
|
#endif
|
|
#include "TD_PackPop.h"
|
#endif
|
