#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.
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.
{
rlwthread_sleep(msec);
}
| int rlwrapdestroy_semaphore | ( | WSEMAPHORE * | s | ) |
Definition at line 291 of file rlwthread.cpp.
{
#ifdef RLWIN32
CloseHandle(s->hSemaphore);
#else
rlwthread_mutex_destroy(&s->mutex);
#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
}
