bluecore/glfw/lib/win32/win32_thread.c

//========================================================================
// GLFW - An OpenGL framework
// File:        win32_thread.c
// Platform:    Windows
// API version: 2.6
// WWW:         http://glfw.sourceforge.net
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Camilla Berglund
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would
//    be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not
//    be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source
//    distribution.
//
//------------------------------------------------------------------------
// $Id: win32_thread.c,v 1.6 2007/03/15 03:20:21 elmindreda Exp $
//========================================================================

#include "internal.h"


//************************************************************************
// This is an implementation of POSIX "compatible" condition variables for
// Win32, as described by Douglas C. Schmidt and Irfan Pyarali:
// http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
//************************************************************************

enum {
    _GLFW_COND_SIGNAL     = 0,
    _GLFW_COND_BROADCAST  = 1
};

typedef struct {
    // Signal and broadcast event HANDLEs
    HANDLE events[ 2 ];

    // Count of the number of waiters
    unsigned int waiters_count;

    // Serialize access to <waiters_count>
    CRITICAL_SECTION waiters_count_lock;
} _GLFWcond;



//************************************************************************
//****                  GLFW internal functions                       ****
//************************************************************************

//========================================================================
// _glfwNewThread() - This is simply a "wrapper" for calling the user
// thread function.
//========================================================================

DWORD WINAPI _glfwNewThread( LPVOID lpParam )
{
    GLFWthreadfun threadfun;
    _GLFWthread   *t;

    // Get pointer to thread information for current thread
    t = _glfwGetThreadPointer( _glfwPlatformGetThreadID() );
    if( t == NULL )
    {
        return 0;
    }

    // Get user thread function pointer
    threadfun = t->Function;

    // Call the user thread function
    threadfun( (void *) lpParam );

    // Remove thread from thread list
    ENTER_THREAD_CRITICAL_SECTION
    _glfwRemoveThread( t );
    LEAVE_THREAD_CRITICAL_SECTION

    // When the thread function returns, the thread will die...
    return 0;
}



//************************************************************************
//****                     GLFW user functions                        ****
//************************************************************************

//========================================================================
// _glfwPlatformCreateThread() - Create a new thread
//========================================================================

GLFWthread _glfwPlatformCreateThread( GLFWthreadfun fun, void *arg )
{
    GLFWthread  ID;
    _GLFWthread *t, *t_tmp;
    HANDLE      hThread;
    DWORD       dwThreadId;

    // Enter critical section
    ENTER_THREAD_CRITICAL_SECTION

    // Create a new thread information memory area
    t = (_GLFWthread *) malloc( sizeof(_GLFWthread) );
    if( t == NULL )
    {
        // Leave critical section
        LEAVE_THREAD_CRITICAL_SECTION
        return -1;
    }

    // Get a new unique thread id
    ID = _glfwThrd.NextID ++;

    // Store thread information in the thread list
    t->Function = fun;
    t->ID       = ID;

    // Create thread
    hThread = CreateThread(
        NULL,              // Default security attributes
        0,                 // Default stack size (1 MB)
        _glfwNewThread,    // Thread function (a wrapper function)
        (LPVOID)arg,       // Argument to thread is the user argument
        0,                 // Default creation flags
        &dwThreadId        // Returned thread identifier
    );

    // Did the thread creation fail?
    if( hThread == NULL )
    {
        free( (void *) t );
        LEAVE_THREAD_CRITICAL_SECTION
        return -1;
    }

    // Store more thread information in the thread list
    t->Handle = hThread;
    t->WinID  = dwThreadId;

    // Append thread to thread list
    t_tmp = &_glfwThrd.First;
    while( t_tmp->Next != NULL )
    {
        t_tmp = t_tmp->Next;
    }
    t_tmp->Next = t;
    t->Previous = t_tmp;
    t->Next     = NULL;

    // Leave critical section
    LEAVE_THREAD_CRITICAL_SECTION

    // Return the GLFW thread ID
    return ID;
}


//========================================================================
// _glfwPlatformDestroyThread() - Kill a thread. NOTE: THIS IS A VERY
// DANGEROUS OPERATION, AND SHOULD NOT BE USED EXCEPT IN EXTREME
// SITUATIONS!
//========================================================================

void _glfwPlatformDestroyThread( GLFWthread ID )
{
    _GLFWthread *t;

    // Enter critical section
    ENTER_THREAD_CRITICAL_SECTION

    // Get thread information pointer
    t = _glfwGetThreadPointer( ID );
    if( t == NULL )
    {
        LEAVE_THREAD_CRITICAL_SECTION
        return;
    }

    // Simply murder the process, no mercy!
    if( TerminateThread( t->Handle, 0 ) )
    {
        // Close thread handle
        CloseHandle( t->Handle );

        // Remove thread from thread list
        _glfwRemoveThread( t );
    }

    // Leave critical section
    LEAVE_THREAD_CRITICAL_SECTION
}


//========================================================================
// _glfwPlatformWaitThread() - Wait for a thread to die
//========================================================================

int _glfwPlatformWaitThread( GLFWthread ID, int waitmode )
{
    DWORD       result;
    HANDLE      hThread;
    _GLFWthread *t;

    // Enter critical section
    ENTER_THREAD_CRITICAL_SECTION

    // Get thread information pointer
    t = _glfwGetThreadPointer( ID );

    // Is the thread already dead?
    if( t == NULL )
    {
        LEAVE_THREAD_CRITICAL_SECTION
        return GL_TRUE;
    }

    // Get thread handle
    hThread = t->Handle;

    // Leave critical section
    LEAVE_THREAD_CRITICAL_SECTION

    // Wait for thread to die
    if( waitmode == GLFW_WAIT )
    {
        result = WaitForSingleObject( hThread, INFINITE );
    }
    else if( waitmode == GLFW_NOWAIT )
    {
        result = WaitForSingleObject( hThread, 0 );
    }
    else
    {
        return GL_FALSE;
    }

    // Did we have a time-out?
    if( result == WAIT_TIMEOUT )
    {
        return GL_FALSE;
    }
    return GL_TRUE;
}


//========================================================================
// _glfwPlatformGetThreadID() - Return the thread ID for the current
// thread
//========================================================================

GLFWthread _glfwPlatformGetThreadID( void )
{
    _GLFWthread *t;
    GLFWthread  ID = -1;
    DWORD       WinID;

    // Get Windows thread ID
    WinID = GetCurrentThreadId();

    // Enter critical section (to avoid an inconsistent thread list)
    ENTER_THREAD_CRITICAL_SECTION

    // Loop through entire list of threads to find the matching Windows
    // thread ID
    for( t = &_glfwThrd.First; t != NULL; t = t->Next )
    {
        if( t->WinID == WinID )
        {
            ID = t->ID;
            break;
        }
    }

    // Leave critical section
    LEAVE_THREAD_CRITICAL_SECTION

    // Return the found GLFW thread identifier
    return ID;
}


//========================================================================
// _glfwPlatformCreateMutex() - Create a mutual exclusion object
//========================================================================

GLFWmutex _glfwPlatformCreateMutex( void )
{
    CRITICAL_SECTION *mutex;

    // Allocate memory for mutex
    mutex = (CRITICAL_SECTION *) malloc( sizeof(CRITICAL_SECTION) );
    if( !mutex )
    {
        return NULL;
    }

    // Initialize mutex
    InitializeCriticalSection( mutex );

    // Cast to GLFWmutex and return
    return (GLFWmutex) mutex;
}


//========================================================================
// glfwDestroyMutex() - Destroy a mutual exclusion object
//========================================================================

void _glfwPlatformDestroyMutex( GLFWmutex mutex )
{
    // Destroy mutex
    DeleteCriticalSection( (CRITICAL_SECTION *) mutex );
    free( mutex );
}


//========================================================================
// _glfwPlatformLockMutex() - Request access to a mutex
//========================================================================

void _glfwPlatformLockMutex( GLFWmutex mutex )
{
    // Wait for mutex to be released
    EnterCriticalSection( (CRITICAL_SECTION *) mutex );
}


//========================================================================
// _glfwPlatformUnlockMutex() - Release a mutex
//========================================================================

void _glfwPlatformUnlockMutex( GLFWmutex mutex )
{
    // Release mutex
    LeaveCriticalSection( (CRITICAL_SECTION *) mutex );
}


//========================================================================
// _glfwPlatformCreateCond() - Create a new condition variable object
//========================================================================

GLFWcond _glfwPlatformCreateCond( void )
{
    _GLFWcond   *cond;

    // Allocate memory for condition variable
    cond = (_GLFWcond *) malloc( sizeof(_GLFWcond) );
    if( !cond )
    {
        return NULL;
    }

    // Initialize condition variable
    cond->waiters_count = 0;
    cond->events[ _GLFW_COND_SIGNAL ]    = CreateEvent( NULL, FALSE,
                                                        FALSE, NULL );
    cond->events[ _GLFW_COND_BROADCAST ] = CreateEvent( NULL, TRUE,
                                                        FALSE, NULL );
    InitializeCriticalSection( &cond->waiters_count_lock );

    // Cast to GLFWcond and return
    return (GLFWcond) cond;
}


//========================================================================
// _glfwPlatformDestroyCond() - Destroy a condition variable object
//========================================================================

void _glfwPlatformDestroyCond( GLFWcond cond )
{
    // Close the condition variable handles
    CloseHandle( ((_GLFWcond *)cond)->events[ _GLFW_COND_SIGNAL ] );
    CloseHandle( ((_GLFWcond *)cond)->events[ _GLFW_COND_BROADCAST ] );

    // Delete critical section
    DeleteCriticalSection( &((_GLFWcond *)cond)->waiters_count_lock );

    // Free memory for condition variable
    free( (void *) cond );
}


//========================================================================
// _glfwPlatformWaitCond() - Wait for a condition to be raised
//========================================================================

void _glfwPlatformWaitCond( GLFWcond cond, GLFWmutex mutex,
    double timeout )
{
    _GLFWcond *cv = (_GLFWcond *) cond;
    int       result, last_waiter;
    DWORD     timeout_ms;

    // Avoid race conditions
    EnterCriticalSection( &cv->waiters_count_lock );
    cv->waiters_count ++;
    LeaveCriticalSection( &cv->waiters_count_lock );

    // It's ok to release the mutex here since Win32 manual-reset events
    // maintain state when used with SetEvent()
    LeaveCriticalSection( (CRITICAL_SECTION *) mutex );

    // Translate timeout into milliseconds
    if( timeout >= GLFW_INFINITY )
    {
        timeout_ms = INFINITE;
    }
    else
    {
        timeout_ms = (DWORD) (1000.0 * timeout + 0.5);
        if( timeout_ms <= 0 )
        {
            timeout_ms = 1;
        }
    }

    // Wait for either event to become signaled due to glfwSignalCond or
    // glfwBroadcastCond being called
    result = WaitForMultipleObjects( 2, cv->events, FALSE, timeout_ms );

    // Check if we are the last waiter
    EnterCriticalSection( &cv->waiters_count_lock );
    cv->waiters_count --;
    last_waiter = (result == WAIT_OBJECT_0 + _GLFW_COND_BROADCAST) &&
                  (cv->waiters_count == 0);
    LeaveCriticalSection( &cv->waiters_count_lock );

    // Some thread called glfwBroadcastCond
    if( last_waiter )
    {
        // We're the last waiter to be notified or to stop waiting, so
        // reset the manual event
        ResetEvent( cv->events[ _GLFW_COND_BROADCAST ] );
    }

    // Reacquire the mutex
    EnterCriticalSection( (CRITICAL_SECTION *) mutex );
}


//========================================================================
// _glfwPlatformSignalCond() - Signal a condition to one waiting thread
//========================================================================

void _glfwPlatformSignalCond( GLFWcond cond )
{
    _GLFWcond *cv = (_GLFWcond *) cond;
    int       have_waiters;

    // Avoid race conditions
    EnterCriticalSection( &cv->waiters_count_lock );
    have_waiters = cv->waiters_count > 0;
    LeaveCriticalSection( &cv->waiters_count_lock );

    if( have_waiters )
    {
        SetEvent( cv->events[ _GLFW_COND_SIGNAL ] );
    }
}


//========================================================================
// _glfwPlatformBroadcastCond() - Broadcast a condition to all waiting
// threads
//========================================================================

void _glfwPlatformBroadcastCond( GLFWcond cond )
{
    _GLFWcond *cv = (_GLFWcond *) cond;
    int       have_waiters;

    // Avoid race conditions
    EnterCriticalSection( &cv->waiters_count_lock );
    have_waiters = cv->waiters_count > 0;
    LeaveCriticalSection( &cv->waiters_count_lock );

    if( have_waiters )
    {
        SetEvent( cv->events[ _GLFW_COND_BROADCAST ] );
    }
}


//========================================================================
// _glfwPlatformGetNumberOfProcessors() - Return the number of processors
// in the system.
//========================================================================

int _glfwPlatformGetNumberOfProcessors( void )
{
    SYSTEM_INFO si;

    // Get hardware system information
    GetSystemInfo( &si );

    return (int) si.dwNumberOfProcessors;
}