fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2008-10-07 02:57 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl)

Browse Source 
* 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
This commit is contained in:
Przemyslaw Czerpak
2008-10-07 00:57:54 +00:00
parent 5b75b78079
commit e1ea6f3cec
6 changed files with 330 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
harbour/ChangeLog
View File

@@ -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.

1
harbour/include/Makefile
View File

@@ -18,6 +18,7 @@ C_HEADERS=\
hbapilng.h \
hbapirdd.h \
hbassert.h \
hbatomic.h \
hbchksum.h \
hbcomp.h \
hbcompdf.h \

302
harbour/include/hbatomic.h Normal file
View File

@@ -0,0 +1,302 @@
/*
* $Id$
*/
/*
* Harbour Project source code:
* header file with functions for atomic operations
*
* Copyright 2008 Przemyslaw Czerpak <druzus / at / priv.onet.pl>
* 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 <windows.h>
#elif defined( HB_OS_DARWIN )
# include <libkern/OSAtomic.h>
#endif
#if defined( __SVR4 )
# include <thread.h>
#endif
#if defined( HB_OS_UNIX )
# include <sched.h>
#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_ */

50
harbour/include/hbthread.h
View File

@@ -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

1
harbour/source/vm/fm.c
View File

@@ -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 )

64
harbour/source/vm/garbage.c
View File

@@ -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 <sched.h>
# 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