SequentialTableReaderBackgroundImpl< Holder > Class Template Reference

#include <kaldi-table-inl.h>

Inheritance diagram for SequentialTableReaderBackgroundImpl< Holder >:

Collaboration diagram for SequentialTableReaderBackgroundImpl< Holder >:

Public Types
typedef Holder::T	T
Public Types inherited from SequentialTableReaderImplBase< Holder >
typedef Holder::T	T

Public Member Functions
	SequentialTableReaderBackgroundImpl (SequentialTableReaderImplBase< Holder > *base_reader)
virtual bool	Open (const std::string &rxfilename)
virtual bool	IsOpen () const
void	RunInBackground ()
virtual bool	Done () const
virtual std::string	Key ()
virtual T &	Value ()
void	SwapHolder (Holder *other_holder)
virtual void	FreeCurrent ()
virtual void	Next ()
virtual bool	Close ()
	~SequentialTableReaderBackgroundImpl ()
Public Member Functions inherited from SequentialTableReaderImplBase< Holder >
	SequentialTableReaderImplBase ()
virtual	~SequentialTableReaderImplBase ()

Static Public Member Functions
static void	run (SequentialTableReaderBackgroundImpl< Holder > *object)

Private Attributes
std::string	key_
Holder	holder_
Semaphore	consumer_sem_
Semaphore	producer_sem_
std::thread	thread_
SequentialTableReaderImplBase< Holder > *	base_reader_

Detailed Description

template<class Holder>
class kaldi::SequentialTableReaderBackgroundImpl< Holder >

Definition at line 702 of file kaldi-table-inl.h.

Member Typedef Documentation

T

typedef Holder::T T

Definition at line 705 of file kaldi-table-inl.h.

Constructor & Destructor Documentation

SequentialTableReaderBackgroundImpl()

SequentialTableReaderBackgroundImpl ( SequentialTableReaderImplBase< Holder > *  base_reader )

inline

Definition at line 707 of file kaldi-table-inl.h.

                                                         :
      base_reader_(base_reader) {}

~SequentialTableReaderBackgroundImpl()

~SequentialTableReaderBackgroundImpl ( )

inline

Definition at line 835 of file kaldi-table-inl.h.

References SequentialTableReaderImplBase< Holder >::Close(), and KALDI_ERR.

                                         {
    if (base_reader_) {
      if (!Close()) {
        KALDI_ERR << "Error detected closing background reader "
                  << "(relates to ',bg' modifier)";
      }
    }
  }

Member Function Documentation

Close()

virtual bool Close ( )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

Definition at line 816 of file kaldi-table-inl.h.

References KALDI_ASSERT.

                       {
    KALDI_ASSERT(base_reader_ != NULL && thread_.joinable());
    // wait until the producer thread is idle.
    consumer_sem_.Wait();
    bool ans = true;
    try {
      ans = base_reader_->Close();
    } catch (...) {
      ans = false;
    }
    delete base_reader_;
    // setting base_reader_ to NULL will cause the loop in the producer thread
    // to exit.
    base_reader_ = NULL;
    producer_sem_.Signal();

    thread_.join();
    return ans;
  }

Done()

virtual bool Done ( ) const

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

Definition at line 771 of file kaldi-table-inl.h.

                            {
    return key_.empty();
  }

FreeCurrent()

virtual void FreeCurrent ( )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

Definition at line 787 of file kaldi-table-inl.h.

References KALDI_ERR.

                             {
    if (key_.empty())
      KALDI_ERR << "Calling FreeCurrent() at the wrong time.";
    // note: ideally a call to Value() should crash if you have just called
    // FreeCurrent().  For typical holders such as KaldiObjectHolder this will
    // happen inside the holder_.Value() call.  This won't be the case for all
    // holders, but it's not a great loss (just a missed opportunity to spot a
    // code error).
    holder_.Clear();
  }

IsOpen()

virtual bool IsOpen ( ) const

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

Definition at line 727 of file kaldi-table-inl.h.

                              {
    // Close() sets base_reader_ to NULL, and we never initialize this object
    // with a non-open base_reader_, so no need to check if it's open.
    return base_reader_ != NULL;
  }

Key()

virtual std::string Key ( )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

