sparsemat.h

Go to the documentation of this file.

#ifndef GHOST_SPARSEMAT_H
#define GHOST_SPARSEMAT_H

#include "config.h"
#include "types.h"
#include "spmv.h"
#include "context.h"
#include "densemat.h"
#include "sparsemat_src.h"

#include <stdarg.h>

#define GHOST_SPARSEMAT_SORT_GLOBAL -1
#define GHOST_SPARSEMAT_SORT_LOCAL -2

typedef struct {
    ghost_lidx row;
    ghost_lidx nEntsInRow;
} ghost_sorting_helper;


typedef enum {
    GHOST_SPARSEMAT_SYMM_GENERAL = 1,
    GHOST_SPARSEMAT_SYMM_SYMMETRIC = 2,
    GHOST_SPARSEMAT_SYMM_SKEW_SYMMETRIC = 4,
    GHOST_SPARSEMAT_SYMM_HERMITIAN = 8
} ghost_sparsemat_symmetry;

typedef struct 
{
    ghost_gidx *col;
    void *val;
    ghost_lidx *rpt;
    size_t dtsize;
    ghost_gidx offs;
} 
ghost_sparsemat_rowfunc_crs_arg;
    
typedef struct ghost_sparsemat_traits ghost_sparsemat_traits;
typedef struct ghost_sparsemat ghost_sparsemat;

typedef struct{
    ghost_spmv_flags flags;
    void *alpha;
    void *beta;
    void *gamma;
    void *delta;
    void *eta;
    void *dot;
    ghost_densemat *z;
    ghost_lidx blocksz;
} 
ghost_spmv_opts;

typedef enum {
    GHOST_KACZ_DIRECTION_UNDEFINED,
    GHOST_KACZ_DIRECTION_FORWARD,
    GHOST_KACZ_DIRECTION_BACKWARD
}
ghost_kacz_direction;

typedef enum{
     GHOST_KACZ_NORMALIZE_YES = 0,
     GHOST_KACZ_NORMALIZE_NO = 1<<0,
     GHOST_KACZ_NORMALIZE_SAVE = 1<<1
}
ghost_kacz_normalize;

#ifdef __cplusplus
static inline ghost_kacz_normalize operator|(const ghost_kacz_normalize &a, const ghost_kacz_normalize &b) {
return static_cast<ghost_kacz_normalize>(static_cast<int>(a) | static_cast<int>(b));
}
static inline ghost_kacz_normalize operator&(const ghost_kacz_normalize &a, const ghost_kacz_normalize &b) {
return static_cast<ghost_kacz_normalize>(static_cast<int>(a) & static_cast<int>(b));
}
static inline ghost_kacz_normalize operator|=(ghost_kacz_normalize &a, const ghost_kacz_normalize &b) {
    a = static_cast<ghost_kacz_normalize>(static_cast<int>(a) | static_cast<int>(b));
    return a;
}
static inline ghost_kacz_normalize operator&=(ghost_kacz_normalize &a, const ghost_kacz_normalize &b) {
    a = static_cast<ghost_kacz_normalize>(static_cast<int>(a) & static_cast<int>(b));
    return a;
}
#endif


typedef enum{
     GHOST_KACZ_MODE_NORMAL,
     GHOST_KACZ_MODE_ECO,
     GHOST_KACZ_MODE_PERFORMANCE
}
ghost_kacz_mode;


typedef struct {
    void *omega;
    void *shift;// shift can be complex
    int num_shifts; //number of shifts provided
    ghost_kacz_direction direction;
    ghost_kacz_mode mode; 
    int best_block_size; //it provides the best block size if performance mode is set 
    ghost_kacz_normalize normalize;
    void *scale; //scaled values if normalize is on
    bool initialized; //internal flag
}
ghost_kacz_opts;

