diff --git a/src/NativeWrappers/Common/blas.c b/src/NativeWrappers/Common/blas.c index fdd3001b..55f89385 100644 --- a/src/NativeWrappers/Common/blas.c +++ b/src/NativeWrappers/Common/blas.c @@ -1,5 +1,5 @@ #include "blas.h" -#include "common.h" +#include "wrapper_common.h" DLLEXPORT void s_axpy(const int n, const float alpha, const float x[], float y[]){ cblas_saxpy(n, alpha, x, 1, y, 1); diff --git a/src/NativeWrappers/Common/resource.rc b/src/NativeWrappers/Common/resource.rc index 14020254..3a698afc 100644 --- a/src/NativeWrappers/Common/resource.rc +++ b/src/NativeWrappers/Common/resource.rc @@ -51,8 +51,8 @@ END // VS_VERSION_INFO VERSIONINFO - FILEVERSION 0,2010,12,0 - PRODUCTVERSION 0,2010,12,0 + FILEVERSION 1,1,0,0 + PRODUCTVERSION 1,1,0,0 FILEFLAGSMASK 0x17L #ifdef _DEBUG FILEFLAGS 0x1L @@ -67,15 +67,15 @@ BEGIN BEGIN BLOCK "040904b0" BEGIN - VALUE "Comments", "http://mathdotnet.com" + VALUE "Comments", "http://http://mathnetnumerics.codeplex.com/" VALUE "CompanyName", "Math.NET" - VALUE "FileDescription", "MathNET Numerics Native Library" - VALUE "FileVersion", "0.2010.12.0" + VALUE "FileDescription", "MathNET Numerics Native Wrapper" + VALUE "FileVersion", "1.1.0.0" VALUE "InternalName", "Math.NET" - VALUE "LegalCopyright", "Copyright (C) Math.NET 2009-2010" + VALUE "LegalCopyright", "Copyright (C) Math.NET 2009-2011" VALUE "OriginalFilename", "MathNET.Numerics" - VALUE "ProductName", "Math.NET" - VALUE "ProductVersion", "0.2010.12.0" + VALUE "ProductName", "Math.NET Numerics" + VALUE "ProductVersion", "1.1.0.0" END END BLOCK "VarFileInfo" diff --git a/src/NativeWrappers/Common/common.h b/src/NativeWrappers/Common/wrapper_common.h similarity index 100% rename from src/NativeWrappers/Common/common.h rename to src/NativeWrappers/Common/wrapper_common.h diff --git a/src/NativeWrappers/GotoBlas2/blas.c b/src/NativeWrappers/GotoBlas2/blas.c new file mode 100644 index 00000000..37ea7875 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/blas.c @@ -0,0 +1,82 @@ +#include "include\cblas.h" +#include "wrapper_common.h" + +DLLEXPORT void s_axpy(int n, float alpha, float x[], float y[]){ + cblas_saxpy(n, alpha, x, 1, y, 1); +} + +DLLEXPORT void d_axpy(int n, double alpha, double x[], double y[]){ + cblas_daxpy(n, alpha, x, 1, y, 1); +} + +DLLEXPORT void c_axpy(int n, Complex8 alpha, Complex8 x[], Complex8 y[]){ + cblas_caxpy(n, &alpha, x, 1, y, 1); +} + +DLLEXPORT void z_axpy(int n, Complex16 alpha, Complex16 x[], Complex16 y[]){ + cblas_zaxpy(n, &alpha, x, 1, y, 1); +} + +DLLEXPORT void s_scale(int n, float alpha, float x[]){ + cblas_sscal(n, alpha, x, 1); +} + +DLLEXPORT void d_scale(int n, double alpha, double x[]){ + cblas_dscal(n, alpha, x, 1); +} + +DLLEXPORT void c_scale(int n, Complex8 alpha, Complex8 x[]){ + cblas_cscal(n, &alpha, x, 1); +} + +DLLEXPORT void z_scale(int n, Complex16 alpha, Complex16 x[]){ + cblas_zscal(n, &alpha, x, 1); +} + +DLLEXPORT float s_dot_product(int n, float x[], float y[]){ + return cblas_sdot(n, x, 1, y, 1); +} + +DLLEXPORT double d_dot_product(int n, double x[], double y[]){ + return cblas_ddot(n, x, 1, y, 1); +} + +DLLEXPORT Complex8 c_dot_product(int n, Complex8 x[], Complex8 y[]){ + Complex8 ret; + cblas_cdotu_sub(n, x, 1, y, 1, &ret); + return ret; +} + +DLLEXPORT Complex16 z_dot_product(int n, Complex16 x[], Complex16 y[]){ + Complex16 ret; + cblas_zdotu_sub(n, x, 1, y, 1, &ret); + return ret; +} + +DLLEXPORT void s_matrix_multiply(enum CBLAS_TRANSPOSE transA, enum CBLAS_TRANSPOSE transB, int m, int n, int k, float alpha, float x[], float y[], float beta, float c[]){ + int lda = transA == CblasNoTrans ? m : k; + int ldb = transB == CblasNoTrans ? k : n; + + cblas_sgemm(CblasColMajor, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m); +} + +DLLEXPORT void d_matrix_multiply(enum CBLAS_TRANSPOSE transA, enum CBLAS_TRANSPOSE transB, int m, int n, int k, double alpha, double x[], double y[], double beta, double c[]){ + int lda = transA == CblasNoTrans ? m : k; + int ldb = transB == CblasNoTrans ? k : n; + + cblas_dgemm(CblasColMajor, transA, transB, m, n, k, alpha, x, lda, y, ldb, beta, c, m); +} + +DLLEXPORT void c_matrix_multiply(enum CBLAS_TRANSPOSE transA, enum CBLAS_TRANSPOSE transB, int m, int n, int k, Complex8 alpha, Complex8 x[], Complex8 y[], Complex8 beta, Complex8 c[]){ + int lda = transA == CblasNoTrans ? m : k; + int ldb = transB == CblasNoTrans ? k : n; + + cblas_cgemm(CblasColMajor, transA, transB, m, n, k, &alpha, x, lda, y, ldb, &beta, c, m); +} + +DLLEXPORT void z_matrix_multiply(enum CBLAS_TRANSPOSE transA, enum CBLAS_TRANSPOSE transB, int m, int n, int k, Complex16 alpha, Complex16 x[], Complex16 y[], Complex16 beta, Complex16 c[]){ + int lda = transA == CblasNoTrans ? m : k; + int ldb = transB == CblasNoTrans ? k : n; + + cblas_zgemm(CblasColMajor, transA, transB, m, n, k, &alpha, x, lda, y, ldb, &beta, c, m); +} diff --git a/src/NativeWrappers/GotoBlas2/include/cblas.h b/src/NativeWrappers/GotoBlas2/include/cblas.h new file mode 100644 index 00000000..121ac725 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/cblas.h @@ -0,0 +1,283 @@ +#ifndef CBLAS_H +#define CBLAS_H +#ifdef __cplusplus +extern "C" { /* Assume C declarations for C++ */ +#endif /* __cplusplus */ +#define CBLAS_INDEX int +#define blasint int +#define _Complex +#define Complex8 float +#define Complex16 double + +enum CBLAS_ORDER {CblasRowMajor=101, CblasColMajor=102}; +enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113, CblasConjNoTrans=114}; +enum CBLAS_UPLO {CblasUpper=121, CblasLower=122}; +enum CBLAS_DIAG {CblasNonUnit=131, CblasUnit=132}; +enum CBLAS_SIDE {CblasLeft=141, CblasRight=142}; + +float cblas_sdsdot(blasint n, float, float *x, blasint incx, float *y, blasint incy); +double cblas_dsdot (blasint n, float *x, blasint incx, float *y, blasint incy); +float cblas_sdot(blasint n, float *x, blasint incx, float *y, blasint incy); +double cblas_ddot(blasint n, double *x, blasint incx, double *y, blasint incy); + +float _Complex cblas_cdotu(blasint n, float *x, blasint incx, float *y, blasint incy); +float _Complex cblas_cdotc(blasint n, float *x, blasint incx, float *y, blasint incy); +double _Complex cblas_zdotu(blasint n, double *x, blasint incx, double *y, blasint incy); +double _Complex cblas_zdotc(blasint n, double *x, blasint incx, double *y, blasint incy); + +void cblas_cdotu_sub(blasint n, float *x, blasint incx, float *y, blasint incy, float _Complex *ret); +void cblas_cdotc_sub(blasint n, float *x, blasint incx, float *y, blasint incy, float _Complex *ret); +void cblas_zdotu_sub(blasint n, double *x, blasint incx, double *y, blasint incy, double _Complex *ret); +void cblas_zdotc_sub(blasint n, double *x, blasint incx, double *y, blasint incy, double _Complex *ret); + +float cblas_sasum (blasint n, float *x, blasint incx); +double cblas_dasum (blasint n, double *x, blasint incx); +float cblas_scasum(blasint n, float *x, blasint incx); +double cblas_dzasum(blasint n, double *x, blasint incx); + +float cblas_snrm2 (blasint N, float *X, blasint incX); +double cblas_dnrm2 (blasint N, double *X, blasint incX); +float cblas_scnrm2(blasint N, float *X, blasint incX); +double cblas_dznrm2(blasint N, double *X, blasint incX); + +CBLAS_INDEX cblas_isamax(blasint n, float *x, blasint incx); +CBLAS_INDEX cblas_idamax(blasint n, double *x, blasint incx); +CBLAS_INDEX cblas_icamax(blasint n, float *x, blasint incx); +CBLAS_INDEX cblas_izamax(blasint n, double *x, blasint incx); + +void cblas_saxpy(blasint n, float, float *x, blasint incx, float *y, blasint incy); +void cblas_daxpy(blasint n, double, double *x, blasint incx, double *y, blasint incy); +void cblas_caxpy(blasint n, float *, float *x, blasint incx, float *y, blasint incy); +void cblas_zaxpy(blasint n, double *, double *x, blasint incx, double *y, blasint incy); + +void cblas_scopy(blasint n, float *x, blasint incx, float *y, blasint incy); +void cblas_dcopy(blasint n, double *x, blasint incx, double *y, blasint incy); +void cblas_ccopy(blasint n, float *x, blasint incx, float *y, blasint incy); +void cblas_zcopy(blasint n, double *x, blasint incx, double *y, blasint incy); + +void cblas_sswap(blasint n, float *x, blasint incx, float *y, blasint incy); +void cblas_dswap(blasint n, double *x, blasint incx, double *y, blasint incy); +void cblas_cswap(blasint n, float *x, blasint incx, float *y, blasint incy); +void cblas_zswap(blasint n, double *x, blasint incx, double *y, blasint incy); + +void cblas_srot(blasint N, float *X, blasint incX, float *Y, blasint incY, float c, float s); +void cblas_drot(blasint N, double *X, blasint incX, double *Y, blasint incY, double c, double s); + +void cblas_srotg(float *a, float *b, float *c, float *s); +void cblas_drotg(double *a, double *b, double *c, double *s); + +void cblas_srotm(blasint N, float *X, blasint incX, float *Y, blasint incY, float *P); +void cblas_drotm(blasint N, double *X, blasint incX, double *Y, blasint incY, double *P); + +void cblas_srotmg(float *d1, float *d2, float *b1, float b2, float *P); +void cblas_drotmg(double *d1, double *d2, double *b1, double b2, double *P); + +void cblas_sscal(blasint N, float alpha, float *X, blasint incX); +void cblas_dscal(blasint N, double alpha, double *X, blasint incX); +void cblas_cscal(blasint N, float *alpha, float *X, blasint incX); +void cblas_zscal(blasint N, double *alpha, double *X, blasint incX); +void cblas_csscal(blasint N, float alpha, float *X, blasint incX); +void cblas_zdscal(blasint N, double alpha, double *X, blasint incX); + +void cblas_sgemv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE trans, blasint m, blasint n, + float alpha, float *a, blasint lda, float *x, blasint incx, float beta, float *y, blasint incy); +void cblas_dgemv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE trans, blasint m, blasint n, + double alpha, double *a, blasint lda, double *x, blasint incx, double beta, double *y, blasint incy); +void cblas_cgemv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE trans, blasint m, blasint n, + float *alpha, float *a, blasint lda, float *x, blasint incx, float *beta, float *y, blasint incy); +void cblas_zgemv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE trans, blasint m, blasint n, + double *alpha, double *a, blasint lda, double *x, blasint incx, double *beta, double *y, blasint incy); + +void cblas_sger (enum CBLAS_ORDER order, blasint M, blasint N, float alpha, float *X, blasint incX, float *Y, blasint incY, float *A, blasint lda); +void cblas_dger (enum CBLAS_ORDER order, blasint M, blasint N, double alpha, double *X, blasint incX, double *Y, blasint incY, double *A, blasint lda); +void cblas_cgeru(enum CBLAS_ORDER order, blasint M, blasint N, float *alpha, float *X, blasint incX, float *Y, blasint incY, float *A, blasint lda); +void cblas_cgerc(enum CBLAS_ORDER order, blasint M, blasint N, float *alpha, float *X, blasint incX, float *Y, blasint incY, float *A, blasint lda); +void cblas_zgeru(enum CBLAS_ORDER order, blasint M, blasint N, double *alpha, double *X, blasint incX, double *Y, blasint incY, double *A, blasint lda); +void cblas_zgerc(enum CBLAS_ORDER order, blasint M, blasint N, double *alpha, double *X, blasint incX, double *Y, blasint incY, double *A, blasint lda); + +void cblas_strsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, float *A, blasint lda, float *X, blasint incX); +void cblas_dtrsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, double *A, blasint lda, double *X, blasint incX); +void cblas_ctrsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, float *A, blasint lda, float *X, blasint incX); +void cblas_ztrsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, double *A, blasint lda, double *X, blasint incX); + +void cblas_strmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, float *A, blasint lda, float *X, blasint incX); +void cblas_dtrmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, double *A, blasint lda, double *X, blasint incX); +void cblas_ctrmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, float *A, blasint lda, float *X, blasint incX); +void cblas_ztrmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, blasint N, double *A, blasint lda, double *X, blasint incX); + +void cblas_ssyr(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float alpha, float *X, blasint incX, float *A, blasint lda); +void cblas_dsyr(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *X, blasint incX, double *A, blasint lda); +void cblas_cher(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float alpha, float *X, blasint incX, float *A, blasint lda); +void cblas_zher(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *X, blasint incX, double *A, blasint lda); + +void cblas_ssyr2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo,blasint N, float alpha, float *X, + blasint incX, float *Y, blasint incY, float *A, blasint lda); +void cblas_dsyr2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *X, + blasint incX, double *Y, blasint incY, double *A, blasint lda); +void cblas_cher2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float *alpha, float *X, blasint incX, + float *Y, blasint incY, float *A, blasint lda); +void cblas_zher2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double *alpha, double *X, blasint incX, + double *Y, blasint incY, double *A, blasint lda); + +void cblas_sgbmv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE TransA, blasint M, blasint N, + blasint KL, blasint KU, float alpha, float *A, blasint lda, float *X, blasint incX, float beta, float *Y, blasint incY); +void cblas_dgbmv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE TransA, blasint M, blasint N, + blasint KL, blasint KU, double alpha, double *A, blasint lda, double *X, blasint incX, double beta, double *Y, blasint incY); +void cblas_cgbmv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE TransA, blasint M, blasint N, + blasint KL, blasint KU, float *alpha, float *A, blasint lda, float *X, blasint incX, float *beta, float *Y, blasint incY); +void cblas_zgbmv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE TransA, blasint M, blasint N, + blasint KL, blasint KU, double *alpha, double *A, blasint lda, double *X, blasint incX, double *beta, double *Y, blasint incY); + +void cblas_ssbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, blasint K, float alpha, float *A, + blasint lda, float *X, blasint incX, float beta, float *Y, blasint incY); +void cblas_dsbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, blasint K, double alpha, double *A, + blasint lda, double *X, blasint incX, double beta, double *Y, blasint incY); + + +void cblas_stbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, blasint K, float *A, blasint lda, float *X, blasint incX); +void cblas_dtbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, blasint K, double *A, blasint lda, double *X, blasint incX); +void cblas_ctbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, blasint K, float *A, blasint lda, float *X, blasint incX); +void cblas_ztbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, blasint K, double *A, blasint lda, double *X, blasint incX); + +void cblas_stbsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, blasint K, float *A, blasint lda, float *X, blasint incX); +void cblas_dtbsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, blasint K, double *A, blasint lda, double *X, blasint incX); +void cblas_ctbsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, blasint K, float *A, blasint lda, float *X, blasint incX); +void cblas_ztbsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, blasint K, double *A, blasint lda, double *X, blasint incX); + +void cblas_stpmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, float *Ap, float *X, blasint incX); +void cblas_dtpmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, double *Ap, double *X, blasint incX); +void cblas_ctpmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, float *Ap, float *X, blasint incX); +void cblas_ztpmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, double *Ap, double *X, blasint incX); + +void cblas_stpsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, float *Ap, float *X, blasint incX); +void cblas_dtpsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, double *Ap, double *X, blasint incX); +void cblas_ctpsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, float *Ap, float *X, blasint incX); +void cblas_ztpsv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, + blasint N, double *Ap, double *X, blasint incX); + +void cblas_ssymv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float alpha, float *A, + blasint lda, float *X, blasint incX, float beta, float *Y, blasint incY); +void cblas_dsymv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *A, + blasint lda, double *X, blasint incX, double beta, double *Y, blasint incY); +void cblas_chemv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float *alpha, float *A, + blasint lda, float *X, blasint incX, float *beta, float *Y, blasint incY); +void cblas_zhemv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double *alpha, double *A, + blasint lda, double *X, blasint incX, double *beta, double *Y, blasint incY); + + +void cblas_sspmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float alpha, float *Ap, + float *X, blasint incX, float beta, float *Y, blasint incY); +void cblas_dspmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *Ap, + double *X, blasint incX, double beta, double *Y, blasint incY); + +void cblas_sspr(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float alpha, float *X, blasint incX, float *Ap); +void cblas_dspr(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *X, blasint incX, double *Ap); + +void cblas_chpr(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float alpha, float *X, blasint incX, float *A); +void cblas_zhpr(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *X,blasint incX, double *A); + +void cblas_sspr2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float alpha, float *X, blasint incX, float *Y, blasint incY, float *A); +void cblas_dspr2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double alpha, double *X, blasint incX, double *Y, blasint incY, double *A); +void cblas_chpr2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, float *alpha, float *X, blasint incX, float *Y, blasint incY, float *Ap); +void cblas_zhpr2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, double *alpha, double *X, blasint incX, double *Y, blasint incY, double *Ap); + +void cblas_chbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, blasint K, + float *alpha, float *A, blasint lda, float *X, blasint incX, float *beta, float *Y, blasint incY); +void cblas_zhbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, blasint K, + double *alpha, double *A, blasint lda, double *X, blasint incX, double *beta, double *Y, blasint incY); + +void cblas_chpmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, + float *alpha, float *Ap, float *X, blasint incX, float *beta, float *Y, blasint incY); +void cblas_zhpmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, blasint N, + double *alpha, double *Ap, double *X, blasint incX, double *beta, double *Y, blasint incY); + +void cblas_sgemm(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB, blasint M, blasint N, blasint K, + float alpha, float *A, blasint lda, float *B, blasint ldb, float beta, float *C, blasint ldc); +void cblas_dgemm(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB, blasint M, blasint N, blasint K, + double alpha, double *A, blasint lda, double *B, blasint ldb, double beta, double *C, blasint ldc); +void cblas_cgemm(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB, blasint M, blasint N, blasint K, + float *alpha, float *A, blasint lda, float *B, blasint ldb, float *beta, float *C, blasint ldc); +void cblas_zgemm(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB, blasint M, blasint N, blasint K, + double *alpha, double *A, blasint lda, double *B, blasint ldb, double *beta, double *C, blasint ldc); + +void cblas_ssymm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, blasint M, blasint N, + float alpha, float *A, blasint lda, float *B, blasint ldb, float beta, float *C, blasint ldc); +void cblas_dsymm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, blasint M, blasint N, + double alpha, double *A, blasint lda, double *B, blasint ldb, double beta, double *C, blasint ldc); +void cblas_csymm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, blasint M, blasint N, + float *alpha, float *A, blasint lda, float *B, blasint ldb, float *beta, float *C, blasint ldc); +void cblas_zsymm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, blasint M, blasint N, + double *alpha, double *A, blasint lda, double *B, blasint ldb, double *beta, double *C, blasint ldc); + +void cblas_ssyrk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, + blasint N, blasint K, float alpha, float *A, blasint lda, float beta, float *C, blasint ldc); +void cblas_dsyrk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, + blasint N, blasint K, double alpha, double *A, blasint lda, double beta, double *C, blasint ldc); +void cblas_csyrk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, + blasint N, blasint K, float *alpha, float *A, blasint lda, float *beta, float *C, blasint ldc); +void cblas_zsyrk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, + blasint N, blasint K, double *alpha, double *A, blasint lda, double *beta, double *C, blasint ldc); + +void cblas_ssyr2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, + blasint N, blasint K, float alpha, float *A, blasint lda, float *B, blasint ldb, float beta, float *C, blasint ldc); +void cblas_dsyr2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, + blasint N, blasint K, double alpha, double *A, blasint lda, double *B, blasint ldb, double beta, double *C, blasint ldc); +void cblas_csyr2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, + blasint N, blasint K, float *alpha, float *A, blasint lda, float *B, blasint ldb, float *beta, float *C, blasint ldc); +void cblas_zsyr2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, + blasint N, blasint K, double *alpha, double *A, blasint lda, double *B, blasint ldb, double *beta, double *C, blasint ldc); + +void cblas_strmm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, + enum CBLAS_DIAG Diag, blasint M, blasint N, float alpha, float *A, blasint lda, float *B, blasint ldb); +void cblas_dtrmm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, + enum CBLAS_DIAG Diag, blasint M, blasint N, double alpha, double *A, blasint lda, double *B, blasint ldb); +void cblas_ctrmm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, + enum CBLAS_DIAG Diag, blasint M, blasint N, float *alpha, float *A, blasint lda, float *B, blasint ldb); +void cblas_ztrmm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, + enum CBLAS_DIAG Diag, blasint M, blasint N, double *alpha, double *A, blasint lda, double *B, blasint ldb); + +void cblas_strsm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, + enum CBLAS_DIAG Diag, blasint M, blasint N, float alpha, float *A, blasint lda, float *B, blasint ldb); +void cblas_dtrsm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, + enum CBLAS_DIAG Diag, blasint M, blasint N, double alpha, double *A, blasint lda, double *B, blasint ldb); +void cblas_ctrsm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, + enum CBLAS_DIAG Diag, blasint M, blasint N, float *alpha, float *A, blasint lda, float *B, blasint ldb); +void cblas_ztrsm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, + enum CBLAS_DIAG Diag, blasint M, blasint N, double *alpha, double *A, blasint lda, double *B, blasint ldb); + +void cblas_chemm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, blasint M, blasint N, + float *alpha, float *A, blasint lda, float *B, blasint ldb, float *beta, float *C, blasint ldc); +void cblas_zhemm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, blasint M, blasint N, + double *alpha, double *A, blasint lda, double *B, blasint ldb, double *beta, double *C, blasint ldc); + +void cblas_cherk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, blasint N, blasint K, + float alpha, float *A, blasint lda, float beta, float *C, blasint ldc); +void cblas_zherk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, blasint N, blasint K, + double alpha, double *A, blasint lda, double beta, double *C, blasint ldc); + +void cblas_cher2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, blasint N, blasint K, + float *alpha, float *A, blasint lda, float *B, blasint ldb, float beta, float *C, blasint ldc); +void cblas_zher2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, blasint N, blasint K, + double *alpha, double *A, blasint lda, double *B, blasint ldb, double beta, double *C, blasint ldc); + +void cblas_xerbla(blasint p, char *rout, char *form, ...); +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif + diff --git a/src/NativeWrappers/GotoBlas2/include/common.h b/src/NativeWrappers/GotoBlas2/include/common.h new file mode 100644 index 00000000..a481b2ac --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common.h @@ -0,0 +1,610 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef COMMON_H +#define COMMON_H + +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif + +#ifndef __USE_XOPEN +#define __USE_XOPEN +#endif + +#ifndef __USE_SVID +#define __USE_SVID +#endif + +#ifdef BUILD_KERNEL +#include "config_kernel.h" +#else +#include "config.h" +#endif + +#undef ENABLE_SSE_EXCEPTION + +#if defined(SMP_SERVER) || defined(SMP_ONDEMAND) +#define SMP +#endif + +#if defined(OS_WINNT) || defined(OS_CYGWIN_NT) || defined(OS_Interix) +#define WINDOWS_ABI +#define OS_WINDOWS + +#ifdef DOUBLE +#define DOUBLE_DEFINED DOUBLE +#undef DOUBLE +#endif +#endif + +#if !defined(NOINCLUDE) && !defined(ASSEMBLER) +#include +#include +#include +#include + +#ifdef OS_LINUX +#include +#include +#endif + +#ifdef OS_WINDOWS +#ifdef ATOM +#define GOTO_ATOM ATOM +#undef ATOM +#endif +#include +#include +#ifdef GOTO_ATOM +#define ATOM GOTO_ATOM +#undef GOTO_ATOM +#endif +#else +#include +#include +#include +#include +#include +#ifdef SMP +#include +#endif +#endif + +#if defined(OS_SUNOS) +#include +#endif + +#ifdef __DECC +#include +#include +#endif + +#if defined(ARCH_IA64) && defined(ENABLE_SSE_EXCEPTION) +#include +#endif + +#endif + +#if defined(OS_WINDOWS) && defined(DOUBLE_DEFINED) +#define DOUBLE DOUBLE_DEFINED +#undef DOUBLE_DEFINED +#endif + +#undef DEBUG_INFO +#define SMP_DEBUG +#undef MALLOC_DEBUG +#undef SMP_ALLOC_DEBUG + +#ifndef ZERO +#ifdef XDOUBLE +#define ZERO 0.e0L +#elif defined DOUBLE +#define ZERO 0.e0 +#else +#define ZERO 0.e0f +#endif +#endif + +#ifndef ONE +#ifdef XDOUBLE +#define ONE 1.e0L +#elif defined DOUBLE +#define ONE 1.e0 +#else +#define ONE 1.e0f +#endif +#endif + +#define BITMASK(a, b, c) ((((a) >> (b)) & (c))) + +#define ALLOCA_ALIGN 63UL + +#define NUM_BUFFERS (MAX_CPU_NUMBER * 2) + +#ifdef NEEDBUNDERSCORE +#define BLASFUNC(FUNC) FUNC##_ +#else +#define BLASFUNC(FUNC) FUNC +#endif + +#undef USE_PTHREAD_LOCK +#undef USE_PTHREAD_SPINLOCK + +#if defined(USE_PTHREAD_LOCK) && defined(USE_PTHREAD_SPINLOCK) +#error "You can't specify both LOCK operation!" +#endif + +#ifdef SMP +#define USE_PTHREAD_LOCK +#undef USE_PTHREAD_SPINLOCK +#endif + +#ifdef OS_WINDOWS +#undef USE_PTHREAD_LOCK +#undef USE_PTHREAD_SPINLOCK +#endif + +#if defined(USE_PTHREAD_LOCK) +#define LOCK_COMMAND(x) pthread_mutex_lock(x) +#define UNLOCK_COMMAND(x) pthread_mutex_unlock(x) +#elif defined(USE_PTHREAD_SPINLOCK) +#ifndef ASSEMBLER +typedef volatile int pthread_spinlock_t; +int pthread_spin_lock (pthread_spinlock_t *__lock); +int pthread_spin_unlock (pthread_spinlock_t *__lock); +#endif +#define LOCK_COMMAND(x) pthread_spin_lock(x) +#define UNLOCK_COMMAND(x) pthread_spin_unlock(x) +#else +#define LOCK_COMMAND(x) blas_lock(x) +#define UNLOCK_COMMAND(x) blas_unlock(x) +#endif + +#define GOTO_SHMID 0x510510 + +#if 0 +#ifndef __CUDACC__ +#define __global__ +#define __device__ +#define __host__ +#define __shared__ +#endif +#endif + +#ifndef ASSEMBLER + +#ifdef QUAD_PRECISION +typedef struct { + unsigned long x[2]; +} xdouble; +#elif defined EXPRECISION +#define xdouble long double +#else +#define xdouble double +#endif + +#if defined(OS_WINDOWS) && defined(__64BIT__) +typedef long long BLASLONG; +typedef unsigned long long BLASULONG; +#else +typedef long BLASLONG; +typedef unsigned long BLASULONG; +#endif + +#ifdef USE64BITINT +typedef BLASLONG blasint; +#else +typedef int blasint; +#endif +#else +#ifdef USE64BITINT +#define INTSHIFT 3 +#define INTSIZE 8 +#else +#define INTSHIFT 2 +#define INTSIZE 4 +#endif +#endif + +#ifdef XDOUBLE +#define FLOAT xdouble +#ifdef QUAD_PRECISION +#define XFLOAT xidouble +#endif +#ifdef QUAD_PRECISION +#define SIZE 32 +#define BASE_SHIFT 5 +#define ZBASE_SHIFT 6 +#else +#define SIZE 16 +#define BASE_SHIFT 4 +#define ZBASE_SHIFT 5 +#endif +#elif defined(DOUBLE) +#define FLOAT double +#define SIZE 8 +#define BASE_SHIFT 3 +#define ZBASE_SHIFT 4 +#else +#define FLOAT float +#define SIZE 4 +#define BASE_SHIFT 2 +#define ZBASE_SHIFT 3 +#endif + +#ifndef XFLOAT +#define XFLOAT FLOAT +#endif + +#ifndef COMPLEX +#define COMPSIZE 1 +#else +#define COMPSIZE 2 +#endif + +#if defined(C_PGI) || defined(C_SUN) +#define CREAL(X) (*((FLOAT *)&X + 0)) +#define CIMAG(X) (*((FLOAT *)&X + 1)) +#else +#define CREAL __real__ +#define CIMAG __imag__ +#endif + +#define Address_H(x) (((x)+(1<<15))>>16) +#define Address_L(x) ((x)-((Address_H(x))<<16)) + +#ifndef MAX_CPU_NUMBER +#define MAX_CPU_NUMBER 2 +#endif + +#if defined(OS_SUNOS) +#define YIELDING thr_yield() +#endif + +#if defined(OS_WINDOWS) +#define YIELDING SwitchToThread() +#endif + +#ifndef YIELDING +#define YIELDING sched_yield() +#endif + +#ifdef QUAD_PRECISION +#include "common_quad.h" +#endif + +#ifdef ARCH_ALPHA +#include "common_alpha.h" +#endif + +#ifdef ARCH_X86 +#include "common_x86.h" +#endif + +#ifdef ARCH_X86_64 +#include "common_x86_64.h" +#endif + +#ifdef ARCH_IA64 +#include "common_ia64.h" +#endif + +#ifdef ARCH_POWER +#include "common_power.h" +#endif + +#ifdef sparc +#include "common_sparc.h" +#endif + +#ifdef ARCH_MIPS64 +#include "common_mips64.h" +#endif + +#ifdef OS_LINUX +#include "common_linux.h" +#endif + +#define MMAP_ACCESS (PROT_READ | PROT_WRITE) +#define MMAP_POLICY (MAP_PRIVATE | MAP_ANONYMOUS) + +#include "param.h" +#include "common_param.h" + +#ifndef STDERR +#define STDERR stderr +#endif + +#ifndef MASK +#define MASK(a, b) (((a) + ((b) - 1)) & ~((b) - 1)) +#endif + +#if defined(XDOUBLE) || defined(DOUBLE) +#define FLOATRET FLOAT +#else +#ifdef NEED_F2CCONV +#define FLOATRET double +#else +#define FLOATRET float +#endif +#endif + +#ifndef IFLUSH +#define IFLUSH +#endif + +#ifndef IFLUSH_HALF +#define IFLUSH_HALF +#endif + +#if defined(C_GCC) && (( __GNUC__ <= 3) || ((__GNUC__ == 4) && (__GNUC_MINOR__ < 2))) +#ifdef USE_OPENMP +#undef USE_OPENMP +#endif +#endif + +#ifndef ASSEMBLER + +#ifndef MIN +#define MIN(a,b) (a>b? b:a) +#endif + +#ifndef MAX +#define MAX(a,b) (a 0x60) (a) -= 0x20;} + +#if defined(__FreeBSD__) || defined(__APPLE__) +#define MAP_ANONYMOUS MAP_ANON +#endif + +/* Common Memory Management Routine */ +void blas_set_parameter(void); +int blas_get_cpu_number(void); +void *blas_memory_alloc (int); +void blas_memory_free (void *); + +int get_num_procs (void); + +#if defined(OS_LINUX) && defined(SMP) && !defined(NO_AFFINITY) +int get_num_nodes (void); +int get_num_proc (int); +int get_node_equal (void); +#endif + +void goto_set_num_threads(int); + +void gotoblas_affinity_init(void); +void gotoblas_affinity_quit(void); +void gotoblas_dynamic_init(void); +void gotoblas_dynamic_quit(void); +void gotoblas_profile_init(void); +void gotoblas_profile_quit(void); + +#ifdef USE_OPENMP +int omp_in_parallel(void); +int omp_get_num_procs(void); +#else +#ifdef __ELF__ +int omp_in_parallel (void) __attribute__ ((weak)); +int omp_get_num_procs(void) __attribute__ ((weak)); +#endif +#endif + +static __inline void blas_unlock(volatile BLASULONG *address){ + MB; + *address = 0; +} + +static __inline int readenv(char *env) { + + char *p; + + p = getenv(env); + + if (p == NULL) return 0; else return atoi(p); +} + + +#if !defined(XDOUBLE) || !defined(QUAD_PRECISION) + +static __inline void compinv(FLOAT *b, FLOAT ar, FLOAT ai){ + +#ifndef UNIT + FLOAT ratio, den; + + if ( +#ifdef XDOUBLE + (fabsl(ar)) >= (fabsl(ai)) +#elif defined DOUBLE + (fabs (ar)) >= (fabs (ai)) +#else + (fabsf(ar)) >= (fabsf(ai)) +#endif + ) { + ratio = ai / ar; + den = (FLOAT)(ONE / (ar * (ONE + ratio * ratio))); + ar = den; + ai = -ratio * den; + } else { + ratio = ar / ai; + den = (FLOAT)(ONE /(ai * (ONE + ratio * ratio))); + ar = ratio * den; + ai = -den; + } + b[0] = ar; + b[1] = ai; +#else + b[0] = ONE; + b[1] = ZERO; +#endif + +} +#endif + +#ifdef MALLOC_DEBUG +void *blas_debug_alloc(int); +void *blas_debug_free(void *); +#undef malloc +#undef free +#define malloc(a) blas_debug_alloc(a) +#define free(a) blas_debug_free (a) +#endif + +#ifndef COPYOVERHEAD +#define GEMMRETTYPE int +#else + +typedef struct { + double outercopy; + double innercopy; + double kernel; + double mflops; +} copyoverhead_t; + +#define GEMMRETTYPE copyoverhead_t +#endif +#endif + +#ifndef BUILD_KERNEL +#define KNAME(A, B) A +#else +#define KNAME(A, B) A##B +#endif + +#include "common_interface.h" +#ifdef SANITY_CHECK +#include "common_reference.h" +#endif +#include "common_macro.h" +#include "common_level1.h" +#include "common_level2.h" +#include "common_level3.h" +#include "common_lapack.h" +#ifdef CBLAS +#include "cblas.h" +#endif + +#ifndef ASSEMBLER +#if 0 +#include "symcopy.h" +#endif + +#if defined(SMP_SERVER) && defined(SMP_ONDEMAND) +#error Both SMP_SERVER and SMP_ONDEMAND are specified. +#endif + +#if defined(SMP_SERVER) || defined(SMP_ONDEMAND) +#include "common_thread.h" +#endif + +#endif + +#define INFO_NUM 99 + +#ifndef DEFAULT_CPU_NUMBER +#define DEFAULT_CPU_NUMBER 4 +#endif + +#ifndef IDEBUG_START +#define IDEBUG_START +#endif + +#ifndef IDEBUG_END +#define IDEBUG_END +#endif + +#if !defined(ASSEMBLER) && defined(FUNCTION_PROFILE) + +typedef struct { + int func; + unsigned long long calls, fops, area, cycles, tcycles; +} func_profile_t; + +extern func_profile_t function_profile_table[]; +extern int gotoblas_profile; + +#ifdef XDOUBLE +#define NUMOPT QNUMOPT +#elif defined DOUBLE +#define NUMOPT DNUMOPT +#else +#define NUMOPT SNUMOPT +#endif + +#define FUNCTION_PROFILE_START() { unsigned long long profile_start = rpcc(), profile_end; +#ifdef SMP +#define FUNCTION_PROFILE_END(COMP, AREA, OPS) \ + if (gotoblas_profile) { \ + profile_end = rpcc(); \ + function_profile_table[PROFILE_FUNC_NAME].calls ++; \ + function_profile_table[PROFILE_FUNC_NAME].area += SIZE * COMPSIZE * (AREA); \ + function_profile_table[PROFILE_FUNC_NAME].fops += (COMP) * (OPS) / NUMOPT; \ + function_profile_table[PROFILE_FUNC_NAME].cycles += (profile_end - profile_start); \ + function_profile_table[PROFILE_FUNC_NAME].tcycles += blas_cpu_number * (profile_end - profile_start); \ + } \ + } +#else +#define FUNCTION_PROFILE_END(COMP, AREA, OPS) \ + if (gotoblas_profile) { \ + profile_end = rpcc(); \ + function_profile_table[PROFILE_FUNC_NAME].calls ++; \ + function_profile_table[PROFILE_FUNC_NAME].area += SIZE * COMPSIZE * (AREA); \ + function_profile_table[PROFILE_FUNC_NAME].fops += (COMP) * (OPS) / NUMOPT; \ + function_profile_table[PROFILE_FUNC_NAME].cycles += (profile_end - profile_start); \ + function_profile_table[PROFILE_FUNC_NAME].tcycles += (profile_end - profile_start); \ + } \ + } +#endif + +#else +#define FUNCTION_PROFILE_START() +#define FUNCTION_PROFILE_END(COMP, AREA, OPS) +#endif + +#if 1 +#define PRINT_DEBUG_CNAME +#define PRINT_DEBUG_NAME +#else +#define PRINT_DEBUG_CNAME if (readenv("GOTO_DEBUG")) fprintf(stderr, "GotoBLAS : %s\n", CHAR_CNAME) +#define PRINT_DEBUG_NAME if (readenv("GOTO_DEBUG")) fprintf(stderr, "GotoBLAS : %s\n", CHAR_NAME) +#endif + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_alpha.h b/src/NativeWrappers/GotoBlas2/include/common_alpha.h new file mode 100644 index 00000000..cf794739 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_alpha.h @@ -0,0 +1,179 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef COMMON_ALPHA +#define COMMON_ALPHA + +#ifndef ASSEMBLER + +#define MB asm("mb") +#define WMB asm("wmb") + +static void __inline blas_lock(unsigned long *address){ +#ifndef __DECC + unsigned long tmp1, tmp2; + asm volatile( + "1: ldq %1, %0\n" + " bne %1, 2f\n" + " ldq_l %1, %0\n" + " bne %1, 2f\n" + " or %1, 1, %2\n" + " stq_c %2, %0\n" + " beq %2, 2f\n" + " mb\n " + " br $31, 3f\n" + "2: br $31, 1b\n" + "3:\n" : "=m"(*address), "=&r"(tmp1), "=&r"(tmp2) : : "memory"); +#else + asm ( + "10:" + " ldq %t0, 0(%a0); " + " bne %t0, 20f; " + " ldq_l %t0, 0(%a0); " + " bne %t0, 20f; " + " or %t0, 1, %t1;" + " stq_c %t1, 0(%a0); " + " beq %t1, 20f; " + " mb; " + " br %r31,30f; " + "20: " + " br %r31,10b; " + "30:", address); +#endif +} + +static __inline unsigned int rpcc(void){ + + unsigned int r0; + +#ifndef __DECC + asm __volatile__("rpcc %0" : "=r"(r0) : : "memory"); +#else + r0 = asm("rpcc %v0"); +#endif + + return r0; +} + + +#define HALT ldq $0, 0($0) + +#ifndef __DECC +#define GET_IMAGE(res) asm __volatile__("fmov $f1, %0" : "=f"(res) : : "memory") +#else +#define GET_IMAGE(res) res = dasm("fmov $f1, %f0") +#endif + +#ifdef SMP +#ifdef USE64BITINT +static __inline long blas_quickdivide(long x, long y){ + return x/y; +} +#else +extern unsigned int blas_quick_divide_table[]; + +static __inline int blas_quickdivide(unsigned int x, unsigned int y){ + if (y <= 1) return x; + return (int)((x * (unsigned long)blas_quick_divide_table[y]) >> 32); +} +#endif +#endif + +#define BASE_ADDRESS ((0x1b0UL << 33) | (0x1c0UL << 23) | (0x000UL << 13)) + +#ifndef PAGESIZE +#define PAGESIZE ( 8UL << 10) +#define HUGE_PAGESIZE ( 4 << 20) +#endif +#define BUFFER_SIZE (32UL << 20) + +#else + +#ifndef F_INTERFACE +#define REALNAME ASMNAME +#else +#define REALNAME ASMFNAME +#endif + +#define PROLOGUE \ + .arch ev6; \ + .set noat; \ + .set noreorder; \ +.text; \ + .align 5; \ + .globl REALNAME; \ + .ent REALNAME; \ +REALNAME: + +#ifdef PROFILE +#define PROFCODE \ + ldgp $gp, 0($27); \ + lda $28, _mcount; \ + jsr $28, ($28), _mcount; \ + .prologue 1 +#else +#define PROFCODE .prologue 0 +#endif + +#define EPILOGUE \ + .end REALNAME; \ + .ident VERSION +#endif + +#ifdef DOUBLE +#define SXADDQ s8addq +#define SXSUBL s8subl +#define LD ldt +#define ST stt +#define STQ stq +#define ADD addt/su +#define SUB subt/su +#define MUL mult/su +#define DIV divt/su +#else +#define SXADDQ s4addq +#define SXSUBL s4subl +#define LD lds +#define ST sts +#define STQ stl +#define ADD adds/su +#define SUB subs/su +#define MUL muls/su +#define DIV divs/su +#endif +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_c.h b/src/NativeWrappers/GotoBlas2/include/common_c.h new file mode 100644 index 00000000..f78f1721 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_c.h @@ -0,0 +1,611 @@ +#ifndef COMMON_C_H +#define COMMON_C_H + +#ifndef DYNAMIC_ARCH + +#define CAMAX_K camax_k +#define CAMIN_K camin_k +#define CMAX_K cmax_k +#define CMIN_K cmin_k +#define ICAMAX_K icamax_k +#define ICAMIN_K icamin_k +#define ICMAX_K icmax_k +#define ICMIN_K icmin_k +#define CASUM_K casum_k +#define CAXPYU_K caxpy_k +#define CAXPYC_K caxpyc_k +#define CCOPY_K ccopy_k +#define CDOTU_K cdotu_k +#define CDOTC_K cdotc_k +#define CNRM2_K cnrm2_k +#define CSCAL_K cscal_k +#define CSWAP_K cswap_k +#define CROT_K csrot_k + +#define CGEMV_N cgemv_n +#define CGEMV_T cgemv_t +#define CGEMV_R cgemv_r +#define CGEMV_C cgemv_c +#define CGEMV_O cgemv_o +#define CGEMV_U cgemv_u +#define CGEMV_S cgemv_s +#define CGEMV_D cgemv_d + +#define CGERU_K cgeru_k +#define CGERC_K cgerc_k +#define CGERV_K cgerv_k +#define CGERD_K cgerd_k + +#define CSYMV_U csymv_U +#define CSYMV_L csymv_L +#define CHEMV_U chemv_U +#define CHEMV_L chemv_L +#define CHEMV_V chemv_V +#define CHEMV_M chemv_M + +#define CSYMV_THREAD_U csymv_thread_U +#define CSYMV_THREAD_L csymv_thread_L +#define CHEMV_THREAD_U chemv_thread_U +#define CHEMV_THREAD_L chemv_thread_L +#define CHEMV_THREAD_V chemv_thread_V +#define CHEMV_THREAD_M chemv_thread_M + +#define CGEMM_ONCOPY cgemm_oncopy +#define CGEMM_OTCOPY cgemm_otcopy + +#if CGEMM_DEFAULT_UNROLL_M == CGEMM_DEFAULT_UNROLL_N +#define CGEMM_INCOPY cgemm_oncopy +#define CGEMM_ITCOPY cgemm_otcopy +#else +#define CGEMM_INCOPY cgemm_incopy +#define CGEMM_ITCOPY cgemm_itcopy +#endif + +#define CTRMM_OUNUCOPY ctrmm_ounucopy +#define CTRMM_OUNNCOPY ctrmm_ounncopy +#define CTRMM_OUTUCOPY ctrmm_outucopy +#define CTRMM_OUTNCOPY ctrmm_outncopy +#define CTRMM_OLNUCOPY ctrmm_olnucopy +#define CTRMM_OLNNCOPY ctrmm_olnncopy +#define CTRMM_OLTUCOPY ctrmm_oltucopy +#define CTRMM_OLTNCOPY ctrmm_oltncopy + +#define CTRSM_OUNUCOPY ctrsm_ounucopy +#define CTRSM_OUNNCOPY ctrsm_ounncopy +#define CTRSM_OUTUCOPY ctrsm_outucopy +#define CTRSM_OUTNCOPY ctrsm_outncopy +#define CTRSM_OLNUCOPY ctrsm_olnucopy +#define CTRSM_OLNNCOPY ctrsm_olnncopy +#define CTRSM_OLTUCOPY ctrsm_oltucopy +#define CTRSM_OLTNCOPY ctrsm_oltncopy + +#if CGEMM_DEFAULT_UNROLL_M == CGEMM_DEFAULT_UNROLL_N +#define CTRMM_IUNUCOPY ctrmm_ounucopy +#define CTRMM_IUNNCOPY ctrmm_ounncopy +#define CTRMM_IUTUCOPY ctrmm_outucopy +#define CTRMM_IUTNCOPY ctrmm_outncopy +#define CTRMM_ILNUCOPY ctrmm_olnucopy +#define CTRMM_ILNNCOPY ctrmm_olnncopy +#define CTRMM_ILTUCOPY ctrmm_oltucopy +#define CTRMM_ILTNCOPY ctrmm_oltncopy + +#define CTRSM_IUNUCOPY ctrsm_ounucopy +#define CTRSM_IUNNCOPY ctrsm_ounncopy +#define CTRSM_IUTUCOPY ctrsm_outucopy +#define CTRSM_IUTNCOPY ctrsm_outncopy +#define CTRSM_ILNUCOPY ctrsm_olnucopy +#define CTRSM_ILNNCOPY ctrsm_olnncopy +#define CTRSM_ILTUCOPY ctrsm_oltucopy +#define CTRSM_ILTNCOPY ctrsm_oltncopy +#else +#define CTRMM_IUNUCOPY ctrmm_iunucopy +#define CTRMM_IUNNCOPY ctrmm_iunncopy +#define CTRMM_IUTUCOPY ctrmm_iutucopy +#define CTRMM_IUTNCOPY ctrmm_iutncopy +#define CTRMM_ILNUCOPY ctrmm_ilnucopy +#define CTRMM_ILNNCOPY ctrmm_ilnncopy +#define CTRMM_ILTUCOPY ctrmm_iltucopy +#define CTRMM_ILTNCOPY ctrmm_iltncopy + +#define CTRSM_IUNUCOPY ctrsm_iunucopy +#define CTRSM_IUNNCOPY ctrsm_iunncopy +#define CTRSM_IUTUCOPY ctrsm_iutucopy +#define CTRSM_IUTNCOPY ctrsm_iutncopy +#define CTRSM_ILNUCOPY ctrsm_ilnucopy +#define CTRSM_ILNNCOPY ctrsm_ilnncopy +#define CTRSM_ILTUCOPY ctrsm_iltucopy +#define CTRSM_ILTNCOPY ctrsm_iltncopy +#endif + +#define CGEMM_BETA cgemm_beta + +#define CGEMM_KERNEL_N cgemm_kernel_n +#define CGEMM_KERNEL_L cgemm_kernel_l +#define CGEMM_KERNEL_R cgemm_kernel_r +#define CGEMM_KERNEL_B cgemm_kernel_b + +#define CTRMM_KERNEL_LN ctrmm_kernel_LN +#define CTRMM_KERNEL_LT ctrmm_kernel_LT +#define CTRMM_KERNEL_LR ctrmm_kernel_LR +#define CTRMM_KERNEL_LC ctrmm_kernel_LC +#define CTRMM_KERNEL_RN ctrmm_kernel_RN +#define CTRMM_KERNEL_RT ctrmm_kernel_RT +#define CTRMM_KERNEL_RR ctrmm_kernel_RR +#define CTRMM_KERNEL_RC ctrmm_kernel_RC + +#define CTRSM_KERNEL_LN ctrsm_kernel_LN +#define CTRSM_KERNEL_LT ctrsm_kernel_LT +#define CTRSM_KERNEL_LR ctrsm_kernel_LR +#define CTRSM_KERNEL_LC ctrsm_kernel_LC +#define CTRSM_KERNEL_RN ctrsm_kernel_RN +#define CTRSM_KERNEL_RT ctrsm_kernel_RT +#define CTRSM_KERNEL_RR ctrsm_kernel_RR +#define CTRSM_KERNEL_RC ctrsm_kernel_RC + +#define CSYMM_OUTCOPY csymm_outcopy +#define CSYMM_OLTCOPY csymm_oltcopy +#if CGEMM_DEFAULT_UNROLL_M == CGEMM_DEFAULT_UNROLL_N +#define CSYMM_IUTCOPY csymm_outcopy +#define CSYMM_ILTCOPY csymm_oltcopy +#else +#define CSYMM_IUTCOPY csymm_iutcopy +#define CSYMM_ILTCOPY csymm_iltcopy +#endif + +#define CHEMM_OUTCOPY chemm_outcopy +#define CHEMM_OLTCOPY chemm_oltcopy +#if CGEMM_DEFAULT_UNROLL_M == CGEMM_DEFAULT_UNROLL_N +#define CHEMM_IUTCOPY chemm_outcopy +#define CHEMM_ILTCOPY chemm_oltcopy +#else +#define CHEMM_IUTCOPY chemm_iutcopy +#define CHEMM_ILTCOPY chemm_iltcopy +#endif + +#define CGEMM3M_ONCOPYB cgemm3m_oncopyb +#define CGEMM3M_ONCOPYR cgemm3m_oncopyr +#define CGEMM3M_ONCOPYI cgemm3m_oncopyi +#define CGEMM3M_OTCOPYB cgemm3m_otcopyb +#define CGEMM3M_OTCOPYR cgemm3m_otcopyr +#define CGEMM3M_OTCOPYI cgemm3m_otcopyi + +#define CGEMM3M_INCOPYB cgemm3m_incopyb +#define CGEMM3M_INCOPYR cgemm3m_incopyr +#define CGEMM3M_INCOPYI cgemm3m_incopyi +#define CGEMM3M_ITCOPYB cgemm3m_itcopyb +#define CGEMM3M_ITCOPYR cgemm3m_itcopyr +#define CGEMM3M_ITCOPYI cgemm3m_itcopyi + +#define CSYMM3M_ILCOPYB csymm3m_ilcopyb +#define CSYMM3M_IUCOPYB csymm3m_iucopyb +#define CSYMM3M_ILCOPYR csymm3m_ilcopyr +#define CSYMM3M_IUCOPYR csymm3m_iucopyr +#define CSYMM3M_ILCOPYI csymm3m_ilcopyi +#define CSYMM3M_IUCOPYI csymm3m_iucopyi + +#define CSYMM3M_OLCOPYB csymm3m_olcopyb +#define CSYMM3M_OUCOPYB csymm3m_oucopyb +#define CSYMM3M_OLCOPYR csymm3m_olcopyr +#define CSYMM3M_OUCOPYR csymm3m_oucopyr +#define CSYMM3M_OLCOPYI csymm3m_olcopyi +#define CSYMM3M_OUCOPYI csymm3m_oucopyi + +#define CHEMM3M_ILCOPYB chemm3m_ilcopyb +#define CHEMM3M_IUCOPYB chemm3m_iucopyb +#define CHEMM3M_ILCOPYR chemm3m_ilcopyr +#define CHEMM3M_IUCOPYR chemm3m_iucopyr +#define CHEMM3M_ILCOPYI chemm3m_ilcopyi +#define CHEMM3M_IUCOPYI chemm3m_iucopyi + +#define CHEMM3M_OLCOPYB chemm3m_olcopyb +#define CHEMM3M_OUCOPYB chemm3m_oucopyb +#define CHEMM3M_OLCOPYR chemm3m_olcopyr +#define CHEMM3M_OUCOPYR chemm3m_oucopyr +#define CHEMM3M_OLCOPYI chemm3m_olcopyi +#define CHEMM3M_OUCOPYI chemm3m_oucopyi + +#define CGEMM3M_KERNEL cgemm3m_kernel + +#define CNEG_TCOPY cneg_tcopy +#define CLASWP_NCOPY claswp_ncopy + +#else + +#define CAMAX_K gotoblas -> camax_k +#define CAMIN_K gotoblas -> camin_k +#define CMAX_K gotoblas -> cmax_k +#define CMIN_K gotoblas -> cmin_k +#define ICAMAX_K gotoblas -> icamax_k +#define ICAMIN_K gotoblas -> icamin_k +#define ICMAX_K gotoblas -> icmax_k +#define ICMIN_K gotoblas -> icmin_k +#define CASUM_K gotoblas -> casum_k +#define CAXPYU_K gotoblas -> caxpy_k +#define CAXPYC_K gotoblas -> caxpyc_k +#define CCOPY_K gotoblas -> ccopy_k +#define CDOTU_K gotoblas -> cdotu_k +#define CDOTC_K gotoblas -> cdotc_k +#define CNRM2_K gotoblas -> cnrm2_k +#define CSCAL_K gotoblas -> cscal_k +#define CSWAP_K gotoblas -> cswap_k +#define CROT_K gotoblas -> csrot_k + +#define CGEMV_N gotoblas -> cgemv_n +#define CGEMV_T gotoblas -> cgemv_t +#define CGEMV_R gotoblas -> cgemv_r +#define CGEMV_C gotoblas -> cgemv_c +#define CGEMV_O gotoblas -> cgemv_o +#define CGEMV_U gotoblas -> cgemv_u +#define CGEMV_S gotoblas -> cgemv_s +#define CGEMV_D gotoblas -> cgemv_d + +#define CGERU_K gotoblas -> cgeru_k +#define CGERC_K gotoblas -> cgerc_k +#define CGERV_K gotoblas -> cgerv_k +#define CGERD_K gotoblas -> cgerd_k + +#define CSYMV_U gotoblas -> csymv_U +#define CSYMV_L gotoblas -> csymv_L +#define CHEMV_U gotoblas -> chemv_U +#define CHEMV_L gotoblas -> chemv_L +#define CHEMV_V gotoblas -> chemv_V +#define CHEMV_M gotoblas -> chemv_M + +#define CSYMV_THREAD_U csymv_thread_U +#define CSYMV_THREAD_L csymv_thread_L +#define CHEMV_THREAD_U chemv_thread_U +#define CHEMV_THREAD_L chemv_thread_L +#define CHEMV_THREAD_V chemv_thread_V +#define CHEMV_THREAD_M chemv_thread_M + +#define CGEMM_ONCOPY gotoblas -> cgemm_oncopy +#define CGEMM_OTCOPY gotoblas -> cgemm_otcopy +#define CGEMM_INCOPY gotoblas -> cgemm_incopy +#define CGEMM_ITCOPY gotoblas -> cgemm_itcopy + +#define CTRMM_OUNUCOPY gotoblas -> ctrmm_ounucopy +#define CTRMM_OUTUCOPY gotoblas -> ctrmm_outucopy +#define CTRMM_OLNUCOPY gotoblas -> ctrmm_olnucopy +#define CTRMM_OLTUCOPY gotoblas -> ctrmm_oltucopy +#define CTRSM_OUNUCOPY gotoblas -> ctrsm_ounucopy +#define CTRSM_OUTUCOPY gotoblas -> ctrsm_outucopy +#define CTRSM_OLNUCOPY gotoblas -> ctrsm_olnucopy +#define CTRSM_OLTUCOPY gotoblas -> ctrsm_oltucopy + +#define CTRMM_IUNUCOPY gotoblas -> ctrmm_iunucopy +#define CTRMM_IUTUCOPY gotoblas -> ctrmm_iutucopy +#define CTRMM_ILNUCOPY gotoblas -> ctrmm_ilnucopy +#define CTRMM_ILTUCOPY gotoblas -> ctrmm_iltucopy +#define CTRSM_IUNUCOPY gotoblas -> ctrsm_iunucopy +#define CTRSM_IUTUCOPY gotoblas -> ctrsm_iutucopy +#define CTRSM_ILNUCOPY gotoblas -> ctrsm_ilnucopy +#define CTRSM_ILTUCOPY gotoblas -> ctrsm_iltucopy + +#define CTRMM_OUNNCOPY gotoblas -> ctrmm_ounncopy +#define CTRMM_OUTNCOPY gotoblas -> ctrmm_outncopy +#define CTRMM_OLNNCOPY gotoblas -> ctrmm_olnncopy +#define CTRMM_OLTNCOPY gotoblas -> ctrmm_oltncopy +#define CTRSM_OUNNCOPY gotoblas -> ctrsm_ounncopy +#define CTRSM_OUTNCOPY gotoblas -> ctrsm_outncopy +#define CTRSM_OLNNCOPY gotoblas -> ctrsm_olnncopy +#define CTRSM_OLTNCOPY gotoblas -> ctrsm_oltncopy + +#define CTRMM_IUNNCOPY gotoblas -> ctrmm_iunncopy +#define CTRMM_IUTNCOPY gotoblas -> ctrmm_iutncopy +#define CTRMM_ILNNCOPY gotoblas -> ctrmm_ilnncopy +#define CTRMM_ILTNCOPY gotoblas -> ctrmm_iltncopy +#define CTRSM_IUNNCOPY gotoblas -> ctrsm_iunncopy +#define CTRSM_IUTNCOPY gotoblas -> ctrsm_iutncopy +#define CTRSM_ILNNCOPY gotoblas -> ctrsm_ilnncopy +#define CTRSM_ILTNCOPY gotoblas -> ctrsm_iltncopy + +#define CGEMM_BETA gotoblas -> cgemm_beta +#define CGEMM_KERNEL_N gotoblas -> cgemm_kernel_n +#define CGEMM_KERNEL_L gotoblas -> cgemm_kernel_l +#define CGEMM_KERNEL_R gotoblas -> cgemm_kernel_r +#define CGEMM_KERNEL_B gotoblas -> cgemm_kernel_b + +#define CTRMM_KERNEL_LN gotoblas -> ctrmm_kernel_LN +#define CTRMM_KERNEL_LT gotoblas -> ctrmm_kernel_LT +#define CTRMM_KERNEL_LR gotoblas -> ctrmm_kernel_LR +#define CTRMM_KERNEL_LC gotoblas -> ctrmm_kernel_LC +#define CTRMM_KERNEL_RN gotoblas -> ctrmm_kernel_RN +#define CTRMM_KERNEL_RT gotoblas -> ctrmm_kernel_RT +#define CTRMM_KERNEL_RR gotoblas -> ctrmm_kernel_RR +#define CTRMM_KERNEL_RC gotoblas -> ctrmm_kernel_RC + +#define CTRSM_KERNEL_LN gotoblas -> ctrsm_kernel_LN +#define CTRSM_KERNEL_LT gotoblas -> ctrsm_kernel_LT +#define CTRSM_KERNEL_LR gotoblas -> ctrsm_kernel_LR +#define CTRSM_KERNEL_LC gotoblas -> ctrsm_kernel_LC +#define CTRSM_KERNEL_RN gotoblas -> ctrsm_kernel_RN +#define CTRSM_KERNEL_RT gotoblas -> ctrsm_kernel_RT +#define CTRSM_KERNEL_RR gotoblas -> ctrsm_kernel_RR +#define CTRSM_KERNEL_RC gotoblas -> ctrsm_kernel_RC + +#define CSYMM_IUTCOPY gotoblas -> csymm_iutcopy +#define CSYMM_ILTCOPY gotoblas -> csymm_iltcopy +#define CSYMM_OUTCOPY gotoblas -> csymm_outcopy +#define CSYMM_OLTCOPY gotoblas -> csymm_oltcopy + +#define CHEMM_OUTCOPY gotoblas -> chemm_outcopy +#define CHEMM_OLTCOPY gotoblas -> chemm_oltcopy +#define CHEMM_IUTCOPY gotoblas -> chemm_iutcopy +#define CHEMM_ILTCOPY gotoblas -> chemm_iltcopy + +#define CGEMM3M_ONCOPYB gotoblas -> cgemm3m_oncopyb +#define CGEMM3M_ONCOPYR gotoblas -> cgemm3m_oncopyr +#define CGEMM3M_ONCOPYI gotoblas -> cgemm3m_oncopyi +#define CGEMM3M_OTCOPYB gotoblas -> cgemm3m_otcopyb +#define CGEMM3M_OTCOPYR gotoblas -> cgemm3m_otcopyr +#define CGEMM3M_OTCOPYI gotoblas -> cgemm3m_otcopyi + +#define CGEMM3M_INCOPYB gotoblas -> cgemm3m_incopyb +#define CGEMM3M_INCOPYR gotoblas -> cgemm3m_incopyr +#define CGEMM3M_INCOPYI gotoblas -> cgemm3m_incopyi +#define CGEMM3M_ITCOPYB gotoblas -> cgemm3m_itcopyb +#define CGEMM3M_ITCOPYR gotoblas -> cgemm3m_itcopyr +#define CGEMM3M_ITCOPYI gotoblas -> cgemm3m_itcopyi + +#define CSYMM3M_ILCOPYB gotoblas -> csymm3m_ilcopyb +#define CSYMM3M_IUCOPYB gotoblas -> csymm3m_iucopyb +#define CSYMM3M_ILCOPYR gotoblas -> csymm3m_ilcopyr +#define CSYMM3M_IUCOPYR gotoblas -> csymm3m_iucopyr +#define CSYMM3M_ILCOPYI gotoblas -> csymm3m_ilcopyi +#define CSYMM3M_IUCOPYI gotoblas -> csymm3m_iucopyi + +#define CSYMM3M_OLCOPYB gotoblas -> csymm3m_olcopyb +#define CSYMM3M_OUCOPYB gotoblas -> csymm3m_oucopyb +#define CSYMM3M_OLCOPYR gotoblas -> csymm3m_olcopyr +#define CSYMM3M_OUCOPYR gotoblas -> csymm3m_oucopyr +#define CSYMM3M_OLCOPYI gotoblas -> csymm3m_olcopyi +#define CSYMM3M_OUCOPYI gotoblas -> csymm3m_oucopyi + +#define CHEMM3M_ILCOPYB gotoblas -> chemm3m_ilcopyb +#define CHEMM3M_IUCOPYB gotoblas -> chemm3m_iucopyb +#define CHEMM3M_ILCOPYR gotoblas -> chemm3m_ilcopyr +#define CHEMM3M_IUCOPYR gotoblas -> chemm3m_iucopyr +#define CHEMM3M_ILCOPYI gotoblas -> chemm3m_ilcopyi +#define CHEMM3M_IUCOPYI gotoblas -> chemm3m_iucopyi + +#define CHEMM3M_OLCOPYB gotoblas -> chemm3m_olcopyb +#define CHEMM3M_OUCOPYB gotoblas -> chemm3m_oucopyb +#define CHEMM3M_OLCOPYR gotoblas -> chemm3m_olcopyr +#define CHEMM3M_OUCOPYR gotoblas -> chemm3m_oucopyr +#define CHEMM3M_OLCOPYI gotoblas -> chemm3m_olcopyi +#define CHEMM3M_OUCOPYI gotoblas -> chemm3m_oucopyi + +#define CGEMM3M_KERNEL gotoblas -> cgemm3m_kernel + +#define CNEG_TCOPY gotoblas -> cneg_tcopy +#define CLASWP_NCOPY gotoblas -> claswp_ncopy + +#endif + +#define CGEMM_NN cgemm_nn +#define CGEMM_CN cgemm_cn +#define CGEMM_TN cgemm_tn +#define CGEMM_NC cgemm_nc +#define CGEMM_NT cgemm_nt +#define CGEMM_CC cgemm_cc +#define CGEMM_CT cgemm_ct +#define CGEMM_TC cgemm_tc +#define CGEMM_TT cgemm_tt +#define CGEMM_NR cgemm_nr +#define CGEMM_TR cgemm_tr +#define CGEMM_CR cgemm_cr +#define CGEMM_RN cgemm_rn +#define CGEMM_RT cgemm_rt +#define CGEMM_RC cgemm_rc +#define CGEMM_RR cgemm_rr + +#define CSYMM_LU csymm_LU +#define CSYMM_LL csymm_LL +#define CSYMM_RU csymm_RU +#define CSYMM_RL csymm_RL + +#define CHEMM_LU chemm_LU +#define CHEMM_LL chemm_LL +#define CHEMM_RU chemm_RU +#define CHEMM_RL chemm_RL + +#define CSYRK_UN csyrk_UN +#define CSYRK_UT csyrk_UT +#define CSYRK_LN csyrk_LN +#define CSYRK_LT csyrk_LT +#define CSYRK_UR csyrk_UN +#define CSYRK_UC csyrk_UT +#define CSYRK_LR csyrk_LN +#define CSYRK_LC csyrk_LT + +#define CSYRK_KERNEL_U csyrk_kernel_U +#define CSYRK_KERNEL_L csyrk_kernel_L + +#define CHERK_UN cherk_UN +#define CHERK_LN cherk_LN +#define CHERK_UC cherk_UC +#define CHERK_LC cherk_LC + +#define CHER2K_UN cher2k_UN +#define CHER2K_LN cher2k_LN +#define CHER2K_UC cher2k_UC +#define CHER2K_LC cher2k_LC + +#define CSYR2K_UN csyr2k_UN +#define CSYR2K_UT csyr2k_UT +#define CSYR2K_LN csyr2k_LN +#define CSYR2K_LT csyr2k_LT +#define CSYR2K_UR csyr2k_UN +#define CSYR2K_UC csyr2k_UT +#define CSYR2K_LR csyr2k_LN +#define CSYR2K_LC csyr2k_LT + +#define CSYR2K_KERNEL_U csyr2k_kernel_U +#define CSYR2K_KERNEL_L csyr2k_kernel_L + +#define CTRMM_LNUU ctrmm_LNUU +#define CTRMM_LNUN ctrmm_LNUN +#define CTRMM_LNLU ctrmm_LNLU +#define CTRMM_LNLN ctrmm_LNLN +#define CTRMM_LTUU ctrmm_LTUU +#define CTRMM_LTUN ctrmm_LTUN +#define CTRMM_LTLU ctrmm_LTLU +#define CTRMM_LTLN ctrmm_LTLN +#define CTRMM_LRUU ctrmm_LRUU +#define CTRMM_LRUN ctrmm_LRUN +#define CTRMM_LRLU ctrmm_LRLU +#define CTRMM_LRLN ctrmm_LRLN +#define CTRMM_LCUU ctrmm_LCUU +#define CTRMM_LCUN ctrmm_LCUN +#define CTRMM_LCLU ctrmm_LCLU +#define CTRMM_LCLN ctrmm_LCLN +#define CTRMM_RNUU ctrmm_RNUU +#define CTRMM_RNUN ctrmm_RNUN +#define CTRMM_RNLU ctrmm_RNLU +#define CTRMM_RNLN ctrmm_RNLN +#define CTRMM_RTUU ctrmm_RTUU +#define CTRMM_RTUN ctrmm_RTUN +#define CTRMM_RTLU ctrmm_RTLU +#define CTRMM_RTLN ctrmm_RTLN +#define CTRMM_RRUU ctrmm_RRUU +#define CTRMM_RRUN ctrmm_RRUN +#define CTRMM_RRLU ctrmm_RRLU +#define CTRMM_RRLN ctrmm_RRLN +#define CTRMM_RCUU ctrmm_RCUU +#define CTRMM_RCUN ctrmm_RCUN +#define CTRMM_RCLU ctrmm_RCLU +#define CTRMM_RCLN ctrmm_RCLN + +#define CTRSM_LNUU ctrsm_LNUU +#define CTRSM_LNUN ctrsm_LNUN +#define CTRSM_LNLU ctrsm_LNLU +#define CTRSM_LNLN ctrsm_LNLN +#define CTRSM_LTUU ctrsm_LTUU +#define CTRSM_LTUN ctrsm_LTUN +#define CTRSM_LTLU ctrsm_LTLU +#define CTRSM_LTLN ctrsm_LTLN +#define CTRSM_LRUU ctrsm_LRUU +#define CTRSM_LRUN ctrsm_LRUN +#define CTRSM_LRLU ctrsm_LRLU +#define CTRSM_LRLN ctrsm_LRLN +#define CTRSM_LCUU ctrsm_LCUU +#define CTRSM_LCUN ctrsm_LCUN +#define CTRSM_LCLU ctrsm_LCLU +#define CTRSM_LCLN ctrsm_LCLN +#define CTRSM_RNUU ctrsm_RNUU +#define CTRSM_RNUN ctrsm_RNUN +#define CTRSM_RNLU ctrsm_RNLU +#define CTRSM_RNLN ctrsm_RNLN +#define CTRSM_RTUU ctrsm_RTUU +#define CTRSM_RTUN ctrsm_RTUN +#define CTRSM_RTLU ctrsm_RTLU +#define CTRSM_RTLN ctrsm_RTLN +#define CTRSM_RRUU ctrsm_RRUU +#define CTRSM_RRUN ctrsm_RRUN +#define CTRSM_RRLU ctrsm_RRLU +#define CTRSM_RRLN ctrsm_RRLN +#define CTRSM_RCUU ctrsm_RCUU +#define CTRSM_RCUN ctrsm_RCUN +#define CTRSM_RCLU ctrsm_RCLU +#define CTRSM_RCLN ctrsm_RCLN + +#define CGEMM_THREAD_NN cgemm_thread_nn +#define CGEMM_THREAD_CN cgemm_thread_cn +#define CGEMM_THREAD_TN cgemm_thread_tn +#define CGEMM_THREAD_NC cgemm_thread_nc +#define CGEMM_THREAD_NT cgemm_thread_nt +#define CGEMM_THREAD_CC cgemm_thread_cc +#define CGEMM_THREAD_CT cgemm_thread_ct +#define CGEMM_THREAD_TC cgemm_thread_tc +#define CGEMM_THREAD_TT cgemm_thread_tt +#define CGEMM_THREAD_NR cgemm_thread_nr +#define CGEMM_THREAD_TR cgemm_thread_tr +#define CGEMM_THREAD_CR cgemm_thread_cr +#define CGEMM_THREAD_RN cgemm_thread_rn +#define CGEMM_THREAD_RT cgemm_thread_rt +#define CGEMM_THREAD_RC cgemm_thread_rc +#define CGEMM_THREAD_RR cgemm_thread_rr + +#define CSYMM_THREAD_LU csymm_thread_LU +#define CSYMM_THREAD_LL csymm_thread_LL +#define CSYMM_THREAD_RU csymm_thread_RU +#define CSYMM_THREAD_RL csymm_thread_RL + +#define CHEMM_THREAD_LU chemm_thread_LU +#define CHEMM_THREAD_LL chemm_thread_LL +#define CHEMM_THREAD_RU chemm_thread_RU +#define CHEMM_THREAD_RL chemm_thread_RL + +#define CSYRK_THREAD_UN csyrk_thread_UN +#define CSYRK_THREAD_UT csyrk_thread_UT +#define CSYRK_THREAD_LN csyrk_thread_LN +#define CSYRK_THREAD_LT csyrk_thread_LT +#define CSYRK_THREAD_UR csyrk_thread_UN +#define CSYRK_THREAD_UC csyrk_thread_UT +#define CSYRK_THREAD_LR csyrk_thread_LN +#define CSYRK_THREAD_LC csyrk_thread_LT + +#define CHERK_THREAD_UN cherk_thread_UN +#define CHERK_THREAD_UT cherk_thread_UT +#define CHERK_THREAD_LN cherk_thread_LN +#define CHERK_THREAD_LT cherk_thread_LT +#define CHERK_THREAD_UR cherk_thread_UR +#define CHERK_THREAD_UC cherk_thread_UC +#define CHERK_THREAD_LR cherk_thread_LR +#define CHERK_THREAD_LC cherk_thread_LC + +#define CGEMM3M_NN cgemm3m_nn +#define CGEMM3M_CN cgemm3m_cn +#define CGEMM3M_TN cgemm3m_tn +#define CGEMM3M_NC cgemm3m_nc +#define CGEMM3M_NT cgemm3m_nt +#define CGEMM3M_CC cgemm3m_cc +#define CGEMM3M_CT cgemm3m_ct +#define CGEMM3M_TC cgemm3m_tc +#define CGEMM3M_TT cgemm3m_tt +#define CGEMM3M_NR cgemm3m_nr +#define CGEMM3M_TR cgemm3m_tr +#define CGEMM3M_CR cgemm3m_cr +#define CGEMM3M_RN cgemm3m_rn +#define CGEMM3M_RT cgemm3m_rt +#define CGEMM3M_RC cgemm3m_rc +#define CGEMM3M_RR cgemm3m_rr + +#define CGEMM3M_THREAD_NN cgemm3m_thread_nn +#define CGEMM3M_THREAD_CN cgemm3m_thread_cn +#define CGEMM3M_THREAD_TN cgemm3m_thread_tn +#define CGEMM3M_THREAD_NC cgemm3m_thread_nc +#define CGEMM3M_THREAD_NT cgemm3m_thread_nt +#define CGEMM3M_THREAD_CC cgemm3m_thread_cc +#define CGEMM3M_THREAD_CT cgemm3m_thread_ct +#define CGEMM3M_THREAD_TC cgemm3m_thread_tc +#define CGEMM3M_THREAD_TT cgemm3m_thread_tt +#define CGEMM3M_THREAD_NR cgemm3m_thread_nr +#define CGEMM3M_THREAD_TR cgemm3m_thread_tr +#define CGEMM3M_THREAD_CR cgemm3m_thread_cr +#define CGEMM3M_THREAD_RN cgemm3m_thread_rn +#define CGEMM3M_THREAD_RT cgemm3m_thread_rt +#define CGEMM3M_THREAD_RC cgemm3m_thread_rc +#define CGEMM3M_THREAD_RR cgemm3m_thread_rr + +#define CSYMM3M_LU csymm3m_LU +#define CSYMM3M_LL csymm3m_LL +#define CSYMM3M_RU csymm3m_RU +#define CSYMM3M_RL csymm3m_RL + +#define CSYMM3M_THREAD_LU csymm3m_thread_LU +#define CSYMM3M_THREAD_LL csymm3m_thread_LL +#define CSYMM3M_THREAD_RU csymm3m_thread_RU +#define CSYMM3M_THREAD_RL csymm3m_thread_RL + +#define CHEMM3M_LU chemm3m_LU +#define CHEMM3M_LL chemm3m_LL +#define CHEMM3M_RU chemm3m_RU +#define CHEMM3M_RL chemm3m_RL + +#define CHEMM3M_THREAD_LU chemm3m_thread_LU +#define CHEMM3M_THREAD_LL chemm3m_thread_LL +#define CHEMM3M_THREAD_RU chemm3m_thread_RU +#define CHEMM3M_THREAD_RL chemm3m_thread_RL + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_d.h b/src/NativeWrappers/GotoBlas2/include/common_d.h new file mode 100644 index 00000000..4c9a53f6 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_d.h @@ -0,0 +1,432 @@ +#ifndef COMMON_D_H +#define COMMON_D_H + +#ifndef DYNAMIC_ARCH + +#define DAMAX_K damax_k +#define DAMIN_K damin_k +#define DMAX_K dmax_k +#define DMIN_K dmin_k +#define IDAMAX_K idamax_k +#define IDAMIN_K idamin_k +#define IDMAX_K idmax_k +#define IDMIN_K idmin_k +#define DASUM_K dasum_k +#define DAXPYU_K daxpy_k +#define DAXPYC_K daxpy_k +#define DCOPY_K dcopy_k +#define DDOTU_K ddot_k +#define DDOTC_K ddot_k +#define DNRM2_K dnrm2_k +#define DSCAL_K dscal_k +#define DSWAP_K dswap_k +#define DROT_K drot_k + +#define DGEMV_N dgemv_n +#define DGEMV_T dgemv_t +#define DGEMV_R dgemv_n +#define DGEMV_C dgemv_t +#define DGEMV_O dgemv_n +#define DGEMV_U dgemv_t +#define DGEMV_S dgemv_n +#define DGEMV_D dgemv_t + +#define DGERU_K dger_k +#define DGERC_K dger_k +#define DGERV_K dger_k +#define DGERD_K dger_k + +#define DSYMV_U dsymv_U +#define DSYMV_L dsymv_L + +#define DSYMV_THREAD_U dsymv_thread_U +#define DSYMV_THREAD_L dsymv_thread_L + +#define DGEMM_ONCOPY dgemm_oncopy +#define DGEMM_OTCOPY dgemm_otcopy + +#if DGEMM_DEFAULT_UNROLL_M == DGEMM_DEFAULT_UNROLL_N +#define DGEMM_INCOPY dgemm_oncopy +#define DGEMM_ITCOPY dgemm_otcopy +#else +#define DGEMM_INCOPY dgemm_incopy +#define DGEMM_ITCOPY dgemm_itcopy +#endif + +#define DTRMM_OUNUCOPY dtrmm_ounucopy +#define DTRMM_OUNNCOPY dtrmm_ounncopy +#define DTRMM_OUTUCOPY dtrmm_outucopy +#define DTRMM_OUTNCOPY dtrmm_outncopy +#define DTRMM_OLNUCOPY dtrmm_olnucopy +#define DTRMM_OLNNCOPY dtrmm_olnncopy +#define DTRMM_OLTUCOPY dtrmm_oltucopy +#define DTRMM_OLTNCOPY dtrmm_oltncopy + +#define DTRSM_OUNUCOPY dtrsm_ounucopy +#define DTRSM_OUNNCOPY dtrsm_ounncopy +#define DTRSM_OUTUCOPY dtrsm_outucopy +#define DTRSM_OUTNCOPY dtrsm_outncopy +#define DTRSM_OLNUCOPY dtrsm_olnucopy +#define DTRSM_OLNNCOPY dtrsm_olnncopy +#define DTRSM_OLTUCOPY dtrsm_oltucopy +#define DTRSM_OLTNCOPY dtrsm_oltncopy + +#if DGEMM_DEFAULT_UNROLL_M == DGEMM_DEFAULT_UNROLL_N +#define DTRMM_IUNUCOPY dtrmm_ounucopy +#define DTRMM_IUNNCOPY dtrmm_ounncopy +#define DTRMM_IUTUCOPY dtrmm_outucopy +#define DTRMM_IUTNCOPY dtrmm_outncopy +#define DTRMM_ILNUCOPY dtrmm_olnucopy +#define DTRMM_ILNNCOPY dtrmm_olnncopy +#define DTRMM_ILTUCOPY dtrmm_oltucopy +#define DTRMM_ILTNCOPY dtrmm_oltncopy + +#define DTRSM_IUNUCOPY dtrsm_ounucopy +#define DTRSM_IUNNCOPY dtrsm_ounncopy +#define DTRSM_IUTUCOPY dtrsm_outucopy +#define DTRSM_IUTNCOPY dtrsm_outncopy +#define DTRSM_ILNUCOPY dtrsm_olnucopy +#define DTRSM_ILNNCOPY dtrsm_olnncopy +#define DTRSM_ILTUCOPY dtrsm_oltucopy +#define DTRSM_ILTNCOPY dtrsm_oltncopy +#else +#define DTRMM_IUNUCOPY dtrmm_iunucopy +#define DTRMM_IUNNCOPY dtrmm_iunncopy +#define DTRMM_IUTUCOPY dtrmm_iutucopy +#define DTRMM_IUTNCOPY dtrmm_iutncopy +#define DTRMM_ILNUCOPY dtrmm_ilnucopy +#define DTRMM_ILNNCOPY dtrmm_ilnncopy +#define DTRMM_ILTUCOPY dtrmm_iltucopy +#define DTRMM_ILTNCOPY dtrmm_iltncopy + +#define DTRSM_IUNUCOPY dtrsm_iunucopy +#define DTRSM_IUNNCOPY dtrsm_iunncopy +#define DTRSM_IUTUCOPY dtrsm_iutucopy +#define DTRSM_IUTNCOPY dtrsm_iutncopy +#define DTRSM_ILNUCOPY dtrsm_ilnucopy +#define DTRSM_ILNNCOPY dtrsm_ilnncopy +#define DTRSM_ILTUCOPY dtrsm_iltucopy +#define DTRSM_ILTNCOPY dtrsm_iltncopy +#endif + +#define DGEMM_BETA dgemm_beta + +#define DGEMM_KERNEL dgemm_kernel + +#define DTRMM_KERNEL_LN dtrmm_kernel_LN +#define DTRMM_KERNEL_LT dtrmm_kernel_LT +#define DTRMM_KERNEL_LR dtrmm_kernel_LN +#define DTRMM_KERNEL_LC dtrmm_kernel_LT +#define DTRMM_KERNEL_RN dtrmm_kernel_RN +#define DTRMM_KERNEL_RT dtrmm_kernel_RT +#define DTRMM_KERNEL_RR dtrmm_kernel_RN +#define DTRMM_KERNEL_RC dtrmm_kernel_RT + +#define DTRSM_KERNEL_LN dtrsm_kernel_LN +#define DTRSM_KERNEL_LT dtrsm_kernel_LT +#define DTRSM_KERNEL_LR dtrsm_kernel_LN +#define DTRSM_KERNEL_LC dtrsm_kernel_LT +#define DTRSM_KERNEL_RN dtrsm_kernel_RN +#define DTRSM_KERNEL_RT dtrsm_kernel_RT +#define DTRSM_KERNEL_RR dtrsm_kernel_RN +#define DTRSM_KERNEL_RC dtrsm_kernel_RT + +#define DSYMM_OUTCOPY dsymm_outcopy +#define DSYMM_OLTCOPY dsymm_oltcopy +#if DGEMM_DEFAULT_UNROLL_M == DGEMM_DEFAULT_UNROLL_N +#define DSYMM_IUTCOPY dsymm_outcopy +#define DSYMM_ILTCOPY dsymm_oltcopy +#else +#define DSYMM_IUTCOPY dsymm_iutcopy +#define DSYMM_ILTCOPY dsymm_iltcopy +#endif + +#define DNEG_TCOPY dneg_tcopy +#define DLASWP_NCOPY dlaswp_ncopy + +#else + +#define DAMAX_K gotoblas -> damax_k +#define DAMIN_K gotoblas -> damin_k +#define DMAX_K gotoblas -> dmax_k +#define DMIN_K gotoblas -> dmin_k +#define IDAMAX_K gotoblas -> idamax_k +#define IDAMIN_K gotoblas -> idamin_k +#define IDMAX_K gotoblas -> idmax_k +#define IDMIN_K gotoblas -> idmin_k +#define DASUM_K gotoblas -> dasum_k +#define DAXPYU_K gotoblas -> daxpy_k +#define DAXPYC_K gotoblas -> daxpy_k +#define DCOPY_K gotoblas -> dcopy_k +#define DDOTU_K gotoblas -> ddot_k +#define DDOTC_K gotoblas -> ddot_k +#define DNRM2_K gotoblas -> dnrm2_k +#define DSCAL_K gotoblas -> dscal_k +#define DSWAP_K gotoblas -> dswap_k +#define DROT_K gotoblas -> drot_k + +#define DGEMV_N gotoblas -> dgemv_n +#define DGEMV_T gotoblas -> dgemv_t +#define DGEMV_R gotoblas -> dgemv_n +#define DGEMV_C gotoblas -> dgemv_t +#define DGEMV_O gotoblas -> dgemv_n +#define DGEMV_U gotoblas -> dgemv_t +#define DGEMV_S gotoblas -> dgemv_n +#define DGEMV_D gotoblas -> dgemv_t + +#define DGERU_K gotoblas -> dger_k +#define DGERC_K gotoblas -> dger_k +#define DGERV_K gotoblas -> dger_k +#define DGERD_K gotoblas -> dger_k + +#define DSYMV_U gotoblas -> dsymv_U +#define DSYMV_L gotoblas -> dsymv_L + +#define DSYMV_THREAD_U dsymv_thread_U +#define DSYMV_THREAD_L dsymv_thread_L + +#define DGEMM_ONCOPY gotoblas -> dgemm_oncopy +#define DGEMM_OTCOPY gotoblas -> dgemm_otcopy +#define DGEMM_INCOPY gotoblas -> dgemm_incopy +#define DGEMM_ITCOPY gotoblas -> dgemm_itcopy + +#define DTRMM_OUNUCOPY gotoblas -> dtrmm_ounucopy +#define DTRMM_OUTUCOPY gotoblas -> dtrmm_outucopy +#define DTRMM_OLNUCOPY gotoblas -> dtrmm_olnucopy +#define DTRMM_OLTUCOPY gotoblas -> dtrmm_oltucopy +#define DTRSM_OUNUCOPY gotoblas -> dtrsm_ounucopy +#define DTRSM_OUTUCOPY gotoblas -> dtrsm_outucopy +#define DTRSM_OLNUCOPY gotoblas -> dtrsm_olnucopy +#define DTRSM_OLTUCOPY gotoblas -> dtrsm_oltucopy + +#define DTRMM_IUNUCOPY gotoblas -> dtrmm_iunucopy +#define DTRMM_IUTUCOPY gotoblas -> dtrmm_iutucopy +#define DTRMM_ILNUCOPY gotoblas -> dtrmm_ilnucopy +#define DTRMM_ILTUCOPY gotoblas -> dtrmm_iltucopy +#define DTRSM_IUNUCOPY gotoblas -> dtrsm_iunucopy +#define DTRSM_IUTUCOPY gotoblas -> dtrsm_iutucopy +#define DTRSM_ILNUCOPY gotoblas -> dtrsm_ilnucopy +#define DTRSM_ILTUCOPY gotoblas -> dtrsm_iltucopy + +#define DTRMM_OUNNCOPY gotoblas -> dtrmm_ounncopy +#define DTRMM_OUTNCOPY gotoblas -> dtrmm_outncopy +#define DTRMM_OLNNCOPY gotoblas -> dtrmm_olnncopy +#define DTRMM_OLTNCOPY gotoblas -> dtrmm_oltncopy +#define DTRSM_OUNNCOPY gotoblas -> dtrsm_ounncopy +#define DTRSM_OUTNCOPY gotoblas -> dtrsm_outncopy +#define DTRSM_OLNNCOPY gotoblas -> dtrsm_olnncopy +#define DTRSM_OLTNCOPY gotoblas -> dtrsm_oltncopy + +#define DTRMM_IUNNCOPY gotoblas -> dtrmm_iunncopy +#define DTRMM_IUTNCOPY gotoblas -> dtrmm_iutncopy +#define DTRMM_ILNNCOPY gotoblas -> dtrmm_ilnncopy +#define DTRMM_ILTNCOPY gotoblas -> dtrmm_iltncopy +#define DTRSM_IUNNCOPY gotoblas -> dtrsm_iunncopy +#define DTRSM_IUTNCOPY gotoblas -> dtrsm_iutncopy +#define DTRSM_ILNNCOPY gotoblas -> dtrsm_ilnncopy +#define DTRSM_ILTNCOPY gotoblas -> dtrsm_iltncopy + +#define DGEMM_BETA gotoblas -> dgemm_beta +#define DGEMM_KERNEL gotoblas -> dgemm_kernel + +#define DTRMM_KERNEL_LN gotoblas -> dtrmm_kernel_LN +#define DTRMM_KERNEL_LT gotoblas -> dtrmm_kernel_LT +#define DTRMM_KERNEL_LR gotoblas -> dtrmm_kernel_LN +#define DTRMM_KERNEL_LC gotoblas -> dtrmm_kernel_LT +#define DTRMM_KERNEL_RN gotoblas -> dtrmm_kernel_RN +#define DTRMM_KERNEL_RT gotoblas -> dtrmm_kernel_RT +#define DTRMM_KERNEL_RR gotoblas -> dtrmm_kernel_RN +#define DTRMM_KERNEL_RC gotoblas -> dtrmm_kernel_RT + +#define DTRSM_KERNEL_LN gotoblas -> dtrsm_kernel_LN +#define DTRSM_KERNEL_LT gotoblas -> dtrsm_kernel_LT +#define DTRSM_KERNEL_LR gotoblas -> dtrsm_kernel_LN +#define DTRSM_KERNEL_LC gotoblas -> dtrsm_kernel_LT +#define DTRSM_KERNEL_RN gotoblas -> dtrsm_kernel_RN +#define DTRSM_KERNEL_RT gotoblas -> dtrsm_kernel_RT +#define DTRSM_KERNEL_RR gotoblas -> dtrsm_kernel_RN +#define DTRSM_KERNEL_RC gotoblas -> dtrsm_kernel_RT + +#define DSYMM_IUTCOPY gotoblas -> dsymm_iutcopy +#define DSYMM_ILTCOPY gotoblas -> dsymm_iltcopy +#define DSYMM_OUTCOPY gotoblas -> dsymm_outcopy +#define DSYMM_OLTCOPY gotoblas -> dsymm_oltcopy + +#define DNEG_TCOPY gotoblas -> dneg_tcopy +#define DLASWP_NCOPY gotoblas -> dlaswp_ncopy + +#endif + +#define DGEMM_NN dgemm_nn +#define DGEMM_CN dgemm_tn +#define DGEMM_TN dgemm_tn +#define DGEMM_NC dgemm_nt +#define DGEMM_NT dgemm_nt +#define DGEMM_CC dgemm_tt +#define DGEMM_CT dgemm_tt +#define DGEMM_TC dgemm_tt +#define DGEMM_TT dgemm_tt +#define DGEMM_NR dgemm_nn +#define DGEMM_TR dgemm_tn +#define DGEMM_CR dgemm_tn +#define DGEMM_RN dgemm_nn +#define DGEMM_RT dgemm_nt +#define DGEMM_RC dgemm_nt +#define DGEMM_RR dgemm_nn + +#define DSYMM_LU dsymm_LU +#define DSYMM_LL dsymm_LL +#define DSYMM_RU dsymm_RU +#define DSYMM_RL dsymm_RL + +#define DHEMM_LU dhemm_LU +#define DHEMM_LL dhemm_LL +#define DHEMM_RU dhemm_RU +#define DHEMM_RL dhemm_RL + +#define DSYRK_UN dsyrk_UN +#define DSYRK_UT dsyrk_UT +#define DSYRK_LN dsyrk_LN +#define DSYRK_LT dsyrk_LT +#define DSYRK_UR dsyrk_UN +#define DSYRK_UC dsyrk_UT +#define DSYRK_LR dsyrk_LN +#define DSYRK_LC dsyrk_LT + +#define DSYRK_KERNEL_U dsyrk_kernel_U +#define DSYRK_KERNEL_L dsyrk_kernel_L + +#define DHERK_UN dsyrk_UN +#define DHERK_LN dsyrk_LN +#define DHERK_UC dsyrk_UT +#define DHERK_LC dsyrk_LT + +#define DHER2K_UN dsyr2k_UN +#define DHER2K_LN dsyr2k_LN +#define DHER2K_UC dsyr2k_UT +#define DHER2K_LC dsyr2k_LT + +#define DSYR2K_UN dsyr2k_UN +#define DSYR2K_UT dsyr2k_UT +#define DSYR2K_LN dsyr2k_LN +#define DSYR2K_LT dsyr2k_LT +#define DSYR2K_UR dsyr2k_UN +#define DSYR2K_UC dsyr2k_UT +#define DSYR2K_LR dsyr2k_LN +#define DSYR2K_LC dsyr2k_LT + +#define DSYR2K_KERNEL_U dsyr2k_kernel_U +#define DSYR2K_KERNEL_L dsyr2k_kernel_L + +#define DTRMM_LNUU dtrmm_LNUU +#define DTRMM_LNUN dtrmm_LNUN +#define DTRMM_LNLU dtrmm_LNLU +#define DTRMM_LNLN dtrmm_LNLN +#define DTRMM_LTUU dtrmm_LTUU +#define DTRMM_LTUN dtrmm_LTUN +#define DTRMM_LTLU dtrmm_LTLU +#define DTRMM_LTLN dtrmm_LTLN +#define DTRMM_LRUU dtrmm_LNUU +#define DTRMM_LRUN dtrmm_LNUN +#define DTRMM_LRLU dtrmm_LNLU +#define DTRMM_LRLN dtrmm_LNLN +#define DTRMM_LCUU dtrmm_LTUU +#define DTRMM_LCUN dtrmm_LTUN +#define DTRMM_LCLU dtrmm_LTLU +#define DTRMM_LCLN dtrmm_LTLN +#define DTRMM_RNUU dtrmm_RNUU +#define DTRMM_RNUN dtrmm_RNUN +#define DTRMM_RNLU dtrmm_RNLU +#define DTRMM_RNLN dtrmm_RNLN +#define DTRMM_RTUU dtrmm_RTUU +#define DTRMM_RTUN dtrmm_RTUN +#define DTRMM_RTLU dtrmm_RTLU +#define DTRMM_RTLN dtrmm_RTLN +#define DTRMM_RRUU dtrmm_RNUU +#define DTRMM_RRUN dtrmm_RNUN +#define DTRMM_RRLU dtrmm_RNLU +#define DTRMM_RRLN dtrmm_RNLN +#define DTRMM_RCUU dtrmm_RTUU +#define DTRMM_RCUN dtrmm_RTUN +#define DTRMM_RCLU dtrmm_RTLU +#define DTRMM_RCLN dtrmm_RTLN + +#define DTRSM_LNUU dtrsm_LNUU +#define DTRSM_LNUN dtrsm_LNUN +#define DTRSM_LNLU dtrsm_LNLU +#define DTRSM_LNLN dtrsm_LNLN +#define DTRSM_LTUU dtrsm_LTUU +#define DTRSM_LTUN dtrsm_LTUN +#define DTRSM_LTLU dtrsm_LTLU +#define DTRSM_LTLN dtrsm_LTLN +#define DTRSM_LRUU dtrsm_LNUU +#define DTRSM_LRUN dtrsm_LNUN +#define DTRSM_LRLU dtrsm_LNLU +#define DTRSM_LRLN dtrsm_LNLN +#define DTRSM_LCUU dtrsm_LTUU +#define DTRSM_LCUN dtrsm_LTUN +#define DTRSM_LCLU dtrsm_LTLU +#define DTRSM_LCLN dtrsm_LTLN +#define DTRSM_RNUU dtrsm_RNUU +#define DTRSM_RNUN dtrsm_RNUN +#define DTRSM_RNLU dtrsm_RNLU +#define DTRSM_RNLN dtrsm_RNLN +#define DTRSM_RTUU dtrsm_RTUU +#define DTRSM_RTUN dtrsm_RTUN +#define DTRSM_RTLU dtrsm_RTLU +#define DTRSM_RTLN dtrsm_RTLN +#define DTRSM_RRUU dtrsm_RNUU +#define DTRSM_RRUN dtrsm_RNUN +#define DTRSM_RRLU dtrsm_RNLU +#define DTRSM_RRLN dtrsm_RNLN +#define DTRSM_RCUU dtrsm_RTUU +#define DTRSM_RCUN dtrsm_RTUN +#define DTRSM_RCLU dtrsm_RTLU +#define DTRSM_RCLN dtrsm_RTLN + +#define DGEMM_THREAD_NN dgemm_thread_nn +#define DGEMM_THREAD_CN dgemm_thread_tn +#define DGEMM_THREAD_TN dgemm_thread_tn +#define DGEMM_THREAD_NC dgemm_thread_nt +#define DGEMM_THREAD_NT dgemm_thread_nt +#define DGEMM_THREAD_CC dgemm_thread_tt +#define DGEMM_THREAD_CT dgemm_thread_tt +#define DGEMM_THREAD_TC dgemm_thread_tt +#define DGEMM_THREAD_TT dgemm_thread_tt +#define DGEMM_THREAD_NR dgemm_thread_nn +#define DGEMM_THREAD_TR dgemm_thread_tn +#define DGEMM_THREAD_CR dgemm_thread_tn +#define DGEMM_THREAD_RN dgemm_thread_nn +#define DGEMM_THREAD_RT dgemm_thread_nt +#define DGEMM_THREAD_RC dgemm_thread_nt +#define DGEMM_THREAD_RR dgemm_thread_nn + +#define DSYMM_THREAD_LU dsymm_thread_LU +#define DSYMM_THREAD_LL dsymm_thread_LL +#define DSYMM_THREAD_RU dsymm_thread_RU +#define DSYMM_THREAD_RL dsymm_thread_RL + +#define DHEMM_THREAD_LU dhemm_thread_LU +#define DHEMM_THREAD_LL dhemm_thread_LL +#define DHEMM_THREAD_RU dhemm_thread_RU +#define DHEMM_THREAD_RL dhemm_thread_RL + +#define DSYRK_THREAD_UN dsyrk_thread_UN +#define DSYRK_THREAD_UT dsyrk_thread_UT +#define DSYRK_THREAD_LN dsyrk_thread_LN +#define DSYRK_THREAD_LT dsyrk_thread_LT +#define DSYRK_THREAD_UR dsyrk_thread_UN +#define DSYRK_THREAD_UC dsyrk_thread_UT +#define DSYRK_THREAD_LR dsyrk_thread_LN +#define DSYRK_THREAD_LC dsyrk_thread_LT + +#define DHERK_THREAD_UN dsyrk_thread_UN +#define DHERK_THREAD_UT dsyrk_thread_UT +#define DHERK_THREAD_LN dsyrk_thread_LN +#define DHERK_THREAD_LT dsyrk_thread_LT +#define DHERK_THREAD_UR dsyrk_thread_UN +#define DHERK_THREAD_UC dsyrk_thread_UT +#define DHERK_THREAD_LR dsyrk_thread_LN +#define DHERK_THREAD_LC dsyrk_thread_LT + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_ia64.h b/src/NativeWrappers/GotoBlas2/include/common_ia64.h new file mode 100644 index 00000000..81939cc1 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_ia64.h @@ -0,0 +1,408 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef COMMON_IA64 +#define COMMON_IA64 + +#ifndef ASSEMBLER + +#ifndef MAP_WRITECOMBINED +#define MAP_WRITECOMBINED 0x10000 +#endif + +#define MB +#define WMB + +#ifdef __ECC +#include +#endif + +#define RPCC64BIT + +#ifndef __ECC +static __inline void blas_lock(volatile unsigned long *address){ + + unsigned long ret; + + do { + while (*address) {YIELDING;}; + + __asm__ __volatile__ ("mov ar.ccv=r0\n;;\n" + "cmpxchg4.acq %0=[%2],%1,ar.ccv\n" + : "=r"(ret) : "r"(1), "r"(address) + : "ar.ccv", "memory"); + } while (ret); +} + +static __inline unsigned long rpcc(void) { + unsigned long clocks; + + __asm__ __volatile__ ("mov %0=ar.itc" : "=r"(clocks)); + return clocks; +} + + +static __inline unsigned long stmxcsr(void){ + unsigned long fp; + + __asm__ __volatile__ ("mov.m %0=ar.fpsr" : "=r" (fp)); + + return fp; +} + +static __inline void ldmxcsr(unsigned long fp) { + + __asm__ __volatile__ ("mov.m ar.fpsr=%0" :: "r" (fp)); + +} + +#define GET_IMAGE(res) asm __volatile__("mov %0 = f9" : "=f"(res) : : "memory") + +#else + +static __inline void blas_lock(volatile unsigned long *address){ + while (*address || _InterlockedCompareExchange((volatile int *) address,1,0)) + ; +} + +static __inline unsigned int rpcc(void) { + return __getReg(_IA64_REG_AR_ITC); +} + +static __inline unsigned int stmxcsr(void) { + return __getReg(_IA64_REG_AR_FPSR); +} + +static __inline void ldmxcsr(unsigned long fp) { + + return __setReg(_IA64_REG_AR_FPSR, fp); + +} + +#ifdef DOUBLE +#define GET_IMAGE(res) __stfd(&res, 9) +#else +#define GET_IMAGE(res) __stfs(&res, 9) +#endif + +#endif + +#define GET_IMAGE_CANCEL + +#ifdef ENABLE_SSE_EXCEPTION + +#define IDEBUG_START \ + { \ + unsigned long fp_sse_mode, new_fp_mode; \ + fp_sse_mode = stmxcsr();\ + new_fp_mode = (fp_sse_mode & ~(FE_UNDERFLOW | FE_OVERFLOW | FE_UNNORMAL | FE_INVALID));\ + ldmxcsr(new_fp_mode); + +#define IDEBUG_END \ + ldmxcsr(fp_sse_mode); \ + } + +#endif + +#ifdef SMP + +#ifdef USE64BITINT + +/* 64bit version */ + +extern unsigned long blas_quick_divide_table[]; + +#ifndef __ECC +static __inline long blas_quickdivide(unsigned long int x, unsigned long int y){ + unsigned long ret; + + if (y <= 1) return x; + + __asm__ __volatile__("setf.sig f6 = %1\n\t" + "ldf8 f7 = [%2];;\n\t" + "xmpy.hu f6= f6, f7;;\n\t" + "getf.sig %0 = f6;;\n" + : "=r"(ret) + : "r"(x), "r"(&blas_quick_divide_table[y]) : "f6", "f7" + ); + + return ret; +} +#else +/* Using Intel Compiler */ +static __inline long blas_quickdivide(unsigned long int x, unsigned long int y){ + if (y <= 1) return x; + return _m64_xmahu(x, blas_quick_divide_table[y], 0); +} +#endif + +#else + /* 32bit version */ +extern unsigned int blas_quick_divide_table[]; + +static __inline int blas_quickdivide(unsigned int x, unsigned int y){ + if (y <= 1) return x; + return (int)((x * (unsigned long)blas_quick_divide_table[y]) >> 32); +} +#endif +#endif + +#endif + +#if 0 +#ifdef DOUBLE +#define GEMM_NCOPY dgemm_ncopy +#define GEMM_TCOPY dgemm_tcopy +#define ZGEMM_NCOPY zgemm_ncopy +#define ZGEMM_TCOPY zgemm_tcopy +#define GEMM_KERNEL dgemm_kernel + +#if defined(NN) || defined(NT) || defined(TN) || defined(TT) +#define ZGEMM_KERNEL zgemm_kernel_n +#endif +#if defined(CN) || defined(CT) || defined(RN) || defined(RT) +#define ZGEMM_KERNEL zgemm_kernel_l +#endif +#if defined(NC) || defined(TC) || defined(NR) || defined(TR) +#define ZGEMM_KERNEL zgemm_kernel_r +#endif +#if defined(CC) || defined(CR) || defined(RC) || defined(RR) +#define ZGEMM_KERNEL zgemm_kernel_b +#endif + +#else +#define GEMM_NCOPY sgemm_ncopy +#define GEMM_TCOPY sgemm_tcopy +#define ZGEMM_NCOPY cgemm_ncopy +#define ZGEMM_TCOPY cgemm_tcopy +#define GEMM_KERNEL sgemm_kernel + +#if defined(NN) || defined(NT) || defined(TN) || defined(TT) +#define ZGEMM_KERNEL cgemm_kernel_n +#endif +#if defined(CN) || defined(CT) || defined(RN) || defined(RT) +#define ZGEMM_KERNEL cgemm_kernel_l +#endif +#if defined(NC) || defined(TC) || defined(NR) || defined(TR) +#define ZGEMM_KERNEL cgemm_kernel_r +#endif +#if defined(CC) || defined(CR) || defined(RC) || defined(RR) +#define ZGEMM_KERNEL cgemm_kernel_b +#endif + +#endif +#endif + +#ifdef USE64BITINT +#define LDINT ld8 +#define INTSIZE 8 +#define CMP4GE cmp.ge +#define CMP4NE cmp.ge +#define CMP4EQ cmp.eq +#else +#define LDINT ld4 +#define INTSIZE 4 +#define CMP4GE cmp4.ge +#define CMP4NE cmp4.ne +#define CMP4EQ cmp4.eq +#endif + +#define HALT mov r0 = 0 + +#ifdef XDOUBLE +#define LD8 ld8 +#define ST8 st8 +#define LDFD ldfe +#define LDFPD ldfpe +#define LDFD_T1 ldfe.t1 +#define LDFD_NT1 ldfe.nt1 +#define LDFD_NT2 ldfe.nt2 +#define LDFD_NTA ldfe.nta +#define LDFPD_NT1 ldfpe.nt1 +#define LDFPD_NT2 ldfpe.nt2 +#define LDFPD_NTA ldfpe.nta +#define STFD stfe +#define STFD_NTA stfe.nta +#define FADD fadd +#define FSUB fsub +#define FMPY fmpy +#define FMA fma +#define FMS fms +#define FNMA fnma +#define FPMA fpma +#define SETF setf.d +#elif defined(DOUBLE) +#define LD8 ld8 +#define ST8 st8 +#define LDF8 ldf8 +#define LDF8_NT1 ldf8.nt1 +#define LDF8_NTA ldf8.nta +#define STF8 stf8 +#define STF8_NTA stf8.nta +#define LDFD ldfd +#define LDFPD ldfpd +#define LDFD_T1 ldfd.t1 +#define LDFD_NT1 ldfd.nt1 +#define LDFD_NT2 ldfd.nt2 +#define LDFD_NTA ldfd.nta +#define LDFPD_NT1 ldfpd.nt1 +#define LDFPD_NT2 ldfpd.nt2 +#define LDFPD_NTA ldfpd.nta +#define STFD stfd +#define STFD_NTA stfd.nta +#define FADD fadd.d +#define FSUB fsub.d +#define FMPY fmpy.d +#define FMA fma.d +#define FMS fms.d +#define FNMA fnma.d +#define FPMA fpma.d +#define SETF setf.d +#else +#define LD8 ld4 +#define ST8 st4 +#define LDF8 ldfs +#define LDF8_NT1 ldfs.nt1 +#define LDF8_NTA ldfs.nta +#define STF8 stfs +#define STF8_NTA stfs.nta +#define LDFD ldfs +#define LDFPD ldfps +#define LDFD_T1 ldfs.t1 +#define LDFD_NT1 ldfs.nt1 +#define LDFD_NT2 ldfs.nt2 +#define LDFD_NTA ldfs.nta +#define LDFPD_NT1 ldfps.nt1 +#define LDFPD_NT2 ldfps.nt2 +#define LDFPD_NTA ldfps.nta +#define STFD stfs +#define STFD_NTA stfs.nta +#if 0 +#define FADD fadd.s +#define FSUB fsub.s +#define FMPY fmpy.s +#define FMA fma.s +#define FMS fms.s +#define FNMA fnma.s +#define FPMA fpma.s +#else +#define FADD fadd +#define FSUB fsub +#define FMPY fmpy +#define FMA fma +#define FMS fms +#define FNMA fnma +#define FPMA fpma +#endif +#define SETF setf.s +#endif + +#ifndef F_INTERFACE +#define REALNAME ASMNAME +#else +#define REALNAME ASMFNAME +#endif + +#ifdef F_INTERFACE_G77 +#define RETURN_BY_STACK +#endif + +#ifdef F_INTERFACE_G95 +#define RETURN_BY_STACK +#endif + +#ifdef F_INTERFACE_GFORT +#define RETURN_BY_REGS +#endif + +#ifdef F_INTERFACE_INTEL +#define RETURN_BY_STACK +#endif + +#define PROLOGUE \ + .explicit; \ + .text; \ + .align 128; \ + .global REALNAME; \ + .proc REALNAME; \ +REALNAME: + + +#ifdef PROFILE +#define PROFCODE \ + .data; \ + .align 8; \ +.LP0:; \ + data8 0; \ + .text; \ + alloc out0 = ar.pfs, 8, 0, 4, 0; \ + mov out1 = r1; \ + mov out2 = b0; \ + addl out3 = @ltoff(.LP0), r1;;; \ + br.call.sptk.many b0 = _mcount;; +#else +#define PROFCODE +#endif + +#define EPILOGUE \ + .endp REALNAME + +#define START_ADDRESS 0x20000fc800000000UL + +#undef SEEK_ADDRESS + +#if 0 +#ifdef CONFIG_IA64_PAGE_SIZE_4KB +#define SEEK_ADDRESS +#endif + +#ifdef CONFIG_IA64_PAGE_SIZE_8KB +#define SEEK_ADDRESS +#endif +#endif + +#define BUFFER_SIZE (128 << 20) + +#ifndef PAGESIZE +#define PAGESIZE (16UL << 10) +#endif +#define HUGE_PAGESIZE ( 4 << 20) + +#define BASE_ADDRESS (START_ADDRESS - (BLASULONG)BUFFER_SIZE * MAX_CPU_NUMBER) + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_interface.h b/src/NativeWrappers/GotoBlas2/include/common_interface.h new file mode 100644 index 00000000..36bf5aa4 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_interface.h @@ -0,0 +1,736 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef ASSEMBLER + +int BLASFUNC(xerbla)(char *, blasint *info, blasint); + +FLOATRET BLASFUNC(sdot) (blasint *, float *, blasint *, float *, blasint *); +FLOATRET BLASFUNC(sdsdot)(blasint *, float *, float *, blasint *, float *, blasint *); + +double BLASFUNC(dsdot) (blasint *, float *, blasint *, float *, blasint *); +double BLASFUNC(ddot) (blasint *, double *, blasint *, double *, blasint *); +xdouble BLASFUNC(qdot) (blasint *, xdouble *, blasint *, xdouble *, blasint *); + + +#ifdef RETURN_BY_STRUCT +typedef struct { + float r, i; +} myccomplex_t; + +typedef struct { + double r, i; +} myzcomplex_t; + +typedef struct { + xdouble r, i; +} myxcomplex_t; + +myccomplex_t BLASFUNC(cdotu) (blasint *, float *, blasint *, float *, blasint *); +myccomplex_t BLASFUNC(cdotc) (blasint *, float *, blasint *, float *, blasint *); +myzcomplex_t BLASFUNC(zdotu) (blasint *, double *, blasint *, double *, blasint *); +myzcomplex_t BLASFUNC(zdotc) (blasint *, double *, blasint *, double *, blasint *); +myxcomplex_t BLASFUNC(xdotu) (blasint *, xdouble *, blasint *, xdouble *, blasint *); +myxcomplex_t BLASFUNC(xdotc) (blasint *, xdouble *, blasint *, xdouble *, blasint *); + +#elif defined RETURN_BY_STACK +void BLASFUNC(cdotu) (float _Complex *, blasint *, float * , blasint *, float *, blasint *); +void BLASFUNC(cdotc) (float _Complex *, blasint *, float *, blasint *, float *, blasint *); +void BLASFUNC(zdotu) (double _Complex *, blasint *, double *, blasint *, double *, blasint *); +void BLASFUNC(zdotc) (double _Complex *, blasint *, double *, blasint *, double *, blasint *); +void BLASFUNC(xdotu) (xdouble _Complex *, blasint *, xdouble *, blasint *, xdouble *, blasint *); +void BLASFUNC(xdotc) (xdouble _Complex *, blasint *, xdouble *, blasint *, xdouble *, blasint *); +#else +float _Complex BLASFUNC(cdotu) (blasint *, float *, blasint *, float *, blasint *); +float _Complex BLASFUNC(cdotc) (blasint *, float *, blasint *, float *, blasint *); +double _Complex BLASFUNC(zdotu) (blasint *, double *, blasint *, double *, blasint *); +double _Complex BLASFUNC(zdotc) (blasint *, double *, blasint *, double *, blasint *); +xdouble _Complex BLASFUNC(xdotu) (blasint *, xdouble *, blasint *, xdouble *, blasint *); +xdouble _Complex BLASFUNC(xdotc) (blasint *, xdouble *, blasint *, xdouble *, blasint *); +#endif + +void BLASFUNC(saxpy) (blasint *, float *, float *, blasint *, float *, blasint *); +void BLASFUNC(daxpy) (blasint *, double *, double *, blasint *, double *, blasint *); +void BLASFUNC(qaxpy) (blasint *, xdouble *, xdouble *, blasint *, xdouble *, blasint *); +void BLASFUNC(caxpy) (blasint *, float *, float *, blasint *, float *, blasint *); +void BLASFUNC(zaxpy) (blasint *, double *, double *, blasint *, double *, blasint *); +void BLASFUNC(xaxpy) (blasint *, xdouble *, xdouble *, blasint *, xdouble *, blasint *); +void BLASFUNC(caxpyc)(blasint *, float *, float *, blasint *, float *, blasint *); +void BLASFUNC(zaxpyc)(blasint *, double *, double *, blasint *, double *, blasint *); +void BLASFUNC(xaxpyc)(blasint *, xdouble *, xdouble *, blasint *, xdouble *, blasint *); + +void BLASFUNC(scopy) (blasint *, float *, blasint *, float *, blasint *); +void BLASFUNC(dcopy) (blasint *, double *, blasint *, double *, blasint *); +void BLASFUNC(qcopy) (blasint *, xdouble *, blasint *, xdouble *, blasint *); +void BLASFUNC(ccopy) (blasint *, float *, blasint *, float *, blasint *); +void BLASFUNC(zcopy) (blasint *, double *, blasint *, double *, blasint *); +void BLASFUNC(xcopy) (blasint *, xdouble *, blasint *, xdouble *, blasint *); + +void BLASFUNC(sswap) (blasint *, float *, blasint *, float *, blasint *); +void BLASFUNC(dswap) (blasint *, double *, blasint *, double *, blasint *); +void BLASFUNC(qswap) (blasint *, xdouble *, blasint *, xdouble *, blasint *); +void BLASFUNC(cswap) (blasint *, float *, blasint *, float *, blasint *); +void BLASFUNC(zswap) (blasint *, double *, blasint *, double *, blasint *); +void BLASFUNC(xswap) (blasint *, xdouble *, blasint *, xdouble *, blasint *); + +FLOATRET BLASFUNC(sasum) (blasint *, float *, blasint *); +FLOATRET BLASFUNC(scasum)(blasint *, float *, blasint *); +double BLASFUNC(dasum) (blasint *, double *, blasint *); +xdouble BLASFUNC(qasum) (blasint *, xdouble *, blasint *); +double BLASFUNC(dzasum)(blasint *, double *, blasint *); +xdouble BLASFUNC(qxasum)(blasint *, xdouble *, blasint *); + +blasint BLASFUNC(isamax)(blasint *, float *, blasint *); +blasint BLASFUNC(idamax)(blasint *, double *, blasint *); +blasint BLASFUNC(iqamax)(blasint *, xdouble *, blasint *); +blasint BLASFUNC(icamax)(blasint *, float *, blasint *); +blasint BLASFUNC(izamax)(blasint *, double *, blasint *); +blasint BLASFUNC(ixamax)(blasint *, xdouble *, blasint *); + +blasint BLASFUNC(ismax) (blasint *, float *, blasint *); +blasint BLASFUNC(idmax) (blasint *, double *, blasint *); +blasint BLASFUNC(iqmax) (blasint *, xdouble *, blasint *); +blasint BLASFUNC(icmax) (blasint *, float *, blasint *); +blasint BLASFUNC(izmax) (blasint *, double *, blasint *); +blasint BLASFUNC(ixmax) (blasint *, xdouble *, blasint *); + +blasint BLASFUNC(isamin)(blasint *, float *, blasint *); +blasint BLASFUNC(idamin)(blasint *, double *, blasint *); +blasint BLASFUNC(iqamin)(blasint *, xdouble *, blasint *); +blasint BLASFUNC(icamin)(blasint *, float *, blasint *); +blasint BLASFUNC(izamin)(blasint *, double *, blasint *); +blasint BLASFUNC(ixamin)(blasint *, xdouble *, blasint *); + +blasint BLASFUNC(ismin)(blasint *, float *, blasint *); +blasint BLASFUNC(idmin)(blasint *, double *, blasint *); +blasint BLASFUNC(iqmin)(blasint *, xdouble *, blasint *); +blasint BLASFUNC(icmin)(blasint *, float *, blasint *); +blasint BLASFUNC(izmin)(blasint *, double *, blasint *); +blasint BLASFUNC(ixmin)(blasint *, xdouble *, blasint *); + +FLOATRET BLASFUNC(samax) (blasint *, float *, blasint *); +double BLASFUNC(damax) (blasint *, double *, blasint *); +xdouble BLASFUNC(qamax) (blasint *, xdouble *, blasint *); +FLOATRET BLASFUNC(scamax)(blasint *, float *, blasint *); +double BLASFUNC(dzamax)(blasint *, double *, blasint *); +xdouble BLASFUNC(qxamax)(blasint *, xdouble *, blasint *); + +FLOATRET BLASFUNC(samin) (blasint *, float *, blasint *); +double BLASFUNC(damin) (blasint *, double *, blasint *); +xdouble BLASFUNC(qamin) (blasint *, xdouble *, blasint *); +FLOATRET BLASFUNC(scamin)(blasint *, float *, blasint *); +double BLASFUNC(dzamin)(blasint *, double *, blasint *); +xdouble BLASFUNC(qxamin)(blasint *, xdouble *, blasint *); + +FLOATRET BLASFUNC(smax) (blasint *, float *, blasint *); +double BLASFUNC(dmax) (blasint *, double *, blasint *); +xdouble BLASFUNC(qmax) (blasint *, xdouble *, blasint *); +FLOATRET BLASFUNC(scmax) (blasint *, float *, blasint *); +double BLASFUNC(dzmax) (blasint *, double *, blasint *); +xdouble BLASFUNC(qxmax) (blasint *, xdouble *, blasint *); + +FLOATRET BLASFUNC(smin) (blasint *, float *, blasint *); +double BLASFUNC(dmin) (blasint *, double *, blasint *); +xdouble BLASFUNC(qmin) (blasint *, xdouble *, blasint *); +FLOATRET BLASFUNC(scmin) (blasint *, float *, blasint *); +double BLASFUNC(dzmin) (blasint *, double *, blasint *); +xdouble BLASFUNC(qxmin) (blasint *, xdouble *, blasint *); + +void BLASFUNC(sscal) (blasint *, float *, float *, blasint *); +void BLASFUNC(dscal) (blasint *, double *, double *, blasint *); +void BLASFUNC(qscal) (blasint *, xdouble *, xdouble *, blasint *); +void BLASFUNC(cscal) (blasint *, float *, float *, blasint *); +void BLASFUNC(zscal) (blasint *, double *, double *, blasint *); +void BLASFUNC(xscal) (blasint *, xdouble *, xdouble *, blasint *); +void BLASFUNC(csscal)(blasint *, float *, float *, blasint *); +void BLASFUNC(zdscal)(blasint *, double *, double *, blasint *); +void BLASFUNC(xqscal)(blasint *, xdouble *, xdouble *, blasint *); + +FLOATRET BLASFUNC(snrm2) (blasint *, float *, blasint *); +FLOATRET BLASFUNC(scnrm2)(blasint *, float *, blasint *); + +double BLASFUNC(dnrm2) (blasint *, double *, blasint *); +xdouble BLASFUNC(qnrm2) (blasint *, xdouble *, blasint *); +double BLASFUNC(dznrm2)(blasint *, double *, blasint *); +xdouble BLASFUNC(qxnrm2)(blasint *, xdouble *, blasint *); + +void BLASFUNC(srot) (blasint *, float *, blasint *, float *, blasint *, float *, float *); +void BLASFUNC(drot) (blasint *, double *, blasint *, double *, blasint *, double *, double *); +void BLASFUNC(qrot) (blasint *, xdouble *, blasint *, xdouble *, blasint *, xdouble *, xdouble *); +void BLASFUNC(csrot) (blasint *, float *, blasint *, float *, blasint *, float *, float *); +void BLASFUNC(zdrot) (blasint *, double *, blasint *, double *, blasint *, double *, double *); +void BLASFUNC(xqrot) (blasint *, xdouble *, blasint *, xdouble *, blasint *, xdouble *, xdouble *); + +void BLASFUNC(srotg) (float *, float *, float *, float *); +void BLASFUNC(drotg) (double *, double *, double *, double *); +void BLASFUNC(qrotg) (xdouble *, xdouble *, xdouble *, xdouble *); +void BLASFUNC(crotg) (float *, float *, float *, float *); +void BLASFUNC(zrotg) (double *, double *, double *, double *); +void BLASFUNC(xrotg) (xdouble *, xdouble *, xdouble *, xdouble *); + +void BLASFUNC(srotmg)(float *, float *, float *, float *, float *); +void BLASFUNC(drotmg)(double *, double *, double *, double *, double *); + +void BLASFUNC(srotm) (blasint *, float *, blasint *, float *, blasint *, float *); +void BLASFUNC(drotm) (blasint *, double *, blasint *, double *, blasint *, double *); +void BLASFUNC(qrotm) (blasint *, xdouble *, blasint *, xdouble *, blasint *, xdouble *); + +/* Level 2 routines */ + +void BLASFUNC(sger)(blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, blasint *); +void BLASFUNC(dger)(blasint *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, blasint *); +void BLASFUNC(qger)(blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, blasint *); +void BLASFUNC(cgeru)(blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, blasint *); +void BLASFUNC(cgerc)(blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, blasint *); +void BLASFUNC(zgeru)(blasint *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, blasint *); +void BLASFUNC(zgerc)(blasint *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, blasint *); +void BLASFUNC(xgeru)(blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, blasint *); +void BLASFUNC(xgerc)(blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, blasint *); + +void BLASFUNC(sgemv)(char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(dgemv)(char *, blasint *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(qgemv)(char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); +void BLASFUNC(cgemv)(char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zgemv)(char *, blasint *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(xgemv)(char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); + +void BLASFUNC(strsv) (char *, char *, char *, blasint *, float *, blasint *, + float *, blasint *); +void BLASFUNC(dtrsv) (char *, char *, char *, blasint *, double *, blasint *, + double *, blasint *); +void BLASFUNC(qtrsv) (char *, char *, char *, blasint *, xdouble *, blasint *, + xdouble *, blasint *); +void BLASFUNC(ctrsv) (char *, char *, char *, blasint *, float *, blasint *, + float *, blasint *); +void BLASFUNC(ztrsv) (char *, char *, char *, blasint *, double *, blasint *, + double *, blasint *); +void BLASFUNC(xtrsv) (char *, char *, char *, blasint *, xdouble *, blasint *, + xdouble *, blasint *); + +void BLASFUNC(strmv) (char *, char *, char *, blasint *, float *, blasint *, + float *, blasint *); +void BLASFUNC(dtrmv) (char *, char *, char *, blasint *, double *, blasint *, + double *, blasint *); +void BLASFUNC(qtrmv) (char *, char *, char *, blasint *, xdouble *, blasint *, + xdouble *, blasint *); +void BLASFUNC(ctrmv) (char *, char *, char *, blasint *, float *, blasint *, + float *, blasint *); +void BLASFUNC(ztrmv) (char *, char *, char *, blasint *, double *, blasint *, + double *, blasint *); +void BLASFUNC(xtrmv) (char *, char *, char *, blasint *, xdouble *, blasint *, + xdouble *, blasint *); + +void BLASFUNC(stpsv) (char *, char *, char *, blasint *, float *, float *, blasint *); +void BLASFUNC(dtpsv) (char *, char *, char *, blasint *, double *, double *, blasint *); +void BLASFUNC(qtpsv) (char *, char *, char *, blasint *, xdouble *, xdouble *, blasint *); +void BLASFUNC(ctpsv) (char *, char *, char *, blasint *, float *, float *, blasint *); +void BLASFUNC(ztpsv) (char *, char *, char *, blasint *, double *, double *, blasint *); +void BLASFUNC(xtpsv) (char *, char *, char *, blasint *, xdouble *, xdouble *, blasint *); + +void BLASFUNC(stpmv) (char *, char *, char *, blasint *, float *, float *, blasint *); +void BLASFUNC(dtpmv) (char *, char *, char *, blasint *, double *, double *, blasint *); +void BLASFUNC(qtpmv) (char *, char *, char *, blasint *, xdouble *, xdouble *, blasint *); +void BLASFUNC(ctpmv) (char *, char *, char *, blasint *, float *, float *, blasint *); +void BLASFUNC(ztpmv) (char *, char *, char *, blasint *, double *, double *, blasint *); +void BLASFUNC(xtpmv) (char *, char *, char *, blasint *, xdouble *, xdouble *, blasint *); + +void BLASFUNC(stbmv) (char *, char *, char *, blasint *, blasint *, float *, blasint *, float *, blasint *); +void BLASFUNC(dtbmv) (char *, char *, char *, blasint *, blasint *, double *, blasint *, double *, blasint *); +void BLASFUNC(qtbmv) (char *, char *, char *, blasint *, blasint *, xdouble *, blasint *, xdouble *, blasint *); +void BLASFUNC(ctbmv) (char *, char *, char *, blasint *, blasint *, float *, blasint *, float *, blasint *); +void BLASFUNC(ztbmv) (char *, char *, char *, blasint *, blasint *, double *, blasint *, double *, blasint *); +void BLASFUNC(xtbmv) (char *, char *, char *, blasint *, blasint *, xdouble *, blasint *, xdouble *, blasint *); + +void BLASFUNC(stbsv) (char *, char *, char *, blasint *, blasint *, float *, blasint *, float *, blasint *); +void BLASFUNC(dtbsv) (char *, char *, char *, blasint *, blasint *, double *, blasint *, double *, blasint *); +void BLASFUNC(qtbsv) (char *, char *, char *, blasint *, blasint *, xdouble *, blasint *, xdouble *, blasint *); +void BLASFUNC(ctbsv) (char *, char *, char *, blasint *, blasint *, float *, blasint *, float *, blasint *); +void BLASFUNC(ztbsv) (char *, char *, char *, blasint *, blasint *, double *, blasint *, double *, blasint *); +void BLASFUNC(xtbsv) (char *, char *, char *, blasint *, blasint *, xdouble *, blasint *, xdouble *, blasint *); + +void BLASFUNC(ssymv) (char *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(dsymv) (char *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(qsymv) (char *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); +void BLASFUNC(csymv) (char *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zsymv) (char *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(xsymv) (char *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); + +void BLASFUNC(sspmv) (char *, blasint *, float *, float *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(dspmv) (char *, blasint *, double *, double *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(qspmv) (char *, blasint *, xdouble *, xdouble *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); +void BLASFUNC(cspmv) (char *, blasint *, float *, float *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zspmv) (char *, blasint *, double *, double *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(xspmv) (char *, blasint *, xdouble *, xdouble *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); + +void BLASFUNC(ssyr) (char *, blasint *, float *, float *, blasint *, + float *, blasint *); +void BLASFUNC(dsyr) (char *, blasint *, double *, double *, blasint *, + double *, blasint *); +void BLASFUNC(qsyr) (char *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *); +void BLASFUNC(csyr) (char *, blasint *, float *, float *, blasint *, + float *, blasint *); +void BLASFUNC(zsyr) (char *, blasint *, double *, double *, blasint *, + double *, blasint *); +void BLASFUNC(xsyr) (char *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *); + +void BLASFUNC(ssyr2) (char *, blasint *, float *, + float *, blasint *, float *, blasint *, float *, blasint *); +void BLASFUNC(dsyr2) (char *, blasint *, double *, + double *, blasint *, double *, blasint *, double *, blasint *); +void BLASFUNC(qsyr2) (char *, blasint *, xdouble *, + xdouble *, blasint *, xdouble *, blasint *, xdouble *, blasint *); +void BLASFUNC(csyr2) (char *, blasint *, float *, + float *, blasint *, float *, blasint *, float *, blasint *); +void BLASFUNC(zsyr2) (char *, blasint *, double *, + double *, blasint *, double *, blasint *, double *, blasint *); +void BLASFUNC(xsyr2) (char *, blasint *, xdouble *, + xdouble *, blasint *, xdouble *, blasint *, xdouble *, blasint *); + +void BLASFUNC(sspr) (char *, blasint *, float *, float *, blasint *, + float *); +void BLASFUNC(dspr) (char *, blasint *, double *, double *, blasint *, + double *); +void BLASFUNC(qspr) (char *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *); +void BLASFUNC(cspr) (char *, blasint *, float *, float *, blasint *, + float *); +void BLASFUNC(zspr) (char *, blasint *, double *, double *, blasint *, + double *); +void BLASFUNC(xspr) (char *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *); + +void BLASFUNC(sspr2) (char *, blasint *, float *, + float *, blasint *, float *, blasint *, float *); +void BLASFUNC(dspr2) (char *, blasint *, double *, + double *, blasint *, double *, blasint *, double *); +void BLASFUNC(qspr2) (char *, blasint *, xdouble *, + xdouble *, blasint *, xdouble *, blasint *, xdouble *); +void BLASFUNC(cspr2) (char *, blasint *, float *, + float *, blasint *, float *, blasint *, float *); +void BLASFUNC(zspr2) (char *, blasint *, double *, + double *, blasint *, double *, blasint *, double *); +void BLASFUNC(xspr2) (char *, blasint *, xdouble *, + xdouble *, blasint *, xdouble *, blasint *, xdouble *); + +void BLASFUNC(cher) (char *, blasint *, float *, float *, blasint *, + float *, blasint *); +void BLASFUNC(zher) (char *, blasint *, double *, double *, blasint *, + double *, blasint *); +void BLASFUNC(xher) (char *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *); + +void BLASFUNC(chpr) (char *, blasint *, float *, float *, blasint *, float *); +void BLASFUNC(zhpr) (char *, blasint *, double *, double *, blasint *, double *); +void BLASFUNC(xhpr) (char *, blasint *, xdouble *, xdouble *, blasint *, xdouble *); + +void BLASFUNC(cher2) (char *, blasint *, float *, + float *, blasint *, float *, blasint *, float *, blasint *); +void BLASFUNC(zher2) (char *, blasint *, double *, + double *, blasint *, double *, blasint *, double *, blasint *); +void BLASFUNC(xher2) (char *, blasint *, xdouble *, + xdouble *, blasint *, xdouble *, blasint *, xdouble *, blasint *); + +void BLASFUNC(chpr2) (char *, blasint *, float *, + float *, blasint *, float *, blasint *, float *); +void BLASFUNC(zhpr2) (char *, blasint *, double *, + double *, blasint *, double *, blasint *, double *); +void BLASFUNC(xhpr2) (char *, blasint *, xdouble *, + xdouble *, blasint *, xdouble *, blasint *, xdouble *); + +void BLASFUNC(chemv) (char *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zhemv) (char *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(xhemv) (char *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); + +void BLASFUNC(chpmv) (char *, blasint *, float *, float *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zhpmv) (char *, blasint *, double *, double *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(xhpmv) (char *, blasint *, xdouble *, xdouble *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); + +int BLASFUNC(snorm)(char *, blasint *, blasint *, float *, blasint *); +int BLASFUNC(dnorm)(char *, blasint *, blasint *, double *, blasint *); +int BLASFUNC(cnorm)(char *, blasint *, blasint *, float *, blasint *); +int BLASFUNC(znorm)(char *, blasint *, blasint *, double *, blasint *); + +void BLASFUNC(sgbmv)(char *, blasint *, blasint *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(dgbmv)(char *, blasint *, blasint *, blasint *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(qgbmv)(char *, blasint *, blasint *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); +void BLASFUNC(cgbmv)(char *, blasint *, blasint *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zgbmv)(char *, blasint *, blasint *, blasint *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(xgbmv)(char *, blasint *, blasint *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); + +void BLASFUNC(ssbmv)(char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(dsbmv)(char *, blasint *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(qsbmv)(char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); +void BLASFUNC(csbmv)(char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zsbmv)(char *, blasint *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(xsbmv)(char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); + +void BLASFUNC(chbmv)(char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zhbmv)(char *, blasint *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(xhbmv)(char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); + +/* Level 3 routines */ + +void BLASFUNC(sgemm)(char *, char *, blasint *, blasint *, blasint *, float *, + float *, blasint *, float *, blasint *, float *, float *, blasint *); +void BLASFUNC(dgemm)(char *, char *, blasint *, blasint *, blasint *, double *, + double *, blasint *, double *, blasint *, double *, double *, blasint *); +void BLASFUNC(qgemm)(char *, char *, blasint *, blasint *, blasint *, xdouble *, + xdouble *, blasint *, xdouble *, blasint *, xdouble *, xdouble *, blasint *); +void BLASFUNC(cgemm)(char *, char *, blasint *, blasint *, blasint *, float *, + float *, blasint *, float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zgemm)(char *, char *, blasint *, blasint *, blasint *, double *, + double *, blasint *, double *, blasint *, double *, double *, blasint *); +void BLASFUNC(xgemm)(char *, char *, blasint *, blasint *, blasint *, xdouble *, + xdouble *, blasint *, xdouble *, blasint *, xdouble *, xdouble *, blasint *); + +void BLASFUNC(cgemm3m)(char *, char *, blasint *, blasint *, blasint *, float *, + float *, blasint *, float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zgemm3m)(char *, char *, blasint *, blasint *, blasint *, double *, + double *, blasint *, double *, blasint *, double *, double *, blasint *); +void BLASFUNC(xgemm3m)(char *, char *, blasint *, blasint *, blasint *, xdouble *, + xdouble *, blasint *, xdouble *, blasint *, xdouble *, xdouble *, blasint *); + +int BLASFUNC(sge2mm)(char *, char *, char *, blasint *, blasint *, + float *, float *, blasint *, float *, blasint *, + float *, float *, blasint *); +int BLASFUNC(dge2mm)(char *, char *, char *, blasint *, blasint *, + double *, double *, blasint *, double *, blasint *, + double *, double *, blasint *); +int BLASFUNC(cge2mm)(char *, char *, char *, blasint *, blasint *, + float *, float *, blasint *, float *, blasint *, + float *, float *, blasint *); +int BLASFUNC(zge2mm)(char *, char *, char *, blasint *, blasint *, + double *, double *, blasint *, double *, blasint *, + double *, double *, blasint *); + +void BLASFUNC(strsm)(char *, char *, char *, char *, blasint *, blasint *, + float *, float *, blasint *, float *, blasint *); +void BLASFUNC(dtrsm)(char *, char *, char *, char *, blasint *, blasint *, + double *, double *, blasint *, double *, blasint *); +void BLASFUNC(qtrsm)(char *, char *, char *, char *, blasint *, blasint *, + xdouble *, xdouble *, blasint *, xdouble *, blasint *); +void BLASFUNC(ctrsm)(char *, char *, char *, char *, blasint *, blasint *, + float *, float *, blasint *, float *, blasint *); +void BLASFUNC(ztrsm)(char *, char *, char *, char *, blasint *, blasint *, + double *, double *, blasint *, double *, blasint *); +void BLASFUNC(xtrsm)(char *, char *, char *, char *, blasint *, blasint *, + xdouble *, xdouble *, blasint *, xdouble *, blasint *); + +void BLASFUNC(strmm)(char *, char *, char *, char *, blasint *, blasint *, + float *, float *, blasint *, float *, blasint *); +void BLASFUNC(dtrmm)(char *, char *, char *, char *, blasint *, blasint *, + double *, double *, blasint *, double *, blasint *); +void BLASFUNC(qtrmm)(char *, char *, char *, char *, blasint *, blasint *, + xdouble *, xdouble *, blasint *, xdouble *, blasint *); +void BLASFUNC(ctrmm)(char *, char *, char *, char *, blasint *, blasint *, + float *, float *, blasint *, float *, blasint *); +void BLASFUNC(ztrmm)(char *, char *, char *, char *, blasint *, blasint *, + double *, double *, blasint *, double *, blasint *); +void BLASFUNC(xtrmm)(char *, char *, char *, char *, blasint *, blasint *, + xdouble *, xdouble *, blasint *, xdouble *, blasint *); + +void BLASFUNC(ssymm)(char *, char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(dsymm)(char *, char *, blasint *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(qsymm)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); +void BLASFUNC(csymm)(char *, char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zsymm)(char *, char *, blasint *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(xsymm)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); + +void BLASFUNC(csymm3m)(char *, char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zsymm3m)(char *, char *, blasint *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(xsymm3m)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); + +void BLASFUNC(ssyrk)(char *, char *, blasint *, blasint *, float *, float *, blasint *, + float *, float *, blasint *); +void BLASFUNC(dsyrk)(char *, char *, blasint *, blasint *, double *, double *, blasint *, + double *, double *, blasint *); +void BLASFUNC(qsyrk)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, xdouble *, blasint *); +void BLASFUNC(csyrk)(char *, char *, blasint *, blasint *, float *, float *, blasint *, + float *, float *, blasint *); +void BLASFUNC(zsyrk)(char *, char *, blasint *, blasint *, double *, double *, blasint *, + double *, double *, blasint *); +void BLASFUNC(xsyrk)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, xdouble *, blasint *); + +void BLASFUNC(ssyr2k)(char *, char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(dsyr2k)(char *, char *, blasint *, blasint *, double *, double *, blasint *, + double*, blasint *, double *, double *, blasint *); +void BLASFUNC(qsyr2k)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble*, blasint *, xdouble *, xdouble *, blasint *); +void BLASFUNC(csyr2k)(char *, char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zsyr2k)(char *, char *, blasint *, blasint *, double *, double *, blasint *, + double*, blasint *, double *, double *, blasint *); +void BLASFUNC(xsyr2k)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble*, blasint *, xdouble *, xdouble *, blasint *); + +void BLASFUNC(chemm)(char *, char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zhemm)(char *, char *, blasint *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(xhemm)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); + +void BLASFUNC(chemm3m)(char *, char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zhemm3m)(char *, char *, blasint *, blasint *, double *, double *, blasint *, + double *, blasint *, double *, double *, blasint *); +void BLASFUNC(xhemm3m)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, blasint *, xdouble *, xdouble *, blasint *); + +void BLASFUNC(cherk)(char *, char *, blasint *, blasint *, float *, float *, blasint *, + float *, float *, blasint *); +void BLASFUNC(zherk)(char *, char *, blasint *, blasint *, double *, double *, blasint *, + double *, double *, blasint *); +void BLASFUNC(xherk)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble *, xdouble *, blasint *); + +void BLASFUNC(cher2k)(char *, char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +void BLASFUNC(zher2k)(char *, char *, blasint *, blasint *, double *, double *, blasint *, + double*, blasint *, double *, double *, blasint *); +void BLASFUNC(xher2k)(char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble*, blasint *, xdouble *, xdouble *, blasint *); + +int BLASFUNC(cher2m)(char *, char *, char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *, float *, float *, blasint *); +int BLASFUNC(zher2m)(char *, char *, char *, blasint *, blasint *, double *, double *, blasint *, + double*, blasint *, double *, double *, blasint *); +int BLASFUNC(xher2m)(char *, char *, char *, blasint *, blasint *, xdouble *, xdouble *, blasint *, + xdouble*, blasint *, xdouble *, xdouble *, blasint *); + +int BLASFUNC(sgemt)(char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *); +int BLASFUNC(dgemt)(char *, blasint *, blasint *, double *, double *, blasint *, + double *, blasint *); +int BLASFUNC(cgemt)(char *, blasint *, blasint *, float *, float *, blasint *, + float *, blasint *); +int BLASFUNC(zgemt)(char *, blasint *, blasint *, double *, double *, blasint *, + double *, blasint *); + +int BLASFUNC(sgema)(char *, char *, blasint *, blasint *, float *, + float *, blasint *, float *, float *, blasint *, float *, blasint *); +int BLASFUNC(dgema)(char *, char *, blasint *, blasint *, double *, + double *, blasint *, double*, double *, blasint *, double*, blasint *); +int BLASFUNC(cgema)(char *, char *, blasint *, blasint *, float *, + float *, blasint *, float *, float *, blasint *, float *, blasint *); +int BLASFUNC(zgema)(char *, char *, blasint *, blasint *, double *, + double *, blasint *, double*, double *, blasint *, double*, blasint *); + +int BLASFUNC(sgems)(char *, char *, blasint *, blasint *, float *, + float *, blasint *, float *, float *, blasint *, float *, blasint *); +int BLASFUNC(dgems)(char *, char *, blasint *, blasint *, double *, + double *, blasint *, double*, double *, blasint *, double*, blasint *); +int BLASFUNC(cgems)(char *, char *, blasint *, blasint *, float *, + float *, blasint *, float *, float *, blasint *, float *, blasint *); +int BLASFUNC(zgems)(char *, char *, blasint *, blasint *, double *, + double *, blasint *, double*, double *, blasint *, double*, blasint *); + +int BLASFUNC(sgemc)(char *, char *, blasint *, blasint *, blasint *, float *, + float *, blasint *, float *, blasint *, float *, blasint *, float *, float *, blasint *); +int BLASFUNC(dgemc)(char *, char *, blasint *, blasint *, blasint *, double *, + double *, blasint *, double *, blasint *, double *, blasint *, double *, double *, blasint *); +int BLASFUNC(qgemc)(char *, char *, blasint *, blasint *, blasint *, xdouble *, + xdouble *, blasint *, xdouble *, blasint *, xdouble *, blasint *, xdouble *, xdouble *, blasint *); +int BLASFUNC(cgemc)(char *, char *, blasint *, blasint *, blasint *, float *, + float *, blasint *, float *, blasint *, float *, blasint *, float *, float *, blasint *); +int BLASFUNC(zgemc)(char *, char *, blasint *, blasint *, blasint *, double *, + double *, blasint *, double *, blasint *, double *, blasint *, double *, double *, blasint *); +int BLASFUNC(xgemc)(char *, char *, blasint *, blasint *, blasint *, xdouble *, + xdouble *, blasint *, xdouble *, blasint *, xdouble *, blasint *, xdouble *, xdouble *, blasint *); + +int BLASFUNC(sgetf2)(blasint *, blasint *, float *, blasint *, blasint *, blasint *); +int BLASFUNC(dgetf2)(blasint *, blasint *, double *, blasint *, blasint *, blasint *); +int BLASFUNC(qgetf2)(blasint *, blasint *, xdouble *, blasint *, blasint *, blasint *); +int BLASFUNC(cgetf2)(blasint *, blasint *, float *, blasint *, blasint *, blasint *); +int BLASFUNC(zgetf2)(blasint *, blasint *, double *, blasint *, blasint *, blasint *); +int BLASFUNC(xgetf2)(blasint *, blasint *, xdouble *, blasint *, blasint *, blasint *); + +int BLASFUNC(sgetrf)(blasint *, blasint *, float *, blasint *, blasint *, blasint *); +int BLASFUNC(dgetrf)(blasint *, blasint *, double *, blasint *, blasint *, blasint *); +int BLASFUNC(qgetrf)(blasint *, blasint *, xdouble *, blasint *, blasint *, blasint *); +int BLASFUNC(cgetrf)(blasint *, blasint *, float *, blasint *, blasint *, blasint *); +int BLASFUNC(zgetrf)(blasint *, blasint *, double *, blasint *, blasint *, blasint *); +int BLASFUNC(xgetrf)(blasint *, blasint *, xdouble *, blasint *, blasint *, blasint *); + +int BLASFUNC(slaswp)(blasint *, float *, blasint *, blasint *, blasint *, blasint *, blasint *); +int BLASFUNC(dlaswp)(blasint *, double *, blasint *, blasint *, blasint *, blasint *, blasint *); +int BLASFUNC(qlaswp)(blasint *, xdouble *, blasint *, blasint *, blasint *, blasint *, blasint *); +int BLASFUNC(claswp)(blasint *, float *, blasint *, blasint *, blasint *, blasint *, blasint *); +int BLASFUNC(zlaswp)(blasint *, double *, blasint *, blasint *, blasint *, blasint *, blasint *); +int BLASFUNC(xlaswp)(blasint *, xdouble *, blasint *, blasint *, blasint *, blasint *, blasint *); + +int BLASFUNC(sgetrs)(char *, blasint *, blasint *, float *, blasint *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(dgetrs)(char *, blasint *, blasint *, double *, blasint *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(qgetrs)(char *, blasint *, blasint *, xdouble *, blasint *, blasint *, xdouble *, blasint *, blasint *); +int BLASFUNC(cgetrs)(char *, blasint *, blasint *, float *, blasint *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(zgetrs)(char *, blasint *, blasint *, double *, blasint *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(xgetrs)(char *, blasint *, blasint *, xdouble *, blasint *, blasint *, xdouble *, blasint *, blasint *); + +int BLASFUNC(sgesv)(blasint *, blasint *, float *, blasint *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(dgesv)(blasint *, blasint *, double *, blasint *, blasint *, double*, blasint *, blasint *); +int BLASFUNC(qgesv)(blasint *, blasint *, xdouble *, blasint *, blasint *, xdouble*, blasint *, blasint *); +int BLASFUNC(cgesv)(blasint *, blasint *, float *, blasint *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(zgesv)(blasint *, blasint *, double *, blasint *, blasint *, double*, blasint *, blasint *); +int BLASFUNC(xgesv)(blasint *, blasint *, xdouble *, blasint *, blasint *, xdouble*, blasint *, blasint *); + +int BLASFUNC(spotf2)(char *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(dpotf2)(char *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(qpotf2)(char *, blasint *, xdouble *, blasint *, blasint *); +int BLASFUNC(cpotf2)(char *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(zpotf2)(char *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(xpotf2)(char *, blasint *, xdouble *, blasint *, blasint *); + +int BLASFUNC(spotrf)(char *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(dpotrf)(char *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(qpotrf)(char *, blasint *, xdouble *, blasint *, blasint *); +int BLASFUNC(cpotrf)(char *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(zpotrf)(char *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(xpotrf)(char *, blasint *, xdouble *, blasint *, blasint *); + +int BLASFUNC(slauu2)(char *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(dlauu2)(char *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(qlauu2)(char *, blasint *, xdouble *, blasint *, blasint *); +int BLASFUNC(clauu2)(char *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(zlauu2)(char *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(xlauu2)(char *, blasint *, xdouble *, blasint *, blasint *); + +int BLASFUNC(slauum)(char *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(dlauum)(char *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(qlauum)(char *, blasint *, xdouble *, blasint *, blasint *); +int BLASFUNC(clauum)(char *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(zlauum)(char *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(xlauum)(char *, blasint *, xdouble *, blasint *, blasint *); + +int BLASFUNC(strti2)(char *, char *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(dtrti2)(char *, char *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(qtrti2)(char *, char *, blasint *, xdouble *, blasint *, blasint *); +int BLASFUNC(ctrti2)(char *, char *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(ztrti2)(char *, char *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(xtrti2)(char *, char *, blasint *, xdouble *, blasint *, blasint *); + +int BLASFUNC(strtri)(char *, char *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(dtrtri)(char *, char *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(qtrtri)(char *, char *, blasint *, xdouble *, blasint *, blasint *); +int BLASFUNC(ctrtri)(char *, char *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(ztrtri)(char *, char *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(xtrtri)(char *, char *, blasint *, xdouble *, blasint *, blasint *); + +int BLASFUNC(spotri)(char *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(dpotri)(char *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(qpotri)(char *, blasint *, xdouble *, blasint *, blasint *); +int BLASFUNC(cpotri)(char *, blasint *, float *, blasint *, blasint *); +int BLASFUNC(zpotri)(char *, blasint *, double *, blasint *, blasint *); +int BLASFUNC(xpotri)(char *, blasint *, xdouble *, blasint *, blasint *); + +int BLASFUNC(slarf)(char *, blasint *, blasint *, float *, blasint *, float *, float *, blasint *, float *); +int BLASFUNC(dlarf)(char *, blasint *, blasint *, double *, blasint *, double *, double *, blasint *, double *); +int BLASFUNC(qlarf)(char *, blasint *, blasint *, xdouble *, blasint *, xdouble *, xdouble *, blasint *, xdouble *); +int BLASFUNC(clarf)(char *, blasint *, blasint *, float *, blasint *, float *, float *, blasint *, float *); +int BLASFUNC(zlarf)(char *, blasint *, blasint *, double *, blasint *, double *, double *, blasint *, double *); +int BLASFUNC(xlarf)(char *, blasint *, blasint *, xdouble *, blasint *, xdouble *, xdouble *, blasint *, xdouble *); + +FLOATRET BLASFUNC(slamch)(char *); +double BLASFUNC(dlamch)(char *); +xdouble BLASFUNC(qlamch)(char *); + +FLOATRET BLASFUNC(slamc3)(float *, float *); +double BLASFUNC(dlamc3)(double *, double *); +xdouble BLASFUNC(qlamc3)(xdouble *, xdouble *); +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_lapack.h b/src/NativeWrappers/GotoBlas2/include/common_lapack.h new file mode 100644 index 00000000..f6d1956f --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_lapack.h @@ -0,0 +1,296 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef ASSEMBLER + +/* Lapack Library */ + +blasint sgetf2_k(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint dgetf2_k(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint qgetf2_k(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint cgetf2_k(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint zgetf2_k(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint xgetf2_k(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +blasint sgetrf_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint dgetrf_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint qgetrf_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint cgetrf_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint zgetrf_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint xgetrf_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +blasint sgetrf_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint dgetrf_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint qgetrf_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint cgetrf_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint zgetrf_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint xgetrf_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int slaswp_plus (BLASLONG, BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, blasint *, BLASLONG); +int slaswp_minus(BLASLONG, BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, blasint *, BLASLONG); +int dlaswp_plus (BLASLONG, BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, blasint *, BLASLONG); +int dlaswp_minus(BLASLONG, BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, blasint *, BLASLONG); +int qlaswp_plus (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, blasint *, BLASLONG); +int qlaswp_minus(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, blasint *, BLASLONG); + +int claswp_plus (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, blasint *, BLASLONG); +int claswp_minus(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, blasint *, BLASLONG); +int zlaswp_plus (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, blasint *, BLASLONG); +int zlaswp_minus(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, blasint *, BLASLONG); +int xlaswp_plus (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, blasint *, BLASLONG); +int xlaswp_minus(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, blasint *, BLASLONG); + +int slaswp_ncopy(BLASLONG, BLASLONG, BLASLONG, float *, BLASLONG, blasint *, float *); +int dlaswp_ncopy(BLASLONG, BLASLONG, BLASLONG, double *, BLASLONG, blasint *, double *); +int qlaswp_ncopy(BLASLONG, BLASLONG, BLASLONG, xdouble *, BLASLONG, blasint *, xdouble *); +int claswp_ncopy(BLASLONG, BLASLONG, BLASLONG, float *, BLASLONG, blasint *, float *); +int zlaswp_ncopy(BLASLONG, BLASLONG, BLASLONG, double *, BLASLONG, blasint *, double *); +int xlaswp_ncopy(BLASLONG, BLASLONG, BLASLONG, xdouble *, BLASLONG, blasint *, xdouble *); + +blasint sgetrs_N_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint sgetrs_T_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint dgetrs_N_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dgetrs_T_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint qgetrs_N_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qgetrs_T_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint cgetrs_N_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint cgetrs_T_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint cgetrs_R_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint cgetrs_C_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint zgetrs_N_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint zgetrs_T_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint zgetrs_R_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint zgetrs_C_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint xgetrs_N_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xgetrs_T_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xgetrs_R_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xgetrs_C_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +blasint sgetrs_N_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint sgetrs_T_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint dgetrs_N_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dgetrs_T_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint qgetrs_N_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qgetrs_T_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint cgetrs_N_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint cgetrs_T_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint cgetrs_R_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint cgetrs_C_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint zgetrs_N_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint zgetrs_T_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint zgetrs_R_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint zgetrs_C_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint xgetrs_N_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xgetrs_T_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xgetrs_R_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xgetrs_C_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +blasint spotf2_U(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint spotf2_L(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint dpotf2_U(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dpotf2_L(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint qpotf2_U(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qpotf2_L(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint cpotf2_U(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint cpotf2_L(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint zpotf2_U(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint zpotf2_L(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint xpotf2_U(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xpotf2_L(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +blasint spotrf_U_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint spotrf_L_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint dpotrf_U_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dpotrf_L_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint qpotrf_U_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qpotrf_L_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint cpotrf_U_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint cpotrf_L_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint zpotrf_U_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint zpotrf_L_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint xpotrf_U_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xpotrf_L_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +blasint spotrf_U_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint spotrf_L_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint dpotrf_U_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dpotrf_L_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint qpotrf_U_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qpotrf_L_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint cpotrf_U_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint cpotrf_L_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint zpotrf_U_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint zpotrf_L_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint xpotrf_U_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xpotrf_L_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +blasint slauu2_U(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint slauu2_L(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint dlauu2_U(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dlauu2_L(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint qlauu2_U(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qlauu2_L(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint clauu2_U(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint clauu2_L(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint zlauu2_U(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint zlauu2_L(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint xlauu2_U(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xlauu2_L(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +blasint slauum_U_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint slauum_L_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint dlauum_U_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dlauum_L_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint qlauum_U_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qlauum_L_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint clauum_U_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint clauum_L_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint zlauum_U_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint zlauum_L_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint xlauum_U_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xlauum_L_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +blasint slauum_U_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint slauum_L_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint dlauum_U_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dlauum_L_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint qlauum_U_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qlauum_L_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint clauum_U_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint clauum_L_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint zlauum_U_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint zlauum_L_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint xlauum_U_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xlauum_L_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +blasint strti2_UU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint strti2_UN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint strti2_LU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint strti2_LN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint dtrti2_UU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dtrti2_UN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dtrti2_LU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dtrti2_LN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint qtrti2_UU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qtrti2_UN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qtrti2_LU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qtrti2_LN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint ctrti2_UU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint ctrti2_UN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint ctrti2_LU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint ctrti2_LN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint ztrti2_UU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint ztrti2_UN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint ztrti2_LU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint ztrti2_LN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint xtrti2_UU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xtrti2_UN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xtrti2_LU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xtrti2_LN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +blasint strtri_UU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint strtri_UN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint strtri_LU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint strtri_LN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint dtrtri_UU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dtrtri_UN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dtrtri_LU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dtrtri_LN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint qtrtri_UU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qtrtri_UN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qtrtri_LU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qtrtri_LN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint ctrtri_UU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint ctrtri_UN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint ctrtri_LU_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint ctrtri_LN_single(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint ztrtri_UU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint ztrtri_UN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint ztrtri_LU_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint ztrtri_LN_single(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint xtrtri_UU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xtrtri_UN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xtrtri_LU_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xtrtri_LN_single(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +blasint strtri_UU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint strtri_UN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint strtri_LU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint strtri_LN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint dtrtri_UU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dtrtri_UN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dtrtri_LU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dtrtri_LN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint qtrtri_UU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qtrtri_UN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qtrtri_LU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qtrtri_LN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint ctrtri_UU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint ctrtri_UN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint ctrtri_LU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint ctrtri_LN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint ztrtri_UU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint ztrtri_UN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint ztrtri_LU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint ztrtri_LN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint xtrtri_UU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xtrtri_UN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xtrtri_LU_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xtrtri_LN_parallel(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int sneg_tcopy(BLASLONG, BLASLONG, float *, BLASLONG, float *); +int dneg_tcopy(BLASLONG, BLASLONG, double *, BLASLONG, double *); +int qneg_tcopy(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); +int cneg_tcopy(BLASLONG, BLASLONG, float *, BLASLONG, float *); +int zneg_tcopy(BLASLONG, BLASLONG, double *, BLASLONG, double *); +int xneg_tcopy(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + +blasint slarf_L(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint slarf_R(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint dlarf_L(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint dlarf_R(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint qlarf_L(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint qlarf_R(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint clarf_L(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint clarf_R(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +blasint zlarf_L(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint zlarf_R(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +blasint xlarf_L(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +blasint xlarf_R(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_level1.h b/src/NativeWrappers/GotoBlas2/include/common_level1.h new file mode 100644 index 00000000..f51ced66 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_level1.h @@ -0,0 +1,212 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef ASSEMBLER + +#ifdef __CUDACC__ +extern "C" { +#endif + +float sdot_k(BLASLONG, float *, BLASLONG, float *, BLASLONG); +double dsdot_k(BLASLONG, float *, BLASLONG, float *, BLASLONG); +double ddot_k(BLASLONG, double *, BLASLONG, double *, BLASLONG); +xdouble qdot_k(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + +float _Complex cdotc_k (BLASLONG, float *, BLASLONG, float *, BLASLONG); +float _Complex cdotu_k (BLASLONG, float *, BLASLONG, float *, BLASLONG); +double _Complex zdotc_k (BLASLONG, double *, BLASLONG, double *, BLASLONG); +double _Complex zdotu_k (BLASLONG, double *, BLASLONG, double *, BLASLONG); +xdouble _Complex xdotc_k (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); +xdouble _Complex xdotu_k (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + +int saxpy_k (BLASLONG, BLASLONG, BLASLONG, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); +int daxpy_k (BLASLONG, BLASLONG, BLASLONG, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); +int qaxpy_k (BLASLONG, BLASLONG, BLASLONG, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); +int caxpy_k (BLASLONG, BLASLONG, BLASLONG, float, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); +int zaxpy_k (BLASLONG, BLASLONG, BLASLONG, double, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); +int xaxpy_k (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); +int caxpyc_k (BLASLONG, BLASLONG, BLASLONG, float, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); +int zaxpyc_k (BLASLONG, BLASLONG, BLASLONG, double, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); +int xaxpyc_k (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + +int scopy_k(BLASLONG, float *, BLASLONG, float *, BLASLONG); +int dcopy_k(BLASLONG, double *, BLASLONG, double *, BLASLONG); +int qcopy_k(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); +int ccopy_k(BLASLONG, float *, BLASLONG, float *, BLASLONG); +int zcopy_k(BLASLONG, double *, BLASLONG, double *, BLASLONG); +int xcopy_k(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + +int sswap_k (BLASLONG, BLASLONG, BLASLONG, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); +int dswap_k (BLASLONG, BLASLONG, BLASLONG, double, + double *, BLASLONG, double *, BLASLONG, double*, BLASLONG); +int qswap_k (BLASLONG, BLASLONG, BLASLONG, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble*, BLASLONG); +int cswap_k (BLASLONG, BLASLONG, BLASLONG, float, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); +int zswap_k (BLASLONG, BLASLONG, BLASLONG, double, double, + double *, BLASLONG, double *, BLASLONG, double*, BLASLONG); +int xswap_k (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble*, BLASLONG); + +float sasum_k (BLASLONG, float *, BLASLONG); +double dasum_k (BLASLONG, double *, BLASLONG); +xdouble qasum_k (BLASLONG, xdouble *, BLASLONG); +float casum_k (BLASLONG, float *, BLASLONG); +double zasum_k (BLASLONG, double *, BLASLONG); +xdouble xasum_k (BLASLONG, xdouble *, BLASLONG); + +float samax_k (BLASLONG, float *, BLASLONG); +double damax_k (BLASLONG, double *, BLASLONG); +xdouble qamax_k (BLASLONG, xdouble *, BLASLONG); +float camax_k (BLASLONG, float *, BLASLONG); +double zamax_k (BLASLONG, double *, BLASLONG); +xdouble xamax_k (BLASLONG, xdouble *, BLASLONG); + +float samin_k (BLASLONG, float *, BLASLONG); +double damin_k (BLASLONG, double *, BLASLONG); +xdouble qamin_k (BLASLONG, xdouble *, BLASLONG); +float camin_k (BLASLONG, float *, BLASLONG); +double zamin_k (BLASLONG, double *, BLASLONG); +xdouble xamin_k (BLASLONG, xdouble *, BLASLONG); + +BLASLONG isamax_k(BLASLONG, float *, BLASLONG); +BLASLONG idamax_k(BLASLONG, double *, BLASLONG); +BLASLONG iqamax_k(BLASLONG, xdouble *, BLASLONG); +BLASLONG icamax_k(BLASLONG, float *, BLASLONG); +BLASLONG izamax_k(BLASLONG, double *, BLASLONG); +BLASLONG ixamax_k(BLASLONG, xdouble *, BLASLONG); + +BLASLONG isamin_k(BLASLONG, float *, BLASLONG); +BLASLONG idamin_k(BLASLONG, double *, BLASLONG); +BLASLONG iqamin_k(BLASLONG, xdouble *, BLASLONG); +BLASLONG icamin_k(BLASLONG, float *, BLASLONG); +BLASLONG izamin_k(BLASLONG, double *, BLASLONG); +BLASLONG ixamin_k(BLASLONG, xdouble *, BLASLONG); + +float smax_k (BLASLONG, float *, BLASLONG); +double dmax_k (BLASLONG, double *, BLASLONG); +xdouble qmax_k (BLASLONG, xdouble *, BLASLONG); +float cmax_k (BLASLONG, float *, BLASLONG); +double zmax_k (BLASLONG, double *, BLASLONG); +xdouble xmax_k (BLASLONG, xdouble *, BLASLONG); + +float smin_k (BLASLONG, float *, BLASLONG); +double dmin_k (BLASLONG, double *, BLASLONG); +xdouble qmin_k (BLASLONG, xdouble *, BLASLONG); +float cmin_k (BLASLONG, float *, BLASLONG); +double zmin_k (BLASLONG, double *, BLASLONG); +xdouble xmin_k (BLASLONG, xdouble *, BLASLONG); + +BLASLONG ismax_k(BLASLONG, float *, BLASLONG); +BLASLONG idmax_k(BLASLONG, double *, BLASLONG); +BLASLONG iqmax_k(BLASLONG, xdouble *, BLASLONG); +BLASLONG icmax_k(BLASLONG, float *, BLASLONG); +BLASLONG izmax_k(BLASLONG, double *, BLASLONG); +BLASLONG ixmax_k(BLASLONG, xdouble *, BLASLONG); + +BLASLONG ismin_k(BLASLONG, float *, BLASLONG); +BLASLONG idmin_k(BLASLONG, double *, BLASLONG); +BLASLONG iqmin_k(BLASLONG, xdouble *, BLASLONG); +BLASLONG icmin_k(BLASLONG, float *, BLASLONG); +BLASLONG izmin_k(BLASLONG, double *, BLASLONG); +BLASLONG ixmin_k(BLASLONG, xdouble *, BLASLONG); + +int sscal_k(BLASLONG, BLASLONG, BLASLONG, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); +int dscal_k(BLASLONG, BLASLONG, BLASLONG, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); +int qscal_k(BLASLONG, BLASLONG, BLASLONG, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); +int cscal_k(BLASLONG, BLASLONG, BLASLONG, float, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); +int zscal_k(BLASLONG, BLASLONG, BLASLONG, double, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); +int xscal_k(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); +int csscal_k(BLASLONG, BLASLONG, BLASLONG, float, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); +int zdscal_k(BLASLONG, BLASLONG, BLASLONG, double, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); +int xqscal_k(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + +float snrm2_k(BLASLONG, float *, BLASLONG); +double dnrm2_k(BLASLONG, double *, BLASLONG); +xdouble qnrm2_k(BLASLONG, xdouble *, BLASLONG); +float cnrm2_k(BLASLONG, float *, BLASLONG); +double znrm2_k(BLASLONG, double *, BLASLONG); +xdouble xnrm2_k(BLASLONG, xdouble *, BLASLONG); + +int srot_k (BLASLONG, float *, BLASLONG, float *, BLASLONG, float , float ); +int drot_k (BLASLONG, double *, BLASLONG, double *, BLASLONG, double, double); +int qrot_k (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble, xdouble); +int csrot_k(BLASLONG, float *, BLASLONG, float *, BLASLONG, float , float ); +int zdrot_k(BLASLONG, double *, BLASLONG, double *, BLASLONG, double, double); +int xqrot_k(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble, xdouble); + +int srotg_k(float *, float *, float *, float *); +int drotg_k(double *, double *, double *, double *); +int qrotg_k(xdouble *, xdouble *, xdouble *, xdouble *); +int csrotg_k(float *, float *, float *, float *); +int zdrotg_k(double *, double *, double *, double *); +int xqrotg_k(xdouble *, xdouble *, xdouble *, xdouble *); + +int srotmg_k(float *, float *, float *, float *, float *); +int drotmg_k(double *, double *, double *, double *, double *); +int qrotmg_k(xdouble *, xdouble *, xdouble *, xdouble *, xdouble *); + +int srotm_k (BLASLONG, float, BLASLONG, float, BLASLONG, float); +int drotm_k (BLASLONG, double, BLASLONG, double, BLASLONG, double); +int qrotm_k (BLASLONG, xdouble, BLASLONG, xdouble, BLASLONG, xdouble); + +#ifdef __CUDACC__ +} +#endif + +#endif + diff --git a/src/NativeWrappers/GotoBlas2/include/common_level2.h b/src/NativeWrappers/GotoBlas2/include/common_level2.h new file mode 100644 index 00000000..2ab682a0 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_level2.h @@ -0,0 +1,1359 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef ASSEMBLER + +/* Level 2 Blas routines */ + +#ifdef __CUDACC__ +extern "C" { +#endif + +int sger_k (BLASLONG, BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int dger_k (BLASLONG, BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int qger_k (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int cgeru_k(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int cgerc_k(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int cgerv_k(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int cgerd_k(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int zgeru_k(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int zgerc_k(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int zgerv_k(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int zgerd_k(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int xgeru_k(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xgerc_k(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xgerv_k(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xgerd_k(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + +int sger_thread (BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int dger_thread (BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int qger_thread (BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int cger_thread_U(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int cger_thread_C(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int cger_thread_V(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int cger_thread_D(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int zger_thread_U(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int zger_thread_C(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int zger_thread_V(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int zger_thread_D(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int xger_thread_U(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xger_thread_C(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xger_thread_V(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xger_thread_D(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); + +int sgemv_n(BLASLONG, BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer); +int sgemv_t(BLASLONG, BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer); +int dgemv_n(BLASLONG, BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer); +int dgemv_t(BLASLONG, BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer); +int qgemv_n(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer); +int qgemv_t(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer); + +int cgemv_n(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer); +int cgemv_t(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer); +int cgemv_r(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer); +int cgemv_c(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer); +int cgemv_o(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer); +int cgemv_u(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer); +int cgemv_s(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer); +int cgemv_d(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer); + +int zgemv_n(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer); +int zgemv_t(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer); +int zgemv_r(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer); +int zgemv_c(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer); +int zgemv_o(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer); +int zgemv_u(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer); +int zgemv_s(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer); +int zgemv_d(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer); + +int xgemv_n(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer); +int xgemv_t(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer); +int xgemv_r(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer); +int xgemv_c(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer); +int xgemv_o(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer); +int xgemv_u(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer); +int xgemv_s(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer); +int xgemv_d(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer); + +int sgemv_thread_n(BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int sgemv_thread_t(BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int dgemv_thread_n(BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int dgemv_thread_t(BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int qgemv_thread_n(BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int qgemv_thread_t(BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); + +int cgemv_thread_n(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int cgemv_thread_t(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int cgemv_thread_r(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int cgemv_thread_c(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int cgemv_thread_o(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int cgemv_thread_u(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int cgemv_thread_s(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int cgemv_thread_d(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); + +int zgemv_thread_n(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int zgemv_thread_t(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int zgemv_thread_r(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int zgemv_thread_c(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int zgemv_thread_o(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int zgemv_thread_u(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int zgemv_thread_s(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int zgemv_thread_d(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); + +int xgemv_thread_n(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int xgemv_thread_t(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int xgemv_thread_r(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int xgemv_thread_c(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int xgemv_thread_o(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int xgemv_thread_u(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int xgemv_thread_s(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int xgemv_thread_d(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); + +int strsv_NUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int strsv_NUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int strsv_NLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int strsv_NLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int strsv_TUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int strsv_TUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int strsv_TLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int strsv_TLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); + +int dtrsv_NUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtrsv_NUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtrsv_NLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtrsv_NLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtrsv_TUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtrsv_TUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtrsv_TLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtrsv_TLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); + +int qtrsv_NUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtrsv_NUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtrsv_NLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtrsv_NLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtrsv_TUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtrsv_TUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtrsv_TLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtrsv_TLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); + +int ctrsv_NUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctrsv_NUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctrsv_NLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctrsv_NLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctrsv_TUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctrsv_TUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctrsv_TLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctrsv_TLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctrsv_RUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctrsv_RUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctrsv_RLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctrsv_RLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctrsv_CUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctrsv_CUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctrsv_CLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctrsv_CLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); + +int ztrsv_NUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztrsv_NUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztrsv_NLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztrsv_NLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztrsv_TUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztrsv_TUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztrsv_TLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztrsv_TLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztrsv_RUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztrsv_RUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztrsv_RLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztrsv_RLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztrsv_CUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztrsv_CUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztrsv_CLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztrsv_CLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); + +int xtrsv_NUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtrsv_NUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtrsv_NLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtrsv_NLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtrsv_TUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtrsv_TUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtrsv_TLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtrsv_TLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtrsv_RUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtrsv_RUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtrsv_RLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtrsv_RLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtrsv_CUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtrsv_CUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtrsv_CLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtrsv_CLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); + +int strmv_NUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int strmv_NUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int strmv_NLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int strmv_NLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int strmv_TUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int strmv_TUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int strmv_TLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int strmv_TLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + +int dtrmv_NUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int dtrmv_NUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int dtrmv_NLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int dtrmv_NLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int dtrmv_TUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int dtrmv_TUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int dtrmv_TLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int dtrmv_TLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + +int qtrmv_NUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int qtrmv_NUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int qtrmv_NLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int qtrmv_NLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int qtrmv_TUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int qtrmv_TUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int qtrmv_TLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int qtrmv_TLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + +int ctrmv_NUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ctrmv_NUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ctrmv_NLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ctrmv_NLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ctrmv_TUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ctrmv_TUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ctrmv_TLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ctrmv_TLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ctrmv_RUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ctrmv_RUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ctrmv_RLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ctrmv_RLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ctrmv_CUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ctrmv_CUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ctrmv_CLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ctrmv_CLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + +int ztrmv_NUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int ztrmv_NUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int ztrmv_NLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int ztrmv_NLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int ztrmv_TUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int ztrmv_TUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int ztrmv_TLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int ztrmv_TLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int ztrmv_RUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int ztrmv_RUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int ztrmv_RLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int ztrmv_RLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int ztrmv_CUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int ztrmv_CUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int ztrmv_CLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int ztrmv_CLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + +int xtrmv_NUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xtrmv_NUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xtrmv_NLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xtrmv_NLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xtrmv_TUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xtrmv_TUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xtrmv_TLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xtrmv_TLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xtrmv_RUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xtrmv_RUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xtrmv_RLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xtrmv_RLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xtrmv_CUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xtrmv_CUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xtrmv_CLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xtrmv_CLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + +int strmv_thread_NUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int strmv_thread_NUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int strmv_thread_NLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int strmv_thread_NLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int strmv_thread_TUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int strmv_thread_TUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int strmv_thread_TLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int strmv_thread_TLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); + +int dtrmv_thread_NUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dtrmv_thread_NUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dtrmv_thread_NLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dtrmv_thread_NLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dtrmv_thread_TUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dtrmv_thread_TUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dtrmv_thread_TLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dtrmv_thread_TLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); + +int qtrmv_thread_NUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qtrmv_thread_NUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qtrmv_thread_NLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qtrmv_thread_NLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qtrmv_thread_TUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qtrmv_thread_TUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qtrmv_thread_TLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qtrmv_thread_TLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); + +int ctrmv_thread_NUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctrmv_thread_NUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctrmv_thread_NLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctrmv_thread_NLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctrmv_thread_TUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctrmv_thread_TUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctrmv_thread_TLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctrmv_thread_TLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctrmv_thread_RUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctrmv_thread_RUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctrmv_thread_RLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctrmv_thread_RLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctrmv_thread_CUU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctrmv_thread_CUN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctrmv_thread_CLU(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctrmv_thread_CLN(BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); + +int ztrmv_thread_NUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztrmv_thread_NUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztrmv_thread_NLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztrmv_thread_NLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztrmv_thread_TUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztrmv_thread_TUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztrmv_thread_TLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztrmv_thread_TLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztrmv_thread_RUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztrmv_thread_RUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztrmv_thread_RLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztrmv_thread_RLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztrmv_thread_CUU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztrmv_thread_CUN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztrmv_thread_CLU(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztrmv_thread_CLN(BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); + +int xtrmv_thread_NUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtrmv_thread_NUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtrmv_thread_NLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtrmv_thread_NLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtrmv_thread_TUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtrmv_thread_TUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtrmv_thread_TLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtrmv_thread_TLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtrmv_thread_RUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtrmv_thread_RUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtrmv_thread_RLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtrmv_thread_RLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtrmv_thread_CUU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtrmv_thread_CUN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtrmv_thread_CLU(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtrmv_thread_CLN(BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); + +int stpsv_NUU(BLASLONG, float *, float *, BLASLONG, void *); +int stpsv_NUN(BLASLONG, float *, float *, BLASLONG, void *); +int stpsv_NLU(BLASLONG, float *, float *, BLASLONG, void *); +int stpsv_NLN(BLASLONG, float *, float *, BLASLONG, void *); +int stpsv_TUU(BLASLONG, float *, float *, BLASLONG, void *); +int stpsv_TUN(BLASLONG, float *, float *, BLASLONG, void *); +int stpsv_TLU(BLASLONG, float *, float *, BLASLONG, void *); +int stpsv_TLN(BLASLONG, float *, float *, BLASLONG, void *); + +int dtpsv_NUU(BLASLONG, double *, double *, BLASLONG, void *); +int dtpsv_NUN(BLASLONG, double *, double *, BLASLONG, void *); +int dtpsv_NLU(BLASLONG, double *, double *, BLASLONG, void *); +int dtpsv_NLN(BLASLONG, double *, double *, BLASLONG, void *); +int dtpsv_TUU(BLASLONG, double *, double *, BLASLONG, void *); +int dtpsv_TUN(BLASLONG, double *, double *, BLASLONG, void *); +int dtpsv_TLU(BLASLONG, double *, double *, BLASLONG, void *); +int dtpsv_TLN(BLASLONG, double *, double *, BLASLONG, void *); + +int qtpsv_NUU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int qtpsv_NUN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int qtpsv_NLU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int qtpsv_NLN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int qtpsv_TUU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int qtpsv_TUN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int qtpsv_TLU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int qtpsv_TLN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); + +int ctpsv_NUU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpsv_NUN(BLASLONG, float *, float *, BLASLONG, void *); +int ctpsv_NLU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpsv_NLN(BLASLONG, float *, float *, BLASLONG, void *); +int ctpsv_TUU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpsv_TUN(BLASLONG, float *, float *, BLASLONG, void *); +int ctpsv_TLU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpsv_TLN(BLASLONG, float *, float *, BLASLONG, void *); +int ctpsv_RUU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpsv_RUN(BLASLONG, float *, float *, BLASLONG, void *); +int ctpsv_RLU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpsv_RLN(BLASLONG, float *, float *, BLASLONG, void *); +int ctpsv_CUU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpsv_CUN(BLASLONG, float *, float *, BLASLONG, void *); +int ctpsv_CLU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpsv_CLN(BLASLONG, float *, float *, BLASLONG, void *); + +int ztpsv_NUU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpsv_NUN(BLASLONG, double *, double *, BLASLONG, void *); +int ztpsv_NLU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpsv_NLN(BLASLONG, double *, double *, BLASLONG, void *); +int ztpsv_TUU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpsv_TUN(BLASLONG, double *, double *, BLASLONG, void *); +int ztpsv_TLU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpsv_TLN(BLASLONG, double *, double *, BLASLONG, void *); +int ztpsv_RUU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpsv_RUN(BLASLONG, double *, double *, BLASLONG, void *); +int ztpsv_RLU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpsv_RLN(BLASLONG, double *, double *, BLASLONG, void *); +int ztpsv_CUU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpsv_CUN(BLASLONG, double *, double *, BLASLONG, void *); +int ztpsv_CLU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpsv_CLN(BLASLONG, double *, double *, BLASLONG, void *); + +int xtpsv_NUU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpsv_NUN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpsv_NLU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpsv_NLN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpsv_TUU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpsv_TUN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpsv_TLU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpsv_TLN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpsv_RUU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpsv_RUN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpsv_RLU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpsv_RLN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpsv_CUU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpsv_CUN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpsv_CLU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpsv_CLN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); + +int stpmv_NUU(BLASLONG, float *, float *, BLASLONG, void *); +int stpmv_NUN(BLASLONG, float *, float *, BLASLONG, void *); +int stpmv_NLU(BLASLONG, float *, float *, BLASLONG, void *); +int stpmv_NLN(BLASLONG, float *, float *, BLASLONG, void *); +int stpmv_TUU(BLASLONG, float *, float *, BLASLONG, void *); +int stpmv_TUN(BLASLONG, float *, float *, BLASLONG, void *); +int stpmv_TLU(BLASLONG, float *, float *, BLASLONG, void *); +int stpmv_TLN(BLASLONG, float *, float *, BLASLONG, void *); + +int dtpmv_NUU(BLASLONG, double *, double *, BLASLONG, void *); +int dtpmv_NUN(BLASLONG, double *, double *, BLASLONG, void *); +int dtpmv_NLU(BLASLONG, double *, double *, BLASLONG, void *); +int dtpmv_NLN(BLASLONG, double *, double *, BLASLONG, void *); +int dtpmv_TUU(BLASLONG, double *, double *, BLASLONG, void *); +int dtpmv_TUN(BLASLONG, double *, double *, BLASLONG, void *); +int dtpmv_TLU(BLASLONG, double *, double *, BLASLONG, void *); +int dtpmv_TLN(BLASLONG, double *, double *, BLASLONG, void *); + +int qtpmv_NUU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int qtpmv_NUN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int qtpmv_NLU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int qtpmv_NLN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int qtpmv_TUU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int qtpmv_TUN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int qtpmv_TLU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int qtpmv_TLN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); + +int ctpmv_NUU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpmv_NUN(BLASLONG, float *, float *, BLASLONG, void *); +int ctpmv_NLU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpmv_NLN(BLASLONG, float *, float *, BLASLONG, void *); +int ctpmv_TUU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpmv_TUN(BLASLONG, float *, float *, BLASLONG, void *); +int ctpmv_TLU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpmv_TLN(BLASLONG, float *, float *, BLASLONG, void *); +int ctpmv_RUU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpmv_RUN(BLASLONG, float *, float *, BLASLONG, void *); +int ctpmv_RLU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpmv_RLN(BLASLONG, float *, float *, BLASLONG, void *); +int ctpmv_CUU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpmv_CUN(BLASLONG, float *, float *, BLASLONG, void *); +int ctpmv_CLU(BLASLONG, float *, float *, BLASLONG, void *); +int ctpmv_CLN(BLASLONG, float *, float *, BLASLONG, void *); + +int ztpmv_NUU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpmv_NUN(BLASLONG, double *, double *, BLASLONG, void *); +int ztpmv_NLU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpmv_NLN(BLASLONG, double *, double *, BLASLONG, void *); +int ztpmv_TUU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpmv_TUN(BLASLONG, double *, double *, BLASLONG, void *); +int ztpmv_TLU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpmv_TLN(BLASLONG, double *, double *, BLASLONG, void *); +int ztpmv_RUU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpmv_RUN(BLASLONG, double *, double *, BLASLONG, void *); +int ztpmv_RLU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpmv_RLN(BLASLONG, double *, double *, BLASLONG, void *); +int ztpmv_CUU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpmv_CUN(BLASLONG, double *, double *, BLASLONG, void *); +int ztpmv_CLU(BLASLONG, double *, double *, BLASLONG, void *); +int ztpmv_CLN(BLASLONG, double *, double *, BLASLONG, void *); + +int xtpmv_NUU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpmv_NUN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpmv_NLU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpmv_NLN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpmv_TUU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpmv_TUN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpmv_TLU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpmv_TLN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpmv_RUU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpmv_RUN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpmv_RLU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpmv_RLN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpmv_CUU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpmv_CUN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpmv_CLU(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); +int xtpmv_CLN(BLASLONG, xdouble *, xdouble *, BLASLONG, void *); + +int stpmv_thread_NUU(BLASLONG, float *, float *, BLASLONG, float *, int); +int stpmv_thread_NUN(BLASLONG, float *, float *, BLASLONG, float *, int); +int stpmv_thread_NLU(BLASLONG, float *, float *, BLASLONG, float *, int); +int stpmv_thread_NLN(BLASLONG, float *, float *, BLASLONG, float *, int); +int stpmv_thread_TUU(BLASLONG, float *, float *, BLASLONG, float *, int); +int stpmv_thread_TUN(BLASLONG, float *, float *, BLASLONG, float *, int); +int stpmv_thread_TLU(BLASLONG, float *, float *, BLASLONG, float *, int); +int stpmv_thread_TLN(BLASLONG, float *, float *, BLASLONG, float *, int); + +int dtpmv_thread_NUU(BLASLONG, double *, double *, BLASLONG, double *, int); +int dtpmv_thread_NUN(BLASLONG, double *, double *, BLASLONG, double *, int); +int dtpmv_thread_NLU(BLASLONG, double *, double *, BLASLONG, double *, int); +int dtpmv_thread_NLN(BLASLONG, double *, double *, BLASLONG, double *, int); +int dtpmv_thread_TUU(BLASLONG, double *, double *, BLASLONG, double *, int); +int dtpmv_thread_TUN(BLASLONG, double *, double *, BLASLONG, double *, int); +int dtpmv_thread_TLU(BLASLONG, double *, double *, BLASLONG, double *, int); +int dtpmv_thread_TLN(BLASLONG, double *, double *, BLASLONG, double *, int); + +int qtpmv_thread_NUU(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int qtpmv_thread_NUN(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int qtpmv_thread_NLU(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int qtpmv_thread_NLN(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int qtpmv_thread_TUU(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int qtpmv_thread_TUN(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int qtpmv_thread_TLU(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int qtpmv_thread_TLN(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); + +int ctpmv_thread_NUU(BLASLONG, float *, float *, BLASLONG, float *, int); +int ctpmv_thread_NUN(BLASLONG, float *, float *, BLASLONG, float *, int); +int ctpmv_thread_NLU(BLASLONG, float *, float *, BLASLONG, float *, int); +int ctpmv_thread_NLN(BLASLONG, float *, float *, BLASLONG, float *, int); +int ctpmv_thread_TUU(BLASLONG, float *, float *, BLASLONG, float *, int); +int ctpmv_thread_TUN(BLASLONG, float *, float *, BLASLONG, float *, int); +int ctpmv_thread_TLU(BLASLONG, float *, float *, BLASLONG, float *, int); +int ctpmv_thread_TLN(BLASLONG, float *, float *, BLASLONG, float *, int); +int ctpmv_thread_RUU(BLASLONG, float *, float *, BLASLONG, float *, int); +int ctpmv_thread_RUN(BLASLONG, float *, float *, BLASLONG, float *, int); +int ctpmv_thread_RLU(BLASLONG, float *, float *, BLASLONG, float *, int); +int ctpmv_thread_RLN(BLASLONG, float *, float *, BLASLONG, float *, int); +int ctpmv_thread_CUU(BLASLONG, float *, float *, BLASLONG, float *, int); +int ctpmv_thread_CUN(BLASLONG, float *, float *, BLASLONG, float *, int); +int ctpmv_thread_CLU(BLASLONG, float *, float *, BLASLONG, float *, int); +int ctpmv_thread_CLN(BLASLONG, float *, float *, BLASLONG, float *, int); + +int ztpmv_thread_NUU(BLASLONG, double *, double *, BLASLONG, double *, int); +int ztpmv_thread_NUN(BLASLONG, double *, double *, BLASLONG, double *, int); +int ztpmv_thread_NLU(BLASLONG, double *, double *, BLASLONG, double *, int); +int ztpmv_thread_NLN(BLASLONG, double *, double *, BLASLONG, double *, int); +int ztpmv_thread_TUU(BLASLONG, double *, double *, BLASLONG, double *, int); +int ztpmv_thread_TUN(BLASLONG, double *, double *, BLASLONG, double *, int); +int ztpmv_thread_TLU(BLASLONG, double *, double *, BLASLONG, double *, int); +int ztpmv_thread_TLN(BLASLONG, double *, double *, BLASLONG, double *, int); +int ztpmv_thread_RUU(BLASLONG, double *, double *, BLASLONG, double *, int); +int ztpmv_thread_RUN(BLASLONG, double *, double *, BLASLONG, double *, int); +int ztpmv_thread_RLU(BLASLONG, double *, double *, BLASLONG, double *, int); +int ztpmv_thread_RLN(BLASLONG, double *, double *, BLASLONG, double *, int); +int ztpmv_thread_CUU(BLASLONG, double *, double *, BLASLONG, double *, int); +int ztpmv_thread_CUN(BLASLONG, double *, double *, BLASLONG, double *, int); +int ztpmv_thread_CLU(BLASLONG, double *, double *, BLASLONG, double *, int); +int ztpmv_thread_CLN(BLASLONG, double *, double *, BLASLONG, double *, int); + +int xtpmv_thread_NUU(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int xtpmv_thread_NUN(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int xtpmv_thread_NLU(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int xtpmv_thread_NLN(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int xtpmv_thread_TUU(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int xtpmv_thread_TUN(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int xtpmv_thread_TLU(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int xtpmv_thread_TLN(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int xtpmv_thread_RUU(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int xtpmv_thread_RUN(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int xtpmv_thread_RLU(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int xtpmv_thread_RLN(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int xtpmv_thread_CUU(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int xtpmv_thread_CUN(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int xtpmv_thread_CLU(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); +int xtpmv_thread_CLN(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, int); + +int ssymv_L(BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ssymv_U(BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int dsymv_L(BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int dsymv_U(BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int qsymv_L(BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int qsymv_U(BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int csymv_L(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int csymv_U(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int zsymv_L(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int zsymv_U(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int xsymv_L(BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xsymv_U(BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + +int ssymv_thread_L(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ssymv_thread_U(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int dsymv_thread_L(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dsymv_thread_U(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int qsymv_thread_L(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qsymv_thread_U(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int csymv_thread_L(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int csymv_thread_U(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int zsymv_thread_L(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int zsymv_thread_U(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int xsymv_thread_L(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xsymv_thread_U(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); + +int chemv_thread_L(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int chemv_thread_U(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int chemv_thread_M(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int chemv_thread_V(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int zhemv_thread_L(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int zhemv_thread_U(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int zhemv_thread_M(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int zhemv_thread_V(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int xhemv_thread_L(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xhemv_thread_U(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xhemv_thread_M(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xhemv_thread_V(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); + +int sspmv_L(BLASLONG, float, float *, float *, BLASLONG, float *, BLASLONG, void *); +int sspmv_U(BLASLONG, float, float *, float *, BLASLONG, float *, BLASLONG, void *); +int dspmv_L(BLASLONG, double, double *, double *, BLASLONG, double *, BLASLONG, void *); +int dspmv_U(BLASLONG, double, double *, double *, BLASLONG, double *, BLASLONG, void *); +int qspmv_L(BLASLONG, xdouble, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qspmv_U(BLASLONG, xdouble, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int cspmv_L(BLASLONG, float, float, float *, float *, BLASLONG, float *, BLASLONG, void *); +int cspmv_U(BLASLONG, float, float, float *, float *, BLASLONG, float *, BLASLONG, void *); +int zspmv_L(BLASLONG, double, double, double *, double *, BLASLONG, double *, BLASLONG, void *); +int zspmv_U(BLASLONG, double, double, double *, double *, BLASLONG, double *, BLASLONG, void *); +int xspmv_L(BLASLONG, xdouble, xdouble, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xspmv_U(BLASLONG, xdouble, xdouble, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); + +int sspmv_thread_L(BLASLONG, float, float *, float *, BLASLONG, float *, BLASLONG, float *, int); +int sspmv_thread_U(BLASLONG, float, float *, float *, BLASLONG, float *, BLASLONG, float *, int); +int dspmv_thread_L(BLASLONG, double, double *, double *, BLASLONG, double *, BLASLONG, double *, int); +int dspmv_thread_U(BLASLONG, double, double *, double *, BLASLONG, double *, BLASLONG, double *, int); +int qspmv_thread_L(BLASLONG, xdouble, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qspmv_thread_U(BLASLONG, xdouble, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int cspmv_thread_L(BLASLONG, float *, float *, float *, BLASLONG, float *, BLASLONG, float *, int); +int cspmv_thread_U(BLASLONG, float *, float *, float *, BLASLONG, float *, BLASLONG, float *, int); +int zspmv_thread_L(BLASLONG, double *, double *, double *, BLASLONG, double *, BLASLONG, double *, int); +int zspmv_thread_U(BLASLONG, double *, double *, double *, BLASLONG, double *, BLASLONG, double *, int); +int xspmv_thread_L(BLASLONG, xdouble *, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xspmv_thread_U(BLASLONG, xdouble *, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); + +int ssyr_L(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *); +int ssyr_U(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *); +int dsyr_L(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *); +int dsyr_U(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *); +int qsyr_L(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int qsyr_U(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int csyr_L(BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *); +int csyr_U(BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *); +int zsyr_L(BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *); +int zsyr_U(BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *); +int xsyr_L(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xsyr_U(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + +int ssyr_thread_L(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, int); +int ssyr_thread_U(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, int); +int dsyr_thread_L(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, int); +int dsyr_thread_U(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, int); +int qsyr_thread_L(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qsyr_thread_U(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int csyr_thread_L(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, int); +int csyr_thread_U(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, int); +int zsyr_thread_L(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, int); +int zsyr_thread_U(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, int); +int xsyr_thread_L(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xsyr_thread_U(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); + +int ssyr2_L(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int ssyr2_U(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int dsyr2_L(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int dsyr2_U(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int qsyr2_L(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int qsyr2_U(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int csyr2_L(BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int csyr2_U(BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int zsyr2_L(BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int zsyr2_U(BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int xsyr2_L(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xsyr2_U(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + +int ssyr2_thread_L(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ssyr2_thread_U(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int dsyr2_thread_L(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dsyr2_thread_U(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int qsyr2_thread_L(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qsyr2_thread_U(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int csyr2_thread_L(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int csyr2_thread_U(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int zsyr2_thread_L(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int zsyr2_thread_U(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int xsyr2_thread_L(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xsyr2_thread_U(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); + +int sspr_L(BLASLONG, float, float *, BLASLONG, float *, float *); +int sspr_U(BLASLONG, float, float *, BLASLONG, float *, float *); +int dspr_L(BLASLONG, double, double *, BLASLONG, double *, double *); +int dspr_U(BLASLONG, double, double *, BLASLONG, double *, double *); +int qspr_L(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, xdouble *); +int qspr_U(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, xdouble *); +int cspr_L(BLASLONG, float, float, float *, BLASLONG, float *, float *); +int cspr_U(BLASLONG, float, float, float *, BLASLONG, float *, float *); +int zspr_L(BLASLONG, double, double, double *, BLASLONG, double *, double *); +int zspr_U(BLASLONG, double, double, double *, BLASLONG, double *, double *); +int xspr_L(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, xdouble *); +int xspr_U(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, xdouble *); + +int sspr_thread_L(BLASLONG, float, float *, BLASLONG, float *, float *, int); +int sspr_thread_U(BLASLONG, float, float *, BLASLONG, float *, float *, int); +int dspr_thread_L(BLASLONG, double, double *, BLASLONG, double *, double *, int); +int dspr_thread_U(BLASLONG, double, double *, BLASLONG, double *, double *, int); +int qspr_thread_L(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, xdouble *, int); +int qspr_thread_U(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, xdouble *, int); +int cspr_thread_L(BLASLONG, float *, float *, BLASLONG, float *, float *, int); +int cspr_thread_U(BLASLONG, float *, float *, BLASLONG, float *, float *, int); +int zspr_thread_L(BLASLONG, double *, double *, BLASLONG, double *, double *, int); +int zspr_thread_U(BLASLONG, double *, double *, BLASLONG, double *, double *, int); +int xspr_thread_L(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, xdouble *, int); +int xspr_thread_U(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, xdouble *, int); + +int sspr2_L(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, float *); +int sspr2_U(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, float *); +int dspr2_L(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, double *); +int dspr2_U(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, double *); +int qspr2_L(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *); +int qspr2_U(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *); +int cspr2_L(BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, float *); +int cspr2_U(BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, float *); +int zspr2_L(BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, double *); +int zspr2_U(BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, double *); +int xspr2_L(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *); +int xspr2_U(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *); + +int sspr2_thread_L(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, float *, int); +int sspr2_thread_U(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, float *, int); +int dspr2_thread_L(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, double *, int); +int dspr2_thread_U(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, double *, int); +int qspr2_thread_L(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *, int); +int qspr2_thread_U(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *, int); +int cspr2_thread_L(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, float *, int); +int cspr2_thread_U(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, float *, int); +int zspr2_thread_L(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, double *, int); +int zspr2_thread_U(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, double *, int); +int xspr2_thread_L(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *, int); +int xspr2_thread_U(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *, int); + +int cher_L(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *); +int cher_U(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *); +int cher_V(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *); +int cher_M(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *); +int zher_L(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *); +int zher_U(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *); +int zher_V(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *); +int zher_M(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *); +int xher_L(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xher_U(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xher_V(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xher_M(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + +int cher_thread_L(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, int); +int cher_thread_U(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, int); +int cher_thread_V(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, int); +int cher_thread_M(BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, int); +int zher_thread_L(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, int); +int zher_thread_U(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, int); +int zher_thread_V(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, int); +int zher_thread_M(BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, int); +int xher_thread_L(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xher_thread_U(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xher_thread_V(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xher_thread_M(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); + +int cher2_L(BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int cher2_U(BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int cher2_M(BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int cher2_V(BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int zher2_L(BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int zher2_U(BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int zher2_M(BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int zher2_V(BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int xher2_L(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xher2_U(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xher2_M(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xher2_V(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + +int cher2_thread_L(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int cher2_thread_U(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int cher2_thread_M(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int cher2_thread_V(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int zher2_thread_L(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int zher2_thread_U(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int zher2_thread_M(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int zher2_thread_V(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int xher2_thread_L(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xher2_thread_U(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xher2_thread_M(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xher2_thread_V(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); + +int chpr_L(BLASLONG, float, float *, BLASLONG, float *, float *); +int chpr_U(BLASLONG, float, float *, BLASLONG, float *, float *); +int chpr_M(BLASLONG, float, float *, BLASLONG, float *, float *); +int chpr_V(BLASLONG, float, float *, BLASLONG, float *, float *); +int zhpr_L(BLASLONG, double, double *, BLASLONG, double *, double *); +int zhpr_U(BLASLONG, double, double *, BLASLONG, double *, double *); +int zhpr_M(BLASLONG, double, double *, BLASLONG, double *, double *); +int zhpr_V(BLASLONG, double, double *, BLASLONG, double *, double *); +int xhpr_L(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, xdouble *); +int xhpr_U(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, xdouble *); +int xhpr_M(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, xdouble *); +int xhpr_V(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, xdouble *); + +int chpr_thread_L(BLASLONG, float, float *, BLASLONG, float *, float *, int); +int chpr_thread_U(BLASLONG, float, float *, BLASLONG, float *, float *, int); +int chpr_thread_M(BLASLONG, float, float *, BLASLONG, float *, float *, int); +int chpr_thread_V(BLASLONG, float, float *, BLASLONG, float *, float *, int); +int zhpr_thread_L(BLASLONG, double, double *, BLASLONG, double *, double *, int); +int zhpr_thread_U(BLASLONG, double, double *, BLASLONG, double *, double *, int); +int zhpr_thread_M(BLASLONG, double, double *, BLASLONG, double *, double *, int); +int zhpr_thread_V(BLASLONG, double, double *, BLASLONG, double *, double *, int); +int xhpr_thread_L(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, xdouble *, int); +int xhpr_thread_U(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, xdouble *, int); +int xhpr_thread_M(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, xdouble *, int); +int xhpr_thread_V(BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, xdouble *, int); + +int chpr2_L(BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, float *); +int chpr2_U(BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, float *); +int chpr2_M(BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, float *); +int chpr2_V(BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, float *); +int zhpr2_L(BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, double *); +int zhpr2_U(BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, double *); +int zhpr2_M(BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, double *); +int zhpr2_V(BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, double *); +int xhpr2_L(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *); +int xhpr2_U(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *); +int xhpr2_M(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *); +int xhpr2_V(BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *); + +int chpr2_thread_L(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, float *, int); +int chpr2_thread_U(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, float *, int); +int chpr2_thread_M(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, float *, int); +int chpr2_thread_V(BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, float *, int); +int zhpr2_thread_L(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, double *, int); +int zhpr2_thread_U(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, double *, int); +int zhpr2_thread_M(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, double *, int); +int zhpr2_thread_V(BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, double *, int); +int xhpr2_thread_L(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *, int); +int xhpr2_thread_U(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *, int); +int xhpr2_thread_M(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *, int); +int xhpr2_thread_V(BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, xdouble *, int); + +int chemv_L(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int chemv_U(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int chemv_M(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int chemv_V(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); +int zhemv_L(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int zhemv_U(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int zhemv_M(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int zhemv_V(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); +int xhemv_L(BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xhemv_U(BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xhemv_M(BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); +int xhemv_V(BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + +int chpmv_L(BLASLONG, float, float, float *, float *, BLASLONG, float *, BLASLONG, void *); +int chpmv_U(BLASLONG, float, float, float *, float *, BLASLONG, float *, BLASLONG, void *); +int chpmv_M(BLASLONG, float, float, float *, float *, BLASLONG, float *, BLASLONG, void *); +int chpmv_V(BLASLONG, float, float, float *, float *, BLASLONG, float *, BLASLONG, void *); +int zhpmv_L(BLASLONG, double, double, double *, double *, BLASLONG, double *, BLASLONG, void *); +int zhpmv_U(BLASLONG, double, double, double *, double *, BLASLONG, double *, BLASLONG, void *); +int zhpmv_M(BLASLONG, double, double, double *, double *, BLASLONG, double *, BLASLONG, void *); +int zhpmv_V(BLASLONG, double, double, double *, double *, BLASLONG, double *, BLASLONG, void *); +int xhpmv_L(BLASLONG, xdouble, xdouble, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xhpmv_U(BLASLONG, xdouble, xdouble, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xhpmv_M(BLASLONG, xdouble, xdouble, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xhpmv_V(BLASLONG, xdouble, xdouble, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); + +int chpmv_thread_L(BLASLONG, float *, float *, float *, BLASLONG, float *, BLASLONG, float *, int); +int chpmv_thread_U(BLASLONG, float *, float *, float *, BLASLONG, float *, BLASLONG, float *, int); +int chpmv_thread_M(BLASLONG, float *, float *, float *, BLASLONG, float *, BLASLONG, float *, int); +int chpmv_thread_V(BLASLONG, float *, float *, float *, BLASLONG, float *, BLASLONG, float *, int); +int zhpmv_thread_L(BLASLONG, double *, double *, double *, BLASLONG, double *, BLASLONG, double *, int); +int zhpmv_thread_U(BLASLONG, double *, double *, double *, BLASLONG, double *, BLASLONG, double *, int); +int zhpmv_thread_M(BLASLONG, double *, double *, double *, BLASLONG, double *, BLASLONG, double *, int); +int zhpmv_thread_V(BLASLONG, double *, double *, double *, BLASLONG, double *, BLASLONG, double *, int); +int xhpmv_thread_L(BLASLONG, xdouble *, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xhpmv_thread_U(BLASLONG, xdouble *, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xhpmv_thread_M(BLASLONG, xdouble *, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xhpmv_thread_V(BLASLONG, xdouble *, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); + +int ssbmv_L(BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ssbmv_U(BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int dsbmv_L(BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dsbmv_U(BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int qsbmv_L(BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qsbmv_U(BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int csbmv_L(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int csbmv_U(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int zsbmv_L(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int zsbmv_U(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int xsbmv_L(BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xsbmv_U(BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); + +int chbmv_L(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int chbmv_U(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int chbmv_M(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int chbmv_V(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int zhbmv_L(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int zhbmv_U(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int zhbmv_M(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int zhbmv_V(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int xhbmv_L(BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xhbmv_U(BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xhbmv_M(BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xhbmv_V(BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); + + +int ssbmv_thread_L(BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ssbmv_thread_U(BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int dsbmv_thread_L(BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dsbmv_thread_U(BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int qsbmv_thread_L(BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qsbmv_thread_U(BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int csbmv_thread_L(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int csbmv_thread_U(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int zsbmv_thread_L(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int zsbmv_thread_U(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int xsbmv_thread_L(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xsbmv_thread_U(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); + +int chbmv_thread_L(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int chbmv_thread_U(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int chbmv_thread_M(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int chbmv_thread_V(BLASLONG, BLASLONG, float *, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int zhbmv_thread_L(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int zhbmv_thread_U(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int zhbmv_thread_M(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int zhbmv_thread_V(BLASLONG, BLASLONG, double *, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int xhbmv_thread_L(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xhbmv_thread_U(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xhbmv_thread_M(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xhbmv_thread_V(BLASLONG, BLASLONG, xdouble *, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); + +int snorm_n(BLASLONG, BLASLONG, float *a, BLASLONG); +int snorm_t(BLASLONG, BLASLONG, float *a, BLASLONG); +int dnorm_n(BLASLONG, BLASLONG, double *a, BLASLONG); +int dnorm_t(BLASLONG, BLASLONG, double *a, BLASLONG); +int cnorm_n(BLASLONG, BLASLONG, float *a, BLASLONG); +int cnorm_t(BLASLONG, BLASLONG, float *a, BLASLONG); +int znorm_n(BLASLONG, BLASLONG, double *a, BLASLONG); +int znorm_t(BLASLONG, BLASLONG, double *a, BLASLONG); + +void sgbmv_n(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *buffer); +void sgbmv_t(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *buffer); + +void dgbmv_n(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *buffer); +void dgbmv_t(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *buffer); + +void qgbmv_n(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *buffer); +void qgbmv_t(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *buffer); + +void cgbmv_n(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *buffer); +void cgbmv_t(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *buffer); +void cgbmv_r(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *buffer); +void cgbmv_c(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *buffer); +void cgbmv_o(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *buffer); +void cgbmv_u(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *buffer); +void cgbmv_s(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *buffer); +void cgbmv_d(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *buffer); + +void zgbmv_n(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *buffer); +void zgbmv_t(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *buffer); +void zgbmv_r(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *buffer); +void zgbmv_c(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *buffer); +void zgbmv_o(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *buffer); +void zgbmv_u(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *buffer); +void zgbmv_s(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *buffer); +void zgbmv_d(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *buffer); + +void xgbmv_n(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *buffer); +void xgbmv_t(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *buffer); +void xgbmv_r(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *buffer); +void xgbmv_c(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *buffer); +void xgbmv_o(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *buffer); +void xgbmv_u(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *buffer); +void xgbmv_s(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *buffer); +void xgbmv_d(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *buffer); + +int sgbmv_thread_n(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int sgbmv_thread_t(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); + +int dgbmv_thread_n(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int dgbmv_thread_t(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); + +int qgbmv_thread_n(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int qgbmv_thread_t(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); + +int cgbmv_thread_n(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float *, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int cgbmv_thread_t(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float *, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int cgbmv_thread_r(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float *, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int cgbmv_thread_c(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float *, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int cgbmv_thread_o(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float *, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int cgbmv_thread_u(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float *, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int cgbmv_thread_s(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float *, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); +int cgbmv_thread_d(BLASLONG, BLASLONG, BLASLONG, BLASLONG, float *, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *buffer, int); + +int zgbmv_thread_n(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double *, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int zgbmv_thread_t(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double *, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int zgbmv_thread_r(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double *, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int zgbmv_thread_c(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double *, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int zgbmv_thread_o(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double *, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int zgbmv_thread_u(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double *, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int zgbmv_thread_s(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double *, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); +int zgbmv_thread_d(BLASLONG, BLASLONG, BLASLONG, BLASLONG, double *, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *buffer, int); + +int xgbmv_thread_n(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble *, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int xgbmv_thread_t(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble *, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int xgbmv_thread_r(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble *, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int xgbmv_thread_c(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble *, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int xgbmv_thread_o(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble *, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int xgbmv_thread_u(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble *, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int xgbmv_thread_s(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble *, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); +int xgbmv_thread_d(BLASLONG, BLASLONG, BLASLONG, BLASLONG, xdouble *, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *buffer, int); + +int stbmv_NUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int stbmv_NUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int stbmv_NLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int stbmv_NLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int stbmv_TUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int stbmv_TUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int stbmv_TLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int stbmv_TLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); + +int dtbmv_NUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtbmv_NUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtbmv_NLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtbmv_NLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtbmv_TUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtbmv_TUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtbmv_TLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtbmv_TLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); + +int qtbmv_NUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtbmv_NUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtbmv_NLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtbmv_NLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtbmv_TUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtbmv_TUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtbmv_TLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtbmv_TLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); + +int ctbmv_NUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbmv_NUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbmv_NLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbmv_NLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbmv_TUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbmv_TUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbmv_TLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbmv_TLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbmv_RUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbmv_RUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbmv_RLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbmv_RLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbmv_CUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbmv_CUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbmv_CLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbmv_CLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); + +int ztbmv_NUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbmv_NUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbmv_NLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbmv_NLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbmv_TUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbmv_TUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbmv_TLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbmv_TLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbmv_RUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbmv_RUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbmv_RLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbmv_RLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbmv_CUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbmv_CUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbmv_CLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbmv_CLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); + +int xtbmv_NUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbmv_NUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbmv_NLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbmv_NLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbmv_TUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbmv_TUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbmv_TLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbmv_TLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbmv_RUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbmv_RUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbmv_RLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbmv_RLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbmv_CUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbmv_CUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbmv_CLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbmv_CLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); + +int stbmv_thread_NUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int stbmv_thread_NUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int stbmv_thread_NLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int stbmv_thread_NLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int stbmv_thread_TUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int stbmv_thread_TUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int stbmv_thread_TLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int stbmv_thread_TLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); + +int dtbmv_thread_NUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dtbmv_thread_NUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dtbmv_thread_NLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dtbmv_thread_NLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dtbmv_thread_TUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dtbmv_thread_TUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dtbmv_thread_TLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int dtbmv_thread_TLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); + +int qtbmv_thread_NUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qtbmv_thread_NUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qtbmv_thread_NLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qtbmv_thread_NLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qtbmv_thread_TUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qtbmv_thread_TUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qtbmv_thread_TLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int qtbmv_thread_TLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); + +int ctbmv_thread_NUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctbmv_thread_NUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctbmv_thread_NLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctbmv_thread_NLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctbmv_thread_TUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctbmv_thread_TUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctbmv_thread_TLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctbmv_thread_TLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctbmv_thread_RUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctbmv_thread_RUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctbmv_thread_RLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctbmv_thread_RLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctbmv_thread_CUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctbmv_thread_CUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctbmv_thread_CLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); +int ctbmv_thread_CLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *, int); + +int ztbmv_thread_NUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztbmv_thread_NUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztbmv_thread_NLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztbmv_thread_NLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztbmv_thread_TUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztbmv_thread_TUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztbmv_thread_TLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztbmv_thread_TLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztbmv_thread_RUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztbmv_thread_RUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztbmv_thread_RLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztbmv_thread_RLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztbmv_thread_CUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztbmv_thread_CUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztbmv_thread_CLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); +int ztbmv_thread_CLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *, int); + +int xtbmv_thread_NUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtbmv_thread_NUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtbmv_thread_NLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtbmv_thread_NLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtbmv_thread_TUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtbmv_thread_TUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtbmv_thread_TLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtbmv_thread_TLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtbmv_thread_RUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtbmv_thread_RUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtbmv_thread_RLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtbmv_thread_RLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtbmv_thread_CUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtbmv_thread_CUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtbmv_thread_CLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); +int xtbmv_thread_CLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, int); + +int stbsv_NUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int stbsv_NUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int stbsv_NLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int stbsv_NLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int stbsv_TUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int stbsv_TUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int stbsv_TLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int stbsv_TLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); + +int dtbsv_NUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtbsv_NUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtbsv_NLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtbsv_NLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtbsv_TUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtbsv_TUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtbsv_TLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int dtbsv_TLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); + +int qtbsv_NUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtbsv_NUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtbsv_NLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtbsv_NLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtbsv_TUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtbsv_TUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtbsv_TLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int qtbsv_TLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); + +int ctbsv_NUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbsv_NUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbsv_NLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbsv_NLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbsv_TUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbsv_TUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbsv_TLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbsv_TLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbsv_RUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbsv_RUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbsv_RLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbsv_RLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbsv_CUU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbsv_CUN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbsv_CLU(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); +int ctbsv_CLN(BLASLONG, BLASLONG, float *, BLASLONG, float *, BLASLONG, void *); + +int ztbsv_NUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbsv_NUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbsv_NLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbsv_NLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbsv_TUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbsv_TUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbsv_TLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbsv_TLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbsv_RUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbsv_RUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbsv_RLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbsv_RLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbsv_CUU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbsv_CUN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbsv_CLU(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); +int ztbsv_CLN(BLASLONG, BLASLONG, double *, BLASLONG, double *, BLASLONG, void *); + +int xtbsv_NUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbsv_NUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbsv_NLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbsv_NLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbsv_TUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbsv_TUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbsv_TLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbsv_TLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbsv_RUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbsv_RUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbsv_RLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbsv_RLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbsv_CUU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbsv_CUN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbsv_CLU(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); +int xtbsv_CLN(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, void *); + +#ifdef __CUDACC__ +} +#endif + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_level3.h b/src/NativeWrappers/GotoBlas2/include/common_level3.h new file mode 100644 index 00000000..cbc67a6c --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_level3.h @@ -0,0 +1,1739 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef ASSEMBLER + +#ifdef __CUDACC__ +__global__ void cuda_sgemm_kernel(int, int, int, float *, float *, float *); +__global__ void cuda_dgemm_kernel(int, int, int, double *, double *, double *); +#endif + +#ifdef __CUDACC__ +extern "C" { +#endif + +int sgemm_beta(BLASLONG, BLASLONG, BLASLONG, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); +int dgemm_beta(BLASLONG, BLASLONG, BLASLONG, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); +int cgemm_beta(BLASLONG, BLASLONG, BLASLONG, float, float, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); +int zgemm_beta(BLASLONG, BLASLONG, BLASLONG, double, double, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); + +#ifdef EXPRECISION +int qgemm_beta(BLASLONG, BLASLONG, BLASLONG, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); +int xgemm_beta(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); +#else +int qgemm_beta(BLASLONG, BLASLONG, BLASLONG, xdouble *, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); +int xgemm_beta(BLASLONG, BLASLONG, BLASLONG, xdouble *, + xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); +#endif + +int sgemm_incopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b); +int sgemm_itcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b); +int sgemm_oncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b); +int sgemm_otcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b); +int dgemm_incopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b); +int dgemm_itcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b); +int dgemm_oncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b); +int dgemm_otcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b); +int cgemm_incopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b); +int cgemm_itcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b); +int cgemm_oncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b); +int cgemm_otcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b); +int zgemm_incopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b); +int zgemm_itcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b); +int zgemm_oncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b); +int zgemm_otcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b); + +#ifdef QUAD_PRECISION +int qgemm_incopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xidouble *b); +int qgemm_itcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xidouble *b); +int qgemm_oncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xidouble *b); +int qgemm_otcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xidouble *b); +int xgemm_incopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xidouble *b); +int xgemm_itcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xidouble *b); +int xgemm_oncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xidouble *b); +int xgemm_otcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xidouble *b); +#else +int qgemm_incopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b); +int qgemm_itcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b); +int qgemm_oncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b); +int qgemm_otcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b); +int xgemm_incopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b); +int xgemm_itcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b); +int xgemm_oncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b); +int xgemm_otcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b); +#endif + + +int strsm_kernel_LN(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); +int strsm_kernel_LT(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); +int strsm_kernel_RN(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); +int strsm_kernel_RT(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); +int dtrsm_kernel_LN(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); +int dtrsm_kernel_LT(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); +int dtrsm_kernel_RN(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); +int dtrsm_kernel_RT(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); + +int qtrsm_kernel_LN(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int qtrsm_kernel_LT(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int qtrsm_kernel_RN(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int qtrsm_kernel_RT(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + +int ctrsm_kernel_LN(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); +int ctrsm_kernel_LT(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); +int ctrsm_kernel_LR(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); +int ctrsm_kernel_LC(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); +int ctrsm_kernel_RN(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); +int ctrsm_kernel_RT(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); +int ctrsm_kernel_RR(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); +int ctrsm_kernel_RC(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + +int ztrsm_kernel_LN(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); +int ztrsm_kernel_LT(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); +int ztrsm_kernel_LR(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); +int ztrsm_kernel_LC(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); +int ztrsm_kernel_RN(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); +int ztrsm_kernel_RT(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); +int ztrsm_kernel_RR(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); +int ztrsm_kernel_RC(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + +int xtrsm_kernel_LN(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int xtrsm_kernel_LT(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int xtrsm_kernel_LR(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int xtrsm_kernel_LC(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int xtrsm_kernel_RN(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int xtrsm_kernel_RT(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int xtrsm_kernel_RR(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int xtrsm_kernel_RC(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + +int strmm_kernel_RN(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); +int strmm_kernel_RT(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); +int strmm_kernel_LN(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); +int strmm_kernel_LT(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); + +int dtrmm_kernel_RN(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); +int dtrmm_kernel_RT(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); +int dtrmm_kernel_LN(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); +int dtrmm_kernel_LT(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); + +int qtrmm_kernel_RN(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int qtrmm_kernel_RT(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int qtrmm_kernel_LN(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int qtrmm_kernel_LT(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + +int ctrmm_kernel_RN(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); +int ctrmm_kernel_RT(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); +int ctrmm_kernel_RR(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); +int ctrmm_kernel_RC(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); +int ctrmm_kernel_LN(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); +int ctrmm_kernel_LT(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); +int ctrmm_kernel_LR(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); +int ctrmm_kernel_LC(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + +int ztrmm_kernel_RN(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); +int ztrmm_kernel_RT(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); +int ztrmm_kernel_RR(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); +int ztrmm_kernel_RC(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); +int ztrmm_kernel_LN(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); +int ztrmm_kernel_LT(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); +int ztrmm_kernel_LR(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); +int ztrmm_kernel_LC(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + +int xtrmm_kernel_RN(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int xtrmm_kernel_RT(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int xtrmm_kernel_RR(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int xtrmm_kernel_RC(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int xtrmm_kernel_LN(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int xtrmm_kernel_LT(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int xtrmm_kernel_LR(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); +int xtrmm_kernel_LC(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + +int strmm_iunucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int strmm_iunncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int strmm_iutucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int strmm_iutncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int strmm_ounucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int strmm_ounncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int strmm_outucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int strmm_outncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int strmm_ilnucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int strmm_ilnncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int strmm_iltucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int strmm_iltncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int strmm_olnucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int strmm_olnncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int strmm_oltucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int strmm_oltncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); + +int dtrmm_iunucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dtrmm_iunncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dtrmm_iutucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dtrmm_iutncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dtrmm_ounucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dtrmm_ounncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dtrmm_outucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dtrmm_outncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dtrmm_ilnucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dtrmm_ilnncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dtrmm_iltucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dtrmm_iltncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dtrmm_olnucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dtrmm_olnncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dtrmm_oltucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dtrmm_oltncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); + +int qtrmm_iunucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qtrmm_iunncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qtrmm_iutucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qtrmm_iutncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qtrmm_ounucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qtrmm_ounncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qtrmm_outucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qtrmm_outncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qtrmm_ilnucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qtrmm_ilnncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qtrmm_iltucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qtrmm_iltncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qtrmm_olnucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qtrmm_olnncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qtrmm_oltucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qtrmm_oltncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); + +int ctrmm_iunucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ctrmm_iunncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ctrmm_iutucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ctrmm_iutncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ctrmm_ounucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ctrmm_ounncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ctrmm_outucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ctrmm_outncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ctrmm_ilnucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ctrmm_ilnncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ctrmm_iltucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ctrmm_iltncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ctrmm_olnucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ctrmm_olnncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ctrmm_oltucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ctrmm_oltncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); + +int ztrmm_iunucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int ztrmm_iunncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int ztrmm_iutucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int ztrmm_iutncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int ztrmm_ounucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int ztrmm_ounncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int ztrmm_outucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int ztrmm_outncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int ztrmm_ilnucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int ztrmm_ilnncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int ztrmm_iltucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int ztrmm_iltncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int ztrmm_olnucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int ztrmm_olnncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int ztrmm_oltucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int ztrmm_oltncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); + +int xtrmm_iunucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xtrmm_iunncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xtrmm_iutucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xtrmm_iutncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xtrmm_ounucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xtrmm_ounncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xtrmm_outucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xtrmm_outncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xtrmm_ilnucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xtrmm_ilnncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xtrmm_iltucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xtrmm_iltncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xtrmm_olnucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xtrmm_olnncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xtrmm_oltucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xtrmm_oltncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); + +int strsm_iunucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int strsm_iunncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int strsm_iutucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int strsm_iutncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int strsm_ounucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int strsm_ounncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int strsm_outucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int strsm_outncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int strsm_ilnucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int strsm_ilnncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int strsm_iltucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int strsm_iltncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int strsm_olnucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int strsm_olnncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int strsm_oltucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int strsm_oltncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); + +int dtrsm_iunucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int dtrsm_iunncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int dtrsm_iutucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int dtrsm_iutncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int dtrsm_ounucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int dtrsm_ounncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int dtrsm_outucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int dtrsm_outncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int dtrsm_ilnucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int dtrsm_ilnncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int dtrsm_iltucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int dtrsm_iltncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int dtrsm_olnucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int dtrsm_olnncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int dtrsm_oltucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int dtrsm_oltncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); + +int qtrsm_iunucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int qtrsm_iunncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int qtrsm_iutucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int qtrsm_iutncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int qtrsm_ounucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int qtrsm_ounncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int qtrsm_outucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int qtrsm_outncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int qtrsm_ilnucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int qtrsm_ilnncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int qtrsm_iltucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int qtrsm_iltncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int qtrsm_olnucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int qtrsm_olnncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int qtrsm_oltucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int qtrsm_oltncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); + +int ctrsm_iunucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int ctrsm_iunncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int ctrsm_iutucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int ctrsm_iutncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int ctrsm_ounucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int ctrsm_ounncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int ctrsm_outucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int ctrsm_outncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int ctrsm_ilnucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int ctrsm_ilnncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int ctrsm_iltucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int ctrsm_iltncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int ctrsm_olnucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int ctrsm_olnncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int ctrsm_oltucopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); +int ctrsm_oltncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG offset, float *b); + +int ztrsm_iunucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int ztrsm_iunncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int ztrsm_iutucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int ztrsm_iutncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int ztrsm_ounucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int ztrsm_ounncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int ztrsm_outucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int ztrsm_outncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int ztrsm_ilnucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int ztrsm_ilnncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int ztrsm_iltucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int ztrsm_iltncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int ztrsm_olnucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int ztrsm_olnncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int ztrsm_oltucopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); +int ztrsm_oltncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG offset, double *b); + +int xtrsm_iunucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int xtrsm_iunncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int xtrsm_iutucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int xtrsm_iutncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int xtrsm_ounucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int xtrsm_ounncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int xtrsm_outucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int xtrsm_outncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int xtrsm_ilnucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int xtrsm_ilnncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int xtrsm_iltucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int xtrsm_iltncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int xtrsm_olnucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int xtrsm_olnncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int xtrsm_oltucopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); +int xtrsm_oltncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG offset, xdouble *b); + +int ssymm_iutcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ssymm_outcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ssymm_iltcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int ssymm_oltcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int dsymm_iutcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dsymm_outcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dsymm_iltcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int dsymm_oltcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int qsymm_iutcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qsymm_outcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qsymm_iltcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int qsymm_oltcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int csymm_iutcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int csymm_outcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int csymm_iltcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int csymm_oltcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int zsymm_iutcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int zsymm_outcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int zsymm_iltcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int zsymm_oltcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int xsymm_iutcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xsymm_outcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xsymm_iltcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xsymm_oltcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); + +int chemm_iutcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int chemm_outcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int chemm_iltcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int chemm_oltcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, float *b); +int zhemm_iutcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int zhemm_outcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int zhemm_iltcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int zhemm_oltcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, double *b); +int xhemm_iutcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xhemm_outcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xhemm_iltcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); +int xhemm_oltcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, xdouble *b); + +int ssyrk_kernel_U(BLASLONG m, BLASLONG n, BLASLONG k, float alpha, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset); +int ssyrk_kernel_L(BLASLONG m, BLASLONG n, BLASLONG k, float alpha, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset); + +int dsyrk_kernel_U(BLASLONG m, BLASLONG n, BLASLONG k, double alpha, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset); +int dsyrk_kernel_L(BLASLONG m, BLASLONG n, BLASLONG k, double alpha, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset); + +int qsyrk_kernel_U(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset); +int qsyrk_kernel_L(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset); + +int csyrk_kernel_U(BLASLONG m, BLASLONG n, BLASLONG k, float alpha_r, float alpha_i, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset); +int csyrk_kernel_L(BLASLONG m, BLASLONG n, BLASLONG k, float alpha_r, float alpha_i, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset); +int zsyrk_kernel_U(BLASLONG m, BLASLONG n, BLASLONG k, double alpha_r, double alpha_i, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset); +int zsyrk_kernel_L(BLASLONG m, BLASLONG n, BLASLONG k, double alpha_r, double alpha_i, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset); +int xsyrk_kernel_U(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha_r, xdouble alpha_i, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset); +int xsyrk_kernel_L(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha_r, xdouble alpha_i, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset); + +int ssyr2k_kernel_U(BLASLONG m, BLASLONG n, BLASLONG k, float alpha, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset, int flag); +int ssyr2k_kernel_L(BLASLONG m, BLASLONG n, BLASLONG k, float alpha, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset, int flag); +int dsyr2k_kernel_U(BLASLONG m, BLASLONG n, BLASLONG k, double alpha, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset, int flag); +int dsyr2k_kernel_L(BLASLONG m, BLASLONG n, BLASLONG k, double alpha, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset, int flag); +int qsyr2k_kernel_U(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset, int flag); +int qsyr2k_kernel_L(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset, int flag); + +int csyr2k_kernel_U(BLASLONG m, BLASLONG n, BLASLONG k, float alpha_r, float alpha_i, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset, int flag); +int csyr2k_kernel_L(BLASLONG m, BLASLONG n, BLASLONG k, float alpha_r, float alpha_i, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset, int flag); +int zsyr2k_kernel_U(BLASLONG m, BLASLONG n, BLASLONG k, double alpha_r, double alpha_i, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset, int flag); +int zsyr2k_kernel_L(BLASLONG m, BLASLONG n, BLASLONG k, double alpha_r, double alpha_i, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset, int flag); +int xsyr2k_kernel_U(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha_r, xdouble alpha_i, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset, int flag); +int xsyr2k_kernel_L(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha_r, xdouble alpha_i, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset, int flag); + +int cherk_kernel_UN(BLASLONG m, BLASLONG n, BLASLONG k, float alpha_r, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset); +int cherk_kernel_UC(BLASLONG m, BLASLONG n, BLASLONG k, float alpha_r, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset); +int cherk_kernel_LN(BLASLONG m, BLASLONG n, BLASLONG k, float alpha_r, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset); +int cherk_kernel_LC(BLASLONG m, BLASLONG n, BLASLONG k, float alpha_r, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset); + +int zherk_kernel_UN(BLASLONG m, BLASLONG n, BLASLONG k, double alpha_r, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset); +int zherk_kernel_UC(BLASLONG m, BLASLONG n, BLASLONG k, double alpha_r, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset); +int zherk_kernel_LN(BLASLONG m, BLASLONG n, BLASLONG k, double alpha_r, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset); +int zherk_kernel_LC(BLASLONG m, BLASLONG n, BLASLONG k, double alpha_r, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset); + +int xherk_kernel_UN(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha_r, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset); +int xherk_kernel_UC(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha_r, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset); +int xherk_kernel_LN(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha_r, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset); +int xherk_kernel_LC(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha_r, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset); + +int cher2k_kernel_UN(BLASLONG m, BLASLONG n, BLASLONG k, float alpha_r, float alpha_i, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset, int flag); +int cher2k_kernel_UC(BLASLONG m, BLASLONG n, BLASLONG k, float alpha_r, float alpha_i, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset, int flag); +int cher2k_kernel_LN(BLASLONG m, BLASLONG n, BLASLONG k, float alpha_r, float alpha_i, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset, int flag); +int cher2k_kernel_LC(BLASLONG m, BLASLONG n, BLASLONG k, float alpha_r, float alpha_i, float *a, float *b, float *c, BLASLONG ldc, BLASLONG offset, int flag); + +int zher2k_kernel_UN(BLASLONG m, BLASLONG n, BLASLONG k, double alpha_r, double alpha_i, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset, int flag); +int zher2k_kernel_UC(BLASLONG m, BLASLONG n, BLASLONG k, double alpha_r, double alpha_i, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset, int flag); +int zher2k_kernel_LN(BLASLONG m, BLASLONG n, BLASLONG k, double alpha_r, double alpha_i, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset, int flag); +int zher2k_kernel_LC(BLASLONG m, BLASLONG n, BLASLONG k, double alpha_r, double alpha_i, double *a, double *b, double *c, BLASLONG ldc, BLASLONG offset, int flag); + +int xher2k_kernel_UN(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha_r, xdouble alpha_i, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset, int flag); +int xher2k_kernel_UC(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha_r, xdouble alpha_i, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset, int flag); +int xher2k_kernel_LN(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha_r, xdouble alpha_i, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset, int flag); +int xher2k_kernel_LC(BLASLONG m, BLASLONG n, BLASLONG k, xdouble alpha_r, xdouble alpha_i, xdouble *a, xdouble *b, xdouble *c, BLASLONG ldc, BLASLONG offset, int flag); + +int sgemm_kernel(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG); +int dgemm_kernel(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG); + +#ifdef QUAD_PRECISION +int qgemm_kernel(BLASLONG, BLASLONG, BLASLONG, xidouble *, xidouble *, xidouble *, xdouble *, BLASLONG); +#else +int qgemm_kernel(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG); +#endif + +int cgemm_kernel_n(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG); +int cgemm_kernel_l(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG); +int cgemm_kernel_r(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG); +int cgemm_kernel_b(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG); + +int zgemm_kernel_n(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG); +int zgemm_kernel_l(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG); +int zgemm_kernel_r(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG); +int zgemm_kernel_b(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG); + +int xgemm_kernel_n(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG); +int xgemm_kernel_l(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG); +int xgemm_kernel_r(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG); +int xgemm_kernel_b(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG); + +int cgemm3m_kernel(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG); +int zgemm3m_kernel(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG); +int xgemm3m_kernel(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG); + +int sgemm_nn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int sgemm_nt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int sgemm_tn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int sgemm_tt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int dgemm_nn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dgemm_nt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dgemm_tn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dgemm_tt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +#ifdef QUAD_PRECISION +int qgemm_nn(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int qgemm_nt(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int qgemm_tn(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int qgemm_tt(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +#else +int qgemm_nn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qgemm_nt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qgemm_tn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qgemm_tt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +#endif + +int cgemm_nn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_nt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_nr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_nc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_tn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_tt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_tr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_tc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_rn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_rt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_rr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_rc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_cn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_ct(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_cr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_cc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zgemm_nn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_nt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_nr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_nc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_tn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_tt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_tr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_tc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_rn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_rt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_rr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_rc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_cn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_ct(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_cr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_cc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +#ifdef QUAD_PRECISION +int xgemm_nn(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int xgemm_nt(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int xgemm_nr(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int xgemm_nc(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int xgemm_tn(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int xgemm_tt(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int xgemm_tr(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int xgemm_tc(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int xgemm_rn(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int xgemm_rt(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int xgemm_rr(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int xgemm_rc(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int xgemm_cn(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int xgemm_ct(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int xgemm_cr(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int xgemm_cc(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +#else +int xgemm_nn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_nt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_nr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_nc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_tn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_tt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_tr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_tc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_rn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_rt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_rr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_rc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_cn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_ct(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_cr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_cc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +#endif + +int sgemm_thread_nn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int sgemm_thread_nt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int sgemm_thread_tn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int sgemm_thread_tt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int dgemm_thread_nn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dgemm_thread_nt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dgemm_thread_tn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dgemm_thread_tt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +#ifdef QUAD_PRECISION +int qgemm_thread_nn(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int qgemm_thread_nt(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int qgemm_thread_tn(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +int qgemm_thread_tt(blas_arg_t *, BLASLONG *, BLASLONG *, xidouble *, xidouble *, BLASLONG); +#else +int qgemm_thread_nn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qgemm_thread_nt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qgemm_thread_tn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qgemm_thread_tt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +#endif + +int cgemm_thread_nn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_thread_nt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_thread_nr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_thread_nc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_thread_tn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_thread_tt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_thread_tr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_thread_tc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_thread_rn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_thread_rt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_thread_rr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_thread_rc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_thread_cn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_thread_ct(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_thread_cr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm_thread_cc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zgemm_thread_nn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_thread_nt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_thread_nr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_thread_nc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_thread_tn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_thread_tt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_thread_tr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_thread_tc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_thread_rn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_thread_rt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_thread_rr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_thread_rc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_thread_cn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_thread_ct(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_thread_cr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm_thread_cc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xgemm_thread_nn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_thread_nt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_thread_nr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_thread_nc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_thread_tn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_thread_tt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_thread_tr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_thread_tc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_thread_rn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_thread_rt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_thread_rr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_thread_rc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_thread_cn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_thread_ct(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_thread_cr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm_thread_cc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int cgemm3m_nn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_nt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_nr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_nc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_tn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_tt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_tr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_tc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_rn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_rt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_rr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_rc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_cn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_ct(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_cr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_cc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int zgemm3m_nn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_nt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_nr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_nc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_tn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_tt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_tr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_tc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_rn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_rt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_rr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_rc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_cn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_ct(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_cr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_cc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int xgemm3m_nn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_nt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_nr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_nc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_tn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_tt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_tr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_tc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_rn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_rt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_rr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_rc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_cn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_ct(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_cr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_cc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int cgemm3m_thread_nn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_thread_nt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_thread_nr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_thread_nc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_thread_tn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_thread_tt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_thread_tr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_thread_tc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_thread_rn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_thread_rt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_thread_rr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_thread_rc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_thread_cn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_thread_ct(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_thread_cr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemm3m_thread_cc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zgemm3m_thread_nn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_thread_nt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_thread_nr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_thread_nc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_thread_tn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_thread_tt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_thread_tr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_thread_tc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_thread_rn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_thread_rt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_thread_rr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_thread_rc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_thread_cn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_thread_ct(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_thread_cr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemm3m_thread_cc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xgemm3m_thread_nn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_thread_nt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_thread_nr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_thread_nc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_thread_tn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_thread_tt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_thread_tr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_thread_tc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_thread_rn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_thread_rt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_thread_rr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_thread_rc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_thread_cn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_thread_ct(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_thread_cr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemm3m_thread_cc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int cher2m_LNN(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_LNT(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_LNR(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_LNC(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_LTN(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_LTT(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_LTR(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_LTC(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_LRN(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_LRT(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_LRR(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_LRC(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_LCN(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_LCT(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_LCR(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_LCC(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_UNN(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_UNT(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_UNR(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_UNC(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_UTN(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_UTT(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_UTR(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_UTC(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_URN(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_URT(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_URR(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_URC(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_UCN(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_UCT(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_UCR(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); +int cher2m_UCC(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, + float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, BLASLONG); + +int zher2m_LNN(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_LNT(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_LNR(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_LNC(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_LTN(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_LTT(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_LTR(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_LTC(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_LRN(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_LRT(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_LRR(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_LRC(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_LCN(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_LCT(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_LCR(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_LCC(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_UNN(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_UNT(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_UNR(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_UNC(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_UTN(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_UTT(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_UTR(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_UTC(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_URN(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_URT(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_URR(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_URC(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_UCN(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_UCT(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_UCR(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); +int zher2m_UCC(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, + double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, BLASLONG); + +int strsm_LNUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strsm_LNUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strsm_LNLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strsm_LNLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strsm_LTUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strsm_LTUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strsm_LTLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strsm_LTLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strsm_RNUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strsm_RNUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strsm_RNLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strsm_RNLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strsm_RTUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strsm_RTUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strsm_RTLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strsm_RTLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int dtrsm_LNUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrsm_LNUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrsm_LNLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrsm_LNLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrsm_LTUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrsm_LTUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrsm_LTLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrsm_LTLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrsm_RNUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrsm_RNUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrsm_RNLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrsm_RNLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrsm_RTUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrsm_RTUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrsm_RTLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrsm_RTLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int qtrsm_LNUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrsm_LNUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrsm_LNLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrsm_LNLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrsm_LTUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrsm_LTUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrsm_LTLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrsm_LTLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrsm_RNUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrsm_RNUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrsm_RNLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrsm_RNLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrsm_RTUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrsm_RTUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrsm_RTLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrsm_RTLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int ctrsm_LNUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_LNUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_LNLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_LNLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_LTUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_LTUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_LTLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_LTLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_LRUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_LRUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_LRLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_LRLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_LCUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_LCUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_LCLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_LCLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RNUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RNUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RNLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RNLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RTUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RTUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RTLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RTLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RRUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RRUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RRLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RRLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RCUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RCUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RCLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrsm_RCLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int ztrsm_LNUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_LNUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_LNLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_LNLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_LTUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_LTUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_LTLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_LTLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_LRUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_LRUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_LRLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_LRLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_LCUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_LCUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_LCLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_LCLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RNUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RNUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RNLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RNLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RTUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RTUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RTLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RTLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RRUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RRUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RRLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RRLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RCUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RCUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RCLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrsm_RCLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xtrsm_LNUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_LNUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_LNLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_LNLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_LTUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_LTUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_LTLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_LTLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_LRUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_LRUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_LRLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_LRLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_LCUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_LCUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_LCLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_LCLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RNUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RNUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RNLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RNLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RTUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RTUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RTLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RTLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RRUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RRUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RRLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RRLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RCUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RCUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RCLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrsm_RCLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int strmm_LNUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strmm_LNUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strmm_LNLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strmm_LNLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strmm_LTUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strmm_LTUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strmm_LTLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strmm_LTLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strmm_RNUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strmm_RNUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strmm_RNLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strmm_RNLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strmm_RTUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strmm_RTUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strmm_RTLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int strmm_RTLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int dtrmm_LNUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrmm_LNUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrmm_LNLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrmm_LNLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrmm_LTUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrmm_LTUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrmm_LTLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrmm_LTLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrmm_RNUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrmm_RNUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrmm_RNLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrmm_RNLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrmm_RTUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrmm_RTUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrmm_RTLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dtrmm_RTLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int qtrmm_LNUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrmm_LNUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrmm_LNLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrmm_LNLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrmm_LTUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrmm_LTUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrmm_LTLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrmm_LTLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrmm_RNUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrmm_RNUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrmm_RNLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrmm_RNLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrmm_RTUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrmm_RTUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrmm_RTLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qtrmm_RTLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int ctrmm_LNUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_LNUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_LNLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_LNLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_LTUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_LTUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_LTLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_LTLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_LRUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_LRUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_LRLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_LRLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_LCUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_LCUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_LCLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_LCLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RNUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RNUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RNLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RNLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RTUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RTUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RTLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RTLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RRUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RRUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RRLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RRLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RCUU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RCUN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RCLU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ctrmm_RCLN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int ztrmm_LNUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_LNUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_LNLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_LNLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_LTUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_LTUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_LTLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_LTLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_LRUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_LRUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_LRLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_LRLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_LCUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_LCUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_LCLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_LCLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RNUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RNUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RNLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RNLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RTUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RTUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RTLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RTLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RRUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RRUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RRLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RRLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RCUU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RCUN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RCLU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int ztrmm_RCLN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xtrmm_LNUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_LNUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_LNLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_LNLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_LTUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_LTUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_LTLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_LTLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_LRUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_LRUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_LRLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_LRLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_LCUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_LCUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_LCLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_LCLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RNUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RNUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RNLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RNLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RTUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RTUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RTLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RTLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RRUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RRUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RRLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RRLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RCUU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RCUN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RCLU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xtrmm_RCLN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int ssymm_LU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ssymm_LL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ssymm_RU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ssymm_RL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int dsymm_LU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dsymm_LL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dsymm_RU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dsymm_RL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int qsymm_LU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qsymm_LL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qsymm_RU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qsymm_RL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int csymm_LU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csymm_LL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csymm_RU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csymm_RL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zsymm_LU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsymm_LL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsymm_RU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsymm_RL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xsymm_LU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsymm_LL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsymm_RU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsymm_RL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int csymm3m_LU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csymm3m_LL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csymm3m_RU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csymm3m_RL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zsymm3m_LU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsymm3m_LL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsymm3m_RU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsymm3m_RL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xsymm3m_LU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsymm3m_LL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsymm3m_RU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsymm3m_RL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int csymm3m_thread_LU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csymm3m_thread_LL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csymm3m_thread_RU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csymm3m_thread_RL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zsymm3m_thread_LU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsymm3m_thread_LL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsymm3m_thread_RU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsymm3m_thread_RL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xsymm3m_thread_LU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsymm3m_thread_LL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsymm3m_thread_RU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsymm3m_thread_RL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int chemm_LU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int chemm_LL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int chemm_RU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int chemm_RL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zhemm_LU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zhemm_LL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zhemm_RU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zhemm_RL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xhemm_LU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xhemm_LL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xhemm_RU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xhemm_RL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int chemm3m_LU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int chemm3m_LL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int chemm3m_RU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int chemm3m_RL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zhemm3m_LU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zhemm3m_LL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zhemm3m_RU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zhemm3m_RL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xhemm3m_LU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xhemm3m_LL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xhemm3m_RU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xhemm3m_RL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int chemm3m_thread_LU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int chemm3m_thread_LL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int chemm3m_thread_RU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int chemm3m_thread_RL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zhemm3m_thread_LU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zhemm3m_thread_LL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zhemm3m_thread_RU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zhemm3m_thread_RL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xhemm3m_thread_LU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xhemm3m_thread_LL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xhemm3m_thread_RU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xhemm3m_thread_RL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int ssymm_thread_LU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ssymm_thread_LL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ssymm_thread_RU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ssymm_thread_RL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int dsymm_thread_LU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dsymm_thread_LL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dsymm_thread_RU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dsymm_thread_RL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int qsymm_thread_LU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qsymm_thread_LL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qsymm_thread_RU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qsymm_thread_RL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int csymm_thread_LU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csymm_thread_LL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csymm_thread_RU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csymm_thread_RL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zsymm_thread_LU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsymm_thread_LL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsymm_thread_RU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsymm_thread_RL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xsymm_thread_LU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsymm_thread_LL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsymm_thread_RU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsymm_thread_RL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int chemm_thread_LU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int chemm_thread_LL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int chemm_thread_RU(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int chemm_thread_RL(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zhemm_thread_LU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zhemm_thread_LL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zhemm_thread_RU(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zhemm_thread_RL(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xhemm_thread_LU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xhemm_thread_LL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xhemm_thread_RU(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xhemm_thread_RL(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int ssyrk_UN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ssyrk_UT(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ssyrk_LN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ssyrk_LT(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int dsyrk_UN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dsyrk_UT(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dsyrk_LN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dsyrk_LT(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int qsyrk_UN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qsyrk_UT(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qsyrk_LN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qsyrk_LT(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int csyrk_UN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csyrk_UT(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csyrk_LN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csyrk_LT(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zsyrk_UN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsyrk_UT(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsyrk_LN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsyrk_LT(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xsyrk_UN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsyrk_UT(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsyrk_LN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsyrk_LT(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int ssyrk_thread_UN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ssyrk_thread_UT(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ssyrk_thread_LN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ssyrk_thread_LT(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int dsyrk_thread_UN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dsyrk_thread_UT(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dsyrk_thread_LN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dsyrk_thread_LT(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int qsyrk_thread_UN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qsyrk_thread_UT(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qsyrk_thread_LN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qsyrk_thread_LT(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int csyrk_thread_UN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csyrk_thread_UT(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csyrk_thread_LN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csyrk_thread_LT(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zsyrk_thread_UN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsyrk_thread_UT(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsyrk_thread_LN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsyrk_thread_LT(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xsyrk_thread_UN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsyrk_thread_UT(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsyrk_thread_LN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsyrk_thread_LT(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int ssyr2k_UN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ssyr2k_UT(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ssyr2k_LN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int ssyr2k_LT(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int dsyr2k_UN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dsyr2k_UT(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dsyr2k_LN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dsyr2k_LT(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int qsyr2k_UN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qsyr2k_UT(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qsyr2k_LN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qsyr2k_LT(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int csyr2k_UN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csyr2k_UT(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csyr2k_LN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int csyr2k_LT(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zsyr2k_UN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsyr2k_UT(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsyr2k_LN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zsyr2k_LT(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xsyr2k_UN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsyr2k_UT(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsyr2k_LN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xsyr2k_LT(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int cherk_UN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cherk_UC(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cherk_LN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cherk_LC(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zherk_UN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zherk_UC(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zherk_LN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zherk_LC(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xherk_UN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xherk_UC(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xherk_LN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xherk_LC(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int cherk_thread_UN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cherk_thread_UC(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cherk_thread_LN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cherk_thread_LC(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zherk_thread_UN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zherk_thread_UC(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zherk_thread_LN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zherk_thread_LC(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xherk_thread_UN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xherk_thread_UC(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xherk_thread_LN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xherk_thread_LC(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int cher2k_UN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cher2k_UC(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cher2k_LN(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cher2k_LC(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zher2k_UN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zher2k_UC(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zher2k_LN(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zher2k_LC(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xher2k_UN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xher2k_UC(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xher2k_LN(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xher2k_LC(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int sgemt_n(BLASLONG, BLASLONG, float, float *, BLASLONG, float *, int); +int sgemt_t(BLASLONG, BLASLONG, float, float *, BLASLONG, float *, int); +int dgemt_n(BLASLONG, BLASLONG, double, double *, BLASLONG, double *, int); +int dgemt_t(BLASLONG, BLASLONG, double, double *, BLASLONG, double *, int); + +int cgemt_n(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, int); +int cgemt_t(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, int); +int cgemt_r(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, int); +int cgemt_c(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, int); +int zgemt_n(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, int); +int zgemt_t(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, int); +int zgemt_r(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, int); +int zgemt_c(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, int); + +int sgema_n(BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG); +int sgema_t(BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG); +int dgema_n(BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG); +int dgema_t(BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG); + +int cgema_n(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG); +int cgema_t(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG); +int cgema_r(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG); +int cgema_c(BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG); +int zgema_n(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG); +int zgema_t(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG); +int zgema_r(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG); +int zgema_c(BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG); + +int cgemm3m_incopyb(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b); +int cgemm3m_incopyr(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b); +int cgemm3m_incopyi(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b); +int cgemm3m_itcopyb(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b); +int cgemm3m_itcopyr(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b); +int cgemm3m_itcopyi(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b); + +int cgemm3m_oncopyb(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float alpha_r, float alpha_i, float *b); +int cgemm3m_oncopyr(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float alpha_r, float alpha_i, float *b); +int cgemm3m_oncopyi(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float alpha_r, float alpha_i, float *b); +int cgemm3m_otcopyb(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float alpha_r, float alpha_i, float *b); +int cgemm3m_otcopyr(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float alpha_r, float alpha_i, float *b); +int cgemm3m_otcopyi(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float alpha_r, float alpha_i, float *b); + +int zgemm3m_incopyb(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b); +int zgemm3m_incopyr(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b); +int zgemm3m_incopyi(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b); +int zgemm3m_itcopyb(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b); +int zgemm3m_itcopyr(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b); +int zgemm3m_itcopyi(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b); + +int zgemm3m_oncopyb(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double alpha_r, double alpha_i, double *b); +int zgemm3m_oncopyr(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double alpha_r, double alpha_i, double *b); +int zgemm3m_oncopyi(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double alpha_r, double alpha_i, double *b); +int zgemm3m_otcopyb(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double alpha_r, double alpha_i, double *b); +int zgemm3m_otcopyr(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double alpha_r, double alpha_i, double *b); +int zgemm3m_otcopyi(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double alpha_r, double alpha_i, double *b); + +int xgemm3m_incopyb(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b); +int xgemm3m_incopyr(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b); +int xgemm3m_incopyi(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b); +int xgemm3m_itcopyb(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b); +int xgemm3m_itcopyr(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b); +int xgemm3m_itcopyi(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b); + +int xgemm3m_oncopyb(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble alpha_r, xdouble alpha_i, xdouble *b); +int xgemm3m_oncopyr(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble alpha_r, xdouble alpha_i, xdouble *b); +int xgemm3m_oncopyi(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble alpha_r, xdouble alpha_i, xdouble *b); +int xgemm3m_otcopyb(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble alpha_r, xdouble alpha_i, xdouble *b); +int xgemm3m_otcopyr(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble alpha_r, xdouble alpha_i, xdouble *b); +int xgemm3m_otcopyi(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble alpha_r, xdouble alpha_i, xdouble *b); + +int csymm3m_iucopyb(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float *b); +int csymm3m_ilcopyb(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float *b); +int csymm3m_iucopyr(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float *b); +int csymm3m_ilcopyr(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float *b); +int csymm3m_iucopyi(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float *b); +int csymm3m_ilcopyi(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float *b); + +int csymm3m_oucopyb(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float alpha_r, float alpha_i, float *b); +int csymm3m_olcopyb(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float alpha_r, float alpha_i, float *b); +int csymm3m_oucopyr(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float alpha_r, float alpha_i, float *b); +int csymm3m_olcopyr(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float alpha_r, float alpha_i, float *b); +int csymm3m_oucopyi(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float alpha_r, float alpha_i, float *b); +int csymm3m_olcopyi(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float alpha_r, float alpha_i, float *b); + +int zsymm3m_iucopyb(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double *b); +int zsymm3m_ilcopyb(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double *b); +int zsymm3m_iucopyr(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double *b); +int zsymm3m_ilcopyr(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double *b); +int zsymm3m_iucopyi(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double *b); +int zsymm3m_ilcopyi(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double *b); + +int zsymm3m_oucopyb(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double alpha_r, double alpha_i, double *b); +int zsymm3m_olcopyb(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double alpha_r, double alpha_i, double *b); +int zsymm3m_oucopyr(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double alpha_r, double alpha_i, double *b); +int zsymm3m_olcopyr(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double alpha_r, double alpha_i, double *b); +int zsymm3m_oucopyi(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double alpha_r, double alpha_i, double *b); +int zsymm3m_olcopyi(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double alpha_r, double alpha_i, double *b); + +int xsymm3m_iucopyb(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble *b); +int xsymm3m_ilcopyb(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble *b); +int xsymm3m_iucopyr(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble *b); +int xsymm3m_ilcopyr(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble *b); +int xsymm3m_iucopyi(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble *b); +int xsymm3m_ilcopyi(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble *b); + +int xsymm3m_oucopyb(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble alpha_r, xdouble alpha_i, xdouble *b); +int xsymm3m_olcopyb(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble alpha_r, xdouble alpha_i, xdouble *b); +int xsymm3m_oucopyr(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble alpha_r, xdouble alpha_i, xdouble *b); +int xsymm3m_olcopyr(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble alpha_r, xdouble alpha_i, xdouble *b); +int xsymm3m_oucopyi(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble alpha_r, xdouble alpha_i, xdouble *b); +int xsymm3m_olcopyi(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble alpha_r, xdouble alpha_i, xdouble *b); + +int chemm3m_iucopyb(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float *b); +int chemm3m_ilcopyb(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float *b); +int chemm3m_iucopyr(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float *b); +int chemm3m_ilcopyr(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float *b); +int chemm3m_iucopyi(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float *b); +int chemm3m_ilcopyi(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float *b); + +int chemm3m_oucopyb(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float alpha_r, float alpha_i, float *b); +int chemm3m_olcopyb(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float alpha_r, float alpha_i, float *b); +int chemm3m_oucopyr(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float alpha_r, float alpha_i, float *b); +int chemm3m_olcopyr(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float alpha_r, float alpha_i, float *b); +int chemm3m_oucopyi(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float alpha_r, float alpha_i, float *b); +int chemm3m_olcopyi(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, BLASLONG x, BLASLONG y, float alpha_r, float alpha_i, float *b); + +int zhemm3m_iucopyb(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double *b); +int zhemm3m_ilcopyb(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double *b); +int zhemm3m_iucopyr(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double *b); +int zhemm3m_ilcopyr(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double *b); +int zhemm3m_iucopyi(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double *b); +int zhemm3m_ilcopyi(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double *b); + +int zhemm3m_oucopyb(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double alpha_r, double alpha_i, double *b); +int zhemm3m_olcopyb(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double alpha_r, double alpha_i, double *b); +int zhemm3m_oucopyr(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double alpha_r, double alpha_i, double *b); +int zhemm3m_olcopyr(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double alpha_r, double alpha_i, double *b); +int zhemm3m_oucopyi(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double alpha_r, double alpha_i, double *b); +int zhemm3m_olcopyi(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, BLASLONG x, BLASLONG y, double alpha_r, double alpha_i, double *b); + +int xhemm3m_iucopyb(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble *b); +int xhemm3m_ilcopyb(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble *b); +int xhemm3m_iucopyr(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble *b); +int xhemm3m_ilcopyr(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble *b); +int xhemm3m_iucopyi(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble *b); +int xhemm3m_ilcopyi(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble *b); + +int xhemm3m_oucopyb(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble alpha_r, xdouble alpha_i, xdouble *b); +int xhemm3m_olcopyb(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble alpha_r, xdouble alpha_i, xdouble *b); +int xhemm3m_oucopyr(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble alpha_r, xdouble alpha_i, xdouble *b); +int xhemm3m_olcopyr(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble alpha_r, xdouble alpha_i, xdouble *b); +int xhemm3m_oucopyi(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble alpha_r, xdouble alpha_i, xdouble *b); +int xhemm3m_olcopyi(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, BLASLONG x, BLASLONG y, xdouble alpha_r, xdouble alpha_i, xdouble *b); + +int sgemc_nn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int sgemc_nt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int sgemc_tn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int sgemc_tt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int dgemc_nn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dgemc_nt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dgemc_tn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int dgemc_tt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int qgemc_nn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qgemc_nt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qgemc_tn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int qgemc_tt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int cgemc_nn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemc_nt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemc_nr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemc_nc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemc_tn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemc_tt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemc_tr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemc_tc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemc_rn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemc_rt(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemc_rr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemc_rc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemc_cn(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemc_ct(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemc_cr(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); +int cgemc_cc(blas_arg_t *, BLASLONG *, BLASLONG *, float *, float *, BLASLONG); + +int zgemc_nn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemc_nt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemc_nr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemc_nc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemc_tn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemc_tt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemc_tr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemc_tc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemc_rn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemc_rt(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemc_rr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemc_rc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemc_cn(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemc_ct(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemc_cr(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); +int zgemc_cc(blas_arg_t *, BLASLONG *, BLASLONG *, double *, double *, BLASLONG); + +int xgemc_nn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemc_nt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemc_nr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemc_nc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemc_tn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemc_tt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemc_tr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemc_tc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemc_rn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemc_rt(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemc_rr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemc_rc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemc_cn(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemc_ct(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemc_cr(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); +int xgemc_cc(blas_arg_t *, BLASLONG *, BLASLONG *, xdouble *, xdouble *, BLASLONG); + +int sgemc_oncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b, BLASLONG ldb, float *c); +int sgemc_otcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b, BLASLONG ldb, float *c); +int dgemc_oncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b, BLASLONG ldb, double *c); +int dgemc_otcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b, BLASLONG ldb, double *c); +int qgemc_oncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b, BLASLONG ldb, xdouble *c); +int qgemc_otcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b, BLASLONG ldb, xdouble *c); +int cgemc_oncopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b, BLASLONG ldb, float *c); +int cgemc_otcopy(BLASLONG m, BLASLONG n, float *a, BLASLONG lda, float *b, BLASLONG ldb, float *c); +int zgemc_oncopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b, BLASLONG ldb, double *c); +int zgemc_otcopy(BLASLONG m, BLASLONG n, double *a, BLASLONG lda, double *b, BLASLONG ldb, double *c); +int xgemc_oncopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b, BLASLONG ldb, xdouble *c); +int xgemc_otcopy(BLASLONG m, BLASLONG n, xdouble *a, BLASLONG lda, xdouble *b, BLASLONG ldb, xdouble *c); + +#ifdef __CUDACC__ +} +#endif + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_linux.h b/src/NativeWrappers/GotoBlas2/include/common_linux.h new file mode 100644 index 00000000..d18cd2b7 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_linux.h @@ -0,0 +1,83 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef COMMON_LINUX_H +#define COMMON_LINUX_H + +#ifndef ASSEMBLER + +#include + +extern long int syscall (long int __sysno, ...); + +#ifndef MPOL_PREFERRED +#define MPOL_PREFERRED 1 +#endif + +#ifndef MPOL_INTERLEAVE +#define MPOL_INTERLEAVE 3 +#endif + +#if defined(ARCH_IA64) && defined(__ECC) +#ifndef __NR_mbind +#define __NR_mbind 1259 +#endif +#ifndef __NR_get_mempolicy +#define __NR_get_mempolicy 1260 +#endif +#ifndef __NR_set_mempolicy +#define __NR_set_mempolicy 1261 +#endif +#endif + +static inline int my_mbind(void *addr, unsigned long len, int mode, + unsigned long *nodemask, unsigned long maxnode, + unsigned flags) { + + return syscall(SYS_mbind, addr, len, mode, nodemask, maxnode, flags); +} + +static inline int my_set_mempolicy(int mode, const unsigned long *addr, unsigned long flag) { + + return syscall(SYS_set_mempolicy, mode, addr, flag); +} + +static inline int my_gettid(void) { return syscall(SYS_gettid); } + +#endif +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_macro.h b/src/NativeWrappers/GotoBlas2/include/common_macro.h new file mode 100644 index 00000000..bcaa9f38 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_macro.h @@ -0,0 +1,2734 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef COMMON_MACRO +#define COMMON_MACRO + +#include "common_s.h" +#include "common_d.h" +#include "common_q.h" + +#include "common_c.h" +#include "common_z.h" +#include "common_x.h" + +#ifndef COMPLEX +#ifdef XDOUBLE + +#define AMAX_K QAMAX_K +#define AMIN_K QAMIN_K +#define MAX_K QMAX_K +#define MIN_K QMIN_K +#define IAMAX_K IQAMAX_K +#define IAMIN_K IQAMIN_K +#define IMAX_K IQMAX_K +#define IMIN_K IQMIN_K +#define ASUM_K QASUM_K +#define AXPYU_K QAXPYU_K +#define AXPYC_K QAXPYC_K +#define COPY_K QCOPY_K +#define DOTU_K QDOTU_K +#define DOTC_K QDOTC_K +#define NRM2_K QNRM2_K +#define SCAL_K QSCAL_K +#define SWAP_K QSWAP_K +#define ROT_K QROT_K + +#define GEMV_N QGEMV_N +#define GEMV_T QGEMV_T +#define GEMV_R QGEMV_R +#define GEMV_C QGEMV_C +#define GEMV_O QGEMV_O +#define GEMV_U QGEMV_U +#define GEMV_S QGEMV_S +#define GEMV_D QGEMV_D + +#define GERU_K QGERU_K +#define GERC_K QGERC_K +#define GERV_K QGERV_K +#define GERD_K QGERD_K + +#define SYMV_U QSYMV_U +#define SYMV_L QSYMV_L + +#define SYMV_THREAD_U QSYMV_THREAD_U +#define SYMV_THREAD_L QSYMV_THREAD_L + +#define GEMM_ONCOPY QGEMM_ONCOPY +#define GEMM_OTCOPY QGEMM_OTCOPY +#define GEMM_INCOPY QGEMM_INCOPY +#define GEMM_ITCOPY QGEMM_ITCOPY + +#ifdef UNIT + +#define TRMM_OUNCOPY QTRMM_OUNUCOPY +#define TRMM_OUTCOPY QTRMM_OUTUCOPY +#define TRMM_OLNCOPY QTRMM_OLNUCOPY +#define TRMM_OLTCOPY QTRMM_OLTUCOPY +#define TRSM_OUNCOPY QTRSM_OUNUCOPY +#define TRSM_OUTCOPY QTRSM_OUTUCOPY +#define TRSM_OLNCOPY QTRSM_OLNUCOPY +#define TRSM_OLTCOPY QTRSM_OLTUCOPY + +#define TRMM_IUNCOPY QTRMM_IUNUCOPY +#define TRMM_IUTCOPY QTRMM_IUTUCOPY +#define TRMM_ILNCOPY QTRMM_ILNUCOPY +#define TRMM_ILTCOPY QTRMM_ILTUCOPY +#define TRSM_IUNCOPY QTRSM_IUNUCOPY +#define TRSM_IUTCOPY QTRSM_IUTUCOPY +#define TRSM_ILNCOPY QTRSM_ILNUCOPY +#define TRSM_ILTCOPY QTRSM_ILTUCOPY + +#else + +#define TRMM_OUNCOPY QTRMM_OUNNCOPY +#define TRMM_OUTCOPY QTRMM_OUTNCOPY +#define TRMM_OLNCOPY QTRMM_OLNNCOPY +#define TRMM_OLTCOPY QTRMM_OLTNCOPY +#define TRSM_OUNCOPY QTRSM_OUNNCOPY +#define TRSM_OUTCOPY QTRSM_OUTNCOPY +#define TRSM_OLNCOPY QTRSM_OLNNCOPY +#define TRSM_OLTCOPY QTRSM_OLTNCOPY + +#define TRMM_IUNCOPY QTRMM_IUNNCOPY +#define TRMM_IUTCOPY QTRMM_IUTNCOPY +#define TRMM_ILNCOPY QTRMM_ILNNCOPY +#define TRMM_ILTCOPY QTRMM_ILTNCOPY +#define TRSM_IUNCOPY QTRSM_IUNNCOPY +#define TRSM_IUTCOPY QTRSM_IUTNCOPY +#define TRSM_ILNCOPY QTRSM_ILNNCOPY +#define TRSM_ILTCOPY QTRSM_ILTNCOPY + +#endif + +#define GEMM_BETA QGEMM_BETA + +#define GEMM_KERNEL_N QGEMM_KERNEL +#define GEMM_KERNEL_L QGEMM_KERNEL +#define GEMM_KERNEL_R QGEMM_KERNEL +#define GEMM_KERNEL_B QGEMM_KERNEL + +#define TRMM_KERNEL_LN QTRMM_KERNEL_LN +#define TRMM_KERNEL_LT QTRMM_KERNEL_LT +#define TRMM_KERNEL_LR QTRMM_KERNEL_LN +#define TRMM_KERNEL_LC QTRMM_KERNEL_LT +#define TRMM_KERNEL_RN QTRMM_KERNEL_RN +#define TRMM_KERNEL_RT QTRMM_KERNEL_RT +#define TRMM_KERNEL_RR QTRMM_KERNEL_RN +#define TRMM_KERNEL_RC QTRMM_KERNEL_RT + +#define TRSM_KERNEL_LN QTRSM_KERNEL_LN +#define TRSM_KERNEL_LT QTRSM_KERNEL_LT +#define TRSM_KERNEL_LR QTRSM_KERNEL_LN +#define TRSM_KERNEL_LC QTRSM_KERNEL_LT +#define TRSM_KERNEL_RN QTRSM_KERNEL_RN +#define TRSM_KERNEL_RT QTRSM_KERNEL_RT +#define TRSM_KERNEL_RR QTRSM_KERNEL_RN +#define TRSM_KERNEL_RC QTRSM_KERNEL_RT + +#define SYMM_IUTCOPY QSYMM_IUTCOPY +#define SYMM_ILTCOPY QSYMM_ILTCOPY +#define SYMM_OUTCOPY QSYMM_OUTCOPY +#define SYMM_OLTCOPY QSYMM_OLTCOPY + +#define GEMM_NN QGEMM_NN +#define GEMM_CN QGEMM_TN +#define GEMM_TN QGEMM_TN +#define GEMM_NC QGEMM_NT +#define GEMM_NT QGEMM_NT +#define GEMM_CC QGEMM_TT +#define GEMM_CT QGEMM_TT +#define GEMM_TC QGEMM_TT +#define GEMM_TT QGEMM_TT +#define GEMM_NR QGEMM_NN +#define GEMM_TR QGEMM_TN +#define GEMM_CR QGEMM_TN +#define GEMM_RN QGEMM_NN +#define GEMM_RT QGEMM_NT +#define GEMM_RC QGEMM_NT +#define GEMM_RR QGEMM_NN + +#define SYMM_LU QSYMM_LU +#define SYMM_LL QSYMM_LL +#define SYMM_RU QSYMM_RU +#define SYMM_RL QSYMM_RL + +#define HEMM_LU QHEMM_LU +#define HEMM_LL QHEMM_LL +#define HEMM_RU QHEMM_RU +#define HEMM_RL QHEMM_RL + +#define SYRK_UN QSYRK_UN +#define SYRK_UT QSYRK_UT +#define SYRK_LN QSYRK_LN +#define SYRK_LT QSYRK_LT +#define SYRK_UR QSYRK_UN +#define SYRK_UC QSYRK_UT +#define SYRK_LR QSYRK_LN +#define SYRK_LC QSYRK_LT + +#define SYRK_KERNEL_U QSYRK_KERNEL_U +#define SYRK_KERNEL_L QSYRK_KERNEL_L + +#define HERK_UN QSYRK_UN +#define HERK_LN QSYRK_LN +#define HERK_UC QSYRK_UT +#define HERK_LC QSYRK_LT + +#define HER2K_UN QSYR2K_UN +#define HER2K_LN QSYR2K_LN +#define HER2K_UC QSYR2K_UT +#define HER2K_LC QSYR2K_LT + +#define SYR2K_UN QSYR2K_UN +#define SYR2K_UT QSYR2K_UT +#define SYR2K_LN QSYR2K_LN +#define SYR2K_LT QSYR2K_LT +#define SYR2K_UR QSYR2K_UN +#define SYR2K_UC QSYR2K_UT +#define SYR2K_LR QSYR2K_LN +#define SYR2K_LC QSYR2K_LT + +#define SYR2K_KERNEL_U QSYR2K_KERNEL_U +#define SYR2K_KERNEL_L QSYR2K_KERNEL_L + +#define TRMM_LNUU QTRMM_LNUU +#define TRMM_LNUN QTRMM_LNUN +#define TRMM_LNLU QTRMM_LNLU +#define TRMM_LNLN QTRMM_LNLN +#define TRMM_LTUU QTRMM_LTUU +#define TRMM_LTUN QTRMM_LTUN +#define TRMM_LTLU QTRMM_LTLU +#define TRMM_LTLN QTRMM_LTLN +#define TRMM_LRUU QTRMM_LNUU +#define TRMM_LRUN QTRMM_LNUN +#define TRMM_LRLU QTRMM_LNLU +#define TRMM_LRLN QTRMM_LNLN +#define TRMM_LCUU QTRMM_LTUU +#define TRMM_LCUN QTRMM_LTUN +#define TRMM_LCLU QTRMM_LTLU +#define TRMM_LCLN QTRMM_LTLN +#define TRMM_RNUU QTRMM_RNUU +#define TRMM_RNUN QTRMM_RNUN +#define TRMM_RNLU QTRMM_RNLU +#define TRMM_RNLN QTRMM_RNLN +#define TRMM_RTUU QTRMM_RTUU +#define TRMM_RTUN QTRMM_RTUN +#define TRMM_RTLU QTRMM_RTLU +#define TRMM_RTLN QTRMM_RTLN +#define TRMM_RRUU QTRMM_RNUU +#define TRMM_RRUN QTRMM_RNUN +#define TRMM_RRLU QTRMM_RNLU +#define TRMM_RRLN QTRMM_RNLN +#define TRMM_RCUU QTRMM_RTUU +#define TRMM_RCUN QTRMM_RTUN +#define TRMM_RCLU QTRMM_RTLU +#define TRMM_RCLN QTRMM_RTLN + +#define TRSM_LNUU QTRSM_LNUU +#define TRSM_LNUN QTRSM_LNUN +#define TRSM_LNLU QTRSM_LNLU +#define TRSM_LNLN QTRSM_LNLN +#define TRSM_LTUU QTRSM_LTUU +#define TRSM_LTUN QTRSM_LTUN +#define TRSM_LTLU QTRSM_LTLU +#define TRSM_LTLN QTRSM_LTLN +#define TRSM_LRUU QTRSM_LNUU +#define TRSM_LRUN QTRSM_LNUN +#define TRSM_LRLU QTRSM_LNLU +#define TRSM_LRLN QTRSM_LNLN +#define TRSM_LCUU QTRSM_LTUU +#define TRSM_LCUN QTRSM_LTUN +#define TRSM_LCLU QTRSM_LTLU +#define TRSM_LCLN QTRSM_LTLN +#define TRSM_RNUU QTRSM_RNUU +#define TRSM_RNUN QTRSM_RNUN +#define TRSM_RNLU QTRSM_RNLU +#define TRSM_RNLN QTRSM_RNLN +#define TRSM_RTUU QTRSM_RTUU +#define TRSM_RTUN QTRSM_RTUN +#define TRSM_RTLU QTRSM_RTLU +#define TRSM_RTLN QTRSM_RTLN +#define TRSM_RRUU QTRSM_RNUU +#define TRSM_RRUN QTRSM_RNUN +#define TRSM_RRLU QTRSM_RNLU +#define TRSM_RRLN QTRSM_RNLN +#define TRSM_RCUU QTRSM_RTUU +#define TRSM_RCUN QTRSM_RTUN +#define TRSM_RCLU QTRSM_RTLU +#define TRSM_RCLN QTRSM_RTLN + +#define GEMM_THREAD_NN QGEMM_THREAD_NN +#define GEMM_THREAD_CN QGEMM_THREAD_TN +#define GEMM_THREAD_TN QGEMM_THREAD_TN +#define GEMM_THREAD_NC QGEMM_THREAD_NT +#define GEMM_THREAD_NT QGEMM_THREAD_NT +#define GEMM_THREAD_CC QGEMM_THREAD_TT +#define GEMM_THREAD_CT QGEMM_THREAD_TT +#define GEMM_THREAD_TC QGEMM_THREAD_TT +#define GEMM_THREAD_TT QGEMM_THREAD_TT +#define GEMM_THREAD_NR QGEMM_THREAD_NN +#define GEMM_THREAD_TR QGEMM_THREAD_TN +#define GEMM_THREAD_CR QGEMM_THREAD_TN +#define GEMM_THREAD_RN QGEMM_THREAD_NN +#define GEMM_THREAD_RT QGEMM_THREAD_NT +#define GEMM_THREAD_RC QGEMM_THREAD_NT +#define GEMM_THREAD_RR QGEMM_THREAD_NN + +#define SYMM_THREAD_LU QSYMM_THREAD_LU +#define SYMM_THREAD_LL QSYMM_THREAD_LL +#define SYMM_THREAD_RU QSYMM_THREAD_RU +#define SYMM_THREAD_RL QSYMM_THREAD_RL + +#define HEMM_THREAD_LU QHEMM_THREAD_LU +#define HEMM_THREAD_LL QHEMM_THREAD_LL +#define HEMM_THREAD_RU QHEMM_THREAD_RU +#define HEMM_THREAD_RL QHEMM_THREAD_RL + +#define SYRK_THREAD_UN QSYRK_THREAD_UN +#define SYRK_THREAD_UT QSYRK_THREAD_UT +#define SYRK_THREAD_LN QSYRK_THREAD_LN +#define SYRK_THREAD_LT QSYRK_THREAD_LT +#define SYRK_THREAD_UR QSYRK_THREAD_UR +#define SYRK_THREAD_UC QSYRK_THREAD_UC +#define SYRK_THREAD_LR QSYRK_THREAD_LN +#define SYRK_THREAD_LC QSYRK_THREAD_LT + +#define HERK_THREAD_UN QSYRK_THREAD_UN +#define HERK_THREAD_UT QSYRK_THREAD_UT +#define HERK_THREAD_LN QSYRK_THREAD_LN +#define HERK_THREAD_LT QSYRK_THREAD_LT +#define HERK_THREAD_UR QSYRK_THREAD_UR +#define HERK_THREAD_UC QSYRK_THREAD_UC +#define HERK_THREAD_LR QSYRK_THREAD_LN +#define HERK_THREAD_LC QSYRK_THREAD_LT + +#elif defined(DOUBLE) + +#define AMAX_K DAMAX_K +#define AMIN_K DAMIN_K +#define MAX_K DMAX_K +#define MIN_K DMIN_K +#define IAMAX_K IDAMAX_K +#define IAMIN_K IDAMIN_K +#define IMAX_K IDMAX_K +#define IMIN_K IDMIN_K +#define ASUM_K DASUM_K +#define AXPYU_K DAXPYU_K +#define AXPYC_K DAXPYC_K +#define COPY_K DCOPY_K +#define DOTU_K DDOTU_K +#define DOTC_K DDOTC_K +#define NRM2_K DNRM2_K +#define SCAL_K DSCAL_K +#define SWAP_K DSWAP_K +#define ROT_K DROT_K + +#define GEMV_N DGEMV_N +#define GEMV_T DGEMV_T +#define GEMV_R DGEMV_R +#define GEMV_C DGEMV_C +#define GEMV_O DGEMV_O +#define GEMV_U DGEMV_U +#define GEMV_S DGEMV_S +#define GEMV_D DGEMV_D + +#define GERU_K DGERU_K +#define GERC_K DGERC_K +#define GERV_K DGERV_K +#define GERD_K DGERD_K + +#define SYMV_U DSYMV_U +#define SYMV_L DSYMV_L + +#define SYMV_THREAD_U DSYMV_THREAD_U +#define SYMV_THREAD_L DSYMV_THREAD_L + +#define GEMM_ONCOPY DGEMM_ONCOPY +#define GEMM_OTCOPY DGEMM_OTCOPY +#define GEMM_INCOPY DGEMM_INCOPY +#define GEMM_ITCOPY DGEMM_ITCOPY + +#ifdef UNIT + +#define TRMM_OUNCOPY DTRMM_OUNUCOPY +#define TRMM_OUTCOPY DTRMM_OUTUCOPY +#define TRMM_OLNCOPY DTRMM_OLNUCOPY +#define TRMM_OLTCOPY DTRMM_OLTUCOPY +#define TRSM_OUNCOPY DTRSM_OUNUCOPY +#define TRSM_OUTCOPY DTRSM_OUTUCOPY +#define TRSM_OLNCOPY DTRSM_OLNUCOPY +#define TRSM_OLTCOPY DTRSM_OLTUCOPY + +#define TRMM_IUNCOPY DTRMM_IUNUCOPY +#define TRMM_IUTCOPY DTRMM_IUTUCOPY +#define TRMM_ILNCOPY DTRMM_ILNUCOPY +#define TRMM_ILTCOPY DTRMM_ILTUCOPY +#define TRSM_IUNCOPY DTRSM_IUNUCOPY +#define TRSM_IUTCOPY DTRSM_IUTUCOPY +#define TRSM_ILNCOPY DTRSM_ILNUCOPY +#define TRSM_ILTCOPY DTRSM_ILTUCOPY + +#else + +#define TRMM_OUNCOPY DTRMM_OUNNCOPY +#define TRMM_OUTCOPY DTRMM_OUTNCOPY +#define TRMM_OLNCOPY DTRMM_OLNNCOPY +#define TRMM_OLTCOPY DTRMM_OLTNCOPY +#define TRSM_OUNCOPY DTRSM_OUNNCOPY +#define TRSM_OUTCOPY DTRSM_OUTNCOPY +#define TRSM_OLNCOPY DTRSM_OLNNCOPY +#define TRSM_OLTCOPY DTRSM_OLTNCOPY + +#define TRMM_IUNCOPY DTRMM_IUNNCOPY +#define TRMM_IUTCOPY DTRMM_IUTNCOPY +#define TRMM_ILNCOPY DTRMM_ILNNCOPY +#define TRMM_ILTCOPY DTRMM_ILTNCOPY +#define TRSM_IUNCOPY DTRSM_IUNNCOPY +#define TRSM_IUTCOPY DTRSM_IUTNCOPY +#define TRSM_ILNCOPY DTRSM_ILNNCOPY +#define TRSM_ILTCOPY DTRSM_ILTNCOPY + +#endif + +#define GEMM_BETA DGEMM_BETA + +#define GEMM_KERNEL_N DGEMM_KERNEL +#define GEMM_KERNEL_L DGEMM_KERNEL +#define GEMM_KERNEL_R DGEMM_KERNEL +#define GEMM_KERNEL_B DGEMM_KERNEL + +#define TRMM_KERNEL_LN DTRMM_KERNEL_LN +#define TRMM_KERNEL_LT DTRMM_KERNEL_LT +#define TRMM_KERNEL_LR DTRMM_KERNEL_LN +#define TRMM_KERNEL_LC DTRMM_KERNEL_LT +#define TRMM_KERNEL_RN DTRMM_KERNEL_RN +#define TRMM_KERNEL_RT DTRMM_KERNEL_RT +#define TRMM_KERNEL_RR DTRMM_KERNEL_RN +#define TRMM_KERNEL_RC DTRMM_KERNEL_RT + +#define TRSM_KERNEL_LN DTRSM_KERNEL_LN +#define TRSM_KERNEL_LT DTRSM_KERNEL_LT +#define TRSM_KERNEL_LR DTRSM_KERNEL_LN +#define TRSM_KERNEL_LC DTRSM_KERNEL_LT +#define TRSM_KERNEL_RN DTRSM_KERNEL_RN +#define TRSM_KERNEL_RT DTRSM_KERNEL_RT +#define TRSM_KERNEL_RR DTRSM_KERNEL_RN +#define TRSM_KERNEL_RC DTRSM_KERNEL_RT + +#define SYMM_IUTCOPY DSYMM_IUTCOPY +#define SYMM_ILTCOPY DSYMM_ILTCOPY +#define SYMM_OUTCOPY DSYMM_OUTCOPY +#define SYMM_OLTCOPY DSYMM_OLTCOPY + +#define GEMM_NN DGEMM_NN +#define GEMM_CN DGEMM_TN +#define GEMM_TN DGEMM_TN +#define GEMM_NC DGEMM_NT +#define GEMM_NT DGEMM_NT +#define GEMM_CC DGEMM_TT +#define GEMM_CT DGEMM_TT +#define GEMM_TC DGEMM_TT +#define GEMM_TT DGEMM_TT +#define GEMM_NR DGEMM_NN +#define GEMM_TR DGEMM_TN +#define GEMM_CR DGEMM_TN +#define GEMM_RN DGEMM_NN +#define GEMM_RT DGEMM_NT +#define GEMM_RC DGEMM_NT +#define GEMM_RR DGEMM_NN + +#define SYMM_LU DSYMM_LU +#define SYMM_LL DSYMM_LL +#define SYMM_RU DSYMM_RU +#define SYMM_RL DSYMM_RL + +#define HEMM_LU DHEMM_LU +#define HEMM_LL DHEMM_LL +#define HEMM_RU DHEMM_RU +#define HEMM_RL DHEMM_RL + +#define SYRK_UN DSYRK_UN +#define SYRK_UT DSYRK_UT +#define SYRK_LN DSYRK_LN +#define SYRK_LT DSYRK_LT +#define SYRK_UR DSYRK_UN +#define SYRK_UC DSYRK_UT +#define SYRK_LR DSYRK_LN +#define SYRK_LC DSYRK_LT + +#define SYRK_KERNEL_U DSYRK_KERNEL_U +#define SYRK_KERNEL_L DSYRK_KERNEL_L + +#define HERK_UN DSYRK_UN +#define HERK_LN DSYRK_LN +#define HERK_UC DSYRK_UT +#define HERK_LC DSYRK_LT + +#define HER2K_UN DSYR2K_UN +#define HER2K_LN DSYR2K_LN +#define HER2K_UC DSYR2K_UT +#define HER2K_LC DSYR2K_LT + +#define SYR2K_UN DSYR2K_UN +#define SYR2K_UT DSYR2K_UT +#define SYR2K_LN DSYR2K_LN +#define SYR2K_LT DSYR2K_LT +#define SYR2K_UR DSYR2K_UN +#define SYR2K_UC DSYR2K_UT +#define SYR2K_LR DSYR2K_LN +#define SYR2K_LC DSYR2K_LT + +#define SYR2K_KERNEL_U DSYR2K_KERNEL_U +#define SYR2K_KERNEL_L DSYR2K_KERNEL_L + +#define TRMM_LNUU DTRMM_LNUU +#define TRMM_LNUN DTRMM_LNUN +#define TRMM_LNLU DTRMM_LNLU +#define TRMM_LNLN DTRMM_LNLN +#define TRMM_LTUU DTRMM_LTUU +#define TRMM_LTUN DTRMM_LTUN +#define TRMM_LTLU DTRMM_LTLU +#define TRMM_LTLN DTRMM_LTLN +#define TRMM_LRUU DTRMM_LNUU +#define TRMM_LRUN DTRMM_LNUN +#define TRMM_LRLU DTRMM_LNLU +#define TRMM_LRLN DTRMM_LNLN +#define TRMM_LCUU DTRMM_LTUU +#define TRMM_LCUN DTRMM_LTUN +#define TRMM_LCLU DTRMM_LTLU +#define TRMM_LCLN DTRMM_LTLN +#define TRMM_RNUU DTRMM_RNUU +#define TRMM_RNUN DTRMM_RNUN +#define TRMM_RNLU DTRMM_RNLU +#define TRMM_RNLN DTRMM_RNLN +#define TRMM_RTUU DTRMM_RTUU +#define TRMM_RTUN DTRMM_RTUN +#define TRMM_RTLU DTRMM_RTLU +#define TRMM_RTLN DTRMM_RTLN +#define TRMM_RRUU DTRMM_RNUU +#define TRMM_RRUN DTRMM_RNUN +#define TRMM_RRLU DTRMM_RNLU +#define TRMM_RRLN DTRMM_RNLN +#define TRMM_RCUU DTRMM_RTUU +#define TRMM_RCUN DTRMM_RTUN +#define TRMM_RCLU DTRMM_RTLU +#define TRMM_RCLN DTRMM_RTLN + +#define TRSM_LNUU DTRSM_LNUU +#define TRSM_LNUN DTRSM_LNUN +#define TRSM_LNLU DTRSM_LNLU +#define TRSM_LNLN DTRSM_LNLN +#define TRSM_LTUU DTRSM_LTUU +#define TRSM_LTUN DTRSM_LTUN +#define TRSM_LTLU DTRSM_LTLU +#define TRSM_LTLN DTRSM_LTLN +#define TRSM_LRUU DTRSM_LNUU +#define TRSM_LRUN DTRSM_LNUN +#define TRSM_LRLU DTRSM_LNLU +#define TRSM_LRLN DTRSM_LNLN +#define TRSM_LCUU DTRSM_LTUU +#define TRSM_LCUN DTRSM_LTUN +#define TRSM_LCLU DTRSM_LTLU +#define TRSM_LCLN DTRSM_LTLN +#define TRSM_RNUU DTRSM_RNUU +#define TRSM_RNUN DTRSM_RNUN +#define TRSM_RNLU DTRSM_RNLU +#define TRSM_RNLN DTRSM_RNLN +#define TRSM_RTUU DTRSM_RTUU +#define TRSM_RTUN DTRSM_RTUN +#define TRSM_RTLU DTRSM_RTLU +#define TRSM_RTLN DTRSM_RTLN +#define TRSM_RRUU DTRSM_RNUU +#define TRSM_RRUN DTRSM_RNUN +#define TRSM_RRLU DTRSM_RNLU +#define TRSM_RRLN DTRSM_RNLN +#define TRSM_RCUU DTRSM_RTUU +#define TRSM_RCUN DTRSM_RTUN +#define TRSM_RCLU DTRSM_RTLU +#define TRSM_RCLN DTRSM_RTLN + +#define GEMM_THREAD_NN DGEMM_THREAD_NN +#define GEMM_THREAD_CN DGEMM_THREAD_TN +#define GEMM_THREAD_TN DGEMM_THREAD_TN +#define GEMM_THREAD_NC DGEMM_THREAD_NT +#define GEMM_THREAD_NT DGEMM_THREAD_NT +#define GEMM_THREAD_CC DGEMM_THREAD_TT +#define GEMM_THREAD_CT DGEMM_THREAD_TT +#define GEMM_THREAD_TC DGEMM_THREAD_TT +#define GEMM_THREAD_TT DGEMM_THREAD_TT +#define GEMM_THREAD_NR DGEMM_THREAD_NN +#define GEMM_THREAD_TR DGEMM_THREAD_TN +#define GEMM_THREAD_CR DGEMM_THREAD_TN +#define GEMM_THREAD_RN DGEMM_THREAD_NN +#define GEMM_THREAD_RT DGEMM_THREAD_NT +#define GEMM_THREAD_RC DGEMM_THREAD_NT +#define GEMM_THREAD_RR DGEMM_THREAD_NN + +#define SYMM_THREAD_LU DSYMM_THREAD_LU +#define SYMM_THREAD_LL DSYMM_THREAD_LL +#define SYMM_THREAD_RU DSYMM_THREAD_RU +#define SYMM_THREAD_RL DSYMM_THREAD_RL + +#define HEMM_THREAD_LU DHEMM_THREAD_LU +#define HEMM_THREAD_LL DHEMM_THREAD_LL +#define HEMM_THREAD_RU DHEMM_THREAD_RU +#define HEMM_THREAD_RL DHEMM_THREAD_RL + +#define SYRK_THREAD_UN DSYRK_THREAD_UN +#define SYRK_THREAD_UT DSYRK_THREAD_UT +#define SYRK_THREAD_LN DSYRK_THREAD_LN +#define SYRK_THREAD_LT DSYRK_THREAD_LT +#define SYRK_THREAD_UR DSYRK_THREAD_UR +#define SYRK_THREAD_UC DSYRK_THREAD_UC +#define SYRK_THREAD_LR DSYRK_THREAD_LN +#define SYRK_THREAD_LC DSYRK_THREAD_LT + +#define HERK_THREAD_UN DSYRK_THREAD_UN +#define HERK_THREAD_UT DSYRK_THREAD_UT +#define HERK_THREAD_LN DSYRK_THREAD_LN +#define HERK_THREAD_LT DSYRK_THREAD_LT +#define HERK_THREAD_UR DSYRK_THREAD_UR +#define HERK_THREAD_UC DSYRK_THREAD_UC +#define HERK_THREAD_LR DSYRK_THREAD_LN +#define HERK_THREAD_LC DSYRK_THREAD_LT + +#else + +#define AMAX_K SAMAX_K +#define AMIN_K SAMIN_K +#define MAX_K SMAX_K +#define MIN_K SMIN_K +#define IAMAX_K ISAMAX_K +#define IAMIN_K ISAMIN_K +#define IMAX_K ISMAX_K +#define IMIN_K ISMIN_K +#define ASUM_K SASUM_K +#define AXPYU_K SAXPYU_K +#define AXPYC_K SAXPYU_K +#define COPY_K SCOPY_K +#define DOTU_K SDOTU_K +#define DOTC_K SDOTC_K +#define NRM2_K SNRM2_K +#define SCAL_K SSCAL_K +#define SWAP_K SSWAP_K +#define ROT_K SROT_K + +#define GEMV_N SGEMV_N +#define GEMV_T SGEMV_T +#define GEMV_R SGEMV_R +#define GEMV_C SGEMV_C +#define GEMV_O SGEMV_O +#define GEMV_U SGEMV_U +#define GEMV_S SGEMV_S +#define GEMV_D SGEMV_D + +#define GERU_K SGERU_K +#define GERC_K SGERC_K +#define GERV_K SGERV_K +#define GERD_K SGERD_K + +#define SYMV_U SSYMV_U +#define SYMV_L SSYMV_L + +#define SYMV_THREAD_U SSYMV_THREAD_U +#define SYMV_THREAD_L SSYMV_THREAD_L + +#define GEMM_ONCOPY SGEMM_ONCOPY +#define GEMM_OTCOPY SGEMM_OTCOPY +#define GEMM_INCOPY SGEMM_INCOPY +#define GEMM_ITCOPY SGEMM_ITCOPY + +#ifdef UNIT + +#define TRMM_OUNCOPY STRMM_OUNUCOPY +#define TRMM_OUTCOPY STRMM_OUTUCOPY +#define TRMM_OLNCOPY STRMM_OLNUCOPY +#define TRMM_OLTCOPY STRMM_OLTUCOPY +#define TRSM_OUNCOPY STRSM_OUNUCOPY +#define TRSM_OUTCOPY STRSM_OUTUCOPY +#define TRSM_OLNCOPY STRSM_OLNUCOPY +#define TRSM_OLTCOPY STRSM_OLTUCOPY + +#define TRMM_IUNCOPY STRMM_IUNUCOPY +#define TRMM_IUTCOPY STRMM_IUTUCOPY +#define TRMM_ILNCOPY STRMM_ILNUCOPY +#define TRMM_ILTCOPY STRMM_ILTUCOPY +#define TRSM_IUNCOPY STRSM_IUNUCOPY +#define TRSM_IUTCOPY STRSM_IUTUCOPY +#define TRSM_ILNCOPY STRSM_ILNUCOPY +#define TRSM_ILTCOPY STRSM_ILTUCOPY + +#else + +#define TRMM_OUNCOPY STRMM_OUNNCOPY +#define TRMM_OUTCOPY STRMM_OUTNCOPY +#define TRMM_OLNCOPY STRMM_OLNNCOPY +#define TRMM_OLTCOPY STRMM_OLTNCOPY +#define TRSM_OUNCOPY STRSM_OUNNCOPY +#define TRSM_OUTCOPY STRSM_OUTNCOPY +#define TRSM_OLNCOPY STRSM_OLNNCOPY +#define TRSM_OLTCOPY STRSM_OLTNCOPY + +#define TRMM_IUNCOPY STRMM_IUNNCOPY +#define TRMM_IUTCOPY STRMM_IUTNCOPY +#define TRMM_ILNCOPY STRMM_ILNNCOPY +#define TRMM_ILTCOPY STRMM_ILTNCOPY +#define TRSM_IUNCOPY STRSM_IUNNCOPY +#define TRSM_IUTCOPY STRSM_IUTNCOPY +#define TRSM_ILNCOPY STRSM_ILNNCOPY +#define TRSM_ILTCOPY STRSM_ILTNCOPY + +#endif + +#define GEMM_BETA SGEMM_BETA + +#define GEMM_KERNEL_N SGEMM_KERNEL +#define GEMM_KERNEL_L SGEMM_KERNEL +#define GEMM_KERNEL_R SGEMM_KERNEL +#define GEMM_KERNEL_B SGEMM_KERNEL + +#define TRMM_KERNEL_LN STRMM_KERNEL_LN +#define TRMM_KERNEL_LT STRMM_KERNEL_LT +#define TRMM_KERNEL_LR STRMM_KERNEL_LN +#define TRMM_KERNEL_LC STRMM_KERNEL_LT +#define TRMM_KERNEL_RN STRMM_KERNEL_RN +#define TRMM_KERNEL_RT STRMM_KERNEL_RT +#define TRMM_KERNEL_RR STRMM_KERNEL_RN +#define TRMM_KERNEL_RC STRMM_KERNEL_RT + +#define TRSM_KERNEL_LN STRSM_KERNEL_LN +#define TRSM_KERNEL_LT STRSM_KERNEL_LT +#define TRSM_KERNEL_LR STRSM_KERNEL_LN +#define TRSM_KERNEL_LC STRSM_KERNEL_LT +#define TRSM_KERNEL_RN STRSM_KERNEL_RN +#define TRSM_KERNEL_RT STRSM_KERNEL_RT +#define TRSM_KERNEL_RR STRSM_KERNEL_RN +#define TRSM_KERNEL_RC STRSM_KERNEL_RT + +#define SYMM_IUTCOPY SSYMM_IUTCOPY +#define SYMM_ILTCOPY SSYMM_ILTCOPY +#define SYMM_OUTCOPY SSYMM_OUTCOPY +#define SYMM_OLTCOPY SSYMM_OLTCOPY + +#define GEMM_NN SGEMM_NN +#define GEMM_CN SGEMM_TN +#define GEMM_TN SGEMM_TN +#define GEMM_NC SGEMM_NT +#define GEMM_NT SGEMM_NT +#define GEMM_CC SGEMM_TT +#define GEMM_CT SGEMM_TT +#define GEMM_TC SGEMM_TT +#define GEMM_TT SGEMM_TT +#define GEMM_NR SGEMM_NN +#define GEMM_TR SGEMM_TN +#define GEMM_CR SGEMM_TN +#define GEMM_RN SGEMM_NN +#define GEMM_RT SGEMM_NT +#define GEMM_RC SGEMM_NT +#define GEMM_RR SGEMM_NN + +#define SYMM_LU SSYMM_LU +#define SYMM_LL SSYMM_LL +#define SYMM_RU SSYMM_RU +#define SYMM_RL SSYMM_RL + +#define HEMM_LU SHEMM_LU +#define HEMM_LL SHEMM_LL +#define HEMM_RU SHEMM_RU +#define HEMM_RL SHEMM_RL + +#define SYRK_UN SSYRK_UN +#define SYRK_UT SSYRK_UT +#define SYRK_LN SSYRK_LN +#define SYRK_LT SSYRK_LT +#define SYRK_UR SSYRK_UN +#define SYRK_UC SSYRK_UT +#define SYRK_LR SSYRK_LN +#define SYRK_LC SSYRK_LT + +#define SYRK_KERNEL_U SSYRK_KERNEL_U +#define SYRK_KERNEL_L SSYRK_KERNEL_L + +#define HERK_UN SSYRK_UN +#define HERK_LN SSYRK_LN +#define HERK_UC SSYRK_UT +#define HERK_LC SSYRK_LT + +#define HER2K_UN SSYR2K_UN +#define HER2K_LN SSYR2K_LN +#define HER2K_UC SSYR2K_UT +#define HER2K_LC SSYR2K_LT + +#define SYR2K_UN SSYR2K_UN +#define SYR2K_UT SSYR2K_UT +#define SYR2K_LN SSYR2K_LN +#define SYR2K_LT SSYR2K_LT +#define SYR2K_UR SSYR2K_UN +#define SYR2K_UC SSYR2K_UT +#define SYR2K_LR SSYR2K_LN +#define SYR2K_LC SSYR2K_LT + +#define SYR2K_KERNEL_U SSYR2K_KERNEL_U +#define SYR2K_KERNEL_L SSYR2K_KERNEL_L + +#define TRMM_LNUU STRMM_LNUU +#define TRMM_LNUN STRMM_LNUN +#define TRMM_LNLU STRMM_LNLU +#define TRMM_LNLN STRMM_LNLN +#define TRMM_LTUU STRMM_LTUU +#define TRMM_LTUN STRMM_LTUN +#define TRMM_LTLU STRMM_LTLU +#define TRMM_LTLN STRMM_LTLN +#define TRMM_LRUU STRMM_LNUU +#define TRMM_LRUN STRMM_LNUN +#define TRMM_LRLU STRMM_LNLU +#define TRMM_LRLN STRMM_LNLN +#define TRMM_LCUU STRMM_LTUU +#define TRMM_LCUN STRMM_LTUN +#define TRMM_LCLU STRMM_LTLU +#define TRMM_LCLN STRMM_LTLN +#define TRMM_RNUU STRMM_RNUU +#define TRMM_RNUN STRMM_RNUN +#define TRMM_RNLU STRMM_RNLU +#define TRMM_RNLN STRMM_RNLN +#define TRMM_RTUU STRMM_RTUU +#define TRMM_RTUN STRMM_RTUN +#define TRMM_RTLU STRMM_RTLU +#define TRMM_RTLN STRMM_RTLN +#define TRMM_RRUU STRMM_RNUU +#define TRMM_RRUN STRMM_RNUN +#define TRMM_RRLU STRMM_RNLU +#define TRMM_RRLN STRMM_RNLN +#define TRMM_RCUU STRMM_RTUU +#define TRMM_RCUN STRMM_RTUN +#define TRMM_RCLU STRMM_RTLU +#define TRMM_RCLN STRMM_RTLN + +#define TRSM_LNUU STRSM_LNUU +#define TRSM_LNUN STRSM_LNUN +#define TRSM_LNLU STRSM_LNLU +#define TRSM_LNLN STRSM_LNLN +#define TRSM_LTUU STRSM_LTUU +#define TRSM_LTUN STRSM_LTUN +#define TRSM_LTLU STRSM_LTLU +#define TRSM_LTLN STRSM_LTLN +#define TRSM_LRUU STRSM_LNUU +#define TRSM_LRUN STRSM_LNUN +#define TRSM_LRLU STRSM_LNLU +#define TRSM_LRLN STRSM_LNLN +#define TRSM_LCUU STRSM_LTUU +#define TRSM_LCUN STRSM_LTUN +#define TRSM_LCLU STRSM_LTLU +#define TRSM_LCLN STRSM_LTLN +#define TRSM_RNUU STRSM_RNUU +#define TRSM_RNUN STRSM_RNUN +#define TRSM_RNLU STRSM_RNLU +#define TRSM_RNLN STRSM_RNLN +#define TRSM_RTUU STRSM_RTUU +#define TRSM_RTUN STRSM_RTUN +#define TRSM_RTLU STRSM_RTLU +#define TRSM_RTLN STRSM_RTLN +#define TRSM_RRUU STRSM_RNUU +#define TRSM_RRUN STRSM_RNUN +#define TRSM_RRLU STRSM_RNLU +#define TRSM_RRLN STRSM_RNLN +#define TRSM_RCUU STRSM_RTUU +#define TRSM_RCUN STRSM_RTUN +#define TRSM_RCLU STRSM_RTLU +#define TRSM_RCLN STRSM_RTLN + +#define GEMM_THREAD_NN SGEMM_THREAD_NN +#define GEMM_THREAD_CN SGEMM_THREAD_TN +#define GEMM_THREAD_TN SGEMM_THREAD_TN +#define GEMM_THREAD_NC SGEMM_THREAD_NT +#define GEMM_THREAD_NT SGEMM_THREAD_NT +#define GEMM_THREAD_CC SGEMM_THREAD_TT +#define GEMM_THREAD_CT SGEMM_THREAD_TT +#define GEMM_THREAD_TC SGEMM_THREAD_TT +#define GEMM_THREAD_TT SGEMM_THREAD_TT +#define GEMM_THREAD_NR SGEMM_THREAD_NN +#define GEMM_THREAD_TR SGEMM_THREAD_TN +#define GEMM_THREAD_CR SGEMM_THREAD_TN +#define GEMM_THREAD_RN SGEMM_THREAD_NN +#define GEMM_THREAD_RT SGEMM_THREAD_NT +#define GEMM_THREAD_RC SGEMM_THREAD_NT +#define GEMM_THREAD_RR SGEMM_THREAD_NN + +#define SYMM_THREAD_LU SSYMM_THREAD_LU +#define SYMM_THREAD_LL SSYMM_THREAD_LL +#define SYMM_THREAD_RU SSYMM_THREAD_RU +#define SYMM_THREAD_RL SSYMM_THREAD_RL + +#define HEMM_THREAD_LU SHEMM_THREAD_LU +#define HEMM_THREAD_LL SHEMM_THREAD_LL +#define HEMM_THREAD_RU SHEMM_THREAD_RU +#define HEMM_THREAD_RL SHEMM_THREAD_RL + +#define SYRK_THREAD_UN SSYRK_THREAD_UN +#define SYRK_THREAD_UT SSYRK_THREAD_UT +#define SYRK_THREAD_LN SSYRK_THREAD_LN +#define SYRK_THREAD_LT SSYRK_THREAD_LT +#define SYRK_THREAD_UR SSYRK_THREAD_UR +#define SYRK_THREAD_UC SSYRK_THREAD_UC +#define SYRK_THREAD_LR SSYRK_THREAD_LN +#define SYRK_THREAD_LC SSYRK_THREAD_LT + +#define HERK_THREAD_UN SSYRK_THREAD_UN +#define HERK_THREAD_UT SSYRK_THREAD_UT +#define HERK_THREAD_LN SSYRK_THREAD_LN +#define HERK_THREAD_LT SSYRK_THREAD_LT +#define HERK_THREAD_UR SSYRK_THREAD_UR +#define HERK_THREAD_UC SSYRK_THREAD_UC +#define HERK_THREAD_LR SSYRK_THREAD_LN +#define HERK_THREAD_LC SSYRK_THREAD_LT + +#endif +#else +#ifdef XDOUBLE + +#define AMAX_K XAMAX_K +#define AMIN_K XAMIN_K +#define MAX_K XMAX_K +#define MIN_K XMIN_K +#define IAMAX_K IXAMAX_K +#define IAMIN_K IXAMIN_K +#define IMAX_K IXMAX_K +#define IMIN_K IXMIN_K +#define ASUM_K XASUM_K +#define AXPYU_K XAXPYU_K +#define AXPYC_K XAXPYC_K +#define COPY_K XCOPY_K +#define DOTU_K XDOTU_K +#define DOTC_K XDOTC_K +#define NRM2_K XNRM2_K +#define SCAL_K XSCAL_K +#define SWAP_K XSWAP_K +#define ROT_K XROT_K + +#define GEMV_N XGEMV_N +#define GEMV_T XGEMV_T +#define GEMV_R XGEMV_R +#define GEMV_C XGEMV_C +#define GEMV_O XGEMV_O +#define GEMV_U XGEMV_U +#define GEMV_S XGEMV_S +#define GEMV_D XGEMV_D + +#define GERU_K XGERU_K +#define GERC_K XGERC_K +#define GERV_K XGERV_K +#define GERD_K XGERD_K + +#define SYMV_U XSYMV_U +#define SYMV_L XSYMV_L +#define HEMV_U XHEMV_U +#define HEMV_L XHEMV_L +#define HEMV_V XHEMV_V +#define HEMV_M XHEMV_M + +#define SYMV_THREAD_U XSYMV_THREAD_U +#define SYMV_THREAD_L XSYMV_THREAD_L +#define HEMV_THREAD_U XHEMV_THREAD_U +#define HEMV_THREAD_L XHEMV_THREAD_L +#define HEMV_THREAD_V XHEMV_THREAD_V +#define HEMV_THREAD_M XHEMV_THREAD_M + +#define GEMM_ONCOPY XGEMM_ONCOPY +#define GEMM_OTCOPY XGEMM_OTCOPY +#define GEMM_INCOPY XGEMM_INCOPY +#define GEMM_ITCOPY XGEMM_ITCOPY + +#define GEMM3M_ONCOPYB XGEMM3M_ONCOPYB +#define GEMM3M_ONCOPYR XGEMM3M_ONCOPYR +#define GEMM3M_ONCOPYI XGEMM3M_ONCOPYI +#define GEMM3M_OTCOPYB XGEMM3M_OTCOPYB +#define GEMM3M_OTCOPYR XGEMM3M_OTCOPYR +#define GEMM3M_OTCOPYI XGEMM3M_OTCOPYI +#define GEMM3M_INCOPYB XGEMM3M_INCOPYB +#define GEMM3M_INCOPYR XGEMM3M_INCOPYR +#define GEMM3M_INCOPYI XGEMM3M_INCOPYI +#define GEMM3M_ITCOPYB XGEMM3M_ITCOPYB +#define GEMM3M_ITCOPYR XGEMM3M_ITCOPYR +#define GEMM3M_ITCOPYI XGEMM3M_ITCOPYI + +#ifdef UNIT + +#define TRMM_OUNCOPY XTRMM_OUNUCOPY +#define TRMM_OUTCOPY XTRMM_OUTUCOPY +#define TRMM_OLNCOPY XTRMM_OLNUCOPY +#define TRMM_OLTCOPY XTRMM_OLTUCOPY +#define TRSM_OUNCOPY XTRSM_OUNUCOPY +#define TRSM_OUTCOPY XTRSM_OUTUCOPY +#define TRSM_OLNCOPY XTRSM_OLNUCOPY +#define TRSM_OLTCOPY XTRSM_OLTUCOPY + +#define TRMM_IUNCOPY XTRMM_IUNUCOPY +#define TRMM_IUTCOPY XTRMM_IUTUCOPY +#define TRMM_ILNCOPY XTRMM_ILNUCOPY +#define TRMM_ILTCOPY XTRMM_ILTUCOPY +#define TRSM_IUNCOPY XTRSM_IUNUCOPY +#define TRSM_IUTCOPY XTRSM_IUTUCOPY +#define TRSM_ILNCOPY XTRSM_ILNUCOPY +#define TRSM_ILTCOPY XTRSM_ILTUCOPY + +#else + +#define TRMM_OUNCOPY XTRMM_OUNNCOPY +#define TRMM_OUTCOPY XTRMM_OUTNCOPY +#define TRMM_OLNCOPY XTRMM_OLNNCOPY +#define TRMM_OLTCOPY XTRMM_OLTNCOPY +#define TRSM_OUNCOPY XTRSM_OUNNCOPY +#define TRSM_OUTCOPY XTRSM_OUTNCOPY +#define TRSM_OLNCOPY XTRSM_OLNNCOPY +#define TRSM_OLTCOPY XTRSM_OLTNCOPY + +#define TRMM_IUNCOPY XTRMM_IUNNCOPY +#define TRMM_IUTCOPY XTRMM_IUTNCOPY +#define TRMM_ILNCOPY XTRMM_ILNNCOPY +#define TRMM_ILTCOPY XTRMM_ILTNCOPY +#define TRSM_IUNCOPY XTRSM_IUNNCOPY +#define TRSM_IUTCOPY XTRSM_IUTNCOPY +#define TRSM_ILNCOPY XTRSM_ILNNCOPY +#define TRSM_ILTCOPY XTRSM_ILTNCOPY + +#endif + +#define SYMM3M_ILCOPYB XSYMM3M_ILCOPYB +#define SYMM3M_IUCOPYB XSYMM3M_IUCOPYB +#define SYMM3M_ILCOPYR XSYMM3M_ILCOPYR +#define SYMM3M_IUCOPYR XSYMM3M_IUCOPYR +#define SYMM3M_ILCOPYI XSYMM3M_ILCOPYI +#define SYMM3M_IUCOPYI XSYMM3M_IUCOPYI + +#define SYMM3M_OLCOPYB XSYMM3M_OLCOPYB +#define SYMM3M_OUCOPYB XSYMM3M_OUCOPYB +#define SYMM3M_OLCOPYR XSYMM3M_OLCOPYR +#define SYMM3M_OUCOPYR XSYMM3M_OUCOPYR +#define SYMM3M_OLCOPYI XSYMM3M_OLCOPYI +#define SYMM3M_OUCOPYI XSYMM3M_OUCOPYI + +#define HEMM3M_ILCOPYB XHEMM3M_ILCOPYB +#define HEMM3M_IUCOPYB XHEMM3M_IUCOPYB +#define HEMM3M_ILCOPYR XHEMM3M_ILCOPYR +#define HEMM3M_IUCOPYR XHEMM3M_IUCOPYR +#define HEMM3M_ILCOPYI XHEMM3M_ILCOPYI +#define HEMM3M_IUCOPYI XHEMM3M_IUCOPYI + +#define HEMM3M_OLCOPYB XHEMM3M_OLCOPYB +#define HEMM3M_OUCOPYB XHEMM3M_OUCOPYB +#define HEMM3M_OLCOPYR XHEMM3M_OLCOPYR +#define HEMM3M_OUCOPYR XHEMM3M_OUCOPYR +#define HEMM3M_OLCOPYI XHEMM3M_OLCOPYI +#define HEMM3M_OUCOPYI XHEMM3M_OUCOPYI + +#define GEMM_BETA XGEMM_BETA + +#define GEMM_KERNEL_N XGEMM_KERNEL_N +#define GEMM_KERNEL_L XGEMM_KERNEL_L +#define GEMM_KERNEL_R XGEMM_KERNEL_R +#define GEMM_KERNEL_B XGEMM_KERNEL_B + +#define GEMM3M_KERNEL XGEMM3M_KERNEL + +#define TRMM_KERNEL_LN XTRMM_KERNEL_LN +#define TRMM_KERNEL_LT XTRMM_KERNEL_LT +#define TRMM_KERNEL_LR XTRMM_KERNEL_LR +#define TRMM_KERNEL_LC XTRMM_KERNEL_LC +#define TRMM_KERNEL_RN XTRMM_KERNEL_RN +#define TRMM_KERNEL_RT XTRMM_KERNEL_RT +#define TRMM_KERNEL_RR XTRMM_KERNEL_RR +#define TRMM_KERNEL_RC XTRMM_KERNEL_RC + +#define TRSM_KERNEL_LN XTRSM_KERNEL_LN +#define TRSM_KERNEL_LT XTRSM_KERNEL_LT +#define TRSM_KERNEL_LR XTRSM_KERNEL_LR +#define TRSM_KERNEL_LC XTRSM_KERNEL_LC +#define TRSM_KERNEL_RN XTRSM_KERNEL_RN +#define TRSM_KERNEL_RT XTRSM_KERNEL_RT +#define TRSM_KERNEL_RR XTRSM_KERNEL_RR +#define TRSM_KERNEL_RC XTRSM_KERNEL_RC + +#define GEMM_NN XGEMM_NN +#define GEMM_CN XGEMM_CN +#define GEMM_TN XGEMM_TN +#define GEMM_NC XGEMM_NC +#define GEMM_NT XGEMM_NT +#define GEMM_CC XGEMM_CC +#define GEMM_CT XGEMM_CT +#define GEMM_TC XGEMM_TC +#define GEMM_TT XGEMM_TT +#define GEMM_NR XGEMM_NR +#define GEMM_TR XGEMM_TR +#define GEMM_CR XGEMM_CR +#define GEMM_RN XGEMM_RN +#define GEMM_RT XGEMM_RT +#define GEMM_RC XGEMM_RC +#define GEMM_RR XGEMM_RR + +#define SYMM_LU XSYMM_LU +#define SYMM_LL XSYMM_LL +#define SYMM_RU XSYMM_RU +#define SYMM_RL XSYMM_RL + +#define HEMM_LU XHEMM_LU +#define HEMM_LL XHEMM_LL +#define HEMM_RU XHEMM_RU +#define HEMM_RL XHEMM_RL + +#define HEMM_IUTCOPY XHEMM_IUTCOPY +#define HEMM_ILTCOPY XHEMM_ILTCOPY +#define HEMM_OUTCOPY XHEMM_OUTCOPY +#define HEMM_OLTCOPY XHEMM_OLTCOPY + +#define SYRK_UN XSYRK_UN +#define SYRK_UT XSYRK_UT +#define SYRK_LN XSYRK_LN +#define SYRK_LT XSYRK_LT +#define SYRK_UR XSYRK_UN +#define SYRK_UC XSYRK_UT +#define SYRK_LR XSYRK_LN +#define SYRK_LC XSYRK_LT + +#define SYRK_KERNEL_U XSYRK_KERNEL_U +#define SYRK_KERNEL_L XSYRK_KERNEL_L + +#define HERK_UN XHERK_UN +#define HERK_LN XHERK_LN +#define HERK_UC XHERK_UC +#define HERK_LC XHERK_LC + +#define HER2K_UN XHER2K_UN +#define HER2K_LN XHER2K_LN +#define HER2K_UC XHER2K_UC +#define HER2K_LC XHER2K_LC + +#define SYR2K_UN XSYR2K_UN +#define SYR2K_UT XSYR2K_UT +#define SYR2K_LN XSYR2K_LN +#define SYR2K_LT XSYR2K_LT +#define SYR2K_UR XSYR2K_UN +#define SYR2K_UC XSYR2K_UT +#define SYR2K_LR XSYR2K_LN +#define SYR2K_LC XSYR2K_LT + +#define SYR2K_KERNEL_U XSYR2K_KERNEL_U +#define SYR2K_KERNEL_L XSYR2K_KERNEL_L + +#define TRMM_LNUU XTRMM_LNUU +#define TRMM_LNUN XTRMM_LNUN +#define TRMM_LNLU XTRMM_LNLU +#define TRMM_LNLN XTRMM_LNLN +#define TRMM_LTUU XTRMM_LTUU +#define TRMM_LTUN XTRMM_LTUN +#define TRMM_LTLU XTRMM_LTLU +#define TRMM_LTLN XTRMM_LTLN +#define TRMM_LRUU XTRMM_LRUU +#define TRMM_LRUN XTRMM_LRUN +#define TRMM_LRLU XTRMM_LRLU +#define TRMM_LRLN XTRMM_LRLN +#define TRMM_LCUU XTRMM_LCUU +#define TRMM_LCUN XTRMM_LCUN +#define TRMM_LCLU XTRMM_LCLU +#define TRMM_LCLN XTRMM_LCLN +#define TRMM_RNUU XTRMM_RNUU +#define TRMM_RNUN XTRMM_RNUN +#define TRMM_RNLU XTRMM_RNLU +#define TRMM_RNLN XTRMM_RNLN +#define TRMM_RTUU XTRMM_RTUU +#define TRMM_RTUN XTRMM_RTUN +#define TRMM_RTLU XTRMM_RTLU +#define TRMM_RTLN XTRMM_RTLN +#define TRMM_RRUU XTRMM_RRUU +#define TRMM_RRUN XTRMM_RRUN +#define TRMM_RRLU XTRMM_RRLU +#define TRMM_RRLN XTRMM_RRLN +#define TRMM_RCUU XTRMM_RCUU +#define TRMM_RCUN XTRMM_RCUN +#define TRMM_RCLU XTRMM_RCLU +#define TRMM_RCLN XTRMM_RCLN + +#define TRSM_LNUU XTRSM_LNUU +#define TRSM_LNUN XTRSM_LNUN +#define TRSM_LNLU XTRSM_LNLU +#define TRSM_LNLN XTRSM_LNLN +#define TRSM_LTUU XTRSM_LTUU +#define TRSM_LTUN XTRSM_LTUN +#define TRSM_LTLU XTRSM_LTLU +#define TRSM_LTLN XTRSM_LTLN +#define TRSM_LRUU XTRSM_LRUU +#define TRSM_LRUN XTRSM_LRUN +#define TRSM_LRLU XTRSM_LRLU +#define TRSM_LRLN XTRSM_LRLN +#define TRSM_LCUU XTRSM_LCUU +#define TRSM_LCUN XTRSM_LCUN +#define TRSM_LCLU XTRSM_LCLU +#define TRSM_LCLN XTRSM_LCLN +#define TRSM_RNUU XTRSM_RNUU +#define TRSM_RNUN XTRSM_RNUN +#define TRSM_RNLU XTRSM_RNLU +#define TRSM_RNLN XTRSM_RNLN +#define TRSM_RTUU XTRSM_RTUU +#define TRSM_RTUN XTRSM_RTUN +#define TRSM_RTLU XTRSM_RTLU +#define TRSM_RTLN XTRSM_RTLN +#define TRSM_RRUU XTRSM_RRUU +#define TRSM_RRUN XTRSM_RRUN +#define TRSM_RRLU XTRSM_RRLU +#define TRSM_RRLN XTRSM_RRLN +#define TRSM_RCUU XTRSM_RCUU +#define TRSM_RCUN XTRSM_RCUN +#define TRSM_RCLU XTRSM_RCLU +#define TRSM_RCLN XTRSM_RCLN + + +#define GEMM_THREAD_NN XGEMM_THREAD_NN +#define GEMM_THREAD_CN XGEMM_THREAD_CN +#define GEMM_THREAD_TN XGEMM_THREAD_TN +#define GEMM_THREAD_NC XGEMM_THREAD_NC +#define GEMM_THREAD_NT XGEMM_THREAD_NT +#define GEMM_THREAD_CC XGEMM_THREAD_CC +#define GEMM_THREAD_CT XGEMM_THREAD_CT +#define GEMM_THREAD_TC XGEMM_THREAD_TC +#define GEMM_THREAD_TT XGEMM_THREAD_TT +#define GEMM_THREAD_NR XGEMM_THREAD_NR +#define GEMM_THREAD_TR XGEMM_THREAD_TR +#define GEMM_THREAD_CR XGEMM_THREAD_CR +#define GEMM_THREAD_RN XGEMM_THREAD_RN +#define GEMM_THREAD_RT XGEMM_THREAD_RT +#define GEMM_THREAD_RC XGEMM_THREAD_RC +#define GEMM_THREAD_RR XGEMM_THREAD_RR + +#define SYMM_THREAD_LU XSYMM_THREAD_LU +#define SYMM_THREAD_LL XSYMM_THREAD_LL +#define SYMM_THREAD_RU XSYMM_THREAD_RU +#define SYMM_THREAD_RL XSYMM_THREAD_RL + +#define HEMM_THREAD_LU XHEMM_THREAD_LU +#define HEMM_THREAD_LL XHEMM_THREAD_LL +#define HEMM_THREAD_RU XHEMM_THREAD_RU +#define HEMM_THREAD_RL XHEMM_THREAD_RL + +#define SYRK_THREAD_UN XSYRK_THREAD_UN +#define SYRK_THREAD_UT XSYRK_THREAD_UT +#define SYRK_THREAD_LN XSYRK_THREAD_LN +#define SYRK_THREAD_LT XSYRK_THREAD_LT +#define SYRK_THREAD_UR XSYRK_THREAD_UR +#define SYRK_THREAD_UC XSYRK_THREAD_UC +#define SYRK_THREAD_LR XSYRK_THREAD_LR +#define SYRK_THREAD_LC XSYRK_THREAD_LC + +#define HERK_THREAD_UN XHERK_THREAD_UN +#define HERK_THREAD_UT XHERK_THREAD_UT +#define HERK_THREAD_LN XHERK_THREAD_LN +#define HERK_THREAD_LT XHERK_THREAD_LT +#define HERK_THREAD_UR XHERK_THREAD_UR +#define HERK_THREAD_UC XHERK_THREAD_UC +#define HERK_THREAD_LR XHERK_THREAD_LR +#define HERK_THREAD_LC XHERK_THREAD_LC + +#define GEMM3M_NN XGEMM3M_NN +#define GEMM3M_CN XGEMM3M_CN +#define GEMM3M_TN XGEMM3M_TN +#define GEMM3M_NC XGEMM3M_NC +#define GEMM3M_NT XGEMM3M_NT +#define GEMM3M_CC XGEMM3M_CC +#define GEMM3M_CT XGEMM3M_CT +#define GEMM3M_TC XGEMM3M_TC +#define GEMM3M_TT XGEMM3M_TT +#define GEMM3M_NR XGEMM3M_NR +#define GEMM3M_TR XGEMM3M_TR +#define GEMM3M_CR XGEMM3M_CR +#define GEMM3M_RN XGEMM3M_RN +#define GEMM3M_RT XGEMM3M_RT +#define GEMM3M_RC XGEMM3M_RC +#define GEMM3M_RR XGEMM3M_RR + +#define GEMM3M_THREAD_NN XGEMM3M_THREAD_NN +#define GEMM3M_THREAD_CN XGEMM3M_THREAD_CN +#define GEMM3M_THREAD_TN XGEMM3M_THREAD_TN +#define GEMM3M_THREAD_NC XGEMM3M_THREAD_NC +#define GEMM3M_THREAD_NT XGEMM3M_THREAD_NT +#define GEMM3M_THREAD_CC XGEMM3M_THREAD_CC +#define GEMM3M_THREAD_CT XGEMM3M_THREAD_CT +#define GEMM3M_THREAD_TC XGEMM3M_THREAD_TC +#define GEMM3M_THREAD_TT XGEMM3M_THREAD_TT +#define GEMM3M_THREAD_NR XGEMM3M_THREAD_NR +#define GEMM3M_THREAD_TR XGEMM3M_THREAD_TR +#define GEMM3M_THREAD_CR XGEMM3M_THREAD_CR +#define GEMM3M_THREAD_RN XGEMM3M_THREAD_RN +#define GEMM3M_THREAD_RT XGEMM3M_THREAD_RT +#define GEMM3M_THREAD_RC XGEMM3M_THREAD_RC +#define GEMM3M_THREAD_RR XGEMM3M_THREAD_RR + +#define SYMM3M_LU XSYMM3M_LU +#define SYMM3M_LL XSYMM3M_LL +#define SYMM3M_RU XSYMM3M_RU +#define SYMM3M_RL XSYMM3M_RL + +#define SYMM3M_THREAD_LU XSYMM3M_THREAD_LU +#define SYMM3M_THREAD_LL XSYMM3M_THREAD_LL +#define SYMM3M_THREAD_RU XSYMM3M_THREAD_RU +#define SYMM3M_THREAD_RL XSYMM3M_THREAD_RL + +#define HEMM3M_LU XHEMM3M_LU +#define HEMM3M_LL XHEMM3M_LL +#define HEMM3M_RU XHEMM3M_RU +#define HEMM3M_RL XHEMM3M_RL + +#define HEMM3M_THREAD_LU XHEMM3M_THREAD_LU +#define HEMM3M_THREAD_LL XHEMM3M_THREAD_LL +#define HEMM3M_THREAD_RU XHEMM3M_THREAD_RU +#define HEMM3M_THREAD_RL XHEMM3M_THREAD_RL + +#define SYMM_IUTCOPY XSYMM_IUTCOPY +#define SYMM_ILTCOPY XSYMM_ILTCOPY +#define SYMM_OUTCOPY XSYMM_OUTCOPY +#define SYMM_OLTCOPY XSYMM_OLTCOPY + +#elif defined(DOUBLE) + +#define AMAX_K ZAMAX_K +#define AMIN_K ZAMIN_K +#define MAX_K ZMAX_K +#define MIN_K ZMIN_K +#define IAMAX_K IZAMAX_K +#define IAMIN_K IZAMIN_K +#define IMAX_K IZMAX_K +#define IMIN_K IZMIN_K +#define ASUM_K ZASUM_K +#define AXPYU_K ZAXPYU_K +#define AXPYC_K ZAXPYC_K +#define COPY_K ZCOPY_K +#define DOTU_K ZDOTU_K +#define DOTC_K ZDOTC_K +#define NRM2_K ZNRM2_K +#define SCAL_K ZSCAL_K +#define SWAP_K ZSWAP_K +#define ROT_K ZROT_K + +#define GEMV_N ZGEMV_N +#define GEMV_T ZGEMV_T +#define GEMV_R ZGEMV_R +#define GEMV_C ZGEMV_C +#define GEMV_O ZGEMV_O +#define GEMV_U ZGEMV_U +#define GEMV_S ZGEMV_S +#define GEMV_D ZGEMV_D + +#define GERU_K ZGERU_K +#define GERC_K ZGERC_K +#define GERV_K ZGERV_K +#define GERD_K ZGERD_K + +#define SYMV_U ZSYMV_U +#define SYMV_L ZSYMV_L +#define HEMV_U ZHEMV_U +#define HEMV_L ZHEMV_L +#define HEMV_V ZHEMV_V +#define HEMV_M ZHEMV_M + +#define SYMV_THREAD_U ZSYMV_THREAD_U +#define SYMV_THREAD_L ZSYMV_THREAD_L +#define HEMV_THREAD_U ZHEMV_THREAD_U +#define HEMV_THREAD_L ZHEMV_THREAD_L +#define HEMV_THREAD_V ZHEMV_THREAD_V +#define HEMV_THREAD_M ZHEMV_THREAD_M + +#define GEMM_ONCOPY ZGEMM_ONCOPY +#define GEMM_OTCOPY ZGEMM_OTCOPY +#define GEMM_INCOPY ZGEMM_INCOPY +#define GEMM_ITCOPY ZGEMM_ITCOPY + +#define GEMM3M_ONCOPYB ZGEMM3M_ONCOPYB +#define GEMM3M_ONCOPYR ZGEMM3M_ONCOPYR +#define GEMM3M_ONCOPYI ZGEMM3M_ONCOPYI +#define GEMM3M_OTCOPYB ZGEMM3M_OTCOPYB +#define GEMM3M_OTCOPYR ZGEMM3M_OTCOPYR +#define GEMM3M_OTCOPYI ZGEMM3M_OTCOPYI +#define GEMM3M_INCOPYB ZGEMM3M_INCOPYB +#define GEMM3M_INCOPYR ZGEMM3M_INCOPYR +#define GEMM3M_INCOPYI ZGEMM3M_INCOPYI +#define GEMM3M_ITCOPYB ZGEMM3M_ITCOPYB +#define GEMM3M_ITCOPYR ZGEMM3M_ITCOPYR +#define GEMM3M_ITCOPYI ZGEMM3M_ITCOPYI + +#ifdef UNIT + +#define TRMM_OUNCOPY ZTRMM_OUNUCOPY +#define TRMM_OUTCOPY ZTRMM_OUTUCOPY +#define TRMM_OLNCOPY ZTRMM_OLNUCOPY +#define TRMM_OLTCOPY ZTRMM_OLTUCOPY +#define TRSM_OUNCOPY ZTRSM_OUNUCOPY +#define TRSM_OUTCOPY ZTRSM_OUTUCOPY +#define TRSM_OLNCOPY ZTRSM_OLNUCOPY +#define TRSM_OLTCOPY ZTRSM_OLTUCOPY + +#define TRMM_IUNCOPY ZTRMM_IUNUCOPY +#define TRMM_IUTCOPY ZTRMM_IUTUCOPY +#define TRMM_ILNCOPY ZTRMM_ILNUCOPY +#define TRMM_ILTCOPY ZTRMM_ILTUCOPY +#define TRSM_IUNCOPY ZTRSM_IUNUCOPY +#define TRSM_IUTCOPY ZTRSM_IUTUCOPY +#define TRSM_ILNCOPY ZTRSM_ILNUCOPY +#define TRSM_ILTCOPY ZTRSM_ILTUCOPY + +#else + +#define TRMM_OUNCOPY ZTRMM_OUNNCOPY +#define TRMM_OUTCOPY ZTRMM_OUTNCOPY +#define TRMM_OLNCOPY ZTRMM_OLNNCOPY +#define TRMM_OLTCOPY ZTRMM_OLTNCOPY +#define TRSM_OUNCOPY ZTRSM_OUNNCOPY +#define TRSM_OUTCOPY ZTRSM_OUTNCOPY +#define TRSM_OLNCOPY ZTRSM_OLNNCOPY +#define TRSM_OLTCOPY ZTRSM_OLTNCOPY + +#define TRMM_IUNCOPY ZTRMM_IUNNCOPY +#define TRMM_IUTCOPY ZTRMM_IUTNCOPY +#define TRMM_ILNCOPY ZTRMM_ILNNCOPY +#define TRMM_ILTCOPY ZTRMM_ILTNCOPY +#define TRSM_IUNCOPY ZTRSM_IUNNCOPY +#define TRSM_IUTCOPY ZTRSM_IUTNCOPY +#define TRSM_ILNCOPY ZTRSM_ILNNCOPY +#define TRSM_ILTCOPY ZTRSM_ILTNCOPY + +#endif + +#define SYMM3M_ILCOPYB ZSYMM3M_ILCOPYB +#define SYMM3M_IUCOPYB ZSYMM3M_IUCOPYB +#define SYMM3M_ILCOPYR ZSYMM3M_ILCOPYR +#define SYMM3M_IUCOPYR ZSYMM3M_IUCOPYR +#define SYMM3M_ILCOPYI ZSYMM3M_ILCOPYI +#define SYMM3M_IUCOPYI ZSYMM3M_IUCOPYI + +#define SYMM3M_OLCOPYB ZSYMM3M_OLCOPYB +#define SYMM3M_OUCOPYB ZSYMM3M_OUCOPYB +#define SYMM3M_OLCOPYR ZSYMM3M_OLCOPYR +#define SYMM3M_OUCOPYR ZSYMM3M_OUCOPYR +#define SYMM3M_OLCOPYI ZSYMM3M_OLCOPYI +#define SYMM3M_OUCOPYI ZSYMM3M_OUCOPYI + +#define HEMM3M_ILCOPYB ZHEMM3M_ILCOPYB +#define HEMM3M_IUCOPYB ZHEMM3M_IUCOPYB +#define HEMM3M_ILCOPYR ZHEMM3M_ILCOPYR +#define HEMM3M_IUCOPYR ZHEMM3M_IUCOPYR +#define HEMM3M_ILCOPYI ZHEMM3M_ILCOPYI +#define HEMM3M_IUCOPYI ZHEMM3M_IUCOPYI + +#define HEMM3M_OLCOPYB ZHEMM3M_OLCOPYB +#define HEMM3M_OUCOPYB ZHEMM3M_OUCOPYB +#define HEMM3M_OLCOPYR ZHEMM3M_OLCOPYR +#define HEMM3M_OUCOPYR ZHEMM3M_OUCOPYR +#define HEMM3M_OLCOPYI ZHEMM3M_OLCOPYI +#define HEMM3M_OUCOPYI ZHEMM3M_OUCOPYI + +#define GEMM_BETA ZGEMM_BETA + +#define GEMM_KERNEL_N ZGEMM_KERNEL_N +#define GEMM_KERNEL_L ZGEMM_KERNEL_L +#define GEMM_KERNEL_R ZGEMM_KERNEL_R +#define GEMM_KERNEL_B ZGEMM_KERNEL_B + +#define GEMM3M_KERNEL ZGEMM3M_KERNEL + +#define TRMM_KERNEL_LN ZTRMM_KERNEL_LN +#define TRMM_KERNEL_LT ZTRMM_KERNEL_LT +#define TRMM_KERNEL_LR ZTRMM_KERNEL_LR +#define TRMM_KERNEL_LC ZTRMM_KERNEL_LC +#define TRMM_KERNEL_RN ZTRMM_KERNEL_RN +#define TRMM_KERNEL_RT ZTRMM_KERNEL_RT +#define TRMM_KERNEL_RR ZTRMM_KERNEL_RR +#define TRMM_KERNEL_RC ZTRMM_KERNEL_RC + +#define TRSM_KERNEL_LN ZTRSM_KERNEL_LN +#define TRSM_KERNEL_LT ZTRSM_KERNEL_LT +#define TRSM_KERNEL_LR ZTRSM_KERNEL_LR +#define TRSM_KERNEL_LC ZTRSM_KERNEL_LC +#define TRSM_KERNEL_RN ZTRSM_KERNEL_RN +#define TRSM_KERNEL_RT ZTRSM_KERNEL_RT +#define TRSM_KERNEL_RR ZTRSM_KERNEL_RR +#define TRSM_KERNEL_RC ZTRSM_KERNEL_RC + +#define GEMM_NN ZGEMM_NN +#define GEMM_CN ZGEMM_CN +#define GEMM_TN ZGEMM_TN +#define GEMM_NC ZGEMM_NC +#define GEMM_NT ZGEMM_NT +#define GEMM_CC ZGEMM_CC +#define GEMM_CT ZGEMM_CT +#define GEMM_TC ZGEMM_TC +#define GEMM_TT ZGEMM_TT +#define GEMM_NR ZGEMM_NR +#define GEMM_TR ZGEMM_TR +#define GEMM_CR ZGEMM_CR +#define GEMM_RN ZGEMM_RN +#define GEMM_RT ZGEMM_RT +#define GEMM_RC ZGEMM_RC +#define GEMM_RR ZGEMM_RR + +#define SYMM_LU ZSYMM_LU +#define SYMM_LL ZSYMM_LL +#define SYMM_RU ZSYMM_RU +#define SYMM_RL ZSYMM_RL + +#define HEMM_LU ZHEMM_LU +#define HEMM_LL ZHEMM_LL +#define HEMM_RU ZHEMM_RU +#define HEMM_RL ZHEMM_RL + +#define HEMM_IUTCOPY ZHEMM_IUTCOPY +#define HEMM_ILTCOPY ZHEMM_ILTCOPY +#define HEMM_OUTCOPY ZHEMM_OUTCOPY +#define HEMM_OLTCOPY ZHEMM_OLTCOPY + +#define SYRK_UN ZSYRK_UN +#define SYRK_UT ZSYRK_UT +#define SYRK_LN ZSYRK_LN +#define SYRK_LT ZSYRK_LT +#define SYRK_UR ZSYRK_UN +#define SYRK_UC ZSYRK_UT +#define SYRK_LR ZSYRK_LN +#define SYRK_LC ZSYRK_LT + +#define SYRK_KERNEL_U ZSYRK_KERNEL_U +#define SYRK_KERNEL_L ZSYRK_KERNEL_L + +#define HERK_UN ZHERK_UN +#define HERK_LN ZHERK_LN +#define HERK_UC ZHERK_UC +#define HERK_LC ZHERK_LC + +#define HER2K_UN ZHER2K_UN +#define HER2K_LN ZHER2K_LN +#define HER2K_UC ZHER2K_UC +#define HER2K_LC ZHER2K_LC + +#define SYR2K_UN ZSYR2K_UN +#define SYR2K_UT ZSYR2K_UT +#define SYR2K_LN ZSYR2K_LN +#define SYR2K_LT ZSYR2K_LT +#define SYR2K_UR ZSYR2K_UN +#define SYR2K_UC ZSYR2K_UT +#define SYR2K_LR ZSYR2K_LN +#define SYR2K_LC ZSYR2K_LT + +#define SYR2K_KERNEL_U ZSYR2K_KERNEL_U +#define SYR2K_KERNEL_L ZSYR2K_KERNEL_L + +#define TRMM_LNUU ZTRMM_LNUU +#define TRMM_LNUN ZTRMM_LNUN +#define TRMM_LNLU ZTRMM_LNLU +#define TRMM_LNLN ZTRMM_LNLN +#define TRMM_LTUU ZTRMM_LTUU +#define TRMM_LTUN ZTRMM_LTUN +#define TRMM_LTLU ZTRMM_LTLU +#define TRMM_LTLN ZTRMM_LTLN +#define TRMM_LRUU ZTRMM_LRUU +#define TRMM_LRUN ZTRMM_LRUN +#define TRMM_LRLU ZTRMM_LRLU +#define TRMM_LRLN ZTRMM_LRLN +#define TRMM_LCUU ZTRMM_LCUU +#define TRMM_LCUN ZTRMM_LCUN +#define TRMM_LCLU ZTRMM_LCLU +#define TRMM_LCLN ZTRMM_LCLN +#define TRMM_RNUU ZTRMM_RNUU +#define TRMM_RNUN ZTRMM_RNUN +#define TRMM_RNLU ZTRMM_RNLU +#define TRMM_RNLN ZTRMM_RNLN +#define TRMM_RTUU ZTRMM_RTUU +#define TRMM_RTUN ZTRMM_RTUN +#define TRMM_RTLU ZTRMM_RTLU +#define TRMM_RTLN ZTRMM_RTLN +#define TRMM_RRUU ZTRMM_RRUU +#define TRMM_RRUN ZTRMM_RRUN +#define TRMM_RRLU ZTRMM_RRLU +#define TRMM_RRLN ZTRMM_RRLN +#define TRMM_RCUU ZTRMM_RCUU +#define TRMM_RCUN ZTRMM_RCUN +#define TRMM_RCLU ZTRMM_RCLU +#define TRMM_RCLN ZTRMM_RCLN + +#define TRSM_LNUU ZTRSM_LNUU +#define TRSM_LNUN ZTRSM_LNUN +#define TRSM_LNLU ZTRSM_LNLU +#define TRSM_LNLN ZTRSM_LNLN +#define TRSM_LTUU ZTRSM_LTUU +#define TRSM_LTUN ZTRSM_LTUN +#define TRSM_LTLU ZTRSM_LTLU +#define TRSM_LTLN ZTRSM_LTLN +#define TRSM_LRUU ZTRSM_LRUU +#define TRSM_LRUN ZTRSM_LRUN +#define TRSM_LRLU ZTRSM_LRLU +#define TRSM_LRLN ZTRSM_LRLN +#define TRSM_LCUU ZTRSM_LCUU +#define TRSM_LCUN ZTRSM_LCUN +#define TRSM_LCLU ZTRSM_LCLU +#define TRSM_LCLN ZTRSM_LCLN +#define TRSM_RNUU ZTRSM_RNUU +#define TRSM_RNUN ZTRSM_RNUN +#define TRSM_RNLU ZTRSM_RNLU +#define TRSM_RNLN ZTRSM_RNLN +#define TRSM_RTUU ZTRSM_RTUU +#define TRSM_RTUN ZTRSM_RTUN +#define TRSM_RTLU ZTRSM_RTLU +#define TRSM_RTLN ZTRSM_RTLN +#define TRSM_RRUU ZTRSM_RRUU +#define TRSM_RRUN ZTRSM_RRUN +#define TRSM_RRLU ZTRSM_RRLU +#define TRSM_RRLN ZTRSM_RRLN +#define TRSM_RCUU ZTRSM_RCUU +#define TRSM_RCUN ZTRSM_RCUN +#define TRSM_RCLU ZTRSM_RCLU +#define TRSM_RCLN ZTRSM_RCLN + + +#define GEMM_THREAD_NN ZGEMM_THREAD_NN +#define GEMM_THREAD_CN ZGEMM_THREAD_CN +#define GEMM_THREAD_TN ZGEMM_THREAD_TN +#define GEMM_THREAD_NC ZGEMM_THREAD_NC +#define GEMM_THREAD_NT ZGEMM_THREAD_NT +#define GEMM_THREAD_CC ZGEMM_THREAD_CC +#define GEMM_THREAD_CT ZGEMM_THREAD_CT +#define GEMM_THREAD_TC ZGEMM_THREAD_TC +#define GEMM_THREAD_TT ZGEMM_THREAD_TT +#define GEMM_THREAD_NR ZGEMM_THREAD_NR +#define GEMM_THREAD_TR ZGEMM_THREAD_TR +#define GEMM_THREAD_CR ZGEMM_THREAD_CR +#define GEMM_THREAD_RN ZGEMM_THREAD_RN +#define GEMM_THREAD_RT ZGEMM_THREAD_RT +#define GEMM_THREAD_RC ZGEMM_THREAD_RC +#define GEMM_THREAD_RR ZGEMM_THREAD_RR + +#define SYMM_THREAD_LU ZSYMM_THREAD_LU +#define SYMM_THREAD_LL ZSYMM_THREAD_LL +#define SYMM_THREAD_RU ZSYMM_THREAD_RU +#define SYMM_THREAD_RL ZSYMM_THREAD_RL + +#define HEMM_THREAD_LU ZHEMM_THREAD_LU +#define HEMM_THREAD_LL ZHEMM_THREAD_LL +#define HEMM_THREAD_RU ZHEMM_THREAD_RU +#define HEMM_THREAD_RL ZHEMM_THREAD_RL + +#define SYRK_THREAD_UN ZSYRK_THREAD_UN +#define SYRK_THREAD_UT ZSYRK_THREAD_UT +#define SYRK_THREAD_LN ZSYRK_THREAD_LN +#define SYRK_THREAD_LT ZSYRK_THREAD_LT +#define SYRK_THREAD_UR ZSYRK_THREAD_UR +#define SYRK_THREAD_UC ZSYRK_THREAD_UC +#define SYRK_THREAD_LR ZSYRK_THREAD_LR +#define SYRK_THREAD_LC ZSYRK_THREAD_LC + +#define HERK_THREAD_UN ZHERK_THREAD_UN +#define HERK_THREAD_UT ZHERK_THREAD_UT +#define HERK_THREAD_LN ZHERK_THREAD_LN +#define HERK_THREAD_LT ZHERK_THREAD_LT +#define HERK_THREAD_UR ZHERK_THREAD_UR +#define HERK_THREAD_UC ZHERK_THREAD_UC +#define HERK_THREAD_LR ZHERK_THREAD_LR +#define HERK_THREAD_LC ZHERK_THREAD_LC + +#define GEMM3M_NN ZGEMM3M_NN +#define GEMM3M_CN ZGEMM3M_CN +#define GEMM3M_TN ZGEMM3M_TN +#define GEMM3M_NC ZGEMM3M_NC +#define GEMM3M_NT ZGEMM3M_NT +#define GEMM3M_CC ZGEMM3M_CC +#define GEMM3M_CT ZGEMM3M_CT +#define GEMM3M_TC ZGEMM3M_TC +#define GEMM3M_TT ZGEMM3M_TT +#define GEMM3M_NR ZGEMM3M_NR +#define GEMM3M_TR ZGEMM3M_TR +#define GEMM3M_CR ZGEMM3M_CR +#define GEMM3M_RN ZGEMM3M_RN +#define GEMM3M_RT ZGEMM3M_RT +#define GEMM3M_RC ZGEMM3M_RC +#define GEMM3M_RR ZGEMM3M_RR + +#define GEMM3M_THREAD_NN ZGEMM3M_THREAD_NN +#define GEMM3M_THREAD_CN ZGEMM3M_THREAD_CN +#define GEMM3M_THREAD_TN ZGEMM3M_THREAD_TN +#define GEMM3M_THREAD_NC ZGEMM3M_THREAD_NC +#define GEMM3M_THREAD_NT ZGEMM3M_THREAD_NT +#define GEMM3M_THREAD_CC ZGEMM3M_THREAD_CC +#define GEMM3M_THREAD_CT ZGEMM3M_THREAD_CT +#define GEMM3M_THREAD_TC ZGEMM3M_THREAD_TC +#define GEMM3M_THREAD_TT ZGEMM3M_THREAD_TT +#define GEMM3M_THREAD_NR ZGEMM3M_THREAD_NR +#define GEMM3M_THREAD_TR ZGEMM3M_THREAD_TR +#define GEMM3M_THREAD_CR ZGEMM3M_THREAD_CR +#define GEMM3M_THREAD_RN ZGEMM3M_THREAD_RN +#define GEMM3M_THREAD_RT ZGEMM3M_THREAD_RT +#define GEMM3M_THREAD_RC ZGEMM3M_THREAD_RC +#define GEMM3M_THREAD_RR ZGEMM3M_THREAD_RR + +#define SYMM3M_LU ZSYMM3M_LU +#define SYMM3M_LL ZSYMM3M_LL +#define SYMM3M_RU ZSYMM3M_RU +#define SYMM3M_RL ZSYMM3M_RL + +#define SYMM3M_THREAD_LU ZSYMM3M_THREAD_LU +#define SYMM3M_THREAD_LL ZSYMM3M_THREAD_LL +#define SYMM3M_THREAD_RU ZSYMM3M_THREAD_RU +#define SYMM3M_THREAD_RL ZSYMM3M_THREAD_RL + +#define HEMM3M_LU ZHEMM3M_LU +#define HEMM3M_LL ZHEMM3M_LL +#define HEMM3M_RU ZHEMM3M_RU +#define HEMM3M_RL ZHEMM3M_RL + +#define HEMM3M_THREAD_LU ZHEMM3M_THREAD_LU +#define HEMM3M_THREAD_LL ZHEMM3M_THREAD_LL +#define HEMM3M_THREAD_RU ZHEMM3M_THREAD_RU +#define HEMM3M_THREAD_RL ZHEMM3M_THREAD_RL + +#define SYMM_IUTCOPY ZSYMM_IUTCOPY +#define SYMM_ILTCOPY ZSYMM_ILTCOPY +#define SYMM_OUTCOPY ZSYMM_OUTCOPY +#define SYMM_OLTCOPY ZSYMM_OLTCOPY + +#else + +#define AMAX_K CAMAX_K +#define AMIN_K CAMIN_K +#define MAX_K CMAX_K +#define MIN_K CMIN_K +#define IAMAX_K ICAMAX_K +#define IAMIN_K ICAMIN_K +#define IMAX_K ICMAX_K +#define IMIN_K ICMIN_K +#define ASUM_K CASUM_K +#define AXPYU_K CAXPYU_K +#define AXPYC_K CAXPYC_K +#define COPY_K CCOPY_K +#define DOTU_K CDOTU_K +#define DOTC_K CDOTC_K +#define NRM2_K CNRM2_K +#define SCAL_K CSCAL_K +#define SWAP_K CSWAP_K +#define ROT_K CROT_K + +#define GEMV_N CGEMV_N +#define GEMV_T CGEMV_T +#define GEMV_R CGEMV_R +#define GEMV_C CGEMV_C +#define GEMV_O CGEMV_O +#define GEMV_U CGEMV_U +#define GEMV_S CGEMV_S +#define GEMV_D CGEMV_D + +#define GERU_K CGERU_K +#define GERC_K CGERC_K +#define GERV_K CGERV_K +#define GERD_K CGERD_K + +#define SYMV_U CSYMV_U +#define SYMV_L CSYMV_L +#define HEMV_U CHEMV_U +#define HEMV_L CHEMV_L +#define HEMV_V CHEMV_V +#define HEMV_M CHEMV_M + +#define SYMV_THREAD_U CSYMV_THREAD_U +#define SYMV_THREAD_L CSYMV_THREAD_L +#define HEMV_THREAD_U CHEMV_THREAD_U +#define HEMV_THREAD_L CHEMV_THREAD_L +#define HEMV_THREAD_V CHEMV_THREAD_V +#define HEMV_THREAD_M CHEMV_THREAD_M + +#define GEMM_ONCOPY CGEMM_ONCOPY +#define GEMM_OTCOPY CGEMM_OTCOPY +#define GEMM_INCOPY CGEMM_INCOPY +#define GEMM_ITCOPY CGEMM_ITCOPY + +#define GEMM3M_ONCOPYB CGEMM3M_ONCOPYB +#define GEMM3M_ONCOPYR CGEMM3M_ONCOPYR +#define GEMM3M_ONCOPYI CGEMM3M_ONCOPYI +#define GEMM3M_OTCOPYB CGEMM3M_OTCOPYB +#define GEMM3M_OTCOPYR CGEMM3M_OTCOPYR +#define GEMM3M_OTCOPYI CGEMM3M_OTCOPYI +#define GEMM3M_INCOPYB CGEMM3M_INCOPYB +#define GEMM3M_INCOPYR CGEMM3M_INCOPYR +#define GEMM3M_INCOPYI CGEMM3M_INCOPYI +#define GEMM3M_ITCOPYB CGEMM3M_ITCOPYB +#define GEMM3M_ITCOPYR CGEMM3M_ITCOPYR +#define GEMM3M_ITCOPYI CGEMM3M_ITCOPYI + +#ifdef UNIT + +#define TRMM_OUNCOPY CTRMM_OUNUCOPY +#define TRMM_OUTCOPY CTRMM_OUTUCOPY +#define TRMM_OLNCOPY CTRMM_OLNUCOPY +#define TRMM_OLTCOPY CTRMM_OLTUCOPY +#define TRSM_OUNCOPY CTRSM_OUNUCOPY +#define TRSM_OUTCOPY CTRSM_OUTUCOPY +#define TRSM_OLNCOPY CTRSM_OLNUCOPY +#define TRSM_OLTCOPY CTRSM_OLTUCOPY + +#define TRMM_IUNCOPY CTRMM_IUNUCOPY +#define TRMM_IUTCOPY CTRMM_IUTUCOPY +#define TRMM_ILNCOPY CTRMM_ILNUCOPY +#define TRMM_ILTCOPY CTRMM_ILTUCOPY +#define TRSM_IUNCOPY CTRSM_IUNUCOPY +#define TRSM_IUTCOPY CTRSM_IUTUCOPY +#define TRSM_ILNCOPY CTRSM_ILNUCOPY +#define TRSM_ILTCOPY CTRSM_ILTUCOPY + +#else + +#define TRMM_OUNCOPY CTRMM_OUNNCOPY +#define TRMM_OUTCOPY CTRMM_OUTNCOPY +#define TRMM_OLNCOPY CTRMM_OLNNCOPY +#define TRMM_OLTCOPY CTRMM_OLTNCOPY +#define TRSM_OUNCOPY CTRSM_OUNNCOPY +#define TRSM_OUTCOPY CTRSM_OUTNCOPY +#define TRSM_OLNCOPY CTRSM_OLNNCOPY +#define TRSM_OLTCOPY CTRSM_OLTNCOPY + +#define TRMM_IUNCOPY CTRMM_IUNNCOPY +#define TRMM_IUTCOPY CTRMM_IUTNCOPY +#define TRMM_ILNCOPY CTRMM_ILNNCOPY +#define TRMM_ILTCOPY CTRMM_ILTNCOPY +#define TRSM_IUNCOPY CTRSM_IUNNCOPY +#define TRSM_IUTCOPY CTRSM_IUTNCOPY +#define TRSM_ILNCOPY CTRSM_ILNNCOPY +#define TRSM_ILTCOPY CTRSM_ILTNCOPY + +#endif + +#define SYMM3M_ILCOPYB CSYMM3M_ILCOPYB +#define SYMM3M_IUCOPYB CSYMM3M_IUCOPYB +#define SYMM3M_ILCOPYR CSYMM3M_ILCOPYR +#define SYMM3M_IUCOPYR CSYMM3M_IUCOPYR +#define SYMM3M_ILCOPYI CSYMM3M_ILCOPYI +#define SYMM3M_IUCOPYI CSYMM3M_IUCOPYI + +#define SYMM3M_OLCOPYB CSYMM3M_OLCOPYB +#define SYMM3M_OUCOPYB CSYMM3M_OUCOPYB +#define SYMM3M_OLCOPYR CSYMM3M_OLCOPYR +#define SYMM3M_OUCOPYR CSYMM3M_OUCOPYR +#define SYMM3M_OLCOPYI CSYMM3M_OLCOPYI +#define SYMM3M_OUCOPYI CSYMM3M_OUCOPYI + +#define HEMM3M_ILCOPYB CHEMM3M_ILCOPYB +#define HEMM3M_IUCOPYB CHEMM3M_IUCOPYB +#define HEMM3M_ILCOPYR CHEMM3M_ILCOPYR +#define HEMM3M_IUCOPYR CHEMM3M_IUCOPYR +#define HEMM3M_ILCOPYI CHEMM3M_ILCOPYI +#define HEMM3M_IUCOPYI CHEMM3M_IUCOPYI + +#define HEMM3M_OLCOPYB CHEMM3M_OLCOPYB +#define HEMM3M_OUCOPYB CHEMM3M_OUCOPYB +#define HEMM3M_OLCOPYR CHEMM3M_OLCOPYR +#define HEMM3M_OUCOPYR CHEMM3M_OUCOPYR +#define HEMM3M_OLCOPYI CHEMM3M_OLCOPYI +#define HEMM3M_OUCOPYI CHEMM3M_OUCOPYI + +#define GEMM_BETA CGEMM_BETA + +#define GEMM_KERNEL_N CGEMM_KERNEL_N +#define GEMM_KERNEL_L CGEMM_KERNEL_L +#define GEMM_KERNEL_R CGEMM_KERNEL_R +#define GEMM_KERNEL_B CGEMM_KERNEL_B + +#define GEMM3M_KERNEL CGEMM3M_KERNEL + +#define TRMM_KERNEL_LN CTRMM_KERNEL_LN +#define TRMM_KERNEL_LT CTRMM_KERNEL_LT +#define TRMM_KERNEL_LR CTRMM_KERNEL_LR +#define TRMM_KERNEL_LC CTRMM_KERNEL_LC +#define TRMM_KERNEL_RN CTRMM_KERNEL_RN +#define TRMM_KERNEL_RT CTRMM_KERNEL_RT +#define TRMM_KERNEL_RR CTRMM_KERNEL_RR +#define TRMM_KERNEL_RC CTRMM_KERNEL_RC + +#define TRSM_KERNEL_LN CTRSM_KERNEL_LN +#define TRSM_KERNEL_LT CTRSM_KERNEL_LT +#define TRSM_KERNEL_LR CTRSM_KERNEL_LR +#define TRSM_KERNEL_LC CTRSM_KERNEL_LC +#define TRSM_KERNEL_RN CTRSM_KERNEL_RN +#define TRSM_KERNEL_RT CTRSM_KERNEL_RT +#define TRSM_KERNEL_RR CTRSM_KERNEL_RR +#define TRSM_KERNEL_RC CTRSM_KERNEL_RC + +#define GEMM_NN CGEMM_NN +#define GEMM_CN CGEMM_CN +#define GEMM_TN CGEMM_TN +#define GEMM_NC CGEMM_NC +#define GEMM_NT CGEMM_NT +#define GEMM_CC CGEMM_CC +#define GEMM_CT CGEMM_CT +#define GEMM_TC CGEMM_TC +#define GEMM_TT CGEMM_TT +#define GEMM_NR CGEMM_NR +#define GEMM_TR CGEMM_TR +#define GEMM_CR CGEMM_CR +#define GEMM_RN CGEMM_RN +#define GEMM_RT CGEMM_RT +#define GEMM_RC CGEMM_RC +#define GEMM_RR CGEMM_RR + +#define SYMM_LU CSYMM_LU +#define SYMM_LL CSYMM_LL +#define SYMM_RU CSYMM_RU +#define SYMM_RL CSYMM_RL + +#define HEMM_LU CHEMM_LU +#define HEMM_LL CHEMM_LL +#define HEMM_RU CHEMM_RU +#define HEMM_RL CHEMM_RL + +#define HEMM_IUTCOPY CHEMM_IUTCOPY +#define HEMM_ILTCOPY CHEMM_ILTCOPY +#define HEMM_OUTCOPY CHEMM_OUTCOPY +#define HEMM_OLTCOPY CHEMM_OLTCOPY + +#define SYRK_UN CSYRK_UN +#define SYRK_UT CSYRK_UT +#define SYRK_LN CSYRK_LN +#define SYRK_LT CSYRK_LT +#define SYRK_UR CSYRK_UN +#define SYRK_UC CSYRK_UT +#define SYRK_LR CSYRK_LN +#define SYRK_LC CSYRK_LT + +#define SYRK_KERNEL_U CSYRK_KERNEL_U +#define SYRK_KERNEL_L CSYRK_KERNEL_L + +#define HERK_UN CHERK_UN +#define HERK_LN CHERK_LN +#define HERK_UC CHERK_UC +#define HERK_LC CHERK_LC + +#define HER2K_UN CHER2K_UN +#define HER2K_LN CHER2K_LN +#define HER2K_UC CHER2K_UC +#define HER2K_LC CHER2K_LC + +#define SYR2K_UN CSYR2K_UN +#define SYR2K_UT CSYR2K_UT +#define SYR2K_LN CSYR2K_LN +#define SYR2K_LT CSYR2K_LT +#define SYR2K_UR CSYR2K_UN +#define SYR2K_UC CSYR2K_UT +#define SYR2K_LR CSYR2K_LN +#define SYR2K_LC CSYR2K_LT + +#define SYR2K_KERNEL_U CSYR2K_KERNEL_U +#define SYR2K_KERNEL_L CSYR2K_KERNEL_L + +#define TRMM_LNUU CTRMM_LNUU +#define TRMM_LNUN CTRMM_LNUN +#define TRMM_LNLU CTRMM_LNLU +#define TRMM_LNLN CTRMM_LNLN +#define TRMM_LTUU CTRMM_LTUU +#define TRMM_LTUN CTRMM_LTUN +#define TRMM_LTLU CTRMM_LTLU +#define TRMM_LTLN CTRMM_LTLN +#define TRMM_LRUU CTRMM_LRUU +#define TRMM_LRUN CTRMM_LRUN +#define TRMM_LRLU CTRMM_LRLU +#define TRMM_LRLN CTRMM_LRLN +#define TRMM_LCUU CTRMM_LCUU +#define TRMM_LCUN CTRMM_LCUN +#define TRMM_LCLU CTRMM_LCLU +#define TRMM_LCLN CTRMM_LCLN +#define TRMM_RNUU CTRMM_RNUU +#define TRMM_RNUN CTRMM_RNUN +#define TRMM_RNLU CTRMM_RNLU +#define TRMM_RNLN CTRMM_RNLN +#define TRMM_RTUU CTRMM_RTUU +#define TRMM_RTUN CTRMM_RTUN +#define TRMM_RTLU CTRMM_RTLU +#define TRMM_RTLN CTRMM_RTLN +#define TRMM_RRUU CTRMM_RRUU +#define TRMM_RRUN CTRMM_RRUN +#define TRMM_RRLU CTRMM_RRLU +#define TRMM_RRLN CTRMM_RRLN +#define TRMM_RCUU CTRMM_RCUU +#define TRMM_RCUN CTRMM_RCUN +#define TRMM_RCLU CTRMM_RCLU +#define TRMM_RCLN CTRMM_RCLN + +#define TRSM_LNUU CTRSM_LNUU +#define TRSM_LNUN CTRSM_LNUN +#define TRSM_LNLU CTRSM_LNLU +#define TRSM_LNLN CTRSM_LNLN +#define TRSM_LTUU CTRSM_LTUU +#define TRSM_LTUN CTRSM_LTUN +#define TRSM_LTLU CTRSM_LTLU +#define TRSM_LTLN CTRSM_LTLN +#define TRSM_LRUU CTRSM_LRUU +#define TRSM_LRUN CTRSM_LRUN +#define TRSM_LRLU CTRSM_LRLU +#define TRSM_LRLN CTRSM_LRLN +#define TRSM_LCUU CTRSM_LCUU +#define TRSM_LCUN CTRSM_LCUN +#define TRSM_LCLU CTRSM_LCLU +#define TRSM_LCLN CTRSM_LCLN +#define TRSM_RNUU CTRSM_RNUU +#define TRSM_RNUN CTRSM_RNUN +#define TRSM_RNLU CTRSM_RNLU +#define TRSM_RNLN CTRSM_RNLN +#define TRSM_RTUU CTRSM_RTUU +#define TRSM_RTUN CTRSM_RTUN +#define TRSM_RTLU CTRSM_RTLU +#define TRSM_RTLN CTRSM_RTLN +#define TRSM_RRUU CTRSM_RRUU +#define TRSM_RRUN CTRSM_RRUN +#define TRSM_RRLU CTRSM_RRLU +#define TRSM_RRLN CTRSM_RRLN +#define TRSM_RCUU CTRSM_RCUU +#define TRSM_RCUN CTRSM_RCUN +#define TRSM_RCLU CTRSM_RCLU +#define TRSM_RCLN CTRSM_RCLN + + +#define GEMM_THREAD_NN CGEMM_THREAD_NN +#define GEMM_THREAD_CN CGEMM_THREAD_CN +#define GEMM_THREAD_TN CGEMM_THREAD_TN +#define GEMM_THREAD_NC CGEMM_THREAD_NC +#define GEMM_THREAD_NT CGEMM_THREAD_NT +#define GEMM_THREAD_CC CGEMM_THREAD_CC +#define GEMM_THREAD_CT CGEMM_THREAD_CT +#define GEMM_THREAD_TC CGEMM_THREAD_TC +#define GEMM_THREAD_TT CGEMM_THREAD_TT +#define GEMM_THREAD_NR CGEMM_THREAD_NR +#define GEMM_THREAD_TR CGEMM_THREAD_TR +#define GEMM_THREAD_CR CGEMM_THREAD_CR +#define GEMM_THREAD_RN CGEMM_THREAD_RN +#define GEMM_THREAD_RT CGEMM_THREAD_RT +#define GEMM_THREAD_RC CGEMM_THREAD_RC +#define GEMM_THREAD_RR CGEMM_THREAD_RR + +#define SYMM_THREAD_LU CSYMM_THREAD_LU +#define SYMM_THREAD_LL CSYMM_THREAD_LL +#define SYMM_THREAD_RU CSYMM_THREAD_RU +#define SYMM_THREAD_RL CSYMM_THREAD_RL + +#define HEMM_THREAD_LU CHEMM_THREAD_LU +#define HEMM_THREAD_LL CHEMM_THREAD_LL +#define HEMM_THREAD_RU CHEMM_THREAD_RU +#define HEMM_THREAD_RL CHEMM_THREAD_RL + +#define SYRK_THREAD_UN CSYRK_THREAD_UN +#define SYRK_THREAD_UT CSYRK_THREAD_UT +#define SYRK_THREAD_LN CSYRK_THREAD_LN +#define SYRK_THREAD_LT CSYRK_THREAD_LT +#define SYRK_THREAD_UR CSYRK_THREAD_UR +#define SYRK_THREAD_UC CSYRK_THREAD_UC +#define SYRK_THREAD_LR CSYRK_THREAD_LR +#define SYRK_THREAD_LC CSYRK_THREAD_LC + +#define HERK_THREAD_UN CHERK_THREAD_UN +#define HERK_THREAD_UT CHERK_THREAD_UT +#define HERK_THREAD_LN CHERK_THREAD_LN +#define HERK_THREAD_LT CHERK_THREAD_LT +#define HERK_THREAD_UR CHERK_THREAD_UR +#define HERK_THREAD_UC CHERK_THREAD_UC +#define HERK_THREAD_LR CHERK_THREAD_LR +#define HERK_THREAD_LC CHERK_THREAD_LC + +#define GEMM3M_NN CGEMM3M_NN +#define GEMM3M_CN CGEMM3M_CN +#define GEMM3M_TN CGEMM3M_TN +#define GEMM3M_NC CGEMM3M_NC +#define GEMM3M_NT CGEMM3M_NT +#define GEMM3M_CC CGEMM3M_CC +#define GEMM3M_CT CGEMM3M_CT +#define GEMM3M_TC CGEMM3M_TC +#define GEMM3M_TT CGEMM3M_TT +#define GEMM3M_NR CGEMM3M_NR +#define GEMM3M_TR CGEMM3M_TR +#define GEMM3M_CR CGEMM3M_CR +#define GEMM3M_RN CGEMM3M_RN +#define GEMM3M_RT CGEMM3M_RT +#define GEMM3M_RC CGEMM3M_RC +#define GEMM3M_RR CGEMM3M_RR + +#define GEMM3M_THREAD_NN CGEMM3M_THREAD_NN +#define GEMM3M_THREAD_CN CGEMM3M_THREAD_CN +#define GEMM3M_THREAD_TN CGEMM3M_THREAD_TN +#define GEMM3M_THREAD_NC CGEMM3M_THREAD_NC +#define GEMM3M_THREAD_NT CGEMM3M_THREAD_NT +#define GEMM3M_THREAD_CC CGEMM3M_THREAD_CC +#define GEMM3M_THREAD_CT CGEMM3M_THREAD_CT +#define GEMM3M_THREAD_TC CGEMM3M_THREAD_TC +#define GEMM3M_THREAD_TT CGEMM3M_THREAD_TT +#define GEMM3M_THREAD_NR CGEMM3M_THREAD_NR +#define GEMM3M_THREAD_TR CGEMM3M_THREAD_TR +#define GEMM3M_THREAD_CR CGEMM3M_THREAD_CR +#define GEMM3M_THREAD_RN CGEMM3M_THREAD_RN +#define GEMM3M_THREAD_RT CGEMM3M_THREAD_RT +#define GEMM3M_THREAD_RC CGEMM3M_THREAD_RC +#define GEMM3M_THREAD_RR CGEMM3M_THREAD_RR + +#define SYMM3M_LU CSYMM3M_LU +#define SYMM3M_LL CSYMM3M_LL +#define SYMM3M_RU CSYMM3M_RU +#define SYMM3M_RL CSYMM3M_RL + +#define SYMM3M_THREAD_LU CSYMM3M_THREAD_LU +#define SYMM3M_THREAD_LL CSYMM3M_THREAD_LL +#define SYMM3M_THREAD_RU CSYMM3M_THREAD_RU +#define SYMM3M_THREAD_RL CSYMM3M_THREAD_RL + +#define HEMM3M_LU CHEMM3M_LU +#define HEMM3M_LL CHEMM3M_LL +#define HEMM3M_RU CHEMM3M_RU +#define HEMM3M_RL CHEMM3M_RL + +#define HEMM3M_THREAD_LU CHEMM3M_THREAD_LU +#define HEMM3M_THREAD_LL CHEMM3M_THREAD_LL +#define HEMM3M_THREAD_RU CHEMM3M_THREAD_RU +#define HEMM3M_THREAD_RL CHEMM3M_THREAD_RL + +#define SYMM_IUTCOPY CSYMM_IUTCOPY +#define SYMM_ILTCOPY CSYMM_ILTCOPY +#define SYMM_OUTCOPY CSYMM_OUTCOPY +#define SYMM_OLTCOPY CSYMM_OLTCOPY + +#endif +#endif + +#ifndef ASSEMBLER +#if defined(ARCH_X86) || defined(ARCH_X86_64) || defined(ARCH_IA64) +extern BLASLONG sgemm_p; +extern BLASLONG sgemm_q; +extern BLASLONG sgemm_r; +extern BLASLONG dgemm_p; +extern BLASLONG dgemm_q; +extern BLASLONG dgemm_r; +extern BLASLONG qgemm_p; +extern BLASLONG qgemm_q; +extern BLASLONG qgemm_r; +extern BLASLONG cgemm_p; +extern BLASLONG cgemm_q; +extern BLASLONG cgemm_r; +extern BLASLONG zgemm_p; +extern BLASLONG zgemm_q; +extern BLASLONG zgemm_r; +extern BLASLONG xgemm_p; +extern BLASLONG xgemm_q; +extern BLASLONG xgemm_r; +#endif + +typedef struct { + void *a, *b, *c, *d, *alpha, *beta; + BLASLONG m, n, k, lda, ldb, ldc, ldd; + +#ifdef SMP + void *common; + BLASLONG nthreads; +#endif + +#ifdef PARAMTEST + BLASLONG gemm_p, gemm_q, gemm_r; +#endif + +#ifdef PREFETCHTEST + BLASLONG prea, preb, prec, pred; +#endif + +} blas_arg_t; +#endif + +#ifdef XDOUBLE + +#define TRSV_NUU qtrsv_NUU +#define TRSV_NUN qtrsv_NUN +#define TRSV_NLU qtrsv_NLU +#define TRSV_NLN qtrsv_NLN +#define TRSV_TUU qtrsv_TUU +#define TRSV_TUN qtrsv_TUN +#define TRSV_TLU qtrsv_TLU +#define TRSV_TLN qtrsv_TLN + +#define ZTRSV_NUU xtrsv_NUU +#define ZTRSV_NUN xtrsv_NUN +#define ZTRSV_NLU xtrsv_NLU +#define ZTRSV_NLN xtrsv_NLN +#define ZTRSV_TUU xtrsv_TUU +#define ZTRSV_TUN xtrsv_TUN +#define ZTRSV_TLU xtrsv_TLU +#define ZTRSV_TLN xtrsv_TLN +#define ZTRSV_RUU xtrsv_RUU +#define ZTRSV_RUN xtrsv_RUN +#define ZTRSV_RLU xtrsv_RLU +#define ZTRSV_RLN xtrsv_RLN +#define ZTRSV_CUU xtrsv_CUU +#define ZTRSV_CUN xtrsv_CUN +#define ZTRSV_CLU xtrsv_CLU +#define ZTRSV_CLN xtrsv_CLN + +#define TRMV_NUU qtrmv_NUU +#define TRMV_NUN qtrmv_NUN +#define TRMV_NLU qtrmv_NLU +#define TRMV_NLN qtrmv_NLN +#define TRMV_TUU qtrmv_TUU +#define TRMV_TUN qtrmv_TUN +#define TRMV_TLU qtrmv_TLU +#define TRMV_TLN qtrmv_TLN + +#define TRMV_THREAD_NUU qtrmv_thread_NUU +#define TRMV_THREAD_NUN qtrmv_thread_NUN +#define TRMV_THREAD_NLU qtrmv_thread_NLU +#define TRMV_THREAD_NLN qtrmv_thread_NLN +#define TRMV_THREAD_TUU qtrmv_thread_TUU +#define TRMV_THREAD_TUN qtrmv_thread_TUN +#define TRMV_THREAD_TLU qtrmv_thread_TLU +#define TRMV_THREAD_TLN qtrmv_thread_TLN + +#define ZTRMV_NUU xtrmv_NUU +#define ZTRMV_NUN xtrmv_NUN +#define ZTRMV_NLU xtrmv_NLU +#define ZTRMV_NLN xtrmv_NLN +#define ZTRMV_TUU xtrmv_TUU +#define ZTRMV_TUN xtrmv_TUN +#define ZTRMV_TLU xtrmv_TLU +#define ZTRMV_TLN xtrmv_TLN +#define ZTRMV_RUU xtrmv_RUU +#define ZTRMV_RUN xtrmv_RUN +#define ZTRMV_RLU xtrmv_RLU +#define ZTRMV_RLN xtrmv_RLN +#define ZTRMV_CUU xtrmv_CUU +#define ZTRMV_CUN xtrmv_CUN +#define ZTRMV_CLU xtrmv_CLU +#define ZTRMV_CLN xtrmv_CLN + +#define ZTRMV_THREAD_NUU xtrmv_thread_NUU +#define ZTRMV_THREAD_NUN xtrmv_thread_NUN +#define ZTRMV_THREAD_NLU xtrmv_thread_NLU +#define ZTRMV_THREAD_NLN xtrmv_thread_NLN +#define ZTRMV_THREAD_TUU xtrmv_thread_TUU +#define ZTRMV_THREAD_TUN xtrmv_thread_TUN +#define ZTRMV_THREAD_TLU xtrmv_thread_TLU +#define ZTRMV_THREAD_TLN xtrmv_thread_TLN +#define ZTRMV_THREAD_RUU xtrmv_thread_RUU +#define ZTRMV_THREAD_RUN xtrmv_thread_RUN +#define ZTRMV_THREAD_RLU xtrmv_thread_RLU +#define ZTRMV_THREAD_RLN xtrmv_thread_RLN +#define ZTRMV_THREAD_CUU xtrmv_thread_CUU +#define ZTRMV_THREAD_CUN xtrmv_thread_CUN +#define ZTRMV_THREAD_CLU xtrmv_thread_CLU +#define ZTRMV_THREAD_CLN xtrmv_thread_CLN + +#elif defined(DOUBLE) + +#define TRSV_NUU dtrsv_NUU +#define TRSV_NUN dtrsv_NUN +#define TRSV_NLU dtrsv_NLU +#define TRSV_NLN dtrsv_NLN +#define TRSV_TUU dtrsv_TUU +#define TRSV_TUN dtrsv_TUN +#define TRSV_TLU dtrsv_TLU +#define TRSV_TLN dtrsv_TLN + +#define ZTRSV_NUU ztrsv_NUU +#define ZTRSV_NUN ztrsv_NUN +#define ZTRSV_NLU ztrsv_NLU +#define ZTRSV_NLN ztrsv_NLN +#define ZTRSV_TUU ztrsv_TUU +#define ZTRSV_TUN ztrsv_TUN +#define ZTRSV_TLU ztrsv_TLU +#define ZTRSV_TLN ztrsv_TLN +#define ZTRSV_RUU ztrsv_RUU +#define ZTRSV_RUN ztrsv_RUN +#define ZTRSV_RLU ztrsv_RLU +#define ZTRSV_RLN ztrsv_RLN +#define ZTRSV_CUU ztrsv_CUU +#define ZTRSV_CUN ztrsv_CUN +#define ZTRSV_CLU ztrsv_CLU +#define ZTRSV_CLN ztrsv_CLN + +#define TRMV_NUU dtrmv_NUU +#define TRMV_NUN dtrmv_NUN +#define TRMV_NLU dtrmv_NLU +#define TRMV_NLN dtrmv_NLN +#define TRMV_TUU dtrmv_TUU +#define TRMV_TUN dtrmv_TUN +#define TRMV_TLU dtrmv_TLU +#define TRMV_TLN dtrmv_TLN + +#define TRMV_THREAD_NUU dtrmv_thread_NUU +#define TRMV_THREAD_NUN dtrmv_thread_NUN +#define TRMV_THREAD_NLU dtrmv_thread_NLU +#define TRMV_THREAD_NLN dtrmv_thread_NLN +#define TRMV_THREAD_TUU dtrmv_thread_TUU +#define TRMV_THREAD_TUN dtrmv_thread_TUN +#define TRMV_THREAD_TLU dtrmv_thread_TLU +#define TRMV_THREAD_TLN dtrmv_thread_TLN + +#define ZTRMV_NUU ztrmv_NUU +#define ZTRMV_NUN ztrmv_NUN +#define ZTRMV_NLU ztrmv_NLU +#define ZTRMV_NLN ztrmv_NLN +#define ZTRMV_TUU ztrmv_TUU +#define ZTRMV_TUN ztrmv_TUN +#define ZTRMV_TLU ztrmv_TLU +#define ZTRMV_TLN ztrmv_TLN +#define ZTRMV_RUU ztrmv_RUU +#define ZTRMV_RUN ztrmv_RUN +#define ZTRMV_RLU ztrmv_RLU +#define ZTRMV_RLN ztrmv_RLN +#define ZTRMV_CUU ztrmv_CUU +#define ZTRMV_CUN ztrmv_CUN +#define ZTRMV_CLU ztrmv_CLU +#define ZTRMV_CLN ztrmv_CLN + +#define ZTRMV_THREAD_NUU ztrmv_thread_NUU +#define ZTRMV_THREAD_NUN ztrmv_thread_NUN +#define ZTRMV_THREAD_NLU ztrmv_thread_NLU +#define ZTRMV_THREAD_NLN ztrmv_thread_NLN +#define ZTRMV_THREAD_TUU ztrmv_thread_TUU +#define ZTRMV_THREAD_TUN ztrmv_thread_TUN +#define ZTRMV_THREAD_TLU ztrmv_thread_TLU +#define ZTRMV_THREAD_TLN ztrmv_thread_TLN +#define ZTRMV_THREAD_RUU ztrmv_thread_RUU +#define ZTRMV_THREAD_RUN ztrmv_thread_RUN +#define ZTRMV_THREAD_RLU ztrmv_thread_RLU +#define ZTRMV_THREAD_RLN ztrmv_thread_RLN +#define ZTRMV_THREAD_CUU ztrmv_thread_CUU +#define ZTRMV_THREAD_CUN ztrmv_thread_CUN +#define ZTRMV_THREAD_CLU ztrmv_thread_CLU +#define ZTRMV_THREAD_CLN ztrmv_thread_CLN + +#else + +#define TRSV_NUU strsv_NUU +#define TRSV_NUN strsv_NUN +#define TRSV_NLU strsv_NLU +#define TRSV_NLN strsv_NLN +#define TRSV_TUU strsv_TUU +#define TRSV_TUN strsv_TUN +#define TRSV_TLU strsv_TLU +#define TRSV_TLN strsv_TLN + +#define ZTRSV_NUU ctrsv_NUU +#define ZTRSV_NUN ctrsv_NUN +#define ZTRSV_NLU ctrsv_NLU +#define ZTRSV_NLN ctrsv_NLN +#define ZTRSV_TUU ctrsv_TUU +#define ZTRSV_TUN ctrsv_TUN +#define ZTRSV_TLU ctrsv_TLU +#define ZTRSV_TLN ctrsv_TLN +#define ZTRSV_RUU ctrsv_RUU +#define ZTRSV_RUN ctrsv_RUN +#define ZTRSV_RLU ctrsv_RLU +#define ZTRSV_RLN ctrsv_RLN +#define ZTRSV_CUU ctrsv_CUU +#define ZTRSV_CUN ctrsv_CUN +#define ZTRSV_CLU ctrsv_CLU +#define ZTRSV_CLN ctrsv_CLN + +#define TRMV_NUU strmv_NUU +#define TRMV_NUN strmv_NUN +#define TRMV_NLU strmv_NLU +#define TRMV_NLN strmv_NLN +#define TRMV_TUU strmv_TUU +#define TRMV_TUN strmv_TUN +#define TRMV_TLU strmv_TLU +#define TRMV_TLN strmv_TLN + +#define TRMV_THREAD_NUU strmv_thread_NUU +#define TRMV_THREAD_NUN strmv_thread_NUN +#define TRMV_THREAD_NLU strmv_thread_NLU +#define TRMV_THREAD_NLN strmv_thread_NLN +#define TRMV_THREAD_TUU strmv_thread_TUU +#define TRMV_THREAD_TUN strmv_thread_TUN +#define TRMV_THREAD_TLU strmv_thread_TLU +#define TRMV_THREAD_TLN strmv_thread_TLN + +#define ZTRMV_NUU ctrmv_NUU +#define ZTRMV_NUN ctrmv_NUN +#define ZTRMV_NLU ctrmv_NLU +#define ZTRMV_NLN ctrmv_NLN +#define ZTRMV_TUU ctrmv_TUU +#define ZTRMV_TUN ctrmv_TUN +#define ZTRMV_TLU ctrmv_TLU +#define ZTRMV_TLN ctrmv_TLN +#define ZTRMV_RUU ctrmv_RUU +#define ZTRMV_RUN ctrmv_RUN +#define ZTRMV_RLU ctrmv_RLU +#define ZTRMV_RLN ctrmv_RLN +#define ZTRMV_CUU ctrmv_CUU +#define ZTRMV_CUN ctrmv_CUN +#define ZTRMV_CLU ctrmv_CLU +#define ZTRMV_CLN ctrmv_CLN + +#define ZTRMV_THREAD_NUU ctrmv_thread_NUU +#define ZTRMV_THREAD_NUN ctrmv_thread_NUN +#define ZTRMV_THREAD_NLU ctrmv_thread_NLU +#define ZTRMV_THREAD_NLN ctrmv_thread_NLN +#define ZTRMV_THREAD_TUU ctrmv_thread_TUU +#define ZTRMV_THREAD_TUN ctrmv_thread_TUN +#define ZTRMV_THREAD_TLU ctrmv_thread_TLU +#define ZTRMV_THREAD_TLN ctrmv_thread_TLN +#define ZTRMV_THREAD_RUU ctrmv_thread_RUU +#define ZTRMV_THREAD_RUN ctrmv_thread_RUN +#define ZTRMV_THREAD_RLU ctrmv_thread_RLU +#define ZTRMV_THREAD_RLN ctrmv_thread_RLN +#define ZTRMV_THREAD_CUU ctrmv_thread_CUU +#define ZTRMV_THREAD_CUN ctrmv_thread_CUN +#define ZTRMV_THREAD_CLU ctrmv_thread_CLU +#define ZTRMV_THREAD_CLN ctrmv_thread_CLN + +#endif + +#define SGETF2 sgetf2_k +#define DGETF2 dgetf2_k +#define QGETF2 qgetf2_k +#define CGETF2 cgetf2_k +#define ZGETF2 zgetf2_k +#define XGETF2 xgetf2_k + +#define SLASWP_PLUS slaswp_plus +#define SLASWP_MINUS slaswp_minus +#define DLASWP_PLUS dlaswp_plus +#define DLASWP_MINUS dlaswp_minus +#define QLASWP_PLUS qlaswp_plus +#define QLASWP_MINUS qlaswp_minus +#define CLASWP_PLUS claswp_plus +#define CLASWP_MINUS claswp_minus +#define ZLASWP_PLUS zlaswp_plus +#define ZLASWP_MINUS zlaswp_minus +#define XLASWP_PLUS xlaswp_plus +#define XLASWP_MINUS xlaswp_minus + +#define SLARF_L slarf_L +#define SLARF_R slarf_R +#define DLARF_L dlarf_L +#define DLARF_R dlarf_R +#define QLARF_L qlarf_L +#define QLARF_R qlarf_R +#define CLARF_L clarf_L +#define CLARF_R clarf_R +#define ZLARF_L zlarf_L +#define ZLARF_R zlarf_R +#define XLARF_L xlarf_L +#define XLARF_R xlarf_R + +#ifndef COMPLEX +#ifdef XDOUBLE +#define GETF2 QGETF2 +#define GETRF QGETRF +#define GETRS_N_SINGLE qgetrs_N_single +#define GETRS_T_SINGLE qgetrs_T_single +#define GETRS_R_SINGLE qgetrs_N_single +#define GETRS_C_SINGLE qgetrs_T_single +#define GETRS_N_PARALLEL qgetrs_N_parallel +#define GETRS_T_PARALLEL qgetrs_T_parallel +#define GETRS_R_PARALLEL qgetrs_N_parallel +#define GETRS_C_PARALLEL qgetrs_T_parallel +#define LASWP_PLUS QLASWP_PLUS +#define LASWP_MINUS QLASWP_MINUS +#define LASWP_NCOPY QLASWP_NCOPY +#define GETRS_N QGETRS_N +#define GETRS_T QGETRS_T +#define GETRF_SINGLE qgetrf_single +#define GETRF_PARALLEL qgetrf_parallel +#define NEG_TCOPY QNEG_TCOPY +#define LARF_L QLARF_L +#define LARF_R QLARF_R +#elif defined(DOUBLE) +#define GETF2 DGETF2 +#define GETRF DGETRF +#define GETRS_N_SINGLE dgetrs_N_single +#define GETRS_T_SINGLE dgetrs_T_single +#define GETRS_R_SINGLE dgetrs_N_single +#define GETRS_C_SINGLE dgetrs_T_single +#define GETRS_N_PARALLEL dgetrs_N_parallel +#define GETRS_T_PARALLEL dgetrs_T_parallel +#define GETRS_R_PARALLEL dgetrs_N_parallel +#define GETRS_C_PARALLEL dgetrs_T_parallel +#define LASWP_PLUS DLASWP_PLUS +#define LASWP_MINUS DLASWP_MINUS +#define LASWP_NCOPY DLASWP_NCOPY +#define GETRS_N DGETRS_N +#define GETRS_T DGETRS_T +#define GETRF_SINGLE dgetrf_single +#define GETRF_PARALLEL dgetrf_parallel +#define NEG_TCOPY DNEG_TCOPY +#define LARF_L DLARF_L +#define LARF_R DLARF_R +#else +#define GETF2 SGETF2 +#define GETRF SGETRF +#define GETRS_N_SINGLE sgetrs_N_single +#define GETRS_T_SINGLE sgetrs_T_single +#define GETRS_R_SINGLE sgetrs_N_single +#define GETRS_C_SINGLE sgetrs_T_single +#define GETRS_N_PARALLEL sgetrs_N_parallel +#define GETRS_T_PARALLEL sgetrs_T_parallel +#define GETRS_R_PARALLEL sgetrs_N_parallel +#define GETRS_C_PARALLEL sgetrs_T_parallel +#define LASWP_PLUS SLASWP_PLUS +#define LASWP_MINUS SLASWP_MINUS +#define LASWP_NCOPY SLASWP_NCOPY +#define GETRS_N SGETRS_N +#define GETRS_T SGETRS_T +#define GETRF_SINGLE sgetrf_single +#define GETRF_PARALLEL sgetrf_parallel +#define NEG_TCOPY SNEG_TCOPY +#define LARF_L SLARF_L +#define LARF_R SLARF_R +#endif +#else +#ifdef XDOUBLE +#define GETF2 XGETF2 +#define GETRF XGETRF +#define GETRS_N_SINGLE xgetrs_N_single +#define GETRS_T_SINGLE xgetrs_T_single +#define GETRS_R_SINGLE xgetrs_R_single +#define GETRS_C_SINGLE xgetrs_C_single +#define GETRS_N_PARALLEL xgetrs_N_parallel +#define GETRS_T_PARALLEL xgetrs_T_parallel +#define GETRS_R_PARALLEL xgetrs_R_parallel +#define GETRS_C_PARALLEL xgetrs_C_parallel +#define LASWP_PLUS XLASWP_PLUS +#define LASWP_MINUS XLASWP_MINUS +#define LASWP_NCOPY XLASWP_NCOPY +#define GETRS_N XGETRS_N +#define GETRS_T XGETRS_T +#define GETRF_SINGLE xgetrf_single +#define GETRF_PARALLEL xgetrf_parallel +#define NEG_TCOPY XNEG_TCOPY +#define LARF_L XLARF_L +#define LARF_R XLARF_R +#elif defined(DOUBLE) +#define GETF2 ZGETF2 +#define GETRF ZGETRF +#define GETRS_N_SINGLE zgetrs_N_single +#define GETRS_T_SINGLE zgetrs_T_single +#define GETRS_R_SINGLE zgetrs_R_single +#define GETRS_C_SINGLE zgetrs_C_single +#define GETRS_N_PARALLEL zgetrs_N_parallel +#define GETRS_T_PARALLEL zgetrs_T_parallel +#define GETRS_R_PARALLEL zgetrs_R_parallel +#define GETRS_C_PARALLEL zgetrs_C_parallel +#define LASWP_PLUS ZLASWP_PLUS +#define LASWP_MINUS ZLASWP_MINUS +#define LASWP_NCOPY ZLASWP_NCOPY +#define GETRS_N ZGETRS_N +#define GETRS_T ZGETRS_T +#define GETRF_SINGLE zgetrf_single +#define GETRF_PARALLEL zgetrf_parallel +#define NEG_TCOPY ZNEG_TCOPY +#define LARF_L ZLARF_L +#define LARF_R ZLARF_R +#else +#define GETF2 CGETF2 +#define GETRF CGETRF +#define GETRS_N_SINGLE cgetrs_N_single +#define GETRS_T_SINGLE cgetrs_T_single +#define GETRS_R_SINGLE cgetrs_R_single +#define GETRS_C_SINGLE cgetrs_C_single +#define GETRS_N_PARALLEL cgetrs_N_parallel +#define GETRS_T_PARALLEL cgetrs_T_parallel +#define GETRS_R_PARALLEL cgetrs_R_parallel +#define GETRS_C_PARALLEL cgetrs_C_parallel +#define LASWP_PLUS CLASWP_PLUS +#define LASWP_MINUS CLASWP_MINUS +#define LASWP_NCOPY CLASWP_NCOPY +#define GETRS_N CGETRS_N +#define GETRS_T CGETRS_T +#define GETRF_SINGLE cgetrf_single +#define GETRF_PARALLEL cgetrf_parallel +#define NEG_TCOPY CNEG_TCOPY +#define LARF_L CLARF_L +#define LARF_R CLARF_R +#endif +#endif + +#ifndef COMPLEX +#ifdef XDOUBLE +#define POTF2_U qpotf2_U +#define POTF2_L qpotf2_L +#define LAUU2_U qlauu2_U +#define LAUU2_L qlauu2_L +#define POTRF_U_SINGLE qpotrf_U_single +#define POTRF_L_SINGLE qpotrf_L_single +#define POTRF_U_PARALLEL qpotrf_U_parallel +#define POTRF_L_PARALLEL qpotrf_L_parallel +#define LAUUM_U_SINGLE qlauum_U_single +#define LAUUM_L_SINGLE qlauum_L_single +#define LAUUM_U_PARALLEL qlauum_U_parallel +#define LAUUM_L_PARALLEL qlauum_L_parallel +#define TRTI2_UU qtrti2_UU +#define TRTI2_UN qtrti2_UN +#define TRTI2_LU qtrti2_LU +#define TRTI2_LN qtrti2_LN +#define TRTRI_UU_SINGLE qtrtri_UU_single +#define TRTRI_UN_SINGLE qtrtri_UN_single +#define TRTRI_LU_SINGLE qtrtri_LU_single +#define TRTRI_LN_SINGLE qtrtri_LN_single +#define TRTRI_UU_PARALLEL qtrtri_UU_parallel +#define TRTRI_UN_PARALLEL qtrtri_UN_parallel +#define TRTRI_LU_PARALLEL qtrtri_LU_parallel +#define TRTRI_LN_PARALLEL qtrtri_LN_parallel +#elif defined(DOUBLE) +#define POTF2_U dpotf2_U +#define POTF2_L dpotf2_L +#define LAUU2_U dlauu2_U +#define LAUU2_L dlauu2_L +#define POTRF_U_SINGLE dpotrf_U_single +#define POTRF_L_SINGLE dpotrf_L_single +#define POTRF_U_PARALLEL dpotrf_U_parallel +#define POTRF_L_PARALLEL dpotrf_L_parallel +#define LAUUM_U_SINGLE dlauum_U_single +#define LAUUM_L_SINGLE dlauum_L_single +#define LAUUM_U_PARALLEL dlauum_U_parallel +#define LAUUM_L_PARALLEL dlauum_L_parallel +#define TRTI2_UU dtrti2_UU +#define TRTI2_UN dtrti2_UN +#define TRTI2_LU dtrti2_LU +#define TRTI2_LN dtrti2_LN +#define TRTRI_UU_SINGLE dtrtri_UU_single +#define TRTRI_UN_SINGLE dtrtri_UN_single +#define TRTRI_LU_SINGLE dtrtri_LU_single +#define TRTRI_LN_SINGLE dtrtri_LN_single +#define TRTRI_UU_PARALLEL dtrtri_UU_parallel +#define TRTRI_UN_PARALLEL dtrtri_UN_parallel +#define TRTRI_LU_PARALLEL dtrtri_LU_parallel +#define TRTRI_LN_PARALLEL dtrtri_LN_parallel +#else +#define POTF2_U spotf2_U +#define POTF2_L spotf2_L +#define LAUU2_U slauu2_U +#define LAUU2_L slauu2_L +#define POTRF_U_SINGLE spotrf_U_single +#define POTRF_L_SINGLE spotrf_L_single +#define POTRF_U_PARALLEL spotrf_U_parallel +#define POTRF_L_PARALLEL spotrf_L_parallel +#define LAUUM_U_SINGLE slauum_U_single +#define LAUUM_L_SINGLE slauum_L_single +#define LAUUM_U_PARALLEL slauum_U_parallel +#define LAUUM_L_PARALLEL slauum_L_parallel +#define TRTI2_UU strti2_UU +#define TRTI2_UN strti2_UN +#define TRTI2_LU strti2_LU +#define TRTI2_LN strti2_LN +#define TRTRI_UU_SINGLE strtri_UU_single +#define TRTRI_UN_SINGLE strtri_UN_single +#define TRTRI_LU_SINGLE strtri_LU_single +#define TRTRI_LN_SINGLE strtri_LN_single +#define TRTRI_UU_PARALLEL strtri_UU_parallel +#define TRTRI_UN_PARALLEL strtri_UN_parallel +#define TRTRI_LU_PARALLEL strtri_LU_parallel +#define TRTRI_LN_PARALLEL strtri_LN_parallel +#endif +#else +#ifdef XDOUBLE +#define POTF2_U xpotf2_U +#define POTF2_L xpotf2_L +#define LAUU2_U xlauu2_U +#define LAUU2_L xlauu2_L +#define POTRF_U_SINGLE xpotrf_U_single +#define POTRF_L_SINGLE xpotrf_L_single +#define POTRF_U_PARALLEL xpotrf_U_parallel +#define POTRF_L_PARALLEL xpotrf_L_parallel +#define LAUUM_U_SINGLE xlauum_U_single +#define LAUUM_L_SINGLE xlauum_L_single +#define LAUUM_U_PARALLEL xlauum_U_parallel +#define LAUUM_L_PARALLEL xlauum_L_parallel +#define TRTI2_UU xtrti2_UU +#define TRTI2_UN xtrti2_UN +#define TRTI2_LU xtrti2_LU +#define TRTI2_LN xtrti2_LN +#define TRTRI_UU_SINGLE xtrtri_UU_single +#define TRTRI_UN_SINGLE xtrtri_UN_single +#define TRTRI_LU_SINGLE xtrtri_LU_single +#define TRTRI_LN_SINGLE xtrtri_LN_single +#define TRTRI_UU_PARALLEL xtrtri_UU_parallel +#define TRTRI_UN_PARALLEL xtrtri_UN_parallel +#define TRTRI_LU_PARALLEL xtrtri_LU_parallel +#define TRTRI_LN_PARALLEL xtrtri_LN_parallel +#elif defined(DOUBLE) +#define POTF2_U zpotf2_U +#define POTF2_L zpotf2_L +#define LAUU2_U zlauu2_U +#define LAUU2_L zlauu2_L +#define POTRF_U_SINGLE zpotrf_U_single +#define POTRF_L_SINGLE zpotrf_L_single +#define POTRF_U_PARALLEL zpotrf_U_parallel +#define POTRF_L_PARALLEL zpotrf_L_parallel +#define LAUUM_U_SINGLE zlauum_U_single +#define LAUUM_L_SINGLE zlauum_L_single +#define LAUUM_U_PARALLEL zlauum_U_parallel +#define LAUUM_L_PARALLEL zlauum_L_parallel +#define TRTI2_UU ztrti2_UU +#define TRTI2_UN ztrti2_UN +#define TRTI2_LU ztrti2_LU +#define TRTI2_LN ztrti2_LN +#define TRTRI_UU_SINGLE ztrtri_UU_single +#define TRTRI_UN_SINGLE ztrtri_UN_single +#define TRTRI_LU_SINGLE ztrtri_LU_single +#define TRTRI_LN_SINGLE ztrtri_LN_single +#define TRTRI_UU_PARALLEL ztrtri_UU_parallel +#define TRTRI_UN_PARALLEL ztrtri_UN_parallel +#define TRTRI_LU_PARALLEL ztrtri_LU_parallel +#define TRTRI_LN_PARALLEL ztrtri_LN_parallel +#else +#define POTF2_U cpotf2_U +#define POTF2_L cpotf2_L +#define LAUU2_U clauu2_U +#define LAUU2_L clauu2_L +#define POTRF_U_SINGLE cpotrf_U_single +#define POTRF_L_SINGLE cpotrf_L_single +#define POTRF_U_PARALLEL cpotrf_U_parallel +#define POTRF_L_PARALLEL cpotrf_L_parallel +#define LAUUM_U_SINGLE clauum_U_single +#define LAUUM_L_SINGLE clauum_L_single +#define LAUUM_U_PARALLEL clauum_U_parallel +#define LAUUM_L_PARALLEL clauum_L_parallel +#define TRTI2_UU ctrti2_UU +#define TRTI2_UN ctrti2_UN +#define TRTI2_LU ctrti2_LU +#define TRTI2_LN ctrti2_LN +#define TRTRI_UU_SINGLE ctrtri_UU_single +#define TRTRI_UN_SINGLE ctrtri_UN_single +#define TRTRI_LU_SINGLE ctrtri_LU_single +#define TRTRI_LN_SINGLE ctrtri_LN_single +#define TRTRI_UU_PARALLEL ctrtri_UU_parallel +#define TRTRI_UN_PARALLEL ctrtri_UN_parallel +#define TRTRI_LU_PARALLEL ctrtri_LU_parallel +#define TRTRI_LN_PARALLEL ctrtri_LN_parallel +#endif +#endif + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_mips64.h b/src/NativeWrappers/GotoBlas2/include/common_mips64.h new file mode 100644 index 00000000..332af3ef --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_mips64.h @@ -0,0 +1,197 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef COMMON_MIPS64 +#define COMMON_MIPS64 + +#define MB +#define WMB + +#define INLINE inline + +#ifndef ASSEMBLER + +static void INLINE blas_lock(volatile unsigned long *address){ + + long int ret, val = 1; + + do { + while (*address) {YIELDING;}; + + __asm__ __volatile__( + "1: ll %0, %3\n" + " ori %2, %0, 1\n" + " sc %2, %1\n" + " beqz %2, 1b\n" + " andi %2, %0, 1\n" + " sync\n" + : "=&r" (val), "=m" (address), "=&r" (ret) + : "m" (address) + : "memory"); + + } while (ret); +} + +static inline unsigned int rpcc(void){ + unsigned long ret; + + __asm__ __volatile__(".set push \n" + ".set mips32r2\n" + "rdhwr %0, $30 \n" + ".set pop" : "=r"(ret) : : "memory"); + + return ret; +} + +static inline int blas_quickdivide(blasint x, blasint y){ + return x / y; +} + +#ifdef DOUBLE +#define GET_IMAGE(res) __asm__ __volatile__("mov.d %0, $f2" : "=f"(res) : : "memory") +#else +#define GET_IMAGE(res) __asm__ __volatile__("mov.s %0, $f2" : "=f"(res) : : "memory") +#endif + +#define GET_IMAGE_CANCEL + +#endif + + +#ifdef ASSEMBLER + +#define HALT teq $0, $0 +#define NOP move $0, $0 + +#ifdef DOUBLE +#define LD ldc1 +#define ST sdc1 +#define MADD madd.d +#define NMADD nmadd.d +#define MSUB msub.d +#define NMSUB nmsub.d +#define ADD add.d +#define SUB sub.d +#define MUL mul.d +#define MOV mov.d +#define CMOVF movf.d +#define CMOVT movt.d +#define MTC dmtc1 +#define FABS abs.d +#define CMPEQ c.eq.d +#define CMPLE c.le.d +#define CMPLT c.lt.d +#else +#define LD lwc1 +#define ST swc1 +#define MADD madd.s +#define NMADD nmadd.s +#define MSUB msub.s +#define NMSUB nmsub.s +#define ADD add.s +#define SUB sub.s +#define MUL mul.s +#define MOV mov.s +#define CMOVF movf.s +#define CMOVT movt.s +#define MTC mtc1 +#define FABS abs.s +#define CMPEQ c.eq.s +#define CMPLE c.le.s +#define CMPLT c.lt.s +#endif + +#if defined(__64BIT__) && defined(USE64BITINT) +#define LDINT ld +#define LDARG ld +#define SDARG sd +#elif defined(__64BIT__) && !defined(USE64BITINT) +#define LDINT lw +#define LDARG ld +#define SDARG sd +#else +#define LDINT lw +#define LDARG lw +#define SDARG sw +#endif + + +#ifndef F_INTERFACE +#define REALNAME ASMNAME +#else +#define REALNAME ASMFNAME +#endif + +#if defined(ASSEMBLER) && !defined(NEEDPARAM) + +#define PROLOGUE \ + .text ;\ + .set mips64 ;\ + .align 5 ;\ + .globl REALNAME ;\ + .ent REALNAME ;\ + .type REALNAME, @function ;\ +REALNAME: ;\ + .set noreorder ;\ + .set nomacro + +#define EPILOGUE \ + .set macro ;\ + .set reorder ;\ + .end REALNAME + +#define PROFCODE +#endif + +#endif + +#define SEEK_ADDRESS + +#define BUFFER_SIZE ( 8 << 20) + +#ifndef PAGESIZE +#define PAGESIZE (64UL << 10) +#endif +#define HUGE_PAGESIZE ( 2 << 20) + +#define BASE_ADDRESS (START_ADDRESS - BUFFER_SIZE * MAX_CPU_NUMBER) + +#ifndef MAP_ANONYMOUS +#define MAP_ANONYMOUS MAP_ANON +#endif +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_param.h b/src/NativeWrappers/GotoBlas2/include/common_param.h new file mode 100644 index 00000000..c4580cc2 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_param.h @@ -0,0 +1,1098 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef COMMON_PARAM_H +#define COMMON_PARAM_H + +#ifndef ASSEMBLER + +#ifdef DYNAMIC_ARCH + +typedef struct { + int offsetA, offsetB, align; + + int sgemm_p, sgemm_q, sgemm_r; + int sgemm_unroll_m, sgemm_unroll_n, sgemm_unroll_mn; + + int exclusive_cache; + + float (*samax_k) (BLASLONG, float *, BLASLONG); + float (*samin_k) (BLASLONG, float *, BLASLONG); + float (*smax_k) (BLASLONG, float *, BLASLONG); + float (*smin_k) (BLASLONG, float *, BLASLONG); +BLASLONG (*isamax_k)(BLASLONG, float *, BLASLONG); +BLASLONG (*isamin_k)(BLASLONG, float *, BLASLONG); +BLASLONG (*ismax_k) (BLASLONG, float *, BLASLONG); +BLASLONG (*ismin_k) (BLASLONG, float *, BLASLONG); + + float (*snrm2_k) (BLASLONG, float *, BLASLONG); + float (*sasum_k) (BLASLONG, float *, BLASLONG); + int (*scopy_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG); + float (*sdot_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG); + double (*dsdot_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG); + + int (*srot_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG, float, float); + + int (*saxpy_k) (BLASLONG, BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); + int (*sscal_k) (BLASLONG, BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); + int (*sswap_k) (BLASLONG, BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); + + int (*sgemv_n) (BLASLONG, BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*sgemv_t) (BLASLONG, BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*sger_k) (BLASLONG, BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + + int (*ssymv_L) (BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*ssymv_U) (BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + + int (*sgemm_kernel )(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG); + int (*sgemm_beta )(BLASLONG, BLASLONG, BLASLONG, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); + + int (*sgemm_incopy )(BLASLONG, BLASLONG, float *, BLASLONG, float *); + int (*sgemm_itcopy )(BLASLONG, BLASLONG, float *, BLASLONG, float *); + int (*sgemm_oncopy )(BLASLONG, BLASLONG, float *, BLASLONG, float *); + int (*sgemm_otcopy )(BLASLONG, BLASLONG, float *, BLASLONG, float *); + + int (*strsm_kernel_LN)(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*strsm_kernel_LT)(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*strsm_kernel_RN)(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*strsm_kernel_RT)(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); + + int (*strsm_iunucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*strsm_iunncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*strsm_iutucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*strsm_iutncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*strsm_ilnucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*strsm_ilnncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*strsm_iltucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*strsm_iltncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*strsm_ounucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*strsm_ounncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*strsm_outucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*strsm_outncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*strsm_olnucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*strsm_olnncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*strsm_oltucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*strsm_oltncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + + int (*strmm_kernel_RN)(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*strmm_kernel_RT)(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*strmm_kernel_LN)(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*strmm_kernel_LT)(BLASLONG, BLASLONG, BLASLONG, float, float *, float *, float *, BLASLONG, BLASLONG); + + int (*strmm_iunucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*strmm_iunncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*strmm_iutucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*strmm_iutncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*strmm_ilnucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*strmm_ilnncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*strmm_iltucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*strmm_iltncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*strmm_ounucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*strmm_ounncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*strmm_outucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*strmm_outncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*strmm_olnucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*strmm_olnncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*strmm_oltucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*strmm_oltncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + + int (*ssymm_iutcopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ssymm_iltcopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ssymm_outcopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ssymm_oltcopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + + int (*sneg_tcopy) (BLASLONG, BLASLONG, float *, BLASLONG, float *); + int (*slaswp_ncopy) (BLASLONG, BLASLONG, BLASLONG, float *, BLASLONG, blasint *, float *); + + int dgemm_p, dgemm_q, dgemm_r; + int dgemm_unroll_m, dgemm_unroll_n, dgemm_unroll_mn; + + double (*damax_k) (BLASLONG, double *, BLASLONG); + double (*damin_k) (BLASLONG, double *, BLASLONG); + double (*dmax_k) (BLASLONG, double *, BLASLONG); + double (*dmin_k) (BLASLONG, double *, BLASLONG); +BLASLONG (*idamax_k)(BLASLONG, double *, BLASLONG); +BLASLONG (*idamin_k)(BLASLONG, double *, BLASLONG); +BLASLONG (*idmax_k) (BLASLONG, double *, BLASLONG); +BLASLONG (*idmin_k) (BLASLONG, double *, BLASLONG); + + double (*dnrm2_k) (BLASLONG, double *, BLASLONG); + double (*dasum_k) (BLASLONG, double *, BLASLONG); + int (*dcopy_k) (BLASLONG, double *, BLASLONG, double *, BLASLONG); + double (*ddot_k) (BLASLONG, double *, BLASLONG, double *, BLASLONG); + int (*drot_k) (BLASLONG, double *, BLASLONG, double *, BLASLONG, double, double); + + int (*daxpy_k) (BLASLONG, BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); + int (*dscal_k) (BLASLONG, BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); + int (*dswap_k) (BLASLONG, BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); + + int (*dgemv_n) (BLASLONG, BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*dgemv_t) (BLASLONG, BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*dger_k) (BLASLONG, BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + + int (*dsymv_L) (BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*dsymv_U) (BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + + int (*dgemm_kernel )(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG); + int (*dgemm_beta )(BLASLONG, BLASLONG, BLASLONG, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); + + int (*dgemm_incopy )(BLASLONG, BLASLONG, double *, BLASLONG, double *); + int (*dgemm_itcopy )(BLASLONG, BLASLONG, double *, BLASLONG, double *); + int (*dgemm_oncopy )(BLASLONG, BLASLONG, double *, BLASLONG, double *); + int (*dgemm_otcopy )(BLASLONG, BLASLONG, double *, BLASLONG, double *); + + int (*dtrsm_kernel_LN)(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*dtrsm_kernel_LT)(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*dtrsm_kernel_RN)(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*dtrsm_kernel_RT)(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); + + int (*dtrsm_iunucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*dtrsm_iunncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*dtrsm_iutucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*dtrsm_iutncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*dtrsm_ilnucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*dtrsm_ilnncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*dtrsm_iltucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*dtrsm_iltncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*dtrsm_ounucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*dtrsm_ounncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*dtrsm_outucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*dtrsm_outncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*dtrsm_olnucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*dtrsm_olnncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*dtrsm_oltucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*dtrsm_oltncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + + int (*dtrmm_kernel_RN)(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*dtrmm_kernel_RT)(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*dtrmm_kernel_LN)(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*dtrmm_kernel_LT)(BLASLONG, BLASLONG, BLASLONG, double, double *, double *, double *, BLASLONG, BLASLONG); + + int (*dtrmm_iunucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dtrmm_iunncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dtrmm_iutucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dtrmm_iutncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dtrmm_ilnucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dtrmm_ilnncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dtrmm_iltucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dtrmm_iltncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dtrmm_ounucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dtrmm_ounncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dtrmm_outucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dtrmm_outncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dtrmm_olnucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dtrmm_olnncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dtrmm_oltucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dtrmm_oltncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + + int (*dsymm_iutcopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dsymm_iltcopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dsymm_outcopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*dsymm_oltcopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + + int (*dneg_tcopy) (BLASLONG, BLASLONG, double *, BLASLONG, double *); + int (*dlaswp_ncopy) (BLASLONG, BLASLONG, BLASLONG, double *, BLASLONG, blasint *, double *); + +#ifdef EXPRECISION + + int qgemm_p, qgemm_q, qgemm_r; + int qgemm_unroll_m, qgemm_unroll_n, qgemm_unroll_mn; + + xdouble (*qamax_k) (BLASLONG, xdouble *, BLASLONG); + xdouble (*qamin_k) (BLASLONG, xdouble *, BLASLONG); + xdouble (*qmax_k) (BLASLONG, xdouble *, BLASLONG); + xdouble (*qmin_k) (BLASLONG, xdouble *, BLASLONG); +BLASLONG (*iqamax_k)(BLASLONG, xdouble *, BLASLONG); +BLASLONG (*iqamin_k)(BLASLONG, xdouble *, BLASLONG); +BLASLONG (*iqmax_k) (BLASLONG, xdouble *, BLASLONG); +BLASLONG (*iqmin_k) (BLASLONG, xdouble *, BLASLONG); + + xdouble (*qnrm2_k) (BLASLONG, xdouble *, BLASLONG); + xdouble (*qasum_k) (BLASLONG, xdouble *, BLASLONG); + int (*qcopy_k) (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + xdouble (*qdot_k) (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + int (*qrot_k) (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble, xdouble); + + int (*qaxpy_k) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + int (*qscal_k) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + int (*qswap_k) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + + int (*qgemv_n) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*qgemv_t) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*qger_k) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + + int (*qsymv_L) (BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*qsymv_U) (BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + + int (*qgemm_kernel )(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG); + int (*qgemm_beta )(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + + int (*qgemm_incopy )(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*qgemm_itcopy )(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*qgemm_oncopy )(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*qgemm_otcopy )(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + + int (*qtrsm_kernel_LN)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*qtrsm_kernel_LT)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*qtrsm_kernel_RN)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*qtrsm_kernel_RT)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + + int (*qtrsm_iunucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*qtrsm_iunncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*qtrsm_iutucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*qtrsm_iutncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*qtrsm_ilnucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*qtrsm_ilnncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*qtrsm_iltucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*qtrsm_iltncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*qtrsm_ounucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*qtrsm_ounncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*qtrsm_outucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*qtrsm_outncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*qtrsm_olnucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*qtrsm_olnncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*qtrsm_oltucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*qtrsm_oltncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + + int (*qtrmm_kernel_RN)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*qtrmm_kernel_RT)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*qtrmm_kernel_LN)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*qtrmm_kernel_LT)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + + int (*qtrmm_iunucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qtrmm_iunncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qtrmm_iutucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qtrmm_iutncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qtrmm_ilnucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qtrmm_ilnncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qtrmm_iltucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qtrmm_iltncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qtrmm_ounucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qtrmm_ounncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qtrmm_outucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qtrmm_outncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qtrmm_olnucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qtrmm_olnncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qtrmm_oltucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qtrmm_oltncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + + int (*qsymm_iutcopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qsymm_iltcopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qsymm_outcopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*qsymm_oltcopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + + int (*qneg_tcopy) (BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*qlaswp_ncopy) (BLASLONG, BLASLONG, BLASLONG, xdouble *, BLASLONG, blasint *, xdouble *); + +#endif + + int cgemm_p, cgemm_q, cgemm_r; + int cgemm_unroll_m, cgemm_unroll_n, cgemm_unroll_mn; + + float (*camax_k) (BLASLONG, float *, BLASLONG); + float (*camin_k) (BLASLONG, float *, BLASLONG); +BLASLONG (*icamax_k)(BLASLONG, float *, BLASLONG); +BLASLONG (*icamin_k)(BLASLONG, float *, BLASLONG); + + float (*cnrm2_k) (BLASLONG, float *, BLASLONG); + float (*casum_k) (BLASLONG, float *, BLASLONG); + int (*ccopy_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG); + float _Complex (*cdotu_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG); + float _Complex (*cdotc_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG); + int (*csrot_k) (BLASLONG, float *, BLASLONG, float *, BLASLONG, float, float); + + int (*caxpy_k) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); + int (*caxpyc_k)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); + int (*cscal_k) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); + int (*cswap_k) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); + + int (*cgemv_n) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*cgemv_t) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*cgemv_r) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*cgemv_c) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*cgemv_o) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*cgemv_u) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*cgemv_s) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*cgemv_d) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*cgeru_k) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*cgerc_k) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*cgerv_k) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*cgerd_k) (BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + + int (*csymv_L) (BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*csymv_U) (BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*chemv_L) (BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*chemv_U) (BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*chemv_M) (BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + int (*chemv_V) (BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG, float *); + + int (*cgemm_kernel_n )(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG); + int (*cgemm_kernel_l )(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG); + int (*cgemm_kernel_r )(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG); + int (*cgemm_kernel_b )(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG); + int (*cgemm_beta )(BLASLONG, BLASLONG, BLASLONG, float, float, float *, BLASLONG, float *, BLASLONG, float *, BLASLONG); + + int (*cgemm_incopy )(BLASLONG, BLASLONG, float *, BLASLONG, float *); + int (*cgemm_itcopy )(BLASLONG, BLASLONG, float *, BLASLONG, float *); + int (*cgemm_oncopy )(BLASLONG, BLASLONG, float *, BLASLONG, float *); + int (*cgemm_otcopy )(BLASLONG, BLASLONG, float *, BLASLONG, float *); + + int (*ctrsm_kernel_LN)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*ctrsm_kernel_LT)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*ctrsm_kernel_LR)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*ctrsm_kernel_LC)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*ctrsm_kernel_RN)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*ctrsm_kernel_RT)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*ctrsm_kernel_RR)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*ctrsm_kernel_RC)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + + int (*ctrsm_iunucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*ctrsm_iunncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*ctrsm_iutucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*ctrsm_iutncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*ctrsm_ilnucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*ctrsm_ilnncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*ctrsm_iltucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*ctrsm_iltncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*ctrsm_ounucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*ctrsm_ounncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*ctrsm_outucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*ctrsm_outncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*ctrsm_olnucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*ctrsm_olnncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*ctrsm_oltucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + int (*ctrsm_oltncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, float *); + + int (*ctrmm_kernel_RN)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*ctrmm_kernel_RT)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*ctrmm_kernel_RR)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*ctrmm_kernel_RC)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*ctrmm_kernel_LN)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*ctrmm_kernel_LT)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*ctrmm_kernel_LR)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + int (*ctrmm_kernel_LC)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG, BLASLONG); + + int (*ctrmm_iunucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ctrmm_iunncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ctrmm_iutucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ctrmm_iutncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ctrmm_ilnucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ctrmm_ilnncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ctrmm_iltucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ctrmm_iltncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ctrmm_ounucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ctrmm_ounncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ctrmm_outucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ctrmm_outncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ctrmm_olnucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ctrmm_olnncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ctrmm_oltucopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*ctrmm_oltncopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + + int (*csymm_iutcopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*csymm_iltcopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*csymm_outcopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*csymm_oltcopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + + int (*chemm_iutcopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*chemm_iltcopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*chemm_outcopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*chemm_oltcopy)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + + int (*cgemm3m_kernel)(BLASLONG, BLASLONG, BLASLONG, float, float, float *, float *, float *, BLASLONG); + + int (*cgemm3m_incopyb)(BLASLONG, BLASLONG, float *, BLASLONG, float *); + int (*cgemm3m_incopyr)(BLASLONG, BLASLONG, float *, BLASLONG, float *); + int (*cgemm3m_incopyi)(BLASLONG, BLASLONG, float *, BLASLONG, float *); + int (*cgemm3m_itcopyb)(BLASLONG, BLASLONG, float *, BLASLONG, float *); + int (*cgemm3m_itcopyr)(BLASLONG, BLASLONG, float *, BLASLONG, float *); + int (*cgemm3m_itcopyi)(BLASLONG, BLASLONG, float *, BLASLONG, float *); + + int (*cgemm3m_oncopyb)(BLASLONG, BLASLONG, float *, BLASLONG, float, float, float *); + int (*cgemm3m_oncopyr)(BLASLONG, BLASLONG, float *, BLASLONG, float, float, float *); + int (*cgemm3m_oncopyi)(BLASLONG, BLASLONG, float *, BLASLONG, float, float, float *); + int (*cgemm3m_otcopyb)(BLASLONG, BLASLONG, float *, BLASLONG, float, float, float *); + int (*cgemm3m_otcopyr)(BLASLONG, BLASLONG, float *, BLASLONG, float, float, float *); + int (*cgemm3m_otcopyi)(BLASLONG, BLASLONG, float *, BLASLONG, float, float, float *); + + int (*csymm3m_iucopyb)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*csymm3m_ilcopyb)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*csymm3m_iucopyr)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*csymm3m_ilcopyr)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*csymm3m_iucopyi)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*csymm3m_ilcopyi)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + + int (*csymm3m_oucopyb)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float, float, float *); + int (*csymm3m_olcopyb)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float, float, float *); + int (*csymm3m_oucopyr)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float, float, float *); + int (*csymm3m_olcopyr)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float, float, float *); + int (*csymm3m_oucopyi)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float, float, float *); + int (*csymm3m_olcopyi)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float, float, float *); + + int (*chemm3m_iucopyb)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*chemm3m_ilcopyb)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*chemm3m_iucopyr)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*chemm3m_ilcopyr)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*chemm3m_iucopyi)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + int (*chemm3m_ilcopyi)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float *); + + int (*chemm3m_oucopyb)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float, float, float *); + int (*chemm3m_olcopyb)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float, float, float *); + int (*chemm3m_oucopyr)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float, float, float *); + int (*chemm3m_olcopyr)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float, float, float *); + int (*chemm3m_oucopyi)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float, float, float *); + int (*chemm3m_olcopyi)(BLASLONG, BLASLONG, float *, BLASLONG, BLASLONG, BLASLONG, float, float, float *); + + int (*cneg_tcopy) (BLASLONG, BLASLONG, float *, BLASLONG, float *); + int (*claswp_ncopy) (BLASLONG, BLASLONG, BLASLONG, float *, BLASLONG, blasint *, float *); + + int zgemm_p, zgemm_q, zgemm_r; + int zgemm_unroll_m, zgemm_unroll_n, zgemm_unroll_mn; + + double (*zamax_k) (BLASLONG, double *, BLASLONG); + double (*zamin_k) (BLASLONG, double *, BLASLONG); +BLASLONG (*izamax_k)(BLASLONG, double *, BLASLONG); +BLASLONG (*izamin_k)(BLASLONG, double *, BLASLONG); + + double (*znrm2_k) (BLASLONG, double *, BLASLONG); + double (*zasum_k) (BLASLONG, double *, BLASLONG); + int (*zcopy_k) (BLASLONG, double *, BLASLONG, double *, BLASLONG); + double _Complex (*zdotu_k) (BLASLONG, double *, BLASLONG, double *, BLASLONG); + double _Complex (*zdotc_k) (BLASLONG, double *, BLASLONG, double *, BLASLONG); + int (*zdrot_k) (BLASLONG, double *, BLASLONG, double *, BLASLONG, double, double); + + int (*zaxpy_k) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); + int (*zaxpyc_k)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); + int (*zscal_k) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); + int (*zswap_k) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); + + int (*zgemv_n) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zgemv_t) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zgemv_r) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zgemv_c) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zgemv_o) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zgemv_u) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zgemv_s) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zgemv_d) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zgeru_k) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zgerc_k) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zgerv_k) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zgerd_k) (BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + + int (*zsymv_L) (BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zsymv_U) (BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zhemv_L) (BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zhemv_U) (BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zhemv_M) (BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + int (*zhemv_V) (BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG, double *); + + int (*zgemm_kernel_n )(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG); + int (*zgemm_kernel_l )(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG); + int (*zgemm_kernel_r )(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG); + int (*zgemm_kernel_b )(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG); + int (*zgemm_beta )(BLASLONG, BLASLONG, BLASLONG, double, double, double *, BLASLONG, double *, BLASLONG, double *, BLASLONG); + + int (*zgemm_incopy )(BLASLONG, BLASLONG, double *, BLASLONG, double *); + int (*zgemm_itcopy )(BLASLONG, BLASLONG, double *, BLASLONG, double *); + int (*zgemm_oncopy )(BLASLONG, BLASLONG, double *, BLASLONG, double *); + int (*zgemm_otcopy )(BLASLONG, BLASLONG, double *, BLASLONG, double *); + + int (*ztrsm_kernel_LN)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*ztrsm_kernel_LT)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*ztrsm_kernel_LR)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*ztrsm_kernel_LC)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*ztrsm_kernel_RN)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*ztrsm_kernel_RT)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*ztrsm_kernel_RR)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*ztrsm_kernel_RC)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + + int (*ztrsm_iunucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*ztrsm_iunncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*ztrsm_iutucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*ztrsm_iutncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*ztrsm_ilnucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*ztrsm_ilnncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*ztrsm_iltucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*ztrsm_iltncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*ztrsm_ounucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*ztrsm_ounncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*ztrsm_outucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*ztrsm_outncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*ztrsm_olnucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*ztrsm_olnncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*ztrsm_oltucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + int (*ztrsm_oltncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, double *); + + int (*ztrmm_kernel_RN)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*ztrmm_kernel_RT)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*ztrmm_kernel_RR)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*ztrmm_kernel_RC)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*ztrmm_kernel_LN)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*ztrmm_kernel_LT)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*ztrmm_kernel_LR)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + int (*ztrmm_kernel_LC)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG, BLASLONG); + + int (*ztrmm_iunucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*ztrmm_iunncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*ztrmm_iutucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*ztrmm_iutncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*ztrmm_ilnucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*ztrmm_ilnncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*ztrmm_iltucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*ztrmm_iltncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*ztrmm_ounucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*ztrmm_ounncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*ztrmm_outucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*ztrmm_outncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*ztrmm_olnucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*ztrmm_olnncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*ztrmm_oltucopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*ztrmm_oltncopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + + int (*zsymm_iutcopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zsymm_iltcopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zsymm_outcopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zsymm_oltcopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + + int (*zhemm_iutcopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zhemm_iltcopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zhemm_outcopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zhemm_oltcopy)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + + int (*zgemm3m_kernel)(BLASLONG, BLASLONG, BLASLONG, double, double, double *, double *, double *, BLASLONG); + + int (*zgemm3m_incopyb)(BLASLONG, BLASLONG, double *, BLASLONG, double *); + int (*zgemm3m_incopyr)(BLASLONG, BLASLONG, double *, BLASLONG, double *); + int (*zgemm3m_incopyi)(BLASLONG, BLASLONG, double *, BLASLONG, double *); + int (*zgemm3m_itcopyb)(BLASLONG, BLASLONG, double *, BLASLONG, double *); + int (*zgemm3m_itcopyr)(BLASLONG, BLASLONG, double *, BLASLONG, double *); + int (*zgemm3m_itcopyi)(BLASLONG, BLASLONG, double *, BLASLONG, double *); + + int (*zgemm3m_oncopyb)(BLASLONG, BLASLONG, double *, BLASLONG, double, double, double *); + int (*zgemm3m_oncopyr)(BLASLONG, BLASLONG, double *, BLASLONG, double, double, double *); + int (*zgemm3m_oncopyi)(BLASLONG, BLASLONG, double *, BLASLONG, double, double, double *); + int (*zgemm3m_otcopyb)(BLASLONG, BLASLONG, double *, BLASLONG, double, double, double *); + int (*zgemm3m_otcopyr)(BLASLONG, BLASLONG, double *, BLASLONG, double, double, double *); + int (*zgemm3m_otcopyi)(BLASLONG, BLASLONG, double *, BLASLONG, double, double, double *); + + int (*zsymm3m_iucopyb)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zsymm3m_ilcopyb)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zsymm3m_iucopyr)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zsymm3m_ilcopyr)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zsymm3m_iucopyi)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zsymm3m_ilcopyi)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + + int (*zsymm3m_oucopyb)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double, double, double *); + int (*zsymm3m_olcopyb)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double, double, double *); + int (*zsymm3m_oucopyr)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double, double, double *); + int (*zsymm3m_olcopyr)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double, double, double *); + int (*zsymm3m_oucopyi)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double, double, double *); + int (*zsymm3m_olcopyi)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double, double, double *); + + int (*zhemm3m_iucopyb)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zhemm3m_ilcopyb)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zhemm3m_iucopyr)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zhemm3m_ilcopyr)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zhemm3m_iucopyi)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + int (*zhemm3m_ilcopyi)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double *); + + int (*zhemm3m_oucopyb)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double, double, double *); + int (*zhemm3m_olcopyb)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double, double, double *); + int (*zhemm3m_oucopyr)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double, double, double *); + int (*zhemm3m_olcopyr)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double, double, double *); + int (*zhemm3m_oucopyi)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double, double, double *); + int (*zhemm3m_olcopyi)(BLASLONG, BLASLONG, double *, BLASLONG, BLASLONG, BLASLONG, double, double, double *); + + int (*zneg_tcopy) (BLASLONG, BLASLONG, double *, BLASLONG, double *); + int (*zlaswp_ncopy) (BLASLONG, BLASLONG, BLASLONG, double *, BLASLONG, blasint *, double *); + +#ifdef EXPRECISION + + int xgemm_p, xgemm_q, xgemm_r; + int xgemm_unroll_m, xgemm_unroll_n, xgemm_unroll_mn; + + xdouble (*xamax_k) (BLASLONG, xdouble *, BLASLONG); + xdouble (*xamin_k) (BLASLONG, xdouble *, BLASLONG); +BLASLONG (*ixamax_k)(BLASLONG, xdouble *, BLASLONG); +BLASLONG (*ixamin_k)(BLASLONG, xdouble *, BLASLONG); + + xdouble (*xnrm2_k) (BLASLONG, xdouble *, BLASLONG); + xdouble (*xasum_k) (BLASLONG, xdouble *, BLASLONG); + int (*xcopy_k) (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + xdouble _Complex (*xdotu_k) (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + xdouble _Complex (*xdotc_k) (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + int (*xqrot_k) (BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble, xdouble); + + int (*xaxpy_k) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + int (*xaxpyc_k)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + int (*xscal_k) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + int (*xswap_k) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + + int (*xgemv_n) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgemv_t) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgemv_r) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgemv_c) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgemv_o) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgemv_u) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgemv_s) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgemv_d) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgeru_k) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgerc_k) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgerv_k) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgerd_k) (BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + + int (*xsymv_L) (BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xsymv_U) (BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xhemv_L) (BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xhemv_U) (BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xhemv_M) (BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xhemv_V) (BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *); + + int (*xgemm_kernel_n )(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG); + int (*xgemm_kernel_l )(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG); + int (*xgemm_kernel_r )(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG); + int (*xgemm_kernel_b )(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG); + int (*xgemm_beta )(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, BLASLONG, xdouble *, BLASLONG, xdouble *, BLASLONG); + + int (*xgemm_incopy )(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgemm_itcopy )(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgemm_oncopy )(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgemm_otcopy )(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + + int (*xtrsm_kernel_LN)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*xtrsm_kernel_LT)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*xtrsm_kernel_LR)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*xtrsm_kernel_LC)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*xtrsm_kernel_RN)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*xtrsm_kernel_RT)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*xtrsm_kernel_RR)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*xtrsm_kernel_RC)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + + int (*xtrsm_iunucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*xtrsm_iunncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*xtrsm_iutucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*xtrsm_iutncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*xtrsm_ilnucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*xtrsm_ilnncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*xtrsm_iltucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*xtrsm_iltncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*xtrsm_ounucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*xtrsm_ounncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*xtrsm_outucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*xtrsm_outncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*xtrsm_olnucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*xtrsm_olnncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*xtrsm_oltucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + int (*xtrsm_oltncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, xdouble *); + + int (*xtrmm_kernel_RN)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*xtrmm_kernel_RT)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*xtrmm_kernel_RR)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*xtrmm_kernel_RC)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*xtrmm_kernel_LN)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*xtrmm_kernel_LT)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*xtrmm_kernel_LR)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + int (*xtrmm_kernel_LC)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG, BLASLONG); + + int (*xtrmm_iunucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xtrmm_iunncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xtrmm_iutucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xtrmm_iutncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xtrmm_ilnucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xtrmm_ilnncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xtrmm_iltucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xtrmm_iltncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xtrmm_ounucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xtrmm_ounncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xtrmm_outucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xtrmm_outncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xtrmm_olnucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xtrmm_olnncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xtrmm_oltucopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xtrmm_oltncopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + + int (*xsymm_iutcopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xsymm_iltcopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xsymm_outcopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xsymm_oltcopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + + int (*xhemm_iutcopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xhemm_iltcopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xhemm_outcopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xhemm_oltcopy)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + + int (*xgemm3m_kernel)(BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *, xdouble *, xdouble *, BLASLONG); + + int (*xgemm3m_incopyb)(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgemm3m_incopyr)(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgemm3m_incopyi)(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgemm3m_itcopyb)(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgemm3m_itcopyr)(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xgemm3m_itcopyi)(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + + int (*xgemm3m_oncopyb)(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble, xdouble, xdouble *); + int (*xgemm3m_oncopyr)(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble, xdouble, xdouble *); + int (*xgemm3m_oncopyi)(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble, xdouble, xdouble *); + int (*xgemm3m_otcopyb)(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble, xdouble, xdouble *); + int (*xgemm3m_otcopyr)(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble, xdouble, xdouble *); + int (*xgemm3m_otcopyi)(BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble, xdouble, xdouble *); + + int (*xsymm3m_iucopyb)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xsymm3m_ilcopyb)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xsymm3m_iucopyr)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xsymm3m_ilcopyr)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xsymm3m_iucopyi)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xsymm3m_ilcopyi)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + + int (*xsymm3m_oucopyb)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *); + int (*xsymm3m_olcopyb)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *); + int (*xsymm3m_oucopyr)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *); + int (*xsymm3m_olcopyr)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *); + int (*xsymm3m_oucopyi)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *); + int (*xsymm3m_olcopyi)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *); + + int (*xhemm3m_iucopyb)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xhemm3m_ilcopyb)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xhemm3m_iucopyr)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xhemm3m_ilcopyr)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xhemm3m_iucopyi)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + int (*xhemm3m_ilcopyi)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble *); + + int (*xhemm3m_oucopyb)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *); + int (*xhemm3m_olcopyb)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *); + int (*xhemm3m_oucopyr)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *); + int (*xhemm3m_olcopyr)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *); + int (*xhemm3m_oucopyi)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *); + int (*xhemm3m_olcopyi)(BLASLONG, BLASLONG, xdouble *, BLASLONG, BLASLONG, BLASLONG, xdouble, xdouble, xdouble *); + + int (*xneg_tcopy) (BLASLONG, BLASLONG, xdouble *, BLASLONG, xdouble *); + int (*xlaswp_ncopy) (BLASLONG, BLASLONG, BLASLONG, xdouble *, BLASLONG, blasint *, xdouble *); + +#endif + + void (*init)(void); + + int snum_opt, dnum_opt, qnum_opt; + +} gotoblas_t; + +extern gotoblas_t *gotoblas; + +#define GEMM_OFFSET_A gotoblas -> offsetA +#define GEMM_OFFSET_B gotoblas -> offsetB +#define GEMM_ALIGN gotoblas -> align + +#define HAVE_EX_L2 gotoblas -> exclusive_cache + +#define SGEMM_P gotoblas -> sgemm_p +#define SGEMM_Q gotoblas -> sgemm_q +#define SGEMM_R gotoblas -> sgemm_r +#define SGEMM_UNROLL_M gotoblas -> sgemm_unroll_m +#define SGEMM_UNROLL_N gotoblas -> sgemm_unroll_n +#define SGEMM_UNROLL_MN gotoblas -> sgemm_unroll_mn + +#define DGEMM_P gotoblas -> dgemm_p +#define DGEMM_Q gotoblas -> dgemm_q +#define DGEMM_R gotoblas -> dgemm_r +#define DGEMM_UNROLL_M gotoblas -> dgemm_unroll_m +#define DGEMM_UNROLL_N gotoblas -> dgemm_unroll_n +#define DGEMM_UNROLL_MN gotoblas -> dgemm_unroll_mn + +#define QGEMM_P gotoblas -> qgemm_p +#define QGEMM_Q gotoblas -> qgemm_q +#define QGEMM_R gotoblas -> qgemm_r +#define QGEMM_UNROLL_M gotoblas -> qgemm_unroll_m +#define QGEMM_UNROLL_N gotoblas -> qgemm_unroll_n +#define QGEMM_UNROLL_MN gotoblas -> qgemm_unroll_mn + +#define CGEMM_P gotoblas -> cgemm_p +#define CGEMM_Q gotoblas -> cgemm_q +#define CGEMM_R gotoblas -> cgemm_r +#define CGEMM_UNROLL_M gotoblas -> cgemm_unroll_m +#define CGEMM_UNROLL_N gotoblas -> cgemm_unroll_n +#define CGEMM_UNROLL_MN gotoblas -> cgemm_unroll_mn + +#define ZGEMM_P gotoblas -> zgemm_p +#define ZGEMM_Q gotoblas -> zgemm_q +#define ZGEMM_R gotoblas -> zgemm_r +#define ZGEMM_UNROLL_M gotoblas -> zgemm_unroll_m +#define ZGEMM_UNROLL_N gotoblas -> zgemm_unroll_n +#define ZGEMM_UNROLL_MN gotoblas -> zgemm_unroll_mn + +#define XGEMM_P gotoblas -> xgemm_p +#define XGEMM_Q gotoblas -> xgemm_q +#define XGEMM_R gotoblas -> xgemm_r +#define XGEMM_UNROLL_M gotoblas -> xgemm_unroll_m +#define XGEMM_UNROLL_N gotoblas -> xgemm_unroll_n +#define XGEMM_UNROLL_MN gotoblas -> xgemm_unroll_mn + +#else + +#define GEMM_OFFSET_A GEMM_DEFAULT_OFFSET_A +#define GEMM_OFFSET_B GEMM_DEFAULT_OFFSET_B +#define GEMM_ALIGN GEMM_DEFAULT_ALIGN + +#ifdef HAVE_EXCLUSIVE_CACHE +#define HAVE_EX_L2 1 +#else +#define HAVE_EX_L2 0 +#endif + +#define SGEMM_P SGEMM_DEFAULT_P +#define SGEMM_Q SGEMM_DEFAULT_Q +#define SGEMM_R SGEMM_DEFAULT_R +#define SGEMM_UNROLL_M SGEMM_DEFAULT_UNROLL_M +#define SGEMM_UNROLL_N SGEMM_DEFAULT_UNROLL_N +#define SGEMM_UNROLL_MN MAX((SGEMM_UNROLL_M), (SGEMM_UNROLL_N)) + +#define DGEMM_P DGEMM_DEFAULT_P +#define DGEMM_Q DGEMM_DEFAULT_Q +#define DGEMM_R DGEMM_DEFAULT_R +#define DGEMM_UNROLL_M DGEMM_DEFAULT_UNROLL_M +#define DGEMM_UNROLL_N DGEMM_DEFAULT_UNROLL_N +#define DGEMM_UNROLL_MN MAX((DGEMM_UNROLL_M), (DGEMM_UNROLL_N)) + +#define QGEMM_P QGEMM_DEFAULT_P +#define QGEMM_Q QGEMM_DEFAULT_Q +#define QGEMM_R QGEMM_DEFAULT_R +#define QGEMM_UNROLL_M QGEMM_DEFAULT_UNROLL_M +#define QGEMM_UNROLL_N QGEMM_DEFAULT_UNROLL_N +#define QGEMM_UNROLL_MN MAX((QGEMM_UNROLL_M), (QGEMM_UNROLL_N)) + +#define CGEMM_P CGEMM_DEFAULT_P +#define CGEMM_Q CGEMM_DEFAULT_Q +#define CGEMM_R CGEMM_DEFAULT_R +#define CGEMM_UNROLL_M CGEMM_DEFAULT_UNROLL_M +#define CGEMM_UNROLL_N CGEMM_DEFAULT_UNROLL_N +#define CGEMM_UNROLL_MN MAX((CGEMM_UNROLL_M), (CGEMM_UNROLL_N)) + +#define ZGEMM_P ZGEMM_DEFAULT_P +#define ZGEMM_Q ZGEMM_DEFAULT_Q +#define ZGEMM_R ZGEMM_DEFAULT_R +#define ZGEMM_UNROLL_M ZGEMM_DEFAULT_UNROLL_M +#define ZGEMM_UNROLL_N ZGEMM_DEFAULT_UNROLL_N +#define ZGEMM_UNROLL_MN MAX((ZGEMM_UNROLL_M), (ZGEMM_UNROLL_N)) + +#define XGEMM_P XGEMM_DEFAULT_P +#define XGEMM_Q XGEMM_DEFAULT_Q +#define XGEMM_R XGEMM_DEFAULT_R +#define XGEMM_UNROLL_M XGEMM_DEFAULT_UNROLL_M +#define XGEMM_UNROLL_N XGEMM_DEFAULT_UNROLL_N +#define XGEMM_UNROLL_MN MAX((XGEMM_UNROLL_M), (XGEMM_UNROLL_N)) + +#endif +#endif + +#ifndef COMPLEX +#if defined(XDOUBLE) +#define GEMM_P QGEMM_P +#define GEMM_Q QGEMM_Q +#define GEMM_R QGEMM_R +#define GEMM_UNROLL_M QGEMM_UNROLL_M +#define GEMM_UNROLL_N QGEMM_UNROLL_N +#define GEMM_UNROLL_MN QGEMM_UNROLL_MN +#define GEMM_DEFAULT_P QGEMM_DEFAULT_P +#define GEMM_DEFAULT_Q QGEMM_DEFAULT_Q +#define GEMM_DEFAULT_R QGEMM_DEFAULT_R +#define GEMM_DEFAULT_UNROLL_M QGEMM_DEFAULT_UNROLL_M +#define GEMM_DEFAULT_UNROLL_N QGEMM_DEFAULT_UNROLL_N +#elif defined(DOUBLE) +#define GEMM_P DGEMM_P +#define GEMM_Q DGEMM_Q +#define GEMM_R DGEMM_R +#define GEMM_UNROLL_M DGEMM_UNROLL_M +#define GEMM_UNROLL_N DGEMM_UNROLL_N +#define GEMM_UNROLL_MN DGEMM_UNROLL_MN +#define GEMM_DEFAULT_P DGEMM_DEFAULT_P +#define GEMM_DEFAULT_Q DGEMM_DEFAULT_Q +#define GEMM_DEFAULT_R DGEMM_DEFAULT_R +#define GEMM_DEFAULT_UNROLL_M DGEMM_DEFAULT_UNROLL_M +#define GEMM_DEFAULT_UNROLL_N DGEMM_DEFAULT_UNROLL_N +#else +#define GEMM_P SGEMM_P +#define GEMM_Q SGEMM_Q +#define GEMM_R SGEMM_R +#define GEMM_UNROLL_M SGEMM_UNROLL_M +#define GEMM_UNROLL_N SGEMM_UNROLL_N +#define GEMM_UNROLL_MN SGEMM_UNROLL_MN +#define GEMM_DEFAULT_P SGEMM_DEFAULT_P +#define GEMM_DEFAULT_Q SGEMM_DEFAULT_Q +#define GEMM_DEFAULT_R SGEMM_DEFAULT_R +#define GEMM_DEFAULT_UNROLL_M SGEMM_DEFAULT_UNROLL_M +#define GEMM_DEFAULT_UNROLL_N SGEMM_DEFAULT_UNROLL_N +#endif +#else +#if defined(XDOUBLE) +#define GEMM_P XGEMM_P +#define GEMM_Q XGEMM_Q +#define GEMM_R XGEMM_R +#define GEMM_UNROLL_M XGEMM_UNROLL_M +#define GEMM_UNROLL_N XGEMM_UNROLL_N +#define GEMM_UNROLL_MN XGEMM_UNROLL_MN +#define GEMM_DEFAULT_P XGEMM_DEFAULT_P +#define GEMM_DEFAULT_Q XGEMM_DEFAULT_Q +#define GEMM_DEFAULT_R XGEMM_DEFAULT_R +#define GEMM_DEFAULT_UNROLL_M XGEMM_DEFAULT_UNROLL_M +#define GEMM_DEFAULT_UNROLL_N XGEMM_DEFAULT_UNROLL_N +#elif defined(DOUBLE) +#define GEMM_P ZGEMM_P +#define GEMM_Q ZGEMM_Q +#define GEMM_R ZGEMM_R +#define GEMM_UNROLL_M ZGEMM_UNROLL_M +#define GEMM_UNROLL_N ZGEMM_UNROLL_N +#define GEMM_UNROLL_MN ZGEMM_UNROLL_MN +#define GEMM_DEFAULT_P ZGEMM_DEFAULT_P +#define GEMM_DEFAULT_Q ZGEMM_DEFAULT_Q +#define GEMM_DEFAULT_R ZGEMM_DEFAULT_R +#define GEMM_DEFAULT_UNROLL_M ZGEMM_DEFAULT_UNROLL_M +#define GEMM_DEFAULT_UNROLL_N ZGEMM_DEFAULT_UNROLL_N +#else +#define GEMM_P CGEMM_P +#define GEMM_Q CGEMM_Q +#define GEMM_R CGEMM_R +#define GEMM_UNROLL_M CGEMM_UNROLL_M +#define GEMM_UNROLL_N CGEMM_UNROLL_N +#define GEMM_UNROLL_MN CGEMM_UNROLL_MN +#define GEMM_DEFAULT_P CGEMM_DEFAULT_P +#define GEMM_DEFAULT_Q CGEMM_DEFAULT_Q +#define GEMM_DEFAULT_R CGEMM_DEFAULT_R +#define GEMM_DEFAULT_UNROLL_M CGEMM_DEFAULT_UNROLL_M +#define GEMM_DEFAULT_UNROLL_N CGEMM_DEFAULT_UNROLL_N +#endif +#endif + +#ifdef XDOUBLE +#define GEMM3M_UNROLL_M QGEMM_DEFAULT_UNROLL_M +#define GEMM3M_UNROLL_N QGEMM_DEFAULT_UNROLL_N +#elif defined(DOUBLE) +#define GEMM3M_UNROLL_M DGEMM_DEFAULT_UNROLL_M +#define GEMM3M_UNROLL_N DGEMM_DEFAULT_UNROLL_N +#else +#define GEMM3M_UNROLL_M SGEMM_DEFAULT_UNROLL_M +#define GEMM3M_UNROLL_N SGEMM_DEFAULT_UNROLL_N +#endif + + +#ifndef QGEMM_DEFAULT_UNROLL_M +#define QGEMM_DEFAULT_UNROLL_M 2 +#endif + +#ifndef QGEMM_DEFAULT_UNROLL_N +#define QGEMM_DEFAULT_UNROLL_N 2 +#endif + +#ifndef XGEMM_DEFAULT_UNROLL_M +#define XGEMM_DEFAULT_UNROLL_M 2 +#endif + +#ifndef XGEMM_DEFAULT_UNROLL_N +#define XGEMM_DEFAULT_UNROLL_N 2 +#endif + +#ifndef GEMM_THREAD +#define GEMM_THREAD gemm_thread_n +#endif + +#ifndef SGEMM_DEFAULT_R +#define SGEMM_DEFAULT_R (((BUFFER_SIZE - ((SGEMM_DEFAULT_P * SGEMM_DEFAULT_Q * 4 + GEMM_DEFAULT_OFFSET_A + GEMM_DEFAULT_ALIGN) & ~GEMM_DEFAULT_ALIGN)) / (SGEMM_DEFAULT_Q * 4) - 15) & ~15) +#endif + +#ifndef DGEMM_DEFAULT_R +#define DGEMM_DEFAULT_R (((BUFFER_SIZE - ((DGEMM_DEFAULT_P * DGEMM_DEFAULT_Q * 8 + GEMM_DEFAULT_OFFSET_A + GEMM_DEFAULT_ALIGN) & ~GEMM_DEFAULT_ALIGN)) / (DGEMM_DEFAULT_Q * 8) - 15) & ~15) +#endif + +#ifndef QGEMM_DEFAULT_R +#define QGEMM_DEFAULT_R (((BUFFER_SIZE - ((QGEMM_DEFAULT_P * QGEMM_DEFAULT_Q * 16 + GEMM_DEFAULT_OFFSET_A + GEMM_DEFAULT_ALIGN) & ~GEMM_DEFAULT_ALIGN)) / (QGEMM_DEFAULT_Q * 16) - 15) & ~15) +#endif + +#ifndef CGEMM_DEFAULT_R +#define CGEMM_DEFAULT_R (((BUFFER_SIZE - ((CGEMM_DEFAULT_P * CGEMM_DEFAULT_Q * 8 + GEMM_DEFAULT_OFFSET_A + GEMM_DEFAULT_ALIGN) & ~GEMM_DEFAULT_ALIGN)) / (CGEMM_DEFAULT_Q * 8) - 15) & ~15) +#endif + +#ifndef ZGEMM_DEFAULT_R +#define ZGEMM_DEFAULT_R (((BUFFER_SIZE - ((ZGEMM_DEFAULT_P * ZGEMM_DEFAULT_Q * 16 + GEMM_DEFAULT_OFFSET_A + GEMM_DEFAULT_ALIGN) & ~GEMM_DEFAULT_ALIGN)) / (ZGEMM_DEFAULT_Q * 16) - 15) & ~15) +#endif + +#ifndef XGEMM_DEFAULT_R +#define XGEMM_DEFAULT_R (((BUFFER_SIZE - ((XGEMM_DEFAULT_P * XGEMM_DEFAULT_Q * 32 + GEMM_DEFAULT_OFFSET_A + GEMM_DEFAULT_ALIGN) & ~GEMM_DEFAULT_ALIGN)) / (XGEMM_DEFAULT_Q * 32) - 15) & ~15) +#endif + +#ifndef SNUMOPT +#define SNUMOPT 2 +#endif + +#ifndef DNUMOPT +#define DNUMOPT 2 +#endif + +#ifndef QNUMOPT +#define QNUMOPT 1 +#endif + +#ifndef GEMM3M_P +#ifdef XDOUBLE +#define GEMM3M_P QGEMM_P +#elif defined(DOUBLE) +#define GEMM3M_P DGEMM_P +#else +#define GEMM3M_P SGEMM_P +#endif +#endif + +#ifndef GEMM3M_Q +#ifdef XDOUBLE +#define GEMM3M_Q QGEMM_Q +#elif defined(DOUBLE) +#define GEMM3M_Q DGEMM_Q +#else +#define GEMM3M_Q SGEMM_Q +#endif +#endif + +#ifndef GEMM3M_R +#ifdef XDOUBLE +#define GEMM3M_R QGEMM_R +#elif defined(DOUBLE) +#define GEMM3M_R DGEMM_R +#else +#define GEMM3M_R SGEMM_R +#endif +#endif + + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_power.h b/src/NativeWrappers/GotoBlas2/include/common_power.h new file mode 100644 index 00000000..34a61539 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_power.h @@ -0,0 +1,795 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef COMMON_POWER +#define COMMON_POWER + +#define MB __asm__ __volatile__ ("sync") +#define WMB __asm__ __volatile__ ("sync") + +#define INLINE inline + +#ifdef PPC440 +#define STDERR stdout +#define QNONCACHE 0x1 +#define QCOMMS 0x2 +#define QFAST 0x4 +#endif + +#ifndef ASSEMBLER + +void *qalloc(int flags, size_t bytes); + +static void INLINE blas_lock(volatile unsigned long *address){ + + long int ret, val = 1; + + do { + while (*address) {YIELDING;}; + +#if defined(OS_LINUX) || defined(OS_DARWIN) + __asm__ __volatile__ ( + "0: lwarx %0, 0, %1\n" + " cmpwi %0, 0\n" + " bne- 1f\n" + " stwcx. %2,0, %1\n" + " bne- 0b\n" + "1: " + : "=&r"(ret) + : "r"(address), "r" (val) + : "cr0", "memory"); +#else + __asm__ __volatile__ ( + ".machine \"any\"\n" + " lwarx %0, 0, %1\n" + " cmpwi %0, 0\n" + " bne- $+12\n" + " stwcx. %2,0, %1\n" + " bne- $-16\n" + : "=&r"(ret) + : "r"(address), "r" (val) + : "cr0", "memory"); +#endif + } while (ret); +} + +static inline unsigned long rpcc(void){ + unsigned long ret; + +#ifdef OS_AIX + __asm__ __volatile__(".machine \"any\" ;"); +#endif + __asm__ __volatile__ ("mftb %0" : "=r" (ret) : ); + +#if defined(POWER5) || defined(PPC970) + return (ret << 6); +#else + return (ret << 3); +#endif + +} + +#ifdef __64BIT__ +#define RPCC64BIT +#endif + +static inline unsigned long getstackaddr(void){ + unsigned long addr; + + __asm__ __volatile__ ("mr %0, 1" + : "=r"(addr) : : "memory"); + + return addr; +}; + +#if defined(OS_LINUX) || defined(OS_AIX) +#define GET_IMAGE(res) __asm__ __volatile__("fmr %0, 2" : "=f"(res) : : "memory") +#else +#define GET_IMAGE(res) __asm__ __volatile__("fmr %0, f2" : "=f"(res) : : "memory") + +#define GET_IMAGE_CANCEL + +#endif + +#ifdef SMP +static inline int blas_quickdivide(blasint x, blasint y){ + return x / y; +} +#endif + +#endif + + +#ifdef ASSEMBLER + +#ifdef DOUBLE +#define LFD lfd +#define LFDX lfdx +#define LFPDX lfpdx +#define LFSDX lfsdx +#define LFXDX lfxdx +#define LFDU lfdu +#define LFDUX lfdux +#define LFPDUX lfpdux +#define LFSDUX lfsdux +#define LFXDUX lfxdux +#define STFD stfd +#define STFDX stfdx +#define STFPDX stfpdx +#define STFSDX stfsdx +#define STFXDX stfxdx +#define STFDU stfdu +#define STFDUX stfdux +#define STFPDUX stfpdux +#define STFSDUX stfsdux +#define STFXDUX stfxdux +#define FMADD fmadd +#define FMSUB fmsub +#define FNMADD fnmadd +#define FNMSUB fnmsub +#define FMUL fmul +#define FADD fadd +#define FSUB fsub +#else +#define LFD lfs +#define LFDX lfsx +#define LFPDX lfpsx +#define LFSDX lfssx +#define LFXDX lfxsx +#define LFDU lfsu +#define LFDUX lfsux +#define LFPDUX lfpsux +#define LFSDUX lfssux +#define LFXDUX lfxsux +#define STFD stfs +#define STFDX stfsx +#define STFPDX stfpsx +#define STFSDX stfssx +#define STFXDX stfxsx +#define STFDU stfsu +#define STFDUX stfsux +#define STFPDUX stfpsux +#define STFSDUX stfssux +#define STFXDUX stfxsux +#define FMADD fmadds +#define FMSUB fmsubs +#define FNMADD fnmadds +#define FNMSUB fnmsubs +#define FMUL fmuls +#define FADD fadds +#define FSUB fsubs +#endif + +#ifdef __64BIT__ +#define LDLONG ld +#else +#define LDLONG lwz +#endif + +#ifdef OS_DARWIN +#define LL(x) L##x +#endif + +#ifdef OS_LINUX +#define LL(x) .L##x +#endif + +#ifndef LL +#define LL(x) __L##x +#endif + + +#if defined(__64BIT__) && defined(USE64BITINT) +#define LDINT ld +#elif defined(__64BIT__) && !defined(USE64BITINT) +#define LDINT lwa +#else +#define LDINT lwz +#endif + +/* +#define DCBT(REGA, REGB, NUM) .long (0x7c00022c | (REGA << 16) | (REGB << 11) | ((NUM) << 21)) +#define DCBTST(REGA, REGB, NUM) .long (0x7c0001ec | (REGA << 16) | (REGB << 11) | ((NUM) << 21)) +*/ + +#define DSTATTR_H(SIZE, COUNT, STRIDE) ((SIZE << 8) | (COUNT)) +#define DSTATTR_L(SIZE, COUNT, STRIDE) (STRIDE) + +#if defined(PPC970) || defined(POWER3) || defined(POWER4) || defined(POWER5) || defined(PPCG4) +#define HAVE_PREFETCH +#endif + +#if defined(POWER3) || defined(POWER6) || defined(PPCG4) || defined(CELL) +#define DCBT_ARG 0 +#else +#define DCBT_ARG 8 +#endif + +#ifdef CELL +#define L1_DUALFETCH +#define L1_PREFETCHSIZE (64 + 128 * 13) +#endif + +#if defined(POWER3) || defined(POWER4) || defined(POWER5) +#define L1_DUALFETCH +#define L1_PREFETCHSIZE (96 + 128 * 12) +#endif + +#if defined(POWER6) +#define L1_DUALFETCH +#define L1_PREFETCHSIZE (16 + 128 * 100) +#define L1_PREFETCH dcbtst +#endif + +#ifndef L1_PREFETCH +#define L1_PREFETCH dcbt +#endif + +#ifndef L1_PREFETCHW +#define L1_PREFETCHW dcbtst +#endif + +#if DCBT_ARG == 0 +#define DCBT(REGA, REGB) L1_PREFETCH REGB, REGA +#define DCBTST(REGA, REGB) L1_PREFETCHW REGB, REGA +#else +#define DCBT(REGA, REGB) L1_PREFETCH DCBT_ARG, REGB, REGA +#define DCBTST(REGA, REGB) L1_PREFETCHW DCBT_ARG, REGB, REGA +#endif + + +#ifndef L1_PREFETCHSIZE +#define L1_PREFETCHSIZE (96 + 128 * 12) +#endif + +#if !defined(OS_DARWIN) || defined(NEEDPARAM) +#define f0 0 +#define f1 1 +#define f2 2 +#define f3 3 +#define f4 4 +#define f5 5 +#define f6 6 +#define f7 7 +#define f8 8 +#define f9 9 +#define f10 10 +#define f11 11 +#define f12 12 +#define f13 13 +#define f14 14 +#define f15 15 +#define f16 16 +#define f17 17 +#define f18 18 +#define f19 19 +#define f20 20 +#define f21 21 +#define f22 22 +#define f23 23 +#define f24 24 +#define f25 25 +#define f26 26 +#define f27 27 +#define f28 28 +#define f29 29 +#define f30 30 +#define f31 31 + +#define r0 0 +#define r1 1 +#define r2 2 +#define r3 3 +#define r4 4 +#define r5 5 +#define r6 6 +#define r7 7 +#define r8 8 +#define r9 9 +#define r10 10 +#define r11 11 +#define r12 12 +#define r13 13 +#define r14 14 +#define r15 15 +#define r16 16 +#define r17 17 +#define r18 18 +#define r19 19 +#define r20 20 +#define r21 21 +#define r22 22 +#define r23 23 +#define r24 24 +#define r25 25 +#define r26 26 +#define r27 27 +#define r28 28 +#define r29 29 +#define r30 30 +#define r31 31 + +#define v0 0 +#define v1 1 +#define v2 2 +#define v3 3 +#define v4 4 +#define v5 5 +#define v6 6 +#define v7 7 +#define v8 8 +#define v9 9 +#define v10 10 +#define v11 11 +#define v12 12 +#define v13 13 +#define v14 14 +#define v15 15 +#define v16 16 +#define v17 17 +#define v18 18 +#define v19 19 +#define v20 20 +#define v21 21 +#define v22 22 +#define v23 23 +#define v24 24 +#define v25 25 +#define v26 26 +#define v27 27 +#define v28 28 +#define v29 29 +#define v30 30 +#define v31 31 + +#define BO_dCTR_NZERO_AND_NOT 0 +#define BO_dCTR_NZERO_AND_NOT_1 1 +#define BO_dCTR_ZERO_AND_NOT 2 +#define BO_dCTR_ZERO_AND_NOT_1 3 +#define BO_IF_NOT 4 +#define BO_IF_NOT_1 5 +#define BO_IF_NOT_2 6 +#define BO_IF_NOT_3 7 +#define BO_dCTR_NZERO_AND 8 +#define BO_dCTR_NZERO_AND_1 9 +#define BO_dCTR_ZERO_AND 10 +#define BO_dCTR_ZERO_AND_1 11 +#define BO_IF 12 +#define BO_IF_1 13 +#define BO_IF_2 14 +#define BO_IF_3 15 +#define BO_dCTR_NZERO 16 +#define BO_dCTR_NZERO_1 17 +#define BO_dCTR_ZERO 18 +#define BO_dCTR_ZERO_1 19 +#define BO_ALWAYS 20 +#define BO_ALWAYS_1 21 +#define BO_ALWAYS_2 22 +#define BO_ALWAYS_3 23 +#define BO_dCTR_NZERO_8 24 +#define BO_dCTR_NZERO_9 25 +#define BO_dCTR_ZERO_8 26 +#define BO_dCTR_ZERO_9 27 +#define BO_ALWAYS_8 28 +#define BO_ALWAYS_9 29 +#define BO_ALWAYS_10 30 +#define BO_ALWAYS_11 31 + +#define CR0_LT 0 +#define CR0_GT 1 +#define CR0_EQ 2 +#define CR0_SO 3 +#define CR1_FX 4 +#define CR1_FEX 5 +#define CR1_VX 6 +#define CR1_OX 7 +#define CR2_LT 8 +#define CR2_GT 9 +#define CR2_EQ 10 +#define CR2_SO 11 +#define CR3_LT 12 +#define CR3_GT 13 +#define CR3_EQ 14 +#define CR3_SO 15 +#define CR4_LT 16 +#define CR4_GT 17 +#define CR4_EQ 18 +#define CR4_SO 19 +#define CR5_LT 20 +#define CR5_GT 21 +#define CR5_EQ 22 +#define CR5_SO 23 +#define CR6_LT 24 +#define CR6_GT 25 +#define CR6_EQ 26 +#define CR6_SO 27 +#define CR7_LT 28 +#define CR7_GT 29 +#define CR7_EQ 30 +#define CR7_SO 31 +#define TO_LT 16 +#define TO_GT 8 +#define TO_EQ 4 +#define TO_LLT 2 +#define TO_LGT 1 +#define CR0 0 +#define CR1 1 +#define CR2 2 +#define CR3 3 +#define CR4 4 +#define CR5 5 +#define CR6 6 +#define CR7 7 +#define cr0 0 +#define cr1 1 +#define cr2 2 +#define cr3 3 +#define cr4 4 +#define cr5 5 +#define cr6 6 +#define cr7 7 +#define VRsave 256 + +#endif + +#define CTR 9 +#define SP r1 + +#ifdef __64BIT__ +#define slwi sldi +#define cmpwi cmpdi +#define srawi sradi +#define mullw mulld +#endif + +#ifndef F_INTERFACE +#define REALNAME ASMNAME +#else +#define REALNAME ASMFNAME +#endif + +#if defined(ASSEMBLER) && !defined(NEEDPARAM) + +#ifdef OS_LINUX +#ifndef __64BIT__ +#define PROLOGUE \ + .section .text;\ + .align 6;\ + .globl REALNAME;\ + .type REALNAME, @function;\ +REALNAME: +#define EPILOGUE .size REALNAME, .-REALNAME +#else +#define PROLOGUE \ + .section .text;\ + .align 5;\ + .globl REALNAME;\ + .section ".opd","aw";\ + .align 3;\ +REALNAME:;\ + .quad .REALNAME, .TOC.@tocbase, 0;\ + .previous;\ + .size REALNAME, 24;\ + .type .REALNAME, @function;\ + .globl .REALNAME;\ +.REALNAME: +#define EPILOGUE \ + .long 0 ; \ + .byte 0,0,0,1,128,0,0,0 ; \ + .size .REALNAME, .-.REALNAME; \ + .section .note.GNU-stack,"",@progbits +#endif + +#ifdef PROFILE +#ifndef __64BIT__ +#define PROFCODE ;\ + .section ".data";\ + .align 2;\ +.LP3:;\ + .long 0;\ + .section ".text";\ + mflr r0;\ + stw r0, 4(SP);\ + lis r12, .LP3@ha;\ + la r0, .LP3@l(r12);\ + bl _mcount;\ + lwz r0, 4(SP);\ + mtlr r0 +#else +#define PROFCODE \ + .globl _mcount; \ + mflr r0; \ + std r0, 16(SP); \ + mr r11, SP; \ + addi SP, SP, -256; \ + std r11, 0(SP); \ + std r3, 128(SP); \ + std r4, 136(SP); \ + std r5, 144(SP); \ + std r6, 152(SP); \ + std r7, 160(SP); \ + std r8, 168(SP); \ + std r9, 176(SP); \ + std r10, 184(SP); \ + stfd f3, 192(SP); \ + stfd f4, 200(SP); \ + bl ._mcount; \ + nop; \ + ld r3, 128(SP);\ + ld r4, 136(SP);\ + ld r5, 144(SP);\ + ld r6, 152(SP);\ + ld r7, 160(SP);\ + ld r8, 168(SP);\ + ld r9, 176(SP);\ + ld r10, 184(SP);\ + lfd f3, 192(SP);\ + lfd f4, 200(SP);\ + addi SP, SP, 256;\ + ld r0, 16(SP);\ + mtlr r0 +#endif +#else +#define PROFCODE +#endif + +#endif + +#if OS_AIX +#ifndef __64BIT__ +#define PROLOGUE \ + .machine "any";\ + .globl .REALNAME;\ + .csect .text[PR],5;\ +.REALNAME:; + +#define EPILOGUE \ +_section_.text:;\ + .csect .data[RW],4;\ + .long _section_.text; + +#else + +#define PROLOGUE \ + .machine "any";\ + .globl .REALNAME;\ + .csect .text[PR], 5;\ +.REALNAME:; + +#define EPILOGUE \ +_section_.text:;\ + .csect .data[RW],4;\ + .llong _section_.text; +#endif + +#define PROFCODE + +#endif + +#ifdef OS_DARWIN +#ifndef __64BIT__ + .macro PROLOGUE + .section __TEXT,__text,regular,pure_instructions + .section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32 + .machine ppc + .text + .align 4 + .globl REALNAME +REALNAME: + .endmacro +#else + .macro PROLOGUE + .section __TEXT,__text,regular,pure_instructions + .section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32 + .machine ppc64 + .text + .align 4 + .globl REALNAME +REALNAME: + .endmacro +#endif + +#ifndef PROFILE +#define PROFCODE +#define EPILOGUE .subsections_via_symbols +#else +#ifndef __64BIT__ + + .macro PROFCODE + mflr r0 + stw r0, 8(SP) + addi SP, SP, -64 + stw SP, 0(SP) + stw r3, 12(SP) + stw r4, 16(SP) + stw r5, 20(SP) + stw r6, 24(SP) + stw r7, 28(SP) + stw r8, 32(SP) + stw r9, 36(SP) + stw r10, 40(SP) + stfd f1, 48(SP) + stfd f2, 56(SP) + mr r3, r0 + bl Lmcount$stub + nop + lwz r3, 12(SP) + lwz r4, 16(SP) + lwz r5, 20(SP) + lwz r6, 24(SP) + lwz r7, 28(SP) + lwz r8, 32(SP) + lwz r9, 36(SP) + lwz r10, 40(SP) + lfd f1, 48(SP) + lfd f2, 56(SP) + addi SP, SP, 64 + lwz r0, 8(SP) + mtlr r0 + .endmacro + + .macro EPILOGUE + .section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32 + .align 5 +Lmcount$stub: + .indirect_symbol mcount + mflr r0 + bcl 20,31,L00000000001$spb +L00000000001$spb: + mflr r11 + addis r11,r11,ha16(Lmcount$lazy_ptr-L00000000001$spb) + mtlr r0 + lwzu r12,lo16(Lmcount$lazy_ptr-L00000000001$spb)(r11) + mtctr r12 + bctr + .lazy_symbol_pointer +Lmcount$lazy_ptr: + .indirect_symbol mcount + .long dyld_stub_binding_helper + .subsections_via_symbols + .endmacro + +#else + .macro PROFCODE + mflr r0 + std r0, 16(SP) + addi SP, SP, -128 + std SP, 0(SP) + std r3, 24(SP) + std r4, 32(SP) + std r5, 40(SP) + std r6, 48(SP) + std r7, 56(SP) + std r8, 64(SP) + std r9, 72(SP) + std r10, 80(SP) + stfd f1, 88(SP) + stfd f2, 96(SP) + mr r3, r0 + bl Lmcount$stub + nop + ld r3, 24(SP) + ld r4, 32(SP) + ld r5, 40(SP) + ld r6, 48(SP) + ld r7, 56(SP) + ld r8, 64(SP) + ld r9, 72(SP) + ld r10, 80(SP) + lfd f1, 88(SP) + lfd f2, 86(SP) + addi SP, SP, 128 + ld r0, 16(SP) + mtlr r0 + .endmacro + + .macro EPILOGUE + .data + .section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32 + .align 5 +Lmcount$stub: + .indirect_symbol mcount + mflr r0 + bcl 20,31,L00000000001$spb +L00000000001$spb: + mflr r11 + addis r11,r11,ha16(Lmcount$lazy_ptr-L00000000001$spb) + mtlr r0 + ld r12,lo16(Lmcount$lazy_ptr-L00000000001$spb)(r11) + mtctr r12 + bctr + .lazy_symbol_pointer +Lmcount$lazy_ptr: + .indirect_symbol mcount + .quad dyld_stub_binding_helper + .subsections_via_symbols + .endmacro +#endif + +#endif + +#endif +#endif + +#endif + +#define HALT mfspr r0, 1023 + +#ifdef OS_LINUX +#if defined(PPC440) || defined(PPC440FP2) +#undef MAX_CPU_NUMBER +#define MAX_CPU_NUMBER 1 +#endif +#if !defined(__64BIT__) && !defined(PROFILE) && !defined(PPC440) && !defined(PPC440FP2) +#define START_ADDRESS (0x0b000000UL) +#else +#define SEEK_ADDRESS +#endif +#endif + +#ifdef OS_AIX +#ifndef __64BIT__ +#define START_ADDRESS (0xf0000000UL) +#else +#define SEEK_ADDRESS +#endif +#endif + +#ifdef OS_DARWIN +#define SEEK_ADDRESS +#endif + +#if defined(PPC440) +#define BUFFER_SIZE ( 2 << 20) +#elif defined(PPC440FP2) +#define BUFFER_SIZE ( 16 << 20) +#else +#define BUFFER_SIZE ( 16 << 20) +#endif + +#ifndef PAGESIZE +#define PAGESIZE ( 4 << 10) +#endif +#define HUGE_PAGESIZE (16 << 20) + +#define BASE_ADDRESS (START_ADDRESS - BUFFER_SIZE * MAX_CPU_NUMBER) + +#ifndef MAP_ANONYMOUS +#define MAP_ANONYMOUS MAP_ANON +#endif +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_q.h b/src/NativeWrappers/GotoBlas2/include/common_q.h new file mode 100644 index 00000000..30ad3727 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_q.h @@ -0,0 +1,431 @@ +#ifndef COMMON_Q_H +#define COMMON_Q_H + +#ifndef DYNAMIC_ARCH + +#define QAMAX_K qamax_k +#define QAMIN_K qamin_k +#define QMAX_K qmax_k +#define QMIN_K qmin_k +#define IQAMAX_K iqamax_k +#define IQAMIN_K iqamin_k +#define IQMAX_K iqmax_k +#define IQMIN_K iqmin_k +#define QASUM_K qasum_k +#define QAXPYU_K qaxpy_k +#define QAXPYC_K qaxpy_k +#define QCOPY_K qcopy_k +#define QDOTU_K qdot_k +#define QDOTC_K qdot_k +#define QNRM2_K qnrm2_k +#define QSCAL_K qscal_k +#define QSWAP_K qswap_k +#define QROT_K qrot_k + +#define QGEMV_N qgemv_n +#define QGEMV_T qgemv_t +#define QGEMV_R qgemv_n +#define QGEMV_C qgemv_t +#define QGEMV_O qgemv_n +#define QGEMV_U qgemv_t +#define QGEMV_S qgemv_n +#define QGEMV_D qgemv_t + +#define QGERU_K qger_k +#define QGERC_K qger_k +#define QGERV_K qger_k +#define QGERD_K qger_k + +#define QSYMV_U qsymv_U +#define QSYMV_L qsymv_L +#define QSYMV_THREAD_U qsymv_thread_U +#define QSYMV_THREAD_L qsymv_thread_L + +#define QGEMM_ONCOPY qgemm_oncopy +#define QGEMM_OTCOPY qgemm_otcopy + +#if QGEMM_DEFAULT_UNROLL_M == QGEMM_DEFAULT_UNROLL_N +#define QGEMM_INCOPY qgemm_oncopy +#define QGEMM_ITCOPY qgemm_otcopy +#else +#define QGEMM_INCOPY qgemm_incopy +#define QGEMM_ITCOPY qgemm_itcopy +#endif + +#define QTRMM_OUNUCOPY qtrmm_ounucopy +#define QTRMM_OUNNCOPY qtrmm_ounncopy +#define QTRMM_OUTUCOPY qtrmm_outucopy +#define QTRMM_OUTNCOPY qtrmm_outncopy +#define QTRMM_OLNUCOPY qtrmm_olnucopy +#define QTRMM_OLNNCOPY qtrmm_olnncopy +#define QTRMM_OLTUCOPY qtrmm_oltucopy +#define QTRMM_OLTNCOPY qtrmm_oltncopy + +#define QTRSM_OUNUCOPY qtrsm_ounucopy +#define QTRSM_OUNNCOPY qtrsm_ounncopy +#define QTRSM_OUTUCOPY qtrsm_outucopy +#define QTRSM_OUTNCOPY qtrsm_outncopy +#define QTRSM_OLNUCOPY qtrsm_olnucopy +#define QTRSM_OLNNCOPY qtrsm_olnncopy +#define QTRSM_OLTUCOPY qtrsm_oltucopy +#define QTRSM_OLTNCOPY qtrsm_oltncopy + +#if QGEMM_DEFAULT_UNROLL_M == QGEMM_DEFAULT_UNROLL_N +#define QTRMM_IUNUCOPY qtrmm_ounucopy +#define QTRMM_IUNNCOPY qtrmm_ounncopy +#define QTRMM_IUTUCOPY qtrmm_outucopy +#define QTRMM_IUTNCOPY qtrmm_outncopy +#define QTRMM_ILNUCOPY qtrmm_olnucopy +#define QTRMM_ILNNCOPY qtrmm_olnncopy +#define QTRMM_ILTUCOPY qtrmm_oltucopy +#define QTRMM_ILTNCOPY qtrmm_oltncopy + +#define QTRSM_IUNUCOPY qtrsm_ounucopy +#define QTRSM_IUNNCOPY qtrsm_ounncopy +#define QTRSM_IUTUCOPY qtrsm_outucopy +#define QTRSM_IUTNCOPY qtrsm_outncopy +#define QTRSM_ILNUCOPY qtrsm_olnucopy +#define QTRSM_ILNNCOPY qtrsm_olnncopy +#define QTRSM_ILTUCOPY qtrsm_oltucopy +#define QTRSM_ILTNCOPY qtrsm_oltncopy +#else +#define QTRMM_IUNUCOPY qtrmm_iunucopy +#define QTRMM_IUNNCOPY qtrmm_iunncopy +#define QTRMM_IUTUCOPY qtrmm_iutucopy +#define QTRMM_IUTNCOPY qtrmm_iutncopy +#define QTRMM_ILNUCOPY qtrmm_ilnucopy +#define QTRMM_ILNNCOPY qtrmm_ilnncopy +#define QTRMM_ILTUCOPY qtrmm_iltucopy +#define QTRMM_ILTNCOPY qtrmm_iltncopy + +#define QTRSM_IUNUCOPY qtrsm_iunucopy +#define QTRSM_IUNNCOPY qtrsm_iunncopy +#define QTRSM_IUTUCOPY qtrsm_iutucopy +#define QTRSM_IUTNCOPY qtrsm_iutncopy +#define QTRSM_ILNUCOPY qtrsm_ilnucopy +#define QTRSM_ILNNCOPY qtrsm_ilnncopy +#define QTRSM_ILTUCOPY qtrsm_iltucopy +#define QTRSM_ILTNCOPY qtrsm_iltncopy +#endif + +#define QGEMM_BETA qgemm_beta + +#define QGEMM_KERNEL qgemm_kernel + +#define QTRMM_KERNEL_LN qtrmm_kernel_LN +#define QTRMM_KERNEL_LT qtrmm_kernel_LT +#define QTRMM_KERNEL_LR qtrmm_kernel_LN +#define QTRMM_KERNEL_LC qtrmm_kernel_LT +#define QTRMM_KERNEL_RN qtrmm_kernel_RN +#define QTRMM_KERNEL_RT qtrmm_kernel_RT +#define QTRMM_KERNEL_RR qtrmm_kernel_RN +#define QTRMM_KERNEL_RC qtrmm_kernel_RT + +#define QTRSM_KERNEL_LN qtrsm_kernel_LN +#define QTRSM_KERNEL_LT qtrsm_kernel_LT +#define QTRSM_KERNEL_LR qtrsm_kernel_LN +#define QTRSM_KERNEL_LC qtrsm_kernel_LT +#define QTRSM_KERNEL_RN qtrsm_kernel_RN +#define QTRSM_KERNEL_RT qtrsm_kernel_RT +#define QTRSM_KERNEL_RR qtrsm_kernel_RN +#define QTRSM_KERNEL_RC qtrsm_kernel_RT + +#define QSYMM_OUTCOPY qsymm_outcopy +#define QSYMM_OLTCOPY qsymm_oltcopy +#if QGEMM_DEFAULT_UNROLL_M == QGEMM_DEFAULT_UNROLL_N +#define QSYMM_IUTCOPY qsymm_outcopy +#define QSYMM_ILTCOPY qsymm_oltcopy +#else +#define QSYMM_IUTCOPY qsymm_iutcopy +#define QSYMM_ILTCOPY qsymm_iltcopy +#endif + +#define QNEG_TCOPY qneg_tcopy +#define QLASWP_NCOPY qlaswp_ncopy + +#else + +#define QAMAX_K gotoblas -> qamax_k +#define QAMIN_K gotoblas -> qamin_k +#define QMAX_K gotoblas -> qmax_k +#define QMIN_K gotoblas -> qmin_k +#define IQAMAX_K gotoblas -> iqamax_k +#define IQAMIN_K gotoblas -> iqamin_k +#define IQMAX_K gotoblas -> iqmax_k +#define IQMIN_K gotoblas -> iqmin_k +#define QASUM_K gotoblas -> qasum_k +#define QAXPYU_K gotoblas -> qaxpy_k +#define QAXPYC_K gotoblas -> qaxpy_k +#define QCOPY_K gotoblas -> qcopy_k +#define QDOTU_K gotoblas -> qdot_k +#define QDOTC_K gotoblas -> qdot_k +#define QNRM2_K gotoblas -> qnrm2_k +#define QSCAL_K gotoblas -> qscal_k +#define QSWAP_K gotoblas -> qswap_k +#define QROT_K gotoblas -> qrot_k + +#define QGEMV_N gotoblas -> qgemv_n +#define QGEMV_T gotoblas -> qgemv_t +#define QGEMV_R gotoblas -> qgemv_n +#define QGEMV_C gotoblas -> qgemv_t +#define QGEMV_O gotoblas -> qgemv_n +#define QGEMV_U gotoblas -> qgemv_t +#define QGEMV_S gotoblas -> qgemv_n +#define QGEMV_D gotoblas -> qgemv_t + +#define QGERU_K gotoblas -> qger_k +#define QGERC_K gotoblas -> qger_k +#define QGERV_K gotoblas -> qger_k +#define QGERD_K gotoblas -> qger_k + +#define QSYMV_U gotoblas -> qsymv_U +#define QSYMV_L gotoblas -> qsymv_L + +#define QSYMV_THREAD_U qsymv_thread_U +#define QSYMV_THREAD_L qsymv_thread_L + +#define QGEMM_ONCOPY gotoblas -> qgemm_oncopy +#define QGEMM_OTCOPY gotoblas -> qgemm_otcopy +#define QGEMM_INCOPY gotoblas -> qgemm_incopy +#define QGEMM_ITCOPY gotoblas -> qgemm_itcopy + +#define QTRMM_OUNUCOPY gotoblas -> qtrmm_ounucopy +#define QTRMM_OUTUCOPY gotoblas -> qtrmm_outucopy +#define QTRMM_OLNUCOPY gotoblas -> qtrmm_olnucopy +#define QTRMM_OLTUCOPY gotoblas -> qtrmm_oltucopy +#define QTRSM_OUNUCOPY gotoblas -> qtrsm_ounucopy +#define QTRSM_OUTUCOPY gotoblas -> qtrsm_outucopy +#define QTRSM_OLNUCOPY gotoblas -> qtrsm_olnucopy +#define QTRSM_OLTUCOPY gotoblas -> qtrsm_oltucopy + +#define QTRMM_IUNUCOPY gotoblas -> qtrmm_iunucopy +#define QTRMM_IUTUCOPY gotoblas -> qtrmm_iutucopy +#define QTRMM_ILNUCOPY gotoblas -> qtrmm_ilnucopy +#define QTRMM_ILTUCOPY gotoblas -> qtrmm_iltucopy +#define QTRSM_IUNUCOPY gotoblas -> qtrsm_iunucopy +#define QTRSM_IUTUCOPY gotoblas -> qtrsm_iutucopy +#define QTRSM_ILNUCOPY gotoblas -> qtrsm_ilnucopy +#define QTRSM_ILTUCOPY gotoblas -> qtrsm_iltucopy + +#define QTRMM_OUNNCOPY gotoblas -> qtrmm_ounncopy +#define QTRMM_OUTNCOPY gotoblas -> qtrmm_outncopy +#define QTRMM_OLNNCOPY gotoblas -> qtrmm_olnncopy +#define QTRMM_OLTNCOPY gotoblas -> qtrmm_oltncopy +#define QTRSM_OUNNCOPY gotoblas -> qtrsm_ounncopy +#define QTRSM_OUTNCOPY gotoblas -> qtrsm_outncopy +#define QTRSM_OLNNCOPY gotoblas -> qtrsm_olnncopy +#define QTRSM_OLTNCOPY gotoblas -> qtrsm_oltncopy + +#define QTRMM_IUNNCOPY gotoblas -> qtrmm_iunncopy +#define QTRMM_IUTNCOPY gotoblas -> qtrmm_iutncopy +#define QTRMM_ILNNCOPY gotoblas -> qtrmm_ilnncopy +#define QTRMM_ILTNCOPY gotoblas -> qtrmm_iltncopy +#define QTRSM_IUNNCOPY gotoblas -> qtrsm_iunncopy +#define QTRSM_IUTNCOPY gotoblas -> qtrsm_iutncopy +#define QTRSM_ILNNCOPY gotoblas -> qtrsm_ilnncopy +#define QTRSM_ILTNCOPY gotoblas -> qtrsm_iltncopy + +#define QGEMM_BETA gotoblas -> qgemm_beta +#define QGEMM_KERNEL gotoblas -> qgemm_kernel + +#define QTRMM_KERNEL_LN gotoblas -> qtrmm_kernel_LN +#define QTRMM_KERNEL_LT gotoblas -> qtrmm_kernel_LT +#define QTRMM_KERNEL_LR gotoblas -> qtrmm_kernel_LN +#define QTRMM_KERNEL_LC gotoblas -> qtrmm_kernel_LT +#define QTRMM_KERNEL_RN gotoblas -> qtrmm_kernel_RN +#define QTRMM_KERNEL_RT gotoblas -> qtrmm_kernel_RT +#define QTRMM_KERNEL_RR gotoblas -> qtrmm_kernel_RN +#define QTRMM_KERNEL_RC gotoblas -> qtrmm_kernel_RT + +#define QTRSM_KERNEL_LN gotoblas -> qtrsm_kernel_LN +#define QTRSM_KERNEL_LT gotoblas -> qtrsm_kernel_LT +#define QTRSM_KERNEL_LR gotoblas -> qtrsm_kernel_LN +#define QTRSM_KERNEL_LC gotoblas -> qtrsm_kernel_LT +#define QTRSM_KERNEL_RN gotoblas -> qtrsm_kernel_RN +#define QTRSM_KERNEL_RT gotoblas -> qtrsm_kernel_RT +#define QTRSM_KERNEL_RR gotoblas -> qtrsm_kernel_RN +#define QTRSM_KERNEL_RC gotoblas -> qtrsm_kernel_RT + +#define QSYMM_IUTCOPY gotoblas -> qsymm_iutcopy +#define QSYMM_ILTCOPY gotoblas -> qsymm_iltcopy +#define QSYMM_OUTCOPY gotoblas -> qsymm_outcopy +#define QSYMM_OLTCOPY gotoblas -> qsymm_oltcopy + +#define QNEG_TCOPY gotoblas -> qneg_tcopy +#define QLASWP_NCOPY gotoblas -> qlaswp_ncopy + +#endif + +#define QGEMM_NN qgemm_nn +#define QGEMM_CN qgemm_tn +#define QGEMM_TN qgemm_tn +#define QGEMM_NC qgemm_nt +#define QGEMM_NT qgemm_nt +#define QGEMM_CC qgemm_tt +#define QGEMM_CT qgemm_tt +#define QGEMM_TC qgemm_tt +#define QGEMM_TT qgemm_tt +#define QGEMM_NR qgemm_nn +#define QGEMM_TR qgemm_tn +#define QGEMM_CR qgemm_tn +#define QGEMM_RN qgemm_nn +#define QGEMM_RT qgemm_nt +#define QGEMM_RC qgemm_nt +#define QGEMM_RR qgemm_nn + +#define QSYMM_LU qsymm_LU +#define QSYMM_LL qsymm_LL +#define QSYMM_RU qsymm_RU +#define QSYMM_RL qsymm_RL + +#define QHEMM_LU qhemm_LU +#define QHEMM_LL qhemm_LL +#define QHEMM_RU qhemm_RU +#define QHEMM_RL qhemm_RL + +#define QSYRK_UN qsyrk_UN +#define QSYRK_UT qsyrk_UT +#define QSYRK_LN qsyrk_LN +#define QSYRK_LT qsyrk_LT +#define QSYRK_UR qsyrk_UN +#define QSYRK_UC qsyrk_UT +#define QSYRK_LR qsyrk_LN +#define QSYRK_LC qsyrk_LT + +#define QSYRK_KERNEL_U qsyrk_kernel_U +#define QSYRK_KERNEL_L qsyrk_kernel_L + +#define QHERK_UN qsyrk_UN +#define QHERK_LN qsyrk_LN +#define QHERK_UC qsyrk_UT +#define QHERK_LC qsyrk_LT + +#define QHER2K_UN qsyr2k_UN +#define QHER2K_LN qsyr2k_LN +#define QHER2K_UC qsyr2k_UT +#define QHER2K_LC qsyr2k_LT + +#define QSYR2K_UN qsyr2k_UN +#define QSYR2K_UT qsyr2k_UT +#define QSYR2K_LN qsyr2k_LN +#define QSYR2K_LT qsyr2k_LT +#define QSYR2K_UR qsyr2k_UN +#define QSYR2K_UC qsyr2k_UT +#define QSYR2K_LR qsyr2k_LN +#define QSYR2K_LC qsyr2k_LT + +#define QSYR2K_KERNEL_U qsyr2k_kernel_U +#define QSYR2K_KERNEL_L qsyr2k_kernel_L + +#define QTRMM_LNUU qtrmm_LNUU +#define QTRMM_LNUN qtrmm_LNUN +#define QTRMM_LNLU qtrmm_LNLU +#define QTRMM_LNLN qtrmm_LNLN +#define QTRMM_LTUU qtrmm_LTUU +#define QTRMM_LTUN qtrmm_LTUN +#define QTRMM_LTLU qtrmm_LTLU +#define QTRMM_LTLN qtrmm_LTLN +#define QTRMM_LRUU qtrmm_LNUU +#define QTRMM_LRUN qtrmm_LNUN +#define QTRMM_LRLU qtrmm_LNLU +#define QTRMM_LRLN qtrmm_LNLN +#define QTRMM_LCUU qtrmm_LTUU +#define QTRMM_LCUN qtrmm_LTUN +#define QTRMM_LCLU qtrmm_LTLU +#define QTRMM_LCLN qtrmm_LTLN +#define QTRMM_RNUU qtrmm_RNUU +#define QTRMM_RNUN qtrmm_RNUN +#define QTRMM_RNLU qtrmm_RNLU +#define QTRMM_RNLN qtrmm_RNLN +#define QTRMM_RTUU qtrmm_RTUU +#define QTRMM_RTUN qtrmm_RTUN +#define QTRMM_RTLU qtrmm_RTLU +#define QTRMM_RTLN qtrmm_RTLN +#define QTRMM_RRUU qtrmm_RNUU +#define QTRMM_RRUN qtrmm_RNUN +#define QTRMM_RRLU qtrmm_RNLU +#define QTRMM_RRLN qtrmm_RNLN +#define QTRMM_RCUU qtrmm_RTUU +#define QTRMM_RCUN qtrmm_RTUN +#define QTRMM_RCLU qtrmm_RTLU +#define QTRMM_RCLN qtrmm_RTLN + +#define QTRSM_LNUU qtrsm_LNUU +#define QTRSM_LNUN qtrsm_LNUN +#define QTRSM_LNLU qtrsm_LNLU +#define QTRSM_LNLN qtrsm_LNLN +#define QTRSM_LTUU qtrsm_LTUU +#define QTRSM_LTUN qtrsm_LTUN +#define QTRSM_LTLU qtrsm_LTLU +#define QTRSM_LTLN qtrsm_LTLN +#define QTRSM_LRUU qtrsm_LNUU +#define QTRSM_LRUN qtrsm_LNUN +#define QTRSM_LRLU qtrsm_LNLU +#define QTRSM_LRLN qtrsm_LNLN +#define QTRSM_LCUU qtrsm_LTUU +#define QTRSM_LCUN qtrsm_LTUN +#define QTRSM_LCLU qtrsm_LTLU +#define QTRSM_LCLN qtrsm_LTLN +#define QTRSM_RNUU qtrsm_RNUU +#define QTRSM_RNUN qtrsm_RNUN +#define QTRSM_RNLU qtrsm_RNLU +#define QTRSM_RNLN qtrsm_RNLN +#define QTRSM_RTUU qtrsm_RTUU +#define QTRSM_RTUN qtrsm_RTUN +#define QTRSM_RTLU qtrsm_RTLU +#define QTRSM_RTLN qtrsm_RTLN +#define QTRSM_RRUU qtrsm_RNUU +#define QTRSM_RRUN qtrsm_RNUN +#define QTRSM_RRLU qtrsm_RNLU +#define QTRSM_RRLN qtrsm_RNLN +#define QTRSM_RCUU qtrsm_RTUU +#define QTRSM_RCUN qtrsm_RTUN +#define QTRSM_RCLU qtrsm_RTLU +#define QTRSM_RCLN qtrsm_RTLN + +#define QGEMM_THREAD_NN qgemm_thread_nn +#define QGEMM_THREAD_CN qgemm_thread_tn +#define QGEMM_THREAD_TN qgemm_thread_tn +#define QGEMM_THREAD_NC qgemm_thread_nt +#define QGEMM_THREAD_NT qgemm_thread_nt +#define QGEMM_THREAD_CC qgemm_thread_tt +#define QGEMM_THREAD_CT qgemm_thread_tt +#define QGEMM_THREAD_TC qgemm_thread_tt +#define QGEMM_THREAD_TT qgemm_thread_tt +#define QGEMM_THREAD_NR qgemm_thread_nn +#define QGEMM_THREAD_TR qgemm_thread_tn +#define QGEMM_THREAD_CR qgemm_thread_tn +#define QGEMM_THREAD_RN qgemm_thread_nn +#define QGEMM_THREAD_RT qgemm_thread_nt +#define QGEMM_THREAD_RC qgemm_thread_nt +#define QGEMM_THREAD_RR qgemm_thread_nn + +#define QSYMM_THREAD_LU qsymm_thread_LU +#define QSYMM_THREAD_LL qsymm_thread_LL +#define QSYMM_THREAD_RU qsymm_thread_RU +#define QSYMM_THREAD_RL qsymm_thread_RL + +#define QHEMM_THREAD_LU qhemm_thread_LU +#define QHEMM_THREAD_LL qhemm_thread_LL +#define QHEMM_THREAD_RU qhemm_thread_RU +#define QHEMM_THREAD_RL qhemm_thread_RL + +#define QSYRK_THREAD_UN qsyrk_thread_UN +#define QSYRK_THREAD_UT qsyrk_thread_UT +#define QSYRK_THREAD_LN qsyrk_thread_LN +#define QSYRK_THREAD_LT qsyrk_thread_LT +#define QSYRK_THREAD_UR qsyrk_thread_UN +#define QSYRK_THREAD_UC qsyrk_thread_UT +#define QSYRK_THREAD_LR qsyrk_thread_LN +#define QSYRK_THREAD_LC qsyrk_thread_LT + +#define QHERK_THREAD_UN qsyrk_thread_UN +#define QHERK_THREAD_UT qsyrk_thread_UT +#define QHERK_THREAD_LN qsyrk_thread_LN +#define QHERK_THREAD_LT qsyrk_thread_LT +#define QHERK_THREAD_UR qsyrk_thread_UN +#define QHERK_THREAD_UC qsyrk_thread_UT +#define QHERK_THREAD_LR qsyrk_thread_LN +#define QHERK_THREAD_LC qsyrk_thread_LT + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_reference.h b/src/NativeWrappers/GotoBlas2/include/common_reference.h new file mode 100644 index 00000000..e69de29b diff --git a/src/NativeWrappers/GotoBlas2/include/common_s.h b/src/NativeWrappers/GotoBlas2/include/common_s.h new file mode 100644 index 00000000..db8d69a0 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_s.h @@ -0,0 +1,436 @@ +#ifndef COMMON_S_H +#define COMMON_S_H + +#ifndef DYNAMIC_ARCH + +#define SAMAX_K samax_k +#define SAMIN_K samin_k +#define SMAX_K smax_k +#define SMIN_K smin_k +#define ISAMAX_K isamax_k +#define ISAMIN_K isamin_k +#define ISMAX_K ismax_k +#define ISMIN_K ismin_k +#define SASUM_K sasum_k +#define SAXPYU_K saxpy_k +#define SAXPYC_K saxpy_k +#define SCOPY_K scopy_k +#define SDOTU_K sdot_k +#define SDOTC_K sdot_k +#define SDSDOT_K sdot_k +#define DSDOT_K dsdot_k +#define SNRM2_K snrm2_k +#define SSCAL_K sscal_k +#define SSWAP_K sswap_k +#define SROT_K srot_k + +#define SGEMV_N sgemv_n +#define SGEMV_T sgemv_t +#define SGEMV_R sgemv_n +#define SGEMV_C sgemv_t +#define SGEMV_O sgemv_n +#define SGEMV_U sgemv_t +#define SGEMV_S sgemv_n +#define SGEMV_D sgemv_t + +#define SGERU_K sger_k +#define SGERC_K sger_k +#define SGERV_K sger_k +#define SGERD_K sger_k + +#define SSYMV_U ssymv_U +#define SSYMV_L ssymv_L + +#define SSYMV_THREAD_U ssymv_thread_U +#define SSYMV_THREAD_L ssymv_thread_L + +#define SGEMM_ONCOPY sgemm_oncopy +#define SGEMM_OTCOPY sgemm_otcopy + +#if SGEMM_DEFAULT_UNROLL_M == SGEMM_DEFAULT_UNROLL_N +#define SGEMM_INCOPY sgemm_oncopy +#define SGEMM_ITCOPY sgemm_otcopy +#else +#define SGEMM_INCOPY sgemm_incopy +#define SGEMM_ITCOPY sgemm_itcopy +#endif + +#define STRMM_OUNUCOPY strmm_ounucopy +#define STRMM_OUNNCOPY strmm_ounncopy +#define STRMM_OUTUCOPY strmm_outucopy +#define STRMM_OUTNCOPY strmm_outncopy +#define STRMM_OLNUCOPY strmm_olnucopy +#define STRMM_OLNNCOPY strmm_olnncopy +#define STRMM_OLTUCOPY strmm_oltucopy +#define STRMM_OLTNCOPY strmm_oltncopy + +#define STRSM_OUNUCOPY strsm_ounucopy +#define STRSM_OUNNCOPY strsm_ounncopy +#define STRSM_OUTUCOPY strsm_outucopy +#define STRSM_OUTNCOPY strsm_outncopy +#define STRSM_OLNUCOPY strsm_olnucopy +#define STRSM_OLNNCOPY strsm_olnncopy +#define STRSM_OLTUCOPY strsm_oltucopy +#define STRSM_OLTNCOPY strsm_oltncopy + +#if SGEMM_DEFAULT_UNROLL_M == SGEMM_DEFAULT_UNROLL_N +#define STRMM_IUNUCOPY strmm_ounucopy +#define STRMM_IUNNCOPY strmm_ounncopy +#define STRMM_IUTUCOPY strmm_outucopy +#define STRMM_IUTNCOPY strmm_outncopy +#define STRMM_ILNUCOPY strmm_olnucopy +#define STRMM_ILNNCOPY strmm_olnncopy +#define STRMM_ILTUCOPY strmm_oltucopy +#define STRMM_ILTNCOPY strmm_oltncopy + +#define STRSM_IUNUCOPY strsm_ounucopy +#define STRSM_IUNNCOPY strsm_ounncopy +#define STRSM_IUTUCOPY strsm_outucopy +#define STRSM_IUTNCOPY strsm_outncopy +#define STRSM_ILNUCOPY strsm_olnucopy +#define STRSM_ILNNCOPY strsm_olnncopy +#define STRSM_ILTUCOPY strsm_oltucopy +#define STRSM_ILTNCOPY strsm_oltncopy +#else +#define STRMM_IUNUCOPY strmm_iunucopy +#define STRMM_IUNNCOPY strmm_iunncopy +#define STRMM_IUTUCOPY strmm_iutucopy +#define STRMM_IUTNCOPY strmm_iutncopy +#define STRMM_ILNUCOPY strmm_ilnucopy +#define STRMM_ILNNCOPY strmm_ilnncopy +#define STRMM_ILTUCOPY strmm_iltucopy +#define STRMM_ILTNCOPY strmm_iltncopy + +#define STRSM_IUNUCOPY strsm_iunucopy +#define STRSM_IUNNCOPY strsm_iunncopy +#define STRSM_IUTUCOPY strsm_iutucopy +#define STRSM_IUTNCOPY strsm_iutncopy +#define STRSM_ILNUCOPY strsm_ilnucopy +#define STRSM_ILNNCOPY strsm_ilnncopy +#define STRSM_ILTUCOPY strsm_iltucopy +#define STRSM_ILTNCOPY strsm_iltncopy +#endif + +#define SGEMM_BETA sgemm_beta + +#define SGEMM_KERNEL sgemm_kernel + +#define STRMM_KERNEL_LN strmm_kernel_LN +#define STRMM_KERNEL_LT strmm_kernel_LT +#define STRMM_KERNEL_LR strmm_kernel_LN +#define STRMM_KERNEL_LC strmm_kernel_LT +#define STRMM_KERNEL_RN strmm_kernel_RN +#define STRMM_KERNEL_RT strmm_kernel_RT +#define STRMM_KERNEL_RR strmm_kernel_RN +#define STRMM_KERNEL_RC strmm_kernel_RT + +#define STRSM_KERNEL_LN strsm_kernel_LN +#define STRSM_KERNEL_LT strsm_kernel_LT +#define STRSM_KERNEL_LR strsm_kernel_LN +#define STRSM_KERNEL_LC strsm_kernel_LT +#define STRSM_KERNEL_RN strsm_kernel_RN +#define STRSM_KERNEL_RT strsm_kernel_RT +#define STRSM_KERNEL_RR strsm_kernel_RN +#define STRSM_KERNEL_RC strsm_kernel_RT + +#define SSYMM_OUTCOPY ssymm_outcopy +#define SSYMM_OLTCOPY ssymm_oltcopy +#if SGEMM_DEFAULT_UNROLL_M == SGEMM_DEFAULT_UNROLL_N +#define SSYMM_IUTCOPY ssymm_outcopy +#define SSYMM_ILTCOPY ssymm_oltcopy +#else +#define SSYMM_IUTCOPY ssymm_iutcopy +#define SSYMM_ILTCOPY ssymm_iltcopy +#endif + +#define SNEG_TCOPY sneg_tcopy +#define SLASWP_NCOPY slaswp_ncopy + +#else + +#define SAMAX_K gotoblas -> samax_k +#define SAMIN_K gotoblas -> samin_k +#define SMAX_K gotoblas -> smax_k +#define SMIN_K gotoblas -> smin_k +#define ISAMAX_K gotoblas -> isamax_k +#define ISAMIN_K gotoblas -> isamin_k +#define ISMAX_K gotoblas -> ismax_k +#define ISMIN_K gotoblas -> ismin_k +#define SASUM_K gotoblas -> sasum_k +#define SAXPYU_K gotoblas -> saxpy_k +#define SAXPYC_K gotoblas -> saxpy_k +#define SCOPY_K gotoblas -> scopy_k +#define SDOTU_K gotoblas -> sdot_k +#define SDOTC_K gotoblas -> sdot_k +#define SDSDOT_K gotoblas -> sdot_k +#define DSDOT_K gotoblas -> dsdot_k +#define SNRM2_K gotoblas -> snrm2_k +#define SSCAL_K gotoblas -> sscal_k +#define SSWAP_K gotoblas -> sswap_k +#define SROT_K gotoblas -> srot_k + +#define SGEMV_N gotoblas -> sgemv_n +#define SGEMV_T gotoblas -> sgemv_t +#define SGEMV_R gotoblas -> sgemv_n +#define SGEMV_C gotoblas -> sgemv_t +#define SGEMV_O gotoblas -> sgemv_n +#define SGEMV_U gotoblas -> sgemv_t +#define SGEMV_S gotoblas -> sgemv_n +#define SGEMV_D gotoblas -> sgemv_t + +#define SGERU_K gotoblas -> sger_k +#define SGERC_K gotoblas -> sger_k +#define SGERV_K gotoblas -> sger_k +#define SGERD_K gotoblas -> sger_k + +#define SSYMV_U gotoblas -> ssymv_U +#define SSYMV_L gotoblas -> ssymv_L + +#define SSYMV_THREAD_U ssymv_thread_U +#define SSYMV_THREAD_L ssymv_thread_L + +#define SGEMM_ONCOPY gotoblas -> sgemm_oncopy +#define SGEMM_OTCOPY gotoblas -> sgemm_otcopy +#define SGEMM_INCOPY gotoblas -> sgemm_incopy +#define SGEMM_ITCOPY gotoblas -> sgemm_itcopy + +#define STRMM_OUNUCOPY gotoblas -> strmm_ounucopy +#define STRMM_OUTUCOPY gotoblas -> strmm_outucopy +#define STRMM_OLNUCOPY gotoblas -> strmm_olnucopy +#define STRMM_OLTUCOPY gotoblas -> strmm_oltucopy +#define STRSM_OUNUCOPY gotoblas -> strsm_ounucopy +#define STRSM_OUTUCOPY gotoblas -> strsm_outucopy +#define STRSM_OLNUCOPY gotoblas -> strsm_olnucopy +#define STRSM_OLTUCOPY gotoblas -> strsm_oltucopy + +#define STRMM_IUNUCOPY gotoblas -> strmm_iunucopy +#define STRMM_IUTUCOPY gotoblas -> strmm_iutucopy +#define STRMM_ILNUCOPY gotoblas -> strmm_ilnucopy +#define STRMM_ILTUCOPY gotoblas -> strmm_iltucopy +#define STRSM_IUNUCOPY gotoblas -> strsm_iunucopy +#define STRSM_IUTUCOPY gotoblas -> strsm_iutucopy +#define STRSM_ILNUCOPY gotoblas -> strsm_ilnucopy +#define STRSM_ILTUCOPY gotoblas -> strsm_iltucopy + +#define STRMM_OUNNCOPY gotoblas -> strmm_ounncopy +#define STRMM_OUTNCOPY gotoblas -> strmm_outncopy +#define STRMM_OLNNCOPY gotoblas -> strmm_olnncopy +#define STRMM_OLTNCOPY gotoblas -> strmm_oltncopy +#define STRSM_OUNNCOPY gotoblas -> strsm_ounncopy +#define STRSM_OUTNCOPY gotoblas -> strsm_outncopy +#define STRSM_OLNNCOPY gotoblas -> strsm_olnncopy +#define STRSM_OLTNCOPY gotoblas -> strsm_oltncopy + +#define STRMM_IUNNCOPY gotoblas -> strmm_iunncopy +#define STRMM_IUTNCOPY gotoblas -> strmm_iutncopy +#define STRMM_ILNNCOPY gotoblas -> strmm_ilnncopy +#define STRMM_ILTNCOPY gotoblas -> strmm_iltncopy +#define STRSM_IUNNCOPY gotoblas -> strsm_iunncopy +#define STRSM_IUTNCOPY gotoblas -> strsm_iutncopy +#define STRSM_ILNNCOPY gotoblas -> strsm_ilnncopy +#define STRSM_ILTNCOPY gotoblas -> strsm_iltncopy + +#define SGEMM_BETA gotoblas -> sgemm_beta +#define SGEMM_KERNEL gotoblas -> sgemm_kernel + +#define STRMM_KERNEL_LN gotoblas -> strmm_kernel_LN +#define STRMM_KERNEL_LT gotoblas -> strmm_kernel_LT +#define STRMM_KERNEL_LR gotoblas -> strmm_kernel_LN +#define STRMM_KERNEL_LC gotoblas -> strmm_kernel_LT +#define STRMM_KERNEL_RN gotoblas -> strmm_kernel_RN +#define STRMM_KERNEL_RT gotoblas -> strmm_kernel_RT +#define STRMM_KERNEL_RR gotoblas -> strmm_kernel_RN +#define STRMM_KERNEL_RC gotoblas -> strmm_kernel_RT + +#define STRSM_KERNEL_LN gotoblas -> strsm_kernel_LN +#define STRSM_KERNEL_LT gotoblas -> strsm_kernel_LT +#define STRSM_KERNEL_LR gotoblas -> strsm_kernel_LN +#define STRSM_KERNEL_LC gotoblas -> strsm_kernel_LT +#define STRSM_KERNEL_RN gotoblas -> strsm_kernel_RN +#define STRSM_KERNEL_RT gotoblas -> strsm_kernel_RT +#define STRSM_KERNEL_RR gotoblas -> strsm_kernel_RN +#define STRSM_KERNEL_RC gotoblas -> strsm_kernel_RT + +#define SSYMM_IUTCOPY gotoblas -> ssymm_iutcopy +#define SSYMM_ILTCOPY gotoblas -> ssymm_iltcopy +#define SSYMM_OUTCOPY gotoblas -> ssymm_outcopy +#define SSYMM_OLTCOPY gotoblas -> ssymm_oltcopy + +#define SNEG_TCOPY gotoblas -> sneg_tcopy +#define SLASWP_NCOPY gotoblas -> slaswp_ncopy + +#endif + +#define SGEMM_NN sgemm_nn +#define SGEMM_CN sgemm_tn +#define SGEMM_TN sgemm_tn +#define SGEMM_NC sgemm_nt +#define SGEMM_NT sgemm_nt +#define SGEMM_CC sgemm_tt +#define SGEMM_CT sgemm_tt +#define SGEMM_TC sgemm_tt +#define SGEMM_TT sgemm_tt +#define SGEMM_NR sgemm_nn +#define SGEMM_TR sgemm_tn +#define SGEMM_CR sgemm_tn +#define SGEMM_RN sgemm_nn +#define SGEMM_RT sgemm_nt +#define SGEMM_RC sgemm_nt +#define SGEMM_RR sgemm_nn + +#define SSYMM_LU ssymm_LU +#define SSYMM_LL ssymm_LL +#define SSYMM_RU ssymm_RU +#define SSYMM_RL ssymm_RL + +#define SHEMM_LU shemm_LU +#define SHEMM_LL shemm_LL +#define SHEMM_RU shemm_RU +#define SHEMM_RL shemm_RL + +#define SSYRK_UN ssyrk_UN +#define SSYRK_UT ssyrk_UT +#define SSYRK_LN ssyrk_LN +#define SSYRK_LT ssyrk_LT +#define SSYRK_UR ssyrk_UN +#define SSYRK_UC ssyrk_UT +#define SSYRK_LR ssyrk_LN +#define SSYRK_LC ssyrk_LT + +#define SSYRK_KERNEL_U ssyrk_kernel_U +#define SSYRK_KERNEL_L ssyrk_kernel_L + +#define SHERK_UN ssyrk_UN +#define SHERK_LN ssyrk_LN +#define SHERK_UC ssyrk_UT +#define SHERK_LC ssyrk_LT + +#define SHER2K_UN ssyr2k_UN +#define SHER2K_LN ssyr2k_LN +#define SHER2K_UC ssyr2k_UT +#define SHER2K_LC ssyr2k_LT + +#define SSYR2K_UN ssyr2k_UN +#define SSYR2K_UT ssyr2k_UT +#define SSYR2K_LN ssyr2k_LN +#define SSYR2K_LT ssyr2k_LT +#define SSYR2K_UR ssyr2k_UN +#define SSYR2K_UC ssyr2k_UT +#define SSYR2K_LR ssyr2k_LN +#define SSYR2K_LC ssyr2k_LT + +#define SSYR2K_KERNEL_U ssyr2k_kernel_U +#define SSYR2K_KERNEL_L ssyr2k_kernel_L + +#define STRMM_LNUU strmm_LNUU +#define STRMM_LNUN strmm_LNUN +#define STRMM_LNLU strmm_LNLU +#define STRMM_LNLN strmm_LNLN +#define STRMM_LTUU strmm_LTUU +#define STRMM_LTUN strmm_LTUN +#define STRMM_LTLU strmm_LTLU +#define STRMM_LTLN strmm_LTLN +#define STRMM_LRUU strmm_LNUU +#define STRMM_LRUN strmm_LNUN +#define STRMM_LRLU strmm_LNLU +#define STRMM_LRLN strmm_LNLN +#define STRMM_LCUU strmm_LTUU +#define STRMM_LCUN strmm_LTUN +#define STRMM_LCLU strmm_LTLU +#define STRMM_LCLN strmm_LTLN +#define STRMM_RNUU strmm_RNUU +#define STRMM_RNUN strmm_RNUN +#define STRMM_RNLU strmm_RNLU +#define STRMM_RNLN strmm_RNLN +#define STRMM_RTUU strmm_RTUU +#define STRMM_RTUN strmm_RTUN +#define STRMM_RTLU strmm_RTLU +#define STRMM_RTLN strmm_RTLN +#define STRMM_RRUU strmm_RNUU +#define STRMM_RRUN strmm_RNUN +#define STRMM_RRLU strmm_RNLU +#define STRMM_RRLN strmm_RNLN +#define STRMM_RCUU strmm_RTUU +#define STRMM_RCUN strmm_RTUN +#define STRMM_RCLU strmm_RTLU +#define STRMM_RCLN strmm_RTLN + +#define STRSM_LNUU strsm_LNUU +#define STRSM_LNUN strsm_LNUN +#define STRSM_LNLU strsm_LNLU +#define STRSM_LNLN strsm_LNLN +#define STRSM_LTUU strsm_LTUU +#define STRSM_LTUN strsm_LTUN +#define STRSM_LTLU strsm_LTLU +#define STRSM_LTLN strsm_LTLN +#define STRSM_LRUU strsm_LNUU +#define STRSM_LRUN strsm_LNUN +#define STRSM_LRLU strsm_LNLU +#define STRSM_LRLN strsm_LNLN +#define STRSM_LCUU strsm_LTUU +#define STRSM_LCUN strsm_LTUN +#define STRSM_LCLU strsm_LTLU +#define STRSM_LCLN strsm_LTLN +#define STRSM_RNUU strsm_RNUU +#define STRSM_RNUN strsm_RNUN +#define STRSM_RNLU strsm_RNLU +#define STRSM_RNLN strsm_RNLN +#define STRSM_RTUU strsm_RTUU +#define STRSM_RTUN strsm_RTUN +#define STRSM_RTLU strsm_RTLU +#define STRSM_RTLN strsm_RTLN +#define STRSM_RRUU strsm_RNUU +#define STRSM_RRUN strsm_RNUN +#define STRSM_RRLU strsm_RNLU +#define STRSM_RRLN strsm_RNLN +#define STRSM_RCUU strsm_RTUU +#define STRSM_RCUN strsm_RTUN +#define STRSM_RCLU strsm_RTLU +#define STRSM_RCLN strsm_RTLN + +#define SGEMM_THREAD_NN sgemm_thread_nn +#define SGEMM_THREAD_CN sgemm_thread_tn +#define SGEMM_THREAD_TN sgemm_thread_tn +#define SGEMM_THREAD_NC sgemm_thread_nt +#define SGEMM_THREAD_NT sgemm_thread_nt +#define SGEMM_THREAD_CC sgemm_thread_tt +#define SGEMM_THREAD_CT sgemm_thread_tt +#define SGEMM_THREAD_TC sgemm_thread_tt +#define SGEMM_THREAD_TT sgemm_thread_tt +#define SGEMM_THREAD_NR sgemm_thread_nn +#define SGEMM_THREAD_TR sgemm_thread_tn +#define SGEMM_THREAD_CR sgemm_thread_tn +#define SGEMM_THREAD_RN sgemm_thread_nn +#define SGEMM_THREAD_RT sgemm_thread_nt +#define SGEMM_THREAD_RC sgemm_thread_nt +#define SGEMM_THREAD_RR sgemm_thread_nn + +#define SSYMM_THREAD_LU ssymm_thread_LU +#define SSYMM_THREAD_LL ssymm_thread_LL +#define SSYMM_THREAD_RU ssymm_thread_RU +#define SSYMM_THREAD_RL ssymm_thread_RL + +#define SHEMM_THREAD_LU shemm_thread_LU +#define SHEMM_THREAD_LL shemm_thread_LL +#define SHEMM_THREAD_RU shemm_thread_RU +#define SHEMM_THREAD_RL shemm_thread_RL + +#define SSYRK_THREAD_UN ssyrk_thread_UN +#define SSYRK_THREAD_UT ssyrk_thread_UT +#define SSYRK_THREAD_LN ssyrk_thread_LN +#define SSYRK_THREAD_LT ssyrk_thread_LT +#define SSYRK_THREAD_UR ssyrk_thread_UN +#define SSYRK_THREAD_UC ssyrk_thread_UT +#define SSYRK_THREAD_LR ssyrk_thread_LN +#define SSYRK_THREAD_LC ssyrk_thread_LT + +#define SHERK_THREAD_UN ssyrk_thread_UN +#define SHERK_THREAD_UT ssyrk_thread_UT +#define SHERK_THREAD_LN ssyrk_thread_LN +#define SHERK_THREAD_LT ssyrk_thread_LT +#define SHERK_THREAD_UR ssyrk_thread_UN +#define SHERK_THREAD_UC ssyrk_thread_UT +#define SHERK_THREAD_LR ssyrk_thread_LN +#define SHERK_THREAD_LC ssyrk_thread_LT + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_sparc.h b/src/NativeWrappers/GotoBlas2/include/common_sparc.h new file mode 100644 index 00000000..35d8bdb5 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_sparc.h @@ -0,0 +1,224 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef COMMON_POWER +#define COMMON_POWER + +#define MB __asm__ __volatile__ ("nop") +#define WMB __asm__ __volatile__ ("nop") + +#ifndef ASSEMBLER + +static void __inline blas_lock(volatile unsigned long *address){ + + long int ret = 1; + + do { + while (*address) {YIELDING;}; + + __asm__ __volatile__( + "ldstub [%1], %0" + : "=&r"(ret) + : "r" (address) + : "memory"); + } while (ret); +} + +static __inline unsigned long rpcc(void){ + unsigned long clocks; + + __asm__ __volatile__ ("rd %%tick, %0" : "=r" (clocks)); + + return clocks; +}; + +#ifdef __64BIT__ +#define RPCC64BIT +#endif + +#ifndef __BIG_ENDIAN__ +#define __BIG_ENDIAN__ +#endif + +#ifdef DOUBLE +#define GET_IMAGE(res) __asm__ __volatile__("fmovd %%f2, %0" : "=f"(res) : : "memory") +#else +#define GET_IMAGE(res) __asm__ __volatile__("fmovs %%f1, %0" : "=f"(res) : : "memory") +#endif + +#define GET_IMAGE_CANCEL + +#ifdef SMP +static __inline int blas_quickdivide(blasint x, blasint y){ + return x / y; +} +#endif +#endif + + +#ifdef ASSEMBLER + +#ifndef __64BIT__ +#define STACK_START 128 +#define SAVESP save %sp, -64, %sp +#else +#define STACK_START 2423 +#define SAVESP save %sp, -256, %sp +#endif + +#define NOP or %g1, %g1, %g1 + +#ifdef DOUBLE +#define LDF ldd +#define STF std +#define FADD faddd +#define FMUL fmuld +#define FMOV fmovd +#define FABS fabsd +#define FSUB fsubd +#define FCMP fcmpd +#define FMOVG fmovdg +#define FMOVL fmovdl +#define FSQRT fsqrtd +#define FDIV fdivd +#else +#define LDF ld +#define STF st +#define FADD fadds +#define FMUL fmuls +#define FMOV fmovs +#define FABS fabss +#define FSUB fsubs +#define FCMP fcmps +#define FMOVG fmovsg +#define FMOVL fmovsl +#define FSQRT fsqrts +#define FDIV fdivs +#endif + +#define HALT prefetch [%g0], 5 + +#define FMADDS(rs1, rs2, rs3, rd) \ + .word ((2 << 30) | ((rd) << 25) | ( 0x37 << 19) | ((rs1) << 14) | ((rs3) << 9) | ( 1 << 5) | (rs2)) + +#define FMADDD(rs1, rs2, rs3, rd) \ + .word ((2 << 30) | ((rd) << 25) | ( 0x37 << 19) | ((rs1) << 14) | ((rs3) << 9) | ( 2 << 5) | (rs2)) + +#define FMSUBS(rs1, rs2, rs3, rd) \ + .word ((2 << 30) | ((rd) << 25) | ( 0x37 << 19) | ((rs1) << 14) | ((rs3) << 9) | ( 5 << 5) | (rs2)) + +#define FMSUBD(rs1, rs2, rs3, rd) \ + .word ((2 << 30) | ((rd) << 25) | ( 0x37 << 19) | ((rs1) << 14) | ((rs3) << 9) | ( 6 << 5) | (rs2)) + +#define FNMSUBS(rs1, rs2, rs3, rd) \ + .word ((2 << 30) | ((rd) << 25) | ( 0x37 << 19) | ((rs1) << 14) | ((rs3) << 9) | ( 9 << 5) | (rs2)) + +#define FNMSUBD(rs1, rs2, rs3, rd) \ + .word ((2 << 30) | ((rd) << 25) | ( 0x37 << 19) | ((rs1) << 14) | ((rs3) << 9) | (10 << 5) | (rs2)) + +#define FNMADDS(rs1, rs2, rs3, rd) \ + .word ((2 << 30) | ((rd) << 25) | ( 0x37 << 19) | ((rs1) << 14) | ((rs3) << 9) | (13 << 5) | (rs2)) + +#define FNMADDD(rs1, rs2, rs3, rd) \ + .word ((2 << 30) | ((rd) << 25) | ( 0x37 << 19) | ((rs1) << 14) | ((rs3) << 9) | (14 << 5) | (rs2)) + +#define FCLRS(rd) \ + .word ((2 << 30) | ((rd) << 25) | ( 0x36 << 19) | ( 0x61 << 5)) + +#define FCLRD(rd) \ + .word ((2 << 30) | ((rd) << 25) | ( 0x36 << 19) | ( 0x60 << 5)) + +#define FONES(rd) \ + .word ((2 << 30) | ((rd) << 25) | ( 0x36 << 19) | ( 0x7f << 5)) + +#define FONED(rd) \ + .word ((2 << 30) | ((rd) << 25) | ( 0x36 << 19) | ( 0x7e << 5)) + +#ifndef DOUBLE +#define FCLR(a) FCLRS(a) +#define FONE(a) FONES(a) +#define FMADD(a, b, c, d) FMADDS(a, b, c, d) +#define FMSUB(a, b, c, d) FMSUBS(a, b, c, d) +#define FNMADD(a, b, c, d) FNMADDS(a, b, c, d) +#define FNMSUB(a, b, c, d) FNMSUBS(a, b, c, d) +#else +#define FCLR(a) FCLRD(a) +#define FONE(a) FONED(a) +#define FMADD(a, b, c, d) FMADDD(a, b, c, d) +#define FMSUB(a, b, c, d) FMSUBD(a, b, c, d) +#define FNMADD(a, b, c, d) FNMADDD(a, b, c, d) +#define FNMSUB(a, b, c, d) FNMSUBD(a, b, c, d) +#endif + +#ifndef F_INTERFACE +#define REALNAME ASMNAME +#else +#define REALNAME ASMFNAME +#endif + +#ifdef sparc +#define PROLOGUE \ + .section ".text"; \ + .align 32; \ + .global REALNAME;\ + .type REALNAME, #function; \ + .proc 07; \ +REALNAME:; +#define EPILOGUE \ + .size REALNAME, .-REALNAME +#endif + +#endif + +#ifdef sparc +#define SEEK_ADDRESS +#endif + +#define BUFFER_SIZE (32 << 20) + +#ifndef PAGESIZE +#define PAGESIZE ( 8 << 10) +#endif +#define HUGE_PAGESIZE ( 4 << 20) + +#define BASE_ADDRESS (START_ADDRESS - BUFFER_SIZE * MAX_CPU_NUMBER) + +#ifndef MAP_ANONYMOUS +#define MAP_ANONYMOUS MAP_ANON +#endif +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_thread.h b/src/NativeWrappers/GotoBlas2/include/common_thread.h new file mode 100644 index 00000000..d74af328 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_thread.h @@ -0,0 +1,192 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef COMMON_THREAD +#define COMMON_THREAD + +/* Basic Thread Debugging */ +#undef SMP_DEBUG + +/* Thread Timing Debugging */ +#undef TIMING_DEBUG + +/* Global Parameter */ +extern int blas_cpu_number; +extern int blas_num_threads; +extern int blas_omp_linked; + +#define BLAS_LEGACY 0x8000U +#define BLAS_PTHREAD 0x4000U +#define BLAS_NODE 0x2000U + +#define BLAS_PREC 0x0003U +#define BLAS_SINGLE 0x0000U +#define BLAS_DOUBLE 0x0001U +#define BLAS_XDOUBLE 0x0002U +#define BLAS_REAL 0x0000U +#define BLAS_COMPLEX 0x0004U + +#define BLAS_TRANSA 0x0030U /* 2bit */ +#define BLAS_TRANSA_N 0x0000U +#define BLAS_TRANSA_T 0x0010U +#define BLAS_TRANSA_R 0x0020U +#define BLAS_TRANSA_C 0x0030U +#define BLAS_TRANSA_SHIFT 4 + +#define BLAS_TRANSB 0x0300U /* 2bit */ +#define BLAS_TRANSB_N 0x0000U +#define BLAS_TRANSB_T 0x0100U +#define BLAS_TRANSB_R 0x0200U +#define BLAS_TRANSB_C 0x0300U +#define BLAS_TRANSB_SHIFT 8 + +#define BLAS_RSIDE 0x0400U +#define BLAS_RSIDE_SHIFT 10 +#define BLAS_UPLO 0x0800U +#define BLAS_UPLO_SHIFT 11 + +#define BLAS_STATUS_NOTYET 0 +#define BLAS_STATUS_QUEUED 1 +#define BLAS_STATUS_RUNNING 2 +#define BLAS_STATUS_FINISHED 4 + +typedef struct blas_queue { + + void *routine; + BLASLONG position; + BLASLONG assigned; + + blas_arg_t *args; + void *range_m; + void *range_n; + void *sa, *sb; + + struct blas_queue *next; + +#if defined( __WIN32__) || defined(__CYGWIN32__) + CRITICAL_SECTION lock; + HANDLE finish; +#else + pthread_mutex_t lock; + pthread_cond_t finished; +#endif + + int mode, status; + +#ifdef CONSISTENT_FPCSR + unsigned int sse_mode, x87_mode; +#endif + +#ifdef SMP_DEBUG + int num; +#endif +#ifdef TIMING_DEBUG + unsigned int clocks; +#endif +} blas_queue_t; + +#ifdef SMP_SERVER + +extern int blas_server_avail; + +static __inline int num_cpu_avail(int level) { + + if ((blas_cpu_number == 1) + +#ifdef USE_OPENMP + || omp_in_parallel() +#endif + ) return 1; + + return blas_cpu_number; + +} + +static __inline void blas_queue_init(blas_queue_t *queue){ + + queue -> sa = NULL; + queue -> sb = NULL; + queue-> next = NULL; +} + +int blas_thread_init(void); +int BLASFUNC(blas_thread_shutdown)(void); +int exec_blas(BLASLONG, blas_queue_t *); +int exec_blas_async(BLASLONG, blas_queue_t *); +int exec_blas_async_wait(BLASLONG, blas_queue_t *); + +#else +int exec_blas_async(BLASLONG num_cpu, blas_param_t *param, pthread_t *); +int exec_blas_async_wait(BLASLONG num_cpu, pthread_t *blas_threads); +int exec_blas(BLASLONG num_cpu, blas_param_t *param, void *buffer); +#endif + +#ifndef ASSEMBLER + +int blas_level1_thread(int mode, BLASLONG m, BLASLONG n, BLASLONG k, void *alpha, + void *a, BLASLONG lda, + void *b, BLASLONG ldb, + void *c, BLASLONG ldc, int (*function)(), int threads); + +int gemm_thread_m (int mode, blas_arg_t *, BLASLONG *, BLASLONG *, int (*function)(), void *, void *, BLASLONG); + +int gemm_thread_n (int mode, blas_arg_t *, BLASLONG *, BLASLONG *, int (*function)(), void *, void *, BLASLONG); + +int gemm_thread_mn(int mode, blas_arg_t *, BLASLONG *, BLASLONG *, int (*function)(), void *, void *, BLASLONG); + +int gemm_thread_variable(int mode, blas_arg_t *, BLASLONG *, BLASLONG *, int (*function)(), void *, void *, BLASLONG, BLASLONG); + +int trsm_thread(int mode, BLASLONG m, BLASLONG n, + double alpha_r, double alpha_i, + void *a, BLASLONG lda, + void *c, BLASLONG ldc, int (*function)(), void *buffer); + +int syrk_thread(int mode, blas_arg_t *, BLASLONG *, BLASLONG *, int (*function)(), void *, void *, BLASLONG); + +int beta_thread(int mode, BLASLONG m, BLASLONG n, + double alpha_r, double alpha_i, + void *c, BLASLONG ldc, int (*fuction)()); + +int getrf_thread(int mode, BLASLONG m, BLASLONG n, BLASLONG k, + void *offsetA, BLASLONG lda, + void *offsetB, BLASLONG jb, + void *ipiv, BLASLONG offset, int (*function)(), void *buffer); + +#endif /* ENDIF ASSEMBLER */ + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_x.h b/src/NativeWrappers/GotoBlas2/include/common_x.h new file mode 100644 index 00000000..03b98db4 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_x.h @@ -0,0 +1,611 @@ +#ifndef COMMON_X_H +#define COMMON_X_H + +#ifndef DYNAMIC_ARCH + +#define XAMAX_K xamax_k +#define XAMIN_K xamin_k +#define XMAX_K xmax_k +#define XMIN_K xmin_k +#define IXAMAX_K ixamax_k +#define IXAMIN_K ixamin_k +#define IXMAX_K ixmax_k +#define IXMIN_K ixmin_k +#define XASUM_K xasum_k +#define XAXPYU_K xaxpy_k +#define XAXPYC_K xaxpyc_k +#define XCOPY_K xcopy_k +#define XDOTU_K xdotu_k +#define XDOTC_K xdotc_k +#define XNRM2_K xnrm2_k +#define XSCAL_K xscal_k +#define XSWAP_K xswap_k +#define XROT_K xqrot_k + +#define XGEMV_N xgemv_n +#define XGEMV_T xgemv_t +#define XGEMV_R xgemv_r +#define XGEMV_C xgemv_c +#define XGEMV_O xgemv_o +#define XGEMV_U xgemv_u +#define XGEMV_S xgemv_s +#define XGEMV_D xgemv_d + +#define XGERU_K xgeru_k +#define XGERC_K xgerc_k +#define XGERV_K xgerv_k +#define XGERD_K xgerd_k + +#define XSYMV_U xsymv_U +#define XSYMV_L xsymv_L +#define XHEMV_U xhemv_U +#define XHEMV_L xhemv_L +#define XHEMV_V xhemv_V +#define XHEMV_M xhemv_M + +#define XSYMV_THREAD_U xsymv_thread_U +#define XSYMV_THREAD_L xsymv_thread_L +#define XHEMV_THREAD_U xhemv_thread_U +#define XHEMV_THREAD_L xhemv_thread_L +#define XHEMV_THREAD_V xhemv_thread_V +#define XHEMV_THREAD_M xhemv_thread_M + +#define XGEMM_ONCOPY xgemm_oncopy +#define XGEMM_OTCOPY xgemm_otcopy + +#if XGEMM_DEFAULT_UNROLL_M == XGEMM_DEFAULT_UNROLL_N +#define XGEMM_INCOPY xgemm_oncopy +#define XGEMM_ITCOPY xgemm_otcopy +#else +#define XGEMM_INCOPY xgemm_incopy +#define XGEMM_ITCOPY xgemm_itcopy +#endif + +#define XTRMM_OUNUCOPY xtrmm_ounucopy +#define XTRMM_OUNNCOPY xtrmm_ounncopy +#define XTRMM_OUTUCOPY xtrmm_outucopy +#define XTRMM_OUTNCOPY xtrmm_outncopy +#define XTRMM_OLNUCOPY xtrmm_olnucopy +#define XTRMM_OLNNCOPY xtrmm_olnncopy +#define XTRMM_OLTUCOPY xtrmm_oltucopy +#define XTRMM_OLTNCOPY xtrmm_oltncopy + +#define XTRSM_OUNUCOPY xtrsm_ounucopy +#define XTRSM_OUNNCOPY xtrsm_ounncopy +#define XTRSM_OUTUCOPY xtrsm_outucopy +#define XTRSM_OUTNCOPY xtrsm_outncopy +#define XTRSM_OLNUCOPY xtrsm_olnucopy +#define XTRSM_OLNNCOPY xtrsm_olnncopy +#define XTRSM_OLTUCOPY xtrsm_oltucopy +#define XTRSM_OLTNCOPY xtrsm_oltncopy + +#if XGEMM_DEFAULT_UNROLL_M == XGEMM_DEFAULT_UNROLL_N +#define XTRMM_IUNUCOPY xtrmm_ounucopy +#define XTRMM_IUNNCOPY xtrmm_ounncopy +#define XTRMM_IUTUCOPY xtrmm_outucopy +#define XTRMM_IUTNCOPY xtrmm_outncopy +#define XTRMM_ILNUCOPY xtrmm_olnucopy +#define XTRMM_ILNNCOPY xtrmm_olnncopy +#define XTRMM_ILTUCOPY xtrmm_oltucopy +#define XTRMM_ILTNCOPY xtrmm_oltncopy + +#define XTRSM_IUNUCOPY xtrsm_ounucopy +#define XTRSM_IUNNCOPY xtrsm_ounncopy +#define XTRSM_IUTUCOPY xtrsm_outucopy +#define XTRSM_IUTNCOPY xtrsm_outncopy +#define XTRSM_ILNUCOPY xtrsm_olnucopy +#define XTRSM_ILNNCOPY xtrsm_olnncopy +#define XTRSM_ILTUCOPY xtrsm_oltucopy +#define XTRSM_ILTNCOPY xtrsm_oltncopy +#else +#define XTRMM_IUNUCOPY xtrmm_iunucopy +#define XTRMM_IUNNCOPY xtrmm_iunncopy +#define XTRMM_IUTUCOPY xtrmm_iutucopy +#define XTRMM_IUTNCOPY xtrmm_iutncopy +#define XTRMM_ILNUCOPY xtrmm_ilnucopy +#define XTRMM_ILNNCOPY xtrmm_ilnncopy +#define XTRMM_ILTUCOPY xtrmm_iltucopy +#define XTRMM_ILTNCOPY xtrmm_iltncopy + +#define XTRSM_IUNUCOPY xtrsm_iunucopy +#define XTRSM_IUNNCOPY xtrsm_iunncopy +#define XTRSM_IUTUCOPY xtrsm_iutucopy +#define XTRSM_IUTNCOPY xtrsm_iutncopy +#define XTRSM_ILNUCOPY xtrsm_ilnucopy +#define XTRSM_ILNNCOPY xtrsm_ilnncopy +#define XTRSM_ILTUCOPY xtrsm_iltucopy +#define XTRSM_ILTNCOPY xtrsm_iltncopy +#endif + +#define XGEMM_BETA xgemm_beta + +#define XGEMM_KERNEL_N xgemm_kernel_n +#define XGEMM_KERNEL_L xgemm_kernel_l +#define XGEMM_KERNEL_R xgemm_kernel_r +#define XGEMM_KERNEL_B xgemm_kernel_b + +#define XTRMM_KERNEL_LN xtrmm_kernel_LN +#define XTRMM_KERNEL_LT xtrmm_kernel_LT +#define XTRMM_KERNEL_LR xtrmm_kernel_LR +#define XTRMM_KERNEL_LC xtrmm_kernel_LC +#define XTRMM_KERNEL_RN xtrmm_kernel_RN +#define XTRMM_KERNEL_RT xtrmm_kernel_RT +#define XTRMM_KERNEL_RR xtrmm_kernel_RR +#define XTRMM_KERNEL_RC xtrmm_kernel_RC + +#define XTRSM_KERNEL_LN xtrsm_kernel_LN +#define XTRSM_KERNEL_LT xtrsm_kernel_LT +#define XTRSM_KERNEL_LR xtrsm_kernel_LR +#define XTRSM_KERNEL_LC xtrsm_kernel_LC +#define XTRSM_KERNEL_RN xtrsm_kernel_RN +#define XTRSM_KERNEL_RT xtrsm_kernel_RT +#define XTRSM_KERNEL_RR xtrsm_kernel_RR +#define XTRSM_KERNEL_RC xtrsm_kernel_RC + +#define XSYMM_OUTCOPY xsymm_outcopy +#define XSYMM_OLTCOPY xsymm_oltcopy +#if XGEMM_DEFAULT_UNROLL_M == XGEMM_DEFAULT_UNROLL_N +#define XSYMM_IUTCOPY xsymm_outcopy +#define XSYMM_ILTCOPY xsymm_oltcopy +#else +#define XSYMM_IUTCOPY xsymm_iutcopy +#define XSYMM_ILTCOPY xsymm_iltcopy +#endif + +#define XHEMM_OUTCOPY xhemm_outcopy +#define XHEMM_OLTCOPY xhemm_oltcopy +#if XGEMM_DEFAULT_UNROLL_M == XGEMM_DEFAULT_UNROLL_N +#define XHEMM_IUTCOPY xhemm_outcopy +#define XHEMM_ILTCOPY xhemm_oltcopy +#else +#define XHEMM_IUTCOPY xhemm_iutcopy +#define XHEMM_ILTCOPY xhemm_iltcopy +#endif + +#define XGEMM3M_ONCOPYB xgemm3m_oncopyb +#define XGEMM3M_ONCOPYR xgemm3m_oncopyr +#define XGEMM3M_ONCOPYI xgemm3m_oncopyi +#define XGEMM3M_OTCOPYB xgemm3m_otcopyb +#define XGEMM3M_OTCOPYR xgemm3m_otcopyr +#define XGEMM3M_OTCOPYI xgemm3m_otcopyi + +#define XGEMM3M_INCOPYB xgemm3m_incopyb +#define XGEMM3M_INCOPYR xgemm3m_incopyr +#define XGEMM3M_INCOPYI xgemm3m_incopyi +#define XGEMM3M_ITCOPYB xgemm3m_itcopyb +#define XGEMM3M_ITCOPYR xgemm3m_itcopyr +#define XGEMM3M_ITCOPYI xgemm3m_itcopyi + +#define XSYMM3M_ILCOPYB xsymm3m_ilcopyb +#define XSYMM3M_IUCOPYB xsymm3m_iucopyb +#define XSYMM3M_ILCOPYR xsymm3m_ilcopyr +#define XSYMM3M_IUCOPYR xsymm3m_iucopyr +#define XSYMM3M_ILCOPYI xsymm3m_ilcopyi +#define XSYMM3M_IUCOPYI xsymm3m_iucopyi + +#define XSYMM3M_OLCOPYB xsymm3m_olcopyb +#define XSYMM3M_OUCOPYB xsymm3m_oucopyb +#define XSYMM3M_OLCOPYR xsymm3m_olcopyr +#define XSYMM3M_OUCOPYR xsymm3m_oucopyr +#define XSYMM3M_OLCOPYI xsymm3m_olcopyi +#define XSYMM3M_OUCOPYI xsymm3m_oucopyi + +#define XHEMM3M_ILCOPYB xhemm3m_ilcopyb +#define XHEMM3M_IUCOPYB xhemm3m_iucopyb +#define XHEMM3M_ILCOPYR xhemm3m_ilcopyr +#define XHEMM3M_IUCOPYR xhemm3m_iucopyr +#define XHEMM3M_ILCOPYI xhemm3m_ilcopyi +#define XHEMM3M_IUCOPYI xhemm3m_iucopyi + +#define XHEMM3M_OLCOPYB xhemm3m_olcopyb +#define XHEMM3M_OUCOPYB xhemm3m_oucopyb +#define XHEMM3M_OLCOPYR xhemm3m_olcopyr +#define XHEMM3M_OUCOPYR xhemm3m_oucopyr +#define XHEMM3M_OLCOPYI xhemm3m_olcopyi +#define XHEMM3M_OUCOPYI xhemm3m_oucopyi + +#define XGEMM3M_KERNEL xgemm3m_kernel + +#define XNEG_TCOPY xneg_tcopy +#define XLASWP_NCOPY xlaswp_ncopy + +#else + +#define XAMAX_K gotoblas -> xamax_k +#define XAMIN_K gotoblas -> xamin_k +#define XMAX_K gotoblas -> xmax_k +#define XMIN_K gotoblas -> xmin_k +#define IXAMAX_K gotoblas -> ixamax_k +#define IXAMIN_K gotoblas -> ixamin_k +#define IXMAX_K gotoblas -> ixmax_k +#define IXMIN_K gotoblas -> ixmin_k +#define XASUM_K gotoblas -> xasum_k +#define XAXPYU_K gotoblas -> xaxpy_k +#define XAXPYC_K gotoblas -> xaxpyc_k +#define XCOPY_K gotoblas -> xcopy_k +#define XDOTU_K gotoblas -> xdotu_k +#define XDOTC_K gotoblas -> xdotc_k +#define XNRM2_K gotoblas -> xnrm2_k +#define XSCAL_K gotoblas -> xscal_k +#define XSWAP_K gotoblas -> xswap_k +#define XROT_K gotoblas -> xqrot_k + +#define XGEMV_N gotoblas -> xgemv_n +#define XGEMV_T gotoblas -> xgemv_t +#define XGEMV_R gotoblas -> xgemv_r +#define XGEMV_C gotoblas -> xgemv_c +#define XGEMV_O gotoblas -> xgemv_o +#define XGEMV_U gotoblas -> xgemv_u +#define XGEMV_S gotoblas -> xgemv_s +#define XGEMV_D gotoblas -> xgemv_d + +#define XGERU_K gotoblas -> xgeru_k +#define XGERC_K gotoblas -> xgerc_k +#define XGERV_K gotoblas -> xgerv_k +#define XGERD_K gotoblas -> xgerd_k + +#define XSYMV_U gotoblas -> xsymv_U +#define XSYMV_L gotoblas -> xsymv_L +#define XHEMV_U gotoblas -> xhemv_U +#define XHEMV_L gotoblas -> xhemv_L +#define XHEMV_V gotoblas -> xhemv_V +#define XHEMV_M gotoblas -> xhemv_M + +#define XSYMV_THREAD_U xsymv_thread_U +#define XSYMV_THREAD_L xsymv_thread_L +#define XHEMV_THREAD_U xhemv_thread_U +#define XHEMV_THREAD_L xhemv_thread_L +#define XHEMV_THREAD_V xhemv_thread_V +#define XHEMV_THREAD_M xhemv_thread_M + +#define XGEMM_ONCOPY gotoblas -> xgemm_oncopy +#define XGEMM_OTCOPY gotoblas -> xgemm_otcopy +#define XGEMM_INCOPY gotoblas -> xgemm_incopy +#define XGEMM_ITCOPY gotoblas -> xgemm_itcopy + +#define XTRMM_OUNUCOPY gotoblas -> xtrmm_ounucopy +#define XTRMM_OUTUCOPY gotoblas -> xtrmm_outucopy +#define XTRMM_OLNUCOPY gotoblas -> xtrmm_olnucopy +#define XTRMM_OLTUCOPY gotoblas -> xtrmm_oltucopy +#define XTRSM_OUNUCOPY gotoblas -> xtrsm_ounucopy +#define XTRSM_OUTUCOPY gotoblas -> xtrsm_outucopy +#define XTRSM_OLNUCOPY gotoblas -> xtrsm_olnucopy +#define XTRSM_OLTUCOPY gotoblas -> xtrsm_oltucopy + +#define XTRMM_IUNUCOPY gotoblas -> xtrmm_iunucopy +#define XTRMM_IUTUCOPY gotoblas -> xtrmm_iutucopy +#define XTRMM_ILNUCOPY gotoblas -> xtrmm_ilnucopy +#define XTRMM_ILTUCOPY gotoblas -> xtrmm_iltucopy +#define XTRSM_IUNUCOPY gotoblas -> xtrsm_iunucopy +#define XTRSM_IUTUCOPY gotoblas -> xtrsm_iutucopy +#define XTRSM_ILNUCOPY gotoblas -> xtrsm_ilnucopy +#define XTRSM_ILTUCOPY gotoblas -> xtrsm_iltucopy + +#define XTRMM_OUNNCOPY gotoblas -> xtrmm_ounncopy +#define XTRMM_OUTNCOPY gotoblas -> xtrmm_outncopy +#define XTRMM_OLNNCOPY gotoblas -> xtrmm_olnncopy +#define XTRMM_OLTNCOPY gotoblas -> xtrmm_oltncopy +#define XTRSM_OUNNCOPY gotoblas -> xtrsm_ounncopy +#define XTRSM_OUTNCOPY gotoblas -> xtrsm_outncopy +#define XTRSM_OLNNCOPY gotoblas -> xtrsm_olnncopy +#define XTRSM_OLTNCOPY gotoblas -> xtrsm_oltncopy + +#define XTRMM_IUNNCOPY gotoblas -> xtrmm_iunncopy +#define XTRMM_IUTNCOPY gotoblas -> xtrmm_iutncopy +#define XTRMM_ILNNCOPY gotoblas -> xtrmm_ilnncopy +#define XTRMM_ILTNCOPY gotoblas -> xtrmm_iltncopy +#define XTRSM_IUNNCOPY gotoblas -> xtrsm_iunncopy +#define XTRSM_IUTNCOPY gotoblas -> xtrsm_iutncopy +#define XTRSM_ILNNCOPY gotoblas -> xtrsm_ilnncopy +#define XTRSM_ILTNCOPY gotoblas -> xtrsm_iltncopy + +#define XGEMM_BETA gotoblas -> xgemm_beta +#define XGEMM_KERNEL_N gotoblas -> xgemm_kernel_n +#define XGEMM_KERNEL_L gotoblas -> xgemm_kernel_l +#define XGEMM_KERNEL_R gotoblas -> xgemm_kernel_r +#define XGEMM_KERNEL_B gotoblas -> xgemm_kernel_b + +#define XTRMM_KERNEL_LN gotoblas -> xtrmm_kernel_LN +#define XTRMM_KERNEL_LT gotoblas -> xtrmm_kernel_LT +#define XTRMM_KERNEL_LR gotoblas -> xtrmm_kernel_LR +#define XTRMM_KERNEL_LC gotoblas -> xtrmm_kernel_LC +#define XTRMM_KERNEL_RN gotoblas -> xtrmm_kernel_RN +#define XTRMM_KERNEL_RT gotoblas -> xtrmm_kernel_RT +#define XTRMM_KERNEL_RR gotoblas -> xtrmm_kernel_RR +#define XTRMM_KERNEL_RC gotoblas -> xtrmm_kernel_RC + +#define XTRSM_KERNEL_LN gotoblas -> xtrsm_kernel_LN +#define XTRSM_KERNEL_LT gotoblas -> xtrsm_kernel_LT +#define XTRSM_KERNEL_LR gotoblas -> xtrsm_kernel_LR +#define XTRSM_KERNEL_LC gotoblas -> xtrsm_kernel_LC +#define XTRSM_KERNEL_RN gotoblas -> xtrsm_kernel_RN +#define XTRSM_KERNEL_RT gotoblas -> xtrsm_kernel_RT +#define XTRSM_KERNEL_RR gotoblas -> xtrsm_kernel_RR +#define XTRSM_KERNEL_RC gotoblas -> xtrsm_kernel_RC + +#define XSYMM_IUTCOPY gotoblas -> xsymm_iutcopy +#define XSYMM_ILTCOPY gotoblas -> xsymm_iltcopy +#define XSYMM_OUTCOPY gotoblas -> xsymm_outcopy +#define XSYMM_OLTCOPY gotoblas -> xsymm_oltcopy + +#define XHEMM_OUTCOPY gotoblas -> xhemm_outcopy +#define XHEMM_OLTCOPY gotoblas -> xhemm_oltcopy +#define XHEMM_IUTCOPY gotoblas -> xhemm_iutcopy +#define XHEMM_ILTCOPY gotoblas -> xhemm_iltcopy + +#define XGEMM3M_ONCOPYB gotoblas -> xgemm3m_oncopyb +#define XGEMM3M_ONCOPYR gotoblas -> xgemm3m_oncopyr +#define XGEMM3M_ONCOPYI gotoblas -> xgemm3m_oncopyi +#define XGEMM3M_OTCOPYB gotoblas -> xgemm3m_otcopyb +#define XGEMM3M_OTCOPYR gotoblas -> xgemm3m_otcopyr +#define XGEMM3M_OTCOPYI gotoblas -> xgemm3m_otcopyi + +#define XGEMM3M_INCOPYB gotoblas -> xgemm3m_incopyb +#define XGEMM3M_INCOPYR gotoblas -> xgemm3m_incopyr +#define XGEMM3M_INCOPYI gotoblas -> xgemm3m_incopyi +#define XGEMM3M_ITCOPYB gotoblas -> xgemm3m_itcopyb +#define XGEMM3M_ITCOPYR gotoblas -> xgemm3m_itcopyr +#define XGEMM3M_ITCOPYI gotoblas -> xgemm3m_itcopyi + +#define XSYMM3M_ILCOPYB gotoblas -> xsymm3m_ilcopyb +#define XSYMM3M_IUCOPYB gotoblas -> xsymm3m_iucopyb +#define XSYMM3M_ILCOPYR gotoblas -> xsymm3m_ilcopyr +#define XSYMM3M_IUCOPYR gotoblas -> xsymm3m_iucopyr +#define XSYMM3M_ILCOPYI gotoblas -> xsymm3m_ilcopyi +#define XSYMM3M_IUCOPYI gotoblas -> xsymm3m_iucopyi + +#define XSYMM3M_OLCOPYB gotoblas -> xsymm3m_olcopyb +#define XSYMM3M_OUCOPYB gotoblas -> xsymm3m_oucopyb +#define XSYMM3M_OLCOPYR gotoblas -> xsymm3m_olcopyr +#define XSYMM3M_OUCOPYR gotoblas -> xsymm3m_oucopyr +#define XSYMM3M_OLCOPYI gotoblas -> xsymm3m_olcopyi +#define XSYMM3M_OUCOPYI gotoblas -> xsymm3m_oucopyi + +#define XHEMM3M_ILCOPYB gotoblas -> xhemm3m_ilcopyb +#define XHEMM3M_IUCOPYB gotoblas -> xhemm3m_iucopyb +#define XHEMM3M_ILCOPYR gotoblas -> xhemm3m_ilcopyr +#define XHEMM3M_IUCOPYR gotoblas -> xhemm3m_iucopyr +#define XHEMM3M_ILCOPYI gotoblas -> xhemm3m_ilcopyi +#define XHEMM3M_IUCOPYI gotoblas -> xhemm3m_iucopyi + +#define XHEMM3M_OLCOPYB gotoblas -> xhemm3m_olcopyb +#define XHEMM3M_OUCOPYB gotoblas -> xhemm3m_oucopyb +#define XHEMM3M_OLCOPYR gotoblas -> xhemm3m_olcopyr +#define XHEMM3M_OUCOPYR gotoblas -> xhemm3m_oucopyr +#define XHEMM3M_OLCOPYI gotoblas -> xhemm3m_olcopyi +#define XHEMM3M_OUCOPYI gotoblas -> xhemm3m_oucopyi + +#define XGEMM3M_KERNEL gotoblas -> xgemm3m_kernel + +#define XNEG_TCOPY gotoblas -> xneg_tcopy +#define XLASWP_NCOPY gotoblas -> xlaswp_ncopy + +#endif + +#define XGEMM_NN xgemm_nn +#define XGEMM_CN xgemm_cn +#define XGEMM_TN xgemm_tn +#define XGEMM_NC xgemm_nc +#define XGEMM_NT xgemm_nt +#define XGEMM_CC xgemm_cc +#define XGEMM_CT xgemm_ct +#define XGEMM_TC xgemm_tc +#define XGEMM_TT xgemm_tt +#define XGEMM_NR xgemm_nr +#define XGEMM_TR xgemm_tr +#define XGEMM_CR xgemm_cr +#define XGEMM_RN xgemm_rn +#define XGEMM_RT xgemm_rt +#define XGEMM_RC xgemm_rc +#define XGEMM_RR xgemm_rr + +#define XSYMM_LU xsymm_LU +#define XSYMM_LL xsymm_LL +#define XSYMM_RU xsymm_RU +#define XSYMM_RL xsymm_RL + +#define XHEMM_LU xhemm_LU +#define XHEMM_LL xhemm_LL +#define XHEMM_RU xhemm_RU +#define XHEMM_RL xhemm_RL + +#define XSYRK_UN xsyrk_UN +#define XSYRK_UT xsyrk_UT +#define XSYRK_LN xsyrk_LN +#define XSYRK_LT xsyrk_LT +#define XSYRK_UR xsyrk_UN +#define XSYRK_UC xsyrk_UT +#define XSYRK_LR xsyrk_LN +#define XSYRK_LC xsyrk_LT + +#define XSYRK_KERNEL_U xsyrk_kernel_U +#define XSYRK_KERNEL_L xsyrk_kernel_L + +#define XHERK_UN xherk_UN +#define XHERK_LN xherk_LN +#define XHERK_UC xherk_UC +#define XHERK_LC xherk_LC + +#define XHER2K_UN xher2k_UN +#define XHER2K_LN xher2k_LN +#define XHER2K_UC xher2k_UC +#define XHER2K_LC xher2k_LC + +#define XSYR2K_UN xsyr2k_UN +#define XSYR2K_UT xsyr2k_UT +#define XSYR2K_LN xsyr2k_LN +#define XSYR2K_LT xsyr2k_LT +#define XSYR2K_UR xsyr2k_UN +#define XSYR2K_UC xsyr2k_UT +#define XSYR2K_LR xsyr2k_LN +#define XSYR2K_LC xsyr2k_LT + +#define XSYR2K_KERNEL_U xsyr2k_kernel_U +#define XSYR2K_KERNEL_L xsyr2k_kernel_L + +#define XTRMM_LNUU xtrmm_LNUU +#define XTRMM_LNUN xtrmm_LNUN +#define XTRMM_LNLU xtrmm_LNLU +#define XTRMM_LNLN xtrmm_LNLN +#define XTRMM_LTUU xtrmm_LTUU +#define XTRMM_LTUN xtrmm_LTUN +#define XTRMM_LTLU xtrmm_LTLU +#define XTRMM_LTLN xtrmm_LTLN +#define XTRMM_LRUU xtrmm_LRUU +#define XTRMM_LRUN xtrmm_LRUN +#define XTRMM_LRLU xtrmm_LRLU +#define XTRMM_LRLN xtrmm_LRLN +#define XTRMM_LCUU xtrmm_LCUU +#define XTRMM_LCUN xtrmm_LCUN +#define XTRMM_LCLU xtrmm_LCLU +#define XTRMM_LCLN xtrmm_LCLN +#define XTRMM_RNUU xtrmm_RNUU +#define XTRMM_RNUN xtrmm_RNUN +#define XTRMM_RNLU xtrmm_RNLU +#define XTRMM_RNLN xtrmm_RNLN +#define XTRMM_RTUU xtrmm_RTUU +#define XTRMM_RTUN xtrmm_RTUN +#define XTRMM_RTLU xtrmm_RTLU +#define XTRMM_RTLN xtrmm_RTLN +#define XTRMM_RRUU xtrmm_RRUU +#define XTRMM_RRUN xtrmm_RRUN +#define XTRMM_RRLU xtrmm_RRLU +#define XTRMM_RRLN xtrmm_RRLN +#define XTRMM_RCUU xtrmm_RCUU +#define XTRMM_RCUN xtrmm_RCUN +#define XTRMM_RCLU xtrmm_RCLU +#define XTRMM_RCLN xtrmm_RCLN + +#define XTRSM_LNUU xtrsm_LNUU +#define XTRSM_LNUN xtrsm_LNUN +#define XTRSM_LNLU xtrsm_LNLU +#define XTRSM_LNLN xtrsm_LNLN +#define XTRSM_LTUU xtrsm_LTUU +#define XTRSM_LTUN xtrsm_LTUN +#define XTRSM_LTLU xtrsm_LTLU +#define XTRSM_LTLN xtrsm_LTLN +#define XTRSM_LRUU xtrsm_LRUU +#define XTRSM_LRUN xtrsm_LRUN +#define XTRSM_LRLU xtrsm_LRLU +#define XTRSM_LRLN xtrsm_LRLN +#define XTRSM_LCUU xtrsm_LCUU +#define XTRSM_LCUN xtrsm_LCUN +#define XTRSM_LCLU xtrsm_LCLU +#define XTRSM_LCLN xtrsm_LCLN +#define XTRSM_RNUU xtrsm_RNUU +#define XTRSM_RNUN xtrsm_RNUN +#define XTRSM_RNLU xtrsm_RNLU +#define XTRSM_RNLN xtrsm_RNLN +#define XTRSM_RTUU xtrsm_RTUU +#define XTRSM_RTUN xtrsm_RTUN +#define XTRSM_RTLU xtrsm_RTLU +#define XTRSM_RTLN xtrsm_RTLN +#define XTRSM_RRUU xtrsm_RRUU +#define XTRSM_RRUN xtrsm_RRUN +#define XTRSM_RRLU xtrsm_RRLU +#define XTRSM_RRLN xtrsm_RRLN +#define XTRSM_RCUU xtrsm_RCUU +#define XTRSM_RCUN xtrsm_RCUN +#define XTRSM_RCLU xtrsm_RCLU +#define XTRSM_RCLN xtrsm_RCLN + +#define XGEMM_THREAD_NN xgemm_thread_nn +#define XGEMM_THREAD_CN xgemm_thread_cn +#define XGEMM_THREAD_TN xgemm_thread_tn +#define XGEMM_THREAD_NC xgemm_thread_nc +#define XGEMM_THREAD_NT xgemm_thread_nt +#define XGEMM_THREAD_CC xgemm_thread_cc +#define XGEMM_THREAD_CT xgemm_thread_ct +#define XGEMM_THREAD_TC xgemm_thread_tc +#define XGEMM_THREAD_TT xgemm_thread_tt +#define XGEMM_THREAD_NR xgemm_thread_nr +#define XGEMM_THREAD_TR xgemm_thread_tr +#define XGEMM_THREAD_CR xgemm_thread_cr +#define XGEMM_THREAD_RN xgemm_thread_rn +#define XGEMM_THREAD_RT xgemm_thread_rt +#define XGEMM_THREAD_RC xgemm_thread_rc +#define XGEMM_THREAD_RR xgemm_thread_rr + +#define XSYMM_THREAD_LU xsymm_thread_LU +#define XSYMM_THREAD_LL xsymm_thread_LL +#define XSYMM_THREAD_RU xsymm_thread_RU +#define XSYMM_THREAD_RL xsymm_thread_RL + +#define XHEMM_THREAD_LU xhemm_thread_LU +#define XHEMM_THREAD_LL xhemm_thread_LL +#define XHEMM_THREAD_RU xhemm_thread_RU +#define XHEMM_THREAD_RL xhemm_thread_RL + +#define XSYRK_THREAD_UN xsyrk_thread_UN +#define XSYRK_THREAD_UT xsyrk_thread_UT +#define XSYRK_THREAD_LN xsyrk_thread_LN +#define XSYRK_THREAD_LT xsyrk_thread_LT +#define XSYRK_THREAD_UR xsyrk_thread_UN +#define XSYRK_THREAD_UC xsyrk_thread_UT +#define XSYRK_THREAD_LR xsyrk_thread_LN +#define XSYRK_THREAD_LC xsyrk_thread_LT + +#define XHERK_THREAD_UN xherk_thread_UN +#define XHERK_THREAD_UT xherk_thread_UT +#define XHERK_THREAD_LN xherk_thread_LN +#define XHERK_THREAD_LT xherk_thread_LT +#define XHERK_THREAD_UR xherk_thread_UR +#define XHERK_THREAD_UC xherk_thread_UC +#define XHERK_THREAD_LR xherk_thread_LR +#define XHERK_THREAD_LC xherk_thread_LC + +#define XGEMM3M_NN xgemm3m_nn +#define XGEMM3M_CN xgemm3m_cn +#define XGEMM3M_TN xgemm3m_tn +#define XGEMM3M_NC xgemm3m_nc +#define XGEMM3M_NT xgemm3m_nt +#define XGEMM3M_CC xgemm3m_cc +#define XGEMM3M_CT xgemm3m_ct +#define XGEMM3M_TC xgemm3m_tc +#define XGEMM3M_TT xgemm3m_tt +#define XGEMM3M_NR xgemm3m_nr +#define XGEMM3M_TR xgemm3m_tr +#define XGEMM3M_CR xgemm3m_cr +#define XGEMM3M_RN xgemm3m_rn +#define XGEMM3M_RT xgemm3m_rt +#define XGEMM3M_RC xgemm3m_rc +#define XGEMM3M_RR xgemm3m_rr + +#define XGEMM3M_THREAD_NN xgemm3m_thread_nn +#define XGEMM3M_THREAD_CN xgemm3m_thread_cn +#define XGEMM3M_THREAD_TN xgemm3m_thread_tn +#define XGEMM3M_THREAD_NC xgemm3m_thread_nc +#define XGEMM3M_THREAD_NT xgemm3m_thread_nt +#define XGEMM3M_THREAD_CC xgemm3m_thread_cc +#define XGEMM3M_THREAD_CT xgemm3m_thread_ct +#define XGEMM3M_THREAD_TC xgemm3m_thread_tc +#define XGEMM3M_THREAD_TT xgemm3m_thread_tt +#define XGEMM3M_THREAD_NR xgemm3m_thread_nr +#define XGEMM3M_THREAD_TR xgemm3m_thread_tr +#define XGEMM3M_THREAD_CR xgemm3m_thread_cr +#define XGEMM3M_THREAD_RN xgemm3m_thread_rn +#define XGEMM3M_THREAD_RT xgemm3m_thread_rt +#define XGEMM3M_THREAD_RC xgemm3m_thread_rc +#define XGEMM3M_THREAD_RR xgemm3m_thread_rr + +#define XSYMM3M_LU xsymm3m_LU +#define XSYMM3M_LL xsymm3m_LL +#define XSYMM3M_RU xsymm3m_RU +#define XSYMM3M_RL xsymm3m_RL + +#define XSYMM3M_THREAD_LU xsymm3m_thread_LU +#define XSYMM3M_THREAD_LL xsymm3m_thread_LL +#define XSYMM3M_THREAD_RU xsymm3m_thread_RU +#define XSYMM3M_THREAD_RL xsymm3m_thread_RL + +#define XHEMM3M_LU xhemm3m_LU +#define XHEMM3M_LL xhemm3m_LL +#define XHEMM3M_RU xhemm3m_RU +#define XHEMM3M_RL xhemm3m_RL + +#define XHEMM3M_THREAD_LU xhemm3m_thread_LU +#define XHEMM3M_THREAD_LL xhemm3m_thread_LL +#define XHEMM3M_THREAD_RU xhemm3m_thread_RU +#define XHEMM3M_THREAD_RL xhemm3m_thread_RL + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_x86.h b/src/NativeWrappers/GotoBlas2/include/common_x86.h new file mode 100644 index 00000000..fbb91f88 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_x86.h @@ -0,0 +1,359 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef COMMON_X86 +#define COMMON_X86 + +#ifndef ASSEMBLER + +#define MB +#define WMB + +#ifdef C_SUN +#define __asm__ __asm +#define __volatile__ +#endif + +static void __inline blas_lock(volatile BLASULONG *address){ + + int ret; + + do { + while (*address) {YIELDING;}; + + __asm__ __volatile__( + "xchgl %0, %1\n" + : "=r"(ret), "=m"(*address) + : "0"(1), "m"(*address) + : "memory"); + + } while (ret); + +} + +static __inline unsigned long long rpcc(void){ + unsigned int a, d; + + __asm__ __volatile__ ("rdtsc" : "=a" (a), "=d" (d)); + + return ((unsigned long long)a + ((unsigned long long)d << 32)); +}; + +static __inline unsigned long getstackaddr(void){ + unsigned long addr; + + __asm__ __volatile__ ("mov %%esp, %0" + : "=r"(addr) : : "memory"); + + return addr; +}; + + +static __inline long double sqrt_long(long double val) { + long double result; + + __asm__ __volatile__ ("fldt %1\n" + "fsqrt\n" + "fstpt %0\n" : "=m" (result) : "m"(val)); + return result; +} + +#define SQRT(a) sqrt_long(a) + +/* This is due to gcc's bug */ +void cpuid(int op, int *eax, int *ebx, int *ecx, int *edx); + +#define WHEREAMI + +static inline int WhereAmI(void){ + int eax, ebx, ecx, edx; + int apicid; + + cpuid(1, &eax, &ebx, &ecx, &edx); + apicid = BITMASK(ebx, 24, 0xff); + + return apicid; +} + +#ifdef ENABLE_SSE_EXCEPTION + +#define IDEBUG_START \ +{ \ + unsigned int fp_sse_mode, new_fp_mode; \ + __asm__ __volatile__ ("stmxcsr %0" : "=m" (fp_sse_mode) : ); \ + new_fp_mode = fp_sse_mode & ~0xd00; \ + __asm__ __volatile__ ("ldmxcsr %0" : : "m" (new_fp_mode) ); + +#define IDEBUG_END \ + __asm__ __volatile__ ("ldmxcsr %0" : : "m" (fp_sse_mode) ); \ +} + +#endif + +#ifdef XDOUBLE +#define GET_IMAGE(res) __asm__ __volatile__("fstpt %0" : "=m"(res) : : "memory") +#elif defined(DOUBLE) +#define GET_IMAGE(res) __asm__ __volatile__("fstpl %0" : "=m"(res) : : "memory") +#else +#define GET_IMAGE(res) __asm__ __volatile__("fstps %0" : "=m"(res) : : "memory"); +#endif + +#define GET_IMAGE_CANCEL __asm__ __volatile__ ("ffree %st") + +#ifdef SMP +extern unsigned int blas_quick_divide_table[]; + +static __inline int blas_quickdivide(unsigned int x, unsigned int y){ + + unsigned int result; + + if (y <= 1) return x; + + y = blas_quick_divide_table[y]; + + __asm__ __volatile__ ("mull %0" :"=d" (result) :"a"(x), "0" (y)); + + return result; +} +#endif + +#endif + +#ifndef PAGESIZE +#define PAGESIZE ( 4 << 10) +#endif +#define HUGE_PAGESIZE ( 4 << 20) + +#define BUFFER_SIZE (16 << 20) + +#define SEEK_ADDRESS + +#if defined(DOUBLE) || defined(XDOUBLE) +#define MMXLOAD movq +#define MMXSTORE movq +#else +#define MMXLOAD movd +#define MMXSTORE movd +#endif + +#if defined(HAVE_3DNOW) +#define EMMS femms +#elif defined(HAVE_MMX) +#define EMMS emms +#endif + +#ifndef EMMS +#define EMMS +#endif + +#if defined(CORE2) || defined(PENTIUM4) +#define movapd movaps +#endif + +#define BRANCH .byte 0x3e +#define NOBRANCH .byte 0x2e +#define PADDING .byte 0x66; +#define HALT hlt + +#ifndef COMPLEX +#ifdef XDOUBLE +#define LOCAL_BUFFER_SIZE QLOCAL_BUFFER_SIZE +#elif defined DOUBLE +#define LOCAL_BUFFER_SIZE DLOCAL_BUFFER_SIZE +#else +#define LOCAL_BUFFER_SIZE SLOCAL_BUFFER_SIZE +#endif +#else +#ifdef XDOUBLE +#define LOCAL_BUFFER_SIZE XLOCAL_BUFFER_SIZE +#elif defined DOUBLE +#define LOCAL_BUFFER_SIZE ZLOCAL_BUFFER_SIZE +#else +#define LOCAL_BUFFER_SIZE CLOCAL_BUFFER_SIZE +#endif +#endif + +#if defined(OS_WINDOWS) +#if LOCAL_BUFFER_SIZE > 16384 +#define STACK_TOUCHING \ + movl $0, 4096 * 4(%esp);\ + movl $0, 4096 * 3(%esp);\ + movl $0, 4096 * 2(%esp);\ + movl $0, 4096 * 1(%esp); +#elif LOCAL_BUFFER_SIZE > 12288 +#define STACK_TOUCHING \ + movl $0, 4096 * 3(%esp);\ + movl $0, 4096 * 2(%esp);\ + movl $0, 4096 * 1(%esp); +#elif LOCAL_BUFFER_SIZE > 8192 +#define STACK_TOUCHING \ + movl $0, 4096 * 2(%esp);\ + movl $0, 4096 * 1(%esp); +#elif LOCAL_BUFFER_SIZE > 4096 +#define STACK_TOUCHING \ + movl $0, 4096 * 1(%esp); +#else +#define STACK_TOUCHING +#endif +#else +#define STACK_TOUCHING +#endif + +#ifndef F_INTERFACE +#define REALNAME ASMNAME +#else +#define REALNAME ASMFNAME +#endif + +#if defined(F_INTERFACE_PATHSCALE) || defined(F_INTERFACE_OPEN64) +#define RETURN_BY_STRUCT +#elif defined(F_INTERFACE_GFORT) || defined(F_INTERFACE_G95) +#define RETURN_BY_COMPLEX +#else +#define RETURN_BY_STACK +#endif + +#ifdef OS_DARWIN +#define PROLOGUE .text;.align 5; .globl REALNAME; REALNAME: +#define EPILOGUE .subsections_via_symbols +#define PROFCODE +#endif + +#if defined(OS_WINNT) || defined(OS_CYGWIN_NT) || defined(OS_INERIX) +#define SAVEREGISTERS \ + subl $32, %esp;\ + movups %xmm6, 0(%esp);\ + movups %xmm7, 16(%esp) + +#define RESTOREREGISTERS \ + movups 0(%esp), %xmm6;\ + movups 16(%esp), %xmm7;\ + addl $32, %esp +#else +#define SAVEREGISTERS +#define RESTOREREGISTERS +#endif + +#if defined(OS_WINNT) || defined(OS_CYGWIN_NT) || defined(OS_INERIX) +#define PROLOGUE \ + .text; \ + .align 16; \ + .globl REALNAME ;\ + .def REALNAME;.scl 2;.type 32;.endef; \ +REALNAME: + +#define PROFCODE + +#define EPILOGUE .end REALNAME +#endif + +#if defined(OS_LINUX) || defined(OS_FreeBSD) || defined(OS_NetBSD) || defined(__ELF__) +#define PROLOGUE \ + .text; \ + .align 16; \ + .globl REALNAME ;\ + .type REALNAME, @function; \ +REALNAME: + +#ifdef PROFILE +#define PROFCODE call mcount +#else +#define PROFCODE +#endif + +#define EPILOGUE .size REALNAME, .-REALNAME + +#endif + +#ifdef XDOUBLE +#define FLD fldt +#define FST fstpt +#define FSTU fstt +#define FMUL fmult +#define FADD faddt +#define FSUB fsubt +#define FSUBR fsubrt +#elif defined(DOUBLE) +#define FLD fldl +#define FST fstpl +#define FSTU fstl +#define FMUL fmull +#define FADD faddl +#define FSUB fsubl +#define FSUBR fsubrl +#else +#define FLD flds +#define FST fstps +#define FSTU fsts +#define FMUL fmuls +#define FADD fadds +#define FSUB fsubs +#define FSUBR fsubrs +#endif +#endif + +#ifdef C_SUN +#define ffreep fstp +#endif + +#ifdef __APPLE__ +#define ALIGN_2 .align 2 +#define ALIGN_3 .align 3 +#define ALIGN_4 .align 4 +#define ffreep fstp +#endif + +#ifndef ALIGN_2 +#define ALIGN_2 .align 4 +#endif + +#ifndef ALIGN_3 +#define ALIGN_3 .align 8 +#endif + +#ifndef ALIGN_4 +#define ALIGN_4 .align 16 +#endif + +#ifndef ALIGN_5 +#define ALIGN_5 .align 32 +#endif + +#ifndef ALIGN_6 +#define ALIGN_6 .align 64 +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_x86_64.h b/src/NativeWrappers/GotoBlas2/include/common_x86_64.h new file mode 100644 index 00000000..53b70218 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_x86_64.h @@ -0,0 +1,451 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef COMMON_X86 +#define COMMON_X86 + +#ifndef ASSEMBLER + +#ifdef C_SUN +#define __asm__ __asm +#define __volatile__ +#endif + +#ifdef HAVE_SSE2 +#define MB __asm__ __volatile__ ("mfence"); +#define WMB __asm__ __volatile__ ("sfence"); +#else +#define MB +#define WMB +#endif + +static void __inline blas_lock(volatile BLASULONG *address){ + + int ret; + + do { + while (*address) {YIELDING;}; + + __asm__ __volatile__( + "xchgl %0, %1\n" + : "=r"(ret), "=m"(*address) + : "0"(1), "m"(*address) + : "memory"); + + } while (ret); +} + +static __inline BLASULONG rpcc(void){ + BLASULONG a, d; + + __asm__ __volatile__ ("rdtsc" : "=a" (a), "=d" (d)); + + return ((BLASULONG)a + ((BLASULONG)d << 32)); +} + +#define RPCC64BIT + +static __inline BLASULONG getstackaddr(void){ + BLASULONG addr; + + __asm__ __volatile__ ("movq %%rsp, %0" + : "=r"(addr) : : "memory"); + + return addr; +} + +static __inline void cpuid(int op, int *eax, int *ebx, int *ecx, int *edx){ + + __asm__ __volatile__("cpuid" + : "=a" (*eax), + "=b" (*ebx), + "=c" (*ecx), + "=d" (*edx) + : "0" (op)); +} + +#define WHEREAMI + +static inline int WhereAmI(void){ + int eax, ebx, ecx, edx; + int apicid; + + cpuid(1, &eax, &ebx, &ecx, &edx); + apicid = BITMASK(ebx, 24, 0xff); + + return apicid; +} + +#ifdef CORE_BARCELONA +#define IFLUSH gotoblas_iflush() +#define IFLUSH_HALF gotoblas_iflush_half() +#endif + +#ifdef ENABLE_SSE_EXCEPTION + +#define IDEBUG_START \ +{ \ + unsigned int fp_sse_mode, new_fp_mode; \ + __asm__ __volatile__ ("stmxcsr %0" : "=m" (fp_sse_mode) : ); \ + new_fp_mode = fp_sse_mode & ~0xd00; \ + __asm__ __volatile__ ("ldmxcsr %0" : : "m" (new_fp_mode) ); + +#define IDEBUG_END \ + __asm__ __volatile__ ("ldmxcsr %0" : : "m" (fp_sse_mode) ); \ +} + +#endif + +#ifdef XDOUBLE +#define GET_IMAGE(res) __asm__ __volatile__("fstpt %0" : "=m"(res) : : "memory") +#elif defined(DOUBLE) +#define GET_IMAGE(res) __asm__ __volatile__("movsd %%xmm1, %0" : "=m"(res) : : "memory") +#else +#define GET_IMAGE(res) __asm__ __volatile__("movss %%xmm1, %0" : "=m"(res) : : "memory") +#endif + +#define GET_IMAGE_CANCEL + +#ifdef SMP +#ifdef USE64BITINT +static __inline blasint blas_quickdivide(blasint x, blasint y){ + return x / y; +} +#else +extern unsigned int blas_quick_divide_table[]; + +static __inline int blas_quickdivide(unsigned int x, unsigned int y){ + + unsigned int result; + + if (y <= 1) return x; + + y = blas_quick_divide_table[y]; + + __asm__ __volatile__ ("mull %0" :"=d" (result) :"a"(x), "0" (y)); + + return result; +} +#endif +#endif + +#endif + +#ifndef PAGESIZE +#define PAGESIZE ( 4 << 10) +#endif +#define HUGE_PAGESIZE ( 2 << 20) + +#define BUFFER_SIZE (32 << 20) + +#define SEEK_ADDRESS + +#ifdef F_INTERFACE_G77 +#define RETURN_BY_STACK +#define NEED_F2CCONV +#endif + +#ifdef F_INTERFACE_G95 +#define RETURN_BY_PACKED +#endif + +#ifdef F_INTERFACE_GFORT +#ifdef OS_WINDOWS +#ifndef DOUBLE +#define RETURN_BY_REGS +#else +#define RETURN_BY_STACK +#endif +#else +#define RETURN_BY_PACKED +#endif +#endif + +#ifdef F_INTERFACE_INTEL +#define RETURN_BY_STACK +#endif + +#ifdef F_INTERFACE_FUJITSU +#define RETURN_BY_STACK +#endif + +#ifdef F_INTERFACE_PGI +#define RETURN_BY_STACK +#endif + +#ifdef F_INTERFACE_PATHSCALE +#define RETURN_BY_PACKED +#endif + +#ifdef F_INTERFACE_SUN +#define RETURN_BY_PACKED +#endif + +#ifdef ASSEMBLER + +#if defined(HAVE_3DNOW) +#define EMMS femms +#elif defined(HAVE_MMX) +#define EMMS emms +#endif + +#ifndef EMMS +#define EMMS +#endif + +#define BRANCH .byte 0x3e +#define NOBRANCH .byte 0x2e +#define PADDING .byte 0x66 + +#ifdef OS_WINDOWS +#define ARG1 %rcx +#define ARG2 %rdx +#define ARG3 %r8 +#define ARG4 %r9 +#else +#define ARG1 %rdi +#define ARG2 %rsi +#define ARG3 %rdx +#define ARG4 %rcx +#define ARG5 %r8 +#define ARG6 %r9 +#endif + +#ifndef COMPLEX +#ifdef XDOUBLE +#define LOCAL_BUFFER_SIZE QLOCAL_BUFFER_SIZE +#elif defined DOUBLE +#define LOCAL_BUFFER_SIZE DLOCAL_BUFFER_SIZE +#else +#define LOCAL_BUFFER_SIZE SLOCAL_BUFFER_SIZE +#endif +#else +#ifdef XDOUBLE +#define LOCAL_BUFFER_SIZE XLOCAL_BUFFER_SIZE +#elif defined DOUBLE +#define LOCAL_BUFFER_SIZE ZLOCAL_BUFFER_SIZE +#else +#define LOCAL_BUFFER_SIZE CLOCAL_BUFFER_SIZE +#endif +#endif + +#if defined(OS_WINDOWS) +#if LOCAL_BUFFER_SIZE > 16384 +#define STACK_TOUCHING \ + movl $0, 4096 * 4(%rsp);\ + movl $0, 4096 * 3(%rsp);\ + movl $0, 4096 * 2(%rsp);\ + movl $0, 4096 * 1(%rsp); +#elif LOCAL_BUFFER_SIZE > 12288 +#define STACK_TOUCHING \ + movl $0, 4096 * 3(%rsp);\ + movl $0, 4096 * 2(%rsp);\ + movl $0, 4096 * 1(%rsp); +#elif LOCAL_BUFFER_SIZE > 8192 +#define STACK_TOUCHING \ + movl $0, 4096 * 2(%rsp);\ + movl $0, 4096 * 1(%rsp); +#elif LOCAL_BUFFER_SIZE > 4096 +#define STACK_TOUCHING \ + movl $0, 4096 * 1(%rsp); +#else +#define STACK_TOUCHING +#endif +#else +#define STACK_TOUCHING +#endif + +#if defined(CORE2) +#define movapd movaps +#define andpd andps +#define movlpd movlps +#define movhpd movhps +#endif + +#ifndef F_INTERFACE +#define REALNAME ASMNAME +#else +#define REALNAME ASMFNAME +#endif + +#ifdef OS_DARWIN +#define PROLOGUE .text;.align 5; .globl REALNAME; REALNAME: +#define EPILOGUE .subsections_via_symbols +#define PROFCODE +#endif + +#ifdef OS_WINDOWS +#define SAVEREGISTERS \ + subq $256, %rsp;\ + movups %xmm6, 0(%rsp);\ + movups %xmm7, 16(%rsp);\ + movups %xmm8, 32(%rsp);\ + movups %xmm9, 48(%rsp);\ + movups %xmm10, 64(%rsp);\ + movups %xmm11, 80(%rsp);\ + movups %xmm12, 96(%rsp);\ + movups %xmm13, 112(%rsp);\ + movups %xmm14, 128(%rsp);\ + movups %xmm15, 144(%rsp) + +#define RESTOREREGISTERS \ + movups 0(%rsp), %xmm6;\ + movups 16(%rsp), %xmm7;\ + movups 32(%rsp), %xmm8;\ + movups 48(%rsp), %xmm9;\ + movups 64(%rsp), %xmm10;\ + movups 80(%rsp), %xmm11;\ + movups 96(%rsp), %xmm12;\ + movups 112(%rsp), %xmm13;\ + movups 128(%rsp), %xmm14;\ + movups 144(%rsp), %xmm15;\ + addq $256, %rsp +#else +#define SAVEREGISTERS +#define RESTOREREGISTERS +#endif + +#if defined(OS_WINDOWS) && !defined(C_PGI) +#define PROLOGUE \ + .text; \ + .align 16; \ + .globl REALNAME ;\ + .def REALNAME;.scl 2;.type 32;.endef; \ +REALNAME: + +#define PROFCODE + +#define EPILOGUE .end REALNAME +#endif + +#if defined(OS_LINUX) || defined(OS_FreeBSD) || defined(OS_NetBSD) || defined(__ELF__) || defined(C_PGI) +#define PROLOGUE \ + .text; \ + .align 512; \ + .globl REALNAME ;\ + .type REALNAME, @function; \ +REALNAME: + +#ifdef PROFILE +#define PROFCODE call *mcount@GOTPCREL(%rip) +#else +#define PROFCODE +#endif + +#define EPILOGUE .size REALNAME, .-REALNAME + +#endif + +#endif + +#ifdef XDOUBLE +#define FLD fldt +#define FST fstpt +#define MOVQ movq +#elif defined(DOUBLE) +#define FLD fldl +#define FST fstpl +#define FSTU fstl +#define FMUL fmull +#define FADD faddl +#define MOVSD movsd +#define MULSD mulsd +#define MULPD mulpd +#define CMPEQPD cmpeqpd +#define COMISD comisd +#define PSRLQ psrlq +#define ANDPD andpd +#define ADDPD addpd +#define ADDSD addsd +#define SUBPD subpd +#define SUBSD subsd +#define MOVQ movq +#define MOVUPD movupd +#define XORPD xorpd +#else +#define FLD flds +#define FST fstps +#define FSTU fsts +#define FMUL fmuls +#define FADD fadds +#define MOVSD movss +#define MULSD mulss +#define MULPD mulps +#define CMPEQPD cmpeqps +#define COMISD comiss +#define PSRLQ psrld +#define ANDPD andps +#define ADDPD addps +#define ADDSD addss +#define SUBPD subps +#define SUBSD subss +#define MOVQ movd +#define MOVUPD movups +#define XORPD xorps +#endif + +#define HALT hlt + +#ifdef OS_DARWIN +#define ALIGN_2 .align 2 +#define ALIGN_3 .align 3 +#define ALIGN_4 .align 4 +#define ffreep fstp +#endif + +#ifndef ALIGN_2 +#define ALIGN_2 .align 4 +#endif + +#ifndef ALIGN_3 +#define ALIGN_3 .align 8 +#endif + +#ifndef ALIGN_4 +#define ALIGN_4 .align 16 +#endif + +#ifndef ALIGN_5 +#define ALIGN_5 .align 32 +#endif + +#ifndef ALIGN_6 +#define ALIGN_6 .align 64 +#endif + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/common_z.h b/src/NativeWrappers/GotoBlas2/include/common_z.h new file mode 100644 index 00000000..8832cacc --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/common_z.h @@ -0,0 +1,611 @@ +#ifndef COMMON_Z_H +#define COMMON_Z_H + +#ifndef DYNAMIC_ARCH + +#define ZAMAX_K zamax_k +#define ZAMIN_K zamin_k +#define ZMAX_K zmax_k +#define ZMIN_K zmin_k +#define IZAMAX_K izamax_k +#define IZAMIN_K izamin_k +#define IZMAX_K izmax_k +#define IZMIN_K izmin_k +#define ZASUM_K zasum_k +#define ZAXPYU_K zaxpy_k +#define ZAXPYC_K zaxpyc_k +#define ZCOPY_K zcopy_k +#define ZDOTU_K zdotu_k +#define ZDOTC_K zdotc_k +#define ZNRM2_K znrm2_k +#define ZSCAL_K zscal_k +#define ZSWAP_K zswap_k +#define ZROT_K zdrot_k + +#define ZGEMV_N zgemv_n +#define ZGEMV_T zgemv_t +#define ZGEMV_R zgemv_r +#define ZGEMV_C zgemv_c +#define ZGEMV_O zgemv_o +#define ZGEMV_U zgemv_u +#define ZGEMV_S zgemv_s +#define ZGEMV_D zgemv_d + +#define ZGERU_K zgeru_k +#define ZGERC_K zgerc_k +#define ZGERV_K zgerv_k +#define ZGERD_K zgerd_k + +#define ZSYMV_U zsymv_U +#define ZSYMV_L zsymv_L +#define ZHEMV_U zhemv_U +#define ZHEMV_L zhemv_L +#define ZHEMV_V zhemv_V +#define ZHEMV_M zhemv_M + +#define ZSYMV_THREAD_U zsymv_thread_U +#define ZSYMV_THREAD_L zsymv_thread_L +#define ZHEMV_THREAD_U zhemv_thread_U +#define ZHEMV_THREAD_L zhemv_thread_L +#define ZHEMV_THREAD_V zhemv_thread_V +#define ZHEMV_THREAD_M zhemv_thread_M + +#define ZGEMM_ONCOPY zgemm_oncopy +#define ZGEMM_OTCOPY zgemm_otcopy + +#if ZGEMM_DEFAULT_UNROLL_M == ZGEMM_DEFAULT_UNROLL_N +#define ZGEMM_INCOPY zgemm_oncopy +#define ZGEMM_ITCOPY zgemm_otcopy +#else +#define ZGEMM_INCOPY zgemm_incopy +#define ZGEMM_ITCOPY zgemm_itcopy +#endif + +#define ZTRMM_OUNUCOPY ztrmm_ounucopy +#define ZTRMM_OUNNCOPY ztrmm_ounncopy +#define ZTRMM_OUTUCOPY ztrmm_outucopy +#define ZTRMM_OUTNCOPY ztrmm_outncopy +#define ZTRMM_OLNUCOPY ztrmm_olnucopy +#define ZTRMM_OLNNCOPY ztrmm_olnncopy +#define ZTRMM_OLTUCOPY ztrmm_oltucopy +#define ZTRMM_OLTNCOPY ztrmm_oltncopy + +#define ZTRSM_OUNUCOPY ztrsm_ounucopy +#define ZTRSM_OUNNCOPY ztrsm_ounncopy +#define ZTRSM_OUTUCOPY ztrsm_outucopy +#define ZTRSM_OUTNCOPY ztrsm_outncopy +#define ZTRSM_OLNUCOPY ztrsm_olnucopy +#define ZTRSM_OLNNCOPY ztrsm_olnncopy +#define ZTRSM_OLTUCOPY ztrsm_oltucopy +#define ZTRSM_OLTNCOPY ztrsm_oltncopy + +#if ZGEMM_DEFAULT_UNROLL_M == ZGEMM_DEFAULT_UNROLL_N +#define ZTRMM_IUNUCOPY ztrmm_ounucopy +#define ZTRMM_IUNNCOPY ztrmm_ounncopy +#define ZTRMM_IUTUCOPY ztrmm_outucopy +#define ZTRMM_IUTNCOPY ztrmm_outncopy +#define ZTRMM_ILNUCOPY ztrmm_olnucopy +#define ZTRMM_ILNNCOPY ztrmm_olnncopy +#define ZTRMM_ILTUCOPY ztrmm_oltucopy +#define ZTRMM_ILTNCOPY ztrmm_oltncopy + +#define ZTRSM_IUNUCOPY ztrsm_ounucopy +#define ZTRSM_IUNNCOPY ztrsm_ounncopy +#define ZTRSM_IUTUCOPY ztrsm_outucopy +#define ZTRSM_IUTNCOPY ztrsm_outncopy +#define ZTRSM_ILNUCOPY ztrsm_olnucopy +#define ZTRSM_ILNNCOPY ztrsm_olnncopy +#define ZTRSM_ILTUCOPY ztrsm_oltucopy +#define ZTRSM_ILTNCOPY ztrsm_oltncopy +#else +#define ZTRMM_IUNUCOPY ztrmm_iunucopy +#define ZTRMM_IUNNCOPY ztrmm_iunncopy +#define ZTRMM_IUTUCOPY ztrmm_iutucopy +#define ZTRMM_IUTNCOPY ztrmm_iutncopy +#define ZTRMM_ILNUCOPY ztrmm_ilnucopy +#define ZTRMM_ILNNCOPY ztrmm_ilnncopy +#define ZTRMM_ILTUCOPY ztrmm_iltucopy +#define ZTRMM_ILTNCOPY ztrmm_iltncopy + +#define ZTRSM_IUNUCOPY ztrsm_iunucopy +#define ZTRSM_IUNNCOPY ztrsm_iunncopy +#define ZTRSM_IUTUCOPY ztrsm_iutucopy +#define ZTRSM_IUTNCOPY ztrsm_iutncopy +#define ZTRSM_ILNUCOPY ztrsm_ilnucopy +#define ZTRSM_ILNNCOPY ztrsm_ilnncopy +#define ZTRSM_ILTUCOPY ztrsm_iltucopy +#define ZTRSM_ILTNCOPY ztrsm_iltncopy +#endif + +#define ZGEMM_BETA zgemm_beta + +#define ZGEMM_KERNEL_N zgemm_kernel_n +#define ZGEMM_KERNEL_L zgemm_kernel_l +#define ZGEMM_KERNEL_R zgemm_kernel_r +#define ZGEMM_KERNEL_B zgemm_kernel_b + +#define ZTRMM_KERNEL_LN ztrmm_kernel_LN +#define ZTRMM_KERNEL_LT ztrmm_kernel_LT +#define ZTRMM_KERNEL_LR ztrmm_kernel_LR +#define ZTRMM_KERNEL_LC ztrmm_kernel_LC +#define ZTRMM_KERNEL_RN ztrmm_kernel_RN +#define ZTRMM_KERNEL_RT ztrmm_kernel_RT +#define ZTRMM_KERNEL_RR ztrmm_kernel_RR +#define ZTRMM_KERNEL_RC ztrmm_kernel_RC + +#define ZTRSM_KERNEL_LN ztrsm_kernel_LN +#define ZTRSM_KERNEL_LT ztrsm_kernel_LT +#define ZTRSM_KERNEL_LR ztrsm_kernel_LR +#define ZTRSM_KERNEL_LC ztrsm_kernel_LC +#define ZTRSM_KERNEL_RN ztrsm_kernel_RN +#define ZTRSM_KERNEL_RT ztrsm_kernel_RT +#define ZTRSM_KERNEL_RR ztrsm_kernel_RR +#define ZTRSM_KERNEL_RC ztrsm_kernel_RC + +#define ZSYMM_OUTCOPY zsymm_outcopy +#define ZSYMM_OLTCOPY zsymm_oltcopy +#if ZGEMM_DEFAULT_UNROLL_M == ZGEMM_DEFAULT_UNROLL_N +#define ZSYMM_IUTCOPY zsymm_outcopy +#define ZSYMM_ILTCOPY zsymm_oltcopy +#else +#define ZSYMM_IUTCOPY zsymm_iutcopy +#define ZSYMM_ILTCOPY zsymm_iltcopy +#endif + +#define ZHEMM_OUTCOPY zhemm_outcopy +#define ZHEMM_OLTCOPY zhemm_oltcopy +#if ZGEMM_DEFAULT_UNROLL_M == ZGEMM_DEFAULT_UNROLL_N +#define ZHEMM_IUTCOPY zhemm_outcopy +#define ZHEMM_ILTCOPY zhemm_oltcopy +#else +#define ZHEMM_IUTCOPY zhemm_iutcopy +#define ZHEMM_ILTCOPY zhemm_iltcopy +#endif + +#define ZGEMM3M_ONCOPYB zgemm3m_oncopyb +#define ZGEMM3M_ONCOPYR zgemm3m_oncopyr +#define ZGEMM3M_ONCOPYI zgemm3m_oncopyi +#define ZGEMM3M_OTCOPYB zgemm3m_otcopyb +#define ZGEMM3M_OTCOPYR zgemm3m_otcopyr +#define ZGEMM3M_OTCOPYI zgemm3m_otcopyi + +#define ZGEMM3M_INCOPYB zgemm3m_incopyb +#define ZGEMM3M_INCOPYR zgemm3m_incopyr +#define ZGEMM3M_INCOPYI zgemm3m_incopyi +#define ZGEMM3M_ITCOPYB zgemm3m_itcopyb +#define ZGEMM3M_ITCOPYR zgemm3m_itcopyr +#define ZGEMM3M_ITCOPYI zgemm3m_itcopyi + +#define ZSYMM3M_ILCOPYB zsymm3m_ilcopyb +#define ZSYMM3M_IUCOPYB zsymm3m_iucopyb +#define ZSYMM3M_ILCOPYR zsymm3m_ilcopyr +#define ZSYMM3M_IUCOPYR zsymm3m_iucopyr +#define ZSYMM3M_ILCOPYI zsymm3m_ilcopyi +#define ZSYMM3M_IUCOPYI zsymm3m_iucopyi + +#define ZSYMM3M_OLCOPYB zsymm3m_olcopyb +#define ZSYMM3M_OUCOPYB zsymm3m_oucopyb +#define ZSYMM3M_OLCOPYR zsymm3m_olcopyr +#define ZSYMM3M_OUCOPYR zsymm3m_oucopyr +#define ZSYMM3M_OLCOPYI zsymm3m_olcopyi +#define ZSYMM3M_OUCOPYI zsymm3m_oucopyi + +#define ZHEMM3M_ILCOPYB zhemm3m_ilcopyb +#define ZHEMM3M_IUCOPYB zhemm3m_iucopyb +#define ZHEMM3M_ILCOPYR zhemm3m_ilcopyr +#define ZHEMM3M_IUCOPYR zhemm3m_iucopyr +#define ZHEMM3M_ILCOPYI zhemm3m_ilcopyi +#define ZHEMM3M_IUCOPYI zhemm3m_iucopyi + +#define ZHEMM3M_OLCOPYB zhemm3m_olcopyb +#define ZHEMM3M_OUCOPYB zhemm3m_oucopyb +#define ZHEMM3M_OLCOPYR zhemm3m_olcopyr +#define ZHEMM3M_OUCOPYR zhemm3m_oucopyr +#define ZHEMM3M_OLCOPYI zhemm3m_olcopyi +#define ZHEMM3M_OUCOPYI zhemm3m_oucopyi + +#define ZGEMM3M_KERNEL zgemm3m_kernel + +#define ZNEG_TCOPY zneg_tcopy +#define ZLASWP_NCOPY zlaswp_ncopy + +#else + +#define ZAMAX_K gotoblas -> zamax_k +#define ZAMIN_K gotoblas -> zamin_k +#define ZMAX_K gotoblas -> zmax_k +#define ZMIN_K gotoblas -> zmin_k +#define IZAMAX_K gotoblas -> izamax_k +#define IZAMIN_K gotoblas -> izamin_k +#define IZMAX_K gotoblas -> izmax_k +#define IZMIN_K gotoblas -> izmin_k +#define ZASUM_K gotoblas -> zasum_k +#define ZAXPYU_K gotoblas -> zaxpy_k +#define ZAXPYC_K gotoblas -> zaxpyc_k +#define ZCOPY_K gotoblas -> zcopy_k +#define ZDOTU_K gotoblas -> zdotu_k +#define ZDOTC_K gotoblas -> zdotc_k +#define ZNRM2_K gotoblas -> znrm2_k +#define ZSCAL_K gotoblas -> zscal_k +#define ZSWAP_K gotoblas -> zswap_k +#define ZROT_K gotoblas -> zdrot_k + +#define ZGEMV_N gotoblas -> zgemv_n +#define ZGEMV_T gotoblas -> zgemv_t +#define ZGEMV_R gotoblas -> zgemv_r +#define ZGEMV_C gotoblas -> zgemv_c +#define ZGEMV_O gotoblas -> zgemv_o +#define ZGEMV_U gotoblas -> zgemv_u +#define ZGEMV_S gotoblas -> zgemv_s +#define ZGEMV_D gotoblas -> zgemv_d + +#define ZGERU_K gotoblas -> zgeru_k +#define ZGERC_K gotoblas -> zgerc_k +#define ZGERV_K gotoblas -> zgerv_k +#define ZGERD_K gotoblas -> zgerd_k + +#define ZSYMV_U gotoblas -> zsymv_U +#define ZSYMV_L gotoblas -> zsymv_L +#define ZHEMV_U gotoblas -> zhemv_U +#define ZHEMV_L gotoblas -> zhemv_L +#define ZHEMV_V gotoblas -> zhemv_V +#define ZHEMV_M gotoblas -> zhemv_M + +#define ZSYMV_THREAD_U zsymv_thread_U +#define ZSYMV_THREAD_L zsymv_thread_L +#define ZHEMV_THREAD_U zhemv_thread_U +#define ZHEMV_THREAD_L zhemv_thread_L +#define ZHEMV_THREAD_V zhemv_thread_V +#define ZHEMV_THREAD_M zhemv_thread_M + +#define ZGEMM_ONCOPY gotoblas -> zgemm_oncopy +#define ZGEMM_OTCOPY gotoblas -> zgemm_otcopy +#define ZGEMM_INCOPY gotoblas -> zgemm_incopy +#define ZGEMM_ITCOPY gotoblas -> zgemm_itcopy + +#define ZTRMM_OUNUCOPY gotoblas -> ztrmm_ounucopy +#define ZTRMM_OUTUCOPY gotoblas -> ztrmm_outucopy +#define ZTRMM_OLNUCOPY gotoblas -> ztrmm_olnucopy +#define ZTRMM_OLTUCOPY gotoblas -> ztrmm_oltucopy +#define ZTRSM_OUNUCOPY gotoblas -> ztrsm_ounucopy +#define ZTRSM_OUTUCOPY gotoblas -> ztrsm_outucopy +#define ZTRSM_OLNUCOPY gotoblas -> ztrsm_olnucopy +#define ZTRSM_OLTUCOPY gotoblas -> ztrsm_oltucopy + +#define ZTRMM_IUNUCOPY gotoblas -> ztrmm_iunucopy +#define ZTRMM_IUTUCOPY gotoblas -> ztrmm_iutucopy +#define ZTRMM_ILNUCOPY gotoblas -> ztrmm_ilnucopy +#define ZTRMM_ILTUCOPY gotoblas -> ztrmm_iltucopy +#define ZTRSM_IUNUCOPY gotoblas -> ztrsm_iunucopy +#define ZTRSM_IUTUCOPY gotoblas -> ztrsm_iutucopy +#define ZTRSM_ILNUCOPY gotoblas -> ztrsm_ilnucopy +#define ZTRSM_ILTUCOPY gotoblas -> ztrsm_iltucopy + +#define ZTRMM_OUNNCOPY gotoblas -> ztrmm_ounncopy +#define ZTRMM_OUTNCOPY gotoblas -> ztrmm_outncopy +#define ZTRMM_OLNNCOPY gotoblas -> ztrmm_olnncopy +#define ZTRMM_OLTNCOPY gotoblas -> ztrmm_oltncopy +#define ZTRSM_OUNNCOPY gotoblas -> ztrsm_ounncopy +#define ZTRSM_OUTNCOPY gotoblas -> ztrsm_outncopy +#define ZTRSM_OLNNCOPY gotoblas -> ztrsm_olnncopy +#define ZTRSM_OLTNCOPY gotoblas -> ztrsm_oltncopy + +#define ZTRMM_IUNNCOPY gotoblas -> ztrmm_iunncopy +#define ZTRMM_IUTNCOPY gotoblas -> ztrmm_iutncopy +#define ZTRMM_ILNNCOPY gotoblas -> ztrmm_ilnncopy +#define ZTRMM_ILTNCOPY gotoblas -> ztrmm_iltncopy +#define ZTRSM_IUNNCOPY gotoblas -> ztrsm_iunncopy +#define ZTRSM_IUTNCOPY gotoblas -> ztrsm_iutncopy +#define ZTRSM_ILNNCOPY gotoblas -> ztrsm_ilnncopy +#define ZTRSM_ILTNCOPY gotoblas -> ztrsm_iltncopy + +#define ZGEMM_BETA gotoblas -> zgemm_beta +#define ZGEMM_KERNEL_N gotoblas -> zgemm_kernel_n +#define ZGEMM_KERNEL_L gotoblas -> zgemm_kernel_l +#define ZGEMM_KERNEL_R gotoblas -> zgemm_kernel_r +#define ZGEMM_KERNEL_B gotoblas -> zgemm_kernel_b + +#define ZTRMM_KERNEL_LN gotoblas -> ztrmm_kernel_LN +#define ZTRMM_KERNEL_LT gotoblas -> ztrmm_kernel_LT +#define ZTRMM_KERNEL_LR gotoblas -> ztrmm_kernel_LR +#define ZTRMM_KERNEL_LC gotoblas -> ztrmm_kernel_LC +#define ZTRMM_KERNEL_RN gotoblas -> ztrmm_kernel_RN +#define ZTRMM_KERNEL_RT gotoblas -> ztrmm_kernel_RT +#define ZTRMM_KERNEL_RR gotoblas -> ztrmm_kernel_RR +#define ZTRMM_KERNEL_RC gotoblas -> ztrmm_kernel_RC + +#define ZTRSM_KERNEL_LN gotoblas -> ztrsm_kernel_LN +#define ZTRSM_KERNEL_LT gotoblas -> ztrsm_kernel_LT +#define ZTRSM_KERNEL_LR gotoblas -> ztrsm_kernel_LR +#define ZTRSM_KERNEL_LC gotoblas -> ztrsm_kernel_LC +#define ZTRSM_KERNEL_RN gotoblas -> ztrsm_kernel_RN +#define ZTRSM_KERNEL_RT gotoblas -> ztrsm_kernel_RT +#define ZTRSM_KERNEL_RR gotoblas -> ztrsm_kernel_RR +#define ZTRSM_KERNEL_RC gotoblas -> ztrsm_kernel_RC + +#define ZSYMM_IUTCOPY gotoblas -> zsymm_iutcopy +#define ZSYMM_ILTCOPY gotoblas -> zsymm_iltcopy +#define ZSYMM_OUTCOPY gotoblas -> zsymm_outcopy +#define ZSYMM_OLTCOPY gotoblas -> zsymm_oltcopy + +#define ZHEMM_OUTCOPY gotoblas -> zhemm_outcopy +#define ZHEMM_OLTCOPY gotoblas -> zhemm_oltcopy +#define ZHEMM_IUTCOPY gotoblas -> zhemm_iutcopy +#define ZHEMM_ILTCOPY gotoblas -> zhemm_iltcopy + +#define ZGEMM3M_ONCOPYB gotoblas -> zgemm3m_oncopyb +#define ZGEMM3M_ONCOPYR gotoblas -> zgemm3m_oncopyr +#define ZGEMM3M_ONCOPYI gotoblas -> zgemm3m_oncopyi +#define ZGEMM3M_OTCOPYB gotoblas -> zgemm3m_otcopyb +#define ZGEMM3M_OTCOPYR gotoblas -> zgemm3m_otcopyr +#define ZGEMM3M_OTCOPYI gotoblas -> zgemm3m_otcopyi + +#define ZGEMM3M_INCOPYB gotoblas -> zgemm3m_incopyb +#define ZGEMM3M_INCOPYR gotoblas -> zgemm3m_incopyr +#define ZGEMM3M_INCOPYI gotoblas -> zgemm3m_incopyi +#define ZGEMM3M_ITCOPYB gotoblas -> zgemm3m_itcopyb +#define ZGEMM3M_ITCOPYR gotoblas -> zgemm3m_itcopyr +#define ZGEMM3M_ITCOPYI gotoblas -> zgemm3m_itcopyi + +#define ZSYMM3M_ILCOPYB gotoblas -> zsymm3m_ilcopyb +#define ZSYMM3M_IUCOPYB gotoblas -> zsymm3m_iucopyb +#define ZSYMM3M_ILCOPYR gotoblas -> zsymm3m_ilcopyr +#define ZSYMM3M_IUCOPYR gotoblas -> zsymm3m_iucopyr +#define ZSYMM3M_ILCOPYI gotoblas -> zsymm3m_ilcopyi +#define ZSYMM3M_IUCOPYI gotoblas -> zsymm3m_iucopyi + +#define ZSYMM3M_OLCOPYB gotoblas -> zsymm3m_olcopyb +#define ZSYMM3M_OUCOPYB gotoblas -> zsymm3m_oucopyb +#define ZSYMM3M_OLCOPYR gotoblas -> zsymm3m_olcopyr +#define ZSYMM3M_OUCOPYR gotoblas -> zsymm3m_oucopyr +#define ZSYMM3M_OLCOPYI gotoblas -> zsymm3m_olcopyi +#define ZSYMM3M_OUCOPYI gotoblas -> zsymm3m_oucopyi + +#define ZHEMM3M_ILCOPYB gotoblas -> zhemm3m_ilcopyb +#define ZHEMM3M_IUCOPYB gotoblas -> zhemm3m_iucopyb +#define ZHEMM3M_ILCOPYR gotoblas -> zhemm3m_ilcopyr +#define ZHEMM3M_IUCOPYR gotoblas -> zhemm3m_iucopyr +#define ZHEMM3M_ILCOPYI gotoblas -> zhemm3m_ilcopyi +#define ZHEMM3M_IUCOPYI gotoblas -> zhemm3m_iucopyi + +#define ZHEMM3M_OLCOPYB gotoblas -> zhemm3m_olcopyb +#define ZHEMM3M_OUCOPYB gotoblas -> zhemm3m_oucopyb +#define ZHEMM3M_OLCOPYR gotoblas -> zhemm3m_olcopyr +#define ZHEMM3M_OUCOPYR gotoblas -> zhemm3m_oucopyr +#define ZHEMM3M_OLCOPYI gotoblas -> zhemm3m_olcopyi +#define ZHEMM3M_OUCOPYI gotoblas -> zhemm3m_oucopyi + +#define ZGEMM3M_KERNEL gotoblas -> zgemm3m_kernel + +#define ZNEG_TCOPY gotoblas -> zneg_tcopy +#define ZLASWP_NCOPY gotoblas -> zlaswp_ncopy + +#endif + +#define ZGEMM_NN zgemm_nn +#define ZGEMM_CN zgemm_cn +#define ZGEMM_TN zgemm_tn +#define ZGEMM_NC zgemm_nc +#define ZGEMM_NT zgemm_nt +#define ZGEMM_CC zgemm_cc +#define ZGEMM_CT zgemm_ct +#define ZGEMM_TC zgemm_tc +#define ZGEMM_TT zgemm_tt +#define ZGEMM_NR zgemm_nr +#define ZGEMM_TR zgemm_tr +#define ZGEMM_CR zgemm_cr +#define ZGEMM_RN zgemm_rn +#define ZGEMM_RT zgemm_rt +#define ZGEMM_RC zgemm_rc +#define ZGEMM_RR zgemm_rr + +#define ZSYMM_LU zsymm_LU +#define ZSYMM_LL zsymm_LL +#define ZSYMM_RU zsymm_RU +#define ZSYMM_RL zsymm_RL + +#define ZHEMM_LU zhemm_LU +#define ZHEMM_LL zhemm_LL +#define ZHEMM_RU zhemm_RU +#define ZHEMM_RL zhemm_RL + +#define ZSYRK_UN zsyrk_UN +#define ZSYRK_UT zsyrk_UT +#define ZSYRK_LN zsyrk_LN +#define ZSYRK_LT zsyrk_LT +#define ZSYRK_UR zsyrk_UN +#define ZSYRK_UC zsyrk_UT +#define ZSYRK_LR zsyrk_LN +#define ZSYRK_LC zsyrk_LT + +#define ZSYRK_KERNEL_U zsyrk_kernel_U +#define ZSYRK_KERNEL_L zsyrk_kernel_L + +#define ZHERK_UN zherk_UN +#define ZHERK_LN zherk_LN +#define ZHERK_UC zherk_UC +#define ZHERK_LC zherk_LC + +#define ZHER2K_UN zher2k_UN +#define ZHER2K_LN zher2k_LN +#define ZHER2K_UC zher2k_UC +#define ZHER2K_LC zher2k_LC + +#define ZSYR2K_UN zsyr2k_UN +#define ZSYR2K_UT zsyr2k_UT +#define ZSYR2K_LN zsyr2k_LN +#define ZSYR2K_LT zsyr2k_LT +#define ZSYR2K_UR zsyr2k_UN +#define ZSYR2K_UC zsyr2k_UT +#define ZSYR2K_LR zsyr2k_LN +#define ZSYR2K_LC zsyr2k_LT + +#define ZSYR2K_KERNEL_U zsyr2k_kernel_U +#define ZSYR2K_KERNEL_L zsyr2k_kernel_L + +#define ZTRMM_LNUU ztrmm_LNUU +#define ZTRMM_LNUN ztrmm_LNUN +#define ZTRMM_LNLU ztrmm_LNLU +#define ZTRMM_LNLN ztrmm_LNLN +#define ZTRMM_LTUU ztrmm_LTUU +#define ZTRMM_LTUN ztrmm_LTUN +#define ZTRMM_LTLU ztrmm_LTLU +#define ZTRMM_LTLN ztrmm_LTLN +#define ZTRMM_LRUU ztrmm_LRUU +#define ZTRMM_LRUN ztrmm_LRUN +#define ZTRMM_LRLU ztrmm_LRLU +#define ZTRMM_LRLN ztrmm_LRLN +#define ZTRMM_LCUU ztrmm_LCUU +#define ZTRMM_LCUN ztrmm_LCUN +#define ZTRMM_LCLU ztrmm_LCLU +#define ZTRMM_LCLN ztrmm_LCLN +#define ZTRMM_RNUU ztrmm_RNUU +#define ZTRMM_RNUN ztrmm_RNUN +#define ZTRMM_RNLU ztrmm_RNLU +#define ZTRMM_RNLN ztrmm_RNLN +#define ZTRMM_RTUU ztrmm_RTUU +#define ZTRMM_RTUN ztrmm_RTUN +#define ZTRMM_RTLU ztrmm_RTLU +#define ZTRMM_RTLN ztrmm_RTLN +#define ZTRMM_RRUU ztrmm_RRUU +#define ZTRMM_RRUN ztrmm_RRUN +#define ZTRMM_RRLU ztrmm_RRLU +#define ZTRMM_RRLN ztrmm_RRLN +#define ZTRMM_RCUU ztrmm_RCUU +#define ZTRMM_RCUN ztrmm_RCUN +#define ZTRMM_RCLU ztrmm_RCLU +#define ZTRMM_RCLN ztrmm_RCLN + +#define ZTRSM_LNUU ztrsm_LNUU +#define ZTRSM_LNUN ztrsm_LNUN +#define ZTRSM_LNLU ztrsm_LNLU +#define ZTRSM_LNLN ztrsm_LNLN +#define ZTRSM_LTUU ztrsm_LTUU +#define ZTRSM_LTUN ztrsm_LTUN +#define ZTRSM_LTLU ztrsm_LTLU +#define ZTRSM_LTLN ztrsm_LTLN +#define ZTRSM_LRUU ztrsm_LRUU +#define ZTRSM_LRUN ztrsm_LRUN +#define ZTRSM_LRLU ztrsm_LRLU +#define ZTRSM_LRLN ztrsm_LRLN +#define ZTRSM_LCUU ztrsm_LCUU +#define ZTRSM_LCUN ztrsm_LCUN +#define ZTRSM_LCLU ztrsm_LCLU +#define ZTRSM_LCLN ztrsm_LCLN +#define ZTRSM_RNUU ztrsm_RNUU +#define ZTRSM_RNUN ztrsm_RNUN +#define ZTRSM_RNLU ztrsm_RNLU +#define ZTRSM_RNLN ztrsm_RNLN +#define ZTRSM_RTUU ztrsm_RTUU +#define ZTRSM_RTUN ztrsm_RTUN +#define ZTRSM_RTLU ztrsm_RTLU +#define ZTRSM_RTLN ztrsm_RTLN +#define ZTRSM_RRUU ztrsm_RRUU +#define ZTRSM_RRUN ztrsm_RRUN +#define ZTRSM_RRLU ztrsm_RRLU +#define ZTRSM_RRLN ztrsm_RRLN +#define ZTRSM_RCUU ztrsm_RCUU +#define ZTRSM_RCUN ztrsm_RCUN +#define ZTRSM_RCLU ztrsm_RCLU +#define ZTRSM_RCLN ztrsm_RCLN + +#define ZGEMM_THREAD_NN zgemm_thread_nn +#define ZGEMM_THREAD_CN zgemm_thread_cn +#define ZGEMM_THREAD_TN zgemm_thread_tn +#define ZGEMM_THREAD_NC zgemm_thread_nc +#define ZGEMM_THREAD_NT zgemm_thread_nt +#define ZGEMM_THREAD_CC zgemm_thread_cc +#define ZGEMM_THREAD_CT zgemm_thread_ct +#define ZGEMM_THREAD_TC zgemm_thread_tc +#define ZGEMM_THREAD_TT zgemm_thread_tt +#define ZGEMM_THREAD_NR zgemm_thread_nr +#define ZGEMM_THREAD_TR zgemm_thread_tr +#define ZGEMM_THREAD_CR zgemm_thread_cr +#define ZGEMM_THREAD_RN zgemm_thread_rn +#define ZGEMM_THREAD_RT zgemm_thread_rt +#define ZGEMM_THREAD_RC zgemm_thread_rc +#define ZGEMM_THREAD_RR zgemm_thread_rr + +#define ZSYMM_THREAD_LU zsymm_thread_LU +#define ZSYMM_THREAD_LL zsymm_thread_LL +#define ZSYMM_THREAD_RU zsymm_thread_RU +#define ZSYMM_THREAD_RL zsymm_thread_RL + +#define ZHEMM_THREAD_LU zhemm_thread_LU +#define ZHEMM_THREAD_LL zhemm_thread_LL +#define ZHEMM_THREAD_RU zhemm_thread_RU +#define ZHEMM_THREAD_RL zhemm_thread_RL + +#define ZSYRK_THREAD_UN zsyrk_thread_UN +#define ZSYRK_THREAD_UT zsyrk_thread_UT +#define ZSYRK_THREAD_LN zsyrk_thread_LN +#define ZSYRK_THREAD_LT zsyrk_thread_LT +#define ZSYRK_THREAD_UR zsyrk_thread_UN +#define ZSYRK_THREAD_UC zsyrk_thread_UT +#define ZSYRK_THREAD_LR zsyrk_thread_LN +#define ZSYRK_THREAD_LC zsyrk_thread_LT + +#define ZHERK_THREAD_UN zherk_thread_UN +#define ZHERK_THREAD_UT zherk_thread_UT +#define ZHERK_THREAD_LN zherk_thread_LN +#define ZHERK_THREAD_LT zherk_thread_LT +#define ZHERK_THREAD_UR zherk_thread_UR +#define ZHERK_THREAD_UC zherk_thread_UC +#define ZHERK_THREAD_LR zherk_thread_LR +#define ZHERK_THREAD_LC zherk_thread_LC + +#define ZGEMM3M_NN zgemm3m_nn +#define ZGEMM3M_CN zgemm3m_cn +#define ZGEMM3M_TN zgemm3m_tn +#define ZGEMM3M_NC zgemm3m_nc +#define ZGEMM3M_NT zgemm3m_nt +#define ZGEMM3M_CC zgemm3m_cc +#define ZGEMM3M_CT zgemm3m_ct +#define ZGEMM3M_TC zgemm3m_tc +#define ZGEMM3M_TT zgemm3m_tt +#define ZGEMM3M_NR zgemm3m_nr +#define ZGEMM3M_TR zgemm3m_tr +#define ZGEMM3M_CR zgemm3m_cr +#define ZGEMM3M_RN zgemm3m_rn +#define ZGEMM3M_RT zgemm3m_rt +#define ZGEMM3M_RC zgemm3m_rc +#define ZGEMM3M_RR zgemm3m_rr + +#define ZGEMM3M_THREAD_NN zgemm3m_thread_nn +#define ZGEMM3M_THREAD_CN zgemm3m_thread_cn +#define ZGEMM3M_THREAD_TN zgemm3m_thread_tn +#define ZGEMM3M_THREAD_NC zgemm3m_thread_nc +#define ZGEMM3M_THREAD_NT zgemm3m_thread_nt +#define ZGEMM3M_THREAD_CC zgemm3m_thread_cc +#define ZGEMM3M_THREAD_CT zgemm3m_thread_ct +#define ZGEMM3M_THREAD_TC zgemm3m_thread_tc +#define ZGEMM3M_THREAD_TT zgemm3m_thread_tt +#define ZGEMM3M_THREAD_NR zgemm3m_thread_nr +#define ZGEMM3M_THREAD_TR zgemm3m_thread_tr +#define ZGEMM3M_THREAD_CR zgemm3m_thread_cr +#define ZGEMM3M_THREAD_RN zgemm3m_thread_rn +#define ZGEMM3M_THREAD_RT zgemm3m_thread_rt +#define ZGEMM3M_THREAD_RC zgemm3m_thread_rc +#define ZGEMM3M_THREAD_RR zgemm3m_thread_rr + +#define ZSYMM3M_LU zsymm3m_LU +#define ZSYMM3M_LL zsymm3m_LL +#define ZSYMM3M_RU zsymm3m_RU +#define ZSYMM3M_RL zsymm3m_RL + +#define ZSYMM3M_THREAD_LU zsymm3m_thread_LU +#define ZSYMM3M_THREAD_LL zsymm3m_thread_LL +#define ZSYMM3M_THREAD_RU zsymm3m_thread_RU +#define ZSYMM3M_THREAD_RL zsymm3m_thread_RL + +#define ZHEMM3M_LU zhemm3m_LU +#define ZHEMM3M_LL zhemm3m_LL +#define ZHEMM3M_RU zhemm3m_RU +#define ZHEMM3M_RL zhemm3m_RL + +#define ZHEMM3M_THREAD_LU zhemm3m_thread_LU +#define ZHEMM3M_THREAD_LL zhemm3m_thread_LL +#define ZHEMM3M_THREAD_RU zhemm3m_thread_RU +#define ZHEMM3M_THREAD_RL zhemm3m_thread_RL + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/cpuid.h b/src/NativeWrappers/GotoBlas2/include/cpuid.h new file mode 100644 index 00000000..665ede07 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/cpuid.h @@ -0,0 +1,191 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef CPUID_H +#define CPUID_H + +#define VENDOR_INTEL 1 +#define VENDOR_UMC 2 +#define VENDOR_AMD 3 +#define VENDOR_CYRIX 4 +#define VENDOR_NEXGEN 5 +#define VENDOR_CENTAUR 6 +#define VENDOR_RISE 7 +#define VENDOR_SIS 8 +#define VENDOR_TRANSMETA 9 +#define VENDOR_NSC 10 +#define VENDOR_UNKNOWN 99 + +#define BITMASK(a, b, c) ((((a) >> (b)) & (c))) + +#define FAMILY_80486 4 +#define FAMILY_P5 5 +#define FAMILY_P6 6 +#define FAMILY_PM 7 +#define FAMILY_IA64 8 + +#if defined(__i386__) || defined(__x86_64__) +#define GET_EXFAMILY 1 +#define GET_EXMODEL 2 +#define GET_TYPE 3 +#define GET_FAMILY 4 +#define GET_MODEL 5 +#define GET_APICID 6 +#define GET_LCOUNT 7 +#define GET_CHUNKS 8 +#define GET_STEPPING 9 +#define GET_BLANDID 10 +#define GET_FEATURE 11 +#define GET_NUMSHARE 12 +#define GET_NUMCORES 13 +#endif + +#ifdef __ia64__ +#define GET_ARCHREV 1 +#define GET_FAMILY 2 +#define GET_MODEL 3 +#define GET_REVISION 4 +#define GET_NUMBER 5 +#endif + +#define CORE_UNKNOWN 0 +#define CORE_80486 1 +#define CORE_P5 2 +#define CORE_P6 3 +#define CORE_KATMAI 4 +#define CORE_COPPERMINE 5 +#define CORE_NORTHWOOD 6 +#define CORE_PRESCOTT 7 +#define CORE_BANIAS 8 +#define CORE_ATHLON 9 +#define CORE_OPTERON 10 +#define CORE_BARCELONA 11 +#define CORE_VIAC3 12 +#define CORE_YONAH 13 +#define CORE_CORE2 14 +#define CORE_PENRYN 15 +#define CORE_DUNNINGTON 16 +#define CORE_NEHALEM 17 +#define CORE_ATOM 18 +#define CORE_NANO 19 + +#define HAVE_SSE (1 << 0) +#define HAVE_SSE2 (1 << 1) +#define HAVE_SSE3 (1 << 2) +#define HAVE_SSSE3 (1 << 3) +#define HAVE_SSE4_1 (1 << 4) +#define HAVE_SSE4_2 (1 << 5) +#define HAVE_SSE4A (1 << 6) +#define HAVE_SSE5 (1 << 7) +#define HAVE_MMX (1 << 8) +#define HAVE_3DNOW (1 << 9) +#define HAVE_3DNOWEX (1 << 10) +#define HAVE_CMOV (1 << 11) +#define HAVE_PSE (1 << 12) +#define HAVE_CFLUSH (1 << 13) +#define HAVE_HIT (1 << 14) +#define HAVE_MISALIGNSSE (1 << 15) +#define HAVE_128BITFPU (1 << 16) +#define HAVE_FASTMOVU (1 << 17) + +#define CACHE_INFO_L1_I 1 +#define CACHE_INFO_L1_D 2 +#define CACHE_INFO_L2 3 +#define CACHE_INFO_L3 4 +#define CACHE_INFO_L1_ITB 5 +#define CACHE_INFO_L1_DTB 6 +#define CACHE_INFO_L1_LITB 7 +#define CACHE_INFO_L1_LDTB 8 +#define CACHE_INFO_L2_ITB 9 +#define CACHE_INFO_L2_DTB 10 +#define CACHE_INFO_L2_LITB 11 +#define CACHE_INFO_L2_LDTB 12 + +typedef struct { + int size; + int associative; + int linesize; + int shared; +} cache_info_t; + +#define CPUTYPE_UNKNOWN 0 +#define CPUTYPE_INTEL_UNKNOWN 1 +#define CPUTYPE_UMC_UNKNOWN 2 +#define CPUTYPE_AMD_UNKNOWN 3 +#define CPUTYPE_CYRIX_UNKNOWN 4 +#define CPUTYPE_NEXGEN_UNKNOWN 5 +#define CPUTYPE_CENTAUR_UNKNOWN 6 +#define CPUTYPE_RISE_UNKNOWN 7 +#define CPUTYPE_SIS_UNKNOWN 8 +#define CPUTYPE_TRANSMETA_UNKNOWN 9 +#define CPUTYPE_NSC_UNKNOWN 10 + +#define CPUTYPE_80386 11 +#define CPUTYPE_80486 12 +#define CPUTYPE_PENTIUM 13 +#define CPUTYPE_PENTIUM2 14 +#define CPUTYPE_PENTIUM3 15 +#define CPUTYPE_PENTIUMM 16 +#define CPUTYPE_PENTIUM4 17 +#define CPUTYPE_CORE2 18 +#define CPUTYPE_PENRYN 19 +#define CPUTYPE_DUNNINGTON 20 +#define CPUTYPE_NEHALEM 21 +#define CPUTYPE_ATOM 22 +#define CPUTYPE_ITANIUM 23 +#define CPUTYPE_ITANIUM2 24 +#define CPUTYPE_AMD5X86 25 +#define CPUTYPE_AMDK6 26 +#define CPUTYPE_ATHLON 27 +#define CPUTYPE_DURON 28 +#define CPUTYPE_OPTERON 29 +#define CPUTYPE_BARCELONA 30 +#define CPUTYPE_SHANGHAI 31 +#define CPUTYPE_ISTANBUL 32 +#define CPUTYPE_CYRIX5X86 33 +#define CPUTYPE_CYRIXM1 34 +#define CPUTYPE_CYRIXM2 35 +#define CPUTYPE_NEXGENNX586 36 +#define CPUTYPE_CENTAURC6 37 +#define CPUTYPE_RISEMP6 38 +#define CPUTYPE_SYS55X 39 +#define CPUTYPE_CRUSOETM3X 40 +#define CPUTYPE_NSGEODE 41 +#define CPUTYPE_VIAC3 42 +#define CPUTYPE_NANO 43 +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/l1param.h b/src/NativeWrappers/GotoBlas2/include/l1param.h new file mode 100644 index 00000000..f1d223ea --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/l1param.h @@ -0,0 +1,84 @@ +#if defined(CORE2) || defined(PENRYN) +#define ALIGNED_ACCESS +#endif + +#ifdef NEHALEM +#define PREFETCH prefetcht0 +#define PREFETCHW prefetcht0 +#define PREFETCHSIZE (128 * 12) +#define ALIGNED_ACCESS +#endif + +#ifdef ATHLON +#define PREFETCH prefetch +#define PREFETCHW prefetchw +#define PREFETCHSIZE (128 * 10) +#define ALIGNED_ACCESS +#define movsd movlps +#endif + +#ifdef PENTIUM3 +#define PREFETCH prefetcht0 +#define PREFETCHSIZE (128 * 10) +#define ALIGNED_ACCESS +#define movsd movlps +#endif + +#ifdef PENTIUM4 +#define PREFETCH prefetcht0 +#define PREFETCHSIZE (128 * 10) +#define FETCH128 +#define ALIGNED_ACCESS +#define xorps pxor +#define xorpd pxor +#endif + +#ifdef ATOM +#define ALIGNED_ACCESS +#define PREFETCH prefetcht0 +#define PREFETCHSIZE ( 64 * 12 + 32) +#endif + +#ifdef OPTERON +#define PREFETCH prefetch +#define PREFETCHW prefetchw +#define PREFETCHSIZE (128 * 3) +#define movsd movlps +#endif + +#ifdef BARCELONA +#define PREFETCH prefetch +#define PREFETCHW prefetchw +#define PREFETCHSIZE (128 * 5) +#define ALIGNED_ACCESS +#endif + +#ifdef SHANGHAI +#define PREFETCH prefetch +#define PREFETCHW prefetchw +#define PREFETCHSIZE (128 * 5) +#define ALIGNED_ACCESS +#endif + +#ifdef NANO +#define PREFETCH prefetcht0 +#define PREFETCHW prefetcht0 +#define PREFETCHSIZE (128 * 4) +#define ALIGNED_ACCESS +#endif + +#define PREOFFSET 128 + + +#ifdef HAVE_SSE2 +#define PSHUFD1(A, B) pshufd A, B, B +#define PSHUFD2(A, B, C) pshufd A, B, C +#else +#define PSHUFD1(A, B) shufps A, B, B +#define PSHUFD2(A, B, C) movaps B, C; shufps A, C, C +#endif + +#define MOVDDUP1(OFFSET, BASE, REGS) movddup OFFSET(BASE), REGS + +#define MOVAPS(OFFSET, BASE, REGS) movlps REGS, OFFSET(BASE); movhps REGS, OFFSET + SIZE(BASE) + diff --git a/src/NativeWrappers/GotoBlas2/include/l2param.h b/src/NativeWrappers/GotoBlas2/include/l2param.h new file mode 100644 index 00000000..af9d1717 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/l2param.h @@ -0,0 +1,165 @@ +#ifndef GEMV_PARAM_H +#define GEMV_PARAM_H + +#ifdef movsd +#undef movsd +#endif + +#undef movapd +#define movapd movaps + +#ifdef ATHLON +#define ALIGNED_ACCESS +#define MOVUPS_A movaps +#define MOVUPS_XL movaps +#define MOVUPS_XS movaps +#define MOVUPS_YL movaps +#define MOVUPS_YS movaps +#define PREFETCH prefetcht0 +#define PREFETCHSIZE 64 * 3 +#endif + +#ifdef PENTIUM4 +#define ALIGNED_ACCESS +#define MOVUPS_A movaps +#define MOVUPS_XL movaps +#define MOVUPS_XS movaps +#define MOVUPS_YL movaps +#define MOVUPS_YS movaps +#define PREFETCH prefetcht0 +#define PREFETCHSIZE 64 * 2 +#endif + +#ifdef CORE2 +#define ALIGNED_ACCESS +#define MOVUPS_A movaps +#define MOVUPS_XL movaps +#define MOVUPS_XS movaps +#define MOVUPS_YL movaps +#define MOVUPS_YS movaps +#define PREFETCH prefetcht0 +#define PREFETCHSIZE 64 * 4 +#endif + +#ifdef PENRYN +#define ALIGNED_ACCESS +#define MOVUPS_A movaps +#define MOVUPS_XL movaps +#define MOVUPS_XS movaps +#define MOVUPS_YL movaps +#define MOVUPS_YS movaps +#define PREFETCH prefetcht0 +#define PREFETCHSIZE 64 * 4 +#endif + +#ifdef NEHALEM +#define MOVUPS_A movups +#define MOVUPS_XL movups +#define MOVUPS_XS movups +#define MOVUPS_YL movups +#define MOVUPS_YS movups +#define PREFETCH prefetcht0 +#define PREFETCHW prefetcht0 +#define PREFETCHSIZE 64 * 3 +#endif + +#ifdef OPTERON +#define PREFETCH prefetch +#define PREFETCHW prefetchw +#ifndef COMPLEX +#define PREFETCHSIZE 64 * 1 +#else +#define PREFETCHSIZE 64 * 1 +#endif +#define movsd movlps +#endif + +#if defined(BARCELONA) || defined(SHANGHAI) +#define ALIGNED_ACCESS +#define MOVUPS_A movaps +#define MOVUPS_XL movaps +#define MOVUPS_XS movaps +#define MOVUPS_YL movaps +#define MOVUPS_YS movaps + +#define PREFETCH prefetch +#define PREFETCHW prefetchw +#ifndef COMPLEX +#define PREFETCHSIZE 64 * 2 +#else +#define PREFETCHSIZE 64 * 4 +#endif +#endif + +#ifdef NANO +#define ALIGNED_ACCESS +#define MOVUPS_A movaps +#define MOVUPS_XL movaps +#define MOVUPS_XS movaps +#define MOVUPS_YL movaps +#define MOVUPS_YS movaps +#define PREFETCH prefetcht0 +#ifndef COMPLEX +#define PREFETCHSIZE 64 * 1 +#else +#define PREFETCHSIZE 64 * 2 +#endif +#endif + +#ifndef PREOFFSET +#ifdef L1_DATA_LINESIZE +#define PREOFFSET (L1_DATA_LINESIZE >> 1) +#else +#define PREOFFSET 32 +#endif +#endif + +#ifndef GEMV_UNROLL +#define GEMV_UNROLL 4 +#endif + +#ifndef ZGEMV_UNROLL +#define ZGEMV_UNROLL 4 +#endif + +/* #define COPY_FORCE */ /* Always copy X or Y to the buffer */ +/* #define NOCOPY_UNALIGNED */ /* Not copy if X or Y is not aligned */ + +#ifdef MOVUPS_A +#define MOVUPS_A1(OFF, ADDR, REGS) MOVUPS_A OFF(ADDR), REGS +#define MOVUPS_A2(OFF, ADDR, BASE, SCALE, REGS) MOVUPS_A OFF(ADDR, BASE, SCALE), REGS +#else +#define MOVUPS_A1(OFF, ADDR, REGS) movsd OFF(ADDR), REGS; movhps OFF + 8(ADDR), REGS +#define MOVUPS_A2(OFF, ADDR, BASE, SCALE, REGS) movsd OFF(ADDR, BASE, SCALE), REGS; movhps OFF + 8(ADDR, BASE, SCALE), REGS +#endif + +#define MOVRPS_A1(OFF, ADDR, REGS) movsd OFF + 8(ADDR), REGS; movhps OFF(ADDR), REGS +#define MOVRPS_A2(OFF, ADDR, BASE, SCALE, REGS) movsd OFF + 8(ADDR, BASE, SCALE), REGS; movhps OFF(ADDR, BASE, SCALE), REGS + +#ifdef MOVUPS_XL +#define MOVUPS_XL1(OFF, ADDR, REGS) MOVUPS_XL OFF(ADDR), REGS +#else +#define MOVUPS_XL1(OFF, ADDR, REGS) movsd OFF(ADDR), REGS; movhps OFF + 8(ADDR), REGS +#endif + +#ifdef MOVUPS_XS +#define MOVUPS_XS1(OFF, ADDR, REGS) MOVUPS_XS REGS, OFF(ADDR) +#else +#define MOVUPS_XS1(OFF, ADDR, REGS) movsd REGS, OFF(ADDR); movhps REGS, OFF + 8(ADDR) +#endif + +#ifdef MOVUPS_YL +#define MOVUPS_YL1(OFF, ADDR, REGS) MOVUPS_YL OFF(ADDR), REGS +#else +#define MOVUPS_YL1(OFF, ADDR, REGS) movsd OFF(ADDR), REGS; movhps OFF + 8(ADDR), REGS +#endif + +#ifdef MOVUPS_YS +#define MOVUPS_YS1(OFF, ADDR, REGS) MOVUPS_YS REGS, OFF(ADDR) +#else +#define MOVUPS_YS1(OFF, ADDR, REGS) movsd REGS, OFF(ADDR); movhps REGS, OFF + 8(ADDR) +#endif + + + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/param.h b/src/NativeWrappers/GotoBlas2/include/param.h new file mode 100644 index 00000000..d8dbcfad --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/param.h @@ -0,0 +1,1543 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef PARAM_H +#define PARAM_H + +#ifdef OPTERON + +#define SNUMOPT 4 +#define DNUMOPT 2 + +#define GEMM_DEFAULT_OFFSET_A 64 +#define GEMM_DEFAULT_OFFSET_B 256 +#define GEMM_DEFAULT_ALIGN 0x01ffffUL + +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 +#define XGEMM_DEFAULT_UNROLL_N 1 + +#ifdef ARCH_X86 +#define SGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_M 2 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define XGEMM_DEFAULT_UNROLL_M 1 +#else +#define SGEMM_DEFAULT_UNROLL_M 8 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 4 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define XGEMM_DEFAULT_UNROLL_M 1 +#endif + +#define SGEMM_DEFAULT_P sgemm_p +#define DGEMM_DEFAULT_P dgemm_p +#define QGEMM_DEFAULT_P qgemm_p +#define CGEMM_DEFAULT_P cgemm_p +#define ZGEMM_DEFAULT_P zgemm_p +#define XGEMM_DEFAULT_P xgemm_p + +#define SGEMM_DEFAULT_R sgemm_r +#define DGEMM_DEFAULT_R dgemm_r +#define QGEMM_DEFAULT_R qgemm_r +#define CGEMM_DEFAULT_R cgemm_r +#define ZGEMM_DEFAULT_R zgemm_r +#define XGEMM_DEFAULT_R xgemm_r + +#ifdef ALLOC_HUGETLB + +#define SGEMM_DEFAULT_Q 248 +#define DGEMM_DEFAULT_Q 248 +#define QGEMM_DEFAULT_Q 248 +#define CGEMM_DEFAULT_Q 248 +#define ZGEMM_DEFAULT_Q 248 +#define XGEMM_DEFAULT_Q 248 + +#else + +#define SGEMM_DEFAULT_Q 240 +#define DGEMM_DEFAULT_Q 240 +#define QGEMM_DEFAULT_Q 240 +#define CGEMM_DEFAULT_Q 240 +#define ZGEMM_DEFAULT_Q 240 +#define XGEMM_DEFAULT_Q 240 + +#endif + + +#define SYMV_P 16 +#define HAVE_EXCLUSIVE_CACHE + +#endif + +#if defined(BARCELONA) || defined(SHANGHAI) + +#define SNUMOPT 8 +#define DNUMOPT 4 + +#define GEMM_DEFAULT_OFFSET_A 64 +#define GEMM_DEFAULT_OFFSET_B 832 +#define GEMM_DEFAULT_ALIGN 0x0fffUL + +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 +#define XGEMM_DEFAULT_UNROLL_N 1 + +#ifdef ARCH_X86 +#define SGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_M 2 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define XGEMM_DEFAULT_UNROLL_M 1 +#else +#define SGEMM_DEFAULT_UNROLL_M 8 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 4 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define XGEMM_DEFAULT_UNROLL_M 1 +#endif + +#if 0 +#define SGEMM_DEFAULT_P 496 +#define DGEMM_DEFAULT_P 248 +#define QGEMM_DEFAULT_P 124 +#define CGEMM_DEFAULT_P 248 +#define ZGEMM_DEFAULT_P 124 +#define XGEMM_DEFAULT_P 62 + +#define SGEMM_DEFAULT_Q 248 +#define DGEMM_DEFAULT_Q 248 +#define QGEMM_DEFAULT_Q 248 +#define CGEMM_DEFAULT_Q 248 +#define ZGEMM_DEFAULT_Q 248 +#define XGEMM_DEFAULT_Q 248 + +#else + +#define SGEMM_DEFAULT_P 448 +#define DGEMM_DEFAULT_P 224 +#define QGEMM_DEFAULT_P 112 +#define CGEMM_DEFAULT_P 224 +#define ZGEMM_DEFAULT_P 112 +#define XGEMM_DEFAULT_P 56 + +#define SGEMM_DEFAULT_Q 224 +#define DGEMM_DEFAULT_Q 224 +#define QGEMM_DEFAULT_Q 224 +#define CGEMM_DEFAULT_Q 224 +#define ZGEMM_DEFAULT_Q 224 +#define XGEMM_DEFAULT_Q 224 + +#endif + +#define SGEMM_DEFAULT_R sgemm_r +#define QGEMM_DEFAULT_R qgemm_r +#define DGEMM_DEFAULT_R dgemm_r +#define CGEMM_DEFAULT_R cgemm_r +#define ZGEMM_DEFAULT_R zgemm_r +#define XGEMM_DEFAULT_R xgemm_r + +#define SYMV_P 16 +#define HAVE_EXCLUSIVE_CACHE + +#define GEMM_THREAD gemm_thread_mn + +#endif + +#ifdef ATHLON + +#define SNUMOPT 4 +#define DNUMOPT 2 + +#define GEMM_DEFAULT_OFFSET_A 0 +#define GEMM_DEFAULT_OFFSET_B 384 +#define GEMM_DEFAULT_ALIGN 0x0ffffUL + +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 +#define XGEMM_DEFAULT_UNROLL_N 1 + +#define SGEMM_DEFAULT_UNROLL_M 2 +#define DGEMM_DEFAULT_UNROLL_M 1 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 1 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define XGEMM_DEFAULT_UNROLL_M 1 + +#define SGEMM_DEFAULT_R sgemm_r +#define DGEMM_DEFAULT_R dgemm_r +#define QGEMM_DEFAULT_R qgemm_r +#define CGEMM_DEFAULT_R cgemm_r +#define ZGEMM_DEFAULT_R zgemm_r +#define XGEMM_DEFAULT_R xgemm_r + +#define SGEMM_DEFAULT_P 208 +#define DGEMM_DEFAULT_P 104 +#define QGEMM_DEFAULT_P 56 +#define CGEMM_DEFAULT_P 104 +#define ZGEMM_DEFAULT_P 56 +#define XGEMM_DEFAULT_P 28 + +#define SGEMM_DEFAULT_Q 208 +#define DGEMM_DEFAULT_Q 208 +#define QGEMM_DEFAULT_Q 208 +#define CGEMM_DEFAULT_Q 208 +#define ZGEMM_DEFAULT_Q 208 +#define XGEMM_DEFAULT_Q 208 + +#define SYMV_P 16 +#define HAVE_EXCLUSIVE_CACHE +#endif + +#ifdef VIAC3 + +#define SNUMOPT 2 +#define DNUMOPT 1 + +#define GEMM_DEFAULT_OFFSET_A 0 +#define GEMM_DEFAULT_OFFSET_B 256 +#define GEMM_DEFAULT_ALIGN 0x0ffffUL + +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 +#define XGEMM_DEFAULT_UNROLL_N 1 + +#define SGEMM_DEFAULT_UNROLL_M 2 +#define DGEMM_DEFAULT_UNROLL_M 1 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 1 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define XGEMM_DEFAULT_UNROLL_M 1 + +#define SGEMM_DEFAULT_R sgemm_r +#define DGEMM_DEFAULT_R dgemm_r +#define QGEMM_DEFAULT_R qgemm_r +#define CGEMM_DEFAULT_R cgemm_r +#define ZGEMM_DEFAULT_R zgemm_r +#define XGEMM_DEFAULT_R xgemm_r + +#define SGEMM_DEFAULT_P 128 +#define DGEMM_DEFAULT_P 128 +#define QGEMM_DEFAULT_P 128 +#define CGEMM_DEFAULT_P 128 +#define ZGEMM_DEFAULT_P 128 +#define XGEMM_DEFAULT_P 128 + +#define SGEMM_DEFAULT_Q 512 +#define DGEMM_DEFAULT_Q 256 +#define QGEMM_DEFAULT_Q 256 +#define CGEMM_DEFAULT_Q 256 +#define ZGEMM_DEFAULT_Q 128 +#define XGEMM_DEFAULT_Q 128 + +#define SYMV_P 16 +#endif + +#ifdef NANO + +#define SNUMOPT 4 +#define DNUMOPT 2 + +#define GEMM_DEFAULT_OFFSET_A 64 +#define GEMM_DEFAULT_OFFSET_B 256 +#define GEMM_DEFAULT_ALIGN 0x01ffffUL + +#ifdef ARCH_X86 +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 +#define XGEMM_DEFAULT_UNROLL_N 1 + +#define SGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_M 2 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define XGEMM_DEFAULT_UNROLL_M 1 +#else +#define SGEMM_DEFAULT_UNROLL_N 8 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 4 +#define ZGEMM_DEFAULT_UNROLL_N 2 +#define XGEMM_DEFAULT_UNROLL_N 1 + +#define SGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define XGEMM_DEFAULT_UNROLL_M 1 +#endif + +#define SGEMM_DEFAULT_P 288 +#define DGEMM_DEFAULT_P 288 +#define QGEMM_DEFAULT_P 288 +#define CGEMM_DEFAULT_P 288 +#define ZGEMM_DEFAULT_P 288 +#define XGEMM_DEFAULT_P 288 + +#define SGEMM_DEFAULT_R sgemm_r +#define DGEMM_DEFAULT_R dgemm_r +#define QGEMM_DEFAULT_R qgemm_r +#define CGEMM_DEFAULT_R cgemm_r +#define ZGEMM_DEFAULT_R zgemm_r +#define XGEMM_DEFAULT_R xgemm_r + +#define SGEMM_DEFAULT_Q 256 +#define DGEMM_DEFAULT_Q 128 +#define QGEMM_DEFAULT_Q 64 +#define CGEMM_DEFAULT_Q 128 +#define ZGEMM_DEFAULT_Q 64 +#define XGEMM_DEFAULT_Q 32 + +#define SYMV_P 16 +#define HAVE_EXCLUSIVE_CACHE + +#endif + +#if defined(PENTIUM) || defined(PENTIUM2) || defined(PENTIUM3) + +#ifdef HAVE_SSE +#define SNUMOPT 2 +#else +#define SNUMOPT 1 +#endif +#define DNUMOPT 1 + +#define GEMM_DEFAULT_OFFSET_A 0 +#define GEMM_DEFAULT_OFFSET_B 0 +#define GEMM_DEFAULT_ALIGN 0x0ffffUL + +#ifdef HAVE_SSE +#define SGEMM_DEFAULT_UNROLL_M 8 +#define CGEMM_DEFAULT_UNROLL_M 4 +#else +#define SGEMM_DEFAULT_UNROLL_M 4 +#define CGEMM_DEFAULT_UNROLL_M 2 +#endif +#define DGEMM_DEFAULT_UNROLL_M 2 +#define SGEMM_DEFAULT_UNROLL_N 2 +#define DGEMM_DEFAULT_UNROLL_N 2 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 1 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define ZGEMM_DEFAULT_UNROLL_N 1 +#define XGEMM_DEFAULT_UNROLL_M 1 +#define XGEMM_DEFAULT_UNROLL_N 1 + +#define SGEMM_DEFAULT_P sgemm_p +#define SGEMM_DEFAULT_Q 256 +#define SGEMM_DEFAULT_R sgemm_r + +#define DGEMM_DEFAULT_P dgemm_p +#define DGEMM_DEFAULT_Q 256 +#define DGEMM_DEFAULT_R dgemm_r + +#define QGEMM_DEFAULT_P qgemm_p +#define QGEMM_DEFAULT_Q 256 +#define QGEMM_DEFAULT_R qgemm_r + +#define CGEMM_DEFAULT_P cgemm_p +#define CGEMM_DEFAULT_Q 256 +#define CGEMM_DEFAULT_R cgemm_r + +#define ZGEMM_DEFAULT_P zgemm_p +#define ZGEMM_DEFAULT_Q 256 +#define ZGEMM_DEFAULT_R zgemm_r + +#define XGEMM_DEFAULT_P xgemm_p +#define XGEMM_DEFAULT_Q 256 +#define XGEMM_DEFAULT_R xgemm_r + +#define SYMV_P 4 + +#endif + +#ifdef PENTIUMM + +#define SNUMOPT 2 +#define DNUMOPT 1 + +#define GEMM_DEFAULT_OFFSET_A 0 +#define GEMM_DEFAULT_OFFSET_B 0 +#define GEMM_DEFAULT_ALIGN 0x0ffffUL + +#ifdef CORE_YONAH +#define SGEMM_DEFAULT_UNROLL_M 4 +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_M 2 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define ZGEMM_DEFAULT_UNROLL_N 2 +#define XGEMM_DEFAULT_UNROLL_M 1 +#define XGEMM_DEFAULT_UNROLL_N 1 +#else +#define SGEMM_DEFAULT_UNROLL_M 8 +#define SGEMM_DEFAULT_UNROLL_N 2 +#define DGEMM_DEFAULT_UNROLL_M 2 +#define DGEMM_DEFAULT_UNROLL_N 2 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_M 4 +#define CGEMM_DEFAULT_UNROLL_N 1 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define ZGEMM_DEFAULT_UNROLL_N 1 +#define XGEMM_DEFAULT_UNROLL_M 1 +#define XGEMM_DEFAULT_UNROLL_N 1 + +#endif + +#define SGEMM_DEFAULT_P sgemm_p +#define SGEMM_DEFAULT_Q 256 +#define SGEMM_DEFAULT_R sgemm_r + +#define DGEMM_DEFAULT_P dgemm_p +#define DGEMM_DEFAULT_Q 256 +#define DGEMM_DEFAULT_R dgemm_r + +#define QGEMM_DEFAULT_P qgemm_p +#define QGEMM_DEFAULT_Q 256 +#define QGEMM_DEFAULT_R qgemm_r + +#define CGEMM_DEFAULT_P cgemm_p +#define CGEMM_DEFAULT_Q 256 +#define CGEMM_DEFAULT_R cgemm_r + +#define ZGEMM_DEFAULT_P zgemm_p +#define ZGEMM_DEFAULT_Q 256 +#define ZGEMM_DEFAULT_R zgemm_r + +#define XGEMM_DEFAULT_P xgemm_p +#define XGEMM_DEFAULT_Q 256 +#define XGEMM_DEFAULT_R xgemm_r + +#define SYMV_P 4 +#endif + +#ifdef CORE_NORTHWOOD + +#define SNUMOPT 4 +#define DNUMOPT 2 + +#define GEMM_DEFAULT_OFFSET_A 0 +#define GEMM_DEFAULT_OFFSET_B 32 + +#define GEMM_DEFAULT_ALIGN 0x0ffffUL + +#define SYMV_P 8 + +#define SGEMM_DEFAULT_UNROLL_M 8 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 4 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define XGEMM_DEFAULT_UNROLL_M 1 + +#define SGEMM_DEFAULT_UNROLL_N 2 +#define DGEMM_DEFAULT_UNROLL_N 2 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 1 +#define ZGEMM_DEFAULT_UNROLL_N 1 +#define XGEMM_DEFAULT_UNROLL_N 1 + +#define SGEMM_DEFAULT_P sgemm_p +#define SGEMM_DEFAULT_R sgemm_r + +#define DGEMM_DEFAULT_P dgemm_p +#define DGEMM_DEFAULT_R dgemm_r + +#define QGEMM_DEFAULT_P qgemm_p +#define QGEMM_DEFAULT_R qgemm_r + +#define CGEMM_DEFAULT_P cgemm_p +#define CGEMM_DEFAULT_R cgemm_r + +#define ZGEMM_DEFAULT_P zgemm_p +#define ZGEMM_DEFAULT_R zgemm_r + +#define XGEMM_DEFAULT_P xgemm_p +#define XGEMM_DEFAULT_R xgemm_r + +#define SGEMM_DEFAULT_Q 128 +#define DGEMM_DEFAULT_Q 128 +#define QGEMM_DEFAULT_Q 128 +#define CGEMM_DEFAULT_Q 128 +#define ZGEMM_DEFAULT_Q 128 +#define XGEMM_DEFAULT_Q 128 +#endif + +#ifdef CORE_PRESCOTT + +#define SNUMOPT 4 +#define DNUMOPT 2 + +#ifndef __64BIT__ +#define GEMM_DEFAULT_OFFSET_A 128 +#define GEMM_DEFAULT_OFFSET_B 192 +#else +#define GEMM_DEFAULT_OFFSET_A 0 +#define GEMM_DEFAULT_OFFSET_B 256 +#endif + +#define GEMM_DEFAULT_ALIGN 0x0ffffUL + +#define SYMV_P 8 + +#ifdef ARCH_X86 +#define SGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_M 2 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define XGEMM_DEFAULT_UNROLL_M 1 +#else +#define SGEMM_DEFAULT_UNROLL_M 8 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 4 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define XGEMM_DEFAULT_UNROLL_M 1 +#endif + +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 +#define XGEMM_DEFAULT_UNROLL_N 1 + +#define SGEMM_DEFAULT_P sgemm_p +#define SGEMM_DEFAULT_R sgemm_r + +#define DGEMM_DEFAULT_P dgemm_p +#define DGEMM_DEFAULT_R dgemm_r + +#define QGEMM_DEFAULT_P qgemm_p +#define QGEMM_DEFAULT_R qgemm_r + +#define CGEMM_DEFAULT_P cgemm_p +#define CGEMM_DEFAULT_R cgemm_r + +#define ZGEMM_DEFAULT_P zgemm_p +#define ZGEMM_DEFAULT_R zgemm_r + +#define XGEMM_DEFAULT_P xgemm_p +#define XGEMM_DEFAULT_R xgemm_r + +#define SGEMM_DEFAULT_Q 128 +#define DGEMM_DEFAULT_Q 128 +#define QGEMM_DEFAULT_Q 128 +#define CGEMM_DEFAULT_Q 128 +#define ZGEMM_DEFAULT_Q 128 +#define XGEMM_DEFAULT_Q 128 +#endif + +#ifdef CORE2 + +#define SNUMOPT 8 +#define DNUMOPT 4 + +#define GEMM_DEFAULT_OFFSET_A 448 +#define GEMM_DEFAULT_OFFSET_B 128 +#define GEMM_DEFAULT_ALIGN 0x03fffUL + +#define SYMV_P 8 + +#define SWITCH_RATIO 4 + +#ifdef ARCH_X86 +#define SGEMM_DEFAULT_UNROLL_M 8 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 4 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define XGEMM_DEFAULT_UNROLL_M 1 + +#define SGEMM_DEFAULT_UNROLL_N 2 +#define DGEMM_DEFAULT_UNROLL_N 2 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 1 +#define ZGEMM_DEFAULT_UNROLL_N 1 +#define XGEMM_DEFAULT_UNROLL_N 1 + +#define MASK(a, b) ((((a) + (b) - 1) / (b)) * (b)) + +#else +#define SGEMM_DEFAULT_UNROLL_M 8 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 4 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define XGEMM_DEFAULT_UNROLL_M 1 + +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 +#define XGEMM_DEFAULT_UNROLL_N 1 +#endif + +#define SGEMM_DEFAULT_P sgemm_p +#define SGEMM_DEFAULT_R sgemm_r + +#define DGEMM_DEFAULT_P dgemm_p +#define DGEMM_DEFAULT_R dgemm_r + +#define QGEMM_DEFAULT_P qgemm_p +#define QGEMM_DEFAULT_R qgemm_r + +#define CGEMM_DEFAULT_P cgemm_p +#define CGEMM_DEFAULT_R cgemm_r + +#define ZGEMM_DEFAULT_P zgemm_p +#define ZGEMM_DEFAULT_R zgemm_r + +#define XGEMM_DEFAULT_P xgemm_p +#define XGEMM_DEFAULT_R xgemm_r + +#define SGEMM_DEFAULT_Q 256 +#define DGEMM_DEFAULT_Q 256 +#define QGEMM_DEFAULT_Q 256 +#define CGEMM_DEFAULT_Q 256 +#define ZGEMM_DEFAULT_Q 256 +#define XGEMM_DEFAULT_Q 256 + +#endif + +#ifdef PENRYN + +#define SNUMOPT 8 +#define DNUMOPT 4 + +#define GEMM_DEFAULT_OFFSET_A 128 +#define GEMM_DEFAULT_OFFSET_B 0 +#define GEMM_DEFAULT_ALIGN 0x03fffUL + +#define SYMV_P 8 + +#define SWITCH_RATIO 4 + +#ifdef ARCH_X86 +#define SGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_M 2 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define XGEMM_DEFAULT_UNROLL_M 1 + +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 +#define XGEMM_DEFAULT_UNROLL_N 1 +#else +#define SGEMM_DEFAULT_UNROLL_M 8 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 4 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define XGEMM_DEFAULT_UNROLL_M 1 + +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 +#define XGEMM_DEFAULT_UNROLL_N 1 +#endif + +#define SGEMM_DEFAULT_P sgemm_p +#define SGEMM_DEFAULT_R sgemm_r + +#define DGEMM_DEFAULT_P dgemm_p +#define DGEMM_DEFAULT_R dgemm_r + +#define QGEMM_DEFAULT_P qgemm_p +#define QGEMM_DEFAULT_R qgemm_r + +#define CGEMM_DEFAULT_P cgemm_p +#define CGEMM_DEFAULT_R cgemm_r + +#define ZGEMM_DEFAULT_P zgemm_p +#define ZGEMM_DEFAULT_R zgemm_r + +#define XGEMM_DEFAULT_P xgemm_p +#define XGEMM_DEFAULT_R xgemm_r + +#define SGEMM_DEFAULT_Q 512 +#define DGEMM_DEFAULT_Q 256 +#define QGEMM_DEFAULT_Q 128 +#define CGEMM_DEFAULT_Q 512 +#define ZGEMM_DEFAULT_Q 256 +#define XGEMM_DEFAULT_Q 128 + +#define GETRF_FACTOR 0.75 +#endif + +#ifdef DUNNINGTON + +#define SNUMOPT 8 +#define DNUMOPT 4 + +#define GEMM_DEFAULT_OFFSET_A 128 +#define GEMM_DEFAULT_OFFSET_B 0 +#define GEMM_DEFAULT_ALIGN 0x03fffUL + +#define SYMV_P 8 + +#define SWITCH_RATIO 4 + +#ifdef ARCH_X86 +#define SGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_M 2 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define XGEMM_DEFAULT_UNROLL_M 1 + +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 +#define XGEMM_DEFAULT_UNROLL_N 1 +#else +#define SGEMM_DEFAULT_UNROLL_M 8 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 4 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define XGEMM_DEFAULT_UNROLL_M 1 + +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 +#define XGEMM_DEFAULT_UNROLL_N 1 +#endif + +#define SGEMM_DEFAULT_P sgemm_p +#define SGEMM_DEFAULT_R sgemm_r + +#define DGEMM_DEFAULT_P dgemm_p +#define DGEMM_DEFAULT_R dgemm_r + +#define QGEMM_DEFAULT_P qgemm_p +#define QGEMM_DEFAULT_R qgemm_r + +#define CGEMM_DEFAULT_P cgemm_p +#define CGEMM_DEFAULT_R cgemm_r + +#define ZGEMM_DEFAULT_P zgemm_p +#define ZGEMM_DEFAULT_R zgemm_r + +#define XGEMM_DEFAULT_P xgemm_p +#define XGEMM_DEFAULT_R xgemm_r + +#define SGEMM_DEFAULT_Q 768 +#define DGEMM_DEFAULT_Q 384 +#define QGEMM_DEFAULT_Q 192 +#define CGEMM_DEFAULT_Q 768 +#define ZGEMM_DEFAULT_Q 384 +#define XGEMM_DEFAULT_Q 192 + +#define GETRF_FACTOR 0.75 +#define GEMM_THREAD gemm_thread_mn +#endif + +#ifdef NEHALEM + +#define SNUMOPT 8 +#define DNUMOPT 4 + +#define GEMM_DEFAULT_OFFSET_A 32 +#define GEMM_DEFAULT_OFFSET_B 0 +#define GEMM_DEFAULT_ALIGN 0x03fffUL + +#define SYMV_P 8 + +#define SWITCH_RATIO 4 + +#ifdef ARCH_X86 +#define SGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_M 2 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define XGEMM_DEFAULT_UNROLL_M 1 + +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 +#define XGEMM_DEFAULT_UNROLL_N 1 +#else +#define SGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_M 2 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define XGEMM_DEFAULT_UNROLL_M 1 + +#define SGEMM_DEFAULT_UNROLL_N 8 +#define DGEMM_DEFAULT_UNROLL_N 8 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 4 +#define ZGEMM_DEFAULT_UNROLL_N 4 +#define XGEMM_DEFAULT_UNROLL_N 1 +#endif + +#define SGEMM_DEFAULT_P 504 +#define SGEMM_DEFAULT_R sgemm_r + +#define DGEMM_DEFAULT_P 504 +#define DGEMM_DEFAULT_R dgemm_r + +#define QGEMM_DEFAULT_P 504 +#define QGEMM_DEFAULT_R qgemm_r + +#define CGEMM_DEFAULT_P 252 +#define CGEMM_DEFAULT_R cgemm_r + +#define ZGEMM_DEFAULT_P 252 +#define ZGEMM_DEFAULT_R zgemm_r + +#define XGEMM_DEFAULT_P 252 +#define XGEMM_DEFAULT_R xgemm_r + +#define SGEMM_DEFAULT_Q 512 +#define DGEMM_DEFAULT_Q 256 +#define QGEMM_DEFAULT_Q 128 +#define CGEMM_DEFAULT_Q 512 +#define ZGEMM_DEFAULT_Q 256 +#define XGEMM_DEFAULT_Q 128 + +#define GETRF_FACTOR 0.72 + +#endif + + +#ifdef ATOM + +#define SNUMOPT 2 +#define DNUMOPT 1 + +#define GEMM_DEFAULT_OFFSET_A 64 +#define GEMM_DEFAULT_OFFSET_B 0 +#define GEMM_DEFAULT_ALIGN 0x0ffffUL + +#define SYMV_P 8 + +#ifdef ARCH_X86 +#define SGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_M 2 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define XGEMM_DEFAULT_UNROLL_M 1 +#else +#define SGEMM_DEFAULT_UNROLL_M 8 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 4 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define XGEMM_DEFAULT_UNROLL_M 1 +#endif + +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_N 2 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_N 1 +#define XGEMM_DEFAULT_UNROLL_N 1 + +#define SGEMM_DEFAULT_P sgemm_p +#define SGEMM_DEFAULT_R sgemm_r + +#define DGEMM_DEFAULT_P dgemm_p +#define DGEMM_DEFAULT_R dgemm_r + +#define QGEMM_DEFAULT_P qgemm_p +#define QGEMM_DEFAULT_R qgemm_r + +#define CGEMM_DEFAULT_P cgemm_p +#define CGEMM_DEFAULT_R cgemm_r + +#define ZGEMM_DEFAULT_P zgemm_p +#define ZGEMM_DEFAULT_R zgemm_r + +#define XGEMM_DEFAULT_P xgemm_p +#define XGEMM_DEFAULT_R xgemm_r + +#define SGEMM_DEFAULT_Q 256 +#define DGEMM_DEFAULT_Q 256 +#define QGEMM_DEFAULT_Q 256 +#define CGEMM_DEFAULT_Q 256 +#define ZGEMM_DEFAULT_Q 256 +#define XGEMM_DEFAULT_Q 256 + +#endif + + +#ifdef ITANIUM2 + +#define SNUMOPT 4 +#define DNUMOPT 4 + +#define GEMM_DEFAULT_OFFSET_A 0 +#define GEMM_DEFAULT_OFFSET_B 128 +#define GEMM_DEFAULT_ALIGN 0x03fffUL + +#define SGEMM_DEFAULT_UNROLL_M 8 +#define SGEMM_DEFAULT_UNROLL_N 8 +#define DGEMM_DEFAULT_UNROLL_M 8 +#define DGEMM_DEFAULT_UNROLL_N 8 +#define QGEMM_DEFAULT_UNROLL_M 8 +#define QGEMM_DEFAULT_UNROLL_N 8 +#define CGEMM_DEFAULT_UNROLL_M 4 +#define CGEMM_DEFAULT_UNROLL_N 4 +#define ZGEMM_DEFAULT_UNROLL_M 4 +#define ZGEMM_DEFAULT_UNROLL_N 4 +#define XGEMM_DEFAULT_UNROLL_M 4 +#define XGEMM_DEFAULT_UNROLL_N 4 + +#define SGEMM_DEFAULT_P sgemm_p +#define DGEMM_DEFAULT_P dgemm_p +#define QGEMM_DEFAULT_P qgemm_p +#define CGEMM_DEFAULT_P cgemm_p +#define ZGEMM_DEFAULT_P zgemm_p +#define XGEMM_DEFAULT_P xgemm_p + +#define SGEMM_DEFAULT_Q 1024 +#define DGEMM_DEFAULT_Q 1024 +#define QGEMM_DEFAULT_Q 1024 +#define CGEMM_DEFAULT_Q 1024 +#define ZGEMM_DEFAULT_Q 1024 +#define XGEMM_DEFAULT_Q 1024 + +#define SGEMM_DEFAULT_R sgemm_r +#define DGEMM_DEFAULT_R dgemm_r +#define QGEMM_DEFAULT_R qgemm_r +#define CGEMM_DEFAULT_R cgemm_r +#define ZGEMM_DEFAULT_R zgemm_r +#define XGEMM_DEFAULT_R xgemm_r + +#define SYMV_P 16 + +#define GETRF_FACTOR 0.65 + +#endif + +#if defined(EV4) || defined(EV5) || defined(EV6) + +#ifdef EV4 +#define SNUMOPT 1 +#define DNUMOPT 1 +#else +#define SNUMOPT 2 +#define DNUMOPT 2 +#endif + +#define GEMM_DEFAULT_OFFSET_A 512 +#define GEMM_DEFAULT_OFFSET_B 512 +#define GEMM_DEFAULT_ALIGN 0x0ffffUL + +#define SGEMM_DEFAULT_UNROLL_M 4 +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 + +#define SYMV_P 8 + +#ifdef EV4 +#define SGEMM_DEFAULT_P 32 +#define SGEMM_DEFAULT_Q 112 +#define SGEMM_DEFAULT_R 256 + +#define DGEMM_DEFAULT_P 32 +#define DGEMM_DEFAULT_Q 56 +#define DGEMM_DEFAULT_R 256 + +#define CGEMM_DEFAULT_P 32 +#define CGEMM_DEFAULT_Q 64 +#define CGEMM_DEFAULT_R 240 + +#define ZGEMM_DEFAULT_P 32 +#define ZGEMM_DEFAULT_Q 32 +#define ZGEMM_DEFAULT_R 240 +#endif + +#ifdef EV5 +#define SGEMM_DEFAULT_P 64 +#define SGEMM_DEFAULT_Q 256 + +#define DGEMM_DEFAULT_P 64 +#define DGEMM_DEFAULT_Q 128 + +#define CGEMM_DEFAULT_P 64 +#define CGEMM_DEFAULT_Q 128 + +#define ZGEMM_DEFAULT_P 64 +#define ZGEMM_DEFAULT_Q 64 +#endif + +#ifdef EV6 +#define SGEMM_DEFAULT_P 256 +#define SGEMM_DEFAULT_Q 512 + +#define DGEMM_DEFAULT_P 256 +#define DGEMM_DEFAULT_Q 256 + +#define CGEMM_DEFAULT_P 256 +#define CGEMM_DEFAULT_Q 256 + +#define ZGEMM_DEFAULT_P 128 +#define ZGEMM_DEFAULT_Q 256 +#endif + +#endif + +#ifdef CELL + +#define SNUMOPT 2 +#define DNUMOPT 2 + +#define GEMM_DEFAULT_OFFSET_A 0 +#define GEMM_DEFAULT_OFFSET_B 8192 +#define GEMM_DEFAULT_ALIGN 0x0ffffUL + +#define SGEMM_DEFAULT_UNROLL_M 16 +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define CGEMM_DEFAULT_UNROLL_M 8 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 + +#define SGEMM_DEFAULT_P 128 +#define DGEMM_DEFAULT_P 128 +#define CGEMM_DEFAULT_P 128 +#define ZGEMM_DEFAULT_P 128 + +#define SGEMM_DEFAULT_Q 512 +#define DGEMM_DEFAULT_Q 256 +#define CGEMM_DEFAULT_Q 256 +#define ZGEMM_DEFAULT_Q 128 + +#define SYMV_P 4 +#endif + +#ifdef PPCG4 +#define GEMM_DEFAULT_OFFSET_A 0 +#define GEMM_DEFAULT_OFFSET_B 1024 +#define GEMM_DEFAULT_ALIGN 0x0ffffUL + +#define SGEMM_DEFAULT_UNROLL_M 16 +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define CGEMM_DEFAULT_UNROLL_M 8 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 + +#define SGEMM_DEFAULT_P 256 +#define DGEMM_DEFAULT_P 128 +#define CGEMM_DEFAULT_P 128 +#define ZGEMM_DEFAULT_P 64 + +#define SGEMM_DEFAULT_Q 256 +#define DGEMM_DEFAULT_Q 256 +#define CGEMM_DEFAULT_Q 256 +#define ZGEMM_DEFAULT_Q 256 + +#define SYMV_P 4 +#endif + +#ifdef PPC970 + +#define SNUMOPT 4 +#define DNUMOPT 4 + +#define GEMM_DEFAULT_OFFSET_A 2688 +#define GEMM_DEFAULT_OFFSET_B 3072 +#define GEMM_DEFAULT_ALIGN 0x03fffUL + +#define SGEMM_DEFAULT_UNROLL_M 16 +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define CGEMM_DEFAULT_UNROLL_M 8 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 + +#ifdef OS_LINUX +#if L2_SIZE == 1024976 +#define SGEMM_DEFAULT_P 320 +#define DGEMM_DEFAULT_P 256 +#define CGEMM_DEFAULT_P 256 +#define ZGEMM_DEFAULT_P 256 +#else +#define SGEMM_DEFAULT_P 176 +#define DGEMM_DEFAULT_P 176 +#define CGEMM_DEFAULT_P 176 +#define ZGEMM_DEFAULT_P 176 +#endif +#endif + +#define SGEMM_DEFAULT_Q 512 +#define DGEMM_DEFAULT_Q 256 +#define CGEMM_DEFAULT_Q 256 +#define ZGEMM_DEFAULT_Q 128 + +#define SYMV_P 4 + +#endif + +#ifdef PPC440 + +#define SNUMOPT 2 +#define DNUMOPT 2 + +#define GEMM_DEFAULT_OFFSET_A (32 * 0) +#define GEMM_DEFAULT_OFFSET_B (32 * 0) +#define GEMM_DEFAULT_ALIGN 0x0ffffUL + +#define SGEMM_DEFAULT_UNROLL_M 4 +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 + +#define SGEMM_DEFAULT_P 512 +#define DGEMM_DEFAULT_P 512 +#define CGEMM_DEFAULT_P 512 +#define ZGEMM_DEFAULT_P 512 + +#define SGEMM_DEFAULT_Q 1024 +#define DGEMM_DEFAULT_Q 512 +#define CGEMM_DEFAULT_Q 512 +#define ZGEMM_DEFAULT_Q 256 + +#define SGEMM_DEFAULT_R SGEMM_DEFAULT_P +#define DGEMM_DEFAULT_R DGEMM_DEFAULT_P +#define CGEMM_DEFAULT_R CGEMM_DEFAULT_P +#define ZGEMM_DEFAULT_R ZGEMM_DEFAULT_P + +#define SYMV_P 4 +#endif + +#ifdef PPC440FP2 + +#define SNUMOPT 4 +#define DNUMOPT 4 + +#define GEMM_DEFAULT_OFFSET_A (32 * 0) +#define GEMM_DEFAULT_OFFSET_B (32 * 0) +#define GEMM_DEFAULT_ALIGN 0x0ffffUL + +#define SGEMM_DEFAULT_UNROLL_M 8 +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_M 8 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define CGEMM_DEFAULT_UNROLL_M 4 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_M 4 +#define ZGEMM_DEFAULT_UNROLL_N 2 + +#define SGEMM_DEFAULT_P 128 +#define DGEMM_DEFAULT_P 128 +#define CGEMM_DEFAULT_P 128 +#define ZGEMM_DEFAULT_P 128 +#if 1 +#define SGEMM_DEFAULT_Q 4096 +#define DGEMM_DEFAULT_Q 3072 +#define CGEMM_DEFAULT_Q 2048 +#define ZGEMM_DEFAULT_Q 1024 +#else +#define SGEMM_DEFAULT_Q 512 +#define DGEMM_DEFAULT_Q 256 +#define CGEMM_DEFAULT_Q 256 +#define ZGEMM_DEFAULT_Q 128 +#endif + +#define SYMV_P 4 +#endif + + + +#if defined(POWER3) || defined(POWER4) || defined(POWER5) +#define GEMM_DEFAULT_OFFSET_A 0 +#define GEMM_DEFAULT_OFFSET_B 2048 +#define GEMM_DEFAULT_ALIGN 0x0ffffUL + +#define SGEMM_DEFAULT_UNROLL_M 4 +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 + +#ifdef POWER3 + +#define SNUMOPT 4 +#define DNUMOPT 4 + +#define SGEMM_DEFAULT_P 256 +#define SGEMM_DEFAULT_Q 432 +#define SGEMM_DEFAULT_R 1012 + +#define DGEMM_DEFAULT_P 256 +#define DGEMM_DEFAULT_Q 216 +#define DGEMM_DEFAULT_R 1012 + +#define ZGEMM_DEFAULT_P 256 +#define ZGEMM_DEFAULT_Q 104 +#define ZGEMM_DEFAULT_R 1012 +#endif + +#if defined(POWER4) +#ifdef ALLOC_HUGETLB +#define SGEMM_DEFAULT_P 184 +#define DGEMM_DEFAULT_P 184 +#define CGEMM_DEFAULT_P 184 +#define ZGEMM_DEFAULT_P 184 +#else +#define SGEMM_DEFAULT_P 144 +#define DGEMM_DEFAULT_P 144 +#define CGEMM_DEFAULT_P 144 +#define ZGEMM_DEFAULT_P 144 +#endif +#endif + +#if defined(POWER5) +#ifdef ALLOC_HUGETLB +#define SGEMM_DEFAULT_P 512 +#define DGEMM_DEFAULT_P 256 +#define CGEMM_DEFAULT_P 256 +#define ZGEMM_DEFAULT_P 128 +#else +#define SGEMM_DEFAULT_P 320 +#define DGEMM_DEFAULT_P 160 +#define CGEMM_DEFAULT_P 160 +#define ZGEMM_DEFAULT_P 80 +#endif + +#define SGEMM_DEFAULT_Q 256 +#define CGEMM_DEFAULT_Q 256 +#define DGEMM_DEFAULT_Q 256 +#define ZGEMM_DEFAULT_Q 256 +#endif + +#define SYMV_P 8 + +#endif + +#if defined(POWER6) + +#define SNUMOPT 4 +#define DNUMOPT 4 + +#define GEMM_DEFAULT_OFFSET_A 384 +#define GEMM_DEFAULT_OFFSET_B 1024 +#define GEMM_DEFAULT_ALIGN 0x03fffUL + +#define SGEMM_DEFAULT_UNROLL_M 4 +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_N 4 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_N 4 + +#define SGEMM_DEFAULT_P 992 +#define DGEMM_DEFAULT_P 480 +#define CGEMM_DEFAULT_P 488 +#define ZGEMM_DEFAULT_P 248 + +#define SGEMM_DEFAULT_Q 504 +#define DGEMM_DEFAULT_Q 504 +#define CGEMM_DEFAULT_Q 400 +#define ZGEMM_DEFAULT_Q 400 + +#define SYMV_P 8 + +#endif + +#if defined(SPARC) && defined(V7) + +#define SNUMOPT 4 +#define DNUMOPT 4 + +#define GEMM_DEFAULT_OFFSET_A 0 +#define GEMM_DEFAULT_OFFSET_B 2048 +#define GEMM_DEFAULT_ALIGN 0x03fffUL + +#define SGEMM_DEFAULT_UNROLL_M 2 +#define SGEMM_DEFAULT_UNROLL_N 8 +#define DGEMM_DEFAULT_UNROLL_M 2 +#define DGEMM_DEFAULT_UNROLL_N 8 +#define CGEMM_DEFAULT_UNROLL_M 1 +#define CGEMM_DEFAULT_UNROLL_N 4 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define ZGEMM_DEFAULT_UNROLL_N 4 + +#define SGEMM_DEFAULT_P 256 +#define DGEMM_DEFAULT_P 256 +#define CGEMM_DEFAULT_P 256 +#define ZGEMM_DEFAULT_P 256 + +#define SGEMM_DEFAULT_Q 512 +#define DGEMM_DEFAULT_Q 256 +#define CGEMM_DEFAULT_Q 256 +#define ZGEMM_DEFAULT_Q 128 + +#define SYMV_P 8 +#define GEMM_THREAD gemm_thread_mn +#endif + +#if defined(SPARC) && defined(V9) + +#define SNUMOPT 2 +#define DNUMOPT 2 + +#define GEMM_DEFAULT_OFFSET_A 0 +#define GEMM_DEFAULT_OFFSET_B 2048 +#define GEMM_DEFAULT_ALIGN 0x03fffUL + +#define SGEMM_DEFAULT_UNROLL_M 4 +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 + +#define SGEMM_DEFAULT_P 512 +#define DGEMM_DEFAULT_P 512 +#define CGEMM_DEFAULT_P 512 +#define ZGEMM_DEFAULT_P 512 + +#define SGEMM_DEFAULT_Q 1024 +#define DGEMM_DEFAULT_Q 512 +#define CGEMM_DEFAULT_Q 512 +#define ZGEMM_DEFAULT_Q 256 + +#define SYMV_P 8 +#endif + +#ifdef SICORTEX + +#define SNUMOPT 2 +#define DNUMOPT 2 + +#define GEMM_DEFAULT_OFFSET_A 0 +#define GEMM_DEFAULT_OFFSET_B 0 +#define GEMM_DEFAULT_ALIGN 0x03fffUL + +#define SGEMM_DEFAULT_UNROLL_M 2 +#define SGEMM_DEFAULT_UNROLL_N 8 +#define DGEMM_DEFAULT_UNROLL_M 2 +#define DGEMM_DEFAULT_UNROLL_N 8 +#define CGEMM_DEFAULT_UNROLL_M 1 +#define CGEMM_DEFAULT_UNROLL_N 4 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define ZGEMM_DEFAULT_UNROLL_N 4 + +#define SGEMM_DEFAULT_P 108 +#define DGEMM_DEFAULT_P 112 +#define CGEMM_DEFAULT_P 108 +#define ZGEMM_DEFAULT_P 112 + +#define SGEMM_DEFAULT_Q 288 +#define DGEMM_DEFAULT_Q 144 +#define CGEMM_DEFAULT_Q 144 +#define ZGEMM_DEFAULT_Q 72 + +#define SGEMM_DEFAULT_R 2000 +#define DGEMM_DEFAULT_R 2000 +#define CGEMM_DEFAULT_R 2000 +#define ZGEMM_DEFAULT_R 2000 + +#define SYMV_P 16 +#endif + +#ifdef GENERIC + +#define SNUMOPT 2 +#define DNUMOPT 2 + +#define GEMM_DEFAULT_OFFSET_A 0 +#define GEMM_DEFAULT_OFFSET_B 0 +#define GEMM_DEFAULT_ALIGN 0x0ffffUL + +#define SGEMM_DEFAULT_UNROLL_N 4 +#define DGEMM_DEFAULT_UNROLL_N 4 +#define QGEMM_DEFAULT_UNROLL_N 2 +#define CGEMM_DEFAULT_UNROLL_N 2 +#define ZGEMM_DEFAULT_UNROLL_N 2 +#define XGEMM_DEFAULT_UNROLL_N 1 + +#ifdef ARCH_X86 +#define SGEMM_DEFAULT_UNROLL_M 4 +#define DGEMM_DEFAULT_UNROLL_M 2 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 2 +#define ZGEMM_DEFAULT_UNROLL_M 1 +#define XGEMM_DEFAULT_UNROLL_M 1 +#else +#define SGEMM_DEFAULT_UNROLL_M 8 +#define DGEMM_DEFAULT_UNROLL_M 4 +#define QGEMM_DEFAULT_UNROLL_M 2 +#define CGEMM_DEFAULT_UNROLL_M 4 +#define ZGEMM_DEFAULT_UNROLL_M 2 +#define XGEMM_DEFAULT_UNROLL_M 1 +#endif + +#define SGEMM_P sgemm_p +#define DGEMM_P dgemm_p +#define QGEMM_P qgemm_p +#define CGEMM_P cgemm_p +#define ZGEMM_P zgemm_p +#define XGEMM_P xgemm_p + +#define SGEMM_R sgemm_r +#define DGEMM_R dgemm_r +#define QGEMM_R qgemm_r +#define CGEMM_R cgemm_r +#define ZGEMM_R zgemm_r +#define XGEMM_R xgemm_r + +#define SGEMM_Q 128 +#define DGEMM_Q 128 +#define QGEMM_Q 128 +#define CGEMM_Q 128 +#define ZGEMM_Q 128 +#define XGEMM_Q 128 + +#define SYMV_P 16 + +#endif + +#ifndef QGEMM_DEFAULT_UNROLL_M +#define QGEMM_DEFAULT_UNROLL_M 2 +#endif + +#ifndef QGEMM_DEFAULT_UNROLL_N +#define QGEMM_DEFAULT_UNROLL_N 2 +#endif + +#ifndef XGEMM_DEFAULT_UNROLL_M +#define XGEMM_DEFAULT_UNROLL_M 2 +#endif + +#ifndef XGEMM_DEFAULT_UNROLL_N +#define XGEMM_DEFAULT_UNROLL_N 2 +#endif + +#ifndef HAVE_SSE2 +#define SHUFPD_0 shufps $0x44, +#define SHUFPD_1 shufps $0x4e, +#define SHUFPD_2 shufps $0xe4, +#define SHUFPD_3 shufps $0xee, +#endif + +#ifndef SHUFPD_0 +#define SHUFPD_0 shufpd $0, +#endif + +#ifndef SHUFPD_1 +#define SHUFPD_1 shufpd $1, +#endif + +#ifndef SHUFPD_2 +#define SHUFPD_2 shufpd $2, +#endif + +#ifndef SHUFPD_3 +#define SHUFPD_3 shufpd $3, +#endif + +#ifndef SHUFPS_39 +#define SHUFPS_39 shufps $0x39, +#endif + + +#endif diff --git a/src/NativeWrappers/GotoBlas2/include/symcopy.h b/src/NativeWrappers/GotoBlas2/include/symcopy.h new file mode 100644 index 00000000..ed6e5b41 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/symcopy.h @@ -0,0 +1,1873 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +/* This implementation is completely wrong. I'll rewrite this */ + +#ifndef SYMCOPY_H +#define SYMCOPY_H + +#if !defined(XDOUBLE) || !defined(QUAD_PRECISION) + +static inline void SYMCOPY_L(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a12; + FLOAT a21, a22; + + b1 = b; + b2 = b; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda + 2; + + bb1 = b1 + 0 * m; + bb2 = b1 + 1 * m; + b1 += 2 * m + 2; + + cc1 = b2 + 0 * m; + cc2 = b2 + 1 * m; + b2 += 2 * m + 2; + + if (m - js >= 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + + a22 = *(aa2 + 1); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb2 + 0) = a21; + *(bb2 + 1) = a22; + aa1 += 2; + aa2 += 2; + bb1 += 2; + bb2 += 2; + + cc1 += 2 * m; + cc2 += 2 * m; + + is = ((m - js - 2) >> 1); + + while (is > 0){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + + aa1 += 2; + aa2 += 2; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a12; + *(cc2 + 0) = a21; + *(cc2 + 1) = a22; + + bb1 += 2; + bb2 += 2; + + cc1 += 2 * m; + cc2 += 2 * m; + + is --; + } + + is = ((m - js - 2) & 1); + + if (is == 1){ + a11 = *(aa1 + 0); + a12 = *(aa2 + 0); + + *(bb1 + 0) = a11; + *(bb2 + 0) = a12; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a12; + } + } + + if (m - js == 1){ + a11 = *(aa1 + 0); + *(bb1 + 0) = a11; + } + + } +} + +static inline void SYMCOPY_U(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a12; + FLOAT a21, a22; + + b1 = b; + b2 = b; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda; + + bb1 = b1 + 0 * m; + bb2 = b1 + 1 * m; + b1 += 2 * m; + + cc1 = b2 + 0 * m; + cc2 = b2 + 1 * m; + b2 += 2; + + if (m - js >= 2){ + + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + + aa1 += 2; + aa2 += 2; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a12; + *(cc2 + 0) = a21; + *(cc2 + 1) = a22; + + bb1 += 2; + bb2 += 2; + + cc1 += 2 * m; + cc2 += 2 * m; + } + + a11 = *(aa1 + 0); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a12; + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + } + + if (m - js == 1){ + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + aa1 += 2; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(cc1 + 0) = a11; + *(cc2 + 0) = a21; + bb1 += 2; + + cc1 += 2 * m; + cc2 += 2 * m; + } + + a11 = *(aa1 + 0); + *(bb1 + 0) = a11; + } + } +} + + +static inline void ZSYMCOPY_L(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a21, a31, a41; + FLOAT a12, a22, a32, a42; + + b1 = b; + b2 = b; + + lda *= 2; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda + 4; + + bb1 = b1 + 0 * m; + bb2 = b1 + 2 * m; + b1 += 4 * m + 4; + + cc1 = b2 + 0 * m; + cc2 = b2 + 2 * m; + b2 += 4 * m + 4; + + if (m - js >= 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + + a12 = *(aa2 + 2); + a22 = *(aa2 + 3); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(bb2 + 0) = a31; + *(bb2 + 1) = a41; + *(bb2 + 2) = a12; + *(bb2 + 3) = a22; + + aa1 += 4; + aa2 += 4; + bb1 += 4; + bb2 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + + is = ((m - js - 2) >> 1); + + while (is > 0){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + a32 = *(aa2 + 2); + a42 = *(aa2 + 3); + + aa1 += 4; + aa2 += 4; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + *(bb2 + 2) = a32; + *(bb2 + 3) = a42; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc1 + 2) = a12; + *(cc1 + 3) = a22; + + *(cc2 + 0) = a31; + *(cc2 + 1) = a41; + *(cc2 + 2) = a32; + *(cc2 + 3) = a42; + + bb1 += 4; + bb2 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + + is --; + } + + if (m & 1){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc1 + 2) = a12; + *(cc1 + 3) = a22; + } + } + + if (m - js == 1){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + } + + } +} + +static inline void ZSYMCOPY_U(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a21, a31, a41; + FLOAT a12, a22, a32, a42; + + b1 = b; + b2 = b; + + lda *= 2; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda; + + bb1 = b1 + 0 * m; + bb2 = b1 + 2 * m; + b1 += 4 * m; + + cc1 = b2 + 0 * m; + cc2 = b2 + 2 * m; + b2 += 4; + + if (m - js >= 2){ + + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + a32 = *(aa2 + 2); + a42 = *(aa2 + 3); + + aa1 += 4; + aa2 += 4; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + *(bb2 + 2) = a32; + *(bb2 + 3) = a42; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc1 + 2) = a12; + *(cc1 + 3) = a22; + + *(cc2 + 0) = a31; + *(cc2 + 1) = a41; + *(cc2 + 2) = a32; + *(cc2 + 3) = a42; + + bb1 += 4; + bb2 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + } + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + a32 = *(aa2 + 2); + a42 = *(aa2 + 3); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a12; + *(bb1 + 3) = a22; + + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + *(bb2 + 2) = a32; + *(bb2 + 3) = a42; + } + + if (m - js == 1){ + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + aa1 += 4; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc2 + 0) = a31; + *(cc2 + 1) = a41; + bb1 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + } + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + } + } +} + +static inline void ZHEMCOPY_L(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a21, a31, a41; + FLOAT a12, a22, a32, a42; + + b1 = b; + b2 = b; + + lda *= 2; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda + 4; + + bb1 = b1 + 0 * m; + bb2 = b1 + 2 * m; + b1 += 4 * m + 4; + + cc1 = b2 + 0 * m; + cc2 = b2 + 2 * m; + b2 += 4 * m + 4; + + if (m - js >= 2){ + + a11 = *(aa1 + 0); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + + a12 = *(aa2 + 2); + + *(bb1 + 0) = a11; + *(bb1 + 1) = 0.; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(bb2 + 0) = a31; + *(bb2 + 1) = -a41; + *(bb2 + 2) = a12; + *(bb2 + 3) = 0.; + + aa1 += 4; + aa2 += 4; + bb1 += 4; + bb2 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + + is = ((m - js - 2) >> 1); + + while (is > 0){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + a32 = *(aa2 + 2); + a42 = *(aa2 + 3); + + aa1 += 4; + aa2 += 4; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + *(bb2 + 2) = a32; + *(bb2 + 3) = a42; + + *(cc1 + 0) = a11; + *(cc1 + 1) = -a21; + *(cc1 + 2) = a12; + *(cc1 + 3) = -a22; + + *(cc2 + 0) = a31; + *(cc2 + 1) = -a41; + *(cc2 + 2) = a32; + *(cc2 + 3) = -a42; + + bb1 += 4; + bb2 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + + is --; + } + + if (m & 1){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + + *(cc1 + 0) = a11; + *(cc1 + 1) = -a21; + *(cc1 + 2) = a12; + *(cc1 + 3) = -a22; + } + } + + if (m - js == 1){ + a11 = *(aa1 + 0); + *(bb1 + 0) = a11; + *(bb1 + 1) = 0.; + } + + } +} + +static inline void ZHEMCOPY_U(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a21, a31, a41; + FLOAT a12, a22, a32, a42; + + b1 = b; + b2 = b; + + lda *= 2; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda; + + bb1 = b1 + 0 * m; + bb2 = b1 + 2 * m; + b1 += 4 * m; + + cc1 = b2 + 0 * m; + cc2 = b2 + 2 * m; + b2 += 4; + + if (m - js >= 2){ + + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + a32 = *(aa2 + 2); + a42 = *(aa2 + 3); + + aa1 += 4; + aa2 += 4; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + *(bb2 + 2) = a32; + *(bb2 + 3) = a42; + + *(cc1 + 0) = a11; + *(cc1 + 1) = -a21; + *(cc1 + 2) = a12; + *(cc1 + 3) = -a22; + + *(cc2 + 0) = a31; + *(cc2 + 1) = -a41; + *(cc2 + 2) = a32; + *(cc2 + 3) = -a42; + + bb1 += 4; + bb2 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + } + + a11 = *(aa1 + 0); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + a32 = *(aa2 + 2); + + *(bb1 + 0) = a11; + *(bb1 + 1) = 0.; + *(bb1 + 2) = a12; + *(bb1 + 3) = -a22; + + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + *(bb2 + 2) = a32; + *(bb2 + 3) = 0.; + } + + if (m - js == 1){ + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + aa1 += 4; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(cc1 + 0) = a11; + *(cc1 + 1) = -a21; + *(cc2 + 0) = a31; + *(cc2 + 1) = -a41; + bb1 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + } + + a11 = *(aa1 + 0); + *(bb1 + 0) = a11; + *(bb1 + 1) = 0.; + } + } +} + + +static inline void ZHEMCOPY_M(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a21, a31, a41; + FLOAT a12, a22, a32, a42; + + b1 = b; + b2 = b; + + lda *= 2; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda + 4; + + bb1 = b1 + 0 * m; + bb2 = b1 + 2 * m; + b1 += 4 * m + 4; + + cc1 = b2 + 0 * m; + cc2 = b2 + 2 * m; + b2 += 4 * m + 4; + + if (m - js >= 2){ + + a11 = *(aa1 + 0); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + + a12 = *(aa2 + 2); + + *(bb1 + 0) = a11; + *(bb1 + 1) = 0.; + *(bb1 + 2) = a31; + *(bb1 + 3) = -a41; + + *(bb2 + 0) = a31; + *(bb2 + 1) = a41; + *(bb2 + 2) = a12; + *(bb2 + 3) = 0.; + + aa1 += 4; + aa2 += 4; + bb1 += 4; + bb2 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + + is = ((m - js - 2) >> 1); + + while (is > 0){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + a32 = *(aa2 + 2); + a42 = *(aa2 + 3); + + aa1 += 4; + aa2 += 4; + + *(bb1 + 0) = a11; + *(bb1 + 1) = -a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = -a41; + + *(bb2 + 0) = a12; + *(bb2 + 1) = -a22; + *(bb2 + 2) = a32; + *(bb2 + 3) = -a42; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc1 + 2) = a12; + *(cc1 + 3) = a22; + + *(cc2 + 0) = a31; + *(cc2 + 1) = a41; + *(cc2 + 2) = a32; + *(cc2 + 3) = a42; + + bb1 += 4; + bb2 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + + is --; + } + + if (m & 1){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + + *(bb1 + 0) = a11; + *(bb1 + 1) = -a21; + *(bb2 + 0) = a12; + *(bb2 + 1) = -a22; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc1 + 2) = a12; + *(cc1 + 3) = a22; + } + } + + if (m - js == 1){ + a11 = *(aa1 + 0); + *(bb1 + 0) = a11; + *(bb1 + 1) = 0.; + } + + } +} + +static inline void ZHEMCOPY_V(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a21, a31, a41; + FLOAT a12, a22, a32, a42; + + b1 = b; + b2 = b; + + lda *= 2; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda; + + bb1 = b1 + 0 * m; + bb2 = b1 + 2 * m; + b1 += 4 * m; + + cc1 = b2 + 0 * m; + cc2 = b2 + 2 * m; + b2 += 4; + + if (m - js >= 2){ + + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + a32 = *(aa2 + 2); + a42 = *(aa2 + 3); + + aa1 += 4; + aa2 += 4; + + *(bb1 + 0) = a11; + *(bb1 + 1) = -a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = -a41; + + *(bb2 + 0) = a12; + *(bb2 + 1) = -a22; + *(bb2 + 2) = a32; + *(bb2 + 3) = -a42; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc1 + 2) = a12; + *(cc1 + 3) = a22; + + *(cc2 + 0) = a31; + *(cc2 + 1) = a41; + *(cc2 + 2) = a32; + *(cc2 + 3) = a42; + + bb1 += 4; + bb2 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + } + + a11 = *(aa1 + 0); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + a32 = *(aa2 + 2); + + *(bb1 + 0) = a11; + *(bb1 + 1) = 0.; + *(bb1 + 2) = a12; + *(bb1 + 3) = a22; + + *(bb2 + 0) = a12; + *(bb2 + 1) = -a22; + *(bb2 + 2) = a32; + *(bb2 + 3) = 0.; + } + + if (m - js == 1){ + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + aa1 += 4; + + *(bb1 + 0) = a11; + *(bb1 + 1) = -a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = -a41; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc2 + 0) = a31; + *(cc2 + 1) = a41; + bb1 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + } + + a11 = *(aa1 + 0); + *(bb1 + 0) = a11; + *(bb1 + 1) = 0.; + } + } +} + + +static inline void TRMCOPY_NL(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a12; + FLOAT a21, a22; + + b1 = b; + b2 = b; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda + 2; + + bb1 = b1 + 0 * m; + bb2 = b1 + 1 * m; + b1 += 2 * m + 2; + + cc1 = b2 + 0 * m; + cc2 = b2 + 1 * m; + b2 += 2 * m + 2; + + if (m - js >= 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + + a22 = *(aa2 + 1); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb2 + 0) = a21; + *(bb2 + 1) = a22; + aa1 += 2; + aa2 += 2; + bb1 += 2; + bb2 += 2; + + cc1 += 2 * m; + cc2 += 2 * m; + + is = ((m - js - 2) >> 1); + + while (is > 0){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + + aa1 += 2; + aa2 += 2; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a12; + *(cc2 + 0) = a21; + *(cc2 + 1) = a22; + + bb1 += 2; + bb2 += 2; + + cc1 += 2 * m; + cc2 += 2 * m; + + is --; + } + + is = ((m - js - 2) & 1); + + if (is == 1){ + a11 = *(aa1 + 0); + a12 = *(aa2 + 0); + + *(bb1 + 0) = a11; + *(bb2 + 0) = a12; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a12; + } + } + + if (m - js == 1){ + a11 = *(aa1 + 0); + *(bb1 + 0) = a11; + } + + } +} + +static inline void TRMCOPY_TL(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a12; + FLOAT a21, a22; + + b1 = b; + b2 = b; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda + 2; + + bb1 = b1 + 0 * m; + bb2 = b1 + 1 * m; + b1 += 2 * m + 2; + + cc1 = b2 + 0 * m; + cc2 = b2 + 1 * m; + b2 += 2 * m + 2; + + if (m - js >= 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + + a22 = *(aa2 + 1); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb2 + 0) = a21; + *(bb2 + 1) = a22; + aa1 += 2; + aa2 += 2; + bb1 += 2; + bb2 += 2; + + cc1 += 2 * m; + cc2 += 2 * m; + + is = ((m - js - 2) >> 1); + + while (is > 0){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + + aa1 += 2; + aa2 += 2; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a12; + *(cc2 + 0) = a21; + *(cc2 + 1) = a22; + + bb1 += 2; + bb2 += 2; + + cc1 += 2 * m; + cc2 += 2 * m; + + is --; + } + + is = ((m - js - 2) & 1); + + if (is == 1){ + a11 = *(aa1 + 0); + a12 = *(aa2 + 0); + + *(bb1 + 0) = a11; + *(bb2 + 0) = a12; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a12; + } + } + + if (m - js == 1){ + a11 = *(aa1 + 0); + *(bb1 + 0) = a11; + } + + } +} + +static inline void TRMCOPY_NU(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a12; + FLOAT a21, a22; + + b1 = b; + b2 = b; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda; + + bb1 = b1 + 0 * m; + bb2 = b1 + 1 * m; + b1 += 2 * m; + + cc1 = b2 + 0 * m; + cc2 = b2 + 1 * m; + b2 += 2; + + if (m - js >= 2){ + + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + + aa1 += 2; + aa2 += 2; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a12; + *(cc2 + 0) = a21; + *(cc2 + 1) = a22; + + bb1 += 2; + bb2 += 2; + + cc1 += 2 * m; + cc2 += 2 * m; + } + + a11 = *(aa1 + 0); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a12; + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + } + + if (m - js == 1){ + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + aa1 += 2; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(cc1 + 0) = a11; + *(cc2 + 0) = a21; + bb1 += 2; + + cc1 += 2 * m; + cc2 += 2 * m; + } + + a11 = *(aa1 + 0); + *(bb1 + 0) = a11; + } + } +} + +static inline void TRMCOPY_TU(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a12; + FLOAT a21, a22; + + b1 = b; + b2 = b; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda; + + bb1 = b1 + 0 * m; + bb2 = b1 + 1 * m; + b1 += 2 * m; + + cc1 = b2 + 0 * m; + cc2 = b2 + 1 * m; + b2 += 2; + + if (m - js >= 2){ + + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + + aa1 += 2; + aa2 += 2; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a12; + *(cc2 + 0) = a21; + *(cc2 + 1) = a22; + + bb1 += 2; + bb2 += 2; + + cc1 += 2 * m; + cc2 += 2 * m; + } + + a11 = *(aa1 + 0); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a12; + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + } + + if (m - js == 1){ + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + aa1 += 2; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(cc1 + 0) = a11; + *(cc2 + 0) = a21; + bb1 += 2; + + cc1 += 2 * m; + cc2 += 2 * m; + } + + a11 = *(aa1 + 0); + *(bb1 + 0) = a11; + } + } +} + +static inline void ZTRMCOPY_NL(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a21, a31, a41; + FLOAT a12, a22, a32, a42; + + b1 = b; + b2 = b; + + lda *= 2; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda + 4; + + bb1 = b1 + 0 * m; + bb2 = b1 + 2 * m; + b1 += 4 * m + 4; + + cc1 = b2 + 0 * m; + cc2 = b2 + 2 * m; + b2 += 4 * m + 4; + + if (m - js >= 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + + a12 = *(aa2 + 2); + a22 = *(aa2 + 3); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(bb2 + 0) = a31; + *(bb2 + 1) = a41; + *(bb2 + 2) = a12; + *(bb2 + 3) = a22; + + aa1 += 4; + aa2 += 4; + bb1 += 4; + bb2 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + + is = ((m - js - 2) >> 1); + + while (is > 0){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + a32 = *(aa2 + 2); + a42 = *(aa2 + 3); + + aa1 += 4; + aa2 += 4; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + *(bb2 + 2) = a32; + *(bb2 + 3) = a42; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc1 + 2) = a12; + *(cc1 + 3) = a22; + + *(cc2 + 0) = a31; + *(cc2 + 1) = a41; + *(cc2 + 2) = a32; + *(cc2 + 3) = a42; + + bb1 += 4; + bb2 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + + is --; + } + + if (m & 1){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc1 + 2) = a12; + *(cc1 + 3) = a22; + } + } + + if (m - js == 1){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + } + + } +} + +static inline void ZTRMCOPY_TL(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a21, a31, a41; + FLOAT a12, a22, a32, a42; + + b1 = b; + b2 = b; + + lda *= 2; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda + 4; + + bb1 = b1 + 0 * m; + bb2 = b1 + 2 * m; + b1 += 4 * m + 4; + + cc1 = b2 + 0 * m; + cc2 = b2 + 2 * m; + b2 += 4 * m + 4; + + if (m - js >= 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + + a12 = *(aa2 + 2); + a22 = *(aa2 + 3); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(bb2 + 0) = a31; + *(bb2 + 1) = a41; + *(bb2 + 2) = a12; + *(bb2 + 3) = a22; + + aa1 += 4; + aa2 += 4; + bb1 += 4; + bb2 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + + is = ((m - js - 2) >> 1); + + while (is > 0){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + a32 = *(aa2 + 2); + a42 = *(aa2 + 3); + + aa1 += 4; + aa2 += 4; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + *(bb2 + 2) = a32; + *(bb2 + 3) = a42; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc1 + 2) = a12; + *(cc1 + 3) = a22; + + *(cc2 + 0) = a31; + *(cc2 + 1) = a41; + *(cc2 + 2) = a32; + *(cc2 + 3) = a42; + + bb1 += 4; + bb2 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + + is --; + } + + if (m & 1){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc1 + 2) = a12; + *(cc1 + 3) = a22; + } + } + + if (m - js == 1){ + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + } + + } +} + +static inline void ZTRMCOPY_NU(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a21, a31, a41; + FLOAT a12, a22, a32, a42; + + b1 = b; + b2 = b; + + lda *= 2; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda; + + bb1 = b1 + 0 * m; + bb2 = b1 + 2 * m; + b1 += 4 * m; + + cc1 = b2 + 0 * m; + cc2 = b2 + 2 * m; + b2 += 4; + + if (m - js >= 2){ + + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + a32 = *(aa2 + 2); + a42 = *(aa2 + 3); + + aa1 += 4; + aa2 += 4; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + *(bb2 + 2) = a32; + *(bb2 + 3) = a42; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc1 + 2) = a12; + *(cc1 + 3) = a22; + + *(cc2 + 0) = a31; + *(cc2 + 1) = a41; + *(cc2 + 2) = a32; + *(cc2 + 3) = a42; + + bb1 += 4; + bb2 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + } + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + a32 = *(aa2 + 2); + a42 = *(aa2 + 3); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a12; + *(bb1 + 3) = a22; + + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + *(bb2 + 2) = a32; + *(bb2 + 3) = a42; + } + + if (m - js == 1){ + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + aa1 += 4; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc2 + 0) = a31; + *(cc2 + 1) = a41; + bb1 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + } + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + } + } +} + +static inline void ZTRMCOPY_TU(BLASLONG m, FLOAT *a, BLASLONG lda, FLOAT *b){ + BLASLONG is, js; + + FLOAT *aa1, *aa2; + FLOAT *b1, *b2; + FLOAT *bb1, *bb2; + FLOAT *cc1, *cc2; + FLOAT a11, a21, a31, a41; + FLOAT a12, a22, a32, a42; + + b1 = b; + b2 = b; + + lda *= 2; + + for (js = 0; js < m; js += 2){ + + aa1 = a + 0 * lda; + aa2 = a + 1 * lda; + a += 2 * lda; + + bb1 = b1 + 0 * m; + bb2 = b1 + 2 * m; + b1 += 4 * m; + + cc1 = b2 + 0 * m; + cc2 = b2 + 2 * m; + b2 += 4; + + if (m - js >= 2){ + + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + a32 = *(aa2 + 2); + a42 = *(aa2 + 3); + + aa1 += 4; + aa2 += 4; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + *(bb2 + 2) = a32; + *(bb2 + 3) = a42; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc1 + 2) = a12; + *(cc1 + 3) = a22; + + *(cc2 + 0) = a31; + *(cc2 + 1) = a41; + *(cc2 + 2) = a32; + *(cc2 + 3) = a42; + + bb1 += 4; + bb2 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + } + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + + a12 = *(aa2 + 0); + a22 = *(aa2 + 1); + a32 = *(aa2 + 2); + a42 = *(aa2 + 3); + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a12; + *(bb1 + 3) = a22; + + *(bb2 + 0) = a12; + *(bb2 + 1) = a22; + *(bb2 + 2) = a32; + *(bb2 + 3) = a42; + } + + if (m - js == 1){ + for (is = 0; is < js; is += 2){ + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + a31 = *(aa1 + 2); + a41 = *(aa1 + 3); + aa1 += 4; + + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + *(bb1 + 2) = a31; + *(bb1 + 3) = a41; + + *(cc1 + 0) = a11; + *(cc1 + 1) = a21; + *(cc2 + 0) = a31; + *(cc2 + 1) = a41; + bb1 += 4; + + cc1 += 4 * m; + cc2 += 4 * m; + } + + a11 = *(aa1 + 0); + a21 = *(aa1 + 1); + *(bb1 + 0) = a11; + *(bb1 + 1) = a21; + } + } +} + +#endif +#endif + diff --git a/src/NativeWrappers/GotoBlas2/include/version.h b/src/NativeWrappers/GotoBlas2/include/version.h new file mode 100644 index 00000000..d4144467 --- /dev/null +++ b/src/NativeWrappers/GotoBlas2/include/version.h @@ -0,0 +1,43 @@ +/*********************************************************************/ +/* Copyright 2009, 2010 The University of Texas at Austin. */ +/* All rights reserved. */ +/* */ +/* 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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN ``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 UNIVERSITY OF TEXAS AT */ +/* AUSTIN 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. */ +/* */ +/* The views and conclusions contained in the software and */ +/* documentation are those of the authors and should not be */ +/* interpreted as representing official policies, either expressed */ +/* or implied, of The University of Texas at Austin. */ +/*********************************************************************/ + +#ifndef VERSION_H +#define VERSION_H + +#define VERSION " Optimized BLAS by Kazushige Goto " +#endif diff --git a/src/NativeWrappers/MKL/lapack.cpp b/src/NativeWrappers/MKL/lapack.cpp index 5814f65b..5ac9d13f 100644 --- a/src/NativeWrappers/MKL/lapack.cpp +++ b/src/NativeWrappers/MKL/lapack.cpp @@ -1,4 +1,4 @@ -#include "common.h" +#include "wrapper_common.h" #include "blas.h" #include "mkl_lapack.h" #include diff --git a/src/NativeWrappers/MKL/vector_functions.c b/src/NativeWrappers/MKL/vector_functions.c index 080b641a..28716fe9 100644 --- a/src/NativeWrappers/MKL/vector_functions.c +++ b/src/NativeWrappers/MKL/vector_functions.c @@ -1,6 +1,6 @@ #include "mkl_vml.h" #include "blas.h" -#include "common.h" +#include "wrapper_common.h" DLLEXPORT void s_vector_add( const int n, const float x[], const float y[], float result[] ){ diff --git a/src/NativeWrappers/Windows/GotoBLAS2Wrapper/GotoBLAS2Wrapper.vcxproj b/src/NativeWrappers/Windows/GotoBLAS2Wrapper/GotoBLAS2Wrapper.vcxproj new file mode 100644 index 00000000..8cf88630 --- /dev/null +++ b/src/NativeWrappers/Windows/GotoBLAS2Wrapper/GotoBLAS2Wrapper.vcxproj @@ -0,0 +1,163 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {507FF69E-32A6-495A-9DE2-20EC10EE8963} + Win32Proj + GotoBLAS2Wrapper + + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + + + + + + + + + + + + + + + + + true + + + true + + + false + + + false + + + + NotUsing + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;GOTOBLAS2WRAPPER_EXPORTS;%(PreprocessorDefinitions) + ..\..\Common;.\include; + + + Windows + true + ..\..\..\..\lib\GotoBLAS2; + libgoto2_core2p-r1.13_x86.lib;%(AdditionalDependencies) + + + + + NotUsing + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;GOTOBLAS2WRAPPER_EXPORTS;%(PreprocessorDefinitions) + ..\..\Common;.\include; + + + Windows + true + ..\..\..\..\lib\GotoBLAS2; + libgoto2_core2p-r1.13_x86_64.lib;%(AdditionalDependencies) + + + + + Level3 + NotUsing + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;GOTOBLAS2WRAPPER_EXPORTS;%(PreprocessorDefinitions) + ..\..\Common;.\include; + + + Windows + true + true + true + ..\..\..\..\lib\GotoBLAS2; + libgoto2_core2p-r1.13_x86.lib;%(AdditionalDependencies) + + + + + Level3 + NotUsing + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;GOTOBLAS2WRAPPER_EXPORTS;%(PreprocessorDefinitions) + ..\..\Common;.\include; + + + Windows + true + true + true + ..\..\..\..\lib\GotoBLAS2; + libgoto2_core2p-r1.13_x86_64.lib;%(AdditionalDependencies) + + + + + + + + + + + + ..\..\Common; + ..\..\Common; + ..\..\Common; + ..\..\Common; + + + + + + \ No newline at end of file diff --git a/src/NativeWrappers/Windows/GotoBLAS2Wrapper/GotoBLAS2Wrapper.vcxproj.filters b/src/NativeWrappers/Windows/GotoBLAS2Wrapper/GotoBLAS2Wrapper.vcxproj.filters new file mode 100644 index 00000000..30bd4d4e --- /dev/null +++ b/src/NativeWrappers/Windows/GotoBLAS2Wrapper/GotoBLAS2Wrapper.vcxproj.filters @@ -0,0 +1,35 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Resource Files + + + + + Header Files + + + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/src/NativeWrappers/Windows/MKL/MKLWrapper.vcxproj b/src/NativeWrappers/Windows/MKL/MKLWrapper.vcxproj index ad4b1dc1..6cf8d7b7 100644 --- a/src/NativeWrappers/Windows/MKL/MKLWrapper.vcxproj +++ b/src/NativeWrappers/Windows/MKL/MKLWrapper.vcxproj @@ -183,12 +183,9 @@ - + - - - diff --git a/src/NativeWrappers/Windows/MKL/MKLWrapper.vcxproj.filters b/src/NativeWrappers/Windows/MKL/MKLWrapper.vcxproj.filters index 597de039..a2e2e4ff 100644 --- a/src/NativeWrappers/Windows/MKL/MKLWrapper.vcxproj.filters +++ b/src/NativeWrappers/Windows/MKL/MKLWrapper.vcxproj.filters @@ -15,18 +15,13 @@ - + Header Files - + Header Files - - - Resource Files - - Source Files diff --git a/src/NativeWrappers/Windows/NativeWrappers.sln b/src/NativeWrappers/Windows/NativeWrappers.sln index 3c535012..8544219f 100644 --- a/src/NativeWrappers/Windows/NativeWrappers.sln +++ b/src/NativeWrappers/Windows/NativeWrappers.sln @@ -4,10 +4,10 @@ Microsoft Visual Studio Solution File, Format Version 11.00 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Common", "Common", "{5A0892FF-82CE-40FC-BCE1-73810C615F52}" ProjectSection(SolutionItems) = preProject ..\Common\blas.c = ..\Common\blas.c - ..\Common\common.h = ..\Common\common.h ..\Common\resource.h = ..\Common\resource.h ..\Common\resource.rc = ..\Common\resource.rc ..\Common\WindowsDLL.cpp = ..\Common\WindowsDLL.cpp + ..\Common\wrapper_common.h = ..\Common\wrapper_common.h EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MKLWrapper", "MKL\MKLWrapper.vcxproj", "{C0B0DBA9-7FB0-4C87-BDB1-3EED19DC2B8F}" @@ -16,17 +16,9 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MKLWrapper64Tests", "MKLWra EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MKLWrapper32Tests", "MKLWrapper32Tests\MKLWrapper32Tests.csproj", "{D0AD591B-0CE6-4A6D-8DEA-01777EE09BC3}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{953422F5-A946-434B-81FD-A5A0AF92AAE1}" - ProjectSection(SolutionItems) = preProject - Local.testsettings = Local.testsettings - NativeWrappers.vsmdi = NativeWrappers.vsmdi - TraceAndTestImpact.testsettings = TraceAndTestImpact.testsettings - EndProjectSection +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "GotoBLAS2Wrapper", "GotoBLAS2Wrapper\GotoBLAS2Wrapper.vcxproj", "{507FF69E-32A6-495A-9DE2-20EC10EE8963}" EndProject Global - GlobalSection(TestCaseManagementSettings) = postSolution - CategoryFile = NativeWrappers.vsmdi - EndGlobalSection GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Debug|Mixed Platforms = Debug|Mixed Platforms @@ -39,8 +31,8 @@ Global EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {C0B0DBA9-7FB0-4C87-BDB1-3EED19DC2B8F}.Debug|Any CPU.ActiveCfg = Debug|x64 - {C0B0DBA9-7FB0-4C87-BDB1-3EED19DC2B8F}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32 - {C0B0DBA9-7FB0-4C87-BDB1-3EED19DC2B8F}.Debug|Mixed Platforms.Build.0 = Debug|Win32 + {C0B0DBA9-7FB0-4C87-BDB1-3EED19DC2B8F}.Debug|Mixed Platforms.ActiveCfg = Release|Win32 + {C0B0DBA9-7FB0-4C87-BDB1-3EED19DC2B8F}.Debug|Mixed Platforms.Build.0 = Release|Win32 {C0B0DBA9-7FB0-4C87-BDB1-3EED19DC2B8F}.Debug|Win32.ActiveCfg = Debug|Win32 {C0B0DBA9-7FB0-4C87-BDB1-3EED19DC2B8F}.Debug|Win32.Build.0 = Debug|Win32 {C0B0DBA9-7FB0-4C87-BDB1-3EED19DC2B8F}.Debug|x64.ActiveCfg = Debug|x64 @@ -55,6 +47,7 @@ Global {B134AA80-D8CA-4B83-9775-AE6ED2D5CFAB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B134AA80-D8CA-4B83-9775-AE6ED2D5CFAB}.Debug|Any CPU.Build.0 = Debug|Any CPU {B134AA80-D8CA-4B83-9775-AE6ED2D5CFAB}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {B134AA80-D8CA-4B83-9775-AE6ED2D5CFAB}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU {B134AA80-D8CA-4B83-9775-AE6ED2D5CFAB}.Debug|Win32.ActiveCfg = Debug|Any CPU {B134AA80-D8CA-4B83-9775-AE6ED2D5CFAB}.Debug|x64.ActiveCfg = Debug|Any CPU {B134AA80-D8CA-4B83-9775-AE6ED2D5CFAB}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -75,6 +68,18 @@ Global {D0AD591B-0CE6-4A6D-8DEA-01777EE09BC3}.Release|Mixed Platforms.Build.0 = Release|Any CPU {D0AD591B-0CE6-4A6D-8DEA-01777EE09BC3}.Release|Win32.ActiveCfg = Release|Any CPU {D0AD591B-0CE6-4A6D-8DEA-01777EE09BC3}.Release|x64.ActiveCfg = Release|Any CPU + {507FF69E-32A6-495A-9DE2-20EC10EE8963}.Debug|Any CPU.ActiveCfg = Debug|Win32 + {507FF69E-32A6-495A-9DE2-20EC10EE8963}.Debug|Mixed Platforms.ActiveCfg = Release|Win32 + {507FF69E-32A6-495A-9DE2-20EC10EE8963}.Debug|Mixed Platforms.Build.0 = Release|Win32 + {507FF69E-32A6-495A-9DE2-20EC10EE8963}.Debug|Win32.ActiveCfg = Debug|Win32 + {507FF69E-32A6-495A-9DE2-20EC10EE8963}.Debug|Win32.Build.0 = Debug|Win32 + {507FF69E-32A6-495A-9DE2-20EC10EE8963}.Debug|x64.ActiveCfg = Debug|Win32 + {507FF69E-32A6-495A-9DE2-20EC10EE8963}.Release|Any CPU.ActiveCfg = Release|Win32 + {507FF69E-32A6-495A-9DE2-20EC10EE8963}.Release|Mixed Platforms.ActiveCfg = Release|Win32 + {507FF69E-32A6-495A-9DE2-20EC10EE8963}.Release|Mixed Platforms.Build.0 = Release|Win32 + {507FF69E-32A6-495A-9DE2-20EC10EE8963}.Release|Win32.ActiveCfg = Release|Win32 + {507FF69E-32A6-495A-9DE2-20EC10EE8963}.Release|Win32.Build.0 = Release|Win32 + {507FF69E-32A6-495A-9DE2-20EC10EE8963}.Release|x64.ActiveCfg = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE