/***************************************************************************//**
Purpose
-------
CGESV solves a system of linear equations
A * X = B
where A is a general N-by-N matrix and X and B are N-by-NRHS matrices.
The LU decomposition without pivoting is
used to factor A as
A = L * U,
where L is unit lower triangular, and U is
upper triangular. The factored form of A is then used to solve the
system of equations A * X = B.
This is a batched version that solves batchCount N-by-N matrices in parallel.
dA, dB, and info become arrays with one entry per matrix.
Arguments
---------
@param[in]
n INTEGER
The order of the matrix A. N >= 0.
@param[in]
nrhs INTEGER
The number of right hand sides, i.e., the number of columns
of the matrix B. NRHS >= 0.
@param[in,out]
dA_array Array of pointers, dimension (batchCount).
Each is a COMPLEX array on the GPU, dimension (LDDA,N).
On entry, each pointer is an M-by-N matrix to be factored.
On exit, the factors L and U from the factorization
A = P*L*U; the unit diagonal elements of L are not stored.
@param[in]
ldda INTEGER
The leading dimension of each array A. LDDA >= max(1,M).
@param[in,out]
dB_array Array of pointers, dimension (batchCount).
Each is a COMPLEX array on the GPU, dimension (LDDB,N).
On entry, each pointer is an right hand side matrix B.
On exit, each pointer is the solution matrix X.
@param[in]
lddb INTEGER
The leading dimension of the array B. LDB >= max(1,N).
@param[out]
info_array Array of INTEGERs, dimension (batchCount), for corresponding matrices.
- = 0: successful exit
- < 0: if INFO = -i, the i-th argument had an illegal value
or another error occured, such as memory allocation failed.
- > 0: if INFO = i, U(i,i) is exactly zero. The factorization
has been completed, but the factor U is exactly
singular, and division by zero will occur if it is used
to solve a system of equations.
@param[in]
batchCount INTEGER
The number of matrices to operate on.
@param[in]
queue magma_queue_t
Queue to execute in.
@ingroup magma_gesv_nopiv_batched
*******************************************************************************/
extern "C" magma_int_t
magma_cgesv_nopiv_batched(
magma_int_t n, magma_int_t nrhs,
magmaFloatComplex **dA_array, magma_int_t ldda,
magmaFloatComplex **dB_array, magma_int_t lddb,
magma_int_t *info_array,
magma_int_t batchCount, magma_queue_t queue)
{
/* Local variables */
magma_int_t info;
info = 0;
if (n < 0) {
info = -1;
} else if (nrhs < 0) {
info = -2;
} else if (ldda < max(1,n)) {
info = -4;
} else if (lddb < max(1,n)) {
info = -6;
}
if (info != 0) {
magma_xerbla( __func__, -(info) );
return info;
}
/* Quick return if possible */
if (n == 0 || nrhs == 0) {
return info;
}
info = magma_cgetrf_nopiv_batched( n, n, dA_array, ldda, info_array, batchCount, queue);
if ( info != MAGMA_SUCCESS ) {
return info;
}
#ifdef CHECK_INFO
// check correctness of results throught "dinfo_magma" and correctness of argument throught "info"
magma_int_t *cpu_info = NULL;
magma_imalloc_cpu( &cpu_info, batchCount );
magma_getvector( batchCount, sizeof(magma_int_t), dinfo_array, 1, cpu_info, 1);
for (magma_int_t i=0; i < batchCount; i++)
{
if (cpu_info[i] != 0 ) {
printf("magma_cgetrf_batched matrix %lld returned error %lld\n", (long long) i, (long long) cpu_info[i] );
info = cpu_info[i];
magma_free_cpu (cpu_info);
return info;
}
}
magma_free_cpu (cpu_info);
#endif
info = magma_cgetrs_nopiv_batched( MagmaNoTrans, n, nrhs, dA_array, ldda, dB_array, lddb, info_array, batchCount, queue );
return info;
}
/* ////////////////////////////////////////////////////////////////////////////
-- Testing cgetrf_batched
*/
int main( int argc, char** argv)
{
TESTING_INIT();
real_Double_t gflops, magma_perf, magma_time, cublas_perf=0., cublas_time=0., cpu_perf=0, cpu_time=0;
float error;
magma_int_t cublas_enable = 0;
magmaFloatComplex *h_A, *h_R;
magmaFloatComplex *dA_magma;
magmaFloatComplex **dA_array = NULL;
magma_int_t **dipiv_array = NULL;
magma_int_t *ipiv, *cpu_info;
magma_int_t *dipiv_magma, *dinfo_magma;
magma_int_t M, N, n2, lda, ldda, min_mn, info;
magma_int_t ione = 1;
magma_int_t ISEED[4] = {0,0,0,1};
magma_int_t batchCount;
magma_int_t status = 0;
magma_opts opts( MagmaOptsBatched );
opts.parse_opts( argc, argv );
//opts.lapack |= opts.check;
batchCount = opts.batchcount;
magma_int_t columns;
float tol = opts.tolerance * lapackf77_slamch("E");
printf("%% BatchCount M N CPU Gflop/s (ms) MAGMA Gflop/s (ms) CUBLAS Gflop/s (ms) ||PA-LU||/(||A||*N)\n");
printf("%%==========================================================================================================\n");
for( int itest = 0; itest < opts.ntest; ++itest ) {
for( int iter = 0; iter < opts.niter; ++iter ) {
M = opts.msize[itest];
N = opts.nsize[itest];
min_mn = min(M, N);
lda = M;
n2 = lda*N * batchCount;
ldda = magma_roundup( M, opts.align ); // multiple of 32 by default
gflops = FLOPS_CGETRF( M, N ) / 1e9 * batchCount;
TESTING_MALLOC_CPU( cpu_info, magma_int_t, batchCount );
TESTING_MALLOC_CPU( ipiv, magma_int_t, min_mn * batchCount );
TESTING_MALLOC_CPU( h_A, magmaFloatComplex, n2 );
TESTING_MALLOC_CPU( h_R, magmaFloatComplex, n2 );
TESTING_MALLOC_DEV( dA_magma, magmaFloatComplex, ldda*N * batchCount );
TESTING_MALLOC_DEV( dipiv_magma, magma_int_t, min_mn * batchCount );
TESTING_MALLOC_DEV( dinfo_magma, magma_int_t, batchCount );
TESTING_MALLOC_DEV( dA_array, magmaFloatComplex*, batchCount );
TESTING_MALLOC_DEV( dipiv_array, magma_int_t*, batchCount );
/* Initialize the matrix */
lapackf77_clarnv( &ione, ISEED, &n2, h_A );
// make A diagonally dominant, to not need pivoting
for( int s=0; s < batchCount; ++s ) {
for( int i=0; i < min_mn; ++i ) {
h_A[ i + i*lda + s*lda*N ] = MAGMA_C_MAKE(
MAGMA_C_REAL( h_A[ i + i*lda + s*lda*N ] ) + N,
MAGMA_C_IMAG( h_A[ i + i*lda + s*lda*N ] ));
}
}
columns = N * batchCount;
lapackf77_clacpy( MagmaFullStr, &M, &columns, h_A, &lda, h_R, &lda );
magma_csetmatrix( M, columns, h_R, lda, dA_magma, ldda );
/* ====================================================================
Performs operation using MAGMA
=================================================================== */
magma_cset_pointer( dA_array, dA_magma, ldda, 0, 0, ldda*N, batchCount, opts.queue );
magma_time = magma_sync_wtime( opts.queue );
info = magma_cgetrf_nopiv_batched( M, N, dA_array, ldda, dinfo_magma, batchCount, opts.queue);
magma_time = magma_sync_wtime( opts.queue ) - magma_time;
magma_perf = gflops / magma_time;
// check correctness of results throught "dinfo_magma" and correctness of argument throught "info"
magma_getvector( batchCount, sizeof(magma_int_t), dinfo_magma, 1, cpu_info, 1);
for (int i=0; i < batchCount; i++)
{
if (cpu_info[i] != 0 ) {
printf("magma_cgetrf_batched matrix %d returned internal error %d\n", i, (int)cpu_info[i] );
}
}
if (info != 0) {
printf("magma_cgetrf_batched returned argument error %d: %s.\n",
(int) info, magma_strerror( info ));
}
/* =====================================================================
Performs operation using LAPACK
=================================================================== */
if ( opts.lapack ) {
cpu_time = magma_wtime();
for (int i=0; i < batchCount; i++) {
lapackf77_cgetrf(&M, &N, h_A + i*lda*N, &lda, ipiv + i * min_mn, &info);
assert( info == 0 );
}
cpu_time = magma_wtime() - cpu_time;
cpu_perf = gflops / cpu_time;
if (info != 0) {
printf("lapackf77_cgetrf returned error %d: %s.\n",
(int) info, magma_strerror( info ));
}
}
/* =====================================================================
Check the factorization
=================================================================== */
if ( opts.lapack ) {
printf("%10d %5d %5d %7.2f (%7.2f) %7.2f (%7.2f) %7.2f (%7.2f)",
(int) batchCount, (int) M, (int) N, cpu_perf, cpu_time*1000., magma_perf, magma_time*1000., cublas_perf*cublas_enable, cublas_time*1000.*cublas_enable );
}
else {
printf("%10d %5d %5d --- ( --- ) %7.2f (%7.2f) %7.2f (%7.2f)",
(int) batchCount, (int) M, (int) N, magma_perf, magma_time*1000., cublas_perf*cublas_enable, cublas_time*1000.*cublas_enable );
}
if ( opts.check ) {
// initialize ipiv to 1, 2, 3, ...
for (int i=0; i < batchCount; i++)
{
for (int k=0; k < min_mn; k++) {
ipiv[i*min_mn+k] = k+1;
}
}
magma_cgetmatrix( M, N*batchCount, dA_magma, ldda, h_A, lda );
error = 0;
for (int i=0; i < batchCount; i++)
{
float err;
err = get_LU_error( M, N, h_R + i * lda*N, lda, h_A + i * lda*N, ipiv + i * min_mn);
if ( isnan(err) || isinf(err) ) {
error = err;
break;
}
error = max( err, error );
}
bool okay = (error < tol);
status += ! okay;
printf(" %8.2e %s\n", error, (okay ? "ok" : "failed") );
}
else {
printf(" --- \n");
}
TESTING_FREE_CPU( cpu_info );
TESTING_FREE_CPU( ipiv );
TESTING_FREE_CPU( h_A );
TESTING_FREE_CPU( h_R );
TESTING_FREE_DEV( dA_magma );
TESTING_FREE_DEV( dinfo_magma );
TESTING_FREE_DEV( dipiv_magma );
TESTING_FREE_DEV( dipiv_array );
TESTING_FREE_DEV( dA_array );
fflush( stdout );
}
if ( opts.niter > 1 ) {
printf( "\n" );
}
}
opts.cleanup();
TESTING_FINALIZE();
return status;
}
extern "C" magma_int_t
magma_cgesv_rbt_batched(
magma_int_t n, magma_int_t nrhs,
magmaFloatComplex **dA_array, magma_int_t ldda,
magmaFloatComplex **dB_array, magma_int_t lddb,
magma_int_t *dinfo_array,
magma_int_t batchCount, magma_queue_t queue)
{
/* Local variables */
magma_int_t i, info;
info = 0;
if (n < 0) {
info = -1;
} else if (nrhs < 0) {
info = -2;
} else if (ldda < max(1,n)) {
info = -4;
} else if (lddb < max(1,n)) {
info = -6;
}
if (info != 0) {
magma_xerbla( __func__, -(info) );
return info;
}
/* Quick return if possible */
if (n == 0 || nrhs == 0) {
return info;
}
magmaFloatComplex *hu, *hv;
if (MAGMA_SUCCESS != magma_cmalloc_cpu( &hu, 2*n )) {
info = MAGMA_ERR_HOST_ALLOC;
return info;
}
if (MAGMA_SUCCESS != magma_cmalloc_cpu( &hv, 2*n )) {
info = MAGMA_ERR_HOST_ALLOC;
return info;
}
info = magma_cgerbt_batched(MagmaTrue, n, nrhs, dA_array, n, dB_array, n, hu, hv, &info, batchCount, queue);
if (info != MAGMA_SUCCESS) {
return info;
}
info = magma_cgetrf_nopiv_batched( n, n, dA_array, ldda, dinfo_array, batchCount, queue);
if ( info != MAGMA_SUCCESS ) {
return info;
}
#ifdef CHECK_INFO
// check correctness of results throught "dinfo_magma" and correctness of argument throught "info"
magma_int_t *cpu_info = NULL;
magma_imalloc_cpu( &cpu_info, batchCount );
magma_getvector( batchCount, sizeof(magma_int_t), dinfo_array, 1, cpu_info, 1);
for (i=0; i < batchCount; i++)
{
if (cpu_info[i] != 0 ) {
printf("magma_cgetrf_batched matrix %d returned error %d\n",i, (int)cpu_info[i] );
info = cpu_info[i];
magma_free_cpu (cpu_info);
return info;
}
}
magma_free_cpu (cpu_info);
#endif
info = magma_cgetrs_nopiv_batched( MagmaNoTrans, n, nrhs, dA_array, ldda, dB_array, lddb, dinfo_array, batchCount, queue );
/* The solution of A.x = b is Vy computed on the GPU */
magmaFloatComplex *dv;
if (MAGMA_SUCCESS != magma_cmalloc( &dv, 2*n )) {
info = MAGMA_ERR_DEVICE_ALLOC;
return info;
}
magma_csetvector( 2*n, hv, 1, dv, 1, queue );
for (i = 0; i < nrhs; i++)
magmablas_cprbt_mv_batched(n, dv, dB_array+(i), batchCount, queue);
// magma_cgetmatrix( n, nrhs, db, nn, B, ldb, queue );
return info;
}