typedef struct {
    void *omega;
    void *shift;// shift can be complex
    int num_shifts; //number of shifts provided
    ghost_kacz_mode mode; 
    int best_block_size; //it provides the best block size if performance mode is set 
    ghost_kacz_normalize normalize;
    void *scale; //scaled values if normalize is on
    bool initialized; //internal flag
}
ghost_carp_opts; //no direction since forward followed by backward done


#define GHOST_SELL_CHUNKHEIGHT_ELLPACK 0

#define GHOST_SELL_CHUNKHEIGHT_AUTO -1

typedef struct 
{
    ghost_alignment alignment;
    ghost_implementation impl;
    ghost_datatype mdt;
    ghost_datatype vdt;
    int blocksz;
    int chunkheight;
    ghost_densemat_storage storage;

}
ghost_sellspmv_parameters;

typedef struct 
{
    ghost_alignment alignment;
    ghost_implementation impl;
    ghost_datatype mdt;
    ghost_datatype vdt;
    int blocksz;
    int chunkheight;
    ghost_densemat_storage storage;
    
    bool do_axpby;
    bool do_scale;
    bool do_vshift;
    bool do_dot_yy;
    bool do_dot_xy;
    bool do_dot_xx;
    bool do_chain_axpby;
    
}
ghost_cusellspmv_parameters;


typedef struct 
{
    ghost_alignment alignment;
    ghost_implementation impl;
    ghost_datatype mdt;
    ghost_datatype vdt;
    int blocksz;
    int chunkheight;
    ghost_densemat_storage storage;

    ghost_kacz_method method;

    int nshifts;

}
ghost_kacz_parameters;

extern const ghost_spmv_opts GHOST_SPMV_OPTS_INITIALIZER;
extern const ghost_kacz_opts GHOST_KACZ_OPTS_INITIALIZER;
extern const ghost_carp_opts GHOST_CARP_OPTS_INITIALIZER;


typedef ghost_error (*ghost_spmv_kernel)(ghost_densemat*, ghost_sparsemat *, ghost_densemat*, ghost_spmv_opts);
typedef ghost_error (*ghost_kacz_kernel)(ghost_densemat*, ghost_sparsemat *, ghost_densemat*, ghost_kacz_opts);
typedef ghost_error (*ghost_kacz_shift_kernel)(ghost_densemat*, ghost_densemat*, ghost_sparsemat *, ghost_densemat*, double, double, ghost_kacz_opts);


typedef enum {
    GHOST_SPARSEMAT_DEFAULT       = 0,
    GHOST_SPARSEMAT_HOST          = 1<<0,
    GHOST_SPARSEMAT_DEVICE        = 1<<1,
    GHOST_SPARSEMAT_NOT_PERMUTE_COLS = 1<<2,
    GHOST_SPARSEMAT_PERMUTE       = 1<<3,
    GHOST_SPARSEMAT_NOT_SORT_COLS    = 1<<4,
    GHOST_SPARSEMAT_NOT_STORE_SPLIT = 1<<5,
    GHOST_SPARSEMAT_NOT_STORE_FULL = 1<<6,
    GHOST_SPARSEMAT_SCOTCHIFY = 1<<7,
    GHOST_SPARSEMAT_SAVE_ORIG_COLS = 1<<8,
    GHOST_SPARSEMAT_COLOR = 1<<9,
    GHOST_SPARSEMAT_TRANSPOSE_MM = 1<<10,
    GHOST_SPARSEMAT_ZOLTAN = 1<<11,
    GHOST_SPARSEMAT_RCM = 1<<12,
    GHOST_SPARSEMAT_BLOCKCOLOR = 1<<13,
    GHOST_SOLVER_KACZ = 1<<14,
    GHOST_SPARSEMAT_SORT_ROWS = 1<<15,
    GHOST_SPARSEMAT_PERM_NO_DISTINCTION=1<<16,
    GHOST_SPARSEMAT_DIAG_FIRST=1<<17

} ghost_sparsemat_flags;

