nl_blas.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#include "nl_private.h"
 
#ifndef OPENNL_BLAS_H
#define OPENNL_BLAS_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
    struct NLBlas;
 
    typedef struct NLBlas* NLBlas_t;
 
    typedef enum {
        NoTranspose=0, Transpose=1, ConjugateTranspose=2
    } MatrixTranspose ;
 
    typedef enum {
        UpperTriangle=0, LowerTriangle=1
    } MatrixTriangle ;
 
    typedef enum {
        UnitTriangular=0, NotUnitTriangular=1
    } MatrixUnitTriangular ;
 
    typedef enum {
        NL_HOST_MEMORY, NL_DEVICE_MEMORY
    } NLmemoryType;
 
    typedef void* (*FUNPTR_malloc)(
        NLBlas_t blas, NLmemoryType type, size_t size
    );
 
    typedef void (*FUNPTR_free)(
        NLBlas_t blas, NLmemoryType type, size_t size, void* ptr
    );
 
    typedef void (*FUNPTR_memcpy)(
        NLBlas_t blas,
        void* to, NLmemoryType to_type,
        void* from, NLmemoryType from_type,
        size_t size
    );
 
    typedef void (*FUNPTR_memset)(
        NLBlas_t blas,
        void* to, NLmemoryType to_type,
        int c, size_t size
    );
 
    typedef void (*FUNPTR_dcopy)(
        NLBlas_t blas, int n, const double *x, int incx, double *y, int incy
    );
 
    typedef void (*FUNPTR_dscal)(
        NLBlas_t blas, int n, double a, double *x, int incx
    );
 
 
    typedef double (*FUNPTR_ddot)(
        NLBlas_t blas,
        int n, const double *x, int incx, const double *y, int incy
    );
 
    typedef double (*FUNPTR_dnrm2)(
        NLBlas_t blas, int n, const double *x, int incx
    );
 
    typedef void (*FUNPTR_daxpy)(
        NLBlas_t blas, int n,
        double a, const double *x, int incx, double *y, int incy
    );
 
 
    typedef void (*FUNPTR_dmul)(
        NLBlas_t blas, int n,
        const double* x, const double* y, double* z
    );
 
    typedef void (*FUNPTR_dgemv)(
        NLBlas_t blas, MatrixTranspose trans, int m, int n, double alpha,
        const double *A, int ldA, const double *x, int incx,
        double beta, double *y, int incy
    );
 
 
    typedef void (*FUNPTR_dtpsv)(
        NLBlas_t blas, MatrixTriangle uplo, MatrixTranspose trans,
        MatrixUnitTriangular diag, int n, const double *AP,
        double *x, int incx
    );
 
 
 
    typedef void (*FUNPTR_show_stats)(NLBlas_t blas);
 
    typedef void (*FUNPTR_reset_stats)(NLBlas_t blas);
 
    struct NLBlas {
        FUNPTR_malloc Malloc;
        FUNPTR_free Free;
        FUNPTR_memcpy Memcpy;
        FUNPTR_memset Memset;
 
        FUNPTR_dcopy Dcopy;
        FUNPTR_dscal Dscal;
        FUNPTR_ddot  Ddot;
        FUNPTR_dnrm2 Dnrm2;
        FUNPTR_daxpy Daxpy;
        FUNPTR_dmul  Dmul;
        FUNPTR_dgemv Dgemv;
        FUNPTR_dtpsv Dtpsv;
 
        FUNPTR_reset_stats reset_stats;
        FUNPTR_show_stats show_stats;
 
        NLboolean has_unified_memory;
        double start_time;
        NLulong flops;
        NLulong used_ram[2];
        NLulong max_used_ram[2];
 
        /*
         * Used for stats of the linear solver
         * (a bit ugly, should not be here, but
         * more convenient for now...)
         */
        double sq_rnorm;
        double sq_bnorm;
 
        double aux_time;
    };
 
    NLAPI NLboolean NLAPIENTRY nlBlasHasUnifiedMemory(NLBlas_t blas);
 
    NLAPI void NLAPIENTRY nlBlasResetStats(NLBlas_t blas);
 
    NLAPI void NLAPIENTRY nlBlasShowStats(NLBlas_t blas);
 
    NLAPI double NLAPIENTRY nlBlasGFlops(NLBlas_t blas);
 
    NLAPI NLulong NLAPIENTRY nlBlasUsedRam(NLBlas_t blas, NLmemoryType type);
 
    NLAPI NLulong NLAPIENTRY nlBlasMaxUsedRam(NLBlas_t blas, NLmemoryType type);
 
    NLAPI NLBlas_t NLAPIENTRY nlHostBlas(void);
 
#define NL_NEW_VECTOR(blas, memtype, dim)                               \
    (double*)blas->Malloc(blas,memtype,(size_t)(dim)*sizeof(double))
 
#define NL_DELETE_VECTOR(blas, memtype, dim, ptr)               \
    blas->Free(blas,memtype,(size_t)(dim)*sizeof(double),ptr)
 
/******************************************************************************/
 
#ifdef __cplusplus
}
#endif
 
#endif