Definition at line 774 of file kaldi-table-inl.h.

References KALDI_ERR.

                          {
    if (key_.empty())
      KALDI_ERR << "Calling Key() at the wrong time.";
    return key_;
  }

Next()

virtual void Next ( )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

Definition at line 797 of file kaldi-table-inl.h.

References KALDI_ERR.

                      {
    consumer_sem_.Wait();
    if (base_reader_ == NULL || !base_reader_->IsOpen())
      KALDI_ERR << "Error detected (likely code error) in background "
                << "reader (',bg' option)";
    if (base_reader_->Done()) {
      // there is nothing else to read.
      key_ = "";
    } else {
      key_ = base_reader_->Key();
      base_reader_->SwapHolder(&holder_);
    }
    // this Signal() tells the producer thread, in the background,
    // that it's now safe to read the next value.
    producer_sem_.Signal();
  }

Open()

virtual bool Open ( const std::string &  rxfilename )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

Definition at line 714 of file kaldi-table-inl.h.

References KALDI_ASSERT, and SequentialTableReaderImplBase< Holder >::Next().

                                                 {
    KALDI_ASSERT(base_reader_ != NULL &&
                 base_reader_->IsOpen());  // or code error.
    {
      thread_ = std::thread(SequentialTableReaderBackgroundImpl<Holder>::run,
                            this);
    }

    if (!base_reader_->Done())
      Next();
    return true;
  }

run()

static void run ( SequentialTableReaderBackgroundImpl< Holder > *  object )

inlinestatic

Definition at line 768 of file kaldi-table-inl.h.

                                                                       {
    object->RunInBackground();
  }

RunInBackground()

void RunInBackground ( )

inline

Definition at line 733 of file kaldi-table-inl.h.

                         {
    try {
      // This function is called in the background thread.  The whole point of
      // the background thread is that we don't want to do the actual reading
      // (inside Next()) in the foreground.
      while (base_reader_ != NULL && !base_reader_->Done()) {
        consumer_sem_.Signal();
        // Here is where the consumer process (parent thread) gets to do its
        // stuff.  Principally it calls SwapHolder()-- a shallow swap that is
        // cheap.
        producer_sem_.Wait();
        // we check that base_reader_ is not NULL in case Close() was
        // called in the main thread.
        if (base_reader_ != NULL)
          base_reader_->Next();   //  here is where the work happens.
      }
      // this signal will be waited on in the Next() function of the foreground
      // thread if it is still running, or Close() otherwise.
      consumer_sem_.Signal();
      // this signal may be waited on in Close().
      consumer_sem_.Signal();
    } catch (...) {
      // There is nothing we called above that could potentially throw due to
      // user data.  So we treat reaching this point as a code-error condition.
      // Closing base_reader_ will trigger an exception in Next() in the main
      // thread when it checks that base_reader_->IsOpen().
      if (base_reader_->IsOpen()) {
        base_reader_->Close();
        delete base_reader_;
        base_reader_ = NULL;
      }
      consumer_sem_.Signal();
      return;
    }
  }

SwapHolder()

void SwapHolder ( Holder *  other_holder )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

Definition at line 784 of file kaldi-table-inl.h.

References KALDI_ERR.

                                        {
    KALDI_ERR << "SwapHolder() should not be called on this class.";
  }

Value()

virtual T& Value ( )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

Definition at line 779 of file kaldi-table-inl.h.

References KALDI_ERR.

                     {
    if (key_.empty())
      KALDI_ERR << "Calling Value() at the wrong time.";
    return holder_.Value();
  }

Member Data Documentation

base_reader_

SequentialTableReaderImplBase<Holder>* base_reader_

private

Definition at line 852 of file kaldi-table-inl.h.

consumer_sem_

Semaphore consumer_sem_

private

Definition at line 849 of file kaldi-table-inl.h.

holder_

Holder holder_

private

Definition at line 845 of file kaldi-table-inl.h.

key_

std::string key_

private

Definition at line 844 of file kaldi-table-inl.h.

producer_sem_

Semaphore producer_sem_

private

Definition at line 850 of file kaldi-table-inl.h.

thread_

std::thread thread_

private

Definition at line 851 of file kaldi-table-inl.h.

---

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

• util/kaldi-table-inl.h