osdThread.c File Reference

#include <string.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <windows.h>
#include <process.h>
#include "epicsStdio.h"
#include "libComAPI.h"
#include "epicsThread.h"
#include "cantProceed.h"
#include "epicsAssert.h"
#include "ellLib.h"
#include "epicsExit.h"
#include "epicsAtomic.h"

Include dependency graph for osdThread.c:

Go to the source code of this file.

Classes
struct	win32ThreadGlobal
struct	epicsThreadOSD
struct	epicsThreadPrivateOSD

Macros
#define	VC_EXTRALEAN
#define	STRICT
#define	_WIN32_WINNT   0x400 /* No support for W95 */
#define	STACK_SIZE_PARAM_IS_A_RESERVATION   0x00010000
#define	osdOrdinaryPriorityStateCount   5u
#define	osdRealtimePriorityStateCount   14u
#define	STACK_SIZE(f)   (f * 0x10000 * sizeof(void *))
#define	EPICS_THREAD_ONCE_DONE   & threadOnceComplete

Typedefs
typedef struct win32ThreadGlobal	win32ThreadGlobal
typedef struct epicsThreadOSD	win32ThreadParam
typedef struct epicsThreadPrivateOSD	epicsThreadPrivateOSD

Functions
LIBCOM_API void	osdThreadHooksRun (epicsThreadId id)
void	setThreadName (DWORD dwThreadID, LPCSTR szThreadName)
LIBCOM_API void epicsStdCall	epicsThreadExitMain (void)
LIBCOM_API void	epicsThreadRealtimeLock (void)
LIBCOM_API epicsThreadBooleanStatus epicsStdCall	epicsThreadLowestPriorityLevelAbove (unsigned int priority, unsigned *pPriorityJustAbove)
LIBCOM_API epicsThreadBooleanStatus epicsStdCall	epicsThreadHighestPriorityLevelBelow (unsigned int priority, unsigned *pPriorityJustBelow)
LIBCOM_API unsigned int epicsStdCall	epicsThreadGetStackSize (epicsThreadStackSizeClass stackSizeClass)
epicsThreadId	epicsThreadCreateOpt (const char *pName, EPICSTHREADFUNC pFunc, void *pParm, const epicsThreadOpts *opts)
	Allocate and start a new OS thread. More...
void	epicsThreadMustJoin (epicsThreadId id)
LIBCOM_API void epicsStdCall	epicsThreadSuspendSelf ()
LIBCOM_API void epicsStdCall	epicsThreadResume (epicsThreadId id)
LIBCOM_API unsigned epicsStdCall	epicsThreadGetPriority (epicsThreadId id)
LIBCOM_API unsigned epicsStdCall	epicsThreadGetPrioritySelf ()
LIBCOM_API void epicsStdCall	epicsThreadSetPriority (epicsThreadId id, unsigned priority)
LIBCOM_API int epicsStdCall	epicsThreadIsEqual (epicsThreadId id1, epicsThreadId id2)
LIBCOM_API int epicsStdCall	epicsThreadIsSuspended (epicsThreadId id)
LIBCOM_API void epicsStdCall	epicsThreadSleep (double seconds)
	Block the calling thread for at least the specified time. More...
double epicsStdCall	epicsThreadSleepQuantum ()
	Query a value approximating the OS timer/scheduler resolution. More...
LIBCOM_API epicsThreadId epicsStdCall	epicsThreadGetIdSelf (void)
LIBCOM_API epicsThreadId epicsStdCall	epicsThreadGetId (const char *pName)
LIBCOM_API const char *epicsStdCall	epicsThreadGetNameSelf (void)
LIBCOM_API void epicsStdCall	epicsThreadGetName (epicsThreadId id, char *pName, size_t size)
LIBCOM_API void	epicsThreadMap (EPICS_THREAD_HOOK_ROUTINE func)
LIBCOM_API void epicsStdCall	epicsThreadShowAll (unsigned level)
LIBCOM_API void epicsStdCall	epicsThreadShow (epicsThreadId id, unsigned level)
LIBCOM_API void epicsStdCall	epicsThreadOnce (epicsThreadOnceId *id, void(*func)(void *), void *arg)
LIBCOM_API epicsThreadPrivateId epicsStdCall	epicsThreadPrivateCreate ()
LIBCOM_API void epicsStdCall	epicsThreadPrivateDelete (epicsThreadPrivateId p)
LIBCOM_API void epicsStdCall	epicsThreadPrivateSet (epicsThreadPrivateId pPvt, void *pVal)
LIBCOM_API void *epicsStdCall	epicsThreadPrivateGet (epicsThreadPrivateId pPvt)
LIBCOM_API int	epicsThreadGetCPUs (void)

