bio::Threaded Class Reference

#include <Threaded.h>

Inheritance diagram for bio::Threaded:

Collaboration diagram for bio::Threaded:

Public Types
typedef pid_t	ThreadId

Public Member Functions
	Threaded ()
virtual	~Threaded ()
virtual ThreadId	GetThreadId ()
virtual bool	IsRunning ()
virtual void	Sleep (TimeUS us)
virtual bool	Start ()
virtual bool	Stop ()
virtual bool	Work ()
Public Member Functions inherited from bio::ThreadSafe
	ThreadSafe ()
	ThreadSafe (const ThreadSafe &toCopy)
virtual	~ThreadSafe ()
void	LockThread () const
void	UnlockThread () const

Static Public Member Functions
static ThreadId	InvalidThreadId ()

Protected Member Functions
virtual void	RequestStop ()

Static Protected Member Functions
static void *	Worker (void *arg)

Protected Attributes
bool	m_created
ThreadId	m_id
bool	m_running
bool	m_stopRequested

Detailed Description

Threaded classes are a wrapper around whatever thread interface the system is using. This class moves whatever Work() you need to do into a new thread with a simple wrapper that is OS & c++ version independent.

NOTE: we're currently only supporting threading on c++11 and greater and on linux using c++98 on. We may or may not ever support c++98 threading on windows, etc. TODO: does pthread work on Apple and BSD?

NOTE: YOU MUST CALL STOP BEFORE DESTROYING *this!!!!

Definition at line 52 of file Threaded.h.

Member Typedef Documentation

ThreadId

typedef pid_t bio::Threaded::ThreadId

Definition at line 57 of file Threaded.h.

Constructor & Destructor Documentation

Threaded()

bio::Threaded::Threaded

(

)

YOU MUST CALL STOP BEFORE DESTROYING *this!!!!

Definition at line 37 of file Threaded.cpp.

    :
//@formatter:off
    #if BIO_CPP_VERSION < 11
        #ifdef BIO_OS_IS_LINUX
            //use m_thread default ctor
        #endif
        m_id(InvalidThreadId()),
    #else
        m_thread(NULL),
    #endif
    //@formatter:on
    m_created(false),
    m_running(false),
    m_stopRequested(false)
{
 
}

~Threaded()

bio::Threaded::~Threaded ( )

virtual

Definition at line 56 of file Threaded.cpp.

{
    BIO_ASSERT(!m_running);
}

References BIO_ASSERT, and m_running.

Member Function Documentation

GetThreadId()

Threaded::ThreadId bio::Threaded::GetThreadId ( )

virtual

Returns

the id of our thread.

Definition at line 102 of file Threaded.cpp.

{
    //@formatter:off
    #if BIO_CPP_VERSION < 11
        return m_id;
    #else
        BIO_SANITIZE(m_thread,,return InvalidThreadId())
        return m_thread->get_id();
    #endif
    //@formatter:on
}

References BIO_SANITIZE, InvalidThreadId(), and m_id.

InvalidThreadId()

static ThreadId bio::Threaded::InvalidThreadId ( )

inlinestatic

Returns

what is hopefully not a proper ThreadId.

Definition at line 65 of file Threaded.h.

    {
        return 0;
    }

Referenced by GetThreadId().

IsRunning()

bool bio::Threaded::IsRunning ( )

virtual

Returns

whether or not Work() is being called by our thread.

Definition at line 61 of file Threaded.cpp.

{
    LockThread();
    bool ret = m_running;
    UnlockThread();
    return ret;
}

References bio::ThreadSafe::LockThread(), m_running, and bio::ThreadSafe::UnlockThread().

RequestStop()

void bio::Threaded::RequestStop ( )

protectedvirtual

Sets m_stopRequested to true.

Definition at line 69 of file Threaded.cpp.

{
    LockThread();
    m_stopRequested = true;
    UnlockThread();
}

References bio::ThreadSafe::LockThread(), m_stopRequested, and bio::ThreadSafe::UnlockThread().

Referenced by Stop().

Sleep()

void bio::Threaded::Sleep ( TimeUS  us )

virtual

Release thread processing for us microseconds.

Parameters

us

Definition at line 170 of file Threaded.cpp.

{
    //@formatter:off
    #if BIO_CPP_VERSION < 11
        #ifdef BIO_OS_IS_LINUX
            usleep(us);
        #endif
    #else
        std::this_thread::sleep_for (std::chrono::microseconds(ms));
    #endif
    //@formatter:on
}

