pmap.h

Go to the documentation of this file.

/*
 *  This file is a part of TiledArray.
 *  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 3 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, see <http://www.gnu.org/licenses/>.
 *
 *  Justus Calvin
 *  Department of Chemistry, Virginia Tech
 *
 *  pmap.h
 *  April 24, 2012
 *
 */
 
#ifndef TILEDARRAY_PMAP_H__INCLUDED
#define TILEDARRAY_PMAP_H__INCLUDED
 
#include <TiledArray/error.h>
#include <TiledArray/external/madness.h>
 
#include <madness/config.h>
 
TILEDARRAY_PRAGMA_GCC(diagnostic push)
TILEDARRAY_PRAGMA_GCC(diagnostic ignored "-Wparentheses")
 
#include <boost/iterator/iterator_facade.hpp>
 
TILEDARRAY_PRAGMA_GCC(diagnostic pop)
 
namespace TiledArray {
 
 
class Pmap {
 public:
  typedef std::size_t size_type;  
 
 protected:
  const size_type rank_;   
  const size_type procs_;  
  const size_type size_;   
  std::vector<size_type>
      local_;  
  size_type local_size_;  
 
 private:
  Pmap(const Pmap&) = delete;
  Pmap& operator=(const Pmap&) = delete;
 
 public:
 
  Pmap(World& world, const size_type size)
      : rank_(world.rank()),
        procs_(world.size()),
        size_(size),
        local_(),
        local_size_(0) {}
 
  virtual ~Pmap() {}
 
 
  virtual size_type owner(const size_type tile) const = 0;
 
 
  virtual bool is_local(const size_type tile) const = 0;
 
 
  size_type size() const { return size_; }
 
 
  size_type rank() const { return rank_; }
 
 
  size_type procs() const { return procs_; }
 
 
  virtual bool known_local_size() const { return true; }
 
 
  size_type local_size() const {
    if (size_ > 0) TA_ASSERT(known_local_size() == true);
    return local_size_;
  }
 
 
  bool empty() const {
    if (size_ > 0) TA_ASSERT(known_local_size() == true);
    return local_size_ == 0;
  }
 
 
  virtual bool is_replicated() const { return false; }
 
 
 private:
  virtual void advance(size_type& value, bool increment) const {
    if (increment)
      ++value;
    else
      --value;
  }
 
 public:
  class Iterator
      : public boost::iterator_facade<Iterator, const size_type,
                                      boost::bidirectional_traversal_tag> {
   public:
    Iterator(const Pmap& pmap, size_type begin_idx, size_type end_idx,
             size_type idx, bool checking, bool use_pmap_advance = false)
        : pmap_(&pmap),
          use_it_(false),
          idx_(idx),
          begin_idx_(begin_idx),
          end_idx_(end_idx),
          checking_(checking),
          use_pmap_advance_(use_pmap_advance) {
      if (idx_ != end_idx) {  // unless this is end
        if (checking_ &&
            idx_ == begin_idx_) {  // create valid begin iterator if needed
          while (idx_ < end_idx_ && !pmap_->is_local(idx_)) {
            ++idx_;
          }
        } else  // else assert that this is a valid iterator
          TA_ASSERT(pmap_->is_local(idx_));
      }
    }
    Iterator(const Pmap& pmap, std::vector<size_type>::const_iterator it)
        : use_it_(true), it_(it) {
      TA_ASSERT(it_ == pmap.local_.end() || pmap.is_local(*it_));
    }
 
   private:
    friend class boost::iterator_core_access;
    const Pmap* pmap_ = nullptr;
 
    bool use_it_;
 
    // have iterator
    std::vector<size_type>::const_iterator it_;
 
    size_type idx_ = 0;
    size_type begin_idx_ = 0;
    size_type end_idx_ = 0;
    bool checking_ = true;
    bool use_pmap_advance_ = false;
 
    void increment() {
      if (use_it_) {
        TA_ASSERT(it_ != pmap_->local_.end());
        ++it_;
      } else {
        if (idx_ == end_idx_) return;
        if (!use_pmap_advance_) {
          ++idx_;
          if (checking_) {
            while (idx_ < end_idx_ && !pmap_->is_local(idx_)) {
              ++idx_;
            }
          }
        } else {
          pmap_->advance(idx_, true);
        }
        if (idx_ > end_idx_)  // normalize if past end
          idx_ = end_idx_;
        TA_ASSERT(idx_ == end_idx_ || pmap_->is_local(idx_));
      }
    }
    void decrement() {
      if (use_it_) {
        TA_ASSERT(it_ !=
                  pmap_->local_
                      .begin());  // no good will happen if we decrement begin
        TA_ASSERT(it_ != pmap_->local_.end());  // don't decrement the end since
                                                // it's an invalid iterator
        --it_;
      } else {
        TA_ASSERT(idx_ != begin_idx_);
        TA_ASSERT(idx_ != end_idx_);
        if (!use_pmap_advance_) {
          --idx_;
          if (checking_) {
            while (idx_ > begin_idx_ && !pmap_->is_local(idx_)) {
              --idx_;
            }
          }
        } else {
          pmap_->advance(idx_, false);
        }
        if (idx_ < begin_idx_)  // normalize if past begin
          idx_ = begin_idx_;
        TA_ASSERT(idx_ == begin_idx_ || pmap_->is_local(idx_));
      }
    }
 
    bool equal(Iterator const& other) const {
      TA_ASSERT(this->pmap_ == other.pmap_ && this->use_it_ == other.use_it_);
      return use_it_ ? this->it_ == other.it_ : this->idx_ == other.idx_;
    }
 
    const size_type& dereference() const { return use_it_ ? *it_ : idx_; }
  };
  friend class Iterator;
 
  typedef Iterator const_iterator;  
 
 
  virtual const_iterator begin() const {
    return !local_.empty() ? Iterator(*this, local_.begin())
                           : Iterator(*this, 0, size_, 0, true);
  }
 
 
  virtual const_iterator end() const {
    return !local_.empty() ? Iterator(*this, local_.end())
                           : Iterator(*this, 0, size_, size_, true);
  }
 
 
  const const_iterator cbegin() const { return begin(); }
 
 
  const const_iterator cend() const { return end(); }
 
 
};  // class Pmap
 
}  // namespace TiledArray
 
#endif  // TILEDARRAY_PMAP_H__INCLUDED