Macro Definition Documentation

#define _WIN32_WINNT   0x400 /* No support for W95 */

Definition at line 22 of file osdThread.c.

#define EPICS_THREAD_ONCE_DONE   & threadOnceComplete

#define osdOrdinaryPriorityStateCount   5u

Definition at line 67 of file osdThread.c.

#define osdRealtimePriorityStateCount   14u

Definition at line 77 of file osdThread.c.

#define STACK_SIZE

(

f

)

(f * 0x10000 * sizeof(void *))

#define STACK_SIZE_PARAM_IS_A_RESERVATION   0x00010000

Definition at line 64 of file osdThread.c.

#define STRICT

Definition at line 20 of file osdThread.c.

#define VC_EXTRALEAN

Definition at line 19 of file osdThread.c.

Typedef Documentation

typedef struct epicsThreadPrivateOSD epicsThreadPrivateOSD

typedef struct win32ThreadGlobal win32ThreadGlobal

typedef struct epicsThreadOSD win32ThreadParam

Function Documentation

epicsThreadId epicsThreadCreateOpt	(	const char *	name,
		EPICSTHREADFUNC	funptr,
		void *	parm,
		const epicsThreadOpts *	opts
	)

Allocate and start a new OS thread.

Parameters

name	A name describing this thread. Appears in various log and error message.
funptr	The thread main function.
parm	Passed to thread main function.
opts	Modifiers for the new thread, or NULL to use target specific defaults.

Returns

NULL on error

Definition at line 548 of file osdThread.c.

{
    win32ThreadGlobal * pGbl = fetchWin32ThreadGlobal ();
    win32ThreadParam * pParmWIN32;
    unsigned int stackSize;
    int osdPriority;
    DWORD wstat;
    BOOL bstat;

    if ( ! pGbl )  {
        return NULL;
    }

    if (!opts) {
        static const epicsThreadOpts opts_default = EPICS_THREAD_OPTS_INIT;
        opts = &opts_default;
    }
    stackSize = opts->stackSize;
    if (stackSize <= epicsThreadStackBig)
        stackSize = epicsThreadGetStackSize(stackSize);

    pParmWIN32 = epicsThreadParmCreate ( pName );
    if ( pParmWIN32 == 0 ) {
        return ( epicsThreadId ) pParmWIN32;
    }
    pParmWIN32->funptr = pFunc;
    pParmWIN32->parm = pParm;
    pParmWIN32->epicsPriority = opts->priority;
    if(opts->joinable) {
        pParmWIN32->joinable = 1;
        epicsAtomicIncrIntT(&pParmWIN32->refcnt);
    }

    {
        unsigned threadId;
        pParmWIN32->handle = (HANDLE) _beginthreadex (
            0, stackSize, epicsWin32ThreadEntry,
            pParmWIN32,
            CREATE_SUSPENDED | STACK_SIZE_PARAM_IS_A_RESERVATION,
            & threadId );
        if ( pParmWIN32->handle == 0 ) {
            free ( pParmWIN32 );
            return NULL;
        }
        /* weird win32 interface threadId parameter inconsistency */
        pParmWIN32->id = ( DWORD ) threadId ;
    }

    osdPriority = epicsThreadGetOsdPriorityValue (opts->priority);
    bstat = SetThreadPriority ( pParmWIN32->handle, osdPriority );
    if (!bstat) {
        CloseHandle ( pParmWIN32->handle );
        free ( pParmWIN32 );
        return NULL;
    }

    EnterCriticalSection ( & pGbl->mutex );
    ellAdd ( & pGbl->threadList, & pParmWIN32->node );
    LeaveCriticalSection ( & pGbl->mutex );

    wstat =  ResumeThread ( pParmWIN32->handle );
    if (wstat==0xFFFFFFFF) {
            EnterCriticalSection ( & pGbl->mutex );
            ellDelete ( & pGbl->threadList, & pParmWIN32->node );
            LeaveCriticalSection ( & pGbl->mutex );
        CloseHandle ( pParmWIN32->handle );
        free ( pParmWIN32 );
        return NULL;
    }

    return ( epicsThreadId ) pParmWIN32;
}

