untyped_tensor.h

Go to the documentation of this file.

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

#ifndef __UNTYPED_TENSOR_H__
#define __UNTYPED_TENSOR_H__

#include "../mapping/mapping.h"
#include "../mapping/distribution.h"
#include "../interface/world.h"
#include "../interface/partition.h"
#include "algstrct.h"
#include <functional>

namespace CTF {
  class Idx_Tensor;
}

namespace CTF_int {

  class tensor {
    protected:
      void init(algstrct const * sr,
                int              order,
                int const *      edge_len,
                int const *      sym,
                CTF::World *     wrld,
                bool             alloc_data,
                char const *     name,
                bool             profile,
                bool             is_sparse);
      PairIterator read_all_pairs(int64_t * num_pair, bool unpack);

      void copy_tensor_data(tensor const * other);

      void set_distribution(char const *               idx,
                            CTF::Idx_Partition const & prl,
                            CTF::Idx_Partition const & blk);

    public:

      CTF::World * wrld;
      algstrct * sr;
      int * sym;
      int order;
      int * lens;
      int * pad_edge_len;
      int * padding;
      char * name;
      int is_scp_padded;
      int * scp_padding;
      int * sym_table;
      bool is_mapped;
      topology * topo;
      mapping * edge_map;
      int64_t size;
      int64_t registered_alloc_size;
      bool is_folded;
      int * inner_ordering;
      tensor * rec_tsr;
      bool is_cyclic;
      bool is_data_aliased;
      tensor * slay;
      bool has_zero_edge_len;
      char * data;
      bool has_home;
      char * home_buffer;
      int64_t home_size;
      bool is_home;
      bool left_home_transp;
      bool profile;
      bool is_sparse;
      bool is_csr;
      int nrow_idx;
      int64_t nnz_loc;
      int64_t nnz_tot;
      int64_t * nnz_blk;

      CTF::Idx_Tensor operator[](char const * idx_map);

      tensor();

      ~tensor();

      void free_self();

      tensor(algstrct const * sr,
             int              order,
             int const *      edge_len,
             int const *      sym,
             CTF::World *     wrld,
             bool             alloc_data=true,
             char const *     name=NULL,
             bool             profile=1,
             bool             is_sparse=0);

      tensor(algstrct const *           sr,
             int                        order,
             bool                       is_sparse,
             int const *                edge_len,
             int const *                sym,
             CTF::World *               wrld,
             char const *               idx,
             CTF::Idx_Partition const & prl,
             CTF::Idx_Partition const & blk,
             char const *               name=NULL,
             bool                       profile=1);

      tensor(tensor const * other, bool copy = 1, bool alloc_data = 1);

      tensor(tensor * other, int const * new_sym);

      int * calc_phase() const;

      int calc_tot_phase() const;

      int64_t calc_nvirt() const;

      int64_t calc_npe() const;


      void set_padding();

      int set_zero();

      int set(char const * val);

      int zero_out_padding();

      void scale_diagonals(int const * sym_mask);

      // apply an additive inverse to all elements of the tensor
      void addinv();

      void print_map(FILE * stream=stdout, bool allcall=1) const;

      void set_name(char const * name);

      char const * get_name() const;

      void profile_on();

      void profile_off();


      void get_raw_data(char ** data, int64_t * size) const;

       int write(int64_t      num_pair,
                 char const * alpha,
                 char const * beta,
                 char *       mapped_data,
                 char const   rw='w');

        void write(int64_t         num_pair,
                   char const *    alpha,
                   char const *    beta,
                   int64_t const * inds,
                   char const *    data);

      void read(int64_t         num_pair,
                char const *    alpha,
                char const *    beta,
                int64_t const * inds,
                char *          data);

      int read(int64_t      num_pair,
               char const * alpha,
               char const * beta,
               char *       mapped_data);


      char * read(char const *               idx,
                  CTF::Idx_Partition const & prl,
                  CTF::Idx_Partition const & blk,
                  bool                       unpack);

      int read(int64_t num_pair,
               char *  mapped_data);

      int64_t get_tot_size(bool packed);

      int allread(int64_t * num_pair,
                  char **   all_data,
                  bool      unpack);

      int allread(int64_t * num_pair,
                  char *    all_data,
                  bool      unpack=true);

      void slice(int const *  offsets_B,
                 int const *  ends_B,
                 char const * beta,
                 tensor  *    A,
                 int const *  offsets_A,
                 int const *  ends_A,
                 char const * alpha);

