vrpn_Thread.h

浏览该文件的文档.

 
// 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