LIBCOM_API void epicsStdCall epicsThreadExitMain

(

void

)

If the main routine is done but wants to let other threads run it can call this routine. This should be the last call in main, except the final return. On most systems epicsThreadExitMain never returns.This must only be called by the main thread.

Definition at line 249 of file osdThread.c.

{
    _endthread ();
}

LIBCOM_API int epicsThreadGetCPUs

(

void

)

Return a value approximating the number of threads which this target can run in parallel. This value is advisory.

Returns

>=1

Definition at line 1114 of file osdThread.c.

{
    SYSTEM_INFO sysinfo;
    GetSystemInfo(&sysinfo);
    if (sysinfo.dwNumberOfProcessors > 0)
        return sysinfo.dwNumberOfProcessors;
    return 1;
}

LIBCOM_API epicsThreadId epicsStdCall epicsThreadGetId

(

const char *

name

)

Attempt to find the first instance of a thread by name.

Returns

An epicsThreadId, or NULL if no such thread is currently running. Note that a non-NULL ID may still be invalid if this call races with thread exit.

Warning

Safe use of this function requires external knowledge that this thread will not return.

Definition at line 850 of file osdThread.c.

{
    win32ThreadGlobal * pGbl = fetchWin32ThreadGlobal ();
    win32ThreadParam * pParm;

    if ( ! pGbl ) {
        return 0;
    }

    EnterCriticalSection ( & pGbl->mutex );

    for ( pParm = ( win32ThreadParam * ) ellFirst ( & pGbl->threadList );
            pParm; pParm = ( win32ThreadParam * ) ellNext ( & pParm->node ) ) {
        if ( pParm->pName ) {
            if ( strcmp ( pParm->pName, pName ) == 0 ) {
                break;
            }
        }
    }

    LeaveCriticalSection ( & pGbl->mutex );

    /* !!!! warning - the thread parm could vanish at any time !!!! */

    return ( epicsThreadId ) pParm;
}

LIBCOM_API epicsThreadId epicsStdCall epicsThreadGetIdSelf

(

void

)

Find an epicsThreadId associated with the current thread. For non-EPICS threads, a new epicsThreadId may be allocated.

Definition at line 834 of file osdThread.c.

{
    win32ThreadGlobal * pGbl = fetchWin32ThreadGlobal ();
    win32ThreadParam * pParm;

    assert ( pGbl );

    pParm = ( win32ThreadParam * ) TlsGetValue (
        pGbl->tlsIndexThreadLibraryEPICS );
    if ( ! pParm ) {
        pParm = epicsThreadImplicitCreate ();
        assert ( pParm ); /* very dangerous to allow non-unique thread id into use */
    }
    return ( epicsThreadId ) pParm;
}

LIBCOM_API void epicsStdCall epicsThreadGetName	(	epicsThreadId	id,
		char *	name,
		size_t	size
	)

Copy out the thread name into the provided buffer.

Guaranteed to be null terminated. size is number of bytes in buffer to hold name (including terminator). Failure results in an empty string stored in name.

Definition at line 907 of file osdThread.c.

{
    win32ThreadParam * pParm = ( win32ThreadParam * ) id;

    if ( size ) {
        size_t sizeMinusOne = size-1;
        strncpy ( pName, pParm->pName, sizeMinusOne );
        pName [sizeMinusOne] = '\0';
    }
}

LIBCOM_API const char* epicsStdCall epicsThreadGetNameSelf

(

void

)

Return the name of the current thread.

Returns

Never NULL. Storage lifetime tied to epicsThreadId.

This is either a copy of the string passed to epicsThread*Create*(), or an arbitrary unique string for non-EPICS threads.

Definition at line 881 of file osdThread.c.

{
    win32ThreadGlobal * pGbl = fetchWin32ThreadGlobal ();
    win32ThreadParam * pParm;

    if ( ! pGbl ) {
        return "thread library not initialized";
    }

    pParm = ( win32ThreadParam * )
        TlsGetValue ( pGbl->tlsIndexThreadLibraryEPICS );
    if ( ! pParm ) {
        pParm = epicsThreadImplicitCreate ();
    }

    if ( pParm ) {
        if ( pParm->pName ) {
            return pParm->pName;
        }
    }
    return "anonymous";
}

LIBCOM_API unsigned epicsStdCall epicsThreadGetPriority

(

epicsThreadId

id

)

Return thread OSI priority

