vrpn_Thread.h

Go to the documentation of this file.

 
// Copyright 2015 Sensics, Inc.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)
 
#ifndef INCLUDED_vrpn_Thread_h_GUID_A455652F_72CE_4F8A_859E_543489012D01
#define INCLUDED_vrpn_Thread_h_GUID_A455652F_72CE_4F8A_859E_543489012D01
 
// Internal Includes
#include "vrpn_Configure.h" // for VRPN_API
 
// Library/third-party includes
// - none
 
// Standard includes
 
#if defined(sgi) || (defined(_WIN32) && !defined(__CYGWIN__)) ||               \
    defined(linux) || defined(__APPLE__)
#define vrpn_THREADS_AVAILABLE
#else
#undef vrpn_THREADS_AVAILABLE
#endif
 
// multi process stuff
#if defined(sgi)
#include <task.h>
#include <ulocks.h>
#elif defined(_WIN32)
#include "vrpn_WindowsH.h"
#include <process.h>
#else
#include <pthread.h>   // for pthread_t
#include <semaphore.h> // for sem_t
#endif
 
// make the SGI compile without tons of warnings
#ifdef sgi
#pragma set woff 1110, 1424, 3201
#endif
 
// and reset the warnings
#ifdef sgi
#pragma reset woff 1110, 1424, 3201
#endif
 
class VRPN_API vrpn_Semaphore {
public:
    vrpn_Semaphore(int cNumResources = 1);

    ~vrpn_Semaphore();

    bool reset(int cNumResources = 1);

    int p();

    int v();

    int condP();

    int numResources();
 
private:
    vrpn_Semaphore(const vrpn_Semaphore &);
    vrpn_Semaphore & operator=(const vrpn_Semaphore &);
    bool init();
    bool destroy();
 
    int cResources;
 
    // arch specific details
#ifdef sgi
    // single mem area for dynamically alloced shared mem
    static usptr_t *ppaArena;
    static void allocArena();
 
    // the semaphore struct in the arena
    usema_t *ps;
    ulock_t l;
    bool fUsingLock;
#elif defined(_WIN32)
    HANDLE hSemaphore;
#else
    sem_t *semaphore; // Posix
#endif
};
 
namespace vrpn {
    struct try_to_lock_t {
    };

    const try_to_lock_t try_to_lock = {};
    class VRPN_API SemaphoreGuard {
    public:
        explicit SemaphoreGuard(vrpn_Semaphore &sem);

        SemaphoreGuard(vrpn_Semaphore &sem, try_to_lock_t);

        ~SemaphoreGuard();

        bool locked() const { return locked_; }

        void lock();

        bool try_to_lock();

        void unlock();
 
    private:
        void handleLockResult_(int result);
        SemaphoreGuard(SemaphoreGuard const &);
        SemaphoreGuard &operator=(SemaphoreGuard const &);
        bool locked_;
        vrpn_Semaphore &sem_;
    };
 
} // namespace vrpn
 
// A ptr to this struct will be passed to the
// thread function.  The user data ptr will be in pvUD.
// (There used to be a non-functional semaphore object
// also in this structure, but it was removed.  This leaves
// a struct with only one element, which is a pain but
// at least it doesn't break existing code.  If we need
// to add something else later, there is a place for it.
 
// The user should create and manage any semaphore needed
// to handle access control to the userdata.
 
struct VRPN_API vrpn_ThreadData {
    void *pvUD;
};
 
typedef void(*vrpn_THREAD_FUNC)(vrpn_ThreadData &threadData);
 
// Don't let the existence of a Thread class fool you into thinking
// that VRPN is thread-safe.  This and the Semaphore are included as
// building blocks towards making your own code thread-safe.  They are
// here to enable the vrpn_Imager_Stream_Buffer class to do its thing.
class VRPN_API vrpn_Thread {
public:
    // args are the routine to run in the thread
    // a ThreadData struct which will be passed into
    // the thread (it will be passed as a void *).
    vrpn_Thread(vrpn_THREAD_FUNC pfThread, vrpn_ThreadData td);
    ~vrpn_Thread();
 
#if defined(sgi)
    typedef unsigned long thread_t;
#elif defined(_WIN32)
    typedef uintptr_t thread_t;
#else
    typedef pthread_t thread_t;
#endif
 
    // start/kill the thread (true on success, false on failure)
    bool go();
    bool kill();
 
    // thread info: check if running, get proc id
    bool running();
    thread_t pid();
 
    // run-time user function to test if threads are available
    // (same value as #ifdef THREADS_AVAILABLE)
    static bool available();
 
    // Number of processors available on this machine.
    static unsigned number_of_processors();
 
    // This can be used to change the ThreadData user data ptr
    // between calls to go (ie, when a thread object is used
    // many times with different args).  This will take
    // effect the next time go() is called.
    void userData(void *pvNewUserData);
    void *userData();
 
protected:
    // user func and data ptrs
    void(*pfThread)(vrpn_ThreadData &ThreadData);
    vrpn_ThreadData td;
 
    // utility func for calling the specified function.
    static void threadFuncShell(void *pvThread);
 
    // Posix version of the utility function, makes the
    // function prototype match.
    static void *threadFuncShellPosix(void *pvThread);
 
    // the process id
    thread_t threadID;
};
 
// Returns true if they work and false if they do not.
extern bool vrpn_test_threads_and_semaphores(void);
 
 
 
#endif // INCLUDED_vrpn_Thread_h_GUID_A455652F_72CE_4F8A_859E_543489012D01