      /* Same as above, except tid_B lives on dt_other_B */
/*      int slice_tensor(int            tid_A,
                       int const *    offsets_A,
                       int const *    ends_A,
                       char const *   alpha,
                       int            tid_B,
                       int const *    offsets_B,
                       int const *    ends_B,
                       char const *   beta,
                       world *        dt_other_B);
*/
      int permute(tensor *      A,
                  int * const * permutation_A,
                  char const *  alpha,
                  int * const * permutation_B,
                  char const *  beta);

      int sparsify(char const * threshold=NULL,
                   bool         take_abs=true);

      int sparsify(std::function<bool(char const*)> f);

      int read_local(int64_t * num_pair,
                     char **   mapped_data,
                     bool      unpack_sym=false) const;

      int read_local_nnz(int64_t * num_pair,
                         char **   mapped_data,
                         bool      unpack_sym=false) const;

      void read_local(int64_t *  num_pair,
                      int64_t ** inds,
                      char **    data,
                      bool       unpack_sym=false) const;

      void read_local_nnz(int64_t * num_pair,
                          int64_t ** inds,
                          char **    data,
                          bool      unpack_sym=false) const;


      //int copy(tensor * A);

      int align(tensor const * B);

      /* product will contain the dot prodiuct if tsr_A and tsr_B */
      //int dot_tensor(int tid_A, int tid_B, char *product);

      int reduce_sum(char * result);

      int reduce_sum(char * result, algstrct const * sr_other);

      int reduce_sumabs(char * result);

      int reduce_sumabs(char * result, algstrct const * sr_other) ;


      int reduce_sumsq(char * result);

      /* map data of tid_A with the given function */
/*      int map_tensor(int tid,
                     dtype (*map_func)(int order,
                                       int const * indices,
                                       dtype elem));*/
      int get_max_abs(int n, char * data) const;

      void print(FILE * fp = stdout, char const * cutoff = NULL) const;
      void prnt() const;

      void compare(const tensor * A, FILE * fp, char const * cutoff);

      void orient_subworld(CTF::World *    greater_world,
                           int &           bw_mirror_rank,
                           int &           fw_mirror_rank,
                           distribution *& odst,
                           char **         sub_buffer_);

      void add_to_subworld(tensor *     tsr_sub,
                           char const * alpha,
                           char const * beta);

      void add_from_subworld(tensor *     tsr_sub,
                             char const * alpha,
                             char const * beta);

      void unfold(bool was_mod=0);

      void remove_fold();


      double est_time_unfold();



      void fold(int         nfold,
                int const * fold_idx,
                int const * idx_map,
                int *       all_fdim,
                int **      all_flen);

      void pull_alias(tensor const * other);


      void clear_mapping();


      int redistribute(distribution const & old_dist,
                       int const *  old_offsets = NULL,
                       int * const * old_permutation = NULL,
                       int const *  new_offsets = NULL,
                       int * const * new_permutation = NULL);

      double est_redist_time(distribution const & old_dist, double nnz_frac);

      int64_t get_redist_mem(distribution const & old_dist, double nnz_frac);

      int map_tensor_rem(int        num_phys_dims,
                         CommData * phys_comm,
                         int        fill=0);

      int extract_diag(int const * idx_map,
                       int         rw,
                       tensor *&   new_tsr,
                       int **      idx_map_new);

      void set_sym(int const * sym);

      void set_new_nnz_glb(int64_t const * nnz_blk);

      void spmatricize(int m, int n, int nrow_idx, bool csr);

      void despmatricize(int nrow_idx, bool csr);

      void leave_home_with_buffer();

      void register_size(int64_t size);

      void deregister_size();

      void write_dense_to_file(MPI_File & file, int64_t offset=0);

      void write_dense_to_file(char const * filename);

      void read_dense_from_file(MPI_File & file, int64_t offset=0);


      void read_dense_from_file(char const * filename);

      template <typename dtype_A, typename dtype_B>
      void conv_type(tensor * B);

      template <typename dtype_A, typename dtype_B>
      void exp_helper(tensor * A);

      template <typename dtype>
      void compare_elementwise(tensor * A, tensor * B);
      
      template <typename dtype>
      void not_equals(tensor * A, tensor * B);

      template <typename dtype>
      void smaller_than(tensor * A, tensor * B);

      template <typename dtype>
      void smaller_equal_than(tensor * A, tensor * B);

      template <typename dtype>
      void larger_than(tensor * A, tensor * B);

      template <typename dtype>
      void larger_equal_than(tensor * A, tensor * B);

      template <typename dtype>
      void true_divide(tensor * A);

      tensor * self_reduce(int const * idx_A,
                           int **      new_idx_A,
                           int         order_B,
                           int const * idx_B,
                           int **      new_idx_B,
                           int         order_C=0,
                           int const * idx_C=NULL,
                           int **      new_idx_C=NULL);
  };
}
#endif// __UNTYPED_TENSOR_H__