TeThreadSignal Class Reference
[Multi-programming tools.]

#include <TeThreadSignal.h>

---

Detailed Description

A class to deal with thread signals.

Author:

Emiliano F. Castejon <castejon@dpi.inpe.br>

Definition at line 49 of file TeThreadSignal.h.

Public Member Functions
void	emitSignal ()
	TeThreadSignal ()
bool	waitSignal (unsigned int waiting_time=0)
	~TeThreadSignal ()
Private Member Functions
const TeThreadSignal &	operator= (const TeThreadSignal &)
	TeThreadSignal (const TeThreadSignal &)

---

Constructor & Destructor Documentation

TeThreadSignal::TeThreadSignal

(

)

Default constructor.

Definition at line 14 of file TeThreadSignal.cpp.

References FALSE, NULL, pthread_cond_init, pthread_mutex_init, pthread_mutexattr_init, TEAGN_TRUE_OR_THROW, and TRUE.

{
  #if TePLATFORM == TePLATFORMCODE_MSWINDOWS
  
   waiters_count_ = 0;
   wait_generation_count_ = 0;
   release_count_ = 0;

    // Create a manual-reset event.
    event_ = CreateEvent (NULL,  // no security
                          TRUE,  // manual-reset
                          FALSE, // non-signaled initially
                          NULL); // unnamed
    
  #elif TePLATFORM == TePLATFORMCODE_LINUX || TePLATFORM == TePLATFORMCODE_AIX || TePLATFORM == TePLATFORMCODE_APPLE

    /* Creating mutex */

    pthread_mutexattr_t access_attr;
    TEAGN_TRUE_OR_THROW( ( pthread_mutexattr_init( &access_attr ) == 0 ),
      "Unable to init mutex attributes" );

    pthread_mutexattr_settype( &access_attr, PTHREAD_MUTEX_DEFAULT );
    TEAGN_TRUE_OR_THROW( 
      ( pthread_mutex_init( &m_access_, &access_attr ) == 0 ),
      "Unable to init mutex" )

    /* Creating condition variable */
  
    TEAGN_TRUE_OR_THROW( ( pthread_cond_init( &condition_var_, 0 ) == 0 ),
      "Unable to create a condition variable" );
  
  #else
    #error "Unsuported plataform"
  #endif   
}

TeThreadSignal::~TeThreadSignal

(

)

Default destructor.

Definition at line 52 of file TeThreadSignal.cpp.

References pthread_cond_destroy, and pthread_mutex_destroy.

{
  #if TePLATFORM == TePLATFORMCODE_MSWINDOWS
  
    CloseHandle( event_ );
    
  #elif TePLATFORM == TePLATFORMCODE_LINUX || TePLATFORM == TePLATFORMCODE_AIX || TePLATFORM == TePLATFORMCODE_APPLE

    pthread_cond_destroy( &condition_var_ );
  
    pthread_mutex_destroy( &m_access_ );
  
  #else
    #error "Unsuported plataform"
  #endif   
}

TeThreadSignal::TeThreadSignal

(

const TeThreadSignal &

)

[inline, private]

Alternative constructor.

Definition at line 132 of file TeThreadSignal.h.

{};

---

Member Function Documentation

void TeThreadSignal::emitSignal

(

)

Emit a broadcast signal unblocking all waiting threads.

Definition at line 70 of file TeThreadSignal.cpp.

References pthread_cond_broadcast, and TEAGN_TRUE_OR_THROW.

Referenced by main(), TePDIParallelSegmenter::RunImplementation(), TePDIParallelSegmenter::segmenterThreadEntry(), threadEntry2(), and TeThreadJobsManager::threadFunction().

{
  #if TePLATFORM == TePLATFORMCODE_MSWINDOWS
  
    waiters_count_lock_.lock();
    
    if ( waiters_count_ > 0) {  
      SetEvent ( event_);
      // Release all the threads in this generation.
      release_count_ =  waiters_count_;

      // Start a new generation.
      wait_generation_count_++;
    }
    
    waiters_count_lock_.unLock();

  #elif TePLATFORM == TePLATFORMCODE_LINUX || TePLATFORM == TePLATFORMCODE_AIX || TePLATFORM == TePLATFORMCODE_APPLE

    TEAGN_TRUE_OR_THROW( ( pthread_cond_broadcast( &condition_var_ ) == 0 ),
      "Error emiting signal" );

  #else
    #error "Unsupported platform"
  #endif   
}

const TeThreadSignal& TeThreadSignal::operator=

(

const TeThreadSignal &

)

[inline, private]

operator= overload.

Returns:

A const reference to the current instance.

Definition at line 138 of file TeThreadSignal.h.

{ return *this; };

bool TeThreadSignal::waitSignal

(

unsigned int

waiting_time = 0

)

Block the current thread waiting for a signal.

Parameters:

waiting_time

The maximim waiting time in milliseconds ( 0 == INFINITE ).

Returns:

true if a signal was received, false if the waiting time has finished or an error occurred.

Definition at line 98 of file TeThreadSignal.cpp.

References pthread_cond_timedwait, pthread_cond_wait, pthread_mutex_lock, pthread_mutex_unlock, TEAGN_LOGWARN, and TEAGN_TRUE_OR_THROW.

Referenced by TePDIParallelSegmenter::groupDataThreadEntry(), main(), and TePDIParallelSegmenter::RunImplementation().

{
  bool return_value = true;
  
  #if TePLATFORM == TePLATFORMCODE_MSWINDOWS
  
    // Avoid race conditions.
    waiters_count_lock_.lock();

    // Increment count of waiters.
    waiters_count_++;

    // Store current generation in our activation record.
    int my_generation =  wait_generation_count_;

    waiters_count_lock_.unLock();

    for (;;) {
      // Wait until the event is signaled.
      if( waiting_time == 0 ) {
        if( WaitForSingleObject ( event_, INFINITE ) != WAIT_OBJECT_0 ) {
          return_value = false;
          break;
        }
      } else {
        if( WaitForSingleObject ( event_, waiting_time ) != WAIT_OBJECT_0 ) {
          return_value = false;
          break;
        }      
      }

      waiters_count_lock_.lock();
      // Exit the loop when the < event_> is signaled and
      // there are still waiting threads from this <wait_generation>
      // that haven't been released from this wait yet.
      int wait_done =  release_count_ > 0
                      &&  wait_generation_count_ != my_generation;
      waiters_count_lock_.unLock();

      if (wait_done)
        break;
    }

    waiters_count_lock_.lock();
    waiters_count_--;
    release_count_--;
    int last_waiter =  release_count_ == 0;
    waiters_count_lock_.unLock();

    if (last_waiter)
      // We're the last waiter to be notified, so reset the manual event.
      ResetEvent ( event_);

  #elif TePLATFORM == TePLATFORMCODE_LINUX || TePLATFORM == TePLATFORMCODE_AIX || TePLATFORM == TePLATFORMCODE_APPLE

    TEAGN_TRUE_OR_THROW( ( pthread_mutex_lock( &m_access_ ) == 0 ),
      "Unable to lock mutex" );
    
    if( waiting_time == 0 ) {
      if( pthread_cond_wait( &condition_var_, &m_access_ ) != 0 ) {
        return_value = false;
      }
    } else {
      struct timeval timevalstr;

      if( gettimeofday( &timevalstr, 0 ) == 0 ) {
        struct timespec timespecstr;

        /* seconds */
        timespecstr.tv_sec = timevalstr.tv_sec + ( waiting_time / 1000 );
        /* nano-seconds */
        timespecstr.tv_nsec = ( timevalstr.tv_usec * 1000 ) +
          ( ( waiting_time % 1000 ) * 1000000 );

        if( pthread_cond_timedwait( &condition_var_, &m_access_, 
          &timespecstr ) != 0 ) {
  
          return_value = false;
        }
      } else {
        TEAGN_LOGWARN( "Unable to get the current time" );
        return_value = false;
      }
    }

    TEAGN_TRUE_OR_THROW( ( pthread_mutex_unlock( &m_access_ ) == 0 ),
      "Unable to unlock mutex" );
  
  #else
    #error "Unsuported plataform"
  #endif   
  
  return return_value;
}

---

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

• TeThreadSignal.h
• TeThreadSignal.cpp

---