my_bool my_thread_global_init(void)
{
if (pthread_key_create(&THR_KEY_mysys,free))
{
fprintf(stderr,"Can't initialize threads: error %d\n",errno);
exit(1);
}
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
pthread_mutexattr_init(&my_fast_mutexattr);
pthread_mutexattr_setkind_np(&my_fast_mutexattr,PTHREAD_MUTEX_ADAPTIVE_NP);
#endif
#ifdef PPTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
pthread_mutexattr_init(&my_errchk_mutexattr);
pthread_mutexattr_setkind_np(&my_errchk_mutexattr,
PTHREAD_MUTEX_ERRORCHECK_NP);
#endif
THR_KEY_mysys_initialized= TRUE;
#ifdef HAVE_OPENSSL
pthread_mutex_init(&LOCK_ssl_config,MY_MUTEX_INIT_FAST);
#endif
pthread_mutex_init(&THR_LOCK_malloc,MY_MUTEX_INIT_FAST);
pthread_mutex_init(&THR_LOCK_open,MY_MUTEX_INIT_FAST);
pthread_mutex_init(&THR_LOCK_lock,MY_MUTEX_INIT_FAST);
pthread_mutex_init(&THR_LOCK_net,MY_MUTEX_INIT_FAST);
#ifdef _WIN32
/* win_pthread_init(); */
#endif
#ifndef HAVE_LOCALTIME_R
pthread_mutex_init(&LOCK_localtime_r,MY_MUTEX_INIT_SLOW);
#endif
return my_thread_init();
}
SDL_mutex *
SDL_CreateMutex(void)
{
SDL_mutex *mutex;
pthread_mutexattr_t attr;
/* Allocate the structure */
mutex = (SDL_mutex *) SDL_calloc(1, sizeof(*mutex));
if (mutex) {
pthread_mutexattr_init(&attr);
#if SDL_THREAD_PTHREAD_RECURSIVE_MUTEX
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
#elif SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP
pthread_mutexattr_setkind_np(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
#else
/* No extra attributes necessary */
#endif
if (pthread_mutex_init(&mutex->id, &attr) != 0) {
SDL_SetError("pthread_mutex_init() failed");
SDL_free(mutex);
mutex = NULL;
}
} else {
SDL_OutOfMemory();
}
return (mutex);
}
int almtx_init(almtx_t *mtx, int type)
{
int ret;
if(!mtx) return althrd_error;
if((type&~(almtx_recursive|almtx_timed)) != 0)
return althrd_error;
type &= ~almtx_timed;
if(type == almtx_plain)
ret = pthread_mutex_init(mtx, NULL);
else
{
pthread_mutexattr_t attr;
ret = pthread_mutexattr_init(&attr);
if(ret) return althrd_error;
if(type == almtx_recursive)
{
ret = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
#ifdef HAVE_PTHREAD_MUTEXATTR_SETKIND_NP
if(ret != 0)
ret = pthread_mutexattr_setkind_np(&attr, PTHREAD_MUTEX_RECURSIVE);
#endif
}
else
ret = 1;
if(ret == 0)
ret = pthread_mutex_init(mtx, &attr);
pthread_mutexattr_destroy(&attr);
}
return ret ? althrd_error : althrd_success;
}
void InitThreads (int wantthreads, size_t needstack)
{
pthread_mutexattr_t mattrib;
if (needstack != 0)
stacksiz = needstack;
else stacksiz = DEFAULT_STACKSIZ;
numthreads = wantthreads;
if (numthreads < 0)
numthreads = 4;
if (numthreads < 1)
numthreads = 1;
if (numthreads > MAX_THREADS)
numthreads = MAX_THREADS;
printf ("Setup for %d threads, 0x%x stack size\n",
numthreads, (unsigned int)stacksiz);
if (numthreads <= 1)
return;
my_mutex = (pthread_mutex_t *) SafeMalloc (sizeof(*my_mutex));
if (pthread_mutexattr_create (&mattrib) == -1)
COM_Error ("pthread_mutex_attr_create failed");
if (pthread_mutexattr_setkind_np (&mattrib, MUTEX_FAST_NP) == -1)
COM_Error ("pthread_mutexattr_setkind_np failed");
if (pthread_mutex_init (my_mutex, mattrib) == -1)
COM_Error ("pthread_mutex_init failed");
}
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void ThreadSetupLock(void)
{
pthread_mutexattr_t mattrib;
Log_Print("pthread multi-threading\n");
if (!my_mutex)
{
my_mutex = GetMemory(sizeof(*my_mutex));
if (pthread_mutexattr_create (&mattrib) == -1)
Error ("pthread_mutex_attr_create failed");
if (pthread_mutexattr_setkind_np (&mattrib, MUTEX_FAST_NP) == -1)
Error ("pthread_mutexattr_setkind_np failed");
if (pthread_mutex_init (my_mutex, mattrib) == -1)
Error ("pthread_mutex_init failed");
}
if (pthread_attr_create (&attrib) == -1)
Error ("pthread_attr_create failed");
if (pthread_attr_setstacksize (&attrib, 0x100000) == -1)
Error ("pthread_attr_setstacksize failed");
threaded = true;
currentnumthreads = 0;
currentthreadid = 0;
} //end of the function ThreadInitLock
hashtable ht_new(unsigned int size,
unsigned int (*hash)(const void *key),
boolean (*isequal)(const void *key1,
const void *key2),
/*@null@*/ void (*free_keyval)(void *key)) {
hashtable ht = malloc(sizeof(struct hashtable_struct));
#ifdef _REENTRANT
pthread_mutexattr_t attrib;
#endif
assert(ht!=NULL);
ht->table = (hashentry **)malloc(sizeof(hashentry *)*size);
assert(ht->table!=NULL);
memset(ht->table, 0, size * sizeof(hashentry *));
ht->table_size = size;
ht->hash = hash;
ht->isequal = isequal;
ht->free_keyval = free_keyval;
#ifdef _REENTRANT
(void)pthread_mutexattr_init(&attrib);
(void)pthread_mutexattr_setkind_np(&attrib, PTHREAD_MUTEX_RECURSIVE_NP);
(void)pthread_mutex_init(&ht->mutex, &attrib);
(void)pthread_mutexattr_destroy(&attrib);
#endif
return(ht);
}
void* XMLPlatformUtils::makeMutex(MemoryManager* manager)
{
MutexHolderType* const holder = new (manager) MutexHolderType;
pthread_mutexattr_t attr;
#if defined(XML_USE_DCE)
pthread_mutexattr_create(&attr);
pthread_mutexattr_setkind_np(&attr, MUTEX_RECURSIVE_NP);
if (pthread_mutex_init(&holder->fInstance, attr))
{
delete holder;
panic(PanicHandler::Panic_MutexErr);
}
pthread_mutexattr_delete(&attr);
#else
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
if (pthread_mutex_init(&holder->fInstance, &attr))
{
delete holder;
panic(PanicHandler::Panic_MutexErr);
}
pthread_mutexattr_destroy(&attr);
#endif
return holder;
}
void* XMLPlatformUtils::makeMutex()
{
pthread_mutex_t* mutex = new pthread_mutex_t;
pthread_mutexattr_t* attr = new pthread_mutexattr_t;
#if defined(XML_USE_DCE)
pthread_mutexattr_create(attr);
pthread_mutexattr_setkind_np(attr, MUTEX_RECURSIVE_NP);
if (pthread_mutex_init(mutex, *attr))
{
ThrowXMLwithMemMgr(XMLPlatformUtilsException,
XMLExcepts::Mutex_CouldNotCreate, fgMemoryManager);
}
pthread_mutexattr_delete(attr);
#else
pthread_mutexattr_init(attr);
pthread_mutexattr_settype(attr, PTHREAD_MUTEX_RECURSIVE);
if (pthread_mutex_init(mutex, attr))
{
ThrowXMLwithMemMgr(XMLPlatformUtilsException,
XMLExcepts::Mutex_CouldNotCreate, fgMemoryManager);
}
pthread_mutexattr_destroy(attr);
#endif
delete attr;
return (void*) mutex;
}
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void RunThreadsOn(int workcnt, qboolean showpacifier, void(*func)(int))
{
int i;
pthread_t work_threads[MAX_THREADS];
pthread_addr_t status;
pthread_attr_t attrib;
pthread_mutexattr_t mattrib;
int start, end;
Log_Print("pthread multi-threading\n");
start = I_FloatTime ();
dispatch = 0;
workcount = workcnt;
oldf = -1;
pacifier = showpacifier;
threaded = true;
if (numthreads < 1 || numthreads > MAX_THREADS) numthreads = 1;
if (pacifier)
setbuf (stdout, NULL);
if (!my_mutex)
{
my_mutex = GetMemory(sizeof(*my_mutex));
if (pthread_mutexattr_create (&mattrib) == -1)
Error ("pthread_mutex_attr_create failed");
if (pthread_mutexattr_setkind_np (&mattrib, MUTEX_FAST_NP) == -1)
Error ("pthread_mutexattr_setkind_np failed");
if (pthread_mutex_init (my_mutex, mattrib) == -1)
Error ("pthread_mutex_init failed");
}
if (pthread_attr_create (&attrib) == -1)
Error ("pthread_attr_create failed");
if (pthread_attr_setstacksize (&attrib, 0x100000) == -1)
Error ("pthread_attr_setstacksize failed");
for (i=0 ; i<numthreads ; i++)
{
if (pthread_create(&work_threads[i], attrib
, (pthread_startroutine_t)func, (pthread_addr_t)i) == -1)
Error ("pthread_create failed");
}
for (i=0 ; i<numthreads ; i++)
{
if (pthread_join (work_threads[i], &status) == -1)
Error ("pthread_join failed");
}
threaded = false;
end = I_FloatTime ();
if (pacifier)
printf (" (%i)\n", end-start);
} //end of the function RunThreadsOn
mutex::mutex()
{
pthread_mutexattr_t attrib;
pthread_mutexattr_init(&attrib);
#ifdef linux_pthreads
pthread_mutexattr_setkind_np(&attrib,PTHREAD_MUTEX_ERRORCHECK_NP);
#endif
pthread_mutex_init(&mymid,&attrib);
// owner = 0;
};
/*
=============
_RunThreadsOn
=============
*/
void _RunThreadsOn (int workcnt, qboolean showpacifier, void(*func)(int))
{
int i;
pthread_t work_threads[MAX_THREADS];
pthread_addr_t status;
pthread_attr_t attrib;
pthread_mutexattr_t mattrib;
int start, end;
start = I_FloatTime ();
dispatch = 0;
workcount = workcnt;
oldf = -1;
pacifier = showpacifier;
if (pacifier)
setbuf (stdout, NULL);
if (!my_mutex)
{
my_mutex = safe_malloc (sizeof(*my_mutex));
if (pthread_mutexattr_create (&mattrib) == -1)
Error ("pthread_mutex_attr_create failed");
if (pthread_mutexattr_setkind_np (&mattrib, MUTEX_FAST_NP) == -1)
Error ("pthread_mutexattr_setkind_np failed");
if (pthread_mutex_init (my_mutex, mattrib) == -1)
Error ("pthread_mutex_init failed");
}
if (pthread_attr_create (&attrib) == -1)
Error ("pthread_attr_create failed");
if (pthread_attr_setstacksize (&attrib, 0x100000) == -1)
Error ("pthread_attr_setstacksize failed");
for (i=0 ; i<numthreads ; i++)
{
if (pthread_create(&work_threads[i], attrib
, (pthread_startroutine_t)func, (pthread_addr_t)i) == -1)
Error ("pthread_create failed");
}
for (i=0 ; i<numthreads ; i++)
{
if (pthread_join (work_threads[i], &status) == -1)
Error ("pthread_join failed");
}
end = I_FloatTime ();
if (pacifier)
Sys_Printf (" (%i)\n", end-start);
}
/*****************************************************************************
* vlc_mutex_init: initialize a mutex
*****************************************************************************/
int vlc_mutex_init( vlc_mutex_t *p_mutex )
{
#if defined( LIBVLC_USE_PTHREAD )
pthread_mutexattr_t attr;
int i_result;
pthread_mutexattr_init( &attr );
# ifndef NDEBUG
/* Create error-checking mutex to detect problems more easily. */
# if defined (__GLIBC__) && (__GLIBC_MINOR__ < 6)
pthread_mutexattr_setkind_np( &attr, PTHREAD_MUTEX_ERRORCHECK_NP );
# else
pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_ERRORCHECK );
# endif
# endif
i_result = pthread_mutex_init( p_mutex, &attr );
pthread_mutexattr_destroy( &attr );
return i_result;
#elif defined( UNDER_CE )
InitializeCriticalSection( &p_mutex->csection );
return 0;
#elif defined( WIN32 )
*p_mutex = CreateMutex( NULL, FALSE, NULL );
return (*p_mutex != NULL) ? 0 : ENOMEM;
#elif defined( HAVE_KERNEL_SCHEDULER_H )
/* check the arguments and whether it's already been initialized */
if( p_mutex == NULL )
{
return B_BAD_VALUE;
}
if( p_mutex->init == 9999 )
{
return EALREADY;
}
p_mutex->lock = create_sem( 1, "BeMutex" );
if( p_mutex->lock < B_NO_ERROR )
{
return( -1 );
}
p_mutex->init = 9999;
return B_OK;
#endif
}
/*****************************************************************************
* vlc_mutex_init: initialize a recursive mutex (Do not use)
*****************************************************************************/
void vlc_mutex_init_recursive( vlc_mutex_t *p_mutex )
{
pthread_mutexattr_t attr;
pthread_mutexattr_init( &attr );
#if defined (__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ < 6)
pthread_mutexattr_setkind_np( &attr, PTHREAD_MUTEX_RECURSIVE_NP );
#else
pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
#endif
if( pthread_mutex_init( p_mutex, &attr ) )
abort();
pthread_mutexattr_destroy( &attr );
}
void InitThreads (void)
{
#ifdef __alpha
pthread_mutexattr_t mattrib;
my_mutex = malloc (sizeof(*my_mutex));
if (pthread_mutexattr_create (&mattrib) == -1)
Error ("pthread_mutex_attr_create failed");
if (pthread_mutexattr_setkind_np (&mattrib, MUTEX_FAST_NP) == -1)
Error ("pthread_mutexattr_setkind_np failed");
if (pthread_mutex_init (my_mutex, mattrib) == -1)
Error ("pthread_mutex_init failed");
#endif
}
my_bool my_thread_global_init(void)
{
if (pthread_key_create(&THR_KEY_mysys,free))
{
fprintf(stderr,"Can't initialize threads: error %d\n",errno);
exit(1);
}
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
pthread_mutexattr_init(&my_fast_mutexattr);
pthread_mutexattr_setkind_np(&my_fast_mutexattr,PTHREAD_MUTEX_ADAPTIVE_NP);
#endif
#ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
pthread_mutexattr_init(&my_errchk_mutexattr);
pthread_mutexattr_setkind_np(&my_errchk_mutexattr,
PTHREAD_MUTEX_ERRORCHECK_NP);
#endif
pthread_mutex_init(&THR_LOCK_malloc,MY_MUTEX_INIT_FAST);
pthread_mutex_init(&THR_LOCK_open,MY_MUTEX_INIT_FAST);
pthread_mutex_init(&THR_LOCK_keycache,MY_MUTEX_INIT_FAST);
pthread_mutex_init(&THR_LOCK_lock,MY_MUTEX_INIT_FAST);
pthread_mutex_init(&THR_LOCK_isam,MY_MUTEX_INIT_SLOW);
pthread_mutex_init(&THR_LOCK_myisam,MY_MUTEX_INIT_SLOW);
pthread_mutex_init(&THR_LOCK_heap,MY_MUTEX_INIT_FAST);
pthread_mutex_init(&THR_LOCK_net,MY_MUTEX_INIT_FAST);
pthread_mutex_init(&THR_LOCK_charset,MY_MUTEX_INIT_FAST);
#if defined( __WIN__) || defined(OS2)
win_pthread_init();
#endif
#ifndef HAVE_LOCALTIME_R
pthread_mutex_init(&LOCK_localtime_r,MY_MUTEX_INIT_SLOW);
#endif
#ifndef HAVE_GETHOSTBYNAME_R
pthread_mutex_init(&LOCK_gethostbyname_r,MY_MUTEX_INIT_SLOW);
#endif
return my_thread_init();
}
mutex_t *MutexAlloc(void)
{
pthread_mutex_t *my_mutex;
pthread_mutexattr_t mattrib;
if (numthreads == 1)
return NULL;
my_mutex = malloc (sizeof(*my_mutex));
if (pthread_mutexattr_create (&mattrib) == -1)
Error ("pthread_mutex_attr_create failed");
if (pthread_mutexattr_setkind_np (&mattrib, MUTEX_FAST_NP) == -1)
Error ("pthread_mutexattr_setkind_np failed");
if (pthread_mutex_init (my_mutex, mattrib) == -1)
Error ("pthread_mutex_init failed");
return (void *) my_mutex;
}
ACL_mutex * ACL_CreateMutex()
{
ACL_mutex *mutex;
pthread_mutexattr_t attr;
mutex=(ACL_mutex *)malloc(sizeof(ACL_mutex));
if(NULL!=mutex)
{
pthread_mutexattr_init(&attr);
pthread_mutexattr_setkind_np(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
if(pthread_mutex_init(&mutex->id, &attr)!=0)
{
free(mutex);
mutex=NULL;
}
}
return mutex;
}
/*****************************************************************************
* vlc_mutex_init: initialize a mutex
*****************************************************************************/
void vlc_mutex_init( vlc_mutex_t *p_mutex )
{
pthread_mutexattr_t attr;
if( pthread_mutexattr_init( &attr ) )
abort();
#ifndef NDEBUG
/* Create error-checking mutex to detect problems more easily. */
# if defined (__GLIBC__) && (__GLIBC_MINOR__ < 6)
pthread_mutexattr_setkind_np( &attr, PTHREAD_MUTEX_ERRORCHECK_NP );
# else
pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_ERRORCHECK );
# endif
#endif
if( pthread_mutex_init( p_mutex, &attr ) )
abort();
pthread_mutexattr_destroy( &attr );
}
SDL_mutex *SDL_CreateMutex (void)
{
#if defined(_WIN32)
SDL_mutex *mutex;
/* Allocate mutex memory */
mutex = (SDL_mutex *)malloc(sizeof(*mutex));
if ( mutex ) {
/* Create the mutex, with initial value signaled */
mutex->id = CreateMutex(NULL, FALSE, NULL);
if ( ! mutex->id ) {
CLog::Log(LOGERROR, "Couldn't create mutex");
free(mutex);
mutex = NULL;
}
} else {
CLog::Log(LOGERROR, "OutOfMemory");
}
return(mutex);
#else
SDL_mutex *mutex;
pthread_mutexattr_t attr;
/* Allocate the structure */
mutex = (SDL_mutex *)calloc(1, sizeof(*mutex));
if ( mutex ) {
pthread_mutexattr_init(&attr);
#if defined(XBMC_PTHREAD_MUTEX_RECURSIVE)
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
#elif defined(XBMC_PTHREAD_MUTEX_RECURSIVE_NP)
pthread_mutexattr_setkind_np(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
#endif
if ( pthread_mutex_init(&mutex->id, &attr) != 0 ) {
CLog::Log(LOGERROR, "pthread_mutex_init() failed");
free(mutex);
mutex = NULL;
}
} else {
CLog::Log(LOGERROR, "OutOfMemory");
}
return(mutex);
#endif
}
void InitializeCriticalSection(CRITICAL_SECTION *cs)
{
pthread_mutexattr_t attrib;
int ret;
ret = pthread_mutexattr_init(&attrib);
assert(ret == 0);
ret = pthread_mutexattr_settype(&attrib, PTHREAD_MUTEX_RECURSIVE);
#ifdef HAVE_PTHREAD_NP_H
if(ret != 0)
ret = pthread_mutexattr_setkind_np(&attrib, PTHREAD_MUTEX_RECURSIVE);
#endif
assert(ret == 0);
ret = pthread_mutex_init(cs, &attrib);
assert(ret == 0);
pthread_mutexattr_destroy(&attrib);
}
int
createMutex(Mutex_t& handle)
{
pthread_mutexattr_t attr;
int res = pthread_mutexattr_create(&attr);
assert(res == 0);
if (res != 0)
{
return -1;
}
#if defined(BLOCXX_HAVE_PTHREAD_MUTEXATTR_SETTYPE)
res = pthread_mutexattr_setkind_np(&attr, MUTEX_RECURSIVE_NP);
assert(res == 0);
if (res != 0)
{
pthread_mutexattr_delete(&attr);
return -1;
}
#endif
res = pthread_mutex_init(&handle.mutex, attr);
pthread_mutexattr_delete(&attr);
if (res != 0)
{
return -1;
}
#if !defined(BLOCXX_HAVE_PTHREAD_MUTEXATTR_SETTYPE)
res = pthread_cond_init(&handle.unlocked, PTHREAD_COND_ATTR_DEFAULT);
if (res != 0)
{
pthread_mutex_destroy(&handle.mutex);
return -1;
}
handle.valid_id = false;
handle.count = 0;
#endif
return 0;
}
int main(){
static const int threadNb = 100;
int tids[threadNb] ;
pthread_t threads[threadNb];
//mutex initialization with non-default attribute
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_setkind_np(&attr, PTHREAD_MUTEX_ERRORCHECK_NP);
pthread_mutex_init(&pseudoListMutex, &attr);
pthread_mutexattr_destroy(&attr);
for(int i=0; i<threadNb; i++){
tids[i] = i;
pthread_create(&threads[i], NULL, &threadFun, &tids[i]);
}
for(int i=0; i<threadNb; i++)
pthread_join(threads[i], NULL);
return 0;
}
/*****************************************************************************
* vlc_mutex_init: initialize a recursive mutex (Do not use)
*****************************************************************************/
int vlc_mutex_init_recursive( vlc_mutex_t *p_mutex )
{
#if defined( LIBVLC_USE_PTHREAD )
pthread_mutexattr_t attr;
int i_result;
pthread_mutexattr_init( &attr );
# if defined (__GLIBC__) && (__GLIBC_MINOR__ < 6)
pthread_mutexattr_setkind_np( &attr, PTHREAD_MUTEX_RECURSIVE_NP );
# else
pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
# endif
i_result = pthread_mutex_init( p_mutex, &attr );
pthread_mutexattr_destroy( &attr );
return( i_result );
#elif defined( WIN32 )
/* Create mutex returns a recursive mutex */
*p_mutex = CreateMutex( 0, FALSE, 0 );
return (*p_mutex != NULL) ? 0 : ENOMEM;
#else
# error Unimplemented!
#endif
}
void FNI_InflateObject(JNIEnv *env, jobject wrapped_obj) {
struct oobj *obj = FNI_UNWRAP_MASKED(wrapped_obj);
FLEX_MUTEX_LOCK(&global_inflate_mutex);
/* be careful in case someone inflates this guy while our back is turned */
if (!FNI_IS_INFLATED(wrapped_obj)) {
/* all data in inflated_oobj is managed manually, so we can use malloc */
struct inflated_oobj *infl =
#if defined(WITH_TRANSACTIONS) && defined(BDW_CONSERVATIVE_GC)
#ifdef WITH_GC_STATS
GC_malloc_uncollectable_stats
#else
GC_malloc_uncollectable /* transactions stores version info here */
#endif
#else
malloc
#endif
(sizeof(*infl));
#if (!defined(WITH_TRANSACTIONS)) || (!defined(BDW_CONSERVATIVE_GC))
INCREMENT_MEM_STATS(sizeof(*infl));
#endif
/* initialize infl */
memset(infl, 0, sizeof(*infl));
#ifndef WITH_HASHLOCK_SHRINK
infl->hashcode = HASHCODE_MASK(obj->hashunion.hashcode);
#endif /* !WITH_HASHLOCK_SHRINK */
#if WITH_HEAVY_THREADS || WITH_PTH_THREADS || WITH_USER_THREADS
# ifdef ERROR_CHECKING_LOCKS
/* error checking locks are slower, but catch more bugs (maybe) */
{ pthread_mutexattr_t attr; pthread_mutexattr_init(&attr);
pthread_mutexattr_setkind_np(&attr, PTHREAD_MUTEX_ERRORCHECK_NP);
pthread_mutex_init(&(infl->mutex), &attr);
pthread_mutexattr_destroy(&attr);
}
# else /* !ERROR_CHECKING_LOCKS */
pthread_mutex_init(&(infl->mutex), NULL);
# endif /* ERROR_CHECKING_LOCKS || !ERROR_CHECKING_LOCKS */
pthread_cond_init(&(infl->cond), NULL);
pthread_rwlock_init(&(infl->jni_data_lock), NULL);
#endif
#ifndef WITH_HASHLOCK_SHRINK
#ifndef WITH_DYNAMIC_WB
obj->hashunion.inflated = infl;
#else /* WITH_DYNAMIC_WB */
obj->hashunion.inflated = (struct inflated_oobj *)
((ptroff_t) infl | (obj->hashunion.hashcode & 2));
#endif /* WITH_DYNAMIC_WB */
#else /* WITH_HASHLOCK_SHRINK */
infl_table_set(INFL_LOCK, obj, infl, NULL);
#endif /* WITH_HASHLOCK_SHRINK */
assert(FNI_IS_INFLATED(wrapped_obj));
#ifdef WITH_PRECISE_GC
#if defined(WITH_REALTIME_JAVA) && defined(WITH_NOHEAP_SUPPORT)
/* Can't inflate a heap reference in a NoHeapRealtimeThread */
assert((!(((ptroff_t)FNI_UNWRAP(wrapped_obj))&1))||
(!((struct FNI_Thread_State*)env)->noheap));
if (((ptroff_t)FNI_UNWRAP(wrapped_obj))&1) /* register only if in heap */
#endif
precise_register_inflated_obj(obj,
#ifdef WITH_REALTIME_JAVA
(void (*)(jobject_unwrapped, ptroff_t))
#endif
deflate_object);
#elif defined(BDW_CONSERVATIVE_GC)
/* register finalizer to deallocate inflated_oobj on gc */
if (GC_base(obj)!=NULL) {// skip if this is not a heap-allocated object
GC_register_finalizer_no_order(GC_base(obj), deflate_object,
(GC_PTR) ((void*)obj-(void*)GC_base(obj)),
&(infl->old_finalizer),
&(infl->old_client_data));
}
#endif
#ifdef WITH_REALTIME_JAVA
# ifdef BDW_CONSERVATIVE_GC /* XXX this test may be reversed? see v1.29 XXX */
if (GC_base(obj)!=NULL) /* skip if this is not a heap-allocated object */
# endif /* BDW_CONSERVATIVE_GC */
RTJ_register_finalizer(wrapped_obj, deflate_object);
#endif
}
FLEX_MUTEX_UNLOCK(&global_inflate_mutex);
}
uintptr_t _createmutexex( SECURITY_ATTRIBUTES *sa, const char *name, unsigned flags, unsigned access )
{
//NOTE: Windows critical sections are recursive
//NOTE: posix recursive mutexes don't return error code
int rc;
pthread_mutex_t *pm;
pthread_mutexattr_t mattr;
int fd_mutex = -1;
char shmname[MAX_PATH+1];
size_t namelen = 0;
bool opened = false;
uintptr_t hndl;
if ( name && *name ) {
namelen = strlen (name);
if ( 1+namelen > NAME_MAX ) {
_setlasterror( ERROR_BAD_ARGUMENTS );
return (uintptr_t)NULL;
}
shmname[0] = '/';
strcpy (shmname+1, name);
//try to open mutex first
fd_mutex = shm_open (shmname, O_RDWR, S_IRUSR|S_IWUSR);
if ( fd_mutex != -1 ) {
struct flock fl;
fl.l_type = F_WRLCK; //note: check only
fl.l_whence = SEEK_SET;
fl.l_start = 0;
fl.l_len = 0;
fl.l_pid = getpid ();
rc = fcntl (fd_mutex, F_GETLK, &fl);
if (!(rc == 0 && fl.l_type == F_RDLCK)) {
//semaphore is unused or other error
ftruncate (fd_mutex, sizeof(pthread_mutex_t));
} else {
_setlasterror( ERROR_ALREADY_EXISTS );
opened = true;
}
} else {
//create new semaphore
fd_mutex = shm_open (shmname, O_CREAT|O_RDWR, S_IRUSR|S_IWUSR);
if ( fd_mutex == -1 ) {
_setlasterror( get_win_error (errno) );
return (uintptr_t)NULL;
}
ftruncate (fd_mutex, sizeof(pthread_mutex_t));
}
void *addr_mutex = mmap (0, sizeof(pthread_mutex_t), PROT_READ|PROT_WRITE, MAP_SHARED, fd_mutex, 0);
if (addr_mutex == MAP_FAILED) {
_setlasterror( get_win_error (errno) );
close (fd_mutex);
if (!opened) shm_unlink (shmname);
return (uintptr_t)NULL;
}
//add file open check
struct flock fl;
fl.l_type = F_RDLCK;
fl.l_whence = SEEK_SET;
fl.l_start = 0;
fl.l_len = 0;
fl.l_pid = getpid ();
fcntl (fd_mutex, F_SETLK, &fl);
pm = (pthread_mutex_t *)addr_mutex;
}
else
{
pm = (pthread_mutex_t *) malloc (sizeof(pthread_mutex_t));
if ( !pm ) {
_setlasterror( get_win_error (errno) ); //ERROR_NOT_ENOUGH_MEMORY
return (uintptr_t)NULL;
}
}
if (!opened) {
//initialize mutex
pthread_mutexattr_init (&mattr);
if ( name && *name )
pthread_mutexattr_setpshared (&mattr, PTHREAD_PROCESS_SHARED);
else
pthread_mutexattr_setpshared (&mattr, PTHREAD_PROCESS_PRIVATE);
#if defined (__linux__) || defined (__bsd__)
pthread_mutexattr_setkind_np (&mattr, PTHREAD_MUTEX_RECURSIVE_NP);
#else
pthread_mutexattr_settype (&mattr, PTHREAD_MUTEX_RECURSIVE);
#endif
rc = pthread_mutex_init (pm, &mattr);
pthread_mutexattr_destroy (&mattr);
if ( rc != 0 ) {
_setlasterror( get_win_error (rc) );
if ( name && *name ) {
munmap ((void*)pm, sizeof(pthread_mutex_t));
shm_unlink (shmname);
close (fd_mutex);
} else
free (pm);
return (uintptr_t)NULL;
}
}
size_t datalen = sizeof(MUTEXOBJDATA) + (name ? namelen+2 : 0);
MUTEXOBJDATA* data;
data = (MUTEXOBJDATA*)malloc (datalen);
if (!data) {
_setlasterror( get_win_error (rc) );
if ( name && *name ) {
munmap ((void*)pm, sizeof(pthread_mutex_t));
if (!opened) shm_unlink (shmname);
close (fd_mutex);
} else
free (pm);
return (uintptr_t)NULL;
}
data->fdmutex = fd_mutex;
strcpy (data->name, (name && *name ? shmname : ""));
//(flags && CREATE_MUTEX_INITIAL_OWNER)
hndl = _createhandle (-1, 0, &mutexkrnlobj, &pm, sizeof(void*), data, datalen);
if ( !hndl ) {
_setlasterror( get_win_error (errno) );
pthread_mutex_destroy (pm); //destroy created mutex
if ( name && *name ) {
munmap ((void*)pm, sizeof(pthread_mutex_t));
if (!opened) shm_unlink (shmname);
close (fd_mutex);
} else
free (pm);
free (data);
return (uintptr_t)NULL;
}
free (data);
return hndl;
}
static int open_s(stream_t *stream,int mode, void* opts, int* file_format) {
int f;
struct stream_priv_s* p = (struct stream_priv_s*)opts;
//printf("open_s called for stream_Sagetv\n");fflush(stdout);
if(mode != STREAM_READ)
return STREAM_UNSUPORTED;
if(!p->host) {
mp_msg(MSGT_OPEN,MSGL_ERR, "We need an host name (ex: stv://server.net/cdda://5)\n");
m_struct_free(&stream_opts,opts);
return STREAM_ERROR;
}
if(!p->url || strlen(p->url) == 0) {
mp_msg(MSGT_OPEN,MSGL_ERR, "We need a remote url (ex: mpst://server.net/cdda://5)\n");
m_struct_free(&stream_opts,opts);
return STREAM_ERROR;
}
stream->priv = p;
if (!OpenConnection(stream))
{
stream->priv = 0;
m_struct_free(&stream_opts,opts);
return STREAM_ERROR;
}
stream->flags = STREAM_SEEK;
#ifndef WIN32
pthread_mutexattr_t attr;
p->mutex = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
if (p->mutex)
{
pthread_mutexattr_init(&attr);
#ifdef CONFIG_DARWIN
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
#else
pthread_mutexattr_setkind_np(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
#endif
if (pthread_mutex_init(p->mutex, &attr) != 0)
{
free(p->mutex);
p->mutex = NULL;
printf("MUTEX creation failed for pthread\n");
}
}
#else
p->mutex = (LPCRITICAL_SECTION) malloc(sizeof(CRITICAL_SECTION));
InitializeCriticalSection(p->mutex);
#endif
stream->end_pos = size(stream, NULL);
if (stream->activeFileFlag)
p->actualSize = 0;
else
p->actualSize = stream->end_pos;
stream->fill_buffer = fill_buffer;
stream->control = control;
stream->size = size;
stream->seek = seek;
stream->close = close_s;
stream->type = STREAMTYPE_FILE;
return STREAM_OK;
}
/*
==================
CalcPortalVis
==================
*/
void CalcPortalVis (void)
{
int i;
// fastvis just uses mightsee for a very loose bound
if (fastvis)
{
for (i=0 ; i<numportals*2 ; i++)
{
portals[i].visbits = portals[i].mightsee;
portals[i].status = stat_done;
}
return;
}
leafon = 0;
#ifdef __alpha
{
pthread_t work_threads[MAX_THREADS];
pthread_addr_t status;
pthread_attr_t attrib;
pthread_mutexattr_t mattrib;
int i;
my_mutex = malloc (sizeof(*my_mutex));
if (pthread_mutexattr_create (&mattrib) == -1)
Error ("pthread_mutex_attr_create failed");
if (pthread_mutexattr_setkind_np (&mattrib, MUTEX_FAST_NP) == -1)
Error ("pthread_mutexattr_setkind_np failed");
if (pthread_mutex_init (my_mutex, mattrib) == -1)
Error ("pthread_mutex_init failed");
if (pthread_attr_create (&attrib) == -1)
Error ("pthread_attr_create failed");
if (pthread_attr_setstacksize (&attrib, 0x100000) == -1)
Error ("pthread_attr_setstacksize failed");
for (i=0 ; i<numthreads ; i++)
{
if (pthread_create(&work_threads[i], attrib
, LeafThread, (pthread_addr_t)i) == -1)
Error ("pthread_create failed");
}
for (i=0 ; i<numthreads ; i++)
{
if (pthread_join (work_threads[i], &status) == -1)
Error ("pthread_join failed");
}
if (pthread_mutex_destroy (my_mutex) == -1)
Error ("pthread_mutex_destroy failed");
}
#else
LeafThread (0);
#endif
if (verbose)
{
printf ("portalcheck: %i portaltest: %i portalpass: %i\n",c_portalcheck, c_portaltest, c_portalpass);
printf ("c_vistest: %i c_mighttest: %i\n",c_vistest, c_mighttest);
}
}
/*
* The main thread must call this function to convert itself into a thread.
*/
thread_t *
thread_initial (unsigned long stack_size)
{
int rc;
thread_t *thr = NULL;
if (_main_thread)
return _main_thread;
/*
* Initialize pthread key
*/
#ifndef OLD_PTHREADS
rc = pthread_key_create (&_key_current, NULL);
#else
rc = pthread_keycreate (&_key_current, NULL);
#endif
CKRET (rc);
/*
* Start off with a value of NULL
*/
rc = pthread_setspecific (_key_current, NULL);
CKRET (rc);
/*
* Initialize default thread/mutex attributes
*/
#ifndef OLD_PTHREADS
/* attribute for thread creation */
rc = pthread_attr_init (&_thread_attr);
CKRET (rc);
/* attribute for mutex creation */
rc = pthread_mutexattr_init (&_mutex_attr);
CKRET (rc);
#else
rc = pthread_attr_create (&_thread_attr);
CKRET (rc);
rc = pthread_mutexattr_create (&_mutex_attr);
CKRET (rc);
#endif
#if defined (PTHREAD_PROCESS_PRIVATE) && !defined(oldlinux) && !defined(__FreeBSD__)
rc = pthread_mutexattr_setpshared (&_mutex_attr, PTHREAD_PROCESS_PRIVATE);
CKRET (rc);
#endif
#if defined (MUTEX_FAST_NP) && !defined (_AIX)
rc = pthread_mutexattr_setkind_np (&_mutex_attr, MUTEX_FAST_NP);
CKRET (rc);
#endif
#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
rc = pthread_mutexattr_settype (&_mutex_attr, PTHREAD_MUTEX_ADAPTIVE_NP);
CKRET (rc);
#endif
/*
* Allocate a thread structure
*/
thr = (thread_t *) dk_alloc (sizeof (thread_t));
memset (thr, 0, sizeof (thread_t));
assert (_main_thread == NULL);
_main_thread = thr;
_sched_init ();
if (stack_size == 0)
stack_size = MAIN_STACK_SIZE;
#if (SIZEOF_VOID_P == 8)
stack_size *= 2;
#endif
#if defined (__x86_64 ) && defined (SOLARIS)
/*GK: the LDAP on that platform requires that */
stack_size *= 2;
#endif
stack_size = ((stack_size / 8192) + 1) * 8192;
thr->thr_stack_size = stack_size;
thr->thr_status = RUNNING;
thr->thr_cv = _alloc_cv ();
thr->thr_sem = semaphore_allocate (0);
thr->thr_schedule_sem = semaphore_allocate (0);
if (thr->thr_cv == NULL)
goto failed;
_thread_init_attributes (thr);
thread_set_priority (thr, NORMAL_PRIORITY);
rc = pthread_setspecific (_key_current, thr);
CKRET (rc);
return thr;
failed:
if (thr)
{
_thread_free_attributes (thr);
dk_free (thr, sizeof (thread_t));
}
return NULL;
}