mirror of
https://github.com/peterosterlund2/droidfish.git
synced 2024-12-18 08:07:01 +01:00
275 lines
7.0 KiB
C
275 lines
7.0 KiB
C
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#include "sysport.h"
|
|
|
|
/**** CLOCK *************************************************************************/
|
|
|
|
#if defined(USECLOCK)
|
|
|
|
#include <time.h>
|
|
extern myclock_t myclock(void) {return (myclock_t)clock();}
|
|
extern myclock_t ticks_per_sec (void) {return CLOCKS_PER_SEC;}
|
|
|
|
#elif defined(USEWINCLOCK)
|
|
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <windows.h>
|
|
extern myclock_t myclock(void) {return (myclock_t)GetTickCount();}
|
|
extern myclock_t ticks_per_sec (void) {return 1000;}
|
|
|
|
|
|
#elif defined(USELINCLOCK)
|
|
|
|
#include <sys/time.h>
|
|
extern myclock_t myclock(void)
|
|
{
|
|
struct timeval tv;
|
|
gettimeofday(&tv, NULL);
|
|
return (myclock_t)tv.tv_sec * 1000 + (myclock_t)tv.tv_usec/1000;
|
|
}
|
|
extern myclock_t ticks_per_sec (void) {return 1000;}
|
|
|
|
#else
|
|
|
|
#error No Clock specified in compilation
|
|
|
|
#endif
|
|
|
|
/**** PATH NAMES *************************************************************************/
|
|
|
|
#if defined(GCCLINUX)
|
|
extern int isfoldersep (int x) { return x == '/';}
|
|
#elif defined(MVSC)
|
|
extern int isfoldersep (int x) { return x == '\\' || x == ':';}
|
|
#else
|
|
extern int isfoldersep (int x) { return x == '/' || x == '\\' || x == ':';}
|
|
#endif
|
|
|
|
/**** Maximum Files Open *****************************************************************/
|
|
|
|
#if defined(GCCLINUX)
|
|
#include <sys/resource.h>
|
|
#if 0
|
|
struct rlimit {
|
|
rlim_t rlim_cur; /* Soft limit */
|
|
rlim_t rlim_max; /* Hard limit (ceiling for rlim_cur) */
|
|
};
|
|
#endif
|
|
extern int mysys_fopen_max (void)
|
|
{
|
|
int ok;
|
|
struct rlimit rl;
|
|
ok = 0 == getrlimit(RLIMIT_NOFILE, &rl);
|
|
if (ok)
|
|
return (int)rl.rlim_cur;
|
|
else
|
|
return FOPEN_MAX;
|
|
}
|
|
#elif defined(MVSC)
|
|
extern int mysys_fopen_max (void) { return FOPEN_MAX;}
|
|
#else
|
|
extern int mysys_fopen_max (void) { return FOPEN_MAX;}
|
|
#endif
|
|
|
|
|
|
#if defined(MULTI_THREADED_INTERFACE)
|
|
/**** THREADS ****************************************************************************/
|
|
|
|
/*
|
|
|
|
|
| POSIX
|
|
|
|
|
\*-------------------------*/
|
|
#if defined (POSIX_THREADS)
|
|
|
|
#include <pthread.h>
|
|
|
|
extern int /* boolean */
|
|
mythread_create (/*@out@*/ mythread_t *thread, routine_t start_routine, void *arg, /*@out@*/ int *ret_error)
|
|
{
|
|
const pthread_attr_t *attr = NULL; /* default attributes */
|
|
int ret;
|
|
ret = pthread_create (thread, attr, start_routine, arg);
|
|
*ret_error = ret;
|
|
return 0 == ret;
|
|
}
|
|
|
|
extern int /* boolean */
|
|
mythread_join (mythread_t thread)
|
|
{
|
|
void *p; /* value return from pthread_exit, not used */
|
|
int ret = pthread_join (thread, &p);
|
|
return 0 == ret;
|
|
}
|
|
|
|
extern void
|
|
mythread_exit (void)
|
|
{
|
|
pthread_exit (NULL);
|
|
}
|
|
|
|
|
|
extern const char *
|
|
mythread_create_error (int err)
|
|
{
|
|
const char *s;
|
|
switch (err) {
|
|
case 0 : s = "Success"; break;
|
|
case EAGAIN: s = "EAGAIN" ; break;
|
|
case EINVAL: s = "EINVAL" ; break;
|
|
case EPERM : s = "EPERM" ; break;
|
|
default : s = "Unknown error"; break;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
extern void mythread_mutex_init (mythread_mutex_t *m) { pthread_mutex_init (m,NULL);}
|
|
extern void mythread_mutex_destroy (mythread_mutex_t *m) { pthread_mutex_destroy(m) ;}
|
|
extern void mythread_mutex_lock (mythread_mutex_t *m) { pthread_mutex_lock (m) ;}
|
|
extern void mythread_mutex_unlock (mythread_mutex_t *m) { pthread_mutex_unlock (m) ;}
|
|
|
|
#ifdef SPINLOCKS
|
|
extern void mythread_spinx_init (mythread_spinx_t *m) { pthread_spin_init (m,0);} /**/
|
|
extern void mythread_spinx_destroy (mythread_spinx_t *m) { pthread_spin_destroy(m) ;} /**/
|
|
extern void mythread_spinx_lock (mythread_spinx_t *m) { pthread_spin_lock (m) ;} /**/
|
|
extern void mythread_spinx_unlock (mythread_spinx_t *m) { pthread_spin_unlock (m) ;} /**/
|
|
#else
|
|
extern void mythread_spinx_init (mythread_spinx_t *m) { pthread_mutex_init (m,NULL);} /**/
|
|
extern void mythread_spinx_destroy (mythread_spinx_t *m) { pthread_mutex_destroy(m) ;} /**/
|
|
extern void mythread_spinx_lock (mythread_spinx_t *m) { pthread_mutex_lock (m) ;} /**/
|
|
extern void mythread_spinx_unlock (mythread_spinx_t *m) { pthread_mutex_unlock (m) ;} /**/
|
|
#endif
|
|
|
|
/* semaphores */
|
|
extern int /* boolean */
|
|
mysem_init (mysem_t *sem, unsigned int value)
|
|
{ return -1 != sem_init (sem, 0 /*not shared with processes*/, value);}
|
|
|
|
extern int /* boolean */
|
|
mysem_wait (mysem_t *sem)
|
|
{ return 0 == sem_wait (sem);}
|
|
|
|
extern int /* boolean */
|
|
mysem_post (mysem_t *sem)
|
|
{ return 0 == sem_post (sem);}
|
|
|
|
extern int /* boolean */
|
|
mysem_destroy (mysem_t *sem)
|
|
{ return 0 == sem_destroy (sem);}
|
|
|
|
/*
|
|
|
|
|
| NT_THREADS
|
|
|
|
|
\*-------------------------*/
|
|
#elif defined(NT_THREADS)
|
|
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <windows.h>
|
|
#include <process.h>
|
|
|
|
extern int /* boolean */
|
|
mythread_create (/*@out@*/ mythread_t *thread, routine_t start_routine, void *arg, /*@out@*/ int *ret_error)
|
|
{
|
|
static unsigned int thread_id;
|
|
mythread_t t;
|
|
int /* boolean */ is_ok;
|
|
|
|
t = (mythread_t) _beginthreadex (NULL, 0, start_routine, arg, 0, &thread_id );
|
|
is_ok = (t != 0);
|
|
*thread = t;
|
|
*ret_error = is_ok? 0: errno;
|
|
return is_ok;
|
|
}
|
|
|
|
extern int /* boolean */
|
|
mythread_join (mythread_t thread)
|
|
{
|
|
unsigned long int ret;
|
|
ret = WaitForSingleObject (thread, INFINITE);
|
|
CloseHandle(thread);
|
|
return ret != WAIT_FAILED;
|
|
}
|
|
|
|
extern void
|
|
mythread_exit (void)
|
|
{
|
|
return;
|
|
}
|
|
|
|
extern const char *
|
|
mythread_create_error (int err)
|
|
{
|
|
const char *s;
|
|
switch (err) {
|
|
case 0 : s = "Success"; break;
|
|
case EAGAIN: s = "EAGAIN" ; break;
|
|
case EINVAL: s = "EINVAL" ; break;
|
|
case EPERM : s = "EPERM" ; break;
|
|
default : s = "Unknown error"; break;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
extern void mythread_mutex_init (mythread_mutex_t *m) { *m = CreateMutex(0, FALSE, 0) ;}
|
|
extern void mythread_mutex_destroy (mythread_mutex_t *m) { CloseHandle(*m) ;}
|
|
extern void mythread_mutex_lock (mythread_mutex_t *m) { WaitForSingleObject(*m, INFINITE) ;}
|
|
extern void mythread_mutex_unlock (mythread_mutex_t *m) { ReleaseMutex(*m) ;}
|
|
|
|
extern void mythread_spinx_init (mythread_spinx_t *m) { InitializeCriticalSection(m) ;} /**/
|
|
extern void mythread_spinx_destroy (mythread_spinx_t *m) { DeleteCriticalSection(m) ;} /**/
|
|
extern void mythread_spinx_lock (mythread_spinx_t *m) { EnterCriticalSection (m) ;} /**/
|
|
extern void mythread_spinx_unlock (mythread_spinx_t *m) { LeaveCriticalSection (m) ;} /**/
|
|
|
|
/* semaphores */
|
|
extern int /* boolean */
|
|
mysem_init (mysem_t *sem, unsigned int value)
|
|
{
|
|
mysem_t h =
|
|
CreateSemaphore(
|
|
NULL, /* cannot be inherited */
|
|
(LONG)value,/* Initial Count */
|
|
256, /* Maximum Count */
|
|
NULL /* Name --> NULL, not shared among threads */
|
|
);
|
|
|
|
if (h != NULL) *sem = h;
|
|
|
|
return h != NULL;
|
|
}
|
|
|
|
extern int /* boolean */
|
|
mysem_wait (mysem_t *sem)
|
|
{
|
|
HANDLE h = *sem;
|
|
return WAIT_FAILED != WaitForSingleObject (h, INFINITE);
|
|
}
|
|
|
|
extern int /* boolean */
|
|
mysem_post (mysem_t *sem)
|
|
{
|
|
HANDLE h = *sem;
|
|
return 0 != ReleaseSemaphore(h, 1, NULL);
|
|
}
|
|
|
|
extern int /* boolean */
|
|
mysem_destroy (mysem_t *sem)
|
|
{
|
|
return 0 != CloseHandle( *sem);
|
|
}
|
|
|
|
/**** THREADS ****************************************************************************/
|
|
#else
|
|
#error Definition of threads not present
|
|
#endif
|
|
|
|
/* MULTI_THREADED_INTERFACE */
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|