[feat] RecyclingVector for optional memory saving

src/feat/feature-window.h

@@ -44,6 +44,7 @@ struct FrameExtractionOptions {
  BaseFloat blackman_coeff;
  bool snip_edges;
  bool allow_downsample;
+ int max_feature_vectors;
  // May be "hamming", "rectangular", "povey", "hanning", "blackman"
  // "povey" is a window I made to be similar to Hamming but to go to zero at the
  // edges, it's pow((0.5 - 0.5*cos(n/N*2*pi)), 0.85)
@@ -59,7 +60,8 @@ struct FrameExtractionOptions {
  round_to_power_of_two(true),
  blackman_coeff(0.42),
  snip_edges(true),
- allow_downsample(false) { }
+ allow_downsample(false),
+ max_feature_vectors(-1) { }
 
  void Register(OptionsItf *opts) {
  opts->Register("sample-frequency", &samp_freq,
@@ -90,6 +92,10 @@ struct FrameExtractionOptions {
  opts->Register("allow-downsample", &allow_downsample,
  "If true, allow the input waveform to have a higher frequency than "
  "the specified --sample-frequency (and we'll downsample).");
+ opts->Register("max-feature-vectors", &max_feature_vectors,
+ "Memory optimization. If larger than 0, periodically remove feature "
+ "vectors so that only this number of the latest feature vectors is "
+ "retained.");
  }
  int32 WindowShift() const {
  return static_cast<int32>(samp_freq * 0.001 * frame_shift_ms);

src/feat/online-feature.cc

@@ -24,18 +24,50 @@
 
 namespace kaldi {
 
+RecyclingVector::RecyclingVector(int items_to_hold) : items_to_hold_(items_to_hold),
+ first_available_index_(0) { }
+
+RecyclingVector::~RecyclingVector() {
+ DeletePointers(&items_);
+}
+
+Vector<BaseFloat> *RecyclingVector::Retrieve(int index) const {
+ if (index < first_available_index_) {
+ KALDI_ERR << "Attempted to retrieve feature vector that was "
+ "already removed by the RecyclingVector";
+ }
+ // 'at' does size checking.
+ return items_.at(index - first_available_index_);
+}
+
+void RecyclingVector::Store(Vector<BaseFloat> *item) {
+ // Internally, we keep at most 2x requested items_to_hold_ and clean up
+ // when this number is reached
+ const int size_before_erase = items_.size();
+ if (size_before_erase == 2 * items_to_hold_) {
+ items_.erase(items_.begin(), items_.begin() + items_to_hold_);
+ first_available_index_ += (size_before_erase - items_.size());
+ }
+ items_.push_back(item);
+}
+
+int RecyclingVector::Size() const {
+ return first_available_index_ + items_.size();
+}
+
+
 template<class C>
 void OnlineGenericBaseFeature<C>::GetFrame(int32 frame,
  VectorBase<BaseFloat> *feat) {
- // 'at' does size checking.
- feat->CopyFromVec(*(features_.at(frame)));
+ feat->CopyFromVec(*(features_.Retrieve(frame)));
 };
 
 template<class C>
 OnlineGenericBaseFeature<C>::OnlineGenericBaseFeature(
  const typename C::Options &opts):
  computer_(opts), window_function_(computer_.GetFrameOptions()),
- input_finished_(false), waveform_offset_(0) { }
+ input_finished_(false), waveform_offset_(0),
+ features_(opts.frame_opts.max_feature_vectors) { }
 
 template<class C>
 void OnlineGenericBaseFeature<C>::AcceptWaveform(BaseFloat sampling_rate,
@@ -63,11 +95,10 @@ template<class C>
 void OnlineGenericBaseFeature<C>::ComputeFeatures() {
  const FrameExtractionOptions &frame_opts = computer_.GetFrameOptions();
  int64 num_samples_total = waveform_offset_ + waveform_remainder_.Dim();
- int32 num_frames_old = features_.size(),
+ int32 num_frames_old = features_.Size(),
  num_frames_new = NumFrames(num_samples_total, frame_opts,
  input_finished_);
  KALDI_ASSERT(num_frames_new >= num_frames_old);
- features_.resize(num_frames_new, NULL);
 
  Vector<BaseFloat> window;
  bool need_raw_log_energy = computer_.NeedRawLogEnergy();
@@ -81,7 +112,7 @@ void OnlineGenericBaseFeature<C>::ComputeFeatures() {
  // note: this online feature-extraction code does not support VTLN.
  BaseFloat vtln_warp = 1.0;
  computer_.Compute(raw_log_energy, vtln_warp, &window, this_feature);
- features_[frame] = this_feature;
+ features_.Store(this_feature);
  }
  // OK, we will now discard any portion of the signal that will not be
  // necessary to compute frames in the future.

src/feat/online-feature.h

@@ -41,6 +41,31 @@ namespace kaldi {
 /// @{
 
 
+/// This class serves as a storage for feature vectors with an option to limit
+/// the memory usage by removing old elements. The deleted frames indices are
+/// "remembered" so that regardless of the MAX_ITEMS setting, the user always
+/// provides the indices as if no deletion was being performed.
+/// This is useful when processing very long recordings which would otherwise
+/// cause the memory to eventually blow up when the features are not being removed.
+class RecyclingVector {
+public:
+ RecyclingVector(int items_to_hold = -1);
+
+ Vector<BaseFloat> *Retrieve(int index) const;
+
+ void Store(Vector<BaseFloat> *item);
+
+ int Size() const;
+
+ ~RecyclingVector();
+
+private:
+ std::vector<Vector<BaseFloat>*> items_;
+ int items_to_hold_;
+ int first_available_index_;
+};
+
+
 /// This is a templated class for online feature extraction;
 /// it's templated on a class like MfccComputer or PlpComputer
 /// that does the basic feature extraction.
@@ -61,7 +86,7 @@ class OnlineGenericBaseFeature: public OnlineBaseFeature {
  return computer_.GetFrameOptions().frame_shift_ms / 1000.0f;
  }
 
- virtual int32 NumFramesReady() const { return features_.size(); }
+ virtual int32 NumFramesReady() const { return features_.Size(); }
 
  virtual void GetFrame(int32 frame, VectorBase<BaseFloat> *feat);
 
@@ -88,10 +113,6 @@ class OnlineGenericBaseFeature: public OnlineBaseFeature {
  ComputeFeatures();
  }
 
- ~OnlineGenericBaseFeature() {
- DeletePointers(&features_);
- }
-
  private:
  // This function computes any additional feature frames that it is possible to
  // compute from 'waveform_remainder_', which at this point may contain more
@@ -107,7 +128,7 @@ class OnlineGenericBaseFeature: public OnlineBaseFeature {
 
  // features_ is the Mfcc or Plp or Fbank features that we have already computed.
 
- std::vector<Vector<BaseFloat>*> features_;
+ RecyclingVector features_;
 
  // True if the user has called "InputFinished()"
  bool input_finished_;