ossim::Block Class Reference

This is a very simple block interface. More...

#include <Block.h>

Public Member Functions
	Block (bool releaseFlag=false)
	Allows one the construct a Block with a release state. More...
	~Block ()
	Destructor. More...
void	set (bool releaseFlag)
	Will set the relase flag and wake up all threads to test the condition again. More...
void	block ()
	Will block the calling thread based on the internal condition. More...
void	block (ossim_uint64 waitTimeMillis)
	Will block the calling thread base on the internal condition. More...
void	release ()
	Releases the threads and will not return until all threads are released. More...
void	reset ()
	Simple reset the values. More...

Private Attributes
std::mutex	m_mutex
	Used by the conditions. More...
std::atomic< bool >	m_release
	The release state. More...
std::condition_variable	m_conditionVariable
	Condition that tests the release state. More...
std::atomic< ossim_int32 >	m_waitCount
	Used to count the number of threads blocked or waiting on the condition. More...
std::condition_variable	m_conditionalWait
	Will be used for destructing and releasing. More...

Detailed Description

This is a very simple block interface.

This allows one to control how their threads are blocked

There is a release state flag that tells the call to block to block the calling thread or release the thread(s) that are currently blocked

For a very simple use case we will start a thread and call block and have the main sleep for 2 seconds before releasing the thread

#include <ossim/base/Block.h>
#include <ossim/base/Thread.h>
std::shared_ptr<ossim::Block> block = std::make_shared<ossim::Block>();
class TestThread : public ossim::Thread
{
public:

protected:
   virtual void run(){
     block->block();
      std::cout << "STARING!!!!!!!\n";
   }
};
int main(int argc, char *argv[])
{
   TestThread t1;
   t1.start();

   std::cout << "WAITING 2 SECOND to release block\n";
   ossim::Thread::sleepInSeconds(2);
   block->release();
   ossim::Thread::sleepInSeconds(2);
}

Definition at line 45 of file Block.h.

Constructor & Destructor Documentation

Block()

ossim::Block::Block

(

bool

releaseFlag = false

)

Allows one the construct a Block with a release state.

Definition at line 4 of file Block.cpp.

:m_release(releaseFlag),
m_waitCount(0)
{

}

~Block()

ossim::Block::~Block

(

)

Destructor.

Will set internally call release

Definition at line 11 of file Block.cpp.

{
   release();
   {
      std::unique_lock<std::mutex> lock(m_mutex);
      if(m_waitCount>0)
      {
         m_conditionalWait.wait(lock, [this]{return m_waitCount.load()<1;});
      }
   }
}

Member Function Documentation

block() [1/2]

void ossim::Block::block

(

)

Will block the calling thread based on the internal condition.

If the internal condition is set to release then it will return without blocking.

Definition at line 33 of file Block.cpp.

Referenced by ossimMultiThreadSequencer::getNextTile(), ossimMultiThreadSequencer::nextJob(), and ossimJobQueue::nextJob().

{
   std::unique_lock<std::mutex> lock(m_mutex);
   if(!m_release)
   {
      ++m_waitCount;
      m_conditionVariable.wait(lock, [this]{
         return (m_release.load() == true);
      });
      --m_waitCount;
      if(m_waitCount < 0) m_waitCount = 0;
   }
   m_conditionVariable.notify_all();   
   m_conditionalWait.notify_all();
}

block() [2/2]

void ossim::Block::block

(

ossim_uint64

waitTimeMillis

)

Will block the calling thread base on the internal condition.

If the internal condition is set to release the it will return without blocking. If the internal condition is set to not release then it will block for the specified time in milliseconds

Parameters

waitTimeMillis

specifies the amount of time to wait for the release

Definition at line 49 of file Block.cpp.

{
   std::unique_lock<std::mutex> lock(m_mutex);
   if(!m_release)
   {
      ++m_waitCount;
      m_conditionVariable.wait_for(lock, 
                                   std::chrono::milliseconds(waitTimeMillis),
                                   [this]{
         return (m_release.load() == true);
      });
      --m_waitCount;
      if(m_waitCount < 0) m_waitCount = 0;
   }
   m_conditionVariable.notify_all();   
   m_conditionalWait.notify_all();
}

release()

void ossim::Block::release

(

)

Releases the threads and will not return until all threads are released.

Definition at line 66 of file Block.cpp.

Referenced by ossimMultiThreadSequencer::getNextTile(), ossimJobQueue::releaseBlock(), and ossimMultiThreadSequencer::ossimGetTileJob::run().

{
   {   
      std::unique_lock<std::mutex> lock(m_mutex);
      if(!m_release)
      {
         m_release = true;
      }
      m_conditionVariable.notify_all();
   }
}

reset()

void ossim::Block::reset

(

)

Simple reset the values.

Will not do any releasing

Definition at line 78 of file Block.cpp.

Referenced by ossimMultiThreadSequencer::getNextTile(), and ossimMultiThreadSequencer::nextJob().

{
   std::unique_lock<std::mutex> lock(m_mutex);

   m_release   = false;
   m_waitCount = 0;
}

set()

void ossim::Block::set

(

bool

releaseFlag

)

Will set the relase flag and wake up all threads to test the condition again.

Definition at line 23 of file Block.cpp.

Referenced by ossimJobQueue::add(), ossimJobQueue::nextJob(), ossimJobQueue::removeById(), and ossimJobQueue::removeByName().

{
   {
      std::unique_lock<std::mutex> lock(m_mutex);

      m_release = releaseFlag;      
   }
   m_conditionVariable.notify_all();
}

Member Data Documentation

m_conditionalWait

std::condition_variable ossim::Block::m_conditionalWait

private

Will be used for destructing and releasing.

resetting should only happen in the main thread

Definition at line 118 of file Block.h.

m_conditionVariable

std::condition_variable ossim::Block::m_conditionVariable

private

Condition that tests the release state.

Definition at line 105 of file Block.h.

m_mutex

std::mutex ossim::Block::m_mutex

mutableprivate

Used by the conditions.

Definition at line 95 of file Block.h.

m_release

std::atomic<bool> ossim::Block::m_release

private

The release state.

Definition at line 100 of file Block.h.

m_waitCount

std::atomic<ossim_int32> ossim::Block::m_waitCount

private

Used to count the number of threads blocked or waiting on the condition.

Definition at line 111 of file Block.h.

---

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

• Block.h
• Block.cpp