diff --git a/flaim/src/f_nici.cpp b/flaim/src/f_nici.cpp index 4a55d1d..6542bf0 100644 --- a/flaim/src/f_nici.cpp +++ b/flaim/src/f_nici.cpp @@ -2718,31 +2718,6 @@ FSTATIC void GetIV( } #endif -/***************************************************************************** -Desc: Add a globally shared reference to this object. -*****************************************************************************/ -FLMINT F_CCS::AddRef() -{ - return( ftkAtomicIncrement( &m_i32RefCnt)); -} - -/***************************************************************************** -Desc: Removes a globally shared reference to this object. -*****************************************************************************/ -FLMINT F_CCS::Release() -{ - FLMINT iRefCnt = 0; - - iRefCnt = ftkAtomicDecrement( &m_i32RefCnt); - - if( !iRefCnt) - { - delete this; - } - - return( iRefCnt); -} - /***************************************************************************** Desc: *****************************************************************************/ diff --git a/flaim/src/f_nici.h b/flaim/src/f_nici.h index a554bdf..99f98b0 100644 --- a/flaim/src/f_nici.h +++ b/flaim/src/f_nici.h @@ -187,10 +187,23 @@ public: return m_uiAlgType; } - FLMINT AddRef( void); - - FLMINT Release( void); + FINLINE FLMINT AddRef( void) + { + return( flmAtomicInc( &m_refCnt, m_hMutex, FALSE)); + } + FINLINE FLMINT Release( void) + { + FLMINT iRefCnt = flmAtomicDec( &m_refCnt, m_hMutex, FALSE); + + if( !iRefCnt) + { + delete this; + } + + return( iRefCnt); + } + private: RCODE getWrappingKey( @@ -265,7 +278,6 @@ private: NICI_OBJECT_HANDLE m_keyHandle; // Handle to the clear key - we don't ever get the actual key. F_MUTEX m_hMutex; FLMBYTE m_pucIV[ IV_SZ]; // Used when the algorithm type is DES, 3DES or AES - }; /**************************************************************************** diff --git a/flaim/src/flaim.h b/flaim/src/flaim.h index 8c6236f..3923690 100644 --- a/flaim/src/flaim.h +++ b/flaim/src/flaim.h @@ -177,13 +177,16 @@ typedef short FLMINT16; typedef signed char FLMINT8; - #if defined( FLM_64BIT) || defined( FLM_OSX) || defined( FLM_S390) || defined( FLM_HPUX) || defined( FLM_AIX) + #if defined( FLM_64BIT) || defined( FLM_OSX) || \ + defined( FLM_S390) || defined( FLM_HPUX) || defined( FLM_AIX) typedef unsigned long FLMSIZET; #else typedef unsigned FLMSIZET; #endif #else + #if defined( FLM_WIN) + #if defined( FLM_64BIT) typedef unsigned __int64 FLMUINT; typedef __int64 FLMINT; @@ -198,10 +201,13 @@ typedef long FLMINT; typedef unsigned int FLMUINT32; #endif + #elif defined( FLM_NLM) + typedef unsigned long int FLMUINT; typedef long int FLMINT; typedef unsigned long int FLMUINT32; + #endif typedef unsigned char FLMBYTE; @@ -224,8 +230,14 @@ #endif + #if defined( FLM_WIN) || defined( FLM_NLM) + #define FLMATOMIC volatile long + #else + #define FLMATOMIC volatile int + #endif + typedef FLMINT FLMBOOL; - + #define F_FILENAME_SIZE 256 #define F_PATH_MAX_SIZE 256 @@ -827,7 +839,7 @@ F_Base() { - m_i32RefCnt = 1; + m_refCnt = 1; } virtual ~F_Base() @@ -839,7 +851,7 @@ /// Return value is the incremented reference count. FINLINE FLMINT AddRef( void) { - return( ++m_i32RefCnt); + return( (FLMINT)(++m_refCnt)); } /// Decrement the reference count for this object. @@ -851,7 +863,7 @@ /// Return the current reference count on the object. FINLINE FLMINT getRefCount( void) { - return( m_i32RefCnt); + return( (FLMINT)(m_refCnt)); } /// Overloaded new operator for objects of this class. @@ -928,7 +940,7 @@ protected: - FLMINT32 m_i32RefCnt; + FLMATOMIC m_refCnt; friend class F_FileHdlPage; friend class F_FileHdlMgrPage; @@ -4615,7 +4627,10 @@ /// Increment the reference count for this ::FlmRecord object. /// The reference count is the number of pointers that are referencing this ::FlmRecord object. /// Return value is the incremented reference count. - FLMINT AddRef( void); + FINLINE FLMINT AddRef( void) + { + return( AddRef( FALSE)); + } /// Decrement the reference count for this ::FlmRecord object. /// The reference count is the number of pointers that are referencing this ::FlmRecord object. @@ -5341,6 +5356,9 @@ private: + FLMINT AddRef( + FLMBOOL bMutexLocked); + FLMINT Release( FLMBOOL bMutexLocked); diff --git a/flaim/src/flalloc.cpp b/flaim/src/flalloc.cpp index 9ed1678..7c50fee 100644 --- a/flaim/src/flalloc.cpp +++ b/flaim/src/flalloc.cpp @@ -1428,7 +1428,7 @@ Desc: ****************************************************************************/ FLMINT F_Base::Release( void) { - FLMINT iRefCnt = --m_i32RefCnt; + FLMINT iRefCnt = --m_refCnt; if( !iRefCnt) { diff --git a/flaim/src/fposix.cpp b/flaim/src/fposix.cpp index c7b9008..3094417 100644 --- a/flaim/src/fposix.cpp +++ b/flaim/src/fposix.cpp @@ -55,18 +55,6 @@ extern RCODE gv_CriticalFSError; -#if defined( FLM_USE_SPIN_LOCK_ATOMICS) - - #if defined( FLM_SPARC) - volatile unsigned char gv_flmAtomicLock; - #endif - -#elif defined( FLM_USE_MUTEX_ATOMICS) - - pthread_mutex_t gv_flmAtomicLock = PTHREAD_MUTEX_INITIALIZER; - -#endif - /**************************************************************************** Desc: ****************************************************************************/ diff --git a/flaim/src/frec.cpp b/flaim/src/frec.cpp index 402061e..dc0e1cb 100644 --- a/flaim/src/frec.cpp +++ b/flaim/src/frec.cpp @@ -59,7 +59,7 @@ FLMBYTE arr[ 16] = #define f_isalpha(c) \ ((c) < 128 && (c) > 58 ? (( ((FLMBYTE)(arr[(c) >> 3])) << \ ((c) & 0x07)) & 0x80) : 0) - + /***************************************************************************** Desc: *****************************************************************************/ @@ -1692,13 +1692,13 @@ RCODE FlmRecord::compactMemory( void) FLMBOOL bHeapAlloc = FALSE; flmAssert( isCached()); - flmAssert( m_i32RefCnt == 1); + flmAssert( getRefCount() == 1); // Temporarily increment the reference count so that we don't hit // debug asserts while processing - - m_i32RefCnt++; - + + flmAtomicInc( &m_refCnt, gv_FlmSysData.RCacheMgr.hMutex, TRUE); + if( !m_uiBufferSize || (!m_bHolesInData && m_uiDataBufOffset == getDataBufSize())) { @@ -1949,10 +1949,8 @@ Exit: gv_FlmSysData.RCacheMgr.pRecBufAlloc->freeBuf( uiNewSize, &pucNewBuf); } - - // Remove the reference count added above - - m_i32RefCnt--; + + flmAtomicDec( &m_refCnt, gv_FlmSysData.RCacheMgr.hMutex, TRUE); return( rc); } @@ -2710,13 +2708,14 @@ Exit: /***************************************************************************** Desc: Add a globally shared reference to this object. *****************************************************************************/ -FLMINT FlmRecord::AddRef( void) +FLMINT FlmRecord::AddRef( + FLMBOOL bMutexLocked) { FLMINT iRefCnt = 0; - - iRefCnt = ftkAtomicIncrement( &m_i32RefCnt); - + + iRefCnt = flmAtomicInc( &m_refCnt, gv_FlmSysData.RCacheMgr.hMutex, bMutexLocked); flmAssert( iRefCnt > 1); + return( iRefCnt); } @@ -2728,8 +2727,8 @@ FLMINT FlmRecord::Release( { FLMINT iRefCnt = 0; FLMBOOL bUnlockMutex = FALSE; - - if( isCached() && m_i32RefCnt == 2) + + if( isCached() && getRefCount() == 2) { if( !bMutexLocked) { @@ -2739,7 +2738,7 @@ FLMINT FlmRecord::Release( } } - iRefCnt = ftkAtomicDecrement( &m_i32RefCnt); + iRefCnt = flmAtomicDec( &m_refCnt, gv_FlmSysData.RCacheMgr.hMutex, bMutexLocked); if( !iRefCnt) { @@ -4555,7 +4554,7 @@ void FlmRecord::operator delete( return; } - flmAssert( ((FlmRecord *)ptr)->m_i32RefCnt == 0); + flmAssert( ((FlmRecord *)ptr)->getRefCount() == 0); gv_FlmSysData.RCacheMgr.pRecAlloc->freeCell( ptr); } @@ -4584,7 +4583,7 @@ void FlmRecord::operator delete( return; } - flmAssert( ((FlmRecord *)ptr)->m_i32RefCnt == 0); + flmAssert( ((FlmRecord *)ptr)->getRefCount() == 0); gv_FlmSysData.RCacheMgr.pRecAlloc->freeCell( ptr); } #endif diff --git a/flaim/src/fsrvlock.cpp b/flaim/src/fsrvlock.cpp index 031dca6..17f664e 100644 --- a/flaim/src/fsrvlock.cpp +++ b/flaim/src/fsrvlock.cpp @@ -568,11 +568,10 @@ Desc: FLMINT ServerLockObject::Release( F_MutexRef * pMutexRef) { - FLMINT iRefCnt = --m_i32RefCnt; + FLMINT iRefCnt = F_Base::Release(); if( !iRefCnt) { - delete this; goto Exit; } @@ -1049,9 +1048,8 @@ RCODE ServerLockObject::Unlock( // the lock manager's reference, and a reference from at least one // waiter (that may have been granted above). - flmAssert( m_i32RefCnt >= 3); - - m_i32RefCnt--; + flmAssert( getRefCount() >= 3); + F_Base::Release(); } MutexRef.Unlock(); diff --git a/flaim/src/fsysdata.cpp b/flaim/src/fsysdata.cpp index 4fd2103..a06bd10 100644 --- a/flaim/src/fsysdata.cpp +++ b/flaim/src/fsysdata.cpp @@ -62,9 +62,9 @@ #endif -FLMINT32 gv_i32FlmSysSpinLock = 0; -FLMUINT gv_uiFlmSysStartupCount = 0; -FLMBOOL gv_bNetWareStartupCalled = FALSE; +FLMATOMIC gv_flmSysSpinLock = 0; +FLMUINT gv_uiFlmSysStartupCount = 0; +FLMBOOL gv_bNetWareStartupCalled = FALSE; #ifdef FLM_NLM extern "C" @@ -574,12 +574,19 @@ Desc: Lock the system data structure for access - called only by startup ***************************************************************************/ FSTATIC void flmLockSysData( void) { - // Obtain the spin lock - - while (ftkAtomicExchange( &gv_i32FlmSysSpinLock, 1) == 1) +#ifdef FLM_HAVE_ATOMICS + while( _flmAtomicExchange( &gv_flmSysSpinLock, 1) == 1) { f_sleep( 10); } +#else + while (gv_flmSysSpinLock) + { + f_sleep( 10); + } + + gv_flmSysSpinLock = 1; +#endif } /*************************************************************************** @@ -588,7 +595,11 @@ Desc: Unlock the system data structure for access - called only by startup ***************************************************************************/ FSTATIC void flmUnlockSysData( void) { - (void)ftkAtomicExchange( &gv_i32FlmSysSpinLock, 0); +#ifdef FLM_HAVE_ATOMICS + _flmAtomicExchange( &gv_flmSysSpinLock, 0); +#else + gv_flmSysSpinLock = 0; +#endif } /*API~*********************************************************************** @@ -610,19 +621,25 @@ FLMEXP RCODE FLMAPI FlmStartup( void) // Before starting anything, make sure the atomic primitives return the // correct values on this platform -#ifdef FLM_DEBUG - { - FLMINT32 i32Val = 10772; - FLMINT32 i32Tmp; +#if defined( FLM_DEBUG) + + #if defined( FLM_HAVE_ATOMICS) + { + FLMATOMIC atomicVal = 10772; + FLMINT32 i32Tmp; - flmAssert( ftkAtomicIncrement( &i32Val) == 10773); - flmAssert( ftkAtomicDecrement( &i32Val) == 10772); + flmAssert( flmAtomicInc( &atomicVal) == 10773); + flmAssert( flmAtomicDec( &atomicVal) == 10772); - i32Tmp = ftkAtomicExchange( &i32Val, 10777); + i32Tmp = flmAtomicExchange( &atomicVal, 10777); flmAssert( i32Tmp == 10772); - flmAssert( i32Val == 10777); + flmAssert( atomicVal == 10777); } + #elif defined( FLM_WIN) || defined( FLM_NLM) + #error Something is wrong with the build environment! + #endif + #endif flmLockSysData(); @@ -706,7 +723,6 @@ FLMEXP RCODE FLMAPI FlmStartup( void) f_memoryInit(); #if defined( FLM_NLM) || (defined( FLM_WIN) && !defined( FLM_64BIT)) - /* Initialize the checksum code variable. */ InitFastBlockCheckSum(); #endif @@ -721,8 +737,6 @@ FLMEXP RCODE FLMAPI FlmStartup( void) flmDbgLogInit(); #endif - /* Initialize all of the fields. */ - FLM_SECS_TO_TIMER_UNITS( DEFAULT_MAX_UNUSED_TIME, gv_FlmSysData.uiMaxUnusedTime); FLM_SECS_TO_TIMER_UNITS( DEFAULT_MAX_CP_INTERVAL, @@ -819,7 +833,7 @@ FLMEXP RCODE FLMAPI FlmStartup( void) goto Exit; } - /* Create the mutex for controlling access to the structure. */ + // Create the mutex for controlling access to the structure if (RC_BAD( rc = f_mutexCreate( &gv_FlmSysData.hShareMutex))) { @@ -851,7 +865,7 @@ FLMEXP RCODE FLMAPI FlmStartup( void) goto Exit; } - /* Initialize a statistics structure. */ + // Initialize a statistics structure if (RC_BAD( rc = flmStatInit( &gv_FlmSysData.Stats, TRUE))) { @@ -859,7 +873,7 @@ FLMEXP RCODE FLMAPI FlmStartup( void) } gv_FlmSysData.bStatsInitialized = TRUE; - /* Allocate memory for the file name hash table. */ + // Allocate memory for the file name hash table if (RC_BAD(rc = flmAllocHashTbl( FILE_HASH_ENTRIES, &gv_FlmSysData.pFileHashTbl))) @@ -869,7 +883,7 @@ FLMEXP RCODE FLMAPI FlmStartup( void) gv_FlmSysData.uiNextFFileId = 1; - /* Allocate and Initialize FLAIM Shared File Handle Manager */ + // Allocate and Initialize FLAIM Shared File Handle Manager if ((gv_FlmSysData.pFileHdlMgr = new F_FileHdlMgr( &gv_FlmSysData.hFileHdlMutex)) == NULL) @@ -884,7 +898,7 @@ FLMEXP RCODE FLMAPI FlmStartup( void) goto Exit; } - /* Allocate and Initialize FLAIM Shared File System object */ + // Allocate and Initialize FLAIM Shared File System object if ((gv_FlmSysData.pFileSystem = f_new F_FileSystemImp) == NULL) { @@ -913,7 +927,7 @@ FLMEXP RCODE FLMAPI FlmStartup( void) gv_FlmSysData.bOkToDoAsyncWrites = TRUE; #endif - /* Allocate and Initialize FLAIM Server Lock Manager. */ + // Allocate and Initialize FLAIM Server Lock Manager if ((gv_FlmSysData.pServerLockMgr = new ServerLockManager( &gv_FlmSysData.hServerLockMgrMutex)) == NULL) @@ -968,9 +982,9 @@ FLMEXP RCODE FLMAPI FlmStartup( void) iHandle = f_getpid(); // Initialize NICI + if (CCS_Init(&iHandle)) { - // Failure. rc = RC_SET( FERR_NICI_INIT_FAILED); goto Exit; } @@ -3753,7 +3767,7 @@ F_Session::~F_Session() { flmAssert( !m_pPrev); flmAssert( !m_pNext); - flmAssert( !m_i32RefCnt); + flmAssert( !getRefCount()); flmAssert( !m_uiThreadLockCount); // Wake up any waiters @@ -4166,7 +4180,7 @@ RCODE F_Session::lockSession( { RCODE rc = FERR_OK; - flmAssert( m_i32RefCnt); + flmAssert( getRefCount()); f_mutexLock( m_hMutex); if( m_uiThreadId && m_uiThreadId != f_threadId()) @@ -4199,7 +4213,7 @@ void F_Session::unlockSession() { F_SEM hSem; - flmAssert( m_i32RefCnt); + flmAssert( getRefCount()); f_mutexLock( m_hMutex); if( m_uiThreadId != f_threadId()) @@ -4250,8 +4264,8 @@ FLMINT F_Session::AddRef( void) FLMINT iRefCnt; f_mutexLock( m_hMutex); - flmAssert( m_i32RefCnt); - iRefCnt = F_Base::AddRef(); + flmAssert( getRefCount()); + iRefCnt = flmAtomicInc( &m_refCnt, m_hMutex, TRUE); f_mutexUnlock( m_hMutex); return( iRefCnt); @@ -4262,12 +4276,12 @@ Desc: Decrements the objects use count ****************************************************************************/ FLMINT F_Session::Release( void) { - FLMINT iRefCnt; + FLMINT iRefCnt; - flmAssert( m_i32RefCnt); + flmAssert( getRefCount()); f_mutexLock( m_hMutex); - if( (iRefCnt = --m_i32RefCnt) == 0) + if( (iRefCnt = flmAtomicDec( &m_refCnt, m_hMutex, TRUE)) == 0) { f_mutexUnlock( m_hMutex); delete this; diff --git a/flaim/src/ftk.h b/flaim/src/ftk.h index 332becb..45c665e 100644 --- a/flaim/src/ftk.h +++ b/flaim/src/ftk.h @@ -705,16 +705,16 @@ FLMUINT * allocatedNodes, FLMUINT * totalMemory); - LONG atomic_xchg( LONG *address, LONG value); + LONG atomic_xchg( volatile LONG * address, LONG value); - #define nlm_AtomicExchange( puiTarget, uiValue) \ - ((FLMUINT32)atomic_xchg( (LONG *)(puiTarget), (LONG)(uiValue))) + #define nlm_AtomicExchange( piTarget, iValue) \ + ((FLMINT32)atomic_xchg( (volatile LONG *)(piTarget), (LONG)(iValue))) - FLMUINT32 nlm_AtomicIncrement( - FLMUINT32 * puiTarget); + FLMINT32 nlm_AtomicIncrement( + volatile LONG * piTarget); - FLMUINT32 nlm_AtomicDecrement( - FLMUINT32 * puiTarget); + FLMINT32 nlm_AtomicDecrement( + volatile LONG * piTarget); #if !defined( __MWERKS__) #pragma aux nlm_AtomicIncrement parm [ecx]; @@ -734,38 +734,38 @@ modify exact [eax]; #else - FINLINE FLMUINT32 nlm_AtomicIncrement( - FLMUINT32 * puiTarget) + FINLINE FLMINT32 nlm_AtomicIncrement( + volatile LONG * piTarget) { - FLMUINT32 ui32Result; + FLMINT32 i32Result; __asm { mov eax, 1 - mov ecx, puiTarget + mov ecx, piTarget lock xadd [ecx], eax inc eax - mov ui32Result, eax + mov i32Result, eax } - return( ui32Result); + return( i32Result); } - FINLINE FLMUINT32 nlm_AtomicDecrement( - FLMUINT32 * puiTarget) + FINLINE FLMINT32 nlm_AtomicDecrement( + volatile LONG * piTarget) { - FLMUINT32 ui32Result; + FLMINT32 i32Result; __asm { mov eax, 0ffffffffh - mov ecx, puiTarget + mov ecx, piTarget lock xadd [ecx], eax dec eax - mov ui32Result, eax + mov i32Result, eax } - return( ui32Result); + return( i32Result); } #endif @@ -1790,228 +1790,82 @@ FLMINT f_timeCompareTimeStamps( unsigned f_timeGetMilliTime(); #endif -/**************************************************************************** -Desc: Atomic Increment, Decrement, Exchange Functions +/********************************************************************** +Desc: Atomic Increment, Decrement, Exchange Note: Some of this code is derived from the Ximian source code contained in that Mono project's atomic.h file. -****************************************************************************/ -#ifdef FLM_USE_SPIN_LOCK_ATOMICS - #undef FLM_USE_SPIN_LOCK_ATOMICS +**********************************************************************/ +#ifndef FLM_HAVE_ATOMICS + #define FLM_HAVE_ATOMICS #endif -#ifdef FLM_USE_MUTEX_ATOMICS - #undef FLM_USE_MUTEX_ATOMICS +/******************************************************************* +Desc: +*******************************************************************/ +#if defined( __GNUC__) && defined( __ia64__) +FINLINE FLMINT32 ia64_compare_and_swap( + volatile int * piTarget, + FLMINT32 i32NewVal, + FLMINT32 i32CompVal) +{ + FLMINT32 i32Old; + + asm volatile ("mov ar.ccv = %2 ;;\n\t" + "cmpxchg4.acq %0 = [%1], %3, ar.ccv\n\t" + : "=r" (i32Old) : "r" (piTarget), + "r" (i32CompVal), + "r" (i32NewVal)); + + return( i32Old); +} #endif -#if defined( FLM_NLM) +/********************************************************************** +Desc: +**********************************************************************/ +#if defined( FLM_AIX) +FINLINE int aix_atomic_add( + volatile int * piTarget, + int iDelta) +{ + return( fetch_and_add( (int *)piTarget, iDelta) + iDelta); +} +#endif - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicIncrement( - volatile FLMINT32 * pi32Target) +/********************************************************************** +Desc: +**********************************************************************/ +FINLINE FLMINT32 _flmAtomicInc( + FLMATOMIC * piTarget) +{ + #if defined( FLM_NLM) { - return( nlm_atomic_inc( pi32Target)); + return( (FLMINT32)nlm_atomic_inc( piTarget); } - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicDecrement( - volatile FLMINT32 * pi32Target) + #elif defined( FLM_WIN) { - return( nlm_atomic_dec( pi32Target)); + return( (FLMINT32)InterlockedIncrement( (volatile LONG *)piTarget)); } - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicExchange( - volatile FLMINT32 * pi32Target, - FLMINT32 i32NewVal) + #elif defined( FLM_AIX) { - return( atomic_xchg( pi32Target, i32NewVal)); + return( (FLMINT32)aix_atomic_add( piTarget, 1)); } - -#elif defined( FLM_WIN) - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicIncrement( - volatile FLMINT32 * pi32Target) + #elif defined( __GNUC__) { - return( InterlockedIncrement( (volatile LONG *)pi32Target)); - } - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicDecrement( - volatile FLMINT32 * pi32Target) - { - return( InterlockedDecrement( (volatile LONG *)pi32Target)); - } - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicExchange( - volatile FLMINT32 * pi32Target, - FLMINT32 i32NewVal) - { - return( InterlockedExchange( (volatile LONG *)pi32Target, i32NewVal)); - } - -#elif defined( FLM_AIX) - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE int aix_atomic_add( - volatile int * piTarget, - int iDelta) + #if defined( __i386__) || defined( __x86_64__) { - return( fetch_and_add( (int *)piTarget, iDelta) + iDelta); - } - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicIncrement( - volatile FLMINT32 * pi32Target) - { - return( aix_atomic_add( (int *)pi32Target, 1)); - } - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicDecrement( - volatile FLMINT32 * pi32Target) - { - return( aix_atomic_add( (int *)pi32Target, -1)); - } - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicExchange( - volatile FLMINT32 * pi32Target, - FLMINT32 i32NewVal) - { - int iOldVal; - - for( ;;) - { - iOldVal = *pi32Target; - - if( compare_and_swap( (int *)pi32Target, &iOldVal, (int)i32NewVal)) - { - break; - } - } - - return( iOldVal); - } - -#elif defined( FLM_HPUX) - - #define FLM_USE_MUTEX_ATOMICS - -#elif defined( __GNUC__) - - #if defined( __i386__) || defined( __x86_64__) - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicIncrement( - volatile FLMINT32 * pi32Target) - { - FLMINT32 i32Tmp; + FLMINT32 i32Tmp; __asm__ __volatile__ ("lock; xaddl %0, %1" - : "=r" (i32Tmp), "=m" (*pi32Target) - : "0" (1), "m" (*pi32Target)); + : "=r" (i32Tmp), "=m" (*piTarget) + : "0" (1), "m" (*piTarget); return( i32Tmp + 1); } - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicDecrement( - volatile FLMINT32 * pi32Target) + #elif defined( __ppc__) || defined ( __powerpc__) { - FLMINT32 i32Tmp; - - __asm__ __volatile__ ("lock; xaddl %0, %1" - : "=r" (i32Tmp), "=m" (*pi32Target) - : "0" (-1), "m" (*pi32Target)); - - return( i32Tmp - 1); - } - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicExchange( - volatile FLMINT32 * pi32Target, - FLMINT32 i32NewVal) - { - FLMINT32 i32Ret; - - __asm__ __volatile__ ("1:; lock; cmpxchgl %2, %0; jne 1b" - : "=m" (*pi32Target), "=a" (i32Ret) - : "r" (i32NewVal), "m" (*pi32Target), "a" (*pi32Target)); - - return( i32Ret); - } - - #elif defined( sparc) || defined ( __sparc__) - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE void begin_spin( - volatile unsigned char * pucLock) - { - int iTmp; - - __asm__ __volatile__("1: ldstub [%1],%0\n\t" \ - " cmp %0, 0\n\t" \ - " bne 1b\n\t" \ - " nop" \ - : "=&r" (iTmp) \ - : "r" (pucLock) \ - : "memory"); - } - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE void end_spin( - volatile unsigned char * pucLock) - { - __asm__ __volatile__("stb %%g0, [%0]" \ - : /* no outputs */ \ - : "r" (pucLock)\ - : "memory"); - } - - #define FLM_USE_SPIN_LOCK_ATOMICS - - #elif defined( __ppc__) || defined ( __powerpc__) - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicIncrement( - volatile FLMINT32 * pi32Target) - { - FLMINT32 i32Result = 0; - FLMINT32 i32Tmp; + FLMINT32 i32Result = 0; + FLMINT32 i32Tmp; __asm__ __volatile__ ("\n1:\n\t" "lwarx %0, 0, %2\n\t" @@ -2019,83 +1873,19 @@ Note: Some of this code is derived from the Ximian source code contained "stwcx. %1, 0, %2\n\t" "bne- 1b" : "=&b" (i32Result), "=&b" (i32Tmp) - : "r" (i32Target) : "cc", "memory"); + : "r" (piTarget) : "cc", "memory"); return( i32Result + 1); } - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicDecrement( - volatile FLMINT32 * pi32Target) + #elif defined( __ia64__) { - FLMINT32 i32Result = 0; - FLMINT32 i32Tmp; - - __asm__ __volatile__ ("\n1:\n\t" - "lwarx %0, 0, %2\n\t" - "addi %1, %0, -1\n\t" - "stwcx. %1, 0, %2\n\t" - "bne- 1b" - : "=&b" (i32Result), "=&b" (i32Tmp) - : "r" (pi32Target) : "cc", "memory"); - - return( i32Result - 1); - } - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicExchange( - volatile FLMINT32 * pi32Target, - FLMINT32 i32NewVal) - { - FLMINT32 i32Tmp = 0; - - __asm__ __volatile__ ("\n1:\n\t" - "lwarx %0, 0, %2\n\t" - "stwcx. %3, 0, %2\n\t" - "bne 1b" - : "=r" (i32Tmp) : "0" (i32Tmp), "b" (pi32Target), - "r" (i32NewVal) : "cc", "memory"); - - return( i32Tmp); - } - - #elif defined( __ia64__) - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ia64_compare_and_swap( - volatile FLMINT32 * pi32Target, - FLMINT32 i32NewVal, - FLMINT32 i32CompVal) - { - FLMINT32 i32Old; - - asm volatile ("mov ar.ccv = %2 ;;\n\t" - "cmpxchg4.acq %0 = [%1], %3, ar.ccv\n\t" - : "=r" (i32Old) : "r" (pi32Target), "r" (i32CompVal), - "r" (i32NewVal)); - - return( i32Old); - } - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicIncrement( - volatile FLMINT32 * pi32Target) - { - FLMINT32 i32Old; + FLMINT32 i32Old; for( ;;) { - i32Old = *pi32Target; + i32Old = (FLMINT32)*piTarget; - if( ia64_compare_and_swap( pi32Target, + if( ia64_compare_and_swap( piTarget, i32Old + 1, i32Old) == i32Old) { break; @@ -2104,61 +1894,9 @@ Note: Some of this code is derived from the Ximian source code contained return( i32Old + 1); } - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicDecrement( - volatile FLMINT32 * pi32Target) + #elif defined( __s390__) { - FLMINT32 i32Old; - - for( ;;) - { - i32Old = *pi32Target; - - if( ia64_compare_and_swap( pi32Target, - i32Old - 1, i32Old) == i32Old) - { - break; - } - } - - return( i32Old - 1); - } - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicExchange( - volatile FLMINT32 * pi32Target, - FLMINT32 i32NewVal) - { - FLMINT32 i32Result; - - for( ;;) - { - i32Result = *pi32Target; - - if( ia64_compare_and_swap( pi32Target, - i32NewVal, i32Result) == i32Result) - { - break; - } - } - - return( iResult); - } - - #elif defined( __s390__) - - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicIncrement( - volatile FLMINT32 * pi32Target) - { - FLMINT32 i32Tmp; + FLMINT32 i32Tmp; __asm__ __volatile__ ("\tLA\t2,%1\n" "0:\tL\t%0,%1\n" @@ -2167,19 +1905,89 @@ Note: Some of this code is derived from the Ximian source code contained "\tCS\t%0,1,0(2)\n" "\tJNZ\t0b\n" "\tLR\t%0,1" - : "=r" (i32Tmp), "+m" (*pi32Target) + : "=r" (i32Tmp), "+m" (*piTarget) : : "1", "2", "cc"); return( i32Tmp); } + #else + #ifdef FLM_HAVE_ATOMICS + #undef FLM_HAVE_ATOMICS + #endif + #endif + } + #else + #ifdef FLM_HAVE_ATOMICS + #undef FLM_HAVE_ATOMICS + #endif + #endif +} - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicDecrement( - volatile FLMINT32 * pi32Target) +/********************************************************************** +Desc: +**********************************************************************/ +FINLINE FLMINT32 _flmAtomicDec( + FLMATOMIC * piTarget) +{ + #if defined( FLM_NLM) + { + return( (FLMINT32)nlm_atomic_dec( piTarget)); + } + #elif defined( FLM_WIN) + { + return( (FLMINT32)InterlockedDecrement( (volatile LONG *)piTarget)); + } + #elif defined( FLM_AIX) + { + return( (FLMINT32)aix_atomic_add( piTarget, -1)); + } + #elif defined( __GNUC__) + { + #if defined( __i386__) || defined( __x86_64__) { - FLMINT32 i32Tmp; + FLMINT32 i32Tmp; + + __asm__ __volatile__ ("lock; xaddl %0, %1" + : "=r" (i32Tmp), "=m" (*piTarget) + : "0" (-1), "m" (*piTarget); + + return( i32Tmp - 1); + } + #elif defined( __ppc__) || defined ( __powerpc__) + { + FLMINT32 i32Result = 0; + FLMINT32 i32Tmp; + + __asm__ __volatile__ ("\n1:\n\t" + "lwarx %0, 0, %2\n\t" + "addi %1, %0, -1\n\t" + "stwcx. %1, 0, %2\n\t" + "bne- 1b" + : "=&b" (i32Result), "=&b" (i32Tmp) + : "r" (piTarget) : "cc", "memory"); + + return( i32Result - 1); + } + #elif defined( __ia64__) + { + FLMINT32 i32Old; + + for( ;;) + { + i32Old = (FLMINT32)*piTarget; + + if( ia64_compare_and_swap( piTarget, i32Old - 1, + i32Old) == i32Old) + { + break; + } + } + + return( i32Old - 1); + } + #elif defined( __s390__) + { + FLMINT32 i32Tmp; __asm__ __volatile__ ("\tLA\t2,%1\n" "0:\tL\t%0,%1\n" @@ -2188,161 +1996,236 @@ Note: Some of this code is derived from the Ximian source code contained "\tCS\t%0,1,0(2)\n" "\tJNZ\t0b\n" "\tLR\t%0,1" - : "=r" (i32Tmp), "+m" (*pi32Target) + : "=r" (i32Tmp), "+m" (*piTarget) : : "1", "2", "cc"); return( i32Tmp); } + #else + #ifdef FLM_HAVE_ATOMICS + #undef FLM_HAVE_ATOMICS + #endif + #endif + } + #else + #ifdef FLM_HAVE_ATOMICS + #undef FLM_HAVE_ATOMICS + #endif + #endif +} - /********************************************************************** - Desc: - **********************************************************************/ - FINLINE FLMINT32 ftkAtomicExchange( - volatile FLMINT32 * pi32Target, - FLMINT32 i32NewVal) +/********************************************************************** +Desc: +**********************************************************************/ +FINLINE FLMINT32 _flmAtomicExchange( + FLMATOMIC * piTarget, + FLMINT32 i32NewVal) +{ + #if defined( FLM_NLM) + { + return( (FLMINT32)atomic_xchg( piTarget, i32NewVal)); + } + #elif defined( FLM_WIN) + { + return( (FLMINT32)InterlockedExchange( (volatile LONG *)piTarget, + i32NewVal)); + } + #elif defined( FLM_AIX) + { + int iOldVal; + + for( ;;) + { + iOldVal = (int)*piTarget; + + if( compare_and_swap( piTarget, &iOldVal, i32NewVal)) + { + break; + } + } + + return( (FLMINT32)iOldVal); + } + #elif defined( __GNUC__) + { + #if defined( __i386__) || defined( __x86_64__) { - FLMINT32 i32Ret; + FLMINT32 i32Ret; + + __asm__ __volatile__ ("1:; lock; cmpxchgl %2, %0; jne 1b" + : "=m" (piTarget->iCounter), "=a" (i32Ret) + : "r" (i32NewVal), "m" (*piTarget), + "a" (*piTarget); + + return( i32Ret); + } + #elif defined( __ppc__) || defined ( __powerpc__) + { + FLMINT32 i32Tmp = 0; + + __asm__ __volatile__ ("\n1:\n\t" + "lwarx %0, 0, %2\n\t" + "stwcx. %3, 0, %2\n\t" + "bne 1b" + : "=r" (i32Tmp) : "0" (i32Tmp), + "b" (piTarget), + "r" (i32NewVal) : "cc", "memory"); + + return( i32Tmp); + } + #elif defined( __ia64__) + { + FLMINT32 i32Result; + + for( ;;) + { + i32Result = (FLMINT32)*piTarget; + + if( ia64_compare_and_swap( piTarget, + i32NewVal, i32Result) == i32Result) + { + break; + } + } + + return( i32Result); + } + #elif defined( __s390__) + { + FLMINT32 i32Ret; __asm__ __volatile__ ("\tLA\t1,%0\n" "0:\tL\t%1,%0\n" "\tCS\t%1,%2,0(1)\n" "\tJNZ\t0b" - : "+m" (*pi32Target), "=r" (i32Ret) + : "+m" (*piTarget), "=r" (i32Ret) : "r" (i32NewVal) : "1", "cc"); return( i32Ret); } - - #else - - #error Atomic operations are unsupported on this platform - - #endif - -#elif defined( FLM_SPARC) - - /************************************************************************* - Desc: - *************************************************************************/ - FINLINE void begin_spin( - volatile unsigned char * pucLock) - { - (void)pucLock; - - asm( "1: ldstub [%i0], %l0"); - asm( "cmp %l0,0"); - asm( "bne 1b"); - asm( "nop"); - } - - /************************************************************************* - Desc: - *************************************************************************/ - FINLINE void end_spin( - volatile unsigned char * pucLock) - { - *pucLock = 0; - } - - #define FLM_USE_SPIN_LOCK_ATOMICS - -#else - - #error Atomic operations are unsupported on this platform - -#endif - -#if defined( FLM_USE_SPIN_LOCK_ATOMICS) || defined( FLM_USE_MUTEX_ATOMICS) - - #if defined( FLM_USE_SPIN_LOCK_ATOMICS) - #if defined( FLM_SPARC) - extern volatile unsigned char gv_flmAtomicLock; + #else + #ifdef FLM_HAVE_ATOMICS + #undef FLM_HAVE_ATOMICS + #endif #endif - #elif defined( FLM_USE_MUTEX_ATOMICS) - extern pthread_mutex_t gv_flmAtomicLock; - #endif - - /************************************************************************* - Desc: - *************************************************************************/ - FINLINE FLMINT32 ftkAtomicIncrement( - volatile FLMINT32 * pi32Target) - { - FLMINT32 i32RetVal; - - #ifdef FLM_USE_SPIN_LOCK_ATOMICS - begin_spin( &gv_flmAtomicLock); - #else - pthread_mutex_lock( &gv_flmAtomicLock); - #endif - - (*pi32Target)++; - i32RetVal = *pi32Target; - - #ifdef FLM_USE_SPIN_LOCK_ATOMICS - end_spin( &gv_flmAtomicLock); - #else - pthread_mutex_unlock( &gv_flmAtomicLock); - #endif - - return( i32RetVal); } - - /************************************************************************* - Desc: - *************************************************************************/ - FINLINE FLMINT32 ftkAtomicDecrement( - volatile FLMINT32 * pi32Target) - { - FLMINT32 i32RetVal; - - #ifdef FLM_USE_SPIN_LOCK_ATOMICS - begin_spin( &gv_flmAtomicLock); #else - pthread_mutex_lock( &gv_flmAtomicLock); + #ifdef FLM_HAVE_ATOMICS + #undef FLM_HAVE_ATOMICS + #endif #endif - - (*pi32Target)--; - i32RetVal = *pi32Target; - - #ifdef FLM_USE_SPIN_LOCK_ATOMICS - end_spin( &gv_flmAtomicLock); - #else - pthread_mutex_unlock( &gv_flmAtomicLock); - #endif - - return( i32RetVal); - } - - /************************************************************************* - Desc: - *************************************************************************/ - FINLINE FLMINT32 ftkAtomicExchange( - volatile FLMINT32 * pi32Target, - FLMINT32 i32NewVal) - { - FLMINT32 i32RetVal; - - #ifdef FLM_USE_SPIN_LOCK_ATOMICS - begin_spin( &gv_flmAtomicLock); - #else - pthread_mutex_lock( &gv_flmAtomicLock); - #endif - - i32RetVal = *pi32Target; - *pi32Target = i32NewVal; +} - #ifdef FLM_USE_SPIN_LOCK_ATOMICS - end_spin( &gv_flmAtomicLock); - #else - pthread_mutex_unlock( &gv_flmAtomicLock); - #endif +/********************************************************************** +Desc: +**********************************************************************/ +FINLINE FLMINT32 flmAtomicInc( + FLMATOMIC * piTarget, + F_MUTEX hMutex = F_MUTEX_NULL, + FLMBOOL bMutexAlreadyLocked = FALSE) +{ + #ifdef FLM_HAVE_ATOMICS + F_UNREFERENCED_PARM( bMutexAlreadyLocked); + F_UNREFERENCED_PARM( hMutex); - return( i32RetVal); - } + return( _flmAtomicInc( piTarget)); + #else + { + FLMINT32 i32NewVal; + + flmAssert( hMutex != F_MUTEX_NULL); -#endif + if( !bMutexAlreadyLocked) + { + f_mutexLock( hMutex); + } + + i32NewVal = (FLMINT32)(++(*piTarget)); + + if( !bMutexAlreadyLocked) + { + f_mutexUnlock( hMutex); + } + + return( i32NewVal); + } + #endif +} + +/********************************************************************** +Desc: +**********************************************************************/ +FINLINE FLMINT32 flmAtomicDec( + FLMATOMIC * piTarget, + F_MUTEX hMutex = F_MUTEX_NULL, + FLMBOOL bMutexAlreadyLocked = FALSE) +{ + #ifdef FLM_HAVE_ATOMICS + F_UNREFERENCED_PARM( bMutexAlreadyLocked); + F_UNREFERENCED_PARM( hMutex); + + return( _flmAtomicDec( piTarget)); + #else + { + FLMINT32 i32NewVal; + + flmAssert( hMutex != F_MUTEX_NULL); + + if( !bMutexAlreadyLocked) + { + f_mutexLock( hMutex); + } + + i32NewVal = (FLMINT32)(--(*piTarget)); + + if( !bMutexAlreadyLocked) + { + f_mutexUnlock( hMutex); + } + + return( i32NewVal); + } + #endif +} + +/********************************************************************** +Desc: +**********************************************************************/ +FINLINE FLMINT32 flmAtomicExchange( + FLMATOMIC * piTarget, + FLMINT32 i32NewVal, + F_MUTEX hMutex = F_MUTEX_NULL, + FLMBOOL bMutexAlreadyLocked = FALSE) +{ + #ifdef FLM_HAVE_ATOMICS + F_UNREFERENCED_PARM( bMutexAlreadyLocked); + F_UNREFERENCED_PARM( hMutex); + + return( _flmAtomicExchange( piTarget, i32NewVal)); + #else + { + FLMINT32 i32OldVal; + + flmAssert( hMutex != F_MUTEX_NULL); + + if( !bMutexAlreadyLocked) + { + f_mutexLock( hMutex); + } + + i32OldVal = (FLMINT32)*piTarget; + *piTarget = i32NewVal; + + if( !bMutexAlreadyLocked) + { + f_mutexUnlock( hMutex); + } + + return( i32OldVal); + } + #endif +} /**************************************************************************** Pseudo Serial Numbers diff --git a/flaim/src/ftkthrd.cpp b/flaim/src/ftkthrd.cpp index d37abda..33652a2 100644 --- a/flaim/src/ftkthrd.cpp +++ b/flaim/src/ftkthrd.cpp @@ -56,7 +56,7 @@ FLMINT F_Thread::AddRef( f_mutexLock( m_hMutex); } - iRefCnt = ++m_i32RefCnt; + iRefCnt = F_Base::AddRef(); if( !bMutexLocked) { @@ -73,16 +73,19 @@ FLMINT F_Thread::Release( FLMBOOL bMutexLocked) { FLMINT iRefCnt; + FLMBOOL bUnlockMutex = FALSE; if( !bMutexLocked && m_hMutex != F_MUTEX_NULL) { f_mutexLock( m_hMutex); + bUnlockMutex = TRUE; + bMutexLocked = TRUE; } - flmAssert( m_i32RefCnt > 0); - iRefCnt = --m_i32RefCnt; + flmAssert( getRefCount() > 0); + iRefCnt = flmAtomicDec( &m_refCnt, m_hMutex, bMutexLocked); - if( !bMutexLocked && m_hMutex != F_MUTEX_NULL) + if( bUnlockMutex) { f_mutexUnlock( m_hMutex); } diff --git a/flaim/src/ftrace.cpp b/flaim/src/ftrace.cpp index dad1736..a40107b 100644 --- a/flaim/src/ftrace.cpp +++ b/flaim/src/ftrace.cpp @@ -68,8 +68,9 @@ FLMINT FlmTrace::AddRef( void) FLMINT iRefCnt; lock(); - iRefCnt = ++m_i32RefCnt; + iRefCnt = flmAtomicInc( &m_refCnt, m_hMutex, TRUE); unlock(); + return( iRefCnt); } @@ -82,7 +83,7 @@ FLMINT FlmTrace::Release( void) FLMINT iRefCnt; lock(); - iRefCnt = --m_i32RefCnt; + iRefCnt = flmAtomicDec( &m_refCnt, m_hMutex, TRUE); unlock(); if( !iRefCnt) diff --git a/flaim/src/imonfhdl.cpp b/flaim/src/imonfhdl.cpp index 2b8906c..eaff34e 100644 --- a/flaim/src/imonfhdl.cpp +++ b/flaim/src/imonfhdl.cpp @@ -303,7 +303,6 @@ Desc: Function to display the private data on a WIN32 platform void F_FileHdlPage::write_data( F_FileHdlImp * pFileHdl) { - F_Base * pBase; F_ListItem * pListItem; F_FileHdlImpBase * pFileHdlBase; char szAddress[20]; @@ -564,19 +563,6 @@ void F_FileHdlPage::write_data( (char *)(pListItem->m_bInList ? "Yes" : "No"), (bHighlight = ~bHighlight)); - // Now for the final base class - F_Base - pBase = (F_Base *)pListItem; - - // m_i32RefCnt - printHTMLInt( - "F_Base.m_i32RefCnt", - "FLMINT32", - (void *)pBase, - (void *)&pBase->m_i32RefCnt, - pBase->m_i32RefCnt, - (bHighlight = ~bHighlight)); - - printTableEnd(); } diff --git a/flaim/src/imonfmgr.cpp b/flaim/src/imonfmgr.cpp index e4b2dd5..c654e37 100644 --- a/flaim/src/imonfmgr.cpp +++ b/flaim/src/imonfmgr.cpp @@ -40,7 +40,6 @@ RCODE F_FileHdlMgrPage::display( char szTemp[20]; FLMUINT uiLoop; FLMBOOL bRefresh = FALSE; - F_Base * pBase; char szAddress[20]; FLMBOOL bHighlight = FALSE; FLMBYTE * pszTemp = NULL; @@ -244,20 +243,6 @@ RCODE F_FileHdlMgrPage::display( pFileHdlMgr->m_uiFileIdCounter, (bHighlight = ~bHighlight)); - // Now show the private member(s) of the F_Base class - - pBase = (F_Base *)pFileHdlMgr; - - // m_i32RefCnt - printHTMLInt( - "F_Base.m_i32RefCnt", - "FLMINT32", - (void *)pBase, - (void *)&pBase->m_i32RefCnt, - pBase->m_i32RefCnt, - (bHighlight = ~bHighlight)); - - printTableEnd();