worldref.h

Go to the documentation of this file.

/*
  This file is part of MADNESS.

  Copyright (C) 2007,2010 Oak Ridge National Laboratory

  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_WORLDREF_H__INCLUDED
#define MADNESS_WORLD_WORLDREF_H__INCLUDED


#include <madness/world/atomicint.h>    // for AtomicInt
#include <madness/world/shared_ptr.h>   // for shared_ptr
#include <madness/world/worldtypes.h>   // for ProcessID
#include <madness/world/archive.h>      // for wrap_opaque
#include <madness/world/worldam.h>      // for new_am_arg
#include <madness/world/worldptr.h>     // for WorldPtr
#include <madness/world/worldhashmap.h> // for ConcurrentHashMap
#include <iosfwd>               // for std::ostream

//#define MADNESS_REMOTE_REFERENCE_DEBUG
#ifdef MADNESS_REMOTE_REFERENCE_DEBUG
#include <madness/world/print.h>        // for print
#endif

namespace madness {

    class World;
    template <typename T> class RemoteReference;
//
//    template <typename T>
//    std::ostream& operator<<(std::ostream& s, const RemoteReference<T>& ref);

    namespace archive {
        template <typename, typename>
        struct ArchiveLoadImpl;

        template <typename, typename>
        struct ArchiveStoreImpl;
    }

    namespace detail {


        template <typename T> class RemoteCounterImpl;


        class RemoteCounterBase {
        private:
            madness::AtomicInt count_;          

            // Copy not allowed
            RemoteCounterBase(const RemoteCounterBase&);
            RemoteCounterBase& operator=(const RemoteCounterBase&);

        public:

            RemoteCounterBase() { count_ = 1; }
            virtual ~RemoteCounterBase() { }


            virtual void* key() const = 0;


            long use_count() const { return count_; }


            template <typename T>
            const std::shared_ptr<T>& get_shared() const {
                return static_cast<const RemoteCounterImpl<T>*>(this)->get_shared();
            }


            void add_ref() {
#ifdef MADNESS_REMOTE_REFERENCE_DEBUG
                long c = count_++;
                print(">>> RemoteCounterBase(", this->key(), ") +ref count=", c + 1);
#else
                count_++;
#endif
            }


            bool release() {
#ifdef MADNESS_REMOTE_REFERENCE_DEBUG
                long c = count_;
                print(">>> RemoteCounterBase(", this->key(), ") -ref count=", c - 1);
#endif
                return count_.dec_and_test();
            }
        }; // class RemoteCounterBase


        template <typename T>
        class RemoteCounterImpl : public RemoteCounterBase {
        private:
            // At some point this should probably be changed to a quick allocator
            // When that happens, also uncomment the new and delete operators
//            typedef std::allocator<RemoteCounterImpl<T> > A;

            // Keep a copy of the shared pointer to make sure it stays in memory
            // while we have outstanding remote references to it.
            std::shared_ptr<T> pointer_; 

        public:
            explicit RemoteCounterImpl(const std::shared_ptr<T>& p) :
                RemoteCounterBase(), pointer_(p)
            { }

            virtual ~RemoteCounterImpl() { }


            const std::shared_ptr<T>& get_shared() const { return pointer_; }


            virtual void* key() const { return static_cast<void*>(pointer_.get()); }

//            void* operator new(std::size_t) {
//                return A().allocate(1);
//            }
//
//            void operator delete(void * p) {
//                A().deallocate(static_cast<RemoteCounterImpl<T> *>(p), 1);
//            }
        }; // class RemoteCounterImpl


        class RemoteCounter {
        private:
            typedef RemoteCounterBase implT;
            typedef ConcurrentHashMap<void*, WorldPtr<implT> > pimpl_mapT;

            static pimpl_mapT pimpl_map_;   

            mutable WorldPtr<implT> pimpl_;


            void destroy() {
                if(pimpl_.is_local()) {
                    if(pimpl_->release()) {
                        // No one else is referencing this pointer.
                        // We can safely dispose of it.

#ifdef MADNESS_REMOTE_REFERENCE_DEBUG
                        print(">>> RemoteCounter::unregister_ptr_: key=", pimpl_->key(), ", value=", pimpl_);
#endif
                        unregister_ptr_(pimpl_->key());
                        delete pimpl_.get();
                    }
                }

                pimpl_ = WorldPtr<implT>();
            }


            template <typename T>
            static WorldPtr<implT> register_ptr_(World& w, const std::shared_ptr<T>& p) {
                // Check for a null pointer
                if(p.get() == NULL)
                    return WorldPtr<implT>(w, NULL);

                pimpl_mapT::accessor acc;
                // Pointer is local and non-null
                if(pimpl_map_.insert(acc,static_cast<void*>(p.get()))) {
                    // The pointer is not registered so we need to make a
                    // new pimpl.
                    implT* pimpl = new RemoteCounterImpl<T>(p);

                    try{
                        acc->second = WorldPtr<implT>(w, pimpl);
                    } catch(...) {
                        delete pimpl;
                        throw;
                    }

#ifdef MADNESS_REMOTE_REFERENCE_DEBUG
                        print(">>> RemoteCounter::register_ptr_(new): key=", p.get(), ", pimpl=", acc->second);
#endif
                } else {
                    // The pointer is already registered, so we just need
                    // increment the counter.
#ifdef MADNESS_REMOTE_REFERENCE_DEBUG
                    print(">>> RemoteCounter::register_ptr_(existing): key=", acc->second->key(), ", pimpl=", acc->second);
#endif
                    acc->second->add_ref();
                }

                return acc->second;
            }


            static void unregister_ptr_(void* key) {
                std::size_t ereased = pimpl_map_.erase(key);
                MADNESS_ASSERT(ereased > 0);
            }

            RemoteCounter(const WorldPtr<implT>& p) :
                pimpl_(p)
            { }

        public:

            RemoteCounter() : pimpl_() { }

            RemoteCounter(const RemoteCounter& other) :
                pimpl_(other.pimpl_)
            {
                if(pimpl_ && pimpl_.is_local())
                    pimpl_->add_ref();
            }

            template <typename T>
            explicit RemoteCounter(World& w, const std::shared_ptr<T>& p) :
                pimpl_(register_ptr_(w, p))
            { }

            ~RemoteCounter() { destroy(); }

            RemoteCounter& operator=(const RemoteCounter& other) {
                WorldPtr<implT> temp = other.pimpl_;

                if(pimpl_ != temp) {
                    if(temp)
                        temp->add_ref();
                    destroy();
                    pimpl_ = temp;
                }

                return *this;
            }


            long use_count() const { return (pimpl_.is_local() ? pimpl_->use_count() : 0); }
            bool unique() const { return use_count() == 1; }
            bool empty() const { return ! pimpl_; }

            bool is_local() const { return pimpl_.is_local(); }
            bool has_owner() const { return pimpl_.has_owner(); }
            ProcessID owner() const { return pimpl_.owner(); }

            template <typename T>
            const std::shared_ptr<T>& get_shared() const { return pimpl_->get_shared<T>(); }

            WorldPtr<implT>::worldidT
            get_worldid() const { return pimpl_.get_worldid(); }
            World& get_world() const { return pimpl_.get_world(); }
            void swap(RemoteCounter& other) {
                madness::detail::swap(pimpl_, other.pimpl_);
            }

        private:

            template <typename, typename>
            friend struct archive::ArchiveLoadImpl;

            template <typename, typename>
            friend struct archive::ArchiveStoreImpl;

            template <typename Archive>
            void load_(const Archive& ar) {
                WorldPtr<implT> p;
                ar & p;
                RemoteCounter(p).swap(*this);

#ifdef MADNESS_REMOTE_REFERENCE_DEBUG
                print(">>> RemoteCounter::load: pimpl=", pimpl_);
#endif
            }

            template <typename Archive>
            void store_(const Archive& ar) const {
                ar & pimpl_;

                if(! ar.count_only()) {
#ifdef MADNESS_REMOTE_REFERENCE_DEBUG
                    print(">>> RemoteCounter::store: pimpl=", pimpl_);
#endif
                    if(pimpl_.is_local())
                        pimpl_->add_ref();
                    else
                        pimpl_ = WorldPtr<implT>();
                }
            }


        }; // class RemoteCounter

        inline void swap(RemoteCounter& l, RemoteCounter& r) { l.swap(r); }

        std::ostream& operator<<(std::ostream& out, const RemoteCounter& counter);

    } // namespace detail



    template <typename T>
    class RemoteReference {
    public:
        typedef typename detail::ptr_traits<T>::reference referenceT;
        typedef T* pointerT;

    private:
        mutable pointerT pointer_;      
        detail::RemoteCounter counter_; 

        // This is for RemoteReferences of other types, so they can still access
        // private members.
        template <typename>
        friend class RemoteReference;

        // Handles reset of a remote reference from another node.
        static void reset_handler(const AmArg& arg) {
            RemoteReference<T> r;
            arg & r;
            // r resets on scope exit.
        }

    public:

        RemoteReference() :
            pointer_(), counter_() {};


        RemoteReference(World& w, const std::shared_ptr<T>& p) :
            pointer_(p.get()), counter_(w, p)
        { }


        RemoteReference(const RemoteReference<T>& other) :
            pointer_(other.pointer_), counter_(other.counter_)
        { }


        template <typename U>
        RemoteReference(const RemoteReference<U>& other) :
            pointer_(other.pointer_), counter_(other.counter_)
        { }

        ~RemoteReference() { }


        RemoteReference<T>& operator=(const RemoteReference<T>& other) {
            RemoteReference<T>(other).swap(*this);
            return *this;
        }


        template <typename U>
        RemoteReference<T>& operator=(const RemoteReference<U>& other) {
            RemoteReference<T>(other).swap(*this);
            return *this;
        }



        void reset() {
            if((! (counter_.is_local())) && counter_.has_owner())
                get_world().am.send(owner(), RemoteReference<T>::reset_handler, new_am_arg(*this));
            else
                RemoteReference<T>().swap(*this);
        }


        operator bool() const {
            return ! counter_.empty();
        }


        pointerT get() const {
            MADNESS_ASSERT(counter_.is_local());
            return pointer_;
        }


        const std::shared_ptr<T>& get_shared() const {
            MADNESS_ASSERT(counter_.is_local());
            return counter_.get_shared<T>();
        }


        referenceT operator*() const {
            MADNESS_ASSERT(pointer_ != NULL);
            MADNESS_ASSERT(counter_.is_local());
            return *pointer_;
        }


        pointerT operator->() const {
            MADNESS_ASSERT(pointer_ != NULL);
            MADNESS_ASSERT(counter_.is_local());
            return pointer_;
        }


        long use_count() const { return counter_.use_count(); }


        bool unique() const { return counter_.unique(); }


        template <typename U>
        void swap(RemoteReference<U>& other) {
            std::swap(pointer_, other.pointer_);
            madness::detail::swap(counter_, other.counter_);
        }


        inline bool is_local() const { return counter_.is_local(); }


        inline ProcessID owner() const { return counter_.owner(); }


        World& get_world() const { return counter_.get_world(); }


        template <typename Archive>
        void serialize(const Archive& ar) const {
            // All of the interesting stuff happens in the counter serialization.
            ar & archive::wrap_opaque(pointer_) & counter_;
        }

    public:


        friend std::ostream& operator<<(std::ostream& out, const RemoteReference<T>& ref) {
            out << "RemoteReference( pointer=" << ref.pointer_ << " counter=" << ref.counter_ << ")";
            return out;
        }
    }; // class RemoteReference



    template <typename T, typename U>
    void swap(RemoteReference<T>& l, RemoteReference<U>& r) {
        l.swap(r);
    }

    namespace archive {

        // This function is not allowed. Therefore it is not implemented so that
        // a compiler error is generated it it is called. This still does not
        // prevent remote references from being wrapped as part of another object.
        template <typename T>
        archive_array<unsigned char> wrap_opaque(const RemoteReference<T>& t);

        // Remote counter serialization

        template <typename Archive>
        struct ArchiveLoadImpl<Archive, detail::RemoteCounter > {
            static inline void load(const Archive& ar, detail::RemoteCounter& c) {
                c.load_(ar);
            }
        };

        template <typename Archive>
        struct ArchiveStoreImpl<Archive, detail::RemoteCounter > {
            static inline void store(const Archive& ar, const detail::RemoteCounter& c) {
                c.store_(ar);
            }
        };

    } // namespace archive
} // namespace madness

#endif // MADNESS_WORLD_WORLDREF_H__INCLUDED