osaThread.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */
 
/*
 
  Author(s): Ankur Kapoor
  Created on: 2004-04-30
 
  (C) Copyright 2004-2019 Johns Hopkins University (JHU), All Rights Reserved.
 
--- begin cisst license - do not edit ---
 
This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.
 
--- end cisst license ---
*/
 

 
#ifndef _osaThread_h
#define _osaThread_h
 
#include <cisstCommon/cmnPortability.h>
#include <cisstOSAbstraction/osaThreadAdapter.h>
#include <cisstOSAbstraction/osaThreadSignal.h>
 
// Always include last
#include <cisstOSAbstraction/osaExport.h>
 
 
#if (CISST_OS == CISST_WINDOWS)
#define SCHED_FIFO 0   
#endif
 
// SCHED_FIFO is not defined otherwise
#if (CISST_OS == CISST_LINUX) || (CISST_OS == CISST_DARWIN)
#include <pthread.h>
#endif

typedef int PriorityType;
 

typedef int SchedulingPolicyType;
 
 

class CISST_EXPORT osaThreadId {

    enum {INTERNALS_SIZE = 8};
    char Internals[INTERNALS_SIZE];
    bool Valid;
 
    friend CISST_EXPORT osaThreadId osaGetCurrentThreadId(void);
    friend class osaThread;

    static unsigned int SizeOfInternals(void);
    friend class osaThreadTest;
 
public:

    osaThreadId(void);

    ~osaThreadId();

    bool IsValid(void) const { return Valid; }

    bool Equal(const osaThreadId & other) const;

    inline bool operator == (const osaThreadId & other) const {
        return this->Equal(other);
    }

    inline bool operator != (const osaThreadId & other) const {
        return !this->Equal(other);
    }

#if (CISST_OS == CISST_LINUX_RTAI) || (CISST_OS == CISST_LINUX) || (CISST_OS == CISST_SOLARIS) || (CISST_OS == CISST_QNX) || (CISST_OS == CISST_WINDOWS)
    bool operator () (const osaThreadId & lhs, const osaThreadId & rhs) const;
#endif

    // bool Lesser(const osaThreadId & other) const;

    // inline bool operator < (const osaThreadId & other) const {
    //    return this->Lesser(other);
    // }

    void ToStream(std::ostream & outputStream) const;
};
 

inline
std::ostream & operator << (std::ostream & output,
                            const osaThreadId & threadId) {
    threadId.ToStream(output);
    return output;
}
 

CISST_EXPORT osaThreadId osaGetCurrentThreadId(void);
 
 
 

class CISST_EXPORT osaThread {

    osaThreadSignal Signal;

    enum { INTERNALS_SIZE = 96 };   // PKAZ: this can be reduced
    char Internals[INTERNALS_SIZE];

    static unsigned int SizeOfInternals(void);
    friend class osaThreadTest;

    char Name[6];

    SchedulingPolicyType Policy;

    PriorityType Priority;

    osaThreadId ThreadId;

    bool Valid;

    bool Running;
 
protected:

    void CreateInternal(const char* name, void* func, void* userdata);
 
    void SetThreadName(const char* name);
 
public:

    osaThread();

    ~osaThread();

    void Create(void * (*threadStart)(void),
                const char * name = 0, int priority = 0, int policy = SCHED_FIFO)
    {
        Priority = priority;
        Policy = policy;
        CreateInternal(name, (void *)threadStart, 0);
    }

    template <class _userDataType>
    void Create(void * (*threadStart)(_userDataType),
                _userDataType userData = _userDataType(),
                const char * name = 0, int priority = 0, int policy = SCHED_FIFO)
    {
        Priority = priority;
        Policy = policy;
        CreateInternal(name, (void *)threadStart, (void *)userData);
    }

    template <class _entryType, class _userDataType>
    void Create(_entryType * obj, void * (_entryType::*threadStart)(_userDataType),
                _userDataType userData = _userDataType(),
                const char * name = 0, int priority = 0, int policy = SCHED_FIFO)
    {
        Priority = priority;
        Policy = policy;
        typedef osaHeapCallBack<_entryType, _userDataType, void *, void *> adapter_t;
        // In the following, the third parameter is not the UserData, but rather an osaHeapCallBack
        // object that includes the UserData.  When the CallbackAndDestroy method is called, it takes
        // its void* parameter, casts it to osaHeapCallBack*, and then finds the actual callback method
        // and UserData within the osaHeapCallBack object.
        CreateInternal(name, (void *)adapter_t::CallbackAndDestroy, (void *)adapter_t::Create(obj, threadStart, userData));
    }

    void CreateFromCurrentThread(const char * name = 0, int priority = 0, int policy = SCHED_FIFO)
    {
        Priority = priority;
        Policy = policy;
        ThreadId = osaGetCurrentThreadId();
        SetThreadName(name);
        Valid = true;
    }
 
    void CreateFromThreadId(const osaThreadId &threadId,
                            const char * name = 0, int priority = 0, int policy = SCHED_FIFO)
    {
        Priority = priority;
        Policy = policy;
        ThreadId = threadId;
        SetThreadName(name);
        Valid = true;
    }

    void Delete(void);

    void Wait(void);

    inline void WaitForWakeup(void) { Signal.Wait(); }

    inline void WaitForWakeup(double timeoutInSec) { Signal.Wait(timeoutInSec); }

    inline void Wakeup(void) { Signal.Raise(); }

    inline const char * GetName(void) const { return Name; }

    inline osaThreadId GetId(void) const { return ThreadId; }

    PriorityType GetPriority(void) const;

    void SetPriority(PriorityType priority);

    SchedulingPolicyType GetSchedulingPolicy(void);

    void SetSchedulingPolicy(SchedulingPolicyType policy);

    void Sleep(double timeInSeconds);

    inline bool IsRunning(void) const { return Running; }

    inline bool IsValid(void) const { return Valid; }
 
};

CISST_EXPORT void osaCurrentThreadYield(void);
 
 
 
#endif // _osaThread_h