aadityansha06
2c6bf39e4e
Extends GEADD to support independent transposition of both A and C, matching the behavior of cuBLAS's geam and Apple's Accelerate geadd. Previously only A could be transposed. - Add transc parameter across cblas.h, common_interface.h, common_level3.h, common_param.h - Add transc handling to interface/geadd.c and interface/zgeadd.c - Extend kernel/generic/geadd.c and kernel/generic/zgeadd.c with stride logic for transposed C - Add transpose test coverage (hand-verified 2x2 cases and randomized large-matrix tests) for sgeadd, dgeadd, cgeadd, zgeadd
959 lines
24 KiB
C
959 lines
24 KiB
C
/*****************************************************************************
|
|
Copyright (c) 2023, The OpenBLAS Project
|
|
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.
|
|
3. Neither the name of the OpenBLAS project nor the names of
|
|
its contributors may be used to endorse or promote products
|
|
derived from this software without specific prior written
|
|
permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
|
|
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
|
|
THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
**********************************************************************************/
|
|
|
|
#include "common.h"
|
|
#include "utest/openblas_utest.h"
|
|
|
|
#define N 100
|
|
#define M 100
|
|
|
|
struct DATA_DGEADD {
|
|
double a_test[M * N];
|
|
double c_test[M * N];
|
|
double c_verify[M * N];
|
|
};
|
|
|
|
#ifdef BUILD_DOUBLE
|
|
static struct DATA_DGEADD data_dgeadd;
|
|
|
|
/**
|
|
* dgeadd reference implementation
|
|
*
|
|
* param m - number of rows of A and C
|
|
* param n - number of columns of A and C
|
|
* param alpha - scaling factor for matrix A
|
|
* param aptr - refer to matrix A
|
|
* param lda - leading dimension of A
|
|
* param beta - scaling factor for matrix C
|
|
* param cptr - refer to matrix C
|
|
* param ldc - leading dimension of C
|
|
* param transa - Traspose of A
|
|
* param transc - Transpose of C
|
|
*/
|
|
static void dgeadd_trusted(blasint m, blasint n, double alpha, double *aptr,
|
|
blasint lda, double beta, double *cptr,
|
|
blasint ldc, OPENBLAS_CONST enum CBLAS_TRANSPOSE transa,
|
|
OPENBLAS_CONST enum CBLAS_TRANSPOSE transc) {
|
|
blasint i;
|
|
blasint inc_a = (transa == CblasTrans) ? lda : 1;
|
|
blasint inc_c = (transc == CblasTrans) ? ldc : 1;
|
|
|
|
|
|
blasint step_a = (transa == CblasTrans) ? 1 : lda;
|
|
blasint step_c = (transc == CblasTrans) ? 1 : ldc;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
BLASFUNC(daxpby)(&m, &alpha, aptr, &inc_a, &beta, cptr, &inc_c);
|
|
aptr += step_a;
|
|
cptr += step_c;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test dgeadd by comparing it against reference
|
|
* Compare with the following options:
|
|
*
|
|
* param api - specifies Fortran or C API
|
|
* param order - specifies whether A and C stored in
|
|
* param transa - Traspose of A
|
|
* param transc - Transpose of C
|
|
* row-major order or column-major order
|
|
* param m - number of rows of A and C
|
|
* param n - number of columns of A and C
|
|
* param alpha - scaling factor for matrix A
|
|
* param lda - leading dimension of A
|
|
* param beta - scaling factor for matrix C
|
|
* param ldc - leading dimension of C
|
|
* return norm of differences
|
|
*/
|
|
static double check_dgeadd(char api, OPENBLAS_CONST enum CBLAS_ORDER order,
|
|
OPENBLAS_CONST enum CBLAS_TRANSPOSE transa,
|
|
OPENBLAS_CONST enum CBLAS_TRANSPOSE transc,
|
|
blasint m, blasint n, double alpha, blasint lda,
|
|
double beta, blasint ldc) {
|
|
blasint i;
|
|
blasint cols = m, rows = n;
|
|
|
|
if (order == CblasRowMajor) {
|
|
rows = m;
|
|
cols = n;
|
|
}
|
|
|
|
// Fill matrix A, C
|
|
drand_generate(data_dgeadd.a_test, lda * rows);
|
|
drand_generate(data_dgeadd.c_test, ldc * rows);
|
|
|
|
// Copy matrix C for dgeadd
|
|
for (i = 0; i < ldc * rows; i++)
|
|
data_dgeadd.c_verify[i] = data_dgeadd.c_test[i];
|
|
|
|
dgeadd_trusted(cols, rows, alpha, data_dgeadd.a_test, lda, beta,
|
|
data_dgeadd.c_verify, ldc,transa, transc);
|
|
|
|
if (api == 'F'){
|
|
char transa_f = (transa == CblasTrans) ? 'T' : 'N';
|
|
char transc_f = (transc == CblasTrans) ? 'T' : 'N';
|
|
|
|
|
|
BLASFUNC(dgeadd)(&m, &n, &alpha, data_dgeadd.a_test, &lda, &beta,
|
|
data_dgeadd.c_test, &ldc, &transa_f,&transc_f);
|
|
|
|
}
|
|
#ifndef NO_CBLAS
|
|
else
|
|
cblas_dgeadd(order,transa,transc, m, n, alpha, data_dgeadd.a_test, lda, beta,
|
|
data_dgeadd.c_test, ldc);
|
|
#endif
|
|
|
|
// Find the differences between output matrix caculated by dgeadd and sgemm
|
|
return dmatrix_difference(data_dgeadd.c_test, data_dgeadd.c_verify, cols,
|
|
rows, ldc);
|
|
}
|
|
|
|
/**
|
|
* Check if error function was called with expected function name
|
|
* and param info
|
|
*
|
|
* param api - specifies Fortran or C API
|
|
* param order - specifies whether A and C stored in
|
|
* param transa - Traspose of A
|
|
* param transc - Transpose of C
|
|
* row-major order or column-major order
|
|
* param m - number of rows of A and C
|
|
* param n - number of columns of A and C
|
|
* param lda - leading dimension of A
|
|
* param ldc - leading dimension of C
|
|
* param expected_info - expected invalid parameter number in dgeadd
|
|
* return TRUE if everything is ok, otherwise FALSE
|
|
*/
|
|
static int check_badargs(char api, OPENBLAS_CONST enum CBLAS_ORDER order,
|
|
OPENBLAS_CONST enum CBLAS_TRANSPOSE transa,
|
|
OPENBLAS_CONST enum CBLAS_TRANSPOSE transc,
|
|
blasint m, blasint n, blasint lda, blasint ldc,
|
|
int expected_info) {
|
|
double alpha = 1.0;
|
|
double beta = 1.0;
|
|
|
|
set_xerbla("DGEADD ", expected_info);
|
|
|
|
if (api == 'F'){
|
|
char transa_f = (transa == CblasTrans) ? 'T' : 'N';
|
|
char transc_f = (transc == CblasTrans) ? 'T' : 'N';
|
|
BLASFUNC(dgeadd)(&m, &n, &alpha, data_dgeadd.a_test, &lda, &beta,
|
|
data_dgeadd.c_test, &ldc,&transa_f, &transc_f);
|
|
|
|
}
|
|
#ifndef NO_CBLAS
|
|
else
|
|
cblas_dgeadd(order, transa, transc, m, n, alpha, data_dgeadd.a_test, lda, beta,
|
|
data_dgeadd.c_test, ldc);
|
|
#endif
|
|
|
|
return check_error();
|
|
}
|
|
|
|
/**
|
|
* Fortran API specific test
|
|
* Test dgeadd by comparing it against reference
|
|
* with the following options:
|
|
*
|
|
* For A number of rows is 100, number of colums is 100
|
|
* For C number of rows is 100, number of colums is 100
|
|
*/
|
|
CTEST(dgeadd, matrix_n_100_m_100) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = N;
|
|
blasint m = M;
|
|
|
|
blasint lda = m;
|
|
blasint ldc = m;
|
|
|
|
double alpha = 3.0;
|
|
double beta = 3.0;
|
|
|
|
double norm = check_dgeadd('F', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
/**
|
|
* Fortran API specific test
|
|
* Test dgeadd by comparing it against reference
|
|
* with the following options:
|
|
*
|
|
* For A number of rows is 100, number of colums is 100
|
|
* For C number of rows is 100, number of colums is 100
|
|
* Scalar alpha is zero (operation is C:=beta*C)
|
|
*/
|
|
CTEST(dgeadd, matrix_n_100_m_100_alpha_zero) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = N;
|
|
blasint m = M;
|
|
|
|
blasint lda = m;
|
|
blasint ldc = m;
|
|
|
|
double alpha = 0.0;
|
|
double beta = 2.5;
|
|
|
|
double norm = check_dgeadd('F', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
/**
|
|
* Fortran API specific test
|
|
* Test dgeadd by comparing it against reference
|
|
* with the following options:
|
|
*
|
|
* For A number of rows is 100, number of colums is 100
|
|
* For C number of rows is 100, number of colums is 100
|
|
* Scalar beta is zero (operation is C:=alpha*A)
|
|
*/
|
|
CTEST(dgeadd, matrix_n_100_m_100_beta_zero) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = N;
|
|
blasint m = M;
|
|
|
|
blasint lda = m;
|
|
blasint ldc = m;
|
|
|
|
double alpha = 3.0;
|
|
double beta = 0.0;
|
|
|
|
double norm = check_dgeadd('F', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
/**
|
|
* Fortran API specific test
|
|
* Test dgeadd by comparing it against reference
|
|
* with the following options:
|
|
*
|
|
* For A number of rows is 100, number of colums is 100
|
|
* For C number of rows is 100, number of colums is 100
|
|
* Scalars alpha, beta is zero (operation is C:= 0)
|
|
*/
|
|
CTEST(dgeadd, matrix_n_100_m_100_alpha_beta_zero) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = N;
|
|
blasint m = M;
|
|
|
|
blasint lda = m;
|
|
blasint ldc = m;
|
|
|
|
double alpha = 0.0;
|
|
double beta = 0.0;
|
|
|
|
double norm = check_dgeadd('F', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
/**
|
|
* Fortran API specific test
|
|
* Test dgeadd by comparing it against reference
|
|
* with the following options:
|
|
*
|
|
* For A number of rows is 50, number of colums is 100
|
|
* For C number of rows is 50, number of colums is 100
|
|
*/
|
|
CTEST(dgeadd, matrix_n_100_m_50) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = N;
|
|
blasint m = M / 2;
|
|
|
|
blasint lda = m;
|
|
blasint ldc = m;
|
|
|
|
double alpha = 1.0;
|
|
double beta = 1.0;
|
|
|
|
double norm = check_dgeadd('F', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
/**
|
|
* Fortran API specific test
|
|
* Test error function for an invalid param n -
|
|
* number of columns of A and C
|
|
* Must be at least zero.
|
|
*/
|
|
CTEST(dgeadd, xerbla_n_invalid) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = INVALID;
|
|
blasint m = 1;
|
|
|
|
blasint lda = m;
|
|
blasint ldc = m;
|
|
|
|
int expected_info = 2;
|
|
|
|
int passed = check_badargs('F', order,CblasNoTrans, CblasNoTrans, m, n, lda, ldc, expected_info);
|
|
ASSERT_EQUAL(TRUE, passed);
|
|
}
|
|
|
|
/**
|
|
* Fortran API specific test
|
|
* Test error function for an invalid param m -
|
|
* number of rows of A and C
|
|
* Must be at least zero.
|
|
*/
|
|
CTEST(dgeadd, xerbla_m_invalid) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = 1;
|
|
blasint m = INVALID;
|
|
|
|
blasint lda = 1;
|
|
blasint ldc = 1;
|
|
|
|
int expected_info = 1;
|
|
|
|
int passed = check_badargs('F', order,CblasNoTrans, CblasNoTrans, m, n, lda, ldc, expected_info);
|
|
ASSERT_EQUAL(TRUE, passed);
|
|
}
|
|
|
|
/**
|
|
* Fortran API specific test
|
|
* Test error function for an invalid param lda -
|
|
* specifies the leading dimension of A. Must be at least MAX(1, m).
|
|
*/
|
|
CTEST(dgeadd, xerbla_lda_invalid) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = 1;
|
|
blasint m = 1;
|
|
|
|
blasint lda = INVALID;
|
|
blasint ldc = 1;
|
|
|
|
int expected_info = 5;
|
|
|
|
int passed = check_badargs('F', order,CblasNoTrans, CblasNoTrans, m, n, lda, ldc, expected_info);
|
|
ASSERT_EQUAL(TRUE, passed);
|
|
}
|
|
|
|
/**
|
|
* Fortran API specific test
|
|
* Test error function for an invalid param ldc -
|
|
* specifies the leading dimension of C. Must be at least MAX(1, m).
|
|
*/
|
|
CTEST(dgeadd, xerbla_ldc_invalid) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = 1;
|
|
blasint m = 1;
|
|
|
|
blasint lda = 1;
|
|
blasint ldc = INVALID;
|
|
|
|
int expected_info = 8;
|
|
|
|
int passed = check_badargs('F', order,CblasNoTrans, CblasNoTrans, m, n, lda, ldc, expected_info);
|
|
ASSERT_EQUAL(TRUE, passed);
|
|
}
|
|
|
|
/**
|
|
* Fortran API specific test
|
|
* Check if n - number of columns of A, C equal zero.
|
|
*/
|
|
CTEST(dgeadd, n_zero) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = 0;
|
|
blasint m = 1;
|
|
|
|
blasint lda = 1;
|
|
blasint ldc = 1;
|
|
|
|
double alpha = 1.0;
|
|
double beta = 1.0;
|
|
|
|
double norm = check_dgeadd('F', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
/**
|
|
* Fortran API specific test
|
|
* Check if m - number of rows of A and C equal zero.
|
|
*/
|
|
CTEST(dgeadd, m_zero) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = 1;
|
|
blasint m = 0;
|
|
|
|
blasint lda = 1;
|
|
blasint ldc = 1;
|
|
|
|
double alpha = 1.0;
|
|
double beta = 1.0;
|
|
|
|
double norm = check_dgeadd('F', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
#ifndef NO_CBLAS
|
|
/**
|
|
* C API specific test
|
|
* Test dgeadd by comparing it against reference
|
|
* with the following options:
|
|
*
|
|
* c api option order is column-major order
|
|
*
|
|
* For A number of rows is 100, number of colums is 100
|
|
* For C number of rows is 100, number of colums is 100
|
|
*/
|
|
CTEST(dgeadd, c_api_matrix_n_100_m_100) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = N;
|
|
blasint m = M;
|
|
|
|
blasint lda = m;
|
|
blasint ldc = m;
|
|
|
|
double alpha = 2.0;
|
|
double beta = 3.0;
|
|
|
|
double norm = check_dgeadd('C', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Test dgeadd by comparing it against reference
|
|
* with the following options:
|
|
*
|
|
* c api option order is row-major order
|
|
* For A number of rows is 100, number of colums is 100
|
|
* For C number of rows is 100, number of colums is 100
|
|
*/
|
|
CTEST(dgeadd, c_api_matrix_n_100_m_100_row_major) {
|
|
CBLAS_ORDER order = CblasRowMajor;
|
|
|
|
blasint n = N;
|
|
blasint m = M;
|
|
|
|
blasint lda = m;
|
|
blasint ldc = m;
|
|
|
|
double alpha = 4.0;
|
|
double beta = 2.0;
|
|
|
|
double norm = check_dgeadd('C', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Test dgeadd by comparing it against reference
|
|
* with the following options:
|
|
*
|
|
* c api option order is row-major order
|
|
* For A number of rows is 50, number of colums is 100
|
|
* For C number of rows is 50, number of colums is 100
|
|
*/
|
|
CTEST(dgeadd, c_api_matrix_n_50_m_100_row_major) {
|
|
CBLAS_ORDER order = CblasRowMajor;
|
|
|
|
blasint n = N / 2;
|
|
blasint m = M;
|
|
|
|
blasint lda = n;
|
|
blasint ldc = n;
|
|
|
|
double alpha = 3.0;
|
|
double beta = 1.0;
|
|
|
|
double norm = check_dgeadd('C', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Test dgeadd by comparing it against reference
|
|
* with the following options:
|
|
*
|
|
* c api option order is column-major order
|
|
* For A number of rows is 100, number of colums is 100
|
|
* For C number of rows is 100, number of colums is 100
|
|
* Scalar alpha is zero (operation is C:=beta*C)
|
|
*/
|
|
CTEST(dgeadd, c_api_matrix_n_100_m_100_alpha_zero) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = N;
|
|
blasint m = M;
|
|
|
|
blasint lda = m;
|
|
blasint ldc = m;
|
|
|
|
double alpha = 0.0;
|
|
double beta = 1.0;
|
|
|
|
double norm = check_dgeadd('C', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Test dgeadd by comparing it against reference
|
|
* with the following options:
|
|
*
|
|
* c api option order is column-major order
|
|
* For A number of rows is 100, number of colums is 100
|
|
* For C number of rows is 100, number of colums is 100
|
|
* Scalar beta is zero (operation is C:=alpha*A)
|
|
*/
|
|
CTEST(dgeadd, c_api_matrix_n_100_m_100_beta_zero) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = N;
|
|
blasint m = M;
|
|
|
|
blasint lda = m;
|
|
blasint ldc = m;
|
|
|
|
double alpha = 3.0;
|
|
double beta = 0.0;
|
|
|
|
double norm = check_dgeadd('C', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Test dgeadd by comparing it against reference
|
|
* with the following options:
|
|
*
|
|
* c api option order is column-major order
|
|
* For A number of rows is 100, number of colums is 100
|
|
* For C number of rows is 100, number of colums is 100
|
|
* Scalars alpha, beta is zero (operation is C:= 0)
|
|
*/
|
|
CTEST(dgeadd, c_api_matrix_n_100_m_100_alpha_beta_zero) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = N;
|
|
blasint m = M;
|
|
|
|
blasint lda = m;
|
|
blasint ldc = m;
|
|
|
|
double alpha = 0.0;
|
|
double beta = 0.0;
|
|
|
|
double norm = check_dgeadd('C', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Test dgeadd by comparing it against reference
|
|
* with the following options:
|
|
*
|
|
* For A number of rows is 50, number of colums is 100
|
|
* For C number of rows is 50, number of colums is 100
|
|
*/
|
|
CTEST(dgeadd, c_api_matrix_n_100_m_50) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = N;
|
|
blasint m = M / 2;
|
|
|
|
blasint lda = m;
|
|
blasint ldc = m;
|
|
|
|
double alpha = 3.0;
|
|
double beta = 4.0;
|
|
|
|
double norm = check_dgeadd('C', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Test error function for an invalid param order -
|
|
* specifies whether A and C stored in
|
|
* row-major order or column-major order
|
|
*/
|
|
CTEST(dgeadd, c_api_xerbla_invalid_order) {
|
|
CBLAS_ORDER order = INVALID;
|
|
|
|
blasint n = 1;
|
|
blasint m = 1;
|
|
|
|
blasint lda = 1;
|
|
blasint ldc = 1;
|
|
|
|
int expected_info = 0;
|
|
|
|
int passed = check_badargs('C', order,CblasNoTrans, CblasNoTrans, m, n, lda, ldc, expected_info);
|
|
ASSERT_EQUAL(TRUE, passed);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Test error function for an invalid param n -
|
|
* number of columns of A and C.
|
|
* Must be at least zero.
|
|
*
|
|
* c api option order is column-major order
|
|
*/
|
|
CTEST(dgeadd, c_api_xerbla_n_invalid) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = INVALID;
|
|
blasint m = 1;
|
|
|
|
blasint lda = 1;
|
|
blasint ldc = 1;
|
|
|
|
int expected_info = 2;
|
|
|
|
int passed = check_badargs('C', order,CblasNoTrans, CblasNoTrans, m, n, lda, ldc, expected_info);
|
|
ASSERT_EQUAL(TRUE, passed);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Test error function for an invalid param n -
|
|
* number of columns of A and C.
|
|
* Must be at least zero.
|
|
*
|
|
* c api option order is row-major order
|
|
*/
|
|
CTEST(dgeadd, c_api_xerbla_n_invalid_row_major) {
|
|
CBLAS_ORDER order = CblasRowMajor;
|
|
|
|
blasint n = INVALID;
|
|
blasint m = 1;
|
|
|
|
blasint lda = 1;
|
|
blasint ldc = 1;
|
|
|
|
int expected_info = 2;
|
|
|
|
int passed = check_badargs('C', order,CblasNoTrans, CblasNoTrans, m, n, lda, ldc, expected_info);
|
|
ASSERT_EQUAL(TRUE, passed);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Test error function for an invalid param m -
|
|
* number of rows of A and C
|
|
* Must be at least zero.
|
|
*
|
|
* c api option order is column-major order
|
|
*/
|
|
CTEST(dgeadd, c_api_xerbla_m_invalid) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = 1;
|
|
blasint m = INVALID;
|
|
|
|
blasint lda = 1;
|
|
blasint ldc = 1;
|
|
|
|
int expected_info = 1;
|
|
|
|
int passed = check_badargs('C', order,CblasNoTrans, CblasNoTrans, m, n, lda, ldc, expected_info);
|
|
ASSERT_EQUAL(TRUE, passed);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Test error function for an invalid param m -
|
|
* number of rows of A and C
|
|
* Must be at least zero.
|
|
*
|
|
* c api option order is row-major order
|
|
*/
|
|
CTEST(dgeadd, c_api_xerbla_m_invalid_row_major) {
|
|
CBLAS_ORDER order = CblasRowMajor;
|
|
|
|
blasint n = 1;
|
|
blasint m = INVALID;
|
|
|
|
blasint lda = 1;
|
|
blasint ldc = 1;
|
|
|
|
int expected_info = 1;
|
|
|
|
int passed = check_badargs('C', order,CblasNoTrans, CblasNoTrans, m, n, lda, ldc, expected_info);
|
|
ASSERT_EQUAL(TRUE, passed);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Test error function for an invalid param lda -
|
|
* specifies the leading dimension of A. Must be at least MAX(1, m).
|
|
*
|
|
* c api option order is column-major order
|
|
*/
|
|
CTEST(dgeadd, c_api_xerbla_lda_invalid) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = 1;
|
|
blasint m = 1;
|
|
|
|
blasint lda = INVALID;
|
|
blasint ldc = 1;
|
|
|
|
int expected_info = 5;
|
|
|
|
int passed = check_badargs('C', order,CblasNoTrans, CblasNoTrans, m, n, lda, ldc, expected_info);
|
|
ASSERT_EQUAL(TRUE, passed);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Test error function for an invalid param lda -
|
|
* specifies the leading dimension of A. Must be at least MAX(1, m).
|
|
*
|
|
* c api option order is row-major order
|
|
*/
|
|
CTEST(dgeadd, c_api_xerbla_lda_invalid_row_major) {
|
|
CBLAS_ORDER order = CblasRowMajor;
|
|
|
|
blasint n = 1;
|
|
blasint m = 1;
|
|
|
|
blasint lda = INVALID;
|
|
blasint ldc = 1;
|
|
|
|
int expected_info = 5;
|
|
|
|
int passed = check_badargs('C', order,CblasNoTrans, CblasNoTrans, m, n, lda, ldc, expected_info);
|
|
ASSERT_EQUAL(TRUE, passed);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Test error function for an invalid param ldc -
|
|
* specifies the leading dimension of C. Must be at least MAX(1, m).
|
|
*
|
|
* c api option order is column-major order
|
|
*/
|
|
CTEST(dgeadd, c_api_xerbla_ldc_invalid) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = 1;
|
|
blasint m = 1;
|
|
|
|
blasint lda = 1;
|
|
blasint ldc = INVALID;
|
|
|
|
int expected_info = 8;
|
|
|
|
int passed = check_badargs('C', order,CblasNoTrans, CblasNoTrans, m, n, lda, ldc, expected_info);
|
|
ASSERT_EQUAL(TRUE, passed);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Test error function for an invalid param ldc -
|
|
* specifies the leading dimension of C. Must be at least MAX(1, m).
|
|
*
|
|
* c api option order is row-major order
|
|
*/
|
|
CTEST(dgeadd, c_api_xerbla_ldc_invalid_row_major) {
|
|
CBLAS_ORDER order = CblasRowMajor;
|
|
|
|
blasint n = 1;
|
|
blasint m = 1;
|
|
|
|
blasint lda = 1;
|
|
blasint ldc = INVALID;
|
|
|
|
int expected_info = 8;
|
|
|
|
int passed = check_badargs('C', order,CblasNoTrans, CblasNoTrans, m, n, lda, ldc, expected_info);
|
|
ASSERT_EQUAL(TRUE, passed);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Check if n - number of columns of A, C equal zero.
|
|
*
|
|
* c api option order is column-major order
|
|
*/
|
|
CTEST(dgeadd, c_api_n_zero) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = 0;
|
|
blasint m = 1;
|
|
|
|
blasint lda = 1;
|
|
blasint ldc = 1;
|
|
|
|
double alpha = 1.0;
|
|
double beta = 1.0;
|
|
|
|
double norm = check_dgeadd('C', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
/**
|
|
* C API specific test
|
|
* Check if m - number of rows of A and C equal zero.
|
|
*
|
|
* c api option order is column-major order
|
|
*/
|
|
|
|
CTEST(dgeadd, c_api_m_zero) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = 1;
|
|
blasint m = 0;
|
|
|
|
blasint lda = 1;
|
|
blasint ldc = 1;
|
|
|
|
double alpha = 1.0;
|
|
double beta = 1.0;
|
|
|
|
double norm = check_dgeadd('C', order,CblasNoTrans, CblasNoTrans, m, n, alpha, lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Custom C API specific test
|
|
* Test A transposed (C = A^T) with a simple 2x2 matrix
|
|
* This verifies the inner stride (lda) jump logic in the bare-metal kernel.
|
|
*/
|
|
|
|
CTEST(dgeadd, c_api_matrix_2x2_transA) {
|
|
blasint m = 2;
|
|
blasint n = 2;
|
|
blasint lda = 2;
|
|
blasint ldc = 2;
|
|
|
|
double alpha = 1.0;
|
|
double beta = 0.0;
|
|
|
|
double a_test[4] = {1.0, 2.0, 3.0, 4.0};
|
|
|
|
double c_test[4] = {0.0, 0.0, 0.0, 0.0};
|
|
double c_verify[4] = {1.0, 3.0, 2.0, 4.0};
|
|
|
|
cblas_dgeadd(CblasColMajor, CblasTrans, CblasNoTrans, m, n, alpha, a_test,
|
|
lda, beta, c_test, ldc);
|
|
|
|
blasint i;
|
|
for (i = 0; i < 4; i++) {
|
|
ASSERT_DBL_NEAR_TOL(c_verify[i], c_test[i], DOUBLE_EPS);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Custom C API specific test
|
|
* Test BOTH transposed (C^T = A^T) with a simple 2x2 matrix
|
|
* This verifies the logic where both inner strides are used.
|
|
*/
|
|
|
|
CTEST(dgeadd, c_api_matrix_2x2_transA_transC) {
|
|
blasint m = 2;
|
|
blasint n = 2;
|
|
blasint lda = 2;
|
|
blasint ldc = 2;
|
|
|
|
double alpha = 1.0;
|
|
double beta = 0.0;
|
|
|
|
double a_test[4] = {1.0, 2.0, 3.0, 4.0};
|
|
|
|
double c_test[4] = {0.0, 0.0, 0.0, 0.0};
|
|
double c_verify[4] = {1.0, 2.0, 3.0, 4.0};
|
|
|
|
cblas_dgeadd(CblasColMajor, CblasTrans, CblasTrans, m, n, alpha, a_test, lda,
|
|
beta, c_test, ldc);
|
|
|
|
blasint i;
|
|
for (i = 0; i < 4; i++) {
|
|
ASSERT_DBL_NEAR_TOL(c_verify[i], c_test[i],DOUBLE_EPS);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* C API specific test - Transposed A (Double Precision)
|
|
* Test A transposed against a large randomized 100x100 matrix
|
|
*/
|
|
|
|
CTEST(dgeadd, c_api_matrix_n_100_m_100_transA) {
|
|
CBLAS_ORDER order = CblasColMajor;
|
|
|
|
blasint n = N;
|
|
blasint m = M;
|
|
|
|
blasint lda = n;
|
|
blasint ldc = m;
|
|
|
|
double alpha = 2.0;
|
|
double beta = 3.0;
|
|
|
|
double norm = check_dgeadd('C', order, CblasTrans, CblasNoTrans, m, n, alpha,
|
|
lda, beta, ldc);
|
|
|
|
ASSERT_DBL_NEAR_TOL(0.0, norm, DOUBLE_EPS);
|
|
}
|
|
|
|
|
|
#endif
|
|
#endif
|