#define GHOST_SPARSEMAT_PERM_ANY (GHOST_SPARSEMAT_PERM_ANY_LOCAL|GHOST_SPARSEMAT_PERM_ANY_GLOBAL)
#define GHOST_SPARSEMAT_PERM_ANY_LOCAL (GHOST_SPARSEMAT_COLOR|GHOST_SPARSEMAT_RCM|GHOST_SPARSEMAT_BLOCKCOLOR|GHOST_SPARSEMAT_SORT_ROWS)
#define GHOST_SPARSEMAT_PERM_ANY_GLOBAL (GHOST_SPARSEMAT_SCOTCHIFY|GHOST_SPARSEMAT_ZOLTAN)

#ifdef __cplusplus
inline ghost_sparsemat_flags operator|(const ghost_sparsemat_flags &a,
        const ghost_sparsemat_flags &b)
{
    return static_cast<ghost_sparsemat_flags>(
            static_cast<int>(a) | static_cast<int>(b));
}

inline ghost_sparsemat_flags operator&(const ghost_sparsemat_flags &a,
        const ghost_sparsemat_flags &b)
{
    return static_cast<ghost_sparsemat_flags>(
            static_cast<int>(a) & static_cast<int>(b));
}
#endif


struct ghost_sparsemat_traits {
    ghost_sparsemat_flags flags;
    ghost_sparsemat_symmetry symmetry;
    int C;
    int T;
    const char * scotchStrat;
    ghost_lidx sortScope;
    ghost_datatype datatype;
    ghost_lidx opt_blockvec_width;
};

#ifdef GHOST_HAVE_MPI
#define GHOST_SCOTCH_STRAT_DEFAULT "n{ole=q{strat=g},ose=q{strat=g},osq=g,sep=m}"
#else
#define GHOST_SCOTCH_STRAT_DEFAULT "g"
#endif

extern const ghost_sparsemat_traits GHOST_SPARSEMAT_TRAITS_INITIALIZER;

struct ghost_sparsemat
{
    ghost_sparsemat_traits traits;
    ghost_sparsemat_traits splittraits[2];
    ghost_sparsemat *localPart;
    ghost_sparsemat *remotePart;
    ghost_context *context;
    char *name;
    char *val;
    ghost_lidx *col;
    ghost_lidx *chunkStart;
    ghost_lidx *chunkMin;
    ghost_lidx *chunkLen;
    ghost_lidx *chunkLenPadded;
    ghost_lidx *rowLen;
    ghost_lidx *rowLen4;
    ghost_lidx *rowLen2;
    ghost_lidx *rowLenPadded; 
    //ghost_cu_sell *cumat;
    char * cu_val;
    ghost_lidx * cu_col;
    ghost_lidx * cu_rowLen;
    ghost_lidx * cu_rowLenPadded;
    ghost_lidx * cu_chunkStart;
    ghost_lidx * cu_chunkLen;
    size_t elSize;
    ghost_gidx *col_orig;
    //ghost_lidx nrows;
    //ghost_lidx nrowsPadded;
    //ghost_gidx ncols;
    //ghost_lidx nnz;
    ghost_lidx nEnts;
    double avgRowBand;
    double avgAvgRowBand;
    double smartRowBand;
    ghost_gidx maxRowLen;
    ghost_gidx nMaxRows;
    double variance;
    double deviation;
    double cv;
    ghost_gidx *nzDist;
    ghost_lidx nchunks;
};

typedef struct 
{
    char *filename;
    ghost_datatype dt;
    ghost_sparsemat *mat;
} 
ghost_sparsemat_rowfunc_file_initargs;

#define SPM_NROWS(mat) mat->context->row_map->dim
#define SPM_NNZ(mat) mat->context->nnz
#define SPM_NCOLS(mat) mat->context->col_map->dim
#define SPM_GNCOLS(mat) mat->context->col_map->gdim
#define SPM_NROWSPAD(mat) mat->context->row_map->dimpad
#define SPM_NCHUNKS(mat) (mat->nchunks)


