fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a67b63175a084d5d1fb6cd67bbd64ae2d7bdb4df
harbour-core/harbour/include/hbatomic.h
Przemyslaw Czerpak 9169e0e94f 2009-07-03 08:28 UTC+0200 Przemyslaw Czerpak (druzus/at/priv.onet.pl) 
+ harbour/include/hbtask.h
  + harbour/source/vm/task.c
  * harbour/include/hbthread.h
  * harbour/include/hbatomic.h
  * harbour/source/vm/thread.c
  * harbour/source/vm/hvm.c
  * harbour/source/vm/fm.c
  * harbour/source/rtl/idle.c
  * harbour/source/rtl/filesys.c
    + implemented OS independent task switching system - it gives PTHREAD
      compatible basic API so it can be used in HVM as alternative MT support
      which does not use any OS threads. As long as Harbour does not call
      any blocking OS function then it's possible to create and execute
      simultaneously many threads though only one CPU is used and switched
      between HVM threads. It gives similar scalability to xbase++ threads
      and also similar behavior in item protection at .prg level.
      Now it's possible to use HVM threads in any OS.
      Of course it does not mean that Harbour adds in some magic way
      thread support to OS-es which does not support threads like DOS.
      It only means that HVM supports threads for .prg code just like
      in native MT environment as long as some C code does not block
      task switching or process execution will not be frozen by sth, i.e.
      executing other process (__run()) in single process OS like DOS.
      In some cases it can be interesting alternative even in OS which
      have native thread support.
      All tests/mttest*.prg programs and speedtst --thread=<n> --scale
      are executed correctly with new task switching just like with
      OS native MT support.
      Compilation with task switching in hbvmmt library can be forced
      by HB_TASK_THREAD macro which also disable native OS threads
      support.
      For task context switching two alternative methods are used:
         1) getcontext()/makecontext()/swapcontext() (SUSv2, POSIX.1-2001)
            which is preferable because does not need any additional
            hacks but not all OS-es supports these functions.
            It's enabled by default in Linux builds.
         2) setjmp()/longjmp() (POSIX, ISO 9899 (C99)) otherwise.
            These functions are supported by most of C compilers
            but there is no function to set new stack in saved context
            so it's necessary to introduce for each architecure/C compiler
            peace of code which makes it. Macro HB_TASK_STACK_INIT() in
            task.c makes it. I defined this macro for x86@32 in DJGPP
            Linux GCC and OpenWatcom builds. I tested OpenWatcom builds only
            in DOS and Linux but probably it works in all x86@32 builds.
            If someone is interesting in adding support for some other
            platforms which does not support ucontext.h and 1-st methods
            then please define above macro for them.

      Have a fun with new toy ;-)

  * harbour/source/vm/Makefile
    * enabled hbvmmt in DJGPP and OpenWatcom DOS builds. It works well.
      Viktor if possible please add support for -mt switch in hbmk2
      in all builds even if we do not compile hbvmmt by default so
      it can be used with DJGPP and OW and any other builds for which
      someone enable hbtask.c though OS does not support threads.

  * harbour/contrib/hbmzip/hbmzip.c
    ! fixed '[const] char|BYTE *' casting in DOS and OS2 builds
2009-07-03 06:29:26 +00:00

419 lines
13 KiB
C
Raw Blame History

/*
* $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 )
# 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 ) && !defined( __WATCOMC__ )
# 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_TASK_THREAD )
hb_taskYield();
#elif defined( HB_OS_WIN )
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 ( ( __GNUC__ > 4 ) || ( __GNUC__ == 4 && __GNUC_MINOR__ >= 1) )
# define HB_ATOM_INC( p ) __sync_add_and_fetch( (p), 1 )
# define HB_ATOM_DEC( p ) __sync_sub_and_fetch( (p), 1 )
# define HB_ATOM_GET( p ) ( *(p) )
# define HB_ATOM_SET( p, n ) do { *(p) = (n); } while(0)
static __inline__ void hb_spinlock_acquire( int * l )
{
for( ;; )
{
if( !__sync_lock_test_and_set( l, 1 ) )
return;
#ifdef HB_SPINLOCK_SLEEP
if( !__sync_lock_test_and_set( l, 1 ) )
return;
#if defined( HB_TASK_THREAD )
hb_taskYield();
#elif defined( HB_OS_WIN )
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
}
}
# define HB_SPINLOCK_T int
# define HB_SPINLOCK_INIT 0
# define HB_SPINLOCK_ACQUIRE(l) hb_spinlock_acquire(l)
# define HB_SPINLOCK_RELEASE(l) __sync_lock_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?? */
#elif defined( _MSC_VER )
# if defined( i386 ) || defined( __i386__ ) || defined( _M_IX86 )
# if HB_COUNTER_SIZE == 4
static __inline void hb_atomic_inc32( volatile int * p )
{
__asm mov eax, p
__asm lock inc dword ptr [eax]
}
static __inline int hb_atomic_dec32( volatile int * p )
{
unsigned char c;
__asm mov eax, p
__asm lock dec dword ptr [eax]
__asm setne c
return c;
}
# 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 /* x86 */
#elif defined( __WATCOMC__ ) && defined( __cplusplus )
# if defined( i386 ) || defined( __i386__ ) || defined( __x86_64__ ) || \
defined( _M_IX86 ) || defined( _M_AMD64 )
# if HB_COUNTER_SIZE == 4
static inline void hb_atomic_inc32( volatile int * p )
{
_asm {
mov eax, p
lock inc dword ptr [eax]
}
}
static inline int hb_atomic_dec32( volatile int * p )
{
unsigned char c;
_asm {
mov eax, p
lock dec dword ptr [eax]
setne c
}
return c;
}
# 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 /* x86 */
#endif /* ??? C compiler ??? */
#if defined( HB_OS_WIN )
/* 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((int64_t *)(p)))
# define HB_ATOM_DEC( p ) (OSAtomicDecrement64((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((int32_t *)(p)))
# define HB_ATOM_DEC( p ) (OSAtomicDecrement32((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_OS_??? */
HB_EXTERN_END
#endif /* HB_ATOMIC_H_ */
Reference in New Issue View Git Blame Copy Permalink