Marcus Cuda
16 years ago
42 changed files with 19297 additions and 34 deletions
@ -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); |
|||
} |
|||
@ -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 |
|||
|
|||
@ -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 <stdio.h> |
|||
#include <stdlib.h> |
|||
#include <string.h> |
|||
#include <unistd.h> |
|||
|
|||
#ifdef OS_LINUX |
|||
#include <malloc.h> |
|||
#include <sched.h> |
|||
#endif |
|||
|
|||
#ifdef OS_WINDOWS |
|||
#ifdef ATOM |
|||
#define GOTO_ATOM ATOM |
|||
#undef ATOM |
|||
#endif |
|||
#include <windows.h> |
|||
#include <math.h> |
|||
#ifdef GOTO_ATOM |
|||
#define ATOM GOTO_ATOM |
|||
#undef GOTO_ATOM |
|||
#endif |
|||
#else |
|||
#include <sys/mman.h> |
|||
#include <sys/shm.h> |
|||
#include <sys/time.h> |
|||
#include <unistd.h> |
|||
#include <math.h> |
|||
#ifdef SMP |
|||
#include <pthread.h> |
|||
#endif |
|||
#endif |
|||
|
|||
#if defined(OS_SUNOS) |
|||
#include <thread.h> |
|||
#endif |
|||
|
|||
#ifdef __DECC |
|||
#include <c_asm.h> |
|||
#include <machine/builtins.h> |
|||
#endif |
|||
|
|||
#if defined(ARCH_IA64) && defined(ENABLE_SSE_EXCEPTION) |
|||
#include <fenv.h> |
|||
#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<b? b:a) |
|||
#endif |
|||
|
|||
#define TOUPPER(a) {if ((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 |
|||
@ -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 |
|||
@ -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 |
|||
@ -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 |
|||
@ -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 <ia64intrin.h> |
|||
#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 |
|||
@ -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 |
|||
@ -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 |
|||
@ -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 |
|||
|
|||
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -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 <syscall.h> |
|||
|
|||
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 |
|||
File diff suppressed because it is too large
@ -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 |
|||
File diff suppressed because it is too large
@ -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 |
|||
@ -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 |
|||
@ -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 |
|||
@ -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 |
|||
@ -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 |
|||
@ -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 |
|||
@ -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 |
|||
@ -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 |
|||
@ -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 |
|||
@ -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 |
|||
@ -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) |
|||
|
|||
@ -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 |
|||
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -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 <kgoto@tacc.utexas.edu>" |
|||
#endif |
|||
@ -0,0 +1,163 @@ |
|||
<?xml version="1.0" encoding="utf-8"?> |
|||
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
|||
<ItemGroup Label="ProjectConfigurations"> |
|||
<ProjectConfiguration Include="Debug|Win32"> |
|||
<Configuration>Debug</Configuration> |
|||
<Platform>Win32</Platform> |
|||
</ProjectConfiguration> |
|||
<ProjectConfiguration Include="Debug|x64"> |
|||
<Configuration>Debug</Configuration> |
|||
<Platform>x64</Platform> |
|||
</ProjectConfiguration> |
|||
<ProjectConfiguration Include="Release|Win32"> |
|||
<Configuration>Release</Configuration> |
|||
<Platform>Win32</Platform> |
|||
</ProjectConfiguration> |
|||
<ProjectConfiguration Include="Release|x64"> |
|||
<Configuration>Release</Configuration> |
|||
<Platform>x64</Platform> |
|||
</ProjectConfiguration> |
|||
</ItemGroup> |
|||
<PropertyGroup Label="Globals"> |
|||
<ProjectGuid>{507FF69E-32A6-495A-9DE2-20EC10EE8963}</ProjectGuid> |
|||
<Keyword>Win32Proj</Keyword> |
|||
<RootNamespace>GotoBLAS2Wrapper</RootNamespace> |
|||
</PropertyGroup> |
|||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" /> |
|||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration"> |
|||
<ConfigurationType>DynamicLibrary</ConfigurationType> |
|||
<UseDebugLibraries>true</UseDebugLibraries> |
|||
<CharacterSet>Unicode</CharacterSet> |
|||
</PropertyGroup> |
|||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration"> |
|||
<ConfigurationType>DynamicLibrary</ConfigurationType> |
|||
<UseDebugLibraries>true</UseDebugLibraries> |
|||
<CharacterSet>Unicode</CharacterSet> |
|||
</PropertyGroup> |
|||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration"> |
|||
<ConfigurationType>DynamicLibrary</ConfigurationType> |
|||
<UseDebugLibraries>false</UseDebugLibraries> |
|||
<WholeProgramOptimization>true</WholeProgramOptimization> |
|||
<CharacterSet>Unicode</CharacterSet> |
|||
</PropertyGroup> |
|||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration"> |
|||
<ConfigurationType>DynamicLibrary</ConfigurationType> |
|||
<UseDebugLibraries>false</UseDebugLibraries> |
|||
<WholeProgramOptimization>true</WholeProgramOptimization> |
|||
<CharacterSet>Unicode</CharacterSet> |
|||
</PropertyGroup> |
|||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" /> |
|||
<ImportGroup Label="ExtensionSettings"> |
|||
</ImportGroup> |
|||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> |
|||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> |
|||
</ImportGroup> |
|||
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets"> |
|||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> |
|||
</ImportGroup> |
|||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> |
|||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> |
|||
</ImportGroup> |
|||
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets"> |
|||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> |
|||
</ImportGroup> |
|||
<PropertyGroup Label="UserMacros" /> |
|||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> |
|||
<LinkIncremental>true</LinkIncremental> |
|||
</PropertyGroup> |
|||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> |
|||
<LinkIncremental>true</LinkIncremental> |
|||
</PropertyGroup> |
|||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> |
|||
<LinkIncremental>false</LinkIncremental> |
|||
</PropertyGroup> |
|||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> |
|||
<LinkIncremental>false</LinkIncremental> |
|||
</PropertyGroup> |
|||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> |
|||
<ClCompile> |
|||
<PrecompiledHeader>NotUsing</PrecompiledHeader> |
|||
<WarningLevel>Level3</WarningLevel> |
|||
<Optimization>Disabled</Optimization> |
|||
<PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;GOTOBLAS2WRAPPER_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions> |
|||
<AdditionalIncludeDirectories>..\..\Common;.\include;</AdditionalIncludeDirectories> |
|||
</ClCompile> |
|||
<Link> |
|||
<SubSystem>Windows</SubSystem> |
|||
<GenerateDebugInformation>true</GenerateDebugInformation> |
|||
<AdditionalLibraryDirectories>..\..\..\..\lib\GotoBLAS2;</AdditionalLibraryDirectories> |
|||
<AdditionalDependencies>libgoto2_core2p-r1.13_x86.lib;%(AdditionalDependencies)</AdditionalDependencies> |
|||
</Link> |
|||
</ItemDefinitionGroup> |
|||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> |
|||
<ClCompile> |
|||
<PrecompiledHeader>NotUsing</PrecompiledHeader> |
|||
<WarningLevel>Level3</WarningLevel> |
|||
<Optimization>Disabled</Optimization> |
|||
<PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;GOTOBLAS2WRAPPER_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions> |
|||
<AdditionalIncludeDirectories>..\..\Common;.\include;</AdditionalIncludeDirectories> |
|||
</ClCompile> |
|||
<Link> |
|||
<SubSystem>Windows</SubSystem> |
|||
<GenerateDebugInformation>true</GenerateDebugInformation> |
|||
<AdditionalLibraryDirectories>..\..\..\..\lib\GotoBLAS2;</AdditionalLibraryDirectories> |
|||
<AdditionalDependencies>libgoto2_core2p-r1.13_x86_64.lib;%(AdditionalDependencies)</AdditionalDependencies> |
|||
</Link> |
|||
</ItemDefinitionGroup> |
|||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> |
|||
<ClCompile> |
|||
<WarningLevel>Level3</WarningLevel> |
|||
<PrecompiledHeader>NotUsing</PrecompiledHeader> |
|||
<Optimization>MaxSpeed</Optimization> |
|||
<FunctionLevelLinking>true</FunctionLevelLinking> |
|||
<IntrinsicFunctions>true</IntrinsicFunctions> |
|||
<PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;GOTOBLAS2WRAPPER_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions> |
|||
<AdditionalIncludeDirectories>..\..\Common;.\include;</AdditionalIncludeDirectories> |
|||
</ClCompile> |
|||
<Link> |
|||
<SubSystem>Windows</SubSystem> |
|||
<GenerateDebugInformation>true</GenerateDebugInformation> |
|||
<EnableCOMDATFolding>true</EnableCOMDATFolding> |
|||
<OptimizeReferences>true</OptimizeReferences> |
|||
<AdditionalLibraryDirectories>..\..\..\..\lib\GotoBLAS2;</AdditionalLibraryDirectories> |
|||
<AdditionalDependencies>libgoto2_core2p-r1.13_x86.lib;%(AdditionalDependencies)</AdditionalDependencies> |
|||
</Link> |
|||
</ItemDefinitionGroup> |
|||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> |
|||
<ClCompile> |
|||
<WarningLevel>Level3</WarningLevel> |
|||
<PrecompiledHeader>NotUsing</PrecompiledHeader> |
|||
<Optimization>MaxSpeed</Optimization> |
|||
<FunctionLevelLinking>true</FunctionLevelLinking> |
|||
<IntrinsicFunctions>true</IntrinsicFunctions> |
|||
<PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;GOTOBLAS2WRAPPER_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions> |
|||
<AdditionalIncludeDirectories>..\..\Common;.\include;</AdditionalIncludeDirectories> |
|||
</ClCompile> |
|||
<Link> |
|||
<SubSystem>Windows</SubSystem> |
|||
<GenerateDebugInformation>true</GenerateDebugInformation> |
|||
<EnableCOMDATFolding>true</EnableCOMDATFolding> |
|||
<OptimizeReferences>true</OptimizeReferences> |
|||
<AdditionalLibraryDirectories>..\..\..\..\lib\GotoBLAS2;</AdditionalLibraryDirectories> |
|||
<AdditionalDependencies>libgoto2_core2p-r1.13_x86_64.lib;%(AdditionalDependencies)</AdditionalDependencies> |
|||
</Link> |
|||
</ItemDefinitionGroup> |
|||
<ItemGroup> |
|||
<ResourceCompile Include="..\..\Common\resource.rc" /> |
|||
</ItemGroup> |
|||
<ItemGroup> |
|||
<ClInclude Include="..\..\Common\wrapper_common.h" /> |
|||
</ItemGroup> |
|||
<ItemGroup> |
|||
<ClCompile Include="..\..\Common\WindowsDLL.cpp" /> |
|||
<ClCompile Include="..\..\GotoBlas2\blas.c"> |
|||
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">..\..\Common;</AdditionalIncludeDirectories> |
|||
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">..\..\Common;</AdditionalIncludeDirectories> |
|||
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">..\..\Common;</AdditionalIncludeDirectories> |
|||
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|x64'">..\..\Common;</AdditionalIncludeDirectories> |
|||
</ClCompile> |
|||
</ItemGroup> |
|||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> |
|||
<ImportGroup Label="ExtensionTargets"> |
|||
</ImportGroup> |
|||
</Project> |
|||
@ -0,0 +1,35 @@ |
|||
<?xml version="1.0" encoding="utf-8"?> |
|||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
|||
<ItemGroup> |
|||
<Filter Include="Source Files"> |
|||
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier> |
|||
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions> |
|||
</Filter> |
|||
<Filter Include="Header Files"> |
|||
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier> |
|||
<Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions> |
|||
</Filter> |
|||
<Filter Include="Resource Files"> |
|||
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier> |
|||
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions> |
|||
</Filter> |
|||
</ItemGroup> |
|||
<ItemGroup> |
|||
<ResourceCompile Include="..\..\Common\resource.rc"> |
|||
<Filter>Resource Files</Filter> |
|||
</ResourceCompile> |
|||
</ItemGroup> |
|||
<ItemGroup> |
|||
<ClInclude Include="..\..\Common\wrapper_common.h"> |
|||
<Filter>Header Files</Filter> |
|||
</ClInclude> |
|||
</ItemGroup> |
|||
<ItemGroup> |
|||
<ClCompile Include="..\..\Common\WindowsDLL.cpp"> |
|||
<Filter>Source Files</Filter> |
|||
</ClCompile> |
|||
<ClCompile Include="..\..\GotoBlas2\blas.c"> |
|||
<Filter>Source Files</Filter> |
|||
</ClCompile> |
|||
</ItemGroup> |
|||
</Project> |
|||
Loading…
Reference in new issue