fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
7349602fcbd9b336183d2fa355454c60cb2f91e1
harbour-core/include/hbthread.h
Przemysław Czerpak 7349602fcb 2014-04-01 12:33 UTC+0200 Przemyslaw Czerpak (druzus/at/poczta.onet.pl) 
* src/rtl/filebuf.c
    ! unlock HVM stack before locking local mutex and calling hb_fs*()
      functions which also unlocks HVM. It fixes possible deadlock condition
      when hb_gcAll( .T. ) is executed.

  * include/hbapi.h
  * src/vm/garbage.c
    ! changed mark function semantic.
      Adding support for user defined mark function I created race condition
      in MT GC code. It happens because blocks marked as deleted were not
      scanned by GC mark code so their subitems where not accessible.
      To fix it we have to change mark function semantic. Now mark function
      can be executed also for blocks currently deleted. It means that GC
      block destructor should clean references to just removed items and
      subblocks. The best place to make it is clearing pointers to GC blocks
      just after hb_itemRelease() or hb_gcRefFree().
      It is save to clean the reference just before hb_itemRelease() or
      hb_gcRefFree() but only for the single block passed to these functions.
      It is not save to clear reference to more then one block and then
      execute above functions.
    + check reference count after destructor execution for all blocks
      not only arrays - warning it may exploit some wrong C code.
    - removed not longer used hb_gcRefCheck() function.

  * include/hbvm.h
  * src/vm/hvm.c
    + added new internal function hb_vmLockForce()
    ! fixed to mark GC blocks with active threads

  * src/vm/thread.c
  * include/hbthread.h
    % modified sync mutexes used by xBase++ signal class emulation
      to not use item array internally
    * updated mutex destructor to new GC mark semantic
    ! mark GT items if GT is bound with thread item
    ! fixed mutex notify/subscribe code to not change GC items
      when HVM stack is unlocked
    ! use hb_vmLockForce() to eliminate potential deadlock
    + added new C function hb_threadEnterCriticalSectionGC().
      It should be used instead of hb_threadEnterCriticalSection()
      in code which manipulates GC items inside critical section.
      It's slower but eliminates possible deadlock condition.
      Please remember that remember that both functions cannot
      be used for the same mutex. So if it's necessary to use
      hb_threadEnterCriticalSectionGC() in one place then it
      has to be used in all others when the same mutex is locked.

  * src/vm/arrays.c
  * src/vm/codebloc.c
  * src/vm/hashes.c
  * src/rtl/hbgtcore.c
  * contrib/hbcurl/core.c
  * contrib/hbexpat/core.c
    * updated destructors to new GC mark semantic

  * contrib/hbxpp/dllx.c
    ! fixed destructor for pointer item created by DllPrepareCall()
      Now it respects reference counter.
    ; added note about real behavior of library handle destructor,
      I haven't changed existing code behavior but maybe it should
      be done.

  * contrib/xhb/hbserv.c
  * src/debug/dbgentry.c
  * src/rdd/wacore.c
    ! fixed possible deadlocks by using hb_threadEnterCriticalSectionGC()
      instead of hb_threadEnterCriticalSection().

  * contrib/hbmemio/memio.c
    ! slightly modified hb_memfsDirectory() code to avoid race condition
      without using hb_threadEnterCriticalSectionGC()

  * src/vm/fm.c
    % reduce the lock range in HB_FM_STAT builds

  * src/rtl/hbsocket.c
    ! added missing HVM stack unlocking in hb_socketSelect() function

  * src/rtl/gtxwc/gtxwc.c
    ! added few missing locks for version compiled with HB_XWC_XLIB_NEEDLOCKS

  * src/rdd/dbtotal.prg
    * allow to use symbols instead of codeblocks
    * modified Harbour extension which uses ordKey() as default group
      signature to work also without index. In such case all records
      are summarized into single one.

  ; Most of above modifications were critical for stability of MT programs.
    They should allow to activate GC in any place.
2014-04-01 12:33:17 +02:00

504 lines
18 KiB
C
Raw Blame History

