rllib  1
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros
Classes | Typedefs | Functions
rlwthread.h File Reference
#include "rldefine.h"
#include <windows.h>
#include <winbase.h>
#include <stddef.h>
#include <string.h>
Include dependency graph for rlwthread.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  __sched_param
 
struct  pthread_attr_t
 
struct  WSEMAPHORE
 

Typedefs

typedef unsigned long int pthread_t
 
typedef struct __sched_param SCHED_PARAM
 
typedef HANDLE pthread_mutex_t
 
typedef long pthread_mutexattr_t
 

Functions

int rlwthread_attr_init (pthread_attr_t *attr)
 
int rlwthread_create (pthread_t *tid, const pthread_attr_t *attr, void *(*func)(void *), void *arg)
 
void rlwthread_close_handle (pthread_t *tid)
 
void rlwthread_exit (void *status)
 
int rlwthread_join (pthread_t tid, void **status)
 
int rlwthread_mutex_init (pthread_mutex_t *mptr, const pthread_mutexattr_t *attr)
 
int rlwthread_mutex_destroy (pthread_mutex_t *mptr)
 
int rlwthread_mutex_lock (pthread_mutex_t *mptr)
 
int rlwthread_mutex_trylock (pthread_mutex_t *mptr)
 
int rlwthread_mutex_unlock (pthread_mutex_t *mptr)
 
int rlwthread_cancel (pthread_t tid)
 
int rlwrapinit_semaphore (WSEMAPHORE *s, int cmax)
 
int rlwrapdestroy_semaphore (WSEMAPHORE *s)
 
int rlwrapincrement_semaphore (WSEMAPHORE *s)
 
int rlwrapwait_semaphore (WSEMAPHORE *s)
 
int rlwthread_sleep (long msec)
 
void rlsleep (long msec)
 

Typedef Documentation

typedef HANDLE pthread_mutex_t

Definition at line 61 of file rlwthread.h.

typedef long pthread_mutexattr_t

Definition at line 63 of file rlwthread.h.

typedef unsigned long int pthread_t

Definition at line 40 of file rlwthread.h.

typedef struct __sched_param SCHED_PARAM

Function Documentation

void rlsleep ( long  msec)

Definition at line 393 of file rlwthread.cpp.

{
}
int rlwrapdestroy_semaphore ( WSEMAPHORE s)

Definition at line 291 of file rlwthread.cpp.

{
#ifdef RLWIN32
CloseHandle(s->hSemaphore);
#else
#endif
return 0;
}
int rlwrapincrement_semaphore ( WSEMAPHORE s)

Definition at line 307 of file rlwthread.cpp.

{
/* Increment the count of the semaphore. */
#ifdef RLWIN32
if(!ReleaseSemaphore(
s->hSemaphore, /* handle of semaphore */
1, /* increase count by one */
NULL) ) /* not interested in previous count */
{
return -1; /* Deal with the error. */
}
return 0;
#else
pthread_mutex_lock(&s->mutex);
if(s->nready == 0) pthread_cond_signal(&s->cond);
s->nready++;
pthread_mutex_unlock(&s->mutex);
return 0;
#endif
}
int rlwrapinit_semaphore ( WSEMAPHORE s,
int  cmax 
)

Definition at line 265 of file rlwthread.cpp.

{
/* Create a semaphore with initial count=0 max. counts of cmax. */
#ifdef RLWIN32
s->cmax = cmax;
s->hSemaphore = CreateSemaphore(
NULL, /* no security attributes */
0, /* initial count */
cmax, /* maximum count */
NULL); /* unnamed semaphore */
if(s->hSemaphore == NULL) return -1; /* Check for error. */
return 0;
#else
s->cmax = cmax;
s->nready = 0;
rlwthread_mutex_init(&s->mutex, NULL);
pthread_cond_init(&s->cond, NULL);
return 0;
#endif
}
int rlwrapwait_semaphore ( WSEMAPHORE s)

Definition at line 338 of file rlwthread.cpp.

{
#ifdef RLWIN32
int ret;
ret = WaitForSingleObject(
s->hSemaphore, /* handle of semaphore */
INFINITE); /* infinite time-out interval */
if(ret) return 0;
return 0;
#else
pthread_mutex_lock(&s->mutex);
while(s->nready == 0)
{
pthread_cond_wait(&s->cond,&s->mutex);
}
s->nready--;
pthread_mutex_unlock(&s->mutex);
return 0;
#endif
}
int rlwthread_attr_init ( pthread_attr_t attr)

Definition at line 36 of file rlwthread.cpp.

{
#ifdef RLWIN32
memset(attr,0,sizeof(pthread_attr_t));
return 0;
#else
return pthread_attr_init(attr);
#endif
}
int rlwthread_cancel ( pthread_t  tid)

Definition at line 250 of file rlwthread.cpp.

{
#ifdef RLWIN32
return (int) CloseHandle((HANDLE) tid);
#else
return pthread_cancel(tid);
#endif
}
void rlwthread_close_handle ( pthread_t tid)

Definition at line 79 of file rlwthread.cpp.