Start()

bool bio::Threaded::Start ( )

virtual

Starts our thread, which will continuously call Work() until Stop()ed (or Work() exits).

Returns

whether or not our thread was successfully created.

Definition at line 114 of file Threaded.cpp.

{
    LockThread();
    bool isStopped = !m_created && !m_running;
    UnlockThread();
    //@formatter:off
    BIO_SANITIZE(!isStopped, ,return true)
    //@formatter:on
 
    //@formatter:off
    #if BIO_CPP_VERSION < 11
        BIO_SANITIZE(m_running,,return false)
        #ifdef BIO_OS_IS_LINUX
            int result = pthread_create(&m_thread, NULL, Worker, this);
        #endif
        m_created = result == 0;
    #else
        BIO_SANITIZE(m_thread,,return false)
        m_thread = new std::thread(&Threaded::Worker, this);
        m_created = true
    #endif
    //@formatter:on
    return m_created;
}

References BIO_SANITIZE, bio::ThreadSafe::LockThread(), m_created, m_running, bio::ThreadSafe::UnlockThread(), and Worker().

Stop()

bool bio::Threaded::Stop ( )

virtual

Instructs our thread to stop calling Work() and joins our thread.

Returns

whether or not our thread was successfully joined.

Definition at line 139 of file Threaded.cpp.

{
    LockThread();
    bool isStopped = !m_created && !m_running;
    UnlockThread();
 
    BIO_SANITIZE(isStopped, ,
        return true)
    //@formatter:off
    #if BIO_CPP_VERSION < 11
        m_stopRequested = true;
        #ifdef BIO_OS_IS_LINUX
            void** threadReturn;
            int result = pthread_join(m_thread, threadReturn);
        #endif
        RequestStop();
        m_created = false;
        return result == 0;
    #else
        BIO_SANITIZE(m_thread,,return true)
        RequestStop();
        m_thread->join();
        delete m_thread;
        m_thread = NULL;
        m_created = false;
        return true;
    #endif
    //@formatter:on
 
}

References BIO_SANITIZE, bio::ThreadSafe::LockThread(), m_created, m_running, m_stopRequested, RequestStop(), and bio::ThreadSafe::UnlockThread().

Work()

virtual bool bio::Threaded::Work ( )

inlinevirtual

Does the actual work. Will be called repeatedly until either: Stop() is called OR this method returns false. So, just return false when you want to stop being a thread. You may want to Sleep() (below) after you Work() ;)

Returns

false when you want to stop; true if you want to run until Stop()ed.

Reimplemented in bio::physical::ThreadedPeriodic.

Definition at line 89 of file Threaded.h.

    {
        //your code goes here!
        return false;
    }

Referenced by Worker().

Worker()

void * bio::Threaded::Worker ( void *  arg )

staticprotected

Parameters

arg	a Threaded*

Returns

NULL

Definition at line 76 of file Threaded.cpp.

{
    Threaded* threaded = Cast< Threaded* >(arg);
    BIO_SANITIZE(threaded, ,
        return NULL);
 
    threaded->LockThread();
    threaded->m_running = true;
    threaded->UnlockThread();
 
    bool again = true;
    while (again)
    {
        bool again = threaded->Work();
        threaded->LockThread();
        again = again && threaded->m_stopRequested;
        threaded->UnlockThread();
    }
 
    threaded->LockThread();
    threaded->m_running = false;
    threaded->UnlockThread();
 
    return NULL;
}

References BIO_SANITIZE, bio::ThreadSafe::LockThread(), m_running, m_stopRequested, bio::ThreadSafe::UnlockThread(), and Work().

Referenced by Start().

Member Data Documentation

m_created

bool bio::Threaded::m_created

protected

Definition at line 141 of file Threaded.h.

Referenced by Start(), and Stop().

m_id

ThreadId bio::Threaded::m_id

protected

Definition at line 130 of file Threaded.h.

Referenced by GetThreadId().

m_running

bool bio::Threaded::m_running

protected

Definition at line 142 of file Threaded.h.

Referenced by ~Threaded(), IsRunning(), Start(), Stop(), and Worker().

m_stopRequested

bool bio::Threaded::m_stopRequested

protected

Definition at line 143 of file Threaded.h.

Referenced by RequestStop(), Stop(), and Worker().

---

The documentation for this class was generated from the following files:

• /home/eons/git/biology/lib_bio/inc/bio/common/Threaded.h
• /home/eons/git/biology/lib_bio/src/common/Threaded.cpp