group.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_GROUP_H__INCLUDED
#define MADNESS_WORLD_GROUP_H__INCLUDED

#include <madness/world/dist_keys.h>
#include <madness/world/worldexc.h>
#include <madness/world/worldfwd.h>
#include <madness/world/worldtask.h>

namespace madness {


    class Group {
    private:

        class Impl {
        private:
            World& world_; 
            DistributedID did_; 
            std::vector<ProcessID> group_to_world_map_; 
            ProcessID group_rank_; 
            mutable AtomicInt local_count_; 
            mutable AtomicInt remote_count_; 


            template <typename T, std::size_t N>
            static T* begin(T (&a)[N]) { return a; }


            template <typename T, std::size_t N>
            static T* end(T (&a)[N]) { return (a + N); }


            template <typename T, std::size_t N>
            static std::size_t size(T (&)[N]) { return N; }


            template <typename vectorT>
            static typename vectorT::const_iterator begin(const vectorT &v) {
                return v.begin();
            }


            template <typename vectorT>
            static typename vectorT::const_iterator end(const vectorT &v) {
                return v.end();
            }


            template <typename vectorT>
            static typename disable_if<std::is_array<vectorT>, std::size_t>::type
            size(const vectorT &v) { return v.size(); }

            public:

            template <typename A>
            Impl(World& world, const A& group, const DistributedID& did) :
                world_(world), did_(did),
                group_to_world_map_(begin(group), end(group)),
                group_rank_(-1), local_count_(), remote_count_()
            {
                // Check that there is at least one process in group
                MADNESS_ASSERT(size(group) > 0ul);

                // Sort and remove duplicates from group
                std::sort(group_to_world_map_.begin(), group_to_world_map_.end());
                group_to_world_map_.erase(std::unique(group_to_world_map_.begin(),
                        group_to_world_map_.end()), group_to_world_map_.end());

                // Check that all processes in the group map are contained by world
                MADNESS_ASSERT(group_to_world_map_.front() >= 0);
                MADNESS_ASSERT(group_to_world_map_.back() < world_.size());

                // Get the group rank for this process
                group_rank_ = rank(world_.rank());
                MADNESS_ASSERT(group_rank_ != -1);

                // Initialize the use counter
                local_count_ = 0;
                remote_count_ = 0;
            }


            World& get_world() const { return world_; }


            const DistributedID& id() const { return did_; }


            ProcessID rank() const { return group_rank_; }


            ProcessID rank(const ProcessID world_rank) const {
                ProcessID result = std::distance(group_to_world_map_.begin(),
                        std::find(group_to_world_map_.begin(), group_to_world_map_.end(),
                                world_rank));
                if(static_cast<std::size_t>(result) == group_to_world_map_.size())
                    result = -1;
                return result;
            }


            ProcessID size() const { return group_to_world_map_.size(); }


            ProcessID world_rank(const ProcessID group_rank) const {
                MADNESS_ASSERT(group_rank >= 0);
                MADNESS_ASSERT(group_rank < ProcessID(group_to_world_map_.size()));
                return group_to_world_map_[group_rank];
            }


            void make_tree(const ProcessID group_root, ProcessID& parent,
                    ProcessID& child0, ProcessID& child1) const
            {
                const ProcessID group_size = group_to_world_map_.size();

                // Check that root is in the range of the group
                MADNESS_ASSERT(group_root >= 0);
                MADNESS_ASSERT(group_root < group_size);

                // Renumber processes so root has me == 0
                const ProcessID me = (group_rank_ + group_size - group_root) % group_size;

                // Compute the group parent
                parent = (me == 0 ? -1 : group_to_world_map_[(((me - 1) >> 1) + group_root) % group_size]);

                // Compute children
                child0 = (me << 1) + 1 + group_root;
                child1 = child0 + 1;

                const ProcessID end = group_size + group_root;
                if(child0 < end)
                    child0 = group_to_world_map_[child0 % group_size];
                else
                    child0 = -1;
                if(child1 < end)
                    child1 = group_to_world_map_[child1 % group_size];
                else
                    child1 = -1;
            }


            void local_update() const { local_count_++; }


            void remote_update(const int n) const {
                const int count = (remote_count_ += n);
                if(count == 0)
                    Group::unregister_group(did_);
            }


            static void deleter(Impl* pimpl) {
                // Note: Calling remote_update() breaks the no throw requirement
                // of deleters. Unfortunately, this cannot be avoided since
                // Group must be used concurrently in different threads, and all
                // cleanup methods requires some type of locking.
                pimpl->remote_update(-(pimpl->local_count_));
            }
        }; // struct Impl

        std::shared_ptr<Impl> pimpl_;



        void register_group() const;


        static void unregister_group(const DistributedID& did);

        Group(Impl* pimpl) : pimpl_(pimpl) { }

    public:


        Group() : pimpl_() { }


        Group(const Group& other) : pimpl_(other.pimpl_) { }


        template <typename A>
        Group(World& world, const A& group, const DistributedID& did) :
            pimpl_(new Impl(world, group, did), Impl::deleter)
        {
            register_group();
        }


        template <typename A>
        Group(World& world, const A& group, const std::size_t tag) :
            pimpl_(new Impl(world, group, DistributedID(uniqueidT(), tag)), Impl::deleter)
        {
            register_group();
        }


        template <typename A>
        Group(World& world, const A& group, const uniqueidT& uid, const std::size_t tag) :
            pimpl_(new Impl(world, group, DistributedID(uid, tag)), Impl::deleter)
        {
            register_group();
        }


        Group& operator=(const Group& other) {
            pimpl_ = other.pimpl_;
            return *this;
        }


        static madness::Future<Group> get_group(const DistributedID& did);


        void local_update() const {
            MADNESS_ASSERT(pimpl_);
            pimpl_->local_update();
        }


        void remote_update() const {
            MADNESS_ASSERT(pimpl_);
            pimpl_->remote_update(1);
        }


        bool empty() const { return !pimpl_; }


        const DistributedID& id() const {
            MADNESS_ASSERT(pimpl_);
            return pimpl_->id();
        }


        World& get_world() const {
            MADNESS_ASSERT(pimpl_);
            return pimpl_->get_world();
        }


        ProcessID rank() const {
            MADNESS_ASSERT(pimpl_);
            return pimpl_->rank();
        }


        ProcessID rank(const ProcessID world_rank) const {
            MADNESS_ASSERT(pimpl_);
            return pimpl_->rank(world_rank);
        }


        ProcessID size() const {
            return (pimpl_ ? pimpl_->size() : 0);
        }


        ProcessID world_rank(const ProcessID group_rank) const {
            MADNESS_ASSERT(pimpl_);
            return pimpl_->world_rank(group_rank);
        }


        void make_tree(const ProcessID group_root, ProcessID& parent,
                ProcessID& child1, ProcessID& child2) const
        {
            MADNESS_ASSERT(pimpl_);
            pimpl_->make_tree(group_root, parent, child1, child2);
        }

        template <typename Archive>
        void serialize(const Archive&) {
            MADNESS_ASSERT(false); // not allowed
        }
    }; // class Group

} // namespace madness

#endif // MADNESS_WORLD_GROUP_H__INCLUDED