fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
6150fa9aa2df2a2673ea2accf6a0f180c787c4e6
harbour-core/harbour/include/hbthread.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

456 lines
16 KiB
C
Raw Blame History

/*
* $Id$
*/
/*
* Harbour Project source code:
* header file with MT mode functions
*
* 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_THREAD_H_
#define HB_THREAD_H_
#include "hbapi.h"
#include "hbset.h"
#if defined( HB_TASK_THREAD )
/* Harbour tasks explicitly requested */
#elif ( defined( HB_OS_LINUX ) && defined( __WATCOMC__ ) ) || \
defined( HB_OS_DOS )
# define HB_TASK_THREAD
#elif defined( HB_OS_LINUX ) || defined( HB_OS_DARWIN ) || \
defined( HB_OS_SUNOS ) || defined( HB_OS_HPUX )
# include <pthread.h>
# define HB_PTHREAD_API
#elif defined( HB_OS_WIN )
# include <windows.h>
# include <process.h>
#elif defined( HB_OS_OS2 )
# if defined( __WATCOMC__ )
# include <process.h>
# endif
#endif
HB_EXTERN_BEGIN
#if defined( HB_TASK_THREAD )
# include "hbtask.h"
typedef HB_LONG HB_THREAD_NO;
typedef void * HB_THREAD_ID;
typedef void * HB_CRITICAL_T;
typedef void * HB_COND_T;
typedef void * HB_THREAD_HANDLE;
typedef HB_CRITICAL_T HB_RAWCRITICAL_T;
typedef HB_COND_T HB_RAWCOND_T;
# define HB_COND_OS_SUPPORT
# undef HB_COND_HARBOUR_SUPPORT
# undef HB_COND_NEED_INIT
# undef HB_CRITICAL_NEED_INIT
# define HB_THREAD_STARTFUNC( func ) void * func( void * Cargo )
# define HB_THREAD_END return NULL;
# define HB_THREAD_RAWEND return NULL;
# define HB_THREAD_INFINITE_WAIT HB_TASK_INFINITE_WAIT
# define HB_THREAD_SELF() hb_taskSelf()
# define HB_THREAD_SHEDULER() hb_taskSheduler()
# define HB_CRITICAL_NEW( name ) HB_CRITICAL_T name = NULL
# define HB_CRITICAL_INIT(v) do { (v) = NULL; } while( 0 )
# define HB_CRITICAL_DESTROY(v) hb_taskDestroyMutex( &(v) )
# define HB_CRITICAL_LOCK(v) hb_taskLock( &(v), HB_TASK_INFINITE_WAIT )
# define HB_CRITICAL_UNLOCK(v) hb_taskUnlock( &(v) )
# define HB_COND_NEW( name ) HB_COND_T name = NULL
# define HB_COND_INIT(v) do { (v) = NULL; } while( 0 )
# define HB_COND_DESTROY(v) hb_taskDestroyCond( &(v) )
# define HB_COND_SIGNAL(v) hb_taskSignal( &(v) )
# define HB_COND_SIGNALN(v,n) hb_taskBroadcast( &(v) )
# define HB_COND_WAIT(c,m) hb_taskWait( (c), (m), HB_TASK_INFINITE_WAIT )
# define HB_COND_TIMEDWAIT(c,m,n) hb_taskWait( (c), (m), (n) )
#elif defined( HB_PTHREAD_API )
typedef HB_LONG HB_THREAD_NO;
typedef pthread_t HB_THREAD_ID;
typedef pthread_t HB_THREAD_HANDLE;
typedef pthread_mutex_t HB_RAWCRITICAL_T;
typedef pthread_cond_t HB_RAWCOND_T;
# define HB_THREAD_STARTFUNC( func ) void * func( void * Cargo )
# define HB_THREAD_END return NULL;
# define HB_THREAD_RAWEND return NULL;
# define HB_THREAD_SELF() pthread_self()
# define HB_THREAD_EQUAL( x, y ) pthread_equal( x, y )
# define HB_CRITICAL_INIT(v) pthread_mutex_init( &(v), NULL )
# define HB_CRITICAL_DESTROY(v) pthread_mutex_destroy( &(v) )
# define HB_CRITICAL_LOCK(v) pthread_mutex_lock( &(v) )
# define HB_CRITICAL_UNLOCK(v) pthread_mutex_unlock( &(v) )
# define HB_COND_INIT(v) pthread_cond_init( &(v), NULL )
# define HB_COND_DESTROY(v) pthread_cond_destroy( &(v) )
# define HB_COND_SIGNAL(v) pthread_cond_signal( &(v) )
# define HB_COND_SIGNALN(v,n) pthread_cond_broadcast( &(v) )
# define HB_COND_OS_SUPPORT /* OS support for conditional variables */
# undef HB_COND_HARBOUR_SUPPORT
# if defined( PTHREAD_MUTEX_INITIALIZER ) && !defined( HB_CRITICAL_NEED_INIT )
typedef pthread_mutex_t HB_CRITICAL_T;
# define HB_CRITICAL_NEW( name ) HB_CRITICAL_T name = PTHREAD_MUTEX_INITIALIZER
# define HB_CRITICAL_GET(v) ( v )
# else
/* platform does not support static mutex initialization */
# if !defined( HB_CRITICAL_NEED_INIT )
# define HB_CRITICAL_NEED_INIT
# endif
# define HB_CRITICAL_GET(v) ( &( (v)->critical ) )
# define HB_CRITICAL_INITVAL { }
# endif
# if defined( PTHREAD_COND_INITIALIZER ) && !defined( HB_COND_NEED_INIT )
typedef pthread_cond_t HB_COND_T;
# define HB_COND_NEW( name ) HB_COND_T name = PTHREAD_COND_INITIALIZER
# define HB_COND_GET(v) ( v )
# else
/* platform does not support static condition var initialization */
# if !defined( HB_COND_NEED_INIT )
# define HB_COND_NEED_INIT
# endif
# define HB_COND_GET(v) ( &( (v)->cond ) )
# define HB_COND_INITVAL { }
# endif
#elif defined( HB_OS_WIN ) && ! defined( HB_OS_WIN_CE )
typedef HB_LONG HB_THREAD_NO;
typedef unsigned HB_THREAD_ID;
typedef HANDLE HB_THREAD_HANDLE;
typedef CRITICAL_SECTION HB_RAWCRITICAL_T;
typedef HANDLE HB_OSCOND_T;
# define HB_THREAD_STARTFUNC( func ) unsigned __stdcall func( void * Cargo )
# define HB_THREAD_END _endthreadex( 0 ); return 0;
# define HB_THREAD_RAWEND return 0;
# define HB_THREAD_SELF() GetCurrentThreadId()
# define HB_CRITICAL_INITVAL { 0, 0, 0, 0, 0, 0 }
# define HB_CRITICAL_INIT(v) InitializeCriticalSection( &(v) )
# define HB_CRITICAL_DESTROY(v) DeleteCriticalSection( &(v) )
# define HB_CRITICAL_LOCK(v) EnterCriticalSection( &(v) )
# define HB_CRITICAL_UNLOCK(v) LeaveCriticalSection( &(v) )
# undef HB_COND_OS_SUPPORT
# undef HB_COND_NEED_INIT
# define HB_COND_HARBOUR_SUPPORT
# define HB_CRITICAL_NEED_INIT
# define HB_THREAD_INFINITE_WAIT INFINITE
#elif defined( HB_OS_OS2 )
/* In OS2 thread ID is continuous integer number so we can use it directly
* anyhow I'd prefer to not make such strict binding to OS values because
* it may cause troubles when code will be ported to other platforms.
*/
/* typedef TID HB_THREAD_NO; */
typedef HB_LONG HB_THREAD_NO;
typedef TID HB_THREAD_ID;
typedef TID HB_THREAD_HANDLE;
typedef HMTX HB_RAWCRITICAL_T;
typedef HEV HB_OSCOND_T;
extern ULONG _hb_gettid( void );
# define HB_THREAD_STARTFUNC( func ) void func( void * Cargo )
# define HB_THREAD_END _endthread(); return;
# define HB_THREAD_RAWEND return;
# define HB_CRITICAL_INITVAL ( ( HMTX ) 0 )
# if defined( __GNUC__ )
# define HB_THREAD_SELF() ( ( TID ) _gettid() )
# else
# define HB_THREAD_SELF() ( ( TID ) _hb_gettid() )
# endif
# define HB_CRITICAL_INIT(v) DosCreateMutexSem( NULL, &(v), 0L, FALSE )
# define HB_CRITICAL_DESTROY(v) DosCloseMutexSem( v )
# define HB_CRITICAL_LOCK(v) DosRequestMutexSem( (v), SEM_INDEFINITE_WAIT )
# define HB_CRITICAL_UNLOCK(v) DosReleaseMutexSem( v )
# undef HB_COND_OS_SUPPORT
# undef HB_COND_NEED_INIT
# define HB_COND_HARBOUR_SUPPORT
# define HB_CRITICAL_NEED_INIT
# define HB_THREAD_INFINITE_WAIT SEM_INDEFINITE_WAIT
#else
typedef int HB_THREAD_NO;
typedef int HB_THREAD_ID;
typedef int HB_THREAD_HANDLE;
typedef int HB_CRITICAL_T;
typedef int HB_RAWCRITICAL_T;
typedef int HB_COND_T;
typedef int HB_RAWCOND_T;
# define HB_THREAD_STARTFUNC( func ) void func( void * Cargo )
# define HB_THREAD_END return;
# define HB_THREAD_RAWEND return;
# define HB_CRITICAL_NEW( name ) HB_CRITICAL_T name = 0
# define HB_COND_NEW( name ) HB_COND_T name = 0
# define HB_THREAD_SELF() (-1)
# define HB_CRITICAL_LOCK(v)
# define HB_CRITICAL_UNLOCK(v)
# define HB_COND_SIGNAL(v)
# define HB_COND_SIGNALN(v,n)
# define HB_COND_WAIT(v) ( FALSE )
# define HB_COND_TIMEDWAIT(v,n) ( FALSE )
#endif
#if defined( HB_COND_HARBOUR_SUPPORT )
typedef struct _HB_WAIT_LIST
{
struct _HB_WAIT_LIST * prev;
struct _HB_WAIT_LIST * next;
HB_OSCOND_T cond;
BOOL signaled;
} HB_WAIT_LIST, * PHB_WAIT_LIST;
typedef struct
{
PHB_WAIT_LIST waiters;
} HB_COND_T, HB_RAWCOND_T;
# define HB_COND_NEW( name ) HB_COND_T name = { NULL }
# define HB_COND_SIGNAL(v) _hb_thread_cond_signal( &(v) )
# define HB_COND_SIGNALN(v,n) _hb_thread_cond_broadcast( &(v) )
# define HB_COND_WAIT(v) _hb_thread_cond_wait( (v), HB_THREAD_INFINITE_WAIT )
# define HB_COND_TIMEDWAIT(v,n) _hb_thread_cond_wait( (v), (n) )
#endif
#ifdef HB_CRITICAL_NEED_INIT
typedef struct
{
BOOL fInit;
HB_RAWCRITICAL_T critical;
} HB_CRITICAL_T;
# define HB_CRITICAL_NEW( name ) HB_CRITICAL_T name = { FALSE, HB_CRITICAL_INITVAL }
#endif /* HB_CRITICAL_NEED_INIT */
#ifdef HB_COND_NEED_INIT
# if defined( HB_COND_OS_SUPPORT )
typedef struct
{
BOOL fInit;
HB_RAWCOND_T cond;
} HB_COND_T;
# define HB_COND_NEW( name ) HB_COND_T name = { FALSE, HB_COND_INITVAL }
# else
typedef struct
{
BOOL fInit;
int waiters;
HB_RAWCOND_T cond;
HB_RAWCRITICAL_T critical;
} HB_COND_T;
# define HB_COND_NEW( name ) HB_COND_T name = { FALSE, 0, HB_COND_INITVAL, HB_CRITICAL_INITVAL }
# endif
#endif /* HB_COND_NEED_INIT */
#ifndef HB_THREAD_EQUAL
# define HB_THREAD_EQUAL( x, y ) ( (x) == (y) )
#endif
#ifndef HB_THREAD_SHEDULER
# define HB_THREAD_SHEDULER()
#endif
#ifndef HB_THREAD_INFINITE_WAIT
# define HB_THREAD_INFINITE_WAIT ( ( ULONG ) -1 )
#endif
typedef HB_THREAD_STARTFUNC( PHB_THREAD_STARTFUNC );
typedef struct _HB_THREADSTATE
{
const char * pszCDP;
const char * pszLang;
const char * pszDefRDD;
PHB_SET_STRUCT pSet;
void * pI18N;
void * hGT;
void * pStackId;
BOOL fActive;
BOOL fFinished;
PHB_ITEM pParams;
PHB_ITEM pMemvars;
PHB_ITEM pResult;
PHB_ITEM pThItm;
HB_THREAD_NO th_no;
HB_THREAD_ID th_id;
HB_THREAD_HANDLE th_h;
struct _HB_THREADSTATE * pPrev;
struct _HB_THREADSTATE * pNext;
#if defined( HB_COND_HARBOUR_SUPPORT )
HB_WAIT_LIST pWaitList;
#endif
} HB_THREADSTATE, * PHB_THREADSTATE;
extern void hb_threadInit( void );
extern void hb_threadExit( void );
extern PHB_THREADSTATE hb_threadStateNew( void );
extern void hb_threadReleaseCPU( void );
/* atomic oprtations */
void hb_atomic_set( volatile HB_COUNTER * pCounter, HB_COUNTER value );
HB_COUNTER hb_atomic_get( volatile HB_COUNTER * pCounter );
void hb_atomic_inc( volatile HB_COUNTER * pCounter );
BOOL hb_atomic_dec( volatile HB_COUNTER * pCounter ); /* returns TRUE when counter reach after decrementation */
/* Critical sections or fast non recursive MUTEXes */
extern void hb_threadEnterCriticalSection( HB_CRITICAL_T * critical );
extern void hb_threadLeaveCriticalSection( HB_CRITICAL_T * critical );
/* conditional variables */
extern BOOL hb_threadCondSignal( HB_COND_T * cond );
extern BOOL hb_threadCondBroadcast( HB_COND_T * cond );
extern BOOL hb_threadCondWait( HB_COND_T * cond, HB_CRITICAL_T * mutex );
extern BOOL hb_threadCondTimedWait( HB_COND_T * cond, HB_CRITICAL_T * mutex, ULONG ulMilliSec );
extern HB_THREAD_HANDLE hb_threadCreate( HB_THREAD_ID * th_id, PHB_THREAD_STARTFUNC start_func, void * Cargo );
extern BOOL hb_threadJoin( HB_THREAD_HANDLE th_h );
extern BOOL hb_threadDetach( HB_THREAD_HANDLE th_h );
/* used by .prg code */
extern PHB_ITEM hb_threadMutexCreate( BOOL fSync );
extern BOOL hb_threadMutexLock( PHB_ITEM pItem );
extern BOOL hb_threadMutexTimedLock( PHB_ITEM pItem, ULONG ulMilliSec );
extern BOOL hb_threadMutexUnlock( PHB_ITEM pItem );
extern void hb_threadMutexNotify( PHB_ITEM pItem, PHB_ITEM pNotifier, BOOL fWaiting );
extern PHB_ITEM hb_threadMutexSubscribe( PHB_ITEM pItem, BOOL fClear );
extern PHB_ITEM hb_threadMutexTimedSubscribe( PHB_ITEM pItem, ULONG ulMilliSec, BOOL fClear );
#if defined( HB_MT_VM ) && defined( _HB_API_INTERNAL_ )
extern void hb_threadMutexUnlockAll( void );
extern void hb_threadMutexSyncSignal( PHB_ITEM pItemMtx );
extern BOOL hb_threadMutexSyncWait( PHB_ITEM pItemMtx, ULONG ulMilliSec, PHB_ITEM pItemSync );
#if defined( HB_NO_TLS ) || defined( HB_TASK_THREAD )
# undef HB_USE_TLS
#elif !defined( HB_USE_TLS )
/* enable native compiler TLS support be default for this compilers
* which are known that it will work correctly
*/
# if defined( _MSC_VER ) && !defined( __POCC__ ) && !defined( __XCC__ )
# define HB_USE_TLS
# elif defined( __GNUC__ ) && __GNUC__ >= 3 && \
defined( __GLIBC__ ) && defined( __GLIBC_MINOR__ ) && \
( __GLIBC__ > 2 || ( __GLIBC__ == 2 && __GLIBC_MINOR__ >= 6 ) ) && \
defined( HB_OS_LINUX ) && \
( defined( __i386__ ) || defined( __x86_64__ ) )
# define HB_USE_TLS
# endif
#endif
#ifdef HB_USE_TLS
# if ( defined( __GNUC__ ) && __GNUC__ >= 3 ) || defined( __BORLANDC__ )
# define HB_TLS_ATTR __thread
# elif defined( _MSC_VER ) || defined( __WATCOMC__ ) || defined( __DMC__ )
# define HB_TLS_ATTR __declspec( thread )
# else
# undef HB_USE_TLS
# error "TLS support undefined for this compiler" /* */
# endif
#endif
#ifndef HB_USE_TLS
# if defined( HB_TASK_THREAD )
# define HB_TLS_KEY void *
# define hb_tls_init(k) HB_SYMBOL_UNUSED( k )
# define hb_tls_set(k,v) hb_taskSetData( ( void * ) (v) )
# define hb_tls_get(k) hb_taskGetData()
# elif defined( HB_PTHREAD_API )
# define HB_TLS_KEY pthread_key_t
# define hb_tls_init(k) pthread_key_create( &k, NULL )
# define hb_tls_set(k,v) pthread_setspecific( k, ( void * ) (v) )
# define hb_tls_get(k) pthread_getspecific( k )
# elif defined( HB_OS_WIN )
# define HB_TLS_KEY DWORD
# define hb_tls_init(k) do { k = TlsAlloc(); } while( 0 )
# define hb_tls_set(k,v) TlsSetValue( k, ( void * ) (v) )
# define hb_tls_get(k) TlsGetValue( k )
# elif defined( HB_OS_OS2 )
# define HB_TLS_KEY PULONG
# define hb_tls_init(k) DosAllocThreadLocalMemory( 1, &k )
# define hb_tls_set(k,v) do { *k = ( ULONG ) (v); } while( 0 )
# define hb_tls_get(k) ( *k )
# endif
#endif
#endif
HB_EXTERN_END
#endif /* HB_THREAD_H_ */
Reference in New Issue View Git Blame Copy Permalink