/**************************************************************************************************
* *
* This file is part of BLASFEO . *
* *
* BLASFEO - - BLAS For Embedded Optimization . *
* Copyright ( C ) 2019 by Gianluca Frison . *
* Developed at IMTEK ( University of Freiburg ) under the supervision of Moritz Diehl . *
* All rights reserved . *
* *
* The 2 - Clause BSD License *
* *
* Redistribution and use in source and binary forms , with or without *
* modification , are permitted provided that the following conditions are met : *
* *
* 1. Redistributions of source code must retain the above copyright notice , this *
* list of conditions and the following disclaimer . *
* 2. 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 . *
* *
* 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 OWNER 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 . *
* *
* Author : Gianluca Frison , gianluca . frison ( at ) imtek . uni - freiburg . de *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
# ifndef BLASFEO_COMMON_H_
# define BLASFEO_COMMON_H_
# include "blasfeo_target.h"
# ifdef __cplusplus
extern " C " {
# endif
# if defined(__GNUC__) || defined(__clang__) || defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__INTEL_LLVM_COMPILER)
# define ALIGNED(VEC, BYTES) VEC __attribute__ ((aligned ( BYTES )))
# elif defined (_MSC_VER)
# define ALIGNED(VEC, BYTES) __declspec(align( BYTES )) VEC
# else
# define ALIGNED(VEC, BYTES) VEC
# endif
# if ( defined(LA_HIGH_PERFORMANCE) & defined(MF_PANELMAJ) ) | ( defined(LA_REFERENCE) & defined(MF_PANELMAJ) )
# include "blasfeo_block_size.h"
// matrix structure
struct blasfeo_dmat
{
double * mem ; // pointer to passed chunk of memory
double * pA ; // pointer to a pm*pn array of doubles, the first is aligned to cache line size
double * dA ; // pointer to a min(m,n) (or max???) array of doubles
int m ; // rows
int n ; // cols
int pm ; // packed number or rows
int cn ; // packed number or cols
int use_dA ; // flag to tell if dA can be used
int memsize ; // size of needed memory
} ;
struct blasfeo_smat
{
float * mem ; // pointer to passed chunk of memory
float * pA ; // pointer to a pm*pn array of floats, the first is aligned to cache line size
float * dA ; // pointer to a min(m,n) (or max???) array of floats
int m ; // rows
int n ; // cols
int pm ; // packed number or rows
int cn ; // packed number or cols
int use_dA ; // flag to tell if dA can be used
int memsize ; // size of needed memory
} ;
// vector structure
struct blasfeo_dvec
{
double * mem ; // pointer to passed chunk of memory
double * pa ; // pointer to a pm array of doubles, the first is aligned to cache line size
int m ; // size
int pm ; // packed size
int memsize ; // size of needed memory
} ;
struct blasfeo_svec
{
float * mem ; // pointer to passed chunk of memory
float * pa ; // pointer to a pm array of floats, the first is aligned to cache line size
int m ; // size
int pm ; // packed size
int memsize ; // size of needed memory
} ;
# define BLASFEO_DMATEL(sA,ai,aj) ((sA)->pA[((ai)-((ai)&(D_PS-1)))*(sA)->cn+(aj)*D_PS+((ai)&(D_PS-1))])
# define BLASFEO_SMATEL(sA,ai,aj) ((sA)->pA[((ai)-((ai)&(S_PS-1)))*(sA)->cn+(aj)*S_PS+((ai)&(S_PS-1))])
# define BLASFEO_DVECEL(sa,ai) ((sa)->pa[ai])
# define BLASFEO_SVECEL(sa,ai) ((sa)->pa[ai])
# elif ( defined(LA_HIGH_PERFORMANCE) & defined(MF_COLMAJ) ) | ( defined(LA_REFERENCE) & defined(MF_COLMAJ) ) | defined(LA_EXTERNAL_BLAS_WRAPPER)
// matrix structure
struct blasfeo_dmat
{
double * mem ; // pointer to passed chunk of memory
double * pA ; // pointer to a m*n array of doubles
double * dA ; // pointer to a min(m,n) (or max???) array of doubles
int m ; // rows
int n ; // cols
int use_dA ; // flag to tell if dA can be used
int memsize ; // size of needed memory
} ;
struct blasfeo_smat
{
float * mem ; // pointer to passed chunk of memory
float * pA ; // pointer to a m*n array of floats
float * dA ; // pointer to a min(m,n) (or max???) array of floats
int m ; // rows
int n ; // cols
int use_dA ; // flag to tell if dA can be used
int memsize ; // size of needed memory
} ;
// vector structure
struct blasfeo_dvec
{
double * mem ; // pointer to passed chunk of memory
double * pa ; // pointer to a m array of doubles, the first is aligned to cache line size
int m ; // size
int memsize ; // size of needed memory
} ;
struct blasfeo_svec
{
float * mem ; // pointer to passed chunk of memory
float * pa ; // pointer to a m array of floats, the first is aligned to cache line size
int m ; // size
int memsize ; // size of needed memory
} ;
# define BLASFEO_DMATEL(sA,ai,aj) ((sA)->pA[(ai)+(aj)*(sA)->m])
# define BLASFEO_SMATEL(sA,ai,aj) ((sA)->pA[(ai)+(aj)*(sA)->m])
# define BLASFEO_DVECEL(sa,ai) ((sa)->pa[ai])
# define BLASFEO_SVECEL(sa,ai) ((sa)->pa[ai])
# else
# error : wrong LA or MF choice
# endif
// Explicitly panel-major matrix structure
struct blasfeo_pm_dmat
{
double * mem ; // pointer to passed chunk of memory
double * pA ; // pointer to a pm*pn array of doubles, the first is aligned to cache line size
double * dA ; // pointer to a min(m,n) (or max???) array of doubles
int m ; // rows
int n ; // cols
int pm ; // packed number or rows
int cn ; // packed number or cols
int use_dA ; // flag to tell if dA can be used
int ps ; // panel size
int memsize ; // size of needed memory
} ;
struct blasfeo_pm_smat
{
float * mem ; // pointer to passed chunk of memory
float * pA ; // pointer to a pm*pn array of floats, the first is aligned to cache line size
float * dA ; // pointer to a min(m,n) (or max???) array of floats
int m ; // rows
int n ; // cols
int pm ; // packed number or rows
int cn ; // packed number or cols
int use_dA ; // flag to tell if dA can be used
int ps ; // panel size
int memsize ; // size of needed memory
} ;
struct blasfeo_pm_dvec
{
double * mem ; // pointer to passed chunk of memory
double * pa ; // pointer to a pm array of doubles, the first is aligned to cache line size
int m ; // size
int pm ; // packed size
int memsize ; // size of needed memory
} ;
struct blasfeo_pm_svec
{
float * mem ; // pointer to passed chunk of memory
float * pa ; // pointer to a pm array of floats, the first is aligned to cache line size
int m ; // size
int pm ; // packed size
int memsize ; // size of needed memory
} ;
// Explicitly column-major matrix structure
struct blasfeo_cm_dmat
{
double * mem ; // pointer to passed chunk of memory
double * pA ; // pointer to a m*n array of doubles
double * dA ; // pointer to a min(m,n) (or max???) array of doubles
int m ; // rows
int n ; // cols
int use_dA ; // flag to tell if dA can be used
int memsize ; // size of needed memory
} ;
struct blasfeo_cm_smat
{
float * mem ; // pointer to passed chunk of memory
float * pA ; // pointer to a m*n array of floats
float * dA ; // pointer to a min(m,n) (or max???) array of floats
int m ; // rows
int n ; // cols
int use_dA ; // flag to tell if dA can be used
int memsize ; // size of needed memory
} ;
struct blasfeo_cm_dvec
{
double * mem ; // pointer to passed chunk of memory
double * pa ; // pointer to a m array of doubles, the first is aligned to cache line size
int m ; // size
int memsize ; // size of needed memory
} ;
struct blasfeo_cm_svec
{
float * mem ; // pointer to passed chunk of memory
float * pa ; // pointer to a m array of floats, the first is aligned to cache line size
int m ; // size
int memsize ; // size of needed memory
} ;
# define BLASFEO_PM_DMATEL(sA,ai,aj) ((sA)->pA[((ai)-((ai)&((sA)->ps-1)))*(sA)->cn+(aj)*((sA)->ps)+((ai)&((sA)->ps-1))])
# define BLASFEO_PM_SMATEL(sA,ai,aj) ((sA)->pA[((ai)-((ai)&((sA)->ps-1)))*(sA)->cn+(aj)*((sA)->ps)+((ai)&((sA)->ps-1))])
# define BLASFEO_PM_DVECEL(sa,ai) ((sa)->pa[ai])
# define BLASFEO_PM_SVECEL(sa,ai) ((sa)->pa[ai])
# define BLASFEO_CM_DMATEL(sA,ai,aj) ((sA)->pA[(ai)+(aj)*(sA)->m])
# define BLASFEO_CM_SMATEL(sA,ai,aj) ((sA)->pA[(ai)+(aj)*(sA)->m])
# define BLASFEO_CM_DVECEL(sa,ai) ((sa)->pa[ai])
# define BLASFEO_CM_SVECEL(sa,ai) ((sa)->pa[ai])
# ifdef __cplusplus
}
# endif
# endif // BLASFEO_COMMON_H_
