MAGMA  magma-1.4.0
Matrix Algebra on GPU and Multicore Architectures
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups
zlaqps_gpu.cpp File Reference
#include "common_magma.h"
#include <cblas.h>
Include dependency graph for zlaqps_gpu.cpp:

Go to the source code of this file.

Macros

#define PRECISION_z
 
#define A(i, j)   (A + (i) + (j)*(lda ))
 
#define F(i, j)   (F + (i) + (j)*(ldf ))
 

Functions

magma_int_t magma_zlaqps_gpu (magma_int_t m, magma_int_t n, magma_int_t offset, magma_int_t nb, magma_int_t *kb, magmaDoubleComplex *A, magma_int_t lda, magma_int_t *jpvt, magmaDoubleComplex *tau, double *vn1, double *vn2, magmaDoubleComplex *auxv, magmaDoubleComplex *F, magma_int_t ldf)
 

Macro Definition Documentation

#define A (   i,
 
)    (A + (i) + (j)*(lda ))
#define F (   i,
 
)    (F + (i) + (j)*(ldf ))
#define PRECISION_z

Definition at line 14 of file zlaqps_gpu.cpp.

Function Documentation

magma_int_t magma_zlaqps_gpu ( magma_int_t  m,
magma_int_t  n,
magma_int_t  offset,
magma_int_t  nb,
magma_int_t kb,
magmaDoubleComplex *  A,
magma_int_t  lda,
magma_int_t jpvt,
magmaDoubleComplex *  tau,
double *  vn1,
double *  vn2,
magmaDoubleComplex *  auxv,
magmaDoubleComplex *  F,
magma_int_t  ldf 
)

Definition at line 17 of file zlaqps_gpu.cpp.

References A, F, lapackf77_dlamch, magma_dcopymatrix, magma_device_sync(), magma_dgetvector, magma_dmalloc(), magma_dsqrt, magma_dswap(), magma_free, magma_idamax(), magma_scopymatrix, magma_sgetvector, magma_sswap(), MAGMA_SUCCESS, MAGMA_Z_MAKE, MAGMA_Z_NEGATE, magma_zcopymatrix, magma_zgemm(), magma_zgemv(), magma_zgetvector, magma_zlarfg_gpu(), magma_zmalloc(), magma_zsetvector, magmablas_dznrm2_check(), magmablas_dznrm2_row_check_adjust(), magmablas_zswap(), MagmaConjTrans, MagmaNoTrans, and min.

