TaskSequencer< C > Class Template Reference

#include <kaldi-thread.h>

Collaboration diagram for TaskSequencer< C >:

Classes
struct	RunTaskArgsList

Public Member Functions
	TaskSequencer (const TaskSequencerConfig &config)
void	Run (C *c)
	This function takes ownership of the pointer "c", and will delete it in the same sequence as Run was called on the jobs. More...
void	Wait ()
	~TaskSequencer ()
	The destructor waits for the last thread to exit. More...

Static Private Member Functions
static void	RunTask (RunTaskArgsList *args)

Private Attributes
int32	num_threads_
Semaphore	threads_avail_
Semaphore	tot_threads_avail_
RunTaskArgsList *	thread_list_

Detailed Description

template<class C>
class kaldi::TaskSequencer< C >

Definition at line 175 of file kaldi-thread.h.

Constructor & Destructor Documentation

TaskSequencer()

TaskSequencer ( const TaskSequencerConfig &  config )

inline

Definition at line 177 of file kaldi-thread.h.

References KALDI_ASSERT, TaskSequencerConfig::num_threads, and TaskSequencerConfig::num_threads_total.

                                                  :
      num_threads_(config.num_threads),
      threads_avail_(config.num_threads),
      tot_threads_avail_(config.num_threads_total > 0 ? config.num_threads_total :
                         config.num_threads + 20),
      thread_list_(NULL) {
    KALDI_ASSERT((config.num_threads_total <= 0 ||
                  config.num_threads_total >= config.num_threads) &&
                 "num-threads-total, if specified, must be >= num-threads");
  }

~TaskSequencer()

~TaskSequencer ( )

inline

The destructor waits for the last thread to exit.

Definition at line 221 of file kaldi-thread.h.

                   {
    Wait();
  }

Member Function Documentation

Run()

void Run ( C *  c )

inline

This function takes ownership of the pointer "c", and will delete it in the same sequence as Run was called on the jobs.

Definition at line 190 of file kaldi-thread.h.

References MultiThreadable::num_threads_.

Referenced by IvectorExtractor::ComputeDerivedVars(), kaldi::nnet2::LimitRankParallel(), main(), kaldi::ProcessUtterance(), kaldi::TestTaskSequencer(), IvectorExtractorStats::UpdateProjections(), and IvectorExtractorStats::UpdateWeights().

                 {
    // run in main thread
    if (num_threads_ == 0) {
      (*c)();
      delete c;
      return;
    }

    threads_avail_.Wait(); // wait till we have a thread for computation free.
    tot_threads_avail_.Wait(); // this ensures we don't have too many threads
    // waiting on I/O, and consume too much memory.

    // put the new RunTaskArgsList object at head of the singly
    // linked list thread_list_.
    thread_list_ = new RunTaskArgsList(this, c, thread_list_);
    thread_list_->thread = std::thread(TaskSequencer<C>::RunTask,
                                       thread_list_);
  }

RunTask()

static void RunTask ( RunTaskArgsList *  args )

inlinestaticprivate

Definition at line 234 of file kaldi-thread.h.

References TaskSequencer< C >::RunTaskArgsList::c, KALDI_ASSERT, TaskSequencer< C >::RunTaskArgsList::me, Semaphore::Signal(), TaskSequencer< C >::RunTaskArgsList::tail, TaskSequencer< C >::RunTaskArgsList::thread, TaskSequencer< C >::threads_avail_, and TaskSequencer< C >::tot_threads_avail_.

                                             {
    // (1) run the job.
    (*(args->c))(); // call operator () on args->c, which does the computation.
    args->me->threads_avail_.Signal(); // Signal that the compute-intensive
    // part of the thread is done (we want to run no more than
    // config_.num_threads of these.)

    // (2) we want to destroy the object "c" now, by deleting it.  But for
    //     correct sequencing (this is the whole point of this class, it
    //     is intended to ensure the output of the program is in correct order),
    //     we first wait till the previous thread, whose details will be in "tail",
    //     is finished.
    if (args->tail != NULL) {
      args->tail->thread.join();
    }

    delete args->c; // delete the object "c".  This may cause some output,
    // e.g. to a stream.  We don't need to worry about concurrent access to
    // the output stream, because each thread waits for the previous thread
    // to be done, before doing this.  So there is no risk of concurrent
    // access.
    args->c = NULL;

    if (args->tail != NULL) {
      KALDI_ASSERT(args->tail->tail == NULL); // Because we already
      // did join on args->tail->thread, which means that
      // thread was done, and before it exited, it would have
      // deleted and set to NULL its tail (which is the next line of code).
      delete args->tail;
      args->tail = NULL;
    }
    // At this point we are exiting from the thread.  Signal the
    // "tot_threads_avail_" semaphore which is used to limit the total number of threads that are alive, including
    // not onlhy those that are in active computation in c->operator (), but those
    // that are waiting on I/O or other threads.
    args->me->tot_threads_avail_.Signal();
  }

Wait()

void Wait ( )

inline

Definition at line 209 of file kaldi-thread.h.

References KALDI_ASSERT.

Referenced by main().

              { // You call this at the end if it's more convenient
    // than waiting for the destructor.  It waits for all tasks to finish.
    if (thread_list_ != NULL) {
      thread_list_->thread.join();
      KALDI_ASSERT(thread_list_->tail == NULL); // thread would not
      // have exited without setting tail to NULL.
      delete thread_list_;
      thread_list_ = NULL;
    }
  }

Member Data Documentation

num_threads_

int32 num_threads_

private

Definition at line 272 of file kaldi-thread.h.

thread_list_

RunTaskArgsList* thread_list_

private

Definition at line 279 of file kaldi-thread.h.

threads_avail_

Semaphore threads_avail_

private

Definition at line 274 of file kaldi-thread.h.

Referenced by TaskSequencer< C >::RunTask().

tot_threads_avail_

Semaphore tot_threads_avail_

private

Definition at line 277 of file kaldi-thread.h.

Referenced by TaskSequencer< C >::RunTask().

---

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

• util/kaldi-thread.h