// tutorial5_copy_async.cc
#include <exception>

#include "magma_v2.h"

// -----------------------------------------------------------------------------
// generates random n-by-n A and n-by-nrhs X in CPU host memory
void generate_problem( int n, int nrhs,
                       double* A, int lda,
                       double* X, int ldx )
{
    for (int j = 0; j < n; ++j) {
        for (int i = 0; i < n; ++i) {
            A[ i + j*lda ] = rand() / double(RAND_MAX);
        }
    }
    for (int j = 0; j < nrhs; ++j) {
        for (int i = 0; i < n; ++i) {
            X[ i + j*ldx ] = rand() / double(RAND_MAX);
        }
    }
}

// -----------------------------------------------------------------------------
// GPU interface: input & output matrices dA and dX in GPU device memory.
// Async copy A, X to dA, dX.
int main( int argc, char** argv )
{
    // ... setup dA, dX, queue
    magma_init();

    magma_queue_t queue;
    int device;
    magma_getdevice( &device );
    magma_queue_create( device, &queue );

    int n = 100, nrhs = 10;
    int lda = n, ldx = n;
    int* ipiv = new int[ n ];

    double *dA, *dX;
    int ldda = magma_roundup( lda, 32 );
    int lddx = magma_roundup( ldx, 32 );
    magma_dmalloc( &dA, ldda*n );
    magma_dmalloc( &dX, lddx*nrhs );
    assert( dA != nullptr );
    assert( dX != nullptr );

    // allocate A, X in pinned CPU memory
    double *A, *X;
    magma_dmalloc_pinned( &A, lda*n );
    magma_dmalloc_pinned( &X, ldx*nrhs );
    assert( A != nullptr );
    assert( X != nullptr );

    // ... fill in A and X
    generate_problem( n, nrhs, A, lda, X, ldx );

    // copy A, X to dA, dX, then wait
    magma_dsetmatrix_async( n, n,
            A, lda, dA, ldda, queue );
    magma_dsetmatrix_async( n, nrhs,
            X, ldx, dX, lddx, queue );    
    magma_queue_sync( queue );

    // ... solve A X = B
    int info;
    magma_dgesv_gpu( n, nrhs,
                     dA, ldda, ipiv,
                     dX, lddx, &info );
    if (info != 0) {
        throw std::exception();
    }

    // copy result dX to X, then wait
    magma_dgetmatrix_async( n, nrhs,
            dX, ldx, X, lddx, queue );
    magma_queue_sync( queue );

    // ... use result in X

    magma_free_pinned( A );
    magma_free_pinned( X );

    // ... cleanup
    magma_free( dA );
    magma_free( dX );
    delete[] ipiv;

    magma_queue_destroy( queue );

    magma_finalize();
}