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/madness.h>
#include <TiledArray/expressions/expr_trace.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_; 
      VariableList vars_; 
      bool permute_tiles_; 
      Permutation 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), vars_(), permute_tiles_(true), perm_(), trange_(), shape_(),
        pmap_(), override_ptr_(expr.override_ptr_)
      { }


      void init(World& world, std::shared_ptr<pmap_interface> pmap,
          const VariableList& target_vars)
      {
        if(target_vars.dim()) {
          derived().init_vars(target_vars);
          derived().init_struct(target_vars);
        } else {
          derived().init_vars();
          derived().init_struct(vars_);
        }

        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 VariableList& target_vars) {
        if(target_vars != vars_) {
          perm_ = derived().make_perm(target_vars);
          trange_ = derived().make_trange(perm_);
          shape_ = derived().make_shape(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;
      }


      Permutation make_perm(const VariableList& target_vars) const {
        return target_vars.permutation(vars_);
      }


      op_type make_op() const {
        if(perm_ && permute_tiles_)
          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 VariableList& vars() const { return vars_; }


      const Permutation& 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 VariableList& target_vars) const {
        if(perm_) {
          os << "[P " << target_vars << "]" << (permute_tiles_ ? " " : " [no permute tiles] ")
              << derived().make_tag() << vars_ << "\n";
        } else {
          os << derived().make_tag() << vars_ << "\n";
        }
      }


      const char* make_tag() const { return ""; }

    }; // class ExprEngine

  }  // namespace expressions
} // namespace TiledArray

#endif // TILEDARRAY_EXPRESSIONS_EXPR_ENGINE_H__INCLUDED