mirror of
https://github.com/SDL-Hercules-390/hyperion.git
synced 2026-05-10 12:21:43 +02:00
870 lines
20 KiB
C
870 lines
20 KiB
C
////////////////////////////////////////////////////////////////////////////////////
|
|
// fthreads.c Fish's WIN32 version of pthreads
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// (c) Copyright "Fish" (David B. Trout), 2001, 2002. Released under the Q Public License
|
|
// (http://www.conmicro.cx/hercules/herclic.html) as modifications to Hercules.
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#if defined(HAVE_CONFIG_H)
|
|
#include <config.h> // (needed to set OPTION_FTHREADS flag appropriately)
|
|
#endif
|
|
|
|
#if !defined(OPTION_FTHREADS)
|
|
int dummy = 0;
|
|
#else // defined(OPTION_FTHREADS)
|
|
|
|
#define _WIN32_WINNT 0x0403 // (so "InitializeCriticalSectionAndSpinCount" gets defined)
|
|
#include <windows.h> // (defines "InitializeCriticalSectionAndSpinCount")
|
|
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#include <malloc.h>
|
|
#include <sys/time.h>
|
|
|
|
#include "fthreads.h"
|
|
#include "hostinfo.h"
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#if defined(FISH_HANG)
|
|
|
|
#include "fishhang.h" // (function definitions)
|
|
|
|
#define MyInitializeCriticalSection(lock) (FishHang_InitializeCriticalSection(pszFile,nLine,(CRITICAL_SECTION*)(lock)))
|
|
#define MyEnterCriticalSection(lock) (FishHang_EnterCriticalSection(pszFile,nLine,(CRITICAL_SECTION*)(lock)))
|
|
#define MyTryEnterCriticalSection(lock) (FishHang_TryEnterCriticalSection(pszFile,nLine,(CRITICAL_SECTION*)(lock)))
|
|
#define MyLeaveCriticalSection(lock) (FishHang_LeaveCriticalSection(pszFile,nLine,(CRITICAL_SECTION*)(lock)))
|
|
#define MyDeleteCriticalSection(lock) (FishHang_DeleteCriticalSection(pszFile,nLine,(CRITICAL_SECTION*)(lock)))
|
|
|
|
#define MyCreateThread(secat,stack,start,parm,flags,tid) (FishHang_CreateThread(pszFile,nLine,(secat),(stack),(start),(parm),(flags),(tid)))
|
|
#define MyExitThread(code) (FishHang_ExitThread((code)))
|
|
|
|
#define MyCreateEvent(sec,man,set,name) (FishHang_CreateEvent(pszFile,nLine,(sec),(man),(set),(name)))
|
|
#define MySetEvent(handle) (FishHang_SetEvent(pszFile,nLine,(handle)))
|
|
#define MyResetEvent(handle) (FishHang_ResetEvent(pszFile,nLine,(handle)))
|
|
#define MyDeleteEvent(handle) (FishHang_CloseHandle(pszFile,nLine,(handle)))
|
|
|
|
#define MyWaitForSingleObject(handle,millsecs) (FishHang_WaitForSingleObject(pszFile,nLine,(handle),(millsecs)))
|
|
|
|
#else // !defined(FISH_HANG)
|
|
|
|
#define MyInitializeCriticalSection(pCS) (InitializeCriticalSectionAndSpinCount((CRITICAL_SECTION*)(pCS),3000))
|
|
#define MyEnterCriticalSection(pCS) (EnterCriticalSection((CRITICAL_SECTION*)(pCS)))
|
|
#define MyTryEnterCriticalSection(pCS) (TryEnterCriticalSection((CRITICAL_SECTION*)(pCS)))
|
|
#define MyLeaveCriticalSection(pCS) (LeaveCriticalSection((CRITICAL_SECTION*)(pCS)))
|
|
#define MyDeleteCriticalSection(pCS) (DeleteCriticalSection((CRITICAL_SECTION*)(pCS)))
|
|
|
|
#define MyCreateThread(secat,stack,start,parm,flags,tid) (CreateThread((secat),(stack),(start),(parm),(flags),(tid)))
|
|
#define MyExitThread(code) (ExitThread((code)))
|
|
|
|
#define MyCreateEvent(sec,man,set,name) (CreateEvent((sec),(man),(set),(name)))
|
|
#define MySetEvent(handle) (SetEvent((handle)))
|
|
#define MyResetEvent(handle) (ResetEvent((handle)))
|
|
#define MyDeleteEvent(handle) (CloseHandle((handle)))
|
|
|
|
#define MyWaitForSingleObject(handle,millisecs) (WaitForSingleObject((handle),(millisecs)))
|
|
|
|
#endif // defined(FISH_HANG)
|
|
|
|
#define IsEventSet(hEventHandle) (WaitForSingleObject(hEventHandle,0) == WAIT_OBJECT_0)
|
|
|
|
#define _fthreadmsg(fmt...) \
|
|
do \
|
|
{ \
|
|
fprintf(stderr, fmt); \
|
|
fflush(stderr); \
|
|
} \
|
|
while (0)
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Debugging
|
|
|
|
#if defined(DEBUG) || defined(_DEBUG)
|
|
#define TRACE(a...) _fthreadmsg(a)
|
|
#define ASSERT(a) \
|
|
do \
|
|
{ \
|
|
if (!(a)) \
|
|
{ \
|
|
_fthreadmsg("** Assertion Failed: %s(%d)\n",__FILE__,__LINE__); \
|
|
} \
|
|
} \
|
|
while(0)
|
|
#define VERIFY(a) ASSERT((a))
|
|
#else
|
|
#define TRACE(a...)
|
|
#define ASSERT(a)
|
|
#define VERIFY(a) ((void)(a))
|
|
#endif
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// private internal fthreads CRITICAL_SECTION functions...
|
|
|
|
void
|
|
InitializeFT_MUTEX
|
|
(
|
|
#ifdef FISH_HANG
|
|
char* pszFile,
|
|
int nLine,
|
|
#endif
|
|
fthread_mutex_t* pFT_MUTEX
|
|
)
|
|
{
|
|
MyInitializeCriticalSection(&pFT_MUTEX->MutexLock);
|
|
pFT_MUTEX->hUnlockedEvent = MyCreateEvent(NULL,TRUE,TRUE,NULL); // (initially signalled)
|
|
pFT_MUTEX->nLockedCount = 0;
|
|
pFT_MUTEX->dwLockOwner = 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void
|
|
DeleteFT_MUTEX
|
|
(
|
|
#ifdef FISH_HANG
|
|
char* pszFile,
|
|
int nLine,
|
|
#endif
|
|
fthread_mutex_t* pFT_MUTEX
|
|
)
|
|
{
|
|
ASSERT(IsEventSet(pFT_MUTEX->hUnlockedEvent) && !pFT_MUTEX->nLockedCount);
|
|
pFT_MUTEX->dwLockOwner = 0;
|
|
pFT_MUTEX->nLockedCount = 0;
|
|
MyDeleteEvent(pFT_MUTEX->hUnlockedEvent);
|
|
MyDeleteCriticalSection(&pFT_MUTEX->MutexLock);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void
|
|
EnterFT_MUTEX
|
|
(
|
|
#ifdef FISH_HANG
|
|
char* pszFile,
|
|
int nLine,
|
|
#endif
|
|
fthread_mutex_t* pFT_MUTEX
|
|
)
|
|
{
|
|
if (hostinfo.trycritsec_avail)
|
|
{
|
|
MyEnterCriticalSection(&pFT_MUTEX->MutexLock);
|
|
}
|
|
else
|
|
{
|
|
FT_W32_DWORD dwThreadId = GetCurrentThreadId();
|
|
|
|
for (;;)
|
|
{
|
|
MyEnterCriticalSection(&pFT_MUTEX->MutexLock);
|
|
ASSERT(pFT_MUTEX->nLockedCount >= 0);
|
|
if (pFT_MUTEX->nLockedCount <= 0 || pFT_MUTEX->dwLockOwner == dwThreadId) break;
|
|
MyLeaveCriticalSection(&pFT_MUTEX->MutexLock);
|
|
MyWaitForSingleObject(pFT_MUTEX->hUnlockedEvent,INFINITE);
|
|
}
|
|
|
|
MyResetEvent(pFT_MUTEX->hUnlockedEvent);
|
|
pFT_MUTEX->dwLockOwner = dwThreadId;
|
|
VERIFY(++pFT_MUTEX->nLockedCount > 0);
|
|
MyLeaveCriticalSection(&pFT_MUTEX->MutexLock);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void
|
|
LeaveFT_MUTEX
|
|
(
|
|
#ifdef FISH_HANG
|
|
char* pszFile,
|
|
int nLine,
|
|
#endif
|
|
fthread_mutex_t* pFT_MUTEX
|
|
)
|
|
{
|
|
if (hostinfo.trycritsec_avail)
|
|
{
|
|
MyLeaveCriticalSection(&pFT_MUTEX->MutexLock);
|
|
}
|
|
else
|
|
{
|
|
MyEnterCriticalSection(&pFT_MUTEX->MutexLock);
|
|
ASSERT(pFT_MUTEX->nLockedCount >= 0);
|
|
if (--pFT_MUTEX->nLockedCount <= 0)
|
|
MySetEvent(pFT_MUTEX->hUnlockedEvent);
|
|
MyLeaveCriticalSection(&pFT_MUTEX->MutexLock);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
FT_W32_BOOL
|
|
TryEnterFT_MUTEX
|
|
(
|
|
#ifdef FISH_HANG
|
|
char* pszFile,
|
|
int nLine,
|
|
#endif
|
|
fthread_mutex_t* pFT_MUTEX
|
|
)
|
|
{
|
|
FT_W32_BOOL bSuccess;
|
|
|
|
if (hostinfo.trycritsec_avail)
|
|
{
|
|
bSuccess = MyTryEnterCriticalSection(&pFT_MUTEX->MutexLock);
|
|
}
|
|
else
|
|
{
|
|
FT_W32_DWORD dwThreadId = GetCurrentThreadId();
|
|
|
|
MyEnterCriticalSection(&pFT_MUTEX->MutexLock);
|
|
|
|
ASSERT(pFT_MUTEX->nLockedCount >= 0);
|
|
|
|
bSuccess = (pFT_MUTEX->nLockedCount <= 0 || pFT_MUTEX->dwLockOwner == dwThreadId);
|
|
|
|
if (bSuccess)
|
|
{
|
|
VERIFY(++pFT_MUTEX->nLockedCount > 0);
|
|
pFT_MUTEX->dwLockOwner = dwThreadId;
|
|
MyResetEvent(pFT_MUTEX->hUnlockedEvent);
|
|
}
|
|
|
|
MyLeaveCriticalSection(&pFT_MUTEX->MutexLock);
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// (thread signalling not supported...)
|
|
|
|
void fthread_kill // (nop)
|
|
(
|
|
int dummy1,
|
|
int dummy2
|
|
)
|
|
{
|
|
// (nop)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
typedef struct _ftCallThreadParms
|
|
{
|
|
PFT_THREAD_FUNC pfnTheirThreadFunc;
|
|
void* pvTheirThreadArgs;
|
|
}
|
|
FT_CALL_THREAD_PARMS;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
FT_W32_DWORD
|
|
__stdcall
|
|
FTWin32ThreadFunc
|
|
(
|
|
void* pMyArgs
|
|
)
|
|
{
|
|
FT_CALL_THREAD_PARMS* pCallTheirThreadParms;
|
|
PFT_THREAD_FUNC pfnTheirThreadFunc;
|
|
void* pvTheirThreadArgs;
|
|
|
|
pCallTheirThreadParms = (FT_CALL_THREAD_PARMS*) pMyArgs;
|
|
|
|
pfnTheirThreadFunc = pCallTheirThreadParms->pfnTheirThreadFunc;
|
|
pvTheirThreadArgs = pCallTheirThreadParms->pvTheirThreadArgs;
|
|
|
|
free(pCallTheirThreadParms);
|
|
|
|
(pfnTheirThreadFunc)(pvTheirThreadArgs);
|
|
|
|
MyExitThread(0);
|
|
|
|
return 0; // (make compiler happy)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// create a new thread...
|
|
|
|
int
|
|
fthread_create
|
|
(
|
|
#ifdef FISH_HANG
|
|
char* pszFile,
|
|
int nLine,
|
|
#endif
|
|
fthread_t* pdwThreadID,
|
|
fthread_attr_t* dummy1,
|
|
PFT_THREAD_FUNC pfnThreadFunc,
|
|
void* pvThreadArgs,
|
|
int nThreadPriority
|
|
)
|
|
{
|
|
FT_CALL_THREAD_PARMS* pCallTheirThreadParms;
|
|
FT_W32_HANDLE hWin32ThreadFunc;
|
|
|
|
pCallTheirThreadParms =
|
|
(FT_CALL_THREAD_PARMS*) malloc(sizeof(FT_CALL_THREAD_PARMS));
|
|
|
|
if (!pCallTheirThreadParms)
|
|
{
|
|
#ifdef FISH_HANG
|
|
_fthreadmsg("fthread_create: malloc(FT_CALL_THREAD_PARMS) failed; %s(%d)\n",pszFile,nLine);
|
|
#else
|
|
_fthreadmsg("fthread_create: malloc(FT_CALL_THREAD_PARMS) failed\n");
|
|
#endif
|
|
errno = ENOMEM;
|
|
return -1;
|
|
}
|
|
|
|
pCallTheirThreadParms->pfnTheirThreadFunc = pfnThreadFunc;
|
|
pCallTheirThreadParms->pvTheirThreadArgs = pvThreadArgs;
|
|
|
|
hWin32ThreadFunc =
|
|
MyCreateThread(NULL,0,FTWin32ThreadFunc,pCallTheirThreadParms,0,(FT_W32_DWORD*)pdwThreadID);
|
|
|
|
if (!hWin32ThreadFunc)
|
|
{
|
|
#ifdef FISH_HANG
|
|
_fthreadmsg("fthread_create: MyCreateThread failed; %s(%d)\n",pszFile,nLine);
|
|
#else
|
|
_fthreadmsg("fthread_create: MyCreateThread failed\n");
|
|
#endif
|
|
free (pCallTheirThreadParms);
|
|
errno = EAGAIN;
|
|
return -1;
|
|
}
|
|
|
|
if (nThreadPriority != THREAD_PRIORITY_NORMAL)
|
|
{
|
|
if (!SetThreadPriority(hWin32ThreadFunc,nThreadPriority))
|
|
{
|
|
#ifdef FISH_HANG
|
|
_fthreadmsg("fthread_create: SetThreadPriority failed; %s(%d)\n",pszFile,nLine);
|
|
#else
|
|
_fthreadmsg("fthread_create: SetThreadPriority failed\n");
|
|
#endif
|
|
}
|
|
}
|
|
|
|
CloseHandle(hWin32ThreadFunc);
|
|
|
|
return 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// return thread-id...
|
|
|
|
FT_W32_DWORD
|
|
fthread_self
|
|
(
|
|
)
|
|
{
|
|
return GetCurrentThreadId();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// exit from a thread...
|
|
|
|
void
|
|
fthread_exit
|
|
(
|
|
FT_W32_DWORD* pdwExitCode
|
|
)
|
|
{
|
|
MyExitThread(pdwExitCode ? *pdwExitCode : 0);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// initialize a lock...
|
|
|
|
int
|
|
fthread_mutex_init
|
|
(
|
|
#ifdef FISH_HANG
|
|
char* pszFile,
|
|
int nLine,
|
|
#endif
|
|
fthread_mutex_t* pFT_MUTEX
|
|
)
|
|
{
|
|
InitializeFT_MUTEX
|
|
(
|
|
#ifdef FISH_HANG
|
|
pszFile,
|
|
nLine,
|
|
#endif
|
|
pFT_MUTEX
|
|
);
|
|
return 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// lock a "mutex"...
|
|
|
|
int
|
|
fthread_mutex_lock
|
|
(
|
|
#ifdef FISH_HANG
|
|
char* pszFile,
|
|
int nLine,
|
|
#endif
|
|
fthread_mutex_t* pFT_MUTEX
|
|
)
|
|
{
|
|
EnterFT_MUTEX
|
|
(
|
|
#ifdef FISH_HANG
|
|
pszFile,
|
|
nLine,
|
|
#endif
|
|
pFT_MUTEX
|
|
);
|
|
return 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// try to lock a "mutex"...
|
|
|
|
int
|
|
fthread_mutex_trylock
|
|
(
|
|
#ifdef FISH_HANG
|
|
char* pszFile,
|
|
int nLine,
|
|
#endif
|
|
fthread_mutex_t* pFT_MUTEX
|
|
)
|
|
{
|
|
// Note: POSIX defines success as 0, failure as !0
|
|
return !TryEnterFT_MUTEX
|
|
(
|
|
#ifdef FISH_HANG
|
|
pszFile,
|
|
nLine,
|
|
#endif
|
|
pFT_MUTEX
|
|
);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// unlock a "mutex"...
|
|
|
|
int
|
|
fthread_mutex_unlock
|
|
(
|
|
#ifdef FISH_HANG
|
|
char* pszFile,
|
|
int nLine,
|
|
#endif
|
|
fthread_mutex_t* pFT_MUTEX
|
|
)
|
|
{
|
|
LeaveFT_MUTEX
|
|
(
|
|
#ifdef FISH_HANG
|
|
pszFile,
|
|
nLine,
|
|
#endif
|
|
pFT_MUTEX
|
|
);
|
|
return 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// initialize a "condition"...
|
|
|
|
int
|
|
fthread_cond_init
|
|
(
|
|
#ifdef FISH_HANG
|
|
char* pszFile,
|
|
int nLine,
|
|
#endif
|
|
fthread_cond_t* pFT_COND_VAR
|
|
)
|
|
{
|
|
if ((pFT_COND_VAR->hSigXmitEvent = MyCreateEvent(NULL,TRUE,FALSE,NULL)))
|
|
{
|
|
if ((pFT_COND_VAR->hSigRecvdEvent = MyCreateEvent(NULL,TRUE,TRUE,NULL)))
|
|
{
|
|
MyInitializeCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
pFT_COND_VAR->bBroadcastSig = FALSE;
|
|
pFT_COND_VAR->nNumWaiting = 0;
|
|
return 0;
|
|
}
|
|
|
|
MyDeleteEvent(pFT_COND_VAR->hSigXmitEvent);
|
|
}
|
|
|
|
#ifdef FISH_HANG
|
|
_fthreadmsg("fthread_cond_init failure; %s(%d)\n",pszFile,nLine);
|
|
#else
|
|
_fthreadmsg("fthread_cond_init failure\n");
|
|
#endif
|
|
errno = EAGAIN;
|
|
return -1;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// 'signal' a "condition"... (releases ONE waiting thread)
|
|
|
|
int
|
|
fthread_cond_signal
|
|
(
|
|
#ifdef FISH_HANG
|
|
char* pszFile,
|
|
int nLine,
|
|
#endif
|
|
fthread_cond_t* pFT_COND_VAR
|
|
)
|
|
{
|
|
if (!pFT_COND_VAR) { errno = EINVAL; return -1; }
|
|
|
|
// Wait for everyone to finish receiving prior signal..
|
|
|
|
for (;;)
|
|
{
|
|
MyEnterCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
if (IsEventSet(pFT_COND_VAR->hSigRecvdEvent)) break;
|
|
MyLeaveCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
MyWaitForSingleObject(pFT_COND_VAR->hSigRecvdEvent,INFINITE);
|
|
}
|
|
|
|
// Begin transmitting our new signal...
|
|
|
|
pFT_COND_VAR->bBroadcastSig = FALSE;
|
|
MySetEvent(pFT_COND_VAR->hSigXmitEvent);
|
|
|
|
if (pFT_COND_VAR->nNumWaiting)
|
|
{
|
|
// Serialize signal reception...
|
|
|
|
MyResetEvent(pFT_COND_VAR->hSigRecvdEvent);
|
|
}
|
|
|
|
MyLeaveCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// 'broadcast' a "condition"... (releases ALL waiting threads)
|
|
|
|
int
|
|
fthread_cond_broadcast
|
|
(
|
|
#ifdef FISH_HANG
|
|
char* pszFile,
|
|
int nLine,
|
|
#endif
|
|
fthread_cond_t* pFT_COND_VAR
|
|
)
|
|
{
|
|
if (!pFT_COND_VAR) { errno = EINVAL; return -1; }
|
|
|
|
// Wait for everyone to finish receiving prior signal..
|
|
|
|
for (;;)
|
|
{
|
|
MyEnterCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
if (IsEventSet(pFT_COND_VAR->hSigRecvdEvent)) break;
|
|
MyLeaveCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
MyWaitForSingleObject(pFT_COND_VAR->hSigRecvdEvent,INFINITE);
|
|
}
|
|
|
|
// Begin transmitting our new signal...
|
|
|
|
pFT_COND_VAR->bBroadcastSig = TRUE;
|
|
MySetEvent(pFT_COND_VAR->hSigXmitEvent);
|
|
|
|
if (pFT_COND_VAR->nNumWaiting)
|
|
{
|
|
// Serialize signal reception...
|
|
|
|
MyResetEvent(pFT_COND_VAR->hSigRecvdEvent);
|
|
}
|
|
|
|
MyLeaveCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// wait for a "condition" to occur...
|
|
|
|
int
|
|
fthread_cond_wait
|
|
(
|
|
#ifdef FISH_HANG
|
|
char* pszFile,
|
|
int nLine,
|
|
#endif
|
|
fthread_cond_t* pFT_COND_VAR,
|
|
fthread_mutex_t* pFT_MUTEX
|
|
)
|
|
{
|
|
if (!pFT_COND_VAR || !pFT_MUTEX) { errno = EINVAL; return -1; }
|
|
|
|
// Release lock (and thus any potential signalers)...
|
|
|
|
LeaveFT_MUTEX
|
|
(
|
|
#ifdef FISH_HANG
|
|
pszFile,
|
|
nLine,
|
|
#endif
|
|
pFT_MUTEX
|
|
);
|
|
|
|
// Wait for everyone to finish receiving prior signal (if any)..
|
|
|
|
for (;;)
|
|
{
|
|
MyEnterCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
if (IsEventSet(pFT_COND_VAR->hSigRecvdEvent)) break;
|
|
MyLeaveCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
MyWaitForSingleObject(pFT_COND_VAR->hSigRecvdEvent,INFINITE);
|
|
}
|
|
|
|
// Indicate new signal reception desired...
|
|
|
|
pFT_COND_VAR->nNumWaiting++;
|
|
|
|
// Wait for condition variable to be signalled...
|
|
|
|
for (;;)
|
|
{
|
|
// Allow signal to be transmitted...
|
|
|
|
MyLeaveCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
|
|
// Wait for signal transmission...
|
|
|
|
MyWaitForSingleObject(pFT_COND_VAR->hSigXmitEvent,INFINITE);
|
|
|
|
// Our condition was signalled...
|
|
|
|
MyEnterCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
|
|
// Make sure signal still being transmitted...
|
|
|
|
if (IsEventSet(pFT_COND_VAR->hSigXmitEvent)) break;
|
|
|
|
// If signal no longer being transmitted, then
|
|
// some other waiter received it; keep waiting
|
|
// for another signal...
|
|
}
|
|
|
|
// Indicate we received the signal...
|
|
|
|
pFT_COND_VAR->nNumWaiting--;
|
|
|
|
// If we were the only one that was supposed to
|
|
// receive it, or if no one remains to receive it,
|
|
// then stop transmitting the signal.
|
|
|
|
if (!pFT_COND_VAR->bBroadcastSig || pFT_COND_VAR->nNumWaiting == 0)
|
|
{
|
|
MyResetEvent(pFT_COND_VAR->hSigXmitEvent);
|
|
MySetEvent(pFT_COND_VAR->hSigRecvdEvent);
|
|
}
|
|
|
|
// Unlock condition variable...
|
|
|
|
MyLeaveCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
|
|
// Re-acquire the original lock before returning...
|
|
|
|
EnterFT_MUTEX
|
|
(
|
|
#ifdef FISH_HANG
|
|
pszFile,
|
|
nLine,
|
|
#endif
|
|
pFT_MUTEX
|
|
);
|
|
|
|
return 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// wait (but not forever) for a "condition" to occur...
|
|
|
|
int
|
|
fthread_cond_timedwait
|
|
(
|
|
#ifdef FISH_HANG
|
|
char* pszFile,
|
|
int nLine,
|
|
#endif
|
|
fthread_cond_t* pFT_COND_VAR,
|
|
fthread_mutex_t* pFT_MUTEX,
|
|
struct timespec* pTimeTimeout
|
|
)
|
|
{
|
|
struct timeval TimeNow;
|
|
FT_W32_DWORD dwWaitRetCode, dwWaitMilliSecs;
|
|
|
|
if (!pFT_COND_VAR || !pFT_MUTEX) { errno = EINVAL; return -1; }
|
|
|
|
// Release lock (and thus any potential signalers)...
|
|
|
|
LeaveFT_MUTEX
|
|
(
|
|
#ifdef FISH_HANG
|
|
pszFile,
|
|
nLine,
|
|
#endif
|
|
pFT_MUTEX
|
|
);
|
|
|
|
// Wait for everyone to finish receiving prior signal..
|
|
|
|
for (;;)
|
|
{
|
|
MyEnterCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
if (IsEventSet(pFT_COND_VAR->hSigRecvdEvent)) break;
|
|
MyLeaveCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
MyWaitForSingleObject(pFT_COND_VAR->hSigRecvdEvent,INFINITE);
|
|
}
|
|
|
|
// Indicate new signal reception desired...
|
|
|
|
pFT_COND_VAR->nNumWaiting++;
|
|
|
|
// Wait for condition variable to be signalled...
|
|
|
|
for (;;)
|
|
{
|
|
// Allow signal to be transmitted...
|
|
|
|
MyLeaveCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
|
|
// Wait for signal transmission...
|
|
|
|
gettimeofday(&TimeNow, NULL);
|
|
|
|
if (TimeNow.tv_sec > pTimeTimeout->tv_sec ||
|
|
(TimeNow.tv_sec == pTimeTimeout->tv_sec &&
|
|
(TimeNow.tv_usec * 1000) > pTimeTimeout->tv_nsec))
|
|
{
|
|
dwWaitMilliSecs = 0;
|
|
}
|
|
else
|
|
{
|
|
dwWaitMilliSecs =
|
|
((pTimeTimeout->tv_sec - TimeNow.tv_sec) * 1000) +
|
|
((pTimeTimeout->tv_nsec - (TimeNow.tv_usec * 1000)) / 1000000);
|
|
}
|
|
|
|
dwWaitRetCode =
|
|
MyWaitForSingleObject(pFT_COND_VAR->hSigXmitEvent,dwWaitMilliSecs);
|
|
|
|
// Our condition was signalled...
|
|
// Or we got tired of waiting for it...
|
|
|
|
MyEnterCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
|
|
// Make sure signal still being transmitted...
|
|
|
|
if (IsEventSet(pFT_COND_VAR->hSigXmitEvent)) break;
|
|
|
|
// If signal no longer being transmitted, then
|
|
// some other waiter received it; keep waiting
|
|
// for another signal...
|
|
|
|
if (WAIT_OBJECT_0 != dwWaitRetCode)
|
|
{
|
|
// We either got tired of waiting for it,
|
|
// or there was an error...
|
|
|
|
pFT_COND_VAR->nNumWaiting--;
|
|
|
|
// If we were the only one that was waiting to
|
|
// receive it, then indicate signal received
|
|
// (even though it really wasn't since we
|
|
// timed out) to allow late signal to eventually
|
|
// be sent [to a different future waiter].
|
|
|
|
if (pFT_COND_VAR->nNumWaiting == 0)
|
|
{
|
|
MySetEvent(pFT_COND_VAR->hSigRecvdEvent);
|
|
}
|
|
|
|
// Unlock condition variable...
|
|
|
|
MyLeaveCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
|
|
// Re-acquire the original lock before returning...
|
|
|
|
EnterFT_MUTEX
|
|
(
|
|
#ifdef FISH_HANG
|
|
pszFile,
|
|
nLine,
|
|
#endif
|
|
pFT_MUTEX
|
|
);
|
|
|
|
if (WAIT_TIMEOUT == dwWaitRetCode)
|
|
{
|
|
errno = EAGAIN; // (timeout)
|
|
return -1;
|
|
}
|
|
|
|
#ifdef FISH_HANG
|
|
_fthreadmsg("fthread_cond_timedwait: Invalid handle; %s(%d)\n",pszFile,nLine);
|
|
#else
|
|
_fthreadmsg("fthread_cond_timedwait: Invalid handle\n");
|
|
#endif
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// Indicate we received the signal...
|
|
|
|
pFT_COND_VAR->nNumWaiting--;
|
|
|
|
// If we were the only one that was supposed to
|
|
// receive it, or if no one remains to receive it,
|
|
// then stop transmitting the signal.
|
|
|
|
if (!pFT_COND_VAR->bBroadcastSig || pFT_COND_VAR->nNumWaiting == 0)
|
|
{
|
|
MyResetEvent(pFT_COND_VAR->hSigXmitEvent);
|
|
MySetEvent(pFT_COND_VAR->hSigRecvdEvent);
|
|
}
|
|
|
|
// Unlock condition variable...
|
|
|
|
MyLeaveCriticalSection(&pFT_COND_VAR->CondVarLock);
|
|
|
|
// Re-acquire the original lock before returning...
|
|
|
|
EnterFT_MUTEX
|
|
(
|
|
#ifdef FISH_HANG
|
|
pszFile,
|
|
nLine,
|
|
#endif
|
|
pFT_MUTEX
|
|
);
|
|
|
|
return 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#undef IsEventSet
|
|
|
|
#endif // !defined(OPTION_FTHREADS)
|