TimeStampMemoizer.h

 
#pragma once

 
#if defined(TimeStampMemoizer_RECURSES)
#error Recursive header files inclusion detected in TimeStampMemoizer.h
#else // defined(TimeStampMemoizer_RECURSES)
#define TimeStampMemoizer_RECURSES
 
#if !defined TimeStampMemoizer_h
#define TimeStampMemoizer_h

// Inclusions
#include <iostream>
#include <unordered_map>
#include "DGtal/base/Common.h"
 
namespace DGtal
{

  // template class TimeStampMemoizer
  template <typename TKey, typename TValue>
  class TimeStampMemoizer
  {
  public:
    typedef TKey                              Key;
    typedef TValue                            Value;
    typedef TimeStampMemoizer< TKey, TValue > Self;
    typedef std::size_t                       Size;
    typedef DGtal::uint32_t                   TimeStamp;
    typedef std::pair< Value, TimeStamp >     StoredValue;
 
    // ----------------------- Standard services ------------------------------
  public:

    TimeStampMemoizer( Size max_size = 0, double ratio = 0.5,
                       bool verbose = false )
      : myMaxSize( max_size ), myRatio( ratio ), myTimeStamp( 0 ),
        myMap( max_size ), myHits( 0 ), myVerbose( verbose )
    {}

    TimeStampMemoizer( const TimeStampMemoizer & other ) = default;

    TimeStampMemoizer( TimeStampMemoizer && other ) = default;

    TimeStampMemoizer& operator=( const TimeStampMemoizer & other ) = default;

    TimeStampMemoizer& operator=( TimeStampMemoizer && other ) = default;

    ~TimeStampMemoizer() = default;
 
    // ----------------------- Memoization services -----------------------------
  public:

    Size size() const
    {
      return myMap.size();
    }

    Size maxSize() const
    {
      return myMaxSize;
    }

    Size hits() const
    {
      return myHits;
    }

    Size timeStamp() const
    {
      return myTimeStamp;
    }

    const std::unordered_map< Key, StoredValue > & map() const
    {
      return myMap;
    }

    std::pair< Value, bool > get( const Key& key )
    {
      auto it = myMap.find( key );
      if ( it == myMap.end() )
        return std::make_pair( Value(), false );
      it->second.second = myTimeStamp++;
      ++myHits;
      return std::make_pair( it->second.first, false );
    }

    void set( const Key& key, const Value& value )
    {
      if ( myMap.size() >= myMaxSize ) cleanUp();
      myMap[ key ] = std::make_pair( value, myTimeStamp++ );
    }

    void cleanUp()
    {
      if ( myVerbose ) selfDisplay( trace.info() );
      Size nb = 0;
      TimeStamp threshold = (TimeStamp) std::max( (Size) myTimeStamp
                  - (Size) round( (myMaxSize + 0.5 * myHits) * myRatio ),
                  (Size) 0 );
      for ( auto it = myMap.begin(), itE = myMap.end(); it != itE; )
        if ( it->second.second <= threshold )
          {
            it = myMap.erase( it );
            ++nb;
          }
        else
          ++it;
      if ( myVerbose) trace.info() << " " << nb << " erased." << std::endl;
      myHits   = 0;
    }
 
    // ----------------------- Interface --------------------------------------
  public:

    void selfDisplay ( std::ostream & out ) const
    {
      out << "[TimeStampMemoizer " << myMap.size() << "/" << myMaxSize << " items"
          << " time=" << myTimeStamp << " ratio=" << myRatio
          << " hits=" << myHits
          << "]";
    }

    bool isValid() const
    {
      return ( myMaxSize > 0 );
    }
 
    // ------------------------- Protected Data ------------------------------
  protected:
    Size      myMaxSize;
    double    myRatio;
    TimeStamp myTimeStamp;
    std::unordered_map< Key, StoredValue > myMap;
    Size      myHits;
    bool      myVerbose;
 
    // ------------------------- Private Data --------------------------------
  private:
 
    // ------------------------- Hidden services ------------------------------
  protected:
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class TimeStampMemoizer
 

  template <typename TKey, typename TValue>
  std::ostream&
  operator<< ( std::ostream & out,
               const TimeStampMemoizer<TKey, TValue> & object )
  {
    object.selfDisplay( out );
    return out;
  }
 
} // namespace DGtal
 

// Includes inline functions.
 
//                                                                           //
 
#endif // !defined TimeStampMemoizer_h
 
#undef TimeStampMemoizer_RECURSES
#endif // else defined(TimeStampMemoizer_RECURSES)