G3D::ThreadSet Class Reference

#include <ThreadSet.h>

Public Types
typedef GThread	Thread
typedef shared_ptr< Thread >	ThreadRef
typedef shared_ptr< ThreadSet >	Ref
typedef Array< ThreadRef > ::Iterator	Iterator
typedef Array< ThreadRef > ::ConstIterator	ConstIterator

Public Member Functions
int	size () const
int	numStarted () const
void	start (SpawnBehavior lastThreadBehavior=USE_NEW_THREAD) const
void	terminate () const
void	waitForCompletion () const
void	clear ()
int	removeCompleted ()
int	insert (const ThreadRef &t)
bool	remove (const ThreadRef &t)
bool	contains (const ThreadRef &t) const
Iterator	begin ()
Iterator	end ()
ConstIterator	begin () const
ConstIterator	end () const
Public Member Functions inherited from G3D::ReferenceCountedObject
virtual	~ReferenceCountedObject ()

Private Attributes
GMutex	m_lock
Array< ThreadRef >	m_thread

Detailed Description

Manages a set of threads. All methods are threadsafe except for the iterator begin/end.

Member Typedef Documentation

typedef Array<ThreadRef>::ConstIterator G3D::ThreadSet::ConstIterator

typedef Array<ThreadRef>::Iterator G3D::ThreadSet::Iterator

typedef shared_ptr<ThreadSet> G3D::ThreadSet::Ref

typedef GThread G3D::ThreadSet::Thread

Intended to allow future use with a template parameter.

typedef shared_ptr<Thread> G3D::ThreadSet::ThreadRef

Member Function Documentation

ThreadSet::Iterator G3D::ThreadSet::begin

(

)

It is an error to mutate the ThreadSet while iterating through it.

 {
 return m_thread.begin();
}

Here is the call graph for this function:

ThreadSet::ConstIterator G3D::ThreadSet::begin

(

)

const

 {
 return m_thread.begin();
}

Here is the call graph for this function:

void G3D::ThreadSet::clear

(

)

Remove all (not stopping them)

 {
 m_lock.lock();
 m_thread.clear();
 m_lock.unlock();
}

Here is the call graph for this function:

bool G3D::ThreadSet::contains

(

const ThreadRef &

t

)

const

 {
 ThreadSet* me = const_cast<ThreadSet*>(this);
 me->m_lock.lock();
 bool found = false;
 for (int i = 0; i < m_thread.size() && ! found; ++i) {
 found = (m_thread[i] == t);
 }
 me->m_lock.unlock();
 return found;
}

Here is the call graph for this function:

ThreadSet::Iterator G3D::ThreadSet::end

(

)

 {
 return m_thread.end();
}

Here is the call graph for this function:

ThreadSet::ConstIterator G3D::ThreadSet::end

(

)

const

 {
 return m_thread.end();
}

Here is the call graph for this function:

int G3D::ThreadSet::insert

(

const ThreadRef &

t

)

Inserts a new thread, if it is not already present, and returns the new number of threads.

 {
 m_lock.lock();
 bool found = false;
 for (int i = 0; i < m_thread.size() && ! found; ++i) {
 found = (m_thread[i] == t);
 }
 if (! found) {
 m_thread.append(t);
 }
 int s = m_thread.size();
 m_lock.unlock();
 return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int G3D::ThreadSet::numStarted

(

)

const

Number of threads that have been started

 {
 ThreadSet* me = const_cast<ThreadSet*>(this);
 me->m_lock.lock();
 int count = 0;
 for (int i = 0; i < m_thread.size(); ++i) {
 if (m_thread[i]->started()) {
 ++count;
 }
 }
 me->m_lock.unlock();
 return count;
}

Here is the call graph for this function:

bool G3D::ThreadSet::remove

(

const ThreadRef &

t

)

Removes a thread. Returns true if the thread was present and removed.

 {
 m_lock.lock();
 bool found = false;
 for (int i = 0; i < m_thread.size() && ! found; ++i) {
 found = (m_thread[i] == t);
 if (found) {
 m_thread.fastRemove(i);
 }
 }
 m_lock.unlock();
 return found;
}

Here is the call graph for this function:

int G3D::ThreadSet::removeCompleted

(

)

Removes completed threads and returns the new size.

 {
 m_lock.lock();
 for (int i = 0; i < m_thread.size(); ++i) {
 if (m_thread[i]->completed()) {
 m_thread.fastRemove(i);
 --i;
 }
 }
 
 int s = m_thread.size();
 m_lock.unlock();
 return s;
}

Here is the call graph for this function:

int G3D::ThreadSet::size

(

)

const

Total number of threads (some of which may be completed).

 {
 ThreadSet* me = const_cast<ThreadSet*>(this);
 me->m_lock.lock();
 int s = m_thread.size();
 me->m_lock.unlock();
 return s;
}

Here is the call graph for this function:

void G3D::ThreadSet::start

(

SpawnBehavior

lastThreadBehavior = USE_NEW_THREAD

)

const

Start all threads that are not currently started.

Parameters

lastThreadBehavior

If USE_CURRENT_THREAD, takes the last unstarted thread and executes it manually on the current thread. This helps to take full advantage of the machine when running a large number of jobs and avoids the overhead of a thread start for single-thread groups. Note that this forces start() to block until that thread is complete.

 {
 ThreadSet* me = const_cast<ThreadSet*>(this);

 Array<GThreadRef> unstarted;
 me->m_lock.lock();
 // Find the unstarted threads
 for (int i = 0; i < m_thread.size(); ++i) {
 if (! m_thread[i]->started()) {
 unstarted.append(m_thread[i]);
 }
 }

 int last = unstarted.size();
 if (lastBehavior == USE_CURRENT_THREAD) {
 // Save the last unstarted for the current thread
 --last;
 }

 // Start all threads
 for (int i = 0; i < last; ++i) {
 unstarted[i]->start(USE_NEW_THREAD);
 }

 me->m_lock.unlock();

 // Start the last one on my thread
 if ((unstarted.size() > 0) && (lastBehavior == USE_CURRENT_THREAD)) {
 unstarted.last()->start(USE_CURRENT_THREAD);
 debugAssert(unstarted.last()->completed());
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::ThreadSet::terminate

(

)

const

Terminate all threads that are currently started

 {
 ThreadSet* me = const_cast<ThreadSet*>(this);
 me->m_lock.lock();
 for (int i = 0; i < m_thread.size(); ++i) {
 if (m_thread[i]->started()) {
 m_thread[i]->terminate();
 }
 }
 me->m_lock.unlock();
}

Here is the call graph for this function:

void G3D::ThreadSet::waitForCompletion

(

)

const

Waits until all started threads have completed.

 {
 ThreadSet* me = const_cast<ThreadSet*>(this);

 me->m_lock.lock();
 for (int i = 0; i < m_thread.size(); ++i) {
 if (m_thread[i]->started()) {
 m_thread[i]->waitForCompletion();
 }
 }
 me->m_lock.unlock();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

GMutex G3D::ThreadSet::m_lock

private

Protects m_thread

Array<ThreadRef> G3D::ThreadSet::m_thread

private

Threads in the set

---

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

• dep/g3dlite/include/G3D/ThreadSet.h
• dep/g3dlite/source/ThreadSet.cpp