starsh.h

Go to the documentation of this file.

#ifndef __STARSH_H__
#define __STARSH_H__

// Add definitions for size_t and ssize_t.
#include <sys/types.h>

// Add definition for va_args.
#include <stdarg.h>

// Add definitions for enumerated constants.
#include "starsh-constants.h"


//                                ENVIRONMENT                                //

// This will automatically include all entities between @{ and @} into group.

struct starsh_params
{
    enum STARSH_BACKEND backend;
    enum STARSH_LRENGINE lrengine;
    int oversample;
};

extern struct starsh_params starsh_params;

int starsh_init();
int starsh_set_backend(const char *string);
int starsh_set_lrengine(const char *string);
int starsh_set_oversample(const char *string);

// End of group


//                                 TYPEDEF                                   //

typedef ssize_t STARSH_int;

typedef void STARSH_kernel(int nrows, int ncols, STARSH_int *irow,
        STARSH_int *icol, void *row_data, void *col_data, void *result,
        int ld);

typedef struct array Array;

typedef struct starsh_problem STARSH_problem;

typedef struct starsh_cluster STARSH_cluster;

typedef struct starsh_blrf STARSH_blrf;

typedef struct starsh_blrm STARSH_blrm;


//                               APPLICATIONS                                //

// This will automatically include all entities between @{ and @} into group.

int starsh_application(void **data, STARSH_kernel **kernel, STARSH_int count,
        char dtype, int problem_type, int kernel_type, ...);

// End of group


//                                   ARRAY                                   //

// This will automatically include all entities between @{ and @} into group.

struct array

{
    int ndim;
    int *shape;
    ssize_t *stride;
    char order;

    size_t size;
    char dtype;

    size_t dtype_size;
    size_t nbytes;
    size_t data_nbytes;
    void *data;
};

int array_from_buffer(Array **A, int ndim, int *shape, char dtype, char order,
        void *buffer);
int array_new(Array **A, int ndim, int *shape, char dtype, char order);
int array_new_like(Array **A, Array *B);
int array_new_copy(Array **A, Array *B, char order);
void array_free(Array *A);
void array_info(Array *A);
void array_print(Array *A);
int array_to_matrix(Array *A, char kind);
int array_trans_inplace(Array *A);
int array_dot(Array* A, Array *B, Array **C);
int array_SVD(Array *A, Array **U, Array **S, Array **V);
int SVD_get_rank(Array *S, double tol, char type, int *rank);
int array_scale(Array *A, char kind, Array *S);
int array_diff(Array *A, Array *B, double *result);
int array_norm(Array *A, double *result);
int array_convert(Array **A, Array *B, char dtype);
int array_cholesky(Array *A, char uplo);

// End of group


//                                  PROBLEM                                  //

// This will automatically include all entities between @{ and @} into group.

struct starsh_problem

{
    int ndim;

    STARSH_int *shape;

    char symm;
    char dtype;

    size_t dtype_size;
    size_t entry_size;

    void *row_data;
    void *col_data;
    STARSH_kernel *kernel;

    char *name;
};

int starsh_problem_new(STARSH_problem **problem, int ndim, STARSH_int *shape,
        char symm, char dtype, void *row_data, void *col_data,
        STARSH_kernel *kernel, char *name);
void starsh_problem_free(STARSH_problem *problem);
void starsh_problem_info(STARSH_problem *problem);
int starsh_problem_get_block(STARSH_problem *problem, int nrows, int ncols,
        STARSH_int *irow, STARSH_int *icol, Array **A);
int starsh_problem_from_array(STARSH_problem **problem, Array *A, char symm);
int starsh_problem_to_array(STARSH_problem *problem, Array **A);

// End of group


//                                  CLUSTER                                  //

// This will automatically include all entities between @{ and @} into group.

struct starsh_cluster
{
    void *data;
    STARSH_int ndata;

    STARSH_int *pivot;

    STARSH_int nblocks;
    STARSH_int nlevels;

    STARSH_int *level;

    STARSH_int *start;

    STARSH_int *size;
    STARSH_int *parent;

    STARSH_int *child_start;

    STARSH_int *child;

    enum STARSH_CLUSTER_TYPE type;
};