/*
* Harbour Project source code:
* header file with MT mode functions
*
* Copyright 2008 Przemyslaw Czerpak <druzus / at / priv.onet.pl>
* www - http://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.txt. 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 ) || defined( HB_OS_MINIX )
# define HB_TASK_THREAD
#elif defined( HB_OS_LINUX ) || defined( HB_OS_DARWIN ) || \
defined( HB_OS_SUNOS ) || defined( HB_OS_HPUX ) || \
defined( HB_OS_BSD ) || defined( HB_OS_BEOS ) || \
defined( HB_OS_QNX ) || defined( HB_OS_VXWORKS ) || \
defined( HB_OS_SYMBIAN ) || defined( HB_OS_CYGWIN ) || \
defined( HB_OS_AIX )
# include <pthread.h>
# define HB_PTHREAD_API
# if defined( HB_OS_VXWORKS )
# /* Avoids compiler warnings in mutex initialization. MT still doesn't work though. */
# define HB_CRITICAL_NEED_INIT
# endif
#elif defined( HB_OS_WIN )
# include <windows.h>
# if ! defined( HB_OS_WIN_CE )
# include <process.h>
# endif
#elif defined( HB_OS_OS2 )
# include <os2.h>
# if defined( __WATCOMC__ )
# include <process.h>
# endif
#endif
HB_EXTERN_BEGIN
#if defined( HB_TASK_THREAD )
# include "hbtask.h"
typedef HB_MAXINT 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_MAXINT 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.value ) )
# 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.value ) )
# endif
#elif defined( HB_OS_WIN )
typedef HB_MAXINT HB_THREAD_NO;
typedef HANDLE HB_THREAD_HANDLE;
typedef CRITICAL_SECTION HB_RAWCRITICAL_T;
typedef HANDLE HB_OSCOND_T;
# if defined( HB_OS_WIN_CE ) && \
( ( defined( __MINGW32CE__ ) && ! defined( __MSVCRT__ ) ) || \
defined( __POCC__ ) ) || \
( defined( _MSC_VER ) && ( _MSC_VER <= 1500 ) )
# define HB_THREAD_RAWWINAPI
# endif
# if defined( HB_THREAD_RAWWINAPI )
typedef DWORD HB_THREAD_ID;
# define HB_THREAD_STARTFUNC( func ) DWORD WINAPI func( void * Cargo )
# define HB_THREAD_END ExitThread( 0 ); return 0;
# else
typedef unsigned HB_THREAD_ID;
# define HB_THREAD_STARTFUNC( func ) unsigned __stdcall func( void * Cargo )
# define HB_THREAD_END _endthreadex( 0 ); return 0;
# endif
# define HB_THREAD_RAWEND return 0;
# define HB_THREAD_SELF() GetCurrentThreadId()
# 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_MAXINT 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;
# if defined( __GNUC__ ) && 0
# 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
# ifndef SEM_INDEFINITE_WAIT
# define SEM_INDEFINITE_WAIT ( ( HB_ULONG ) -1 )
# endif
#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) ( HB_FALSE )
# define HB_COND_TIMEDWAIT(v,n) ( HB_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;
HB_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
{
HB_BOOL fInit;
union
{
int dummy;
HB_RAWCRITICAL_T value;
} critical;
} HB_CRITICAL_T;
# define HB_CRITICAL_NEW( name ) HB_CRITICAL_T name = { HB_FALSE, { 0 } }
#endif /* HB_CRITICAL_NEED_INIT */
#ifdef HB_COND_NEED_INIT
# if defined( HB_COND_OS_SUPPORT )
typedef struct
{
HB_BOOL fInit;
union
{
int dummy;
HB_RAWCOND_T value;
} cond;
} HB_COND_T;
# define HB_COND_NEW( name ) HB_COND_T name = { HB_FALSE, { 0 } }
# else
typedef struct
{
HB_BOOL fInit;
int waiters;
union
{
int dummy;
HB_RAWCOND_T value;
} cond;
union
{
int dummy;
HB_RAWCRITICAL_T value;
} critical;
} HB_COND_T;
# define HB_COND_NEW( name ) HB_COND_T name = { HB_FALSE, 0, { 0 }, { 0 } }
# 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 ( ( HB_ULONG ) -1 )
#endif
typedef HB_THREAD_STARTFUNC( PHB_THREAD_STARTFUNC );
extern HB_EXPORT void hb_threadReleaseCPU( void );
/* atomic oprtations */
extern HB_EXPORT void hb_atomic_set( volatile HB_COUNTER * pCounter, HB_COUNTER value );
extern HB_EXPORT HB_COUNTER hb_atomic_get( volatile HB_COUNTER * pCounter );
extern HB_EXPORT void hb_atomic_inc( volatile HB_COUNTER * pCounter );
extern HB_EXPORT HB_BOOL hb_atomic_dec( volatile HB_COUNTER * pCounter ); /* returns HB_TRUE when counter reaches 0 after decrementation */
/* Critical sections or fast non recursive MUTEXes */
extern HB_EXPORT void hb_threadEnterCriticalSection( HB_CRITICAL_T * critical );
extern HB_EXPORT void hb_threadEnterCriticalSectionGC( HB_CRITICAL_T * critical );
extern HB_EXPORT void hb_threadLeaveCriticalSection( HB_CRITICAL_T * critical );
/* conditional variables */
extern HB_EXPORT HB_BOOL hb_threadCondSignal( HB_COND_T * cond );
extern HB_EXPORT HB_BOOL hb_threadCondBroadcast( HB_COND_T * cond );
extern HB_EXPORT HB_BOOL hb_threadCondWait( HB_COND_T * cond, HB_CRITICAL_T * mutex );
extern HB_EXPORT HB_BOOL hb_threadCondTimedWait( HB_COND_T * cond, HB_CRITICAL_T * mutex, HB_ULONG ulMilliSec );
extern HB_EXPORT HB_THREAD_HANDLE hb_threadCreate( HB_THREAD_ID * th_id, PHB_THREAD_STARTFUNC start_func, void * Cargo );
extern HB_EXPORT HB_BOOL hb_threadJoin( HB_THREAD_HANDLE th_h );
extern HB_EXPORT HB_BOOL hb_threadDetach( HB_THREAD_HANDLE th_h );
extern HB_EXPORT HB_THREAD_NO hb_threadNO( void );
/* used by .prg code */
extern HB_EXPORT PHB_ITEM hb_threadMutexCreate( void );
extern HB_EXPORT HB_BOOL hb_threadMutexLock( PHB_ITEM pItem );
extern HB_EXPORT HB_BOOL hb_threadMutexTimedLock( PHB_ITEM pItem, HB_ULONG ulMilliSec );
extern HB_EXPORT HB_BOOL hb_threadMutexUnlock( PHB_ITEM pItem );
extern HB_EXPORT void hb_threadMutexNotify( PHB_ITEM pItem, PHB_ITEM pNotifier, HB_BOOL fWaiting );
extern HB_EXPORT PHB_ITEM hb_threadMutexSubscribe( PHB_ITEM pItem, HB_BOOL fClear );
extern HB_EXPORT PHB_ITEM hb_threadMutexTimedSubscribe( PHB_ITEM pItem, HB_ULONG ulMilliSec, HB_BOOL fClear );
#if defined( _HB_API_INTERNAL_ )
typedef struct _HB_THREADSTATE
{
const char * pszCDP;
const char * pszLang;
const char * pszDefRDD;
PHB_SET_STRUCT pSet;
void * pI18N;
void * hGT;
void * pStackId;
void * cargo;
PHB_CARGO_FUNC pFunc;
HB_BOOL fActive;
HB_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;
#if defined( HB_MT_VM )
extern void hb_threadInit( void );
extern void hb_threadExit( void );
extern PHB_THREADSTATE hb_threadStateNew( void );
extern PHB_THREADSTATE hb_threadStateClone( HB_ULONG ulAttr, PHB_ITEM pParams );
extern PHB_ITEM hb_threadStart( HB_ULONG ulAttr, PHB_CARGO_FUNC pFunc, void * cargo );
extern void hb_threadMutexUnlockAll( void );
extern void hb_threadMutexUnsubscribeAll( void );
extern void hb_threadMutexSyncSignal( PHB_ITEM pItemMtx );
extern HB_BOOL hb_threadMutexSyncWait( PHB_ITEM pItemMtx, HB_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 by default for this compilers
* which are known that it will work correctly
*/
# if ( defined( _MSC_VER ) && ( _MSC_VER > 1500 ) ) && ! 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__ ) ) && \
! defined( __OPENCC__ )
# 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 /* HB_USE_TLS */
#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 /* ! HB_USE_TLS */
#endif /* HB_MT_VM */
#endif /* _HB_API_INTERNAL_ */
HB_EXTERN_END
#endif /* HB_THREAD_H_ */
Reference in New Issue View Git Blame Copy Permalink