sum_tsr.h

Go to the documentation of this file.

/*Copyright (c) 2011, Edgar Solomonik, all rights reserved.*/

#ifndef __SUM_TSR_H__
#define __SUM_TSR_H__

#include "../tensor/algstrct.h"
#include "../interface/fun_term.h"

namespace CTF_int {
  class summation;
  class univar_function {
    public:
      void (*f)(char const *, char *);

      bool is_distributive = false;

      virtual void apply_f(char const * a, char * b)const { f(a,b); }
      
      virtual void acc_f(char const * a, char * b, CTF_int::algstrct const * sr_B) const { 

        char tb[sr_B->el_size];
        f(a,tb);
        sr_B->add(b, tb, b);
      }

      virtual bool is_transform() const { return false; };

      univar_function(void (*f_)(char const *, char *)) { f=f_; }
      univar_function(void (*f_)(char const *, char *), bool is_dist) { f=f_; is_distributive=is_dist; }
      univar_function() { }
      univar_function(univar_function const & other) { f = other.f; is_distributive=other.is_distributive; }

      Unifun_Term operator()(Term const & A) const;

      void operator()(Term const & A, Term const & B) const;

      virtual ~univar_function(){}

      virtual bool is_accumulator() const { return false; }
  };


  class tsum {
    public:
      char *           A;
      algstrct const * sr_A;
      char const *     alpha;
      char *           B;
      algstrct const * sr_B;
      char const *     beta;
      void *           buffer;

      virtual void run() {};
      virtual void print() {};
//      virtual int64_t calc_new_nnz_B() { return nnz_B; } //if sparse
      virtual int64_t mem_fp() { return 0; };
      virtual tsum * clone() { return NULL; };
      virtual ~tsum();
      tsum(tsum * other);
      tsum(summation const * s);
  };

  class tsum_virt : public tsum {
    public: 
      /* Class to be called on sub-blocks */
      tsum * rec_tsum;

      int         num_dim;
      int *       virt_dim;
      int         order_A;
      int64_t     blk_sz_A; //if dense
      int const * idx_map_A;
      int         order_B;
      int64_t     blk_sz_B; //if dense
      int const * idx_map_B;
      
      void run();
      void print();
      int64_t mem_fp();
      tsum * clone();

      tsum_virt(tsum * other);
      ~tsum_virt();
      tsum_virt(summation const * s);
  };


  class tsum_replicate : public tsum {
    public: 
      int64_t size_A; /* size of A blocks */
      int64_t size_B; /* size of B blocks */
      int ncdt_A; /* number of processor dimensions to replicate A along */
      int ncdt_B; /* number of processor dimensions to replicate B along */

      CommData ** cdt_A;
      CommData ** cdt_B;
      /* Class to be called on sub-blocks */
      tsum * rec_tsum;
      
      void run();
      void print();
      int64_t mem_fp();
      tsum * clone();

      tsum_replicate(tsum * other);
      ~tsum_replicate();
      tsum_replicate(summation const * s,
                     int const *       phys_mapped,
                     int64_t           blk_sz_A,
                     int64_t           blk_sz_B);
  };

  class seq_tsr_sum : public tsum {
    public:
      int         order_A;
      int *       edge_len_A;
      int const * idx_map_A;
      int *       sym_A;
      int         order_B;
      int *       edge_len_B;
      int const * idx_map_B;
      int *       sym_B;
      //fseq_tsr_sum func_ptr;

      int is_inner;
      int inr_stride;

      int64_t map_pfx;

      int is_custom;
      univar_function const * func; //fseq_elm_sum custom_params;

      void run();
      void print();
      int64_t mem_fp();
      tsum * clone();

      seq_tsr_sum(tsum * other);
      ~seq_tsr_sum(){ CTF_int::cdealloc(edge_len_A), CTF_int::cdealloc(edge_len_B), 
                      CTF_int::cdealloc(sym_A), CTF_int::cdealloc(sym_B); };
      seq_tsr_sum(summation const * s);

  };

  void inv_idx(int         order_A,
               int const * idx_A,
               int         order_B,
               int const * idx_B,
               int *       order_tot,
               int **      idx_arr);

}

#endif // __SUM_TSR_H__