diff --git a/harbour/ChangeLog b/harbour/ChangeLog index f60a9e14ba..c693b1ab9e 100644 --- a/harbour/ChangeLog +++ b/harbour/ChangeLog @@ -8,6 +8,20 @@ 2008-12-31 13:59 UTC+0100 Foo Bar (foo.bar foobar.org) */ +2008-10-07 02:57 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl) + * harbour/include/Makefile + + harbour/include/hbatomic.h + * harbour/include/hbthread.h + * harbour/source/vm/garbage.c + * harbour/source/vm/fm.c + * moved atomic and spinlock functions into hbatomic.h + + * harbour/include/hbatomic.h + + added atomic inc/dec for GCC and x86@64 and PPC@32 + + use OSAtomic*() and OSSpin*() functions for atomic inc/dec and + spinlocks in Darwin builds + + added spinlocks to MS-Win builds + 2008-10-06 22:33 UTC+0200 Viktor Szakats (harbour.01 syenar hu) * source/rtl/tobject.prg ! Formatting to some old code. diff --git a/harbour/include/Makefile b/harbour/include/Makefile index 0b64be06ef..004a50a39f 100644 --- a/harbour/include/Makefile +++ b/harbour/include/Makefile @@ -18,6 +18,7 @@ C_HEADERS=\ hbapilng.h \ hbapirdd.h \ hbassert.h \ + hbatomic.h \ hbchksum.h \ hbcomp.h \ hbcompdf.h \ diff --git a/harbour/include/hbatomic.h b/harbour/include/hbatomic.h new file mode 100644 index 0000000000..25b779c61b --- /dev/null +++ b/harbour/include/hbatomic.h @@ -0,0 +1,302 @@ +/* + * $Id$ + */ + +/* + * Harbour Project source code: + * header file with functions for atomic operations + * + * Copyright 2008 Przemyslaw Czerpak + * www - http://www.harbour-project.org + * + * This program 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, or (at your option) + * any later version. + * + * This program 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 this software; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, + * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). + * + * As a special exception, the Harbour Project gives permission for + * additional uses of the text contained in its release of Harbour. + * + * The exception is that, if you link the Harbour libraries with other + * files to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public License. + * Your use of that executable is in no way restricted on account of + * linking the Harbour library code into it. + * + * This exception does not however invalidate any other reasons why + * the executable file might be covered by the GNU General Public License. + * + * This exception applies only to the code released by the Harbour + * Project under the name Harbour. If you copy code from other + * Harbour Project or Free Software Foundation releases into a copy of + * Harbour, as the General Public License permits, the exception does + * not apply to the code that you add in this way. To avoid misleading + * anyone as to the status of such modified files, you must delete + * this exception notice from them. + * + * If you write modifications of your own for Harbour, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * + */ + +#ifndef HB_ATOMIC_H_ +#define HB_ATOMIC_H_ + +#include "hbdefs.h" + +#if defined( HB_OS_WIN_32 ) +# include +#elif defined( HB_OS_DARWIN ) +# include +#endif +#if defined( __SVR4 ) +# include +#endif +#if defined( HB_OS_UNIX ) +# include +#endif + + +HB_EXTERN_BEGIN + +/* Inline assembler version of atomic operations on memory reference counters */ +#if defined( __GNUC__ ) + +# if ( defined( i386 ) || defined( __i386__ ) || defined( __x86_64__ ) ) + +# if HB_COUNTER_SIZE == 4 + + static __inline__ void hb_atomic_inc32( volatile int * p ) + { + __asm__ __volatile__( + "lock; incl %0\n" + :"=m" (*p) :"m" (*p) + ); + } + + static __inline__ int hb_atomic_dec32( volatile int * p ) + { + unsigned char c; + __asm__ __volatile__( + "lock; decl %0\n" + "sete %1\n" + :"=m" (*p), "=qm" (c) :"m" (*p) : "memory" + ); + return c == 0; + } + +# define HB_ATOM_INC( p ) ( hb_atomic_inc32( ( volatile int * ) (p) ) ) +# define HB_ATOM_DEC( p ) ( hb_atomic_dec32( ( volatile int * ) (p) ) ) +# define HB_ATOM_GET( p ) (*(int volatile *)(p)) +# define HB_ATOM_SET( p, n ) do { (*(int volatile *)(p)) = (n); } while(0) + +# elif HB_COUNTER_SIZE == 8 + + static __inline__ void hb_atomic_inc64( volatile long long int * p ) + { + __asm__ __volatile__( + "lock; incq %0\n" + :"=m" (*p) :"m" (*p) + ); + } + + static __inline__ int hb_atomic_dec64( volatile long long int * p ) + { + unsigned char c; + __asm__ __volatile__( + "lock; decq %0\n" + "sete %1\n" + :"=m" (*p), "=qm" (c) :"m" (*p) : "memory" + ); + return c == 0; + } + +# define HB_ATOM_INC( p ) ( hb_atomic_inc64( ( volatile long long int * ) (p) ) ) +# define HB_ATOM_DEC( p ) ( hb_atomic_dec64( ( volatile long long int * ) (p) ) ) +# define HB_ATOM_GET( p ) (*(long long int volatile *)(p)) +# define HB_ATOM_SET( p, n ) do { (*(long long int volatile *)(p)) = (n); } while(0) + +# endif + + static __inline__ int hb_spinlock_trylock( volatile int * p ) + { + int i = 1; + __asm__ __volatile__( + "xchgl %0, %1\n\t" + : "=r" (i) + : "m" (*p), "0" (i) + : "memory" + ); + return i; + } + + static __inline__ void hb_spinlock_acquire( volatile int * l ) + { + for( ;; ) + { + if( !hb_spinlock_trylock( l ) ) + return; + + #ifdef HB_SPINLOCK_SLEEP + if( !hb_spinlock_trylock( l ) ) + return; + #if defined( HB_OS_WIN_32 ) + Sleep( 0 ); + #elif defined( HB_OS_OS2 ) + DosSleep( 0 ); + #elif defined( __SVR4 ) + thr_yield(); + #elif defined( HB_OS_UNIX ) + sched_yield(); + #else + sleep( 0 ); + #endif + #endif + } + } + + static __inline__ void hb_spinlock_release( volatile int * l ) + { + *l = 0; + } + +# define HB_SPINLOCK_T volatile int +# define HB_SPINLOCK_INIT 0 +# define HB_SPINLOCK_ACQUIRE(l) hb_spinlock_acquire(l) +# define HB_SPINLOCK_RELEASE(l) hb_spinlock_release(l) + +# elif defined( __powerpc__ ) || defined( __ppc ) + +# if HB_COUNTER_SIZE == 4 + + static __inline__ void hb_atomic_inc32( volatile int * p ) + { + int i; + + __asm__ __volatile__( + "1: lwarx %0,0,%2\n\t" + " addic %0,%0,1\n\t" + " stwcx. %0,0,%2\n\t" + " bne- 1b\n\t" + : "=&r" (i), "=m" (*p) : "r" (p), "m" (*p) : "cc" + ); + } + + static __inline__ int hb_atomic_dec32( volatile int * p ) + { + int i; + + __asm__ __volatile__( + "1: lwarx %0,0,%1\n\t" + " addic %0,%0,-1\n\t" + " stwcx. %0,0,%1\n\t" + " bne- 1b\n\t" + " isync\n\t" + : "=&r" (i) : "r" (p) : "cc", "memory" + ); + return i; + } + +# define HB_ATOM_INC( p ) ( hb_atomic_inc32( ( volatile int * ) (p) ) ) +# define HB_ATOM_DEC( p ) ( hb_atomic_dec32( ( volatile int * ) (p) ) ) +# define HB_ATOM_GET( p ) (*(int volatile *)(p)) +# define HB_ATOM_SET( p, n ) do { (*(int volatile *)(p)) = (n); } while(0) + +# elif HB_COUNTER_SIZE == 8 + + /* TODO: */ + +# endif + +# endif /* ???CPU?? */ + +#endif + + +#if defined( HB_OS_WIN_32 ) + + /* Atomic operations on memory reference counters */ +# if !defined( HB_ATOM_INC ) || !defined( HB_ATOM_DEC ) +# undef HB_ATOM_DEC +# undef HB_ATOM_INC +# undef HB_ATOM_GET +# undef HB_ATOM_SET +# if HB_COUNTER_SIZE == 8 +# define HB_ATOM_INC( p ) (InterlockedIncrement64((LONGLONG *)(p))) +# define HB_ATOM_DEC( p ) (InterlockedDecrement64((LONGLONG *)(p))) +# define HB_ATOM_GET( p ) (*(LONGLONG volatile *)(p)) +# define HB_ATOM_SET( p, n ) do { (*(LONGLONG volatile *)(p)) = (n); } while(0) +# else +# define HB_ATOM_INC( p ) (InterlockedIncrement((LONG *)(p))) +# define HB_ATOM_DEC( p ) (InterlockedDecrement((LONG *)(p))) +# define HB_ATOM_GET( p ) (*(LONG volatile *)(p)) +# define HB_ATOM_SET( p, n ) do { (*(LONG volatile *)(p)) = (n); } while(0) +# endif +# endif + + /* Spin locks */ +# if !defined( HB_SPINLOCK_T ) +# define HB_SPINLOCK_T volatile LONG +# define HB_SPINLOCK_INIT 0 +# define HB_SPINLOCK_ACQUIRE(l) do { \ + for( ;; ) \ + { \ + if( !InterlockedExchange( (LONG *)(l), 1 ) ) \ + break; \ + if( !InterlockedExchange( (LONG *)(l), 1 ) ) \ + break; \ + Sleep( 0 ); \ + } \ + } while(0) +# define HB_SPINLOCK_RELEASE(l) do { *(l) = 0; } while(0) +# endif + +#elif defined( HB_OS_DARWIN ) + + /* Atomic operations on memory reference counters */ +# if !defined( HB_ATOM_INC ) || !defined( HB_ATOM_DEC ) +# undef HB_ATOM_DEC +# undef HB_ATOM_INC +# undef HB_ATOM_GET +# undef HB_ATOM_SET +# if HB_COUNTER_SIZE == 8 +# define HB_ATOM_INC( p ) (OSAtomicIncrement64((volatile int64_t *)(p))) +# define HB_ATOM_DEC( p ) (OSAtomicDecrement64((volatile int64_t *)(p))) +# define HB_ATOM_GET( p ) (*(int64_t volatile *)(p)) +# define HB_ATOM_SET( p, n ) do { (*(int64_t volatile *)(p)) = (n); } while(0) +# else +# define HB_ATOM_INC( p ) (OSAtomicIncrement32((volatile int32_t *)(p))) +# define HB_ATOM_DEC( p ) (OSAtomicDecrement32((volatile int32_t *)(p))) +# define HB_ATOM_GET( p ) (*(volatile int32_t *)(p)) +# define HB_ATOM_SET( p, n ) do { (*(volatile int32_t *)(p)) = (n); } while(0) +# endif +# endif + + /* Spin locks */ +# if !defined( HB_SPINLOCK_T ) || 1 /* <= force using OSSpinLock */ +# undef HB_SPINLOCK_T +# undef HB_SPINLOCK_INIT +# undef HB_SPINLOCK_ACQUIRE +# undef HB_SPINLOCK_RELEASE +# define HB_SPINLOCK_T OSSpinLock +# define HB_SPINLOCK_INIT OS_SPINLOCK_INIT +# define HB_SPINLOCK_ACQUIRE(l) OSSpinLockLock(l) +# define HB_SPINLOCK_RELEASE(l) OSSpinLockUnlock(l) +# endif + +#endif + +HB_EXTERN_END + +#endif /* HB_ATOMIC_H_ */ diff --git a/harbour/include/hbthread.h b/harbour/include/hbthread.h index c3b8aec640..04e50f7df5 100644 --- a/harbour/include/hbthread.h +++ b/harbour/include/hbthread.h @@ -67,37 +67,6 @@ HB_EXTERN_BEGIN -/* Inline assembler version of atomic operations on memory reference counters */ -#if HB_COUNTER_SIZE == 4 && defined( __GNUC__ ) && \ - ( defined( i386 ) || defined( __i386__ ) || defined( __x86_64__ ) ) - - static __inline__ void hb_atomic_inc32( volatile int * p ) - { - __asm__ __volatile__( - "lock; incl %0\n" - :"=m" (*p) :"m" (*p) - ); - } - - static __inline__ int hb_atomic_dec32( volatile int * p ) - { - unsigned char c; - __asm__ __volatile__( - "lock; decl %0\n" - "sete %1\n" - :"=m" (*p), "=qm" (c) :"m" (*p) : "memory" - ); - return c == 0; - } - -# define HB_ATOM_INC( p ) ( hb_atomic_inc32( ( volatile int * ) (p) ) ) -# define HB_ATOM_DEC( p ) ( hb_atomic_dec32( ( volatile int * ) (p) ) ) -# define HB_ATOM_GET( p ) (*(int volatile *)(p)) -# define HB_ATOM_SET( p, n ) do { (*(int volatile *)(p)) = (n); } while(0) - -#endif - - #if defined( HB_PTHREAD_API ) typedef HB_LONG HB_THREAD_NO; @@ -166,25 +135,6 @@ HB_EXTERN_BEGIN # define HB_COND_WAIT(v) ( WaitForSingleObject( (v), INFINITE ) != WAIT_FAILED ) # define HB_COND_TIMEDWAIT(v,n) ( WaitForSingleObject( (v), (n) ) != WAIT_FAILED ) - /* Atomic operations on memory reference counters */ -# if !defined( HB_ATOM_INC ) || !defined( HB_ATOM_DEC ) -# undef HB_ATOM_DEC -# undef HB_ATOM_INC -# undef HB_ATOM_GET -# undef HB_ATOM_SET -# if HB_COUNTER_SIZE == 8 -# define HB_ATOM_INC( p ) (InterlockedIncrement64((LONGLONG *)(p))) -# define HB_ATOM_DEC( p ) (InterlockedDecrement64((LONGLONG *)(p))) -# define HB_ATOM_GET( p ) (*(LONGLONG volatile *)(p)) -# define HB_ATOM_SET( p, n ) do { (*(LONGLONG volatile *)(p)) = (n); } while(0) -# else -# define HB_ATOM_INC( p ) (InterlockedIncrement((LONG *)(p))) -# define HB_ATOM_DEC( p ) (InterlockedDecrement((LONG *)(p))) -# define HB_ATOM_GET( p ) (*(LONG volatile *)(p)) -# define HB_ATOM_SET( p, n ) do { (*(LONG volatile *)(p)) = (n); } while(0) -# endif -# endif - #elif defined( HB_OS_OS2 ) /* In OS2 thread ID is continuous integer number so we can use it directly diff --git a/harbour/source/vm/fm.c b/harbour/source/vm/fm.c index 290a5077c7..ca86c24d5d 100644 --- a/harbour/source/vm/fm.c +++ b/harbour/source/vm/fm.c @@ -99,6 +99,7 @@ #include "hbset.h" #if defined( HB_MT_VM ) # include "hbthread.h" +# include "hbatomic.h" #endif #if defined( HB_FM_STD_ALLOC ) diff --git a/harbour/source/vm/garbage.c b/harbour/source/vm/garbage.c index 9504ad4404..58a2e3a630 100644 --- a/harbour/source/vm/garbage.c +++ b/harbour/source/vm/garbage.c @@ -67,64 +67,24 @@ #if defined( HB_MT_VM ) +# define HB_SPINLOCK_SLEEP + # include "hbthread.h" +# include "hbatomic.h" -/* Performance test. Use spinlock instead of mutex in OS2 builds */ +/* Use spinlock instead of mutex in OS2 builds */ -#if defined( __GNUC__ ) && \ - ( defined( i386 ) || defined( __i386__ ) || defined( __x86_64__ ) ) +# if defined( HB_SPINLOCK_INIT ) -# if defined( HB_OS_UNIX ) -# include -# endif + HB_SPINLOCK_T s_gcSpinLock = HB_SPINLOCK_INIT; +# define HB_GC_LOCK HB_SPINLOCK_ACQUIRE( &s_gcSpinLock ); +# define HB_GC_UNLOCK HB_SPINLOCK_RELEASE( &s_gcSpinLock ); - static __inline__ int hb_atomic_lock( volatile int * p ) - { - int i = 0; - __asm__ __volatile__( - "xchgl %0, %1\n\t" - : "=r" (i) - : "m" (*p), "0" (i) - : "memory" - ); - return i; - } +# else - static volatile int s_gcSpinLock = 1; - - static void hb_gc_acquire_lock( void ) - { - for( ;; ) - { - if( hb_atomic_lock( &s_gcSpinLock ) ) - return; -#if defined( HB_OS_WIN_32 ) - Sleep( 0 ); -#elif defined( HB_OS_OS2 ) - DosSleep( 0 ); -#elif defined( __SVR4 ) - thr_yield(); -#elif defined( HB_OS_UNIX ) - sched_yield(); -#else - sleep( 0 ); -#endif - } - } - - static __inline__ void hb_gc_release_lock( void ) - { - s_gcSpinLock = 1; - } - -# define HB_GC_LOCK hb_gc_acquire_lock(); -# define HB_GC_UNLOCK hb_gc_release_lock(); - -#else - - static HB_CRITICAL_NEW( s_gcMtx ); -# define HB_GC_LOCK hb_threadEnterCriticalSection( &s_gcMtx ); -# define HB_GC_UNLOCK hb_threadLeaveCriticalSection( &s_gcMtx ); + static HB_CRITICAL_NEW( s_gcMtx ); +# define HB_GC_LOCK hb_threadEnterCriticalSection( &s_gcMtx ); +# define HB_GC_UNLOCK hb_threadLeaveCriticalSection( &s_gcMtx ); #endif