ctr_comm.h

Go to the documentation of this file.

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

#ifndef __CTR_COMM_H__
#define __CTR_COMM_H__

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

namespace CTF_int{
  class contraction;
  
  class bivar_function {
    public:
      bool has_kernel;
      bool has_off_gemm;
      bool commutative;
      bool left_distributive;
      bool right_distributive;

      virtual void apply_f(char const * a, char const * b, char * c) const = 0;
      
      virtual void acc_f(char const * a, char const * b, char * c, CTF_int::algstrct const * sr_C) const = 0;


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

      Bifun_Term operator()(Term const & A, Term const & B) const;
     
      bivar_function(bool is_comm=false,
                     bool is_left_dist=false,
                     bool is_right_dist=false){
        has_kernel = false;
        has_off_gemm = false;
        commutative = is_comm;
        left_distributive = is_left_dist;
        right_distributive = is_right_dist;
      }

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

      virtual void cgemm(char         tA,
                         char         tB,
                         int          m,
                         int          n,
                         int          k,
                         char const * A,
                         char const * B,
                         char *       C)  const {}

      virtual void coffload_gemm(char         tA,
                                 char         tB,
                                 int          m,
                                 int          n,
                                 int          k,
                                 char const * A,
                                 char const * B,
                                 char *       C) const { assert(0); }

    virtual void ccoomm(int          m,
                        int          n,
                        int          k,
                        char const * A,
                        int const *  rows_A,
                        int const *  cols_A,
                        int64_t      nnz_A,
                        char const * B,
                        char *       C) const { assert(0); }


    virtual void ccsrmm
               (int              m,
                int              n,
                int              k,
                char const *     A,
                int const *      JA,
                int const *      IA,
                int64_t          nnz_A,
                char const *     B,
                char *           C,
                algstrct const * sr_C) const { assert(0); }

    virtual void ccsrmultd
                 (int              m,
                  int              n,
                  int              k,
                  char const *     A,
                  int const *      JA,
                  int const *      IA,
                  int              nnz_A,
                  char const *     B,
                  int const *      JB,
                  int const *      IB,
                  int              nnz_B,
                  char *           C,
                  algstrct const * sr_C) const { assert(0); }

    virtual void ccsrmultcsr
              (int              m,
               int              n,
               int              k,
               char const *     A,
               int const *      JA,
               int const *      IA,
               int              nnz_A,
               char const *     B,
               int const *      JB,
               int const *      IB,
               int              nnz_B,
               char *&          C_CSR,
               algstrct const * sr_C) const { assert(0); }


    virtual void coffload_csrmm(int          m,
                                int          n,
                                int          k,
                                char const * all_data,
                                char const * B,
                                char *       C) const { assert(0); }


  };

  class ctr {
    public: 
      algstrct const * sr_A;
      algstrct const * sr_B;
      algstrct const * sr_C;
      char const * beta;
      int num_lyr; /* number of copies of this matrix being computed on */
      int idx_lyr; /* the index of this copy */

      virtual void run(char * A, char * B, char * C) { printf("SHOULD NOTR\n"); };
      virtual void print() { };
      virtual int64_t mem_fp() { return 0; };
      virtual int64_t mem_rec() { return mem_fp(); };
      virtual double est_time_fp(int nlyr) { return 0; };
      virtual double est_time_rec(int nlyr) { return est_time_fp(nlyr); };
      virtual ctr * clone() { return NULL; };
      
      virtual ~ctr();
    
      ctr(ctr * other);
      
      ctr(contraction const * c);
  };

  class ctr_replicate : public ctr {
    public: 
      int ncdt_A; /* number of processor dimensions to replicate A along */
      int ncdt_B; /* number of processor dimensions to replicate B along */
      int ncdt_C; /* number of processor dimensions to replicate C along */
      int64_t size_A; /* size of A blocks */
      int64_t size_B; /* size of B blocks */
      int64_t size_C; /* size of C blocks */

      CommData ** cdt_A;
      CommData ** cdt_B;
      CommData ** cdt_C;
      /* Class to be called on sub-blocks */
      ctr * rec_ctr;
      
      void run(char * A, char * B, char * C);
      int64_t mem_fp();
      int64_t mem_rec();
      double est_time_fp(int nlyr);
      double est_time_rec(int nlyr);
      void print();
      ctr * clone();

      ctr_replicate(ctr * other);
      ~ctr_replicate();
      ctr_replicate(contraction const * c,
                    int const *         phys_mapped,
                    int64_t             blk_sz_A,
                    int64_t             blk_sz_B,
                    int64_t             blk_sz_C);
  };
}
#endif // __CTR_COMM_H__