Thread.h

Go to the documentation of this file.

/* -*-c++-*- OpenThreads library, Copyright (C) 2002 - 2007  The Open Thread Group
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * OpenSceneGraph Public License for more details.
*/


//
// Thread - C++ Thread class
// ~~~~~~~~
//

#ifndef _OPENTHREADS_THREAD_
#define _OPENTHREADS_THREAD_

#include <sys/types.h>

#include <OpenThreads/Mutex>

namespace OpenThreads {

extern OPENTHREAD_EXPORT_DIRECTIVE int GetNumberOfProcessors();

extern OPENTHREAD_EXPORT_DIRECTIVE int SetProcessorAffinityOfCurrentThread(unsigned int cpunum);

class OPENTHREAD_EXPORT_DIRECTIVE Thread {

public:

    static int SetConcurrency(int concurrencyLevel);

    static int GetConcurrency();

    enum ThreadPriority {

        THREAD_PRIORITY_MAX,      
        THREAD_PRIORITY_HIGH,     
        THREAD_PRIORITY_NOMINAL,  
        THREAD_PRIORITY_LOW,      
        THREAD_PRIORITY_MIN,      
        THREAD_PRIORITY_DEFAULT   
    };

    enum ThreadPolicy {

        THREAD_SCHEDULE_FIFO,        
        THREAD_SCHEDULE_ROUND_ROBIN, 
        THREAD_SCHEDULE_TIME_SHARE,  
        THREAD_SCHEDULE_DEFAULT      
    };

    Thread();

    virtual ~Thread();


    static Thread *CurrentThread();


    static void Init();

    static int YieldCurrentThread();

    static ThreadPriority GetMasterPriority() {return s_masterThreadPriority;};


    int getThreadId();

    size_t getProcessId();

    int start();
    int startThread();

    int testCancel();


    virtual int cancel();

    int setSchedulePriority(ThreadPriority priority);

    int getSchedulePriority();

    int setSchedulePolicy(ThreadPolicy policy);

    int getSchedulePolicy();

    int setStackSize(size_t size);

    size_t getStackSize();

    void printSchedulingInfo();

    int detach();

    int join();

    int setCancelModeDisable();

    int setCancelModeAsynchronous();

    int setCancelModeDeferred();

    bool isRunning();

    virtual void run() = 0;

    virtual void cancelCleanup() {};

    void* getImplementation(){ return _prvData; };

    int setProcessorAffinity( unsigned int cpunum );

    static int microSleep( unsigned int microsec);

private:

    friend class ThreadPrivateActions;

    Thread(const Thread &/*t*/) {};

    Thread &operator=(const Thread &/*t*/) {return *(this);};

    void * _prvData;

    static ThreadPriority s_masterThreadPriority;

    static bool s_isInitialized;
};

}

#endif // !_OPENTHREADS_THREAD_