testing_dgetrf.cpp File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <cuda.h>
#include <cuda_runtime_api.h>
#include <cublas.h>
#include "flops.h"
#include "magma.h"
#include "magma_lapack.h"
#include "testings.h"

Include dependency graph for testing_dgetrf.cpp:

Go to the source code of this file.

Macros
#define	PRECISION_d
#define	FLOPS(m, n)   ( FMULS_GETRF(m, n) + FADDS_GETRF(m, n) )

Functions
magma_int_t	magma_dgetrf3 (magma_int_t num_gpus, magma_int_t m, magma_int_t n, double *a, magma_int_t lda, magma_int_t *ipiv, magma_int_t *info)
double	get_LU_error (magma_int_t M, magma_int_t N, double *A, magma_int_t lda, double *LU, magma_int_t *IPIV)
int	main (int argc, char **argv)

---

Macro Definition Documentation

#define FLOPS	(		m,
			n
	)		( FMULS_GETRF(m, n) + FADDS_GETRF(m, n) )

Definition at line 38 of file testing_dgetrf.cpp.

#define PRECISION_d

Definition at line 34 of file testing_dgetrf.cpp.

---

Function Documentation

double get_LU_error	(	magma_int_t	M,
		magma_int_t	N,
		double *	A,
		magma_int_t	lda,
		double *	LU,
		magma_int_t *	IPIV
	)

Definition at line 41 of file testing_dgetrf.cpp.

References blasf77_dgemm(), L, lapackf77_dlacpy(), lapackf77_dlange(), lapackf77_dlaswp(), MAGMA_D_MAKE, MAGMA_D_ONE, MAGMA_D_SUB, MAGMA_D_ZERO, MagmaLowerStr, MagmaUpperStr, min, gbstrct_blg::N, TESTING_FREE, TESTING_MALLOC, and codegen::work.

{
    magma_int_t min_mn = min(M,N);
    magma_int_t ione   = 1;
    magma_int_t i, j;
    double alpha = MAGMA_D_ONE;
    double beta  = MAGMA_D_ZERO;
    double *L, *U;
    double work[1], matnorm, residual;
                       
    TESTING_MALLOC( L, double, M*min_mn);
    TESTING_MALLOC( U, double, min_mn*N);
    memset( L, 0, M*min_mn*sizeof(double) );
    memset( U, 0, min_mn*N*sizeof(double) );

    lapackf77_dlaswp( &N, A, &lda, &ione, &min_mn, IPIV, &ione);
    lapackf77_dlacpy( MagmaLowerStr, &M, &min_mn, LU, &lda, L, &M      );
    lapackf77_dlacpy( MagmaUpperStr, &min_mn, &N, LU, &lda, U, &min_mn );

    for(j=0; j<min_mn; j++)
        L[j+j*M] = MAGMA_D_MAKE( 1., 0. );
    
    matnorm = lapackf77_dlange("f", &M, &N, A, &lda, work);

    blasf77_dgemm("N", "N", &M, &N, &min_mn,
                  &alpha, L, &M, U, &min_mn, &beta, LU, &lda);

    for( j = 0; j < N; j++ ) {
        for( i = 0; i < M; i++ ) {
            LU[i+j*lda] = MAGMA_D_SUB( LU[i+j*lda], A[i+j*lda] );
        }
    }
    residual = lapackf77_dlange("f", &M, &N, LU, &lda, work);

    TESTING_FREE(L);
    TESTING_FREE(U);

    return residual / (matnorm * N);
}

Here is the call graph for this function:

magma_int_t magma_dgetrf3	(	magma_int_t	num_gpus,
		magma_int_t	m,
		magma_int_t	n,
		double *	a,
		magma_int_t	lda,
		magma_int_t *	ipiv,
		magma_int_t *	info
	)

int main	(	int	argc,
		char **	argv
	)

Definition at line 86 of file testing_dgetrf.cpp.

