threadsafe.cpp

Go to the documentation of this file.

/*
 * threadsafe.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 */

// includes --------------------------------------------------------------------
#include "threadsafe.h"         // always include our own header first!

#include "common/wave_ex.h"
#include "perf/perf.h"
#include "threadsafe/smart_mutex.h"



////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

#ifdef WIN32

struct win32_context_t {
        // constructor, manipulators
        win32_context_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        start_fn = NULL;
                        real_context = NULL;
                }

        // data fields
        thread_start_fn_t       start_fn;
        void *                  real_context;
};


static DWORD WINAPI
win32start
(
IN LPVOID ctx
)
{
        win32_context_t * win32ctx = (win32_context_t *) ctx;
        ASSERT(win32ctx, "should always have win32 thread context");
        ASSERT(win32ctx->start_fn, "null thread start function");

        win32ctx->start_fn(win32ctx->real_context);

        return 0;
}


#endif  // WIN32


////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

int
createThread
(
IN thread_start_fn_t start_fn,
IN void * context,
OUT thread_id_t& threadId
)
{
        ASSERT(start_fn, "null thread start function");
        // ASSERT(context) -- we don't care!
        threadId = 0;

#ifdef WIN32
// win32 threading implementation
        ASSERT(sizeof(thread_id_t) >= sizeof(dword_t),
            "thread_id_t type is too small!");
        dword_t stackSize = 0;  // use default
        dword_t flags = 0;      // default flags
        win32_context_t wctx;
        wctx.start_fn = start_fn;
        wctx.real_context = context;
        dword_t dwThreadId = 0;
        HANDLE hThread =
            CreateThread(NULL, stackSize, win32start, &wctx, flags,
                (LPDWORD) &dwThreadId);
        if (!hThread) {
                int error = GetLastError();
                DPRINTF("Failed to create new thread: %d", error);
                return (error) ? error : 1;
        }
        threadId = (thread_id_t) dwThreadId;

#else   // WIN32
// posix threading implementation

        ASSERT(sizeof(thread_id_t) >= sizeof(pthread_t),
            "thread_id_t type is too small!");
        pthread_t pid;
        pthread_create(&pid, NULL, start_fn, context);
        threadId = (thread_id_t) pid;

#endif  // WIN32

        // must be okay!
        return 0;
}



thread_id_t
getCurrentThreadId
(
void
)
{
#ifdef WIN32
        return (thread_id_t) GetCurrentThreadId();
#else   // WIN32
        return (thread_id_t) pthread_self();
#endif  // WIN32
}



void
sleepMilliseconds
(
IN long milliseconds
)
{
        ASSERT(milliseconds >= 0, "bad sleep milliseconds: %d",
            (int) milliseconds);
#ifdef WIN32
        // windows: use Sleep()
        Sleep(milliseconds);
#else   // WIN32
        // linux/posix: use nanosleep
        struct timespec ts;
        ts.tv_sec = 0;
        ts.tv_nsec = 1000 * 1000 * milliseconds;
        nanosleep(&ts, NULL);
#endif  // WIN32
}