int starsh_cluster_new(STARSH_cluster **cluster, void *data, STARSH_int ndata,
        STARSH_int *pivot, STARSH_int nblocks, STARSH_int nlevels,
        STARSH_int *level, STARSH_int *start, STARSH_int *size,
        STARSH_int *parent, STARSH_int *child_start, STARSH_int *child,
        enum STARSH_CLUSTER_TYPE type);
void starsh_cluster_free(STARSH_cluster *cluster);
void starsh_cluster_info(STARSH_cluster *cluster);
int starsh_cluster_new_plain(STARSH_cluster **cluster, void *data,
        STARSH_int ndata, STARSH_int block_size);

// End of group


//                                H-FORMAT                                   //

// This will automatically include all entities between @{ and @} into group.

struct starsh_blrf

{
    STARSH_problem *problem;
    char symm;
    STARSH_cluster *row_cluster;
    STARSH_cluster *col_cluster;
    STARSH_int nbrows;
    STARSH_int nbcols;
    STARSH_int nblocks_far;
    STARSH_int *block_far;

    STARSH_int *brow_far_start;

    STARSH_int *brow_far;

    STARSH_int *bcol_far_start;

    STARSH_int *bcol_far;

    STARSH_int nblocks_far_local;
    STARSH_int *block_far_local;
    STARSH_int nblocks_near;

    STARSH_int *block_near;

    STARSH_int *brow_near_start;

    STARSH_int *brow_near;

    STARSH_int *bcol_near_start;

    STARSH_int *bcol_near;

    STARSH_int nblocks_near_local;
    STARSH_int *block_near_local;
    enum STARSH_BLRF_TYPE type;
};

int starsh_blrf_new(STARSH_blrf **format, STARSH_problem *problem, char symm,
        STARSH_cluster *row_cluster, STARSH_cluster *col_cluster,
        STARSH_int nbrows, STARSH_int nbcols, STARSH_int nblocks_far,
        STARSH_int *block_far, STARSH_int *brow_far_start,
        STARSH_int *brow_far, STARSH_int *bcol_far_start,
        STARSH_int *bcol_far, STARSH_int nblocks_far_local,
        STARSH_int *block_far_local, STARSH_int nblocks_near,
        STARSH_int *block_near, STARSH_int *brow_near_start,
        STARSH_int *brow_near, STARSH_int *bcol_near_start,
        STARSH_int *bcol_near, STARSH_int nblocks_near_local,
        STARSH_int *block_near_local, enum STARSH_BLRF_TYPE type);
int starsh_blrf_new_from_coo(STARSH_blrf **format, STARSH_problem *problem,
        char symm, STARSH_cluster *row_cluster, STARSH_cluster *col_cluster,
        STARSH_int nblocks_far, STARSH_int *block_far,
        STARSH_int nblocks_near, STARSH_int *block_near,
        enum STARSH_BLRF_TYPE type);
int starsh_blrf_new_tlr(STARSH_blrf **format, STARSH_problem *problem,
        char symm, STARSH_cluster *row_cluster, STARSH_cluster *col_cluster);
void starsh_blrf_free(STARSH_blrf *format);
void starsh_blrf_info(STARSH_blrf *format);
void starsh_blrf_print(STARSH_blrf *format);
int starsh_blrf_get_block(STARSH_blrf *format, STARSH_int i, STARSH_int j,
        int *shape, void **D);

// End of group


//                                H-MATRIX                                   //

// This will automatically include all entities between @{ and @} into group.

struct starsh_blrm

{
    STARSH_blrf *format;
    int *far_rank;
    Array **far_U;

    Array **far_V;

    int onfly;
    Array **near_D;
    void *alloc_U;
    void *alloc_V;
    void *alloc_D;
    char alloc_type;

    size_t nbytes;
    size_t data_nbytes;
};

int starsh_blrm_new(STARSH_blrm **matrix, STARSH_blrf *format, int *far_rank,
        Array **far_U, Array **far_V, int onfly, Array **near_D, void *alloc_U,
        void *alloc_V, void *alloc_D, char alloc_type);
