mosesdecoder/moses/TranslationModel/CompactPT/TargetPhraseCollectionCache.h

// $Id$
// vim:tabstop=2
/***********************************************************************
Moses - factored phrase-based language decoder
Copyright (C) 2006 University of Edinburgh

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
***********************************************************************/

#ifndef moses_TargetPhraseCollectionCache_h
#define moses_TargetPhraseCollectionCache_h

#include <map>
#include <set>
#include <vector>

#ifdef WITH_THREADS
#ifdef BOOST_HAS_PTHREADS
#include <boost/thread/mutex.hpp>
#endif
#endif

#include <boost/shared_ptr.hpp>

#include "moses/Phrase.h"
#include "moses/TargetPhraseCollection.h"

namespace Moses
{

// Avoid using new due to locking
typedef std::vector<TargetPhrase> TargetPhraseVector;
typedef boost::shared_ptr<TargetPhraseVector> TargetPhraseVectorPtr;

class TargetPhraseCollectionCache
{
private:
  size_t m_max;
  float m_tolerance;

  struct LastUsed {
    clock_t m_clock;
    TargetPhraseVectorPtr m_tpv;
    size_t m_bitsLeft;

    LastUsed() : m_clock(0), m_bitsLeft(0) {}

    LastUsed(clock_t clock, TargetPhraseVectorPtr tpv, size_t bitsLeft = 0)
      : m_clock(clock), m_tpv(tpv), m_bitsLeft(bitsLeft) {}
  };

  typedef std::map<Phrase, LastUsed> CacheMap;

  CacheMap m_phraseCache;

#ifdef WITH_THREADS
  boost::mutex m_mutex;
#endif

public:

  typedef CacheMap::iterator iterator;
  typedef CacheMap::const_iterator const_iterator;

  TargetPhraseCollectionCache(size_t max = 5000, float tolerance = 0.2)
    : m_max(max), m_tolerance(tolerance) {
  }

  iterator Begin() {
    return m_phraseCache.begin();
  }

  const_iterator Begin() const {
    return m_phraseCache.begin();
  }

  iterator End() {
    return m_phraseCache.end();
  }

  const_iterator End() const {
    return m_phraseCache.end();
  }

  void Cache(const Phrase &sourcePhrase, TargetPhraseVectorPtr tpv,
             size_t bitsLeft = 0, size_t maxRank = 0) {
#ifdef WITH_THREADS
    boost::mutex::scoped_lock lock(m_mutex);
#endif

    iterator it = m_phraseCache.find(sourcePhrase);
    if(it != m_phraseCache.end())
      it->second.m_clock = clock();
    else {
      if(maxRank && tpv->size() > maxRank) {
        TargetPhraseVectorPtr tpv_temp(new TargetPhraseVector());
        tpv_temp->resize(maxRank);
        std::copy(tpv->begin(), tpv->begin() + maxRank, tpv_temp->begin());
        m_phraseCache[sourcePhrase] = LastUsed(clock(), tpv_temp, bitsLeft);
      } else
        m_phraseCache[sourcePhrase] = LastUsed(clock(), tpv, bitsLeft);
    }
  }

  std::pair<TargetPhraseVectorPtr, size_t> Retrieve(const Phrase &sourcePhrase) {
#ifdef WITH_THREADS
    boost::mutex::scoped_lock lock(m_mutex);
#endif

    iterator it = m_phraseCache.find(sourcePhrase);
    if(it != m_phraseCache.end()) {
      LastUsed &lu = it->second;
      lu.m_clock = clock();
      return std::make_pair(lu.m_tpv, lu.m_bitsLeft);
    } else
      return std::make_pair(TargetPhraseVectorPtr(), 0);
  }

  void Prune() {
#ifdef WITH_THREADS
    boost::mutex::scoped_lock lock(m_mutex);
#endif

    if(m_phraseCache.size() > m_max * (1 + m_tolerance)) {
      typedef std::set<std::pair<clock_t, Phrase> > Cands;
      Cands cands;
      for(CacheMap::iterator it = m_phraseCache.begin();
          it != m_phraseCache.end(); it++) {
        LastUsed &lu = it->second;
        cands.insert(std::make_pair(lu.m_clock, it->first));
      }

      for(Cands::iterator it = cands.begin(); it != cands.end(); it++) {
        const Phrase& p = it->second;
        m_phraseCache.erase(p);

        if(m_phraseCache.size() < (m_max * (1 - m_tolerance)))
          break;
      }
    }
  }

  void CleanUp() {
#ifdef WITH_THREADS
    boost::mutex::scoped_lock lock(m_mutex);
#endif
    m_phraseCache.clear();
  }

};

}

#endif