common.h

Go to the documentation of this file.

#ifndef __COMMON_H__
#define __COMMON_H__
#include <string.h>
#include <string>
#include <stdio.h>
#include <assert.h>
#include <stdint.h>
#include <math.h>
#include <algorithm>
#include <list>
#include <vector>
#include <complex>
#include <unistd.h>
#include <iostream>
#include <limits.h>
#include <random>

#include <mpi.h>
#include "../shared/model.h"

//enum SYM : int { NS, SY, AS, SH };
enum STRUCTURE : int { NS, SY, AS, SH, SP };
typedef STRUCTURE SYM;

namespace CTF {
  extern int DGTOG_SWITCH;

  enum OP { OP_SUM, OP_SUMABS, OP_SUMSQ, OP_MAX, OP_MIN, OP_MAXABS, OP_MINABS};

}


namespace CTF_int {
  void init_rng(int rank);

  double get_rand48();



  void handler();
  #define IASSERT(...)                \
  do { if (!(__VA_ARGS__)){ int rank; MPI_Comm_rank(MPI_COMM_WORLD,&rank); if (rank == 0){ printf("CTF ERROR: %s:%d, ASSERT(%s) failed\n",__FILE__,__LINE__,#__VA_ARGS__); } CTF_int::handler(); assert(__VA_ARGS__); } } while (0)

  int64_t sy_packed_size(int order, const int* len, const int* sym);


  int64_t packed_size(int order, const int* len, const int* sym);


  enum { SUCCESS, ERROR, NEGATIVE };

  template <typename type=char>
  int conv_idx(int          order,
               type const * cidx,
               int **       iidx);

  template <typename type=char>
  int conv_idx(int          order_A,
               type const * cidx_A,
               int **       iidx_A,
               int          order_B,
               type const * cidx_B,
               int **       iidx_B);

  template <typename type=char>
  int conv_idx(int          order_A,
               type const * cidx_A,
               int **       iidx_A,
               int          order_B,
               type const * cidx_B,
               int **       iidx_B,
               int          order_C,
               type const * cidx_C,
               int **       iidx_C);

  void flops_add(int64_t n);

  int64_t get_flops();

  class CommData {
    public:
      MPI_Comm cm;
      int np;
      int rank;
      int color;
      int alive;
      int created;
  
      CommData();
      ~CommData();

      CommData(CommData const & other);
      CommData& operator=(CommData const & other);

      CommData(MPI_Comm cm);

      CommData(int rank, int color, int np);

      CommData(int rank, int color, CommData parent);

      void activate(MPI_Comm parent);

      /* \brief deactivate (MPI_Free) this comm */
      void deactivate();
     
      /* \brief provide estimate of broadcast execution time */
      double estimate_bcast_time(int64_t msg_sz);
   
      /* \brief provide estimate of allreduction execution time */
      double estimate_allred_time(int64_t msg_sz, MPI_Op op);
     
      /* \brief provide estimate of reduction execution time */
      double estimate_red_time(int64_t msg_sz, MPI_Op op);
     
      /* \brief provide estimate of sparse reduction execution time */
//      double estimate_csrred_time(int64_t msg_sz, MPI_Op op);
     
      /* \brief provide estimate of all_to_all execution time */
      double estimate_alltoall_time(int64_t chunk_sz);
     
      /* \brief provide estimate of all_to_all_v execution time */
      double estimate_alltoallv_time(int64_t tot_sz);

      void bcast(void * buf, int64_t count, MPI_Datatype mdtype, int root);

      void allred(void * inbuf, void * outbuf, int64_t count, MPI_Datatype mdtype, MPI_Op op);

      void red(void * inbuf, void * outbuf, int64_t count, MPI_Datatype mdtype, MPI_Op op, int root);

      void all_to_allv(void *          send_buffer, 
                       int64_t const * send_counts,
                       int64_t const * send_displs,
                       int64_t         datum_size,
                       void *          recv_buffer, 
                       int64_t const * recv_counts,
                       int64_t const * recv_displs);

  };

  int  alloc_ptr(int64_t len, void ** const ptr);
  int  mst_alloc_ptr(int64_t len, void ** const ptr);
  void * alloc(int64_t len);
  void * mst_alloc(int64_t len);
  int cdealloc(void * ptr);


  void cvrt_idx(int         order,
                int const * lens,
                int64_t     idx,
                int **      idx_arr);

  void cvrt_idx(int         order,
                int const * lens,
                int64_t     idx,
                int *       idx_arr);

  void cvrt_idx(int         order,
                int const * lens,
                int const * idx_arr,
                int64_t *   idx);

  bool get_mpi_dt(int64_t count, int64_t datum_size, MPI_Datatype & dt);


}
#endif