plasma_descriptor.h

#ifndef ICL_PLASMA_DESCRIPTOR_H
#define ICL_PLASMA_DESCRIPTOR_H

#include "plasma_types.h"
#include "plasma_error.h"

#include <stdlib.h>
#include <assert.h>

#ifdef __cplusplus
extern "C" {
#endif

/***************************************************************************/
typedef struct {
    // matrix properties
    plasma_enum_t type;      
    plasma_enum_t uplo;      
    plasma_enum_t precision; 

    // pointer and offsets
    void *matrix; 
    size_t A21;   
    size_t A12;   
    size_t A22;   

    // tile parameters
    int mb; 
    int nb; 

    // main matrix parameters
    int gm;  
    int gn;  
    int gmt; 
    int gnt; 

    // submatrix parameters
    int i;  
    int j;  
    int m;  
    int n;  
    int mt; 
    int nt; 

    // submatrix parameters for a band matrix
    int kl;  
    int ku;  
    int klt; 
    int kut; 
} plasma_desc_t;

/******************************************************************************/
static inline size_t plasma_element_size(int type)
{
    switch (type) {
    case PlasmaByte:          return          1;
    case PlasmaInteger:       return   sizeof(int);
    case PlasmaRealFloat:     return   sizeof(float);
    case PlasmaRealDouble:    return   sizeof(double);
    case PlasmaComplexFloat:  return 2*sizeof(float);
    case PlasmaComplexDouble: return 2*sizeof(double);
    default: assert(0);
    }
}

/******************************************************************************/
static inline void *plasma_tile_addr_general(plasma_desc_t A, int m, int n)
{
    int mm = m + A.i/A.mb;
    int nn = n + A.j/A.nb;
    size_t eltsize = plasma_element_size(A.precision);
    size_t offset = 0;

    int lm1 = A.gm/A.mb;
    int ln1 = A.gn/A.nb;

    if (mm < lm1)
        if (nn < ln1)
            offset = A.mb*A.nb*(mm + (size_t)lm1 * nn);
        else
            offset = A.A12 + ((size_t)A.mb * (A.gn%A.nb) * mm);
    else
        if (nn < ln1)
            offset = A.A21 + ((size_t)A.nb * (A.gm%A.mb) * nn);
        else
            offset = A.A22;

    return (void*)((char*)A.matrix + (offset*eltsize));
}

/******************************************************************************/
static inline void *plasma_tile_addr_triangle(plasma_desc_t A, int m, int n)
{
    int mm = m + A.i/A.mb;
    int nn = n + A.j/A.nb;
    size_t eltsize = plasma_element_size(A.precision);
    size_t offset = 0;

    int lm1 = A.gm/A.mb;
    int ln1 = A.gn/A.nb;

    if (mm < lm1) {
        if (nn < ln1) {
            if (A.type == PlasmaUpper) {
                offset = A.mb*A.nb*(mm + (nn * (nn + 1))/2);
            } 
            else {
                offset = A.mb*A.nb*((mm - nn) + (nn * (2*lm1 - (nn-1)))/2);
            }
        } 
        else {
            offset = A.A12 + ((size_t)A.mb * (A.gn%A.nb) * mm);
        }
    } 
    else {
        if (nn < ln1) {
            offset = A.A21 + ((size_t)A.nb * (A.gm%A.mb) * nn);
        }
        else {
            offset = A.A22;
        }
    }

    return (void*)((char*)A.matrix + (offset*eltsize));
}

/******************************************************************************/
static inline void *plasma_tile_addr_general_band(plasma_desc_t A, int m, int n)
{
    return plasma_tile_addr_general(A, (A.kut-1)+m-n, n);
}

/******************************************************************************/
static inline void *plasma_tile_addr(plasma_desc_t A, int m, int n)
{
    if (A.type == PlasmaGeneral) {
        return plasma_tile_addr_general(A, m, n);
    }
    else if (A.type == PlasmaGeneralBand) {
        return plasma_tile_addr_general_band(A, m, n);
    }
    else if (A.type == PlasmaUpper || A.type == PlasmaLower) {
        return plasma_tile_addr_triangle(A, m, n);
    }
    else {
        plasma_fatal_error("invalid matrix type");
        return NULL;
    }
}

/***************************************************************************/
static inline int plasma_tile_mmain(plasma_desc_t A, int k)
{
    if (A.i/A.mb+k < A.gm/A.mb)
        return A.mb;
    else
        return A.gm%A.mb;
}

/***************************************************************************/
static inline int plasma_tile_nmain(plasma_desc_t A, int k)
{
    if (A.j/A.nb+k < A.gn/A.nb)
        return A.nb;
    else
        return A.gn%A.nb;
}

/***************************************************************************/
static inline int plasma_tile_mview(plasma_desc_t A, int k)
{
    if (k < A.mt-1)
        return A.mb;
    else
        if ((A.i+A.m)%A.mb == 0)
            return A.mb;
        else
            return (A.i+A.m)%A.mb;
}

/***************************************************************************/
static inline int plasma_tile_nview(plasma_desc_t A, int k)
{
    if (k < A.nt-1)
        return A.nb;
    else
        if ((A.j+A.n)%A.nb == 0)
            return A.nb;
        else
            return (A.j+A.n)%A.nb;
}

/******************************************************************************/
static inline int plasma_tile_mmain_band(plasma_desc_t A, int m, int n)
{
    return plasma_tile_mmain(A, (A.kut-1)+m-n);
}

/******************************************************************************/
int plasma_desc_general_create(plasma_enum_t dtyp, int mb, int nb,
                               int lm, int ln, int i, int j, int m, int n,
                               plasma_desc_t *A);

int plasma_desc_general_band_create(plasma_enum_t dtyp, plasma_enum_t uplo,
                                    int mb, int nb, int lm, int ln,
                                    int i, int j, int m, int n, int kl, int ku,
                                    plasma_desc_t *A);

int plasma_desc_triangular_create(plasma_enum_t dtyp, plasma_enum_t uplo, int mb, int nb,
                                  int lm, int ln, int i, int j, int m, int n,
                                  plasma_desc_t *A);

int plasma_desc_destroy(plasma_desc_t *A);

int plasma_desc_general_init(plasma_enum_t precision, void *matrix,
                             int mb, int nb, int lm, int ln, int i, int j,
                             int m, int n, plasma_desc_t *A);

int plasma_desc_general_band_init(plasma_enum_t precision, plasma_enum_t uplo,
                                  void *matrix, int mb, int nb, int lm, int ln,
                                  int i, int j, int m, int n, int kl, int ku,
                                  plasma_desc_t *A);

int plasma_desc_triangular_init(plasma_enum_t precision, plasma_enum_t uplo, void *matrix,
                                int mb, int nb, int lm, int ln, int i, int j,
                                int m, int n, plasma_desc_t *A);

int plasma_desc_check(plasma_desc_t A);
int plasma_desc_general_check(plasma_desc_t A);
int plasma_desc_general_band_check(plasma_desc_t A);

plasma_desc_t plasma_desc_view(plasma_desc_t A, int i, int j, int m, int n);

int plasma_descT_create(plasma_desc_t A, int ib, plasma_enum_t householder_mode,
                        plasma_desc_t *T);

#ifdef __cplusplus
}  // extern "C"
#endif

#endif // ICL_PLASMA_DESCRIPTOR_H