24 {
25 /* -- MAGMA (version 1.4.0) --
26  Univ. of Tennessee, Knoxville
27  Univ. of California, Berkeley
28  Univ. of Colorado, Denver
29  August 2013
30 
31  Purpose
32  =======
33  ZLAQPS computes a step of QR factorization with column pivoting
34  of a complex M-by-N matrix A by using Blas-3. It tries to factorize
35  NB columns from A starting from the row OFFSET+1, and updates all
36  of the matrix with Blas-3 xGEMM.
37 
38  In some cases, due to catastrophic cancellations, it cannot
39  factorize NB columns. Hence, the actual number of factorized
40  columns is returned in KB.
41 
42  Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.
43 
44  Arguments
45  =========
46  M (input) INTEGER
47  The number of rows of the matrix A. M >= 0.
48 
49  N (input) INTEGER
50  The number of columns of the matrix A. N >= 0
51 
52  OFFSET (input) INTEGER
53  The number of rows of A that have been factorized in
54  previous steps.
55 
56  NB (input) INTEGER
57  The number of columns to factorize.
58 
59  KB (output) INTEGER
60  The number of columns actually factorized.
61 
62  A (input/output) COMPLEX*16 array, dimension (LDA,N)
63  On entry, the M-by-N matrix A.
64  On exit, block A(OFFSET+1:M,1:KB) is the triangular
65  factor obtained and block A(1:OFFSET,1:N) has been
66  accordingly pivoted, but no factorized.
67  The rest of the matrix, block A(OFFSET+1:M,KB+1:N) has
68  been updated.
69 
70  LDA (input) INTEGER
71  The leading dimension of the array A. LDA >= max(1,M).
72 
73  JPVT (input/output) INTEGER array, dimension (N)
74  JPVT(I) = K <==> Column K of the full matrix A has been
75  permuted into position I in AP.
76 
77  TAU (output) COMPLEX*16 array, dimension (KB)
78  The scalar factors of the elementary reflectors.
79 
80  VN1 (input/output) DOUBLE PRECISION array, dimension (N)
81  The vector with the partial column norms.
82 
83  VN2 (input/output) DOUBLE PRECISION array, dimension (N)
84  The vector with the exact column norms.
85 
86  AUXV (input/output) COMPLEX*16 array, dimension (NB)
87  Auxiliar vector.
88 
89  F (input/output) COMPLEX*16 array, dimension (LDF,NB)
90  Matrix F' = L*Y'*A.
91 
92  LDF (input) INTEGER
93  The leading dimension of the array F. LDF >= max(1,N).
94 
95  ===================================================================== */
96 
97 #define A(i, j) (A + (i) + (j)*(lda ))
98 #define F(i, j) (F + (i) + (j)*(ldf ))
99 
100  magmaDoubleComplex c_zero = MAGMA_Z_MAKE( 0.,0.);
101  magmaDoubleComplex c_one = MAGMA_Z_MAKE( 1.,0.);
102  magmaDoubleComplex c_neg_one = MAGMA_Z_MAKE(-1.,0.);
103  magma_int_t ione = 1;
104 
105  magma_int_t i__1, i__2;
106  //double d__1;
107  magmaDoubleComplex z__1;
108 
109  //magma_int_t j;
110  magma_int_t k, rk;
111  //magmaDoubleComplex Akk;
112  magmaDoubleComplex *Aks;
113  magmaDoubleComplex tauk;
114  magma_int_t pvt;
115  //double temp, temp2;
116  double tol3z;
117  magma_int_t itemp;
118 
119  double lsticc, *lsticcs;
120  magma_int_t lastrk;
121  magma_dmalloc( &lsticcs, 1+256*(n+255)/256 );
122 
123  lastrk = min( m, n + offset );
124  tol3z = magma_dsqrt( lapackf77_dlamch("Epsilon"));
125 
126  lsticc = 0;
127  k = 0;
128  magma_zmalloc( &Aks, nb );
129 
130  while( k < nb && lsticc == 0 ) {
131  rk = offset + k;
132 
133  /* Determine ith pivot column and swap if necessary */
134  // Fortran: pvt, k, idamax are all 1-based; subtract 1 from k.
135  // C: pvt, k, idamax are all 0-based; don't subtract 1.
136  pvt = k - 1 + magma_idamax( n-k, &vn1[k], ione );
137 
138  if (pvt != k) {
139 
140  /*if (pvt >= nb) {
141  // 1. Start copy from GPU
142  magma_zgetmatrix_async( m - offset - nb, 1,
143  dA(offset + nb, pvt), ldda,
144  A (offset + nb, pvt), lda, stream );
145  }*/
146 
147  /* F gets swapped so F must be sent at the end to GPU */
148  i__1 = k;
149  /*if (pvt < nb){
150  // no need of transfer if pivot is within the panel
151  blasf77_zswap( &m, A(0, pvt), &ione, A(0, k), &ione );
152  }
153  else {
154  // 1. Finish copy from GPU
155  magma_queue_sync( stream );
156 
157  // 2. Swap as usual on CPU
158  blasf77_zswap(&m, A(0, pvt), &ione, A(0, k), &ione);
159 
160  // 3. Restore the GPU
161  magma_zsetmatrix_async( m - offset - nb, 1,
162  A (offset + nb, pvt), lda,
163  dA(offset + nb, pvt), ldda, stream);
164  }*/
165  magmablas_zswap( m, A(0, pvt), ione, A(0, k), ione );
166 
167  //blasf77_zswap( &i__1, F(pvt,0), &ldf, F(k,0), &ldf );
168  magmablas_zswap( i__1, F(pvt, 0), ldf, F(k, 0), ldf);
169  itemp = jpvt[pvt];
170  jpvt[pvt] = jpvt[k];
171  jpvt[k] = itemp;
172  //vn1[pvt] = vn1[k];
173  //vn2[pvt] = vn2[k];
174  #if defined(PRECISION_d) || defined(PRECISION_z)
175  //magma_dswap( 1, &vn1[pvt], 1, &vn1[k], 1 );
176  //magma_dswap( 1, &vn2[pvt], 1, &vn2[k], 1 );
177  magma_dswap( 2, &vn1[pvt], n+offset, &vn1[k], n+offset );
178  #else
179  //magma_sswap( 1, &vn1[pvt], 1, &vn1[k], 1 );
180  //magma_sswap( 1, &vn2[pvt], 1, &vn2[k], 1 );
181  magma_sswap(2, &vn1[pvt], n+offset, &vn1[k], n+offset);
182  #endif
183 
184  }
185 
186  /* Apply previous Householder reflectors to column K:
187  A(RK:M,K) := A(RK:M,K) - A(RK:M,1:K-1)*F(K,1:K-1)'.
188  Optimization: multiply with beta=0; wait for vector and subtract */
189  if (k > 0) {
190  /*#if (defined(PRECISION_c) || defined(PRECISION_z))
191  for (j = 0; j < k; ++j){
192  *F(k,j) = MAGMA_Z_CNJG( *F(k,j) );
193  }
194  #endif*/
195 
196 //#define RIGHT_UPDATE
197 #ifdef RIGHT_UPDATE
198  i__1 = m - offset - nb;
199  i__2 = k;
200  magma_zgemv( MagmaNoTrans, i__1, i__2,
201  c_neg_one, A(offset+nb, 0), lda,
202  F(k, 0), ldf,
203  c_one, A(offset+nb, k), ione );
204 #else
205  i__1 = m - rk;
206  i__2 = k;
207  /*blasf77_zgemv( MagmaNoTransStr, &i__1, &i__2,
208  &c_neg_one, A(rk, 0), &lda,
209  F(k, 0), &ldf,
210  &c_one, A(rk, k), &ione );*/
211  magma_zgemv( MagmaNoTrans, i__1, i__2,
212  c_neg_one, A(rk, 0), lda,
213  F(k, 0), ldf,
214  c_one, A(rk, k), ione );
215 #endif
216 
217  /*#if (defined(PRECISION_c) || defined(PRECISION_z))
218  for (j = 0; j < k; ++j) {
219  *F(k,j) = MAGMA_Z_CNJG( *F(k,j) );
220  }
221  #endif*/
222  }
223 
224  /* Generate elementary reflector H(k). */
225  magma_zlarfg_gpu(m-rk, A(rk, k), A(rk + 1, k), &tau[k], &vn1[k], &Aks[k]);
226 
227  //Akk = *A(rk, k);
228  //*A(rk, k) = c_one;
229  //magma_zgetvector( 1, &Aks[k], 1, &Akk, 1 );
230 
231  /* needed to avoid the race condition */
232  if (k == 0) magma_zsetvector( 1, &c_one, 1, A(rk, k), 1 );
233  else magma_zcopymatrix( 1, 1, A(offset, 0), 1, A(rk, k), 1 );
234 
235  /* Compute Kth column of F:
236  Compute F(K+1:N,K) := tau(K)*A(RK:M,K+1:N)'*A(RK:M,K) on the GPU */
237  if (k < n-1 || k > 0) magma_zgetvector( 1, &tau[k], 1, &tauk, 1 );
238  if (k < n-1) {
239  i__1 = m - rk;
240  i__2 = n - k - 1;
241 
242  /* Send the vector to the GPU */
243  //magma_zsetmatrix( i__1, 1, A(rk, k), lda, dA(rk,k), ldda );
244 
245  /* Multiply on GPU */
246  // was CALL ZGEMV( 'Conjugate transpose', M-RK+1, N-K,
247  // TAU( K ), A( RK, K+1 ), LDA,
248  // A( RK, K ), 1,
249  // CZERO, F( K+1, K ), 1 )
250  //magma_zgetvector( 1, &tau[k], 1, &tauk, 1 );
251  magma_zgemv( MagmaConjTrans, m-rk, n-k-1,
252  tauk, A( rk, k+1 ), lda,
253  A( rk, k ), 1,
254  c_zero, F( k+1, k ), 1 );
255  //magma_zscal( m-rk, tau[k], F( k+1, k), 1 );
256  //magma_int_t i__3 = nb-k-1;
257  //magma_int_t i__4 = i__2 - i__3;
258  //magma_int_t i__5 = nb-k;
259  //magma_zgemv( MagmaConjTrans, i__1 - i__5, i__2 - i__3,
260  // tau[k], dA(rk +i__5, k+1+i__3), ldda,
261  // dA(rk +i__5, k ), ione,
262  // c_zero, dF(k+1+i__3, k ), ione );
263 
264  //magma_zgetmatrix_async( i__2-i__3, 1,
265  // dF(k + 1 +i__3, k), i__2,
266  // F (k + 1 +i__3, k), i__2, stream );
267 
268  //blasf77_zgemv( MagmaConjTransStr, &i__1, &i__3,
269  // &tau[k], A(rk, k+1), &lda,
270  // A(rk, k ), &ione,
271  // &c_zero, F(k+1, k ), &ione );
272 
273  //magma_queue_sync( stream );
274  //blasf77_zgemv( MagmaConjTransStr, &i__5, &i__4,
275  // &tau[k], A(rk, k+1+i__3), &lda,
276  // A(rk, k ), &ione,
277  // &c_one, F(k+1+i__3, k ), &ione );
278  }
279 
280  /* Padding F(1:K,K) with zeros.
281  for (j = 0; j <= k; ++j) {
282  magma_zsetvector( 1, &c_zero, 1, F(j, k), 1 );
283  }*/
284 
285  /* Incremental updating of F:
286  F(1:N,K) := F(1:N,K) - tau(K)*F(1:N,1:K-1)*A(RK:M,1:K-1)'*A(RK:M,K).
287  F(1:N,K) := tau(K)*A(RK:M,K+1:N)'*A(RK:M,K) - tau(K)*F(1:N,1:K-1)*A(RK:M,1:K-1)'*A(RK:M,K)
288  := tau(K)(A(RK:M,K+1:N)' - F(1:N,1:K-1)*A(RK:M,1:K-1)') A(RK:M,K)
289  so, F is (updated A)*V */
290  //if (k > 0 && k<n-1) {
291  if (k > 0) {
292  //magma_zgetvector( 1, &tau[k], 1, &tauk, 1 );
293  z__1 = MAGMA_Z_NEGATE( tauk );
294 #ifdef RIGHT_UPDATE
295  i__1 = m - offset - nb;
296  i__2 = k;
297  magma_zgemv( MagmaConjTrans, i__1, i__2,
298  z__1, A(offset+nb, 0), lda,
299  A(offset+nb, k), ione,
300  c_zero, auxv, ione );
301 
302  i__1 = k;
303  magma_zgemv( MagmaNoTrans, n-k-1, i__1,
304  c_one, F(k+1,0), ldf,
305  auxv, ione,
306  c_one, F(k+1,k), ione );
307 #else
308  i__1 = m - rk;
309  i__2 = k;
310  //blasf77_zgemv( MagmaConjTransStr, &i__1, &i__2,
311  // &z__1, A(rk, 0), &lda,
312  // A(rk, k), &ione,
313  // &c_zero, auxv, &ione );
314 
315  magma_zgemv( MagmaConjTrans, i__1, i__2,
316  z__1, A(rk, 0), lda,
317  A(rk, k), ione,
318  c_zero, auxv, ione );
319 
320  //i__1 = k;
321  //blasf77_zgemv( MagmaNoTransStr, &n, &i__1,
322  // &c_one, F(0,0), &ldf,
323  // auxv, &ione,
324  // &c_one, F(0,k), &ione );
325  /*magma_zgemv( MagmaNoTrans, n, i__1,
326  c_one, F(0,0), ldf,
327  auxv, ione,
328  c_one, F(0,k), ione );*/
329  /* I think we only need stricly lower-triangular part :) */
330  magma_zgemv( MagmaNoTrans, n-k-1, i__2,
331  c_one, F(k+1,0), ldf,
332  auxv, ione,
333  c_one, F(k+1,k), ione );
334 #endif
335  }
336 
337  /* Optimization: On the last iteration start sending F back to the GPU */
338 
339  /* Update the current row of A:
340  A(RK,K+1:N) := A(RK,K+1:N) - A(RK,1:K)*F(K+1:N,1:K)'. */
341  if (k < n-1) {
342  i__1 = n - k - 1;
343  i__2 = k + 1;
344  //blasf77_zgemm( MagmaNoTransStr, MagmaConjTransStr, &ione, &i__1, &i__2,
345  // &c_neg_one, A(rk, 0 ), &lda,
346  // F(k+1,0 ), &ldf,
347  // &c_one, A(rk, k+1), &lda );
348 #ifdef RIGHT_UPDATE
349  /* right-looking update of rows, */
350  magma_zgemm( MagmaNoTrans, MagmaConjTrans, nb-k, i__1, ione,
351  c_neg_one, A(rk, k ), lda,
352  F(k+1, k ), ldf,
353  c_one, A(rk, k+1), lda );
354 #else
355  /* left-looking update of rows, *
356  * since F=A'v with original A, so no right-looking */
357  magma_zgemm( MagmaNoTrans, MagmaConjTrans, ione, i__1, i__2,
358  c_neg_one, A(rk, 0 ), lda,
359  F(k+1,0 ), ldf,
360  c_one, A(rk, k+1), lda );
361 #endif
362  }
363 
364  /* Update partial column norms. */
365  if (rk < min(m, n+offset)-1 ){
366  magmablas_dznrm2_row_check_adjust(n-k-1, tol3z, &vn1[k+1], &vn2[k+1], A(rk,k+1), lda, lsticcs);
367 
369  #if defined(PRECISION_d) || defined(PRECISION_z)
370  magma_dgetvector( 1, &lsticcs[0], 1, &lsticc, 1 );
371  #else
372  magma_sgetvector( 1, &lsticcs[0], 1, &lsticc, 1 );
373  #endif
374  }
375 
376 
377  /*if (rk < lastrk) {
378  for (j = k + 1; j < n; ++j) {
379  if (vn1[j] != 0.) {
380  // NOTE: The following 4 lines follow from the analysis in
381  // Lapack Working Note 176.
382  temp = MAGMA_Z_ABS( *A(rk,j) ) / vn1[j];
383  temp = max( 0., ((1. + temp) * (1. - temp)) );
384 
385  d__1 = vn1[j] / vn2[j];
386  temp2 = temp * (d__1 * d__1);
387 
388  if (temp2 <= tol3z) {
389  vn2[j] = (double) lsticc;
390  lsticc = j;
391  } else {
392  vn1[j] *= magma_dsqrt(temp);
393  }
394  }
395  }
396  }*/
397 
398  //*A(rk, k) = Akk;
399  //magma_zsetvector( 1, &Akk, 1, A(rk, k), 1 );
400  //magma_zswap( 1, &Aks[k], 1, A(rk, k), 1 );
401 
402  ++k;
403  }
404  magma_zcopymatrix( 1, k, Aks, 1, A(offset, 0), lda+1 );
405 
406  // leave k as the last column done
407  --k;
408  *kb = k + 1;
409  rk = offset + *kb - 1;
410 
411  /* Apply the block reflector to the rest of the matrix:
412  A(OFFSET+KB+1:M,KB+1:N) := A(OFFSET+KB+1:M,KB+1:N) - A(OFFSET+KB+1:M,1:KB)*F(KB+1:N,1:KB)' */
413  if (*kb < min(n, m - offset)) {
414  i__1 = m - rk - 1;
415  i__2 = n - *kb;
416 
417  /* Send F to the GPU
418  magma_zsetmatrix( i__2, *kb,
419  F (*kb, 0), ldf,
420  dF(*kb, 0), i__2 );*/
421 
422  magma_zgemm( MagmaNoTrans, MagmaConjTrans, i__1, i__2, *kb,
423  c_neg_one, A(rk+1, 0 ), lda,
424  F(*kb, 0 ), ldf,
425  c_one, A(rk+1, *kb), lda );
426  }
427  /* Recomputation of difficult columns. */
428  if( lsticc > 0 ) {
429  printf( " -- recompute dnorms --\n" );
430  magmablas_dznrm2_check(m-rk-1, n-*kb, A(rk+1,*kb), lda,
431  &vn1[*kb], lsticcs);
432 #if defined(PRECISION_d) || defined(PRECISION_z)
433  magma_dcopymatrix( n-*kb, 1, &vn1[*kb], *kb, &vn2[*kb], *kb);
434 #else
435  magma_scopymatrix( n-*kb, 1, &vn1[*kb], *kb, &vn2[*kb], *kb);
436 #endif
437  /*while( lsticc > 0 ) {
438  itemp = (magma_int_t)(vn2[lsticc] >= 0. ? floor(vn2[lsticc] + .5) : -floor(.5 - vn2[lsticc]));
439  i__1 = m - rk - 1;
440  if (lsticc <= nb)
441  vn1[lsticc] = cblas_dznrm2(i__1, A(rk + 1, lsticc), ione);
442  else {
443  // Where is the data, CPU or GPU ?
444  double r1, r2;
445 
446  r1 = cblas_dznrm2(nb-k, A(rk + 1, lsticc), ione);
447  r2 = magma_dznrm2(m-offset-nb, dA(offset + nb + 1, lsticc), ione);
448 
449  vn1[lsticc] = magma_dsqrt(r1*r1+r2*r2);
450  }
451 
452  // NOTE: The computation of VN1( LSTICC ) relies on the fact that
453  // SNRM2 does not fail on vectors with norm below the value of SQRT(DLAMCH('S'))
454  vn2[lsticc] = vn1[lsticc];
455  lsticc = itemp;*/
456  }
457  magma_free(Aks);
458  magma_free(lsticcs);
459 
460  return MAGMA_SUCCESS;
461 } /* magma_zlaqps */
#define magma_dsqrt
Definition: common_magma.h:98
#define min(a, b)
Definition: common_magma.h:86
void magma_device_sync()
magma_int_t magma_zlarfg_gpu(magma_int_t n, magmaDoubleComplex *dx0, magmaDoubleComplex *dx, magmaDoubleComplex *dtau, double *dxnorm, magmaDoubleComplex *dAkk)
#define magma_dgetvector(n, dx_src, incx, hy_dst, incy)
Definition: magmablas_d.h:637
void magmablas_dznrm2_check(magma_int_t m, magma_int_t num, magmaDoubleComplex *da, magma_int_t ldda, double *dxnorm, double *lsticc)
void magmablas_dznrm2_row_check_adjust(magma_int_t k, double tol, double *xnorm, double *xnorm2, magmaDoubleComplex *c, magma_int_t ldc, double *lsticc)
#define MAGMA_Z_MAKE(r, i)
Definition: magma.h:123
static magma_err_t magma_zmalloc(magmaDoubleComplex_ptr *ptrPtr, size_t n)
Definition: magma.h:80
static magma_err_t magma_dmalloc(magmaDouble_ptr *ptrPtr, size_t n)
Definition: magma.h:78
#define magma_free(ptr)
Definition: magma.h:57
int magma_int_t
Definition: magmablas.h:12
#define magma_zcopymatrix(m, n, dA_src, ldda, dB_dst, lddb)
Definition: magmablas_z.h:708
#define magma_zgetvector(n, dx_src, incx, hy_dst, incy)
Definition: magmablas_z.h:637
#define MAGMA_Z_NEGATE(a)
Definition: magma_types.h:150
void magmablas_zswap(magma_int_t N, cuDoubleComplex *dA1, magma_int_t lda1, cuDoubleComplex *dA2, magma_int_t lda2)
#define lapackf77_dlamch
Definition: magma_lapack.h:27
#define magma_zsetvector(n, hx_src, incx, dy_dst, incy)
Definition: magmablas_z.h:634
void magma_zgemm(magma_trans_t transA, magma_trans_t transB, magma_int_t m, magma_int_t n, magma_int_t k, magmaDoubleComplex alpha, magmaDoubleComplex_const_ptr dA, magma_int_t ldda, magmaDoubleComplex_const_ptr dB, magma_int_t lddb, magmaDoubleComplex beta, magmaDoubleComplex_ptr dC, magma_int_t lddc)
magma_int_t magma_idamax(magma_int_t n, magmaDouble_const_ptr dx, magma_int_t incx)
#define magma_scopymatrix(m, n, dA_src, ldda, dB_dst, lddb)
Definition: magmablas_s.h:708
#define MagmaConjTrans
Definition: magma.h:59
#define magma_dcopymatrix(m, n, dA_src, ldda, dB_dst, lddb)
Definition: magmablas_d.h:708
#define MAGMA_SUCCESS
Definition: magma.h:106
void magma_sswap(magma_int_t n, magmaFloat_ptr dx, magma_int_t incx, magmaFloat_ptr dy, magma_int_t incy)
#define F(i, j)
void magma_zgemv(magma_trans_t transA, magma_int_t m, magma_int_t n, magmaDoubleComplex alpha, magmaDoubleComplex_const_ptr dA, magma_int_t ldda, magmaDoubleComplex_const_ptr dx, magma_int_t incx, magmaDoubleComplex beta, magmaDoubleComplex_ptr dy, magma_int_t incy)
#define A(i, j)
#define magma_sgetvector(n, dx_src, incx, hy_dst, incy)
Definition: magmablas_s.h:637
#define MagmaNoTrans
Definition: magma.h:57
void magma_dswap(magma_int_t n, magmaDouble_ptr dx, magma_int_t incx, magmaDouble_ptr dy, magma_int_t incy)

Here is the call graph for this function: