spctr_2d_general.h

Go to the documentation of this file.

/*Copyright (c) 2011, Edgar Solomonik, all rights reserved.*/
#include "spctr_comm.h"

#ifndef __SPCTR_2D_GENERAL_H__
#define __SPCTR_2D_GENERAL_H__

namespace CTF_int{
  class tensor;
  int  spctr_2d_gen_build(int                        is_used,
                          CommData                   global_comm,
                          int                        i,
                          int *                      virt_dim,
                          int &                      cg_edge_len,
                          int &                      total_iter,
                          tensor *                   A,
                          int                        i_A,
                          CommData *&                cg_cdt_A,
                          int64_t &                  cg_spctr_lda_A,
                          int64_t &                  cg_spctr_sub_lda_A,
                          bool &                     cg_move_A,
                          int *                      blk_len_A,
                          int64_t &                  blk_sz_A,
                          int const *                virt_blk_len_A,
                          int &                      load_phase_A,
                          tensor *                   B,
                          int                        i_B,
                          CommData *&                cg_cdt_B,
                          int64_t &                  cg_spctr_lda_B,
                          int64_t &                  cg_spctr_sub_lda_B,
                          bool &                     cg_move_B,
                          int *                      blk_len_B,
                          int64_t &                  blk_sz_B,
                          int const *                virt_blk_len_B,
                          int &                      load_phase_B,
                          tensor *                   C,
                          int                        i_C,
                          CommData *&                cg_cdt_C,
                          int64_t &                  cg_spctr_lda_C,
                          int64_t &                  cg_spctr_sub_lda_C,
                          bool &                     cg_move_C,
                          int *                      blk_len_C,
                          int64_t &                  blk_sz_C,
                          int const *                virt_blk_len_C,
                          int &                      load_phase_C);


  class spctr_2d_general : public spctr {
    public: 
      int edge_len;

      int64_t ctr_lda_A; /* local lda_A of contraction dimension 'k' */
      int64_t ctr_sub_lda_A; /* elements per local lda_A 
                            of contraction dimension 'k' */
      int64_t ctr_lda_B; /* local lda_B of contraction dimension 'k' */
      int64_t ctr_sub_lda_B; /* elements per local lda_B 
                            of contraction dimension 'k' */
      int64_t ctr_lda_C; /* local lda_C of contraction dimension 'k' */
      int64_t ctr_sub_lda_C; /* elements per local lda_C 
                            of contraction dimension 'k' */
      int64_t dns_vrt_sz_A; /* size of each block of A when stored as dense, needed for time estimation given nnz frac */
      int64_t dns_vrt_sz_B; /* size of each block of A when stored as dense, needed for time estimation given nnz frac */
      int64_t dns_vrt_sz_C; /* size of each block of A when stored as dense, needed for time estimation given nnz frac */
  #ifdef OFFLOAD
      bool alloc_host_buf;
  #endif

      bool move_A;
      bool move_B;
      bool move_C;

      CommData * cdt_A;
      CommData * cdt_B;
      CommData * cdt_C;
      /* Class to be called on sub-blocks */
      spctr * rec_ctr;
      
      void print();
      void run(char * A, int nblk_A, int64_t const * size_blk_A,
               char * B, int nblk_B, int64_t const * size_blk_B,
               char * C, int nblk_C, int64_t * size_blk_C,
               char *& new_C);

      int64_t spmem_fp(double nnz_frac_A, double nnz_frac_B, double nnz_frac_C);
      int64_t spmem_rec(double nnz_frac_A, double nnz_frac_B, double nnz_frac_C);
      double est_time_fp(int nlyr, double nnz_frac_A, double nnz_frac_B, double nnz_frac_C);

      double est_time_rec(int nlyr, double nnz_frac_A, double nnz_frac_B, double nnz_frac_C);

      spctr * clone();
/*      void set_size_blk_A(int new_nblk_A, int64_t const * nnbA){
        spctr::set_size_blk_A(new_nblk_A, nnbA);
        rec_ctr->set_size_blk_A(new_nblk_A, nnbA);
      }*/

      void find_bsizes(int64_t & b_A,
                       int64_t & b_B,
                       int64_t & b_C,
                       int64_t & s_A,
                       int64_t & s_B,
                       int64_t & s_C,
                       int64_t & aux_size);
      spctr_2d_general(spctr * other);
      ~spctr_2d_general();
      spctr_2d_general(contraction * c) : spctr(c){ move_A=0; move_B=0; move_C=0; }
  };
}

#endif