Function magma_geqrf3_gpu

src/backend/opencl/magma/geqrf3.cpp:92–305

template<typename Ty>
magma_int_t magma_geqrf3_gpu(magma_int_t m, magma_int_t n, cl_mem dA,
                             size_t dA_offset, magma_int_t ldda, Ty *tau,
                             cl_mem dT, size_t dT_offset, magma_queue_t queue,
                             magma_int_t *info) {
    /*  -- clMAGMA (version 0.1) --
           Univ. of Tennessee, Knoxville
           Univ. of California, Berkeley
           Univ. of Colorado, Denver
           @date

        Purpose
        =======
        ZGEQRF computes a QR factorization of a complex M-by-N matrix A:
        A = Q * R.

        This version stores the triangular dT matrices used in
        the block QR factorization so that they can be applied directly (i.e.,
        without being recomputed) later. As a result, the application
        of Q is much faster. Also, the upper triangular matrices for V have 0s
        in them. The corresponding parts of the upper triangular R are inverted
        and stored separately in dT.

        Arguments
        =========
        M       (input) INTEGER
                The number of rows of the matrix A.  M >= 0.

        N       (input) INTEGER
                The number of columns of the matrix A.  N >= 0.

        dA      (input/output) COMPLEX_16 array on the GPU, dimension (LDDA,N)
                On entry, the M-by-N matrix A.
                On exit, the elements on and above the diagonal of the array
                contain the min(M,N)-by-N upper trapezoidal matrix R (R is
                upper triangular if m >= n); the elements below the diagonal,
                with the array TAU, represent the orthogonal matrix Q as a
                product of min(m,n) elementary reflectors (see Further
                Details).

        LDDA     (input) INTEGER
                The leading dimension of the array dA.  LDDA >= max(1,M).
                To benefit from coalescent memory accesses LDDA must be
                divisible by 16.

        TAU     (output) COMPLEX_16 array, dimension (min(M,N))
                The scalar factors of the elementary reflectors (see Further
                Details).

        dT      (workspace/output)  COMPLEX_16 array on the GPU,
                dimension (2*MIN(M, N) + (N+31)/32*32 )*NB,
                where NB can be obtained through magma_get_zgeqrf_nb(M).
                It starts with MIN(M,N)*NB block that store the triangular T
                matrices, followed by the MIN(M,N)*NB block of the diagonal
                inverses for the R matrix. The rest of the array is used as
       workspace.

        INFO    (output) INTEGER
                = 0:  successful exit