Functions | |
magma_int_t | magma_dbajac_csr (magma_int_t localiters, magma_d_sparse_matrix D, magma_d_sparse_matrix R, magma_d_vector b, magma_d_vector *x) |
This routine is a block-asynchronous Jacobi iteration performing s local Jacobi-updates within the block. | |
magma_int_t | magma_dbcsrvalcpy (magma_int_t size_b, magma_int_t num_blocks, magma_int_t num_zblocks, double **Aval, double **Bval, double **Bval2) |
For a Block-CSR ILU factorization, this routine copies the filled blocks from the original matrix A and initializes the blocks that will later be filled in the factorization process with zeros. | |
magma_int_t | magma_dbcsrluegemm (magma_int_t size_b, magma_int_t num_brows, magma_int_t kblocks, double **dA, double **dB, double **dC) |
For a Block-CSR ILU factorization, this routine updates all blocks in the trailing matrix. | |
magma_int_t | magma_dbcsrlupivloc (magma_int_t size_b, magma_int_t kblocks, double **dA, magma_int_t *ipiv) |
For a Block-CSR ILU factorization, this routine updates all blocks in the trailing matrix. | |
magma_int_t | magma_dbcsrswp (magma_int_t r_blocks, magma_int_t size_b, magma_int_t *ipiv, double *x) |
For a Block-CSR ILU factorization, this routine swaps rows in the vector *x according to the pivoting in *ipiv. | |
magma_int_t | magma_dbcsrtrsv (magma_uplo_t uplo, magma_int_t r_blocks, magma_int_t c_blocks, magma_int_t size_b, double *A, magma_index_t *blockinfo, double *x) |
For a Block-CSR ILU factorization, this routine performs the triangular solves. | |
void | magma_dcompact (magma_int_t m, magma_int_t n, double *dA, magma_int_t ldda, double *dnorms, double tol, magma_index_t *active, magma_index_t *cBlock) |
ZCOMPACT takes a set of n vectors of size m (in dA) and their norms and compacts them into the cBlock size<=n vectors that have norms > tol. | |
magma_int_t | magma_djacobisetup_vector_gpu (int num_rows, double *b, double *d, double *c, double *x) |
Prepares the Jacobi Iteration according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k. | |
magma_int_t | magma_dlobpcg_maxpy (magma_int_t num_rows, magma_int_t num_vecs, double *X, double *Y) |
This routine computes a axpy for a mxn matrix:. | |
int | magma_dbicgmerge1 (int n, double *skp, double *v, double *r, double *p) |
Mergels multiple operations into one kernel:. | |
int | magma_dbicgmerge2 (int n, double *skp, double *r, double *v, double *s) |
Mergels multiple operations into one kernel:. | |
int | magma_dbicgmerge3 (int n, double *skp, double *p, double *s, double *t, double *x, double *r) |
Mergels multiple operations into one kernel:. | |
int | magma_dbicgmerge4 (int type, double *skp) |
Performs some parameter operations for the BiCGSTAB with scalars on GPU. | |
magma_int_t | magma_dbicgmerge_spmv1 (magma_d_sparse_matrix A, double *d1, double *d2, double *d_p, double *d_r, double *d_v, double *skp) |
Merges the first SpmV using CSR with the dot product and the computation of alpha. | |
magma_int_t | magma_dbicgmerge_spmv2 (magma_d_sparse_matrix A, double *d1, double *d2, double *d_s, double *d_t, double *skp) |
Merges the second SpmV using CSR with the dot product and the computation of omega. | |
magma_int_t | magma_dbicgmerge_xrbeta (int n, double *d1, double *d2, double *rr, double *r, double *p, double *s, double *t, double *x, double *skp) |
Merges the second SpmV using CSR with the dot product and the computation of omega. | |
magma_int_t | magma_dcgmerge_spmv1 (magma_d_sparse_matrix A, double *d1, double *d2, double *d_d, double *d_z, double *skp) |
Merges the first SpmV using different formats with the dot product and the computation of rho. |
magma_int_t magma_dbajac_csr | ( | magma_int_t | localiters, | |
magma_d_sparse_matrix | D, | |||
magma_d_sparse_matrix | R, | |||
magma_d_vector | b, | |||
magma_d_vector * | x | |||
) |
This routine is a block-asynchronous Jacobi iteration performing s local Jacobi-updates within the block.
Input format is two CSR matrices, one containing the diagonal blocks, one containing the rest.
localiters | magma_int_t number of local Jacobi-like updates | |
D | magma_d_sparse_matrix input matrix with diagonal blocks | |
R | magma_d_sparse_matrix input matrix with non-diagonal parts | |
b | magma_d_vector RHS | |
x | magma_d_vector* iterate/solution |
magma_int_t magma_dbcsrluegemm | ( | magma_int_t | size_b, | |
magma_int_t | num_brows, | |||
magma_int_t | kblocks, | |||
double ** | dA, | |||
double ** | dB, | |||
double ** | dC | |||
) |
For a Block-CSR ILU factorization, this routine updates all blocks in the trailing matrix.
size_b | magma_int_t blocksize in BCSR | |
num_brows | magma_int_t number of block rows | |
kblocks | magma_int_t number of blocks in row | |
dA | double** input blocks of matrix A | |
dB | double** input blocks of matrix B | |
dC | double** output blocks of matrix C |
magma_int_t magma_dbcsrlupivloc | ( | magma_int_t | size_b, | |
magma_int_t | kblocks, | |||
double ** | dA, | |||
magma_int_t * | ipiv | |||
) |
For a Block-CSR ILU factorization, this routine updates all blocks in the trailing matrix.
size_b | magma_int_t blocksize in BCSR | |
kblocks | magma_int_t number of blocks | |
dA | double** matrix in BCSR | |
ipiv | magma_int_t* array containing pivots |
magma_int_t magma_dbcsrswp | ( | magma_int_t | r_blocks, | |
magma_int_t | size_b, | |||
magma_int_t * | ipiv, | |||
double * | x | |||
) |
For a Block-CSR ILU factorization, this routine swaps rows in the vector *x according to the pivoting in *ipiv.
r_blocks | magma_int_t number of blocks | |
size_b | magma_int_t blocksize in BCSR | |
ipiv | magma_int_t* array containing pivots | |
x | double* input/output vector x |
magma_int_t magma_dbcsrtrsv | ( | magma_uplo_t | uplo, | |
magma_int_t | r_blocks, | |||
magma_int_t | c_blocks, | |||
magma_int_t | size_b, | |||
double * | A, | |||
magma_index_t * | blockinfo, | |||
double * | x | |||
) |
For a Block-CSR ILU factorization, this routine performs the triangular solves.
uplo | magma_uplo_t upper/lower fill structure | |
r_blocks | magma_int_t number of blocks in row | |
c_blocks | magma_int_t number of blocks in column | |
size_b | magma_int_t blocksize in BCSR | |
A | double* upper/lower factor | |
blockinfo | magma_int_t* array containing matrix information | |
x | double* input/output vector x |
magma_int_t magma_dbcsrvalcpy | ( | magma_int_t | size_b, | |
magma_int_t | num_blocks, | |||
magma_int_t | num_zblocks, | |||
double ** | Aval, | |||
double ** | Bval, | |||
double ** | Bval2 | |||
) |
For a Block-CSR ILU factorization, this routine copies the filled blocks from the original matrix A and initializes the blocks that will later be filled in the factorization process with zeros.
size_b | magma_int_t blocksize in BCSR | |
num_blocks | magma_int_t number of nonzero blocks | |
num_zblocks | magma_int_t number of zero-blocks (will later be filled) | |
Aval | double** pointers to the nonzero blocks in A | |
Bval | double** pointers to the nonzero blocks in B | |
Bval2 | double** pointers to the zero blocks in B |
int magma_dbicgmerge1 | ( | int | n, | |
double * | skp, | |||
double * | v, | |||
double * | r, | |||
double * | p | |||
) |
Mergels multiple operations into one kernel:.
p = beta*p p = p-omega*beta*v p = p+r
-> p = r + beta * ( p - omega * v )
n | int dimension n | |
skp | double* set of scalar parameters | |
v | double* input v | |
r | double* input r | |
p | double* input/output p |
int magma_dbicgmerge2 | ( | int | n, | |
double * | skp, | |||
double * | r, | |||
double * | v, | |||
double * | s | |||
) |
Mergels multiple operations into one kernel:.
s=r s=s-alpha*v
-> s = r - alpha * v
n | int dimension n | |
skp | double* set of scalar parameters | |
r | double* input r | |
v | double* input v | |
s | double* input/output s |
int magma_dbicgmerge3 | ( | int | n, | |
double * | skp, | |||
double * | p, | |||
double * | s, | |||
double * | t, | |||
double * | x, | |||
double * | r | |||
) |
Mergels multiple operations into one kernel:.
x=x+alpha*p x=x+omega*s r=s r=r-omega*t
-> x = x + alpha * p + omega * s -> r = s - omega * t
n | int dimension n | |
skp | double* set of scalar parameters | |
p | double* input p | |
s | double* input s | |
t | double* input t | |
x | double* input/output x | |
r | double* input/output r |
int magma_dbicgmerge4 | ( | int | type, | |
double * | skp | |||
) |
Performs some parameter operations for the BiCGSTAB with scalars on GPU.
type | int kernel type | |
skp | double* vector with parameters |
magma_int_t magma_dbicgmerge_spmv1 | ( | magma_d_sparse_matrix | A, | |
double * | d1, | |||
double * | d2, | |||
double * | d_p, | |||
double * | d_r, | |||
double * | d_v, | |||
double * | skp | |||
) |
Merges the first SpmV using CSR with the dot product and the computation of alpha.
A | magma_d_sparse_matrix system matrix | |
d1 | double* temporary vector | |
d2 | double* temporary vector | |
d_p | double* input vector p | |
d_r | double* input vector r | |
d_v | double* output vector v | |
skp | double* array for parameters ( skp[0]=alpha ) |
magma_int_t magma_dbicgmerge_spmv2 | ( | magma_d_sparse_matrix | A, | |
double * | d1, | |||
double * | d2, | |||
double * | d_s, | |||
double * | d_t, | |||
double * | skp | |||
) |
Merges the second SpmV using CSR with the dot product and the computation of omega.
A | magma_d_sparse_matrix input matrix | |
d1 | double* temporary vector | |
d2 | double* temporary vector | |
d_s | double* input vector s | |
d_t | double* output vector t | |
skp | double* array for parameters |
magma_int_t magma_dbicgmerge_xrbeta | ( | int | n, | |
double * | d1, | |||
double * | d2, | |||
double * | rr, | |||
double * | r, | |||
double * | p, | |||
double * | s, | |||
double * | t, | |||
double * | x, | |||
double * | skp | |||
) |
Merges the second SpmV using CSR with the dot product and the computation of omega.
n | int dimension n | |
d1 | double* temporary vector | |
d2 | double* temporary vector | |
rr | double* input vector rr | |
r | double* input/output vector r | |
p | double* input vector p | |
s | double* input vector s | |
t | double* input vector t | |
x | double* output vector x | |
skp | double* array for parameters |
magma_int_t magma_dcgmerge_spmv1 | ( | magma_d_sparse_matrix | A, | |
double * | d1, | |||
double * | d2, | |||
double * | d_d, | |||
double * | d_z, | |||
double * | skp | |||
) |
Merges the first SpmV using different formats with the dot product and the computation of rho.
A | magma_d_sparse_matrix input matrix | |
d1 | double* temporary vector | |
d2 | double* temporary vector | |
d_d | double* input vector d | |
d_z | double* input vector z | |
skp | double* array for parameters ( skp[3]=rho ) |
void magma_dcompact | ( | magma_int_t | m, | |
magma_int_t | n, | |||
double * | dA, | |||
magma_int_t | ldda, | |||
double * | dnorms, | |||
double | tol, | |||
magma_index_t * | active, | |||
magma_index_t * | cBlock | |||
) |
ZCOMPACT takes a set of n vectors of size m (in dA) and their norms and compacts them into the cBlock size<=n vectors that have norms > tol.
The active mask array has 1 or 0, showing if a vector remained or not in the compacted resulting set of vectors.
[in] | m | INTEGER The number of rows of the matrix dA. M >= 0. |
[in] | n | INTEGER The number of columns of the matrix dA. N >= 0. |
[in,out] | dA | COMPLEX DOUBLE PRECISION array, dimension (LDDA,N) The m by n matrix dA. |
[in] | ldda | INTEGER The leading dimension of the array dA. LDDA >= max(1,M). |
[in] | dnorms | DOUBLE PRECISION array, dimension N The norms of the N vectors in dA |
[in] | tol | DOUBLE PRECISON The tolerance value used in the criteria to compact or not. |
[out] | active | INTEGER array, dimension N A mask of 1s and 0s showing if a vector remains or has been removed |
[out] | cBlock | magma_index_t* The number of vectors that remain in dA (i.e., with norms > tol). |
magma_int_t magma_djacobisetup_vector_gpu | ( | int | num_rows, | |
double * | b, | |||
double * | d, | |||
double * | c, | |||
double * | x | |||
) |
Prepares the Jacobi Iteration according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.
Returns the vector c. It calls a GPU kernel
num_rows | magma_int_t number of rows | |
b | magma_d_vector RHS b | |
d | magma_d_vector vector with diagonal entries | |
c | magma_d_vector* c = D^(-1) * b | |
x | magma_d_vector* iteration vector |
magma_int_t magma_dlobpcg_maxpy | ( | magma_int_t | num_rows, | |
magma_int_t | num_vecs, | |||
double * | X, | |||
double * | Y | |||
) |
This routine computes a axpy for a mxn matrix:.
Y = X + Y
It replaces: magma_daxpy(m*n, c_one, Y, 1, X, 1);
/ x1[0] x2[0] x3[0] \ | x1[1] x2[1] x3[1] | X = | x1[2] x2[2] x3[2] | = x1[0] x1[1] x1[2] x1[3] x1[4] x2[0] x2[1] . | x1[3] x2[3] x3[3] | \ x1[4] x2[4] x3[4] /
num_rows | magma_int_t number of rows | |
num_vecs | magma_int_t number of vectors | |
X | double* input vector X | |
Y | double* input/output vector Y |