tpie::pipelining::parallel_bits::state_base Class Reference

Common state in parallel pipelining library. More...

#include <tpie/pipelining/parallel/base.h>

Inherited by tpie::pipelining::parallel_bits::state< T1, T2 >.

Public Types
typedef std::mutex	mutex_t
typedef std::condition_variable	cond_t
typedef std::unique_lock < std::mutex >	lock_t

Public Member Functions
void	set_input_ptr (size_t idx, node *v)
	Must not be used concurrently. More...
void	set_output_ptr (size_t idx, after_base *v)
	Must not be used concurrently. More...
node &	input (size_t idx)
	Get the specified before instance. More...
after_base &	output (size_t idx)
	Get the specified after instance. More...
worker_state	get_state (size_t idx)
	Shared state, must have mutex to use. More...
void	transition_state (size_t idx, worker_state from, worker_state to)
	Shared state, must have mutex to use. More...

Public Attributes
const options	opts
mutex_t	mutex
	Single mutex. More...
cond_t	producerCond
	Condition variable. More...
cond_t *	workerCond
	Condition variable, one per worker. More...
size_t	runningWorkers
	Shared state, must have mutex to write. More...

Protected Member Functions
	state_base (const options opts)

Protected Attributes
std::vector< node * >	m_inputs
std::vector< after_base * >	m_outputs
std::vector< worker_state >	m_states

Detailed Description

Common state in parallel pipelining library.

This class is instantiated once and kept in a std::shared_ptr, and it is not copy constructible.

Unless noted otherwise, a thread must own the state mutex to access other parts of this instance.

Definition at line 211 of file base.h.

Member Function Documentation

worker_state tpie::pipelining::parallel_bits::state_base::get_state ( size_t  idx )

inline

Shared state, must have mutex to use.

Definition at line 276 of file base.h.

                                       {
        return m_states[idx];
    }

node& tpie::pipelining::parallel_bits::state_base::input ( size_t  idx )

inline

Get the specified before instance.

Enables easy construction of the pipeline graph at runtime.

Shared state, must have mutex to use.

Definition at line 261 of file base.h.

{ return *m_inputs[idx]; }

after_base& tpie::pipelining::parallel_bits::state_base::output ( size_t  idx )

inline

Get the specified after instance.

Serves two purposes: First, it enables easy construction of the pipeline graph at runtime. Second, it is used by before to send batch signals to after.

Shared state, must have mutex to use.

Definition at line 273 of file base.h.

{ return *m_outputs[idx]; }

void tpie::pipelining::parallel_bits::state_base::set_input_ptr ( size_t  idx, node *  v  )

inline

Must not be used concurrently.

Definition at line 245 of file base.h.

                                             {
        m_inputs[idx] = v;
    }

void tpie::pipelining::parallel_bits::state_base::set_output_ptr ( size_t  idx, after_base *  v  )

inline

Must not be used concurrently.

Definition at line 250 of file base.h.

                                                    {
        m_outputs[idx] = v;
    }

void tpie::pipelining::parallel_bits::state_base::transition_state ( size_t  idx, worker_state  from, worker_state  to  )

inline

Shared state, must have mutex to use.

Definition at line 281 of file base.h.

References tpie::log_error().

                                                                          {
        if (m_states[idx] != from) {
            std::stringstream ss;
            ss << idx << " Invalid state transition " << from << " -> " << to << "; current state is " << m_states[idx];
            log_error() << ss.str() << std::endl;
            throw exception(ss.str());
        }
        m_states[idx] = to;
    }

Member Data Documentation

mutex_t tpie::pipelining::parallel_bits::state_base::mutex

Single mutex.

Definition at line 220 of file base.h.

cond_t tpie::pipelining::parallel_bits::state_base::producerCond

Condition variable.

Who waits: The producer, with the single mutex (waits until at least one worker has state = IDLE or state = OUTPUTTING).

Who signals: The par_after, when a worker is OUTPUTTING.

Definition at line 228 of file base.h.

size_t tpie::pipelining::parallel_bits::state_base::runningWorkers

Shared state, must have mutex to write.

Definition at line 242 of file base.h.

cond_t* tpie::pipelining::parallel_bits::state_base::workerCond

Condition variable, one per worker.

Who waits: The worker's par_before when waiting for input (wait for state = PROCESSING), the worker's par_after when waiting for output to be read (wait for state = IDLE). Waits with the single mutex.

Who signals: par_producer, when input has been written (sets state to PROCESSING). par_consumer, when output has been read (sets state to IDLE).

Definition at line 239 of file base.h.

---

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

• pipelining/parallel/base.h