/Users/mourrain/Devel/mmx/basix/include/basix/memoize.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : memoize.hpp
* DESCRIPTION: Remember option
* COPYRIGHT  : (C) 2007  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#ifndef __MEMOIZE_HPP
#define __MEMOIZE_HPP
#include <basix/table.hpp>
#include <basix/triple.hpp>
#include <basix/list.hpp>


namespace mmx {

/******************************************************************************
* Different variants of memoizers
******************************************************************************/

struct std_memoizer {
  typedef hard_eq_table table_variant;
};

struct exact_eq_memoizer {
  typedef exact_eq_table table_variant;
};

struct equal_memoizer {
  typedef equal_table table_variant;
};

/******************************************************************************
* The memoizer template class
******************************************************************************/

template<typename V>
struct memoizer {
  typedef typename V::table_variant table_variant;
  typedef void (*cleaner) (void);
  static bool busy;
  static list<cleaner> to_clean;

  static inline void start () {
    busy= true; }
  static inline void end () {
    while (!is_nil (to_clean)) {
      read_car (to_clean) ();
      to_clean= read_cdr (to_clean);
    }
    busy= false; }

  template<typename D, typename S1,
           D (*fun) (const S1&)>
  struct unary {
    typedef D (*fun_type) (const S1&);
    static bool busy;
    static table<D,S1,table_variant> t;
    static void end () {
      busy= false;
      t= table<D,S1,table_variant> (); }
    static inline void start () {
      if (!busy) {
        busy= true;
        to_clean= cons<cleaner> (end, to_clean); } }
  };

  template<typename D, typename S1, typename S2,
           D (*fun) (const S1&, const S2&)>
  struct binary {
    typedef D (*fun_type) (const S1&, const S2&);
    static bool busy;
    static table<D,pair<S1,S2>,table_variant> t;
    static void end () {
      busy= false;
      t= table<D,pair<S1,S2>,table_variant> (); }
    static inline void start () {
      if (!busy) {
        busy= true;
        to_clean= cons<cleaner> (end, to_clean); } }
  };

  template<typename D, typename S1, typename S2, typename S3,
           D (*fun) (const S1&, const S2&, const S3&)>
  struct ternary {
    static bool busy;
    typedef D (*fun_type) (const S1&, const S2&, const S3&);
    static table<D,triple<S1,S2,S3>,table_variant> t;
    static void end () {
      busy= false;
      t= table<D,triple<S1,S2,S3>,table_variant> (); }
    static inline void start () {
      if (!busy) {
        busy= true;
        to_clean= cons<cleaner> (end, to_clean); } }
  };
};

template<typename V> bool memoizer<V>::busy= false;
template<typename V> list<typename memoizer<V>::cleaner> memoizer<V>::to_clean=
  list<typename memoizer<V>::cleaner> ();

template<typename V>
template<typename D, typename S1,
         D (*fun) (const S1&)>
bool
memoizer<V>::unary<D,S1,fun>::busy= false;

template<typename V>
template<typename D, typename S1,
         D (*fun) (const S1&)>
table<D,S1,typename V::table_variant>
memoizer<V>::unary<D,S1,fun>::t= table<D,S1,typename V::table_variant> ();

template<typename V>
template<typename D, typename S1, typename S2,
         D (*fun) (const S1&, const S2&)>
bool
memoizer<V>::binary<D,S1,S2,fun>::busy= false;

template<typename V>
template<typename D, typename S1, typename S2,
         D (*fun) (const S1&, const S2&)>
table<D,pair<S1,S2>,typename V::table_variant>
memoizer<V>::binary<D,S1,S2,fun>::t=
  table<D,pair<S1,S2>,typename V::table_variant> ();

template<typename V>
template<typename D, typename S1, typename S2, typename S3,
         D (*fun) (const S1&, const S2&, const S3&)>
bool
memoizer<V>::ternary<D,S1,S2,S3,fun>::busy= false;

template<typename V>
template<typename D, typename S1, typename S2, typename S3,
         D (*fun) (const S1&, const S2&, const S3&)>
table<D,triple<S1,S2,S3>,typename V::table_variant>
memoizer<V>::ternary<D,S1,S2,S3,fun>::t=
  table<D,triple<S1,S2,S3>,typename V::table_variant> ();

/******************************************************************************
* Memoization macros
******************************************************************************/

#define START_MEMOIZER(V,dest,call)             \
  if (!memoizer<V>::busy) {                     \
    memoizer<V>::start ();                      \
    dest res= call;                             \
    memoizer<V>::end ();                        \
    return res;                                 \
  }

#define MEMOIZE_UNARY(V,dest,src1,fun,arg1,lazy)        \
  typedef memoizer<V>::unary<dest,src1,fun> memo;       \
  if (!memo::busy) {                                    \
    START_MEMOIZER(V,dest,(fun)(arg1));                 \
    memo::start ();                                     \
  }                                                     \
  dest res;                                             \
  if (memo::t->get (arg1, res)) return res;             \
  res= lazy;                                            \
  memo::t [arg1]= res;                                  \
  return res;

#define MEMOIZE_BINARY(V,dest,src1,src2,fun,arg1,arg2,lazy)     \
  typedef memoizer<V>::binary<dest,src1,src2,fun> memo;         \
  if (!memo::busy) {                                            \
    START_MEMOIZER(V,dest,(fun)(arg1,arg2));                    \
    memo::start ();                                             \
  }                                                             \
  pair<src1,src2> arg (arg1, arg2);                             \
  dest res;                                                     \
  if (memo::t->get (arg, res)) return res;                      \
  res= lazy;                                                    \
  memo::t [arg]= res;                                           \
  return res;

#define MEMOIZE_TERNARY(V,dest,src1,src2,src3,fun,arg1,arg2,arg3,lazy)  \
  typedef memoizer<V>::ternary<dest,src1,src2,src3,fun> memo;           \
  if (!memo::busy) {                                                    \
    START_MEMOIZER(V,dest,(fun)(arg1,arg2, arg3));                      \
    memo::start ();                                                     \
  }                                                                     \
  triple<src1,src2,src3> arg (arg1, arg2, arg3);                        \
  dest res;                                                             \
  if (memo::t->get (arg, res)) return res;                              \
  res= lazy;                                                            \
  memo::t [arg]= res;                                                   \
  return res;

} // namespace mmx
#endif // __MEMOIZE_HPP