Definition at line 704 of file osdThread.c.

{
    win32ThreadParam * pParm = ( win32ThreadParam * ) id;
    return pParm->epicsPriority;
}

LIBCOM_API unsigned epicsStdCall epicsThreadGetPrioritySelf

(

void

)

Return thread OSI priority

Definition at line 713 of file osdThread.c.

{
    win32ThreadGlobal * pGbl = fetchWin32ThreadGlobal ();
    win32ThreadParam * pParm;

    assert ( pGbl );

    pParm = ( win32ThreadParam * )
        TlsGetValue ( pGbl->tlsIndexThreadLibraryEPICS );
    if ( ! pParm ) {
        pParm = epicsThreadImplicitCreate ();
    }
    if ( pParm ) {
        return pParm->epicsPriority;
    }
    else {
        int win32ThreadPriority =
            GetThreadPriority ( GetCurrentThread () );
        assert ( win32ThreadPriority != THREAD_PRIORITY_ERROR_RETURN );
        return epicsThreadGetOsiPriorityValue ( win32ThreadPriority );
    }
}

LIBCOM_API unsigned int epicsStdCall epicsThreadGetStackSize

(

epicsThreadStackSizeClass

size

)

Get a stack size value that can be given to epicsThreadCreate().

Parameters

size	one of the values epicsThreadStackSmall, epicsThreadStackMedium or epicsThreadStackBig.

Definition at line 420 of file osdThread.c.

{
    #define STACK_SIZE(f) (f * 0x10000 * sizeof(void *))
    static const unsigned stackSizeTable[epicsThreadStackBig+1] = {
        STACK_SIZE(1), STACK_SIZE(2), STACK_SIZE(4)
    };

    if (stackSizeClass<epicsThreadStackSmall) {
        fprintf ( stderr,
            "epicsThreadGetStackSize illegal argument (too small)");
        return stackSizeTable[epicsThreadStackBig];
    }

    if (stackSizeClass>epicsThreadStackBig) {
        fprintf ( stderr,
            "epicsThreadGetStackSize illegal argument (too large)");
        return stackSizeTable[epicsThreadStackBig];
    }

    return stackSizeTable[stackSizeClass];
}

LIBCOM_API epicsThreadBooleanStatus epicsStdCall epicsThreadHighestPriorityLevelBelow	(	unsigned int	priority,
		unsigned *	pPriorityJustBelow
	)

Lookup the next usage OSI priority such that priority > *pPriorityJustBelow if this is possible with the current target configuration and privlages.

Definition at line 390 of file osdThread.c.

{
    const DWORD priorityClass = GetPriorityClass ( GetCurrentProcess () );
    epicsThreadBooleanStatus status;
    unsigned stateCount;
    unsigned magnitude;

    if ( priorityClass == REALTIME_PRIORITY_CLASS ) {
        stateCount = osdRealtimePriorityStateCount;
    }
    else {
        stateCount = osdOrdinaryPriorityStateCount;
    }

    magnitude = osdPriorityMagFromPriorityOSI ( priority, stateCount );

    if ( magnitude > 0u ) {
        *pPriorityJustBelow = osiPriorityMagFromMagnitueOSD ( magnitude - 1u, stateCount );
        status = epicsThreadBooleanStatusSuccess;
    }
    else {
        status = epicsThreadBooleanStatusFail;
    }
    return status;
}

LIBCOM_API int epicsStdCall epicsThreadIsEqual	(	epicsThreadId	id1,
		epicsThreadId	id2
	)

Test if two thread IDs actually refer to the same OS thread

Definition at line 749 of file osdThread.c.

{
    win32ThreadParam * pParm1 = ( win32ThreadParam * ) id1;
    win32ThreadParam * pParm2 = ( win32ThreadParam * ) id2;
    return ( id1 == id2 && pParm1->id == pParm2->id );
}

LIBCOM_API int epicsStdCall epicsThreadIsSuspended

(

epicsThreadId

id

)

How and why a thread can be suspended is implementation dependent. A thread calling epicsThreadSuspendSelf() should result in this routine returning true for that thread, but a thread may also be suspended for other reasons.

Definition at line 759 of file osdThread.c.

{
    win32ThreadParam *pParm = ( win32ThreadParam * ) id;
    DWORD exitCode;
    BOOL stat;

    stat = GetExitCodeThread ( pParm->handle, & exitCode );
    if ( stat ) {
        if ( exitCode != STILL_ACTIVE ) {
            return 1;
        }
        else {
            return pParm->isSuspended;
        }
    }
    else {
        return 1;
    }
}

