dist_cache.h

Go to the documentation of this file.

/*
  This file is part of MADNESS.

  Copyright (C) 2013  Virginia Tech

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

  This program 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 General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

  For more information please contact:

  Robert J. Harrison
  Oak Ridge National Laboratory
  One Bethel Valley Road
  P.O. Box 2008, MS-6367

  email: harrisonrj@ornl.gov
  tel:   865-241-3937
  fax:   865-572-0680


  $Id$
 */

#ifndef MADNESS_WORLD_DIST_CACHE_H__INCLUDED
#define MADNESS_WORLD_DIST_CACHE_H__INCLUDED

#include <madness/world/worldexc.h>
#include <madness/world/worldhashmap.h>
#include <madness/world/worldfut.h>

namespace madness {
    namespace detail {


        template <typename keyT>
        class DistCache {
        private:

            // Forward declarations
            class Cache;
            template <typename> class CacheData;

            typedef madness::ConcurrentHashMap<keyT, Cache*> cache_container;
            typedef typename cache_container::datumT datum_type;

            static cache_container caches_; 


            class Cache {
            public:

                virtual ~Cache() { }


                template <typename valueT>
                const madness::Future<valueT>& get() const {
                    MADNESS_ASSERT(this->get_type_info() == typeid(CacheData<valueT>));
                    return static_cast<const CacheData<valueT>*>(this)->value();
                }

            private:


                virtual const std::type_info& get_type_info() const = 0;

            }; // class Cache


            template <typename valueT>
            class CacheData : public Cache {
            private:
                madness::Future<valueT> value_; 

            public:

                CacheData() : value_() { }

                CacheData(const madness::Future<valueT>& value) : value_(value) { }

                CacheData(const valueT& value) : value_(value) { }

                virtual ~CacheData() { }


                const madness::Future<valueT>& value() const { return value_; }

            private:


                virtual const std::type_info& get_type_info() const {
                    return typeid(CacheData<valueT>);
                }

            }; // class CacheData

            public:


            template <typename valueT>
            static void set_cache_value(const keyT& key, const valueT& value) {
                typedef typename madness::remove_future<valueT>::type value_type;

                // Retrieve the cached future
                typename cache_container::accessor acc;
                if(caches_.insert(acc, datum_type(key, static_cast<Cache*>(NULL)))) {

                    // A new element was inserted, so create a new cache object.
                    acc->second = new CacheData<value_type>(value);
                    acc.release();

                } else {

                    // The element already existed, so retrieve the data
                    Cache* cache = acc->second;
                    caches_.erase(acc);

                    // Set the cache value
                    madness::Future<value_type> f =
                            cache->template get<value_type>();
                    MADNESS_ASSERT(! f.probe());
                    f.set(value);

                    // Cleanup cache
                    delete cache;
                }
            }


            template <typename valueT>
            static void get_cache_value(const keyT& key, madness::Future<valueT>& value) {
                // Retrieve the cached future
                typename cache_container::accessor acc;
                if(caches_.insert(acc, datum_type(key, static_cast<Cache*>(NULL)))) {
                    // A new element was inserted, so create a new cache object.
                    acc->second = new CacheData<valueT>(value);
                    acc.release();
                } else {
                    // The element already existed, so retrieve the data and
                    // remove the cache element.
                    Cache* cache = acc->second;
                    caches_.erase(acc);

                    // Get the result
                    value.set(cache->template get<valueT>());
                    delete cache;
                }
            }


            template <typename valueT>
            static madness::Future<valueT> get_cache_value(const keyT& key) {
                // Retrieve the cached future
                typename cache_container::accessor acc;
                if(caches_.insert(acc, datum_type(key, static_cast<Cache*>(NULL)))) {
                    // A new element was inserted, so create a new cache object.
                    acc->second = new CacheData<valueT>();
                    madness::Future<valueT> value(acc->second->template get<valueT>());
                    acc.release();

                    return value;
                } else {
                    // The element already existed, so retrieve the data and
                    // remove the cache element.
                    Cache* cache = acc->second;
                    caches_.erase(acc);

                    // Get the result
                    madness::Future<valueT> value(cache->template get<valueT>());
                    delete cache;

                    return value;
                }
            }

        }; // class DistCache

        template <typename keyT>
        typename DistCache<keyT>::cache_container DistCache<keyT>::caches_;

    }  // namespace detail
} // namespace madness

#endif // MADNESS_WORLD_DIST_CACHE_H__INCLUDED