OnlineTimer Class Reference

class OnlineTimer is used to test real-time decoding algorithms and evaluate how long the decoding of a particular utterance would take. More...

#include <online-timing.h>

Collaboration diagram for OnlineTimer:

Public Member Functions
	OnlineTimer (const std::string &utterance_id)
void	SleepUntil (double cur_utterance_length)
	The call to SleepUntil(t) will sleep until cur_utterance_length seconds after this object was initialized, or return immediately if we've already passed that time. More...
void	WaitUntil (double cur_utterance_length)
	The call to WaitUntil(t) simulates the effect of sleeping until cur_utterance_length seconds after this object was initialized; but instead of actually sleeping, it increases a counter. More...
void	OutputStats (OnlineTimingStats *stats)
	This call, which should be made after decoding is done, writes the stats to the object that accumulates them. More...
double	Elapsed ()
	Returns the simulated time elapsed in seconds since the timer was started; this equals waited_ plus the real time elapsed. More...

Private Attributes
std::string	utterance_id_
Timer	timer_
double	waited_
double	utterance_length_

Detailed Description

class OnlineTimer is used to test real-time decoding algorithms and evaluate how long the decoding of a particular utterance would take.

The 'obvious' way to evaluate this would be to measure the wall-clock time, and if we're processing the data in chunks, to sleep() until a given chunk would become available in a real-time application– e.g. say we need to process a chunk that ends half a second into the utterance, we would sleep until half a second had elapsed since the start of the utterance. In this code we have the option to not actually sleep: we can simulate the effect of sleeping by just incrementing a variable that says how long we would have slept; and we add this to wall-clock times obtained from Timer::Elapsed(). The usage of this class will be something like as follows:

OnlineTimingStats stats;
while (.. process different utterances..) {
  OnlineTimer this_utt_timer(utterance_id);
  while (...process chunks of this utterance..) {
     double num_secs_elapsed = 0.01 * num_frames;
     this_utt_timer.WaitUntil(num_secs_elapsed);
  }
  this_utt_timer.OutputStats(&stats);

This assumes that the value provided to the last WaitUntil() call was the length of the utterance.

Definition at line 88 of file online-timing.h.

Constructor & Destructor Documentation

OnlineTimer()

OnlineTimer

(

const std::string &

utterance_id

)

Definition at line 62 of file online-timing.cc.

                                                     :
    utterance_id_(utterance_id), waited_(0.0), utterance_length_(0.0) { }

Member Function Documentation

Elapsed()

double Elapsed

(

)

Returns the simulated time elapsed in seconds since the timer was started; this equals waited_ plus the real time elapsed.

Definition at line 92 of file online-timing.cc.

References Timer::Elapsed(), OnlineTimer::timer_, and OnlineTimer::waited_.

                            {
  return timer_.Elapsed() + waited_;
}

OutputStats()

void OutputStats

(

OnlineTimingStats *

stats

)

This call, which should be made after decoding is done, writes the stats to the object that accumulates them.

Definition at line 96 of file online-timing.cc.

References Timer::Elapsed(), KALDI_VLOG, KALDI_WARN, OnlineTimingStats::max_delay_, OnlineTimingStats::max_delay_utt_, OnlineTimingStats::num_utts_, OnlineTimer::timer_, OnlineTimingStats::total_audio_, OnlineTimingStats::total_time_taken_, OnlineTimingStats::total_time_waited_, OnlineTimer::utterance_id_, OnlineTimer::utterance_length_, and OnlineTimer::waited_.

Referenced by main().

                                                      {
  double processing_time = timer_.Elapsed() + waited_,
      wait_time = processing_time - utterance_length_;
  if (wait_time < 0.0) {
    // My first though was to make this a KALDI_ERR, but perhaps
    // clocks can go backwards under some weird circumstance, so
    // let's just make it a warning.
    KALDI_WARN << "Negative wait time " << wait_time
               << " does not make sense.";
  }
  KALDI_VLOG(2) << "Latency " << wait_time << " seconds out of "
                << utterance_length_ << ", for utterance "
                << utterance_id_;
  
  stats->num_utts_++;
  stats->total_audio_ += utterance_length_;
  stats->total_time_taken_ += processing_time;
  stats->total_time_waited_ += waited_;
  if (wait_time > stats->max_delay_) {
    stats->max_delay_ = wait_time;
    stats->max_delay_utt_ = utterance_id_;
  }
}

SleepUntil()

void SleepUntil

(

double

cur_utterance_length

)

The call to SleepUntil(t) will sleep until cur_utterance_length seconds after this object was initialized, or return immediately if we've already passed that time.

Definition at line 81 of file online-timing.cc.

References Timer::Elapsed(), KALDI_ASSERT, kaldi::Sleep(), OnlineTimer::timer_, OnlineTimer::utterance_length_, and OnlineTimer::waited_.

Referenced by main().

                                                        {
  KALDI_ASSERT(waited_ == 0 && "Do not mix SleepUntil with WaitUntil.");
  double elapsed = timer_.Elapsed();

  double to_wait = cur_utterance_length - elapsed;
  if (to_wait > 0.0) {
    Sleep(to_wait);
  }
  utterance_length_ = cur_utterance_length;
}

WaitUntil()

void WaitUntil

(

double

cur_utterance_length

)

The call to WaitUntil(t) simulates the effect of sleeping until cur_utterance_length seconds after this object was initialized; but instead of actually sleeping, it increases a counter.

Definition at line 65 of file online-timing.cc.

References Timer::Elapsed(), OnlineTimer::timer_, OnlineTimer::utterance_length_, and OnlineTimer::waited_.

Referenced by main().

                                                       {
  double elapsed = timer_.Elapsed();
  // it's been cur_utterance_length seconds since we would have
  // started processing this utterance, in a real-time decoding
  // scenario.  We've been actually processing it for "elapsed"
  // seconds, plus we would have been waiting on some kind of
  // semaphore for waited_ seconds.  If we have to wait further
  // at this point, increase "waited_".
  // (I have to think of a better way of explaining this).
  double to_wait = cur_utterance_length - (elapsed + waited_);
  if (to_wait > 0.0)
    waited_ += to_wait;

  utterance_length_ = cur_utterance_length;
}

Member Data Documentation

timer_

Timer timer_

private

Definition at line 112 of file online-timing.h.

Referenced by OnlineTimer::Elapsed(), OnlineTimer::OutputStats(), OnlineTimer::SleepUntil(), and OnlineTimer::WaitUntil().

utterance_id_

std::string utterance_id_

private

Definition at line 111 of file online-timing.h.

Referenced by OnlineTimer::OutputStats().

utterance_length_

double utterance_length_

private

Definition at line 115 of file online-timing.h.

Referenced by OnlineTimer::OutputStats(), OnlineTimer::SleepUntil(), and OnlineTimer::WaitUntil().

waited_

double waited_

private

Definition at line 114 of file online-timing.h.

Referenced by OnlineTimer::Elapsed(), OnlineTimer::OutputStats(), OnlineTimer::SleepUntil(), and OnlineTimer::WaitUntil().

---

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

• online2/online-timing.h
• online2/online-timing.cc