LIBCOM_API epicsThreadBooleanStatus epicsStdCall epicsThreadLowestPriorityLevelAbove	(	unsigned int	priority,
		unsigned *	pPriorityJustAbove
	)

Lookup the next usage OSI priority such that priority < *pPriorityJustBelow if this is possible with the current target configuration and privlages.

Definition at line 360 of file osdThread.c.

{
    const DWORD priorityClass = GetPriorityClass ( GetCurrentProcess () );
    epicsThreadBooleanStatus status;
    unsigned stateCount;
    unsigned magnitude;

    if ( priorityClass == REALTIME_PRIORITY_CLASS ) {
        stateCount = osdRealtimePriorityStateCount;
    }
    else {
        stateCount = osdOrdinaryPriorityStateCount;
    }

    magnitude = osdPriorityMagFromPriorityOSI ( priority, stateCount );

    if ( magnitude < ( stateCount - 1 ) ) {
        *pPriorityJustAbove = osiPriorityMagFromMagnitueOSD ( magnitude + 1u, stateCount );
        status = epicsThreadBooleanStatusSuccess;
    }
    else {
        status = epicsThreadBooleanStatusFail;
    }
    return status;
}

LIBCOM_API void epicsThreadMap

(

EPICS_THREAD_HOOK_ROUTINE

func

)

Call func once for every known thread.

Definition at line 982 of file osdThread.c.

{
    win32ThreadGlobal * pGbl = fetchWin32ThreadGlobal ();
    win32ThreadParam * pParm;

    if ( ! pGbl ) {
        return;
    }

    EnterCriticalSection ( & pGbl->mutex );

    for ( pParm = ( win32ThreadParam * ) ellFirst ( & pGbl->threadList );
            pParm; pParm = ( win32ThreadParam * ) ellNext ( & pParm->node ) ) {
        func ( ( epicsThreadId ) pParm );
    }

    LeaveCriticalSection ( & pGbl->mutex );
}

void epicsThreadMustJoin

(

epicsThreadId

id

)

Wait for a joinable thread to exit (return from its main function)

Definition at line 624 of file osdThread.c.

{
    win32ThreadParam * pParmWIN32 = id;

    if(!id) {
        /* no-op */
    } else if(epicsAtomicCmpAndSwapIntT(&id->joinable, 1, 0)!=1) {
        if(epicsThreadGetIdSelf()==id) {
            fprintf(stderr, "Warning: %s thread self-join of unjoinable\n", pParmWIN32->pName);

        } else {
            /* try to error nicely, however in all likelyhood de-ref of
             * 'id' has already caused SIGSEGV as we are racing thread exit,
             * which free's 'id'.
             */
            cantProceed("Error: %s thread not joinable.\n", pParmWIN32->pName);
        }

    } else if(epicsThreadGetIdSelf() != id) {
        DWORD status = WaitForSingleObject(pParmWIN32->handle, INFINITE);
        if(status != WAIT_OBJECT_0) {
            /* TODO: signal error? */
        }

        epicsParmCleanupWIN32(pParmWIN32);
    } else {
        /* join self silently does nothing */
        epicsParmCleanupWIN32(pParmWIN32);
    }
}

LIBCOM_API void epicsStdCall epicsThreadOnce	(	epicsThreadOnceId *	id,
		void(*)(void *)	func,
		void *	arg
	)

Definition at line 1036 of file osdThread.c.

{
    static struct epicsThreadOSD threadOnceComplete;
    #define EPICS_THREAD_ONCE_DONE & threadOnceComplete
    win32ThreadGlobal * pGbl = fetchWin32ThreadGlobal ();

    assert ( pGbl );

    EnterCriticalSection ( & pGbl->mutex );

    if ( *id != EPICS_THREAD_ONCE_DONE ) {
        if ( *id == EPICS_THREAD_ONCE_INIT ) { /* first call */
            *id = epicsThreadGetIdSelf();      /* mark active */
            LeaveCriticalSection ( & pGbl->mutex );
            func ( arg );
            EnterCriticalSection ( & pGbl->mutex );
            *id = EPICS_THREAD_ONCE_DONE;      /* mark done */
        } else if ( *id == epicsThreadGetIdSelf() ) {
            LeaveCriticalSection ( & pGbl->mutex );
            cantProceed( "Recursive epicsThreadOnce() initialization\n" );
        } else
            while ( *id != EPICS_THREAD_ONCE_DONE ) {
                /* Another thread is in the above func(arg) call. */
                LeaveCriticalSection ( & pGbl->mutex );
                epicsThreadSleep ( epicsThreadSleepQuantum() );
                EnterCriticalSection ( & pGbl->mutex );
            }
    }
    LeaveCriticalSection ( & pGbl->mutex );
}

