expr_engine.h

Go to the documentation of this file.

/*
 *  This file is a part of TiledArray.
 *  Copyright (C) 2014  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
 *
 *  expr_engine.h
 *  Mar 31, 2014
 *
 */
 
#ifndef TILEDARRAY_EXPRESSIONS_EXPR_ENGINE_H__INCLUDED
#define TILEDARRAY_EXPRESSIONS_EXPR_ENGINE_H__INCLUDED
 
#include <TiledArray/expressions/expr_trace.h>
#include <TiledArray/external/madness.h>
 
namespace TiledArray {
namespace expressions {
 
// Forward declarations
template <typename>
struct EngineParamOverride;
template <typename>
class Expr;
template <typename>
struct EngineTrait;
 
template <typename Derived>
class ExprEngine : private NO_DEFAULTS {
 public:
  typedef ExprEngine<Derived> ExprEngine_;
  typedef Derived derived_type;  
 
  // Operational typedefs
  typedef typename EngineTrait<Derived>::value_type
      value_type;  
  typedef
      typename EngineTrait<Derived>::op_type op_type;  
  typedef
      typename EngineTrait<Derived>::policy policy;  
  typedef typename EngineTrait<Derived>::dist_eval_type
      dist_eval_type;  
 
  // Meta data typedefs
  typedef typename EngineTrait<Derived>::size_type size_type;  
  typedef typename EngineTrait<Derived>::trange_type
      trange_type;  
  typedef typename EngineTrait<Derived>::shape_type
      shape_type;  
  typedef typename EngineTrait<Derived>::pmap_interface
      pmap_interface;  
 
 protected:
  // The member variables of this class are protected because derived
  // classes will customize initialization.
 
  World* world_;  
  BipartiteIndexList
      indices_;  
  bool permute_tiles_;  
  BipartitePermutation perm_;
  trange_type trange_;  
  shape_type shape_;    
  std::shared_ptr<pmap_interface>
      pmap_;  
  std::shared_ptr<EngineParamOverride<Derived> >
      override_ptr_;  
 
 public:
 
  template <typename D>
  ExprEngine(const Expr<D>& expr)
      : world_(NULL),
        indices_(),
        permute_tiles_(true),
        perm_(),
        trange_(),
        shape_(),
        pmap_(),
        override_ptr_(expr.override_ptr_) {}
 
 
  void init(World& world, std::shared_ptr<pmap_interface> pmap,
            const BipartiteIndexList& target_indices) {
    if (target_indices.size()) {
      derived().init_indices(target_indices);
      derived().init_struct(target_indices);
    } else {
      derived().init_indices();
      derived().init_struct(indices_);
    }
 
    auto override_world = override_ptr_ != nullptr && override_ptr_->world;
    auto override_pmap = override_ptr_ != nullptr && override_ptr_->pmap;
    world_ = override_world ? override_ptr_->world : &world;
    pmap_ = override_pmap ? override_ptr_->pmap : pmap;
 
    // Check for a valid process map.
    if (pmap_) {
      // If process map is not valid, use the process map constructed by the
      // expression engine.
      if ((typename pmap_interface::size_type(world_->size()) !=
           pmap_->procs()) ||
          (trange_.tiles_range().volume() != pmap_->size()))
        pmap_.reset();
    }
 
    derived().init_distribution(world_, pmap_);
  }
 
 
  void init_struct(const BipartiteIndexList& target_indices) {
    if (target_indices != indices_) {
      perm_ = derived().make_perm(target_indices);
      trange_ = derived().make_trange(outer(perm_));
      shape_ = derived().make_shape(outer(perm_));
    } else {
      trange_ = derived().make_trange();
      shape_ = derived().make_shape();
    }
 
    if (override_ptr_ && override_ptr_->shape)
      shape_ = shape_.mask(*override_ptr_->shape);
  }
 
 
  void init_distribution(World* world,
                         const std::shared_ptr<pmap_interface>& pmap) {
    TA_ASSERT(world);
    TA_ASSERT(pmap);
    TA_ASSERT(pmap->procs() ==
              typename pmap_interface::size_type(world->size()));
    TA_ASSERT(pmap->size() == trange_.tiles_range().volume());
 
    world_ = world;
    pmap_ = pmap;
  }
 
 
  BipartitePermutation make_perm(
      const BipartiteIndexList& target_indices) const {
    return target_indices.permutation(indices_);
  }
 
 
  op_type make_op() const {
    if (perm_ && permute_tiles_)
      // permutation can only be applied to the tile, not to its element (if
      // tile = tensor-of-tensors)
      return derived().make_tile_op(perm_);
    else
      return derived().make_tile_op();
  }
 
  derived_type& derived() { return *static_cast<derived_type*>(this); }
 
  const derived_type& derived() const {
    return *static_cast<const derived_type*>(this);
  }
 
 
  World* world() const { return world_; }
 
 
  const BipartiteIndexList& indices() const { return indices_; }
 
 
  const BipartitePermutation& perm() const { return perm_; }
 
 
  const trange_type& trange() const { return trange_; }
 
 
  const shape_type& shape() const { return shape_; }
 
 
  const std::shared_ptr<pmap_interface>& pmap() const { return pmap_; }
 
 
  void permute_tiles(const bool status) { permute_tiles_ = status; }
 
 
  void print(ExprOStream& os, const BipartiteIndexList& target_indices) const {
    if (perm_) {
      os << "[P " << target_indices << "]"
         << (permute_tiles_ ? " " : " [no permute tiles] ")
         << derived().make_tag() << indices_ << "\n";
    } else {
      os << derived().make_tag() << indices_ << "\n";
    }
  }
 
 
  const char* make_tag() const { return ""; }
 
};  // class ExprEngine
 
}  // namespace expressions
}  // namespace TiledArray
 
#endif  // TILEDARRAY_EXPRESSIONS_EXPR_ENGINE_H__INCLUDED