void starsh_blrm_free(STARSH_blrm *matrix);
void starsh_blrm_info(STARSH_blrm *matrix);
int starsh_blrm_get_block(STARSH_blrm *matrix, STARSH_int i, STARSH_int j,
        int *shape, int *rank, void **U, void **V, void **D);

// End of group


//                            APPROXIMATIONS                                 //

// This will automatically include all entities between @{ and @} into group.

typedef int STARSH_blrm_approximate(STARSH_blrm **matrix, STARSH_blrf *format,
        int maxrank, double tol, int onfly);
extern STARSH_blrm_approximate *starsh_blrm_approximate;

int starsh_blrm__dsdd(STARSH_blrm **matrix, STARSH_blrf *format, int maxrank,
        double tol, int onfly);
int starsh_blrm__drsdd(STARSH_blrm **matrix, STARSH_blrf *format, int maxrank,
        double tol, int onfly);
int starsh_blrm__dqp3(STARSH_blrm **matrix, STARSH_blrf *format, int maxrank,
        double tol, int onfly);
//int starsh_blrm__dna(STARSH_blrm **matrix, STARSH_blrf *format, int maxrank,
//        double tol, int onfly);

int starsh_blrm__dsdd_omp(STARSH_blrm **matrix, STARSH_blrf *format,
        int maxrank, double tol, int onfly);
int starsh_blrm__drsdd_omp(STARSH_blrm **matrix, STARSH_blrf *format,
        int maxrank, double tol, int onfly);
int starsh_blrm__dqp3_omp(STARSH_blrm **matrix, STARSH_blrf *format,
        int maxrank, double tol, int onfly);
//int starsh_blrm__dna_omp(STARSH_blrm **matrix, STARSH_blrf *format,
//        int maxrank, double tol, int onfly);

// End of group


//                  MATRIX-MATRIX MULTIPLICATION                             //

// This will automatically include all entities between @{ and @} into group.

int starsh_blrm__dmml(STARSH_blrm *matrix, int nrhs, double alpha,
        double *A, int lda, double beta, double *B, int ldb);
int starsh_blrm__dmml_omp(STARSH_blrm *matrix, int nrhs, double alpha,
        double *A, int lda, double beta, double *B, int ldb);

// End of group


//                   MEASURE APPROXIMATION ERROR                             //

// This will automatically include all entities between @{ and @} into group.

double starsh_blrm__dfe(STARSH_blrm *matrix);
double starsh_blrm__dfe_omp(STARSH_blrm *matrix);

// This function should not be in this group, but it is for now.
int starsh_blrm__dca(STARSH_blrm *matrix, Array *A);

// End of group


//                  LOW-RANK ROUTINES FOR DENSE                              //

// This will automatically include all entities between @{ and @} into group.

int starsh_dense_dsvfr(int size, double *S, double tol);

void starsh_dense_dlrsdd(int nrows, int ncols, double *D, int ldD, double *U,
        int ldU, double *V, int ldV, int *rank, int maxrank, double tol,
        double *work, int lwork, int *iwork);
void starsh_dense_dlrrsdd(int nrows, int ncols, double *D, int ldD, double *U,
        int ldU, double *V, int ldV, int *rank, int maxrank, int oversample,
        double tol, double *work, int lwork, int *iwork);
void starsh_dense_dlrqp3(int nrows, int ncols, double *D, int ldD, double *U,
        int ldU, double *V, int ldV, int *rank, int maxrank, int oversample,
        double tol, double *work, int lwork, int *iwork);
void starsh_dense_dlrna(int nrows, int ncols, double *D, double *U, double *V,
        int *rank, int maxrank, double tol, double *work, int lwork,
        int *iwork);

// End of group


//                            ITERATIVE SOLVERS                              //

// This will automatically include all entities between @{ and @} into group.

int starsh_itersolvers__dcg_omp(STARSH_blrm *matrix, int nrhs, double *B,
        int ldb, double *X, int ldx, double tol, double *work);

// End of group


//                       HEADERS FOR OTHER BACKENDS                          //

// This headers should be at the end, since all Doxygen groups must be defined
// before (and they are defined above).
#include "starsh-mpi.h"
#include "starsh-starpu.h"
#include "starsh-mpi-starpu.h"


#endif // __STARSH_H__