LIBCOM_API epicsThreadPrivateId epicsStdCall epicsThreadPrivateCreate

(

void

)

Allocate a new thread local variable. This variable will initially hold NULL for each thread.

Definition at line 1071 of file osdThread.c.

{
    epicsThreadPrivateOSD *p = ( epicsThreadPrivateOSD * ) malloc ( sizeof ( *p ) );
    if ( p ) {
        p->key = TlsAlloc ();
        if ( p->key == 0xFFFFFFFF ) {
            free ( p );
            p = 0;
        }
    }
    return p;
}

LIBCOM_API void epicsStdCall epicsThreadPrivateDelete

(

epicsThreadPrivateId

id

)

Free a thread local variable

Definition at line 1087 of file osdThread.c.

{
    BOOL stat = TlsFree ( p->key );
    assert ( stat );
    free ( p );
}

LIBCOM_API void* epicsStdCall epicsThreadPrivateGet

(

epicsThreadPrivateId

)

Fetch the current value of a thread local variable

Definition at line 1106 of file osdThread.c.

{
    return ( void * ) TlsGetValue ( pPvt->key );
}

LIBCOM_API void epicsStdCall epicsThreadPrivateSet	(	epicsThreadPrivateId	,
		void *
	)

Update thread local variable

Definition at line 1097 of file osdThread.c.

{
    BOOL stat = TlsSetValue ( pPvt->key, (void *) pVal );
    assert (stat);
}

LIBCOM_API void epicsThreadRealtimeLock

(

void

)

When real-time scheduling is active, attempt any post-init operations that preserve real-time performance. For POSIX targets this locks the process into RAM, preventing swap-related VM faults.

Definition at line 278 of file osdThread.c.

{}

LIBCOM_API void epicsStdCall epicsThreadResume

(

epicsThreadId

id

)

Resume a thread suspended with epicsThreadSuspendSelf()

Definition at line 683 of file osdThread.c.

{
    win32ThreadGlobal * pGbl = fetchWin32ThreadGlobal ();
    win32ThreadParam * pParm = ( win32ThreadParam * ) id;
    DWORD stat;

    assert ( pGbl );

    EnterCriticalSection ( & pGbl->mutex );

    stat =  ResumeThread ( pParm->handle );
    pParm->isSuspended = 0;

    LeaveCriticalSection ( & pGbl->mutex );

    assert ( stat != 0xFFFFFFFF );
}

LIBCOM_API void epicsStdCall epicsThreadSetPriority	(	epicsThreadId	id,
		unsigned	priority
	)

Definition at line 739 of file osdThread.c.

{
    win32ThreadParam * pParm = ( win32ThreadParam * ) id;
    BOOL stat = SetThreadPriority ( pParm->handle, epicsThreadGetOsdPriorityValue (priority) );
    assert (stat);
}

LIBCOM_API void epicsStdCall epicsThreadShow	(	epicsThreadId	id,
		unsigned	level
	)

Definition at line 1027 of file osdThread.c.

{
    epicsThreadShowInfo ( 0, level );
    epicsThreadShowInfo ( id, level );
}

LIBCOM_API void epicsStdCall epicsThreadShowAll

(

unsigned

level

)

Definition at line 1004 of file osdThread.c.

{
    win32ThreadGlobal * pGbl = fetchWin32ThreadGlobal ();
    win32ThreadParam * pParm;

    if ( ! pGbl ) {
        return;
    }

    EnterCriticalSection ( & pGbl->mutex );

    epicsThreadShowInfo ( 0, level );
    for ( pParm = ( win32ThreadParam * ) ellFirst ( & pGbl->threadList );
            pParm; pParm = ( win32ThreadParam * ) ellNext ( & pParm->node ) ) {
        epicsThreadShowInfo ( ( epicsThreadId ) pParm, level );
    }

    LeaveCriticalSection ( & pGbl->mutex );
}

LIBCOM_API void epicsStdCall epicsThreadSleep