#ifdef __cplusplus
extern "C" {
#endif

    ghost_error ghost_sparsemat_create(ghost_sparsemat **mat, 
            ghost_context *ctx, ghost_sparsemat_traits *traits, 
            int nTraits);
    ghost_error ghost_sparsemat_info_string(char **str, ghost_sparsemat *matrix);
    ghost_error ghost_sparsemat_nnz(ghost_gidx *nnz, 
            ghost_sparsemat *mat);
    ghost_error ghost_sparsemat_nrows(ghost_gidx *nrows, 
            ghost_sparsemat *mat);
    const char * ghost_sparsemat_symmetry_string(ghost_sparsemat_symmetry symmetry);
    bool ghost_sparsemat_symmetry_valid(ghost_sparsemat_symmetry symmetry);
    ghost_error ghost_sparsemat_perm_scotch(ghost_context *ctx, ghost_sparsemat *mat);
    ghost_error ghost_sparsemat_perm_sort(ghost_context *ctx, ghost_sparsemat *mat, ghost_lidx scope);

    ghost_error ghost_sparsemat_perm_spmp(ghost_context *ctx, ghost_sparsemat *mat);

    ghost_error ghost_sparsemat_perm_color(ghost_context *ctx, ghost_sparsemat *mat);

    ghost_error ghost_sparsemat_blockColor(ghost_context *ctx, ghost_sparsemat *mat);
 
    ghost_error ghost_sparsemat_perm_zoltan(ghost_context *ctx, ghost_sparsemat *mat);
    ghost_error ghost_sparsemat_fromfile_common(ghost_sparsemat *mat, 
            char *matrixPath, ghost_lidx **rpt) ;
    ghost_error ghost_sparsematofile_header(ghost_sparsemat *mat,
            char *path);
    ghost_error ghost_sparsemat_registerrow(ghost_sparsemat *mat, 
            ghost_gidx row, ghost_gidx *col, ghost_lidx rowlen, 
            ghost_lidx stride);
    ghost_error ghost_sparsemat_registerrow_finalize(ghost_sparsemat *mat);

    void ghost_sparsemat_destroy(ghost_sparsemat *mat);
    ghost_error ghost_sell_spmv_selector(ghost_densemat *lhs, 
            ghost_sparsemat *mat, 
            ghost_densemat *rhs, 
            ghost_spmv_opts traits);
    ghost_error ghost_cu_sell_spmv_selector(ghost_densemat *lhs, 
            ghost_sparsemat *mat, 
            ghost_densemat *rhs, 
            ghost_spmv_opts traits);
    
    ghost_error ghost_sell_stringify_selector(ghost_sparsemat *mat, 
            char **str, int dense);
    ghost_error ghost_sparsemat_string(char **str, ghost_sparsemat *mat, int dense);
    ghost_error ghost_sparsemat_init_rowfunc(ghost_sparsemat *mat, ghost_sparsemat_src_rowfunc *src, ghost_mpi_comm mpicomm, double weight);

    ghost_error ghost_sparsemat_init_bin(ghost_sparsemat *mat, char *path, ghost_mpi_comm mpicomm, double weight);

    ghost_error ghost_sparsemat_init_mm(ghost_sparsemat *mat, char *path, ghost_mpi_comm mpicomm, double weight);

    ghost_error ghost_sparsemat_init_crs(ghost_sparsemat *mat, ghost_gidx offs, ghost_lidx n, ghost_gidx *col, void *val, ghost_lidx *rpt, ghost_mpi_comm mpicomm, double weight);
    
    ghost_error ghost_sparsemat_to_bin(ghost_sparsemat *mat, char *path);
    
    size_t ghost_sparsemat_bytesize(ghost_sparsemat *mat);
    
    ghost_error ghost_cu_sell_spmv_selector(ghost_densemat *lhs, 
            ghost_sparsemat *mat, 
            ghost_densemat *rhs, 
            ghost_spmv_opts traits);

    ghost_error ghost_cu_sell1_spmv_selector(ghost_densemat * lhs_in, 
            ghost_sparsemat *mat, ghost_densemat * rhs_in, ghost_spmv_opts traits);

     ghost_error ghost_sell_kacz_selector(ghost_densemat *x, ghost_sparsemat *mat, ghost_densemat *b, ghost_kacz_opts opts);

     ghost_error ghost_sell_kacz_shift_selector(ghost_densemat *x_real, ghost_densemat *x_imag, ghost_sparsemat *mat, ghost_densemat *b, double sigma_r, double sigma_i, ghost_kacz_opts opts);

    ghost_error ghost_kacz(ghost_densemat *x, ghost_sparsemat *mat, ghost_densemat *b, ghost_kacz_opts opts); 
    ghost_error ghost_kacz_mc(ghost_densemat *x, ghost_sparsemat *mat, ghost_densemat *b, ghost_kacz_opts opts);
    ghost_error ghost_kacz_rb(ghost_densemat *x, ghost_sparsemat *mat, ghost_densemat *b, ghost_kacz_opts opts);
    ghost_error ghost_kacz_bmc(ghost_densemat *x, ghost_sparsemat *mat, ghost_densemat *b, ghost_kacz_opts opts);
    ghost_error ghost_kacz_rb_with_shift(ghost_densemat *x, ghost_sparsemat *mat, ghost_densemat *b, double *shift_r,  ghost_kacz_opts opts);
    ghost_error ghost_carp(ghost_sparsemat *mat, ghost_densemat *x, ghost_densemat *b, ghost_carp_opts opts);
    ghost_error checker(ghost_sparsemat *mat);
    ghost_error split_transition(ghost_sparsemat *mat);
 
    ghost_error ghost_carp_init(ghost_sparsemat *mat, ghost_densemat *b, ghost_carp_opts *opts); 
    ghost_error ghost_carp_perf_init(ghost_sparsemat *mat, ghost_carp_opts *opts);
    void ghost_carp_destroy(ghost_carp_opts *opts); 
    ghost_error kacz_analyze_print(ghost_sparsemat *mat);
    
    ghost_error ghost_sparsemat_to_mm(char *path, ghost_sparsemat *mat);

    ghost_error ghost_context_comm_init(ghost_context *ctx, ghost_gidx *col_orig, ghost_sparsemat *mat, ghost_lidx *col, ghost_lidx *nhalo);

    ghost_error ghost_sparsemat_perm_global_cols(ghost_gidx *cols, ghost_lidx ncols, ghost_context *context);

 static inline int ghost_sparsemat_rowfunc_crs(ghost_gidx row, ghost_lidx *rowlen, ghost_gidx *col, void *val, void *crsdata)
{
    ghost_gidx *crscol = ((ghost_sparsemat_rowfunc_crs_arg *)crsdata)->col;
    ghost_lidx *crsrpt = ((ghost_sparsemat_rowfunc_crs_arg *)crsdata)->rpt;
    char *crsval = (char *)((ghost_sparsemat_rowfunc_crs_arg *)crsdata)->val;
    size_t dtsize = ((ghost_sparsemat_rowfunc_crs_arg *)crsdata)->dtsize;
    ghost_gidx offs = ((ghost_sparsemat_rowfunc_crs_arg *)crsdata)->offs;

    *rowlen = crsrpt[row-offs+1]-crsrpt[row-offs];
    memcpy(col,&crscol[crsrpt[row-offs]],*rowlen * sizeof(ghost_gidx));
    memcpy(val,&crsval[dtsize*crsrpt[row-offs]],*rowlen * dtsize);

    return 0;
}

//To calculate Bandwidth        
ghost_error calculate_bw(ghost_sparsemat *mat, void *matrixSource, ghost_sparsemat_src srcType);
ghost_error set_kacz_ratio(ghost_sparsemat *mat, void *matrixSource, ghost_sparsemat_src srcType); 

#ifdef __cplusplus
} 
#endif


#endif