{
#ifdef RLWIN32
CloseHandle((HANDLE) *tid);
#else
if(tid == NULL) return;
#endif
}
int rlwthread_create ( pthread_t tid,
const pthread_attr_t attr,
void *(*)(void *)  func,
void *  arg 
)

Definition at line 54 of file rlwthread.cpp.

{
#ifdef RLWIN32
HANDLE handle;
int ThreadId;
int dwStackSize = 0;
if(attr != NULL) dwStackSize = attr->__stacksize;
handle = CreateThread( NULL, /* pointer to thread security attributes */
dwStackSize, /* initial thread stack size, in bytes */
(LPTHREAD_START_ROUTINE)func, /* pointer to thread function */
arg, /* argument for new thread */
0, /* creation flags */
(unsigned long *) &ThreadId /* pointer to returned thread identifier */
);
*tid = (pthread_t) handle;
if(handle == NULL) return -1;
else return 0;
#else
int ret = pthread_create(tid,attr,func,arg);
pthread_detach(*tid);
return ret;
#endif
}
void rlwthread_exit ( void *  status)

Definition at line 94 of file rlwthread.cpp.

{
#ifdef RLWIN32
DWORD *ptr;
ptr = (DWORD *) status;
if(status == NULL) ExitThread((DWORD) 0);
else ExitThread(*ptr);
#else
pthread_exit(status);
#endif
}
int rlwthread_join ( pthread_t  tid,
void **  status 
)

Definition at line 113 of file rlwthread.cpp.

{
#ifdef RLWIN32
#ifdef USE_OLD_JOIN
DWORD exitcode;
while(1)
{
GetExitCodeThread((HANDLE) tid,&exitcode);
if(exitcode != STILL_ACTIVE) return exitcode;
Sleep(10); /* sleep 10 msec */
}
#else
int result = 1;
DWORD exitcode;
DWORD dwWait = WaitForSingleObject((HANDLE) tid, INFINITE);
if(dwWait == WAIT_OBJECT_0)
{
if(GetExitCodeThread((HANDLE) tid, &exitcode) == TRUE)
{
result = 0;
*status = (int) exitcode; // ???
}
else
{
result = GetLastError();
}
}
else if(dwWait == WAIT_FAILED)
{
result = GetLastError();
}
return result;
#endif
#else
return pthread_join(tid,status);
#endif
}
int rlwthread_mutex_destroy ( pthread_mutex_t mptr)

Definition at line 175 of file rlwthread.cpp.

{
#ifdef RLWIN32
CloseHandle(*mptr);
//old DeleteCriticalSection(mptr);
return 0;
#else
return pthread_mutex_destroy(mptr);
#endif
}
int rlwthread_mutex_init ( pthread_mutex_t mptr,
const pthread_mutexattr_t attr 
)

Definition at line 158 of file rlwthread.cpp.

{
#ifdef RLWIN32
HANDLE handle = CreateMutex(NULL, FALSE, NULL);
if(handle) *mptr = handle;
//old InitializeCriticalSection(mptr);
return 0;
#else
return pthread_mutex_init(mptr,attr);
#endif
}
int rlwthread_mutex_lock ( pthread_mutex_t mptr)

Definition at line 190 of file rlwthread.cpp.

{
#ifdef RLWIN32
if(WaitForSingleObject(*mptr, INFINITE) == WAIT_OBJECT_0) return 0;
//old EnterCriticalSection(mptr); // pointer to critical section object
return 0;
#else
return pthread_mutex_lock(mptr);
#endif
}
int rlwthread_mutex_trylock ( pthread_mutex_t mptr)

Definition at line 212 of file rlwthread.cpp.

{
#ifdef RLWIN32
DWORD ret;
ret = WaitForSingleObject(*mptr, 0);
if(ret == WAIT_OBJECT_0) return 1;
return 0;
//old ret = TryEnterCriticalSection(mptr); // pointer to critical section object
return ret;
#else
int ret;
ret = pthread_mutex_trylock(mptr);
if(ret == EBUSY) return 0;
return 1;
#endif
}
int rlwthread_mutex_unlock ( pthread_mutex_t mptr)

Definition at line 235 of file rlwthread.cpp.

{
#ifdef RLWIN32
ReleaseMutex(*mptr);
//old LeaveCriticalSection(mptr);
return 0;
#else
return pthread_mutex_unlock(mptr);
#endif
}
int rlwthread_sleep ( long  msec)

Definition at line 363 of file rlwthread.cpp.

{
#ifdef RLWIN32
Sleep(msec);
return 0;
#endif
#ifdef RLUNIX
fd_set wset,rset,eset;
struct timeval timeout;
FD_ZERO(&rset);
FD_ZERO(&wset);
FD_ZERO(&eset);
timeout.tv_sec = msec / 1000;
timeout.tv_usec = (msec % 1000) * 1000;
select(1,&rset,&wset,&eset,&timeout);
return 0;
#endif
#ifdef __VMS
struct timespec interval;
interval.tv_sec = msec / 1000;
interval.tv_nsec = (msec % 1000) * 1000 * 1000; /* wait msec msec */
pthread_delay_np(&interval);
return 0;
#endif
}