(

double

seconds

)

Block the calling thread for at least the specified time.

Parameters

seconds

Time to wait in seconds. Values <=0 blocks for the shortest possible time.

Definition at line 782 of file osdThread.c.

{
    static const unsigned mSecPerSec = 1000;
    DWORD milliSecDelay;

    if ( seconds > 0.0 ) {
        seconds *= mSecPerSec;
        seconds += 0.99999999;  /* 8 9s here is optimal */
        milliSecDelay = ( seconds >= INFINITE ) ?
            INFINITE - 1 : ( DWORD ) seconds;
    }
    else {  /* seconds <= 0 or NAN */
        milliSecDelay = 0u;
    }
    Sleep ( milliSecDelay );
}

double epicsStdCall epicsThreadSleepQuantum

(

void

)

Query a value approximating the OS timer/scheduler resolution.

Returns

A value in seconds >=0

Warning

On targets other than vxWorks and RTEMS, the quantum value often isn't meaningful. Use of this function is discouraged in portable code.

Definition at line 802 of file osdThread.c.

{
    /*
     * Its worth noting here that the sleep quantum on windows can
     * mysteriously get better. I eventually tracked this down to
     * codes that call timeBeginPeriod(1). Calling timeBeginPeriod()
     * specifying a better timer resolution also increases the interrupt
     * load. This appears to be related to java applet activity.
     * The function timeGetDevCaps can tell us the range of periods
     * that can be specified to timeBeginPeriod, but alas there
     * appears to be no way to find out what the value of the global
     * minimum of all timeBeginPeriod calls for all processes is.
     */
    static const double secPerTick = 100e-9;
    DWORD adjustment;
    DWORD delay;
    BOOL disabled;
    BOOL success;

    success = GetSystemTimeAdjustment (
        & adjustment, & delay, & disabled );
    if ( success ) {
        return delay * secPerTick;
    }
    else {
        return 0.0;
    }
}

LIBCOM_API void epicsStdCall epicsThreadSuspendSelf

(

void

)

Block the current thread until epicsThreadResume().

Definition at line 658 of file osdThread.c.

{
    win32ThreadGlobal * pGbl = fetchWin32ThreadGlobal ();
    win32ThreadParam * pParm;
    DWORD stat;

    assert ( pGbl );

    pParm = ( win32ThreadParam * )
        TlsGetValue ( pGbl->tlsIndexThreadLibraryEPICS );
    if ( ! pParm ) {
        pParm = epicsThreadImplicitCreate ();
    }
    if ( pParm ) {
        EnterCriticalSection ( & pGbl->mutex );
        pParm->isSuspended = 1;
        LeaveCriticalSection ( & pGbl->mutex );
    }
    stat =  SuspendThread ( GetCurrentThread () );
    assert ( stat != 0xFFFFFFFF );
}

LIBCOM_API void osdThreadHooksRun

(

epicsThreadId

id

)

Definition at line 105 of file osdThreadHooks.c.

{
    threadHookInit();

    if (epicsMutexLock(hookLock) == epicsMutexLockOK) {
        epicsThreadHook *pHook = (epicsThreadHook *) ellFirst(&hookList);

        while (pHook) {
            pHook->func(id);
            pHook = (epicsThreadHook *) ellNext(&pHook->node);
        }
        epicsMutexUnlock(hookLock);
    }
    else {
        fprintf(stderr, "osdThreadHooksRun: Locking problem\n");
    }
}

void setThreadName	(	DWORD	dwThreadID,
		LPCSTR	szThreadName
	)

Definition at line 26 of file setThreadName.cpp.

{
#if _MSC_VER >= 1300 && defined ( _DEBUG )
    typedef struct tagTHREADNAME_INFO
    {
        DWORD dwType; // must be 0x1000
        LPCSTR szName; // pointer to name (in user addr space)
        DWORD dwThreadID; // thread ID (-1=caller thread)
        DWORD dwFlags; // reserved for future use, must be zero
    } THREADNAME_INFO;
    THREADNAME_INFO info;
    info.dwType = 0x1000;
    info.szName = szThreadName;
    info.dwThreadID = dwThreadID;
    info.dwFlags = 0;

    __try
    {
        RaiseException( 0x406D1388, 0,
            sizeof(info)/sizeof(DWORD), (const ULONG_PTR*)&info );
    }
    __except(EXCEPTION_CONTINUE_EXECUTION)
    {
    }
#endif
}