cyclic_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
 *
 *  cyclic_pmap.h
 *  May 1, 2012
 *
 */
 
#ifndef TILEDARRAY_PMAP_CYCLIC_PMAP_H__INCLUDED
#define TILEDARRAY_PMAP_CYCLIC_PMAP_H__INCLUDED
 
#include <TiledArray/pmap/pmap.h>
 
namespace TiledArray {
namespace detail {
 
 
class CyclicPmap : public Pmap {
 protected:
  // Import Pmap protected variables
  using Pmap::procs_;  
  using Pmap::rank_;   
  using Pmap::size_;   
 
 private:
  const size_type rows_;       
  const size_type cols_;       
  const size_type proc_cols_;  
  const size_type proc_rows_;  
  size_type rank_row_ = 0;     
  size_type rank_col_ = 0;     
  size_type local_rows_ = 0;   
  size_type local_cols_ =
      0;  
 
 public:
  typedef Pmap::size_type size_type;  
 
 
  CyclicPmap(World& world, size_type rows, size_type cols, size_type proc_rows,
             size_type proc_cols)
      : Pmap(world, rows * cols),
        rows_(rows),
        cols_(cols),
        proc_cols_(proc_cols),
        proc_rows_(proc_rows) {
    // Check that the size is non-zero
    TA_ASSERT(rows_ >= 1ul);
    TA_ASSERT(cols_ >= 1ul);
 
    // Check limits of process rows and columns
    TA_ASSERT(proc_rows_ >= 1ul);
    TA_ASSERT(proc_cols_ >= 1ul);
    TA_ASSERT((proc_rows_ * proc_cols_) <= procs_);
 
    // Compute local size_, if have any
    if (rank_ < (proc_rows_ * proc_cols_)) {
      // Compute rank coordinates
      rank_row_ = rank_ / proc_cols_;
      rank_col_ = rank_ % proc_cols_;
 
      local_rows_ =
          (rows_ / proc_rows_) + ((rows_ % proc_rows_) > rank_row_ ? 1ul : 0ul);
      local_cols_ =
          (cols_ / proc_cols_) + ((cols_ % proc_cols_) > rank_col_ ? 1ul : 0ul);
 
      // Allocate memory for the local tile list
      this->local_size_ = local_rows_ * local_cols_;
    }
  }
 
  virtual ~CyclicPmap() {}
 
  size_type nrows() const { return rows_; }
  size_type ncols() const { return cols_; }
  size_type nrows_proc() const { return proc_rows_; }
  size_type ncols_proc() const { return proc_cols_; }
 
 
  virtual size_type owner(const size_type tile) const {
    TA_ASSERT(tile < size_);
    // Compute tile coordinate in tile grid
    const size_type tile_row = tile / cols_;
    const size_type tile_col = tile % cols_;
    // Compute process coordinate of tile in the process grid
    const size_type proc_row = tile_row % proc_rows_;
    const size_type proc_col = tile_col % proc_cols_;
    // Compute the process that owns tile
    const size_type proc = proc_row * proc_cols_ + proc_col;
 
    TA_ASSERT(proc < procs_);
 
    return proc;
  }
 
 
  virtual bool is_local(const size_type tile) const {
    return (CyclicPmap::owner(tile) == rank_);
  }
 
 private:
  virtual void advance(size_type& value, bool increment) const {
    if (increment) {
      auto row = value / cols_;
      const auto row_end = (row + 1) * cols_;
      value += proc_cols_;
      if (value >= row_end) {  // if past the end of row ...
        row += proc_rows_;
        if (row < rows_) {                  // still have tiles
          value = row * cols_ + rank_col_;  // first tile in this row
        } else                              // done
          value = size_;
      }
    } else {  // decrement
      auto row = value / cols_;
      const auto row_begin = row * cols_;
      if (value < proc_cols_) {  // protect against unsigned wraparound
        return;
      }
      value -= proc_cols_;
      if (value < row_begin) {  // if past the beginning of row ...
        if (row < proc_rows_)   // protect against unsigned wraparound
          return;
        row -= proc_rows_;
        value = row * cols_ + rank_col_ +
                (local_cols_ - 1) * proc_cols_;  // last tile in this row
      }
    }
  }
 
 public:
  virtual const_iterator begin() const {
    return this->local_size_ > 0
               ? Iterator(*this, rank_row_ * cols_ + rank_col_, this->size_,
                          rank_row_ * cols_ + rank_col_, false, true)
               : end();  // make end() if empty
  }
  virtual const_iterator end() const {
    return this->local_size_ > 0
               ? Iterator(*this, rank_row_ * cols_ + rank_col_, this->size_,
                          this->size_, false, true)
               : Iterator(*this, 0, this->size_, this->size_, false, true);
  }
 
};  // class CyclicPmap
 
}  // namespace detail
}  // namespace TiledArray
 
#endif  // TILEDARRAY_PMAP_CYCLIC_PMAP_H__INCLUDED