References FLOPS, get_current_time(), get_LU_error(), GetTimerValue(), ISEED, lapackf77_dgetrf(), lapackf77_dlacpy(), lapackf77_dlarnv(), magma_dgetrf(), magma_get_dgetrf_nb(), MagmaUpperLowerStr, min, gbstrct_blg::N, TESTING_CUDA_FINALIZE, TESTING_CUDA_INIT, TESTING_FREE, TESTING_HOSTALLOC, TESTING_HOSTFREE, and TESTING_MALLOC.

{
    TESTING_CUDA_INIT();

    magma_timestr_t       start, end;
    double           flops, gpu_perf, cpu_perf, error;
    double *h_A, *h_R;
    magma_int_t     *ipiv;

    /* Matrix size */
    magma_int_t M = 0, N = 0, n2, lda, ldda;
    magma_int_t size[10] = {1024,2048,3072,4032,5184,6016,7040,8064,9088,10112};

    magma_int_t i, info, min_mn, nb;
    magma_int_t ione     = 1;
    magma_int_t ISEED[4] = {0,0,0,1};

    if (argc != 1){
        for(i = 1; i<argc; i++){
            if (strcmp("-N", argv[i])==0)
                N = atoi(argv[++i]);
            else if (strcmp("-M", argv[i])==0)
                M = atoi(argv[++i]);
        }
        if (M>0 && N>0)
            printf("  testing_dgetrf -M %d -N %d\n\n", M, N);
        else
            {
                printf("\nUsage: \n");
                printf("  testing_dgetrf -M %d -N %d\n\n", 1024, 1024);
                exit(1);
            }
    }
    else {
        printf("\nUsage: \n");
        printf("  testing_dgetrf -M %d -N %d\n\n", 1024, 1024);
        M = N = size[9];
    }
    
    ldda   = ((M+31)/32)*32;
    n2     = M * N;
    min_mn = min(M, N);
    nb     = magma_get_dgetrf_nb(min_mn);

    /* Allocate host memory for the matrix */
    TESTING_MALLOC(ipiv, magma_int_t, min_mn);
    TESTING_MALLOC(    h_A, double, n2     );
    TESTING_HOSTALLOC( h_R, double, n2     );

    printf("\n\n");
    printf("  M     N   CPU GFlop/s    GPU GFlop/s   ||PA-LU||/(||A||*N)\n");
    printf("============================================================\n");
    for(i=0; i<10; i++){
        if (argc == 1){
            M = N = size[i];
        }
        min_mn= min(M, N);
        lda   = M;
        n2    = lda*N;
        ldda  = ((M+31)/32)*32;
        flops = FLOPS( (double)M, (double)N ) / 1000000;

        /* Initialize the matrix */
        lapackf77_dlarnv( &ione, ISEED, &n2, h_A );
        lapackf77_dlacpy( MagmaUpperLowerStr, &M, &N, h_A, &lda, h_R, &lda );

        /* =====================================================================
           Performs operation using LAPACK
           =================================================================== */
        start = get_current_time();
        lapackf77_dgetrf(&M, &N, h_A, &lda, ipiv, &info);
        end = get_current_time();
        if (info < 0)
            printf("Argument %d of dgetrf had an illegal value.\n", -info);

        cpu_perf = flops / GetTimerValue(start, end);

        /* ====================================================================
           Performs operation using MAGMA
           =================================================================== */
        lapackf77_dlacpy( MagmaUpperLowerStr, &M, &N, h_R, &lda, h_A, &lda );
        start = get_current_time();
        magma_dgetrf( M, N, h_R, lda, ipiv, &info);
        end = get_current_time();
        if (info < 0)
            printf("Argument %d of dgetrf had an illegal value.\n", -info);

        gpu_perf = flops / GetTimerValue(start, end);

        /* =====================================================================
           Check the factorization
           =================================================================== */
        error = get_LU_error(M, N, h_A, lda, h_R, ipiv);

        printf("%5d %5d  %6.2f         %6.2f         %e\n",
               M, N, cpu_perf, gpu_perf, error);

        if (argc != 1)
            break;
    }

    /* Memory clean up */
    TESTING_FREE( ipiv );
    TESTING_FREE( h_A );
    TESTING_HOSTFREE( h_R );

    /* Shutdown */
    TESTING_CUDA_FINALIZE();
}

Here is the call graph for this function: