single precision

Functions
magma_int_t	magma_sftjacobi (magma_s_matrix A, magma_s_matrix b, magma_s_matrix *x, magma_s_solver_par *solver_par, magma_queue_t queue)
	Iterates the solution approximation 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_sjacobisetup_matrix (magma_s_matrix A, magma_s_matrix *M, magma_s_matrix *d, magma_queue_t queue)
	Prepares the Matrix M for 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_sjacobisetup_diagscal (magma_s_matrix A, magma_s_matrix *d, magma_queue_t queue)
	It returns a vector d containing the inverse diagonal elements.
magma_int_t	magma_sjacobisetup_vector (magma_s_matrix b, magma_s_matrix d, magma_s_matrix *c, magma_queue_t queue)
	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_sjacobisetup (magma_s_matrix A, magma_s_matrix b, magma_s_matrix *M, magma_s_matrix *c, magma_queue_t queue)
	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_sjacobiiter (magma_s_matrix M, magma_s_matrix c, magma_s_matrix *x, magma_s_solver_par *solver_par, magma_queue_t queue)
	Iterates the solution approximation 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_sjacobiiter_precond (magma_s_matrix M, magma_s_matrix *x, magma_s_solver_par *solver_par, magma_s_preconditioner *precond, magma_queue_t queue)
	Iterates the solution approximation 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_sjacobiiter_sys (magma_s_matrix A, magma_s_matrix b, magma_s_matrix d, magma_s_matrix t, magma_s_matrix *x, magma_s_solver_par *solver_par, magma_queue_t queue)
	Iterates the solution approximation 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_scompactActive (magma_int_t m, magma_int_t n, magmaFloat_ptr dA, magma_int_t ldda, magmaInt_ptr active, magma_queue_t queue)
	ZCOMPACTACTIVE takes a set of n vectors of size m (in dA) and an array of 1s and 0sindicating which vectors to compact (for 1s) and which to disregard (for 0s).
magma_int_t	magma_sgeelltmv (magma_trans_t transA, magma_int_t m, magma_int_t n, magma_int_t nnz_per_row, float alpha, magmaFloat_ptr dval, magmaIndex_ptr dcolind, magmaFloat_ptr dx, float beta, magmaFloat_ptr dy, magma_queue_t queue)
	This routine computes y = alpha * A^t * x + beta * y on the GPU.
magma_int_t	magma_sgemvmdot (magma_int_t n, magma_int_t k, magmaFloat_ptr v, magmaFloat_ptr r, magmaFloat_ptr d1, magmaFloat_ptr d2, magmaFloat_ptr skp, magma_queue_t queue)
	This is an extension of the merged dot product above by chunking the set of vectors v_i such that the data always fits into cache.
magma_int_t	magma_sjacobi_diagscal (magma_int_t num_rows, magma_s_matrix d, magma_s_matrix b, magma_s_matrix *c, magma_queue_t queue)
	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_sjacobiupdate (magma_s_matrix t, magma_s_matrix b, magma_s_matrix d, magma_s_matrix *x, magma_queue_t queue)
	Updates the iteration vector x for the Jacobi iteration according to x=x+d.
magma_int_t	magma_sjacobispmvupdate (magma_int_t maxiter, magma_s_matrix A, magma_s_matrix t, magma_s_matrix b, magma_s_matrix d, magma_s_matrix *x, magma_queue_t queue)
	Updates the iteration vector x for the Jacobi iteration according to x=x+d.
magma_int_t	magma_sjacobispmvupdate_bw (magma_int_t maxiter, magma_s_matrix A, magma_s_matrix t, magma_s_matrix b, magma_s_matrix d, magma_s_matrix *x, magma_queue_t queue)
	Updates the iteration vector x for the Jacobi iteration according to x=x+d.
magma_int_t	magma_sjacobispmvupdateselect (magma_int_t maxiter, magma_int_t num_updates, magma_index_t *indices, magma_s_matrix A, magma_s_matrix t, magma_s_matrix b, magma_s_matrix d, magma_s_matrix tmp, magma_s_matrix *x, magma_queue_t queue)
	Updates the iteration vector x for the Jacobi iteration according to x=x+d.
magma_int_t	magma_sftjacobicontractions (magma_s_matrix xkm2, magma_s_matrix xkm1, magma_s_matrix xk, magma_s_matrix *z, magma_s_matrix *c, magma_queue_t queue)
	Computes the contraction coefficients c_i:
magma_int_t	magma_sftjacobiupdatecheck (float delta, magma_s_matrix *xold, magma_s_matrix *xnew, magma_s_matrix *zprev, magma_s_matrix c, magma_int_t *flag_t, magma_int_t *flag_fp, magma_queue_t queue)
	Checks the Jacobi updates accorting to the condition in the ScaLA'15 paper.
magma_int_t	magma_sgemvmdot_shfl (magma_int_t n, magma_int_t k, magmaFloat_ptr v, magmaFloat_ptr r, magmaFloat_ptr d1, magmaFloat_ptr d2, magmaFloat_ptr skp, magma_queue_t queue)
	This is an extension of the merged dot product above by chunking the set of vectors v_i such that the data always fits into cache.

Detailed Description

Function Documentation

magma_sftjacobi()

magma_int_t magma_sftjacobi	(	magma_s_matrix	A,
		magma_s_matrix	b,
		magma_s_matrix *	x,
		magma_s_solver_par *	solver_par,
		magma_queue_t	queue )

Iterates the solution approximation according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.

This routine takes the system matrix A and the RHS b as input. This is the fault-tolerant version of Jacobi according to ScalLA'15.

Parameters

[in]	A	magma_s_matrix input matrix M = D^(-1) * (L+U)
[in]	b	magma_s_matrix input RHS b
[in,out]	x	magma_s_matrix* iteration vector x
[in,out]	solver_par	magma_s_solver_par* solver parameters
[in]	queue	magma_queue_t Queue to execute in.

magma_sjacobisetup_matrix()

magma_int_t magma_sjacobisetup_matrix	(	magma_s_matrix	A,
		magma_s_matrix *	M,
		magma_s_matrix *	d,
		magma_queue_t	queue )

Prepares the Matrix M for the Jacobi Iteration according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.

It returns the preconditioner Matrix M and a vector d containing the diagonal elements.

Parameters

[in]	A	magma_s_matrix input matrix A
[in]	M	magma_s_matrix* M = D^(-1) * (L+U)
[in,out]	d	magma_s_matrix* vector with diagonal elements of A
[in]	queue	magma_queue_t Queue to execute in.

magma_sjacobisetup_diagscal()

magma_int_t magma_sjacobisetup_diagscal	(	magma_s_matrix	A,
		magma_s_matrix *	d,
		magma_queue_t	queue )

It returns a vector d containing the inverse diagonal elements.

Parameters

[in]	A	magma_s_matrix input matrix A
[in,out]	d	magma_s_matrix* vector with diagonal elements
[in]	queue	magma_queue_t Queue to execute in.

magma_sjacobisetup_vector()

magma_int_t magma_sjacobisetup_vector	(	magma_s_matrix	b,
		magma_s_matrix	d,
		magma_s_matrix *	c,
		magma_queue_t	queue )

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

Parameters

[in]	b	magma_s_matrix RHS b
[in]	d	magma_s_matrix vector with diagonal entries
[in]	c	magma_s_matrix* c = D^(-1) * b
[in]	queue	magma_queue_t Queue to execute in.

magma_sjacobisetup()

magma_int_t magma_sjacobisetup	(	magma_s_matrix	A,
		magma_s_matrix	b,
		magma_s_matrix *	M,
		magma_s_matrix *	c,
		magma_queue_t	queue )

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.

Parameters

[in]	A	magma_s_matrix input matrix A
[in]	b	magma_s_matrix RHS b
[in]	M	magma_s_matrix* M = D^(-1) * (L+U)
[in]	c	magma_s_matrix* c = D^(-1) * b
[in]	queue	magma_queue_t Queue to execute in.

magma_sjacobiiter()

magma_int_t magma_sjacobiiter	(	magma_s_matrix	M,
		magma_s_matrix	c,
		magma_s_matrix *	x,
		magma_s_solver_par *	solver_par,
		magma_queue_t	queue )

Iterates the solution approximation according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.

This routine takes the iteration matrix M as input.

Parameters

[in]	M	magma_s_matrix input matrix M = D^(-1) * (L+U)
[in]	c	magma_s_matrix c = D^(-1) * b
[in,out]	x	magma_s_matrix* iteration vector x
[in,out]	solver_par	magma_s_solver_par* solver parameters
[in]	queue	magma_queue_t Queue to execute in.

magma_sjacobiiter_precond()

magma_int_t magma_sjacobiiter_precond	(	magma_s_matrix	M,
		magma_s_matrix *	x,
		magma_s_solver_par *	solver_par,
		magma_s_preconditioner *	precond,
		magma_queue_t	queue )

Iterates the solution approximation according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.

Parameters

[in]	M	magma_s_matrix input matrix M = D^(-1) * (L+U)
[in,out]	x	magma_s_matrix* iteration vector x
[in,out]	solver_par	magma_s_solver_par* solver parameters
[in]	precond	magma_s_precond_par* precond parameters
[in]	queue	magma_queue_t Queue to execute in.

magma_sjacobiiter_sys()

magma_int_t magma_sjacobiiter_sys	(	magma_s_matrix	A,
		magma_s_matrix	b,
		magma_s_matrix	d,
		magma_s_matrix	t,
		magma_s_matrix *	x,
		magma_s_solver_par *	solver_par,
		magma_queue_t	queue )

Iterates the solution approximation according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.

This routine takes the system matrix A and the RHS b as input.

Parameters

[in]	A	magma_s_matrix input matrix M = D^(-1) * (L+U)
[in]	b	magma_s_matrix input RHS b
[in]	d	magma_s_matrix input matrix diagonal elements diag(A)
[in]	t	magma_s_matrix temporary vector
[in,out]	x	magma_s_matrix* iteration vector x
[in,out]	solver_par	magma_s_solver_par* solver parameters
[in]	queue	magma_queue_t Queue to execute in.

magma_scompactActive()

magma_int_t magma_scompactActive	(	magma_int_t	m,
		magma_int_t	n,
		magmaFloat_ptr	dA,
		magma_int_t	ldda,
		magmaInt_ptr	active,
		magma_queue_t	queue )

ZCOMPACTACTIVE takes a set of n vectors of size m (in dA) and an array of 1s and 0sindicating which vectors to compact (for 1s) and which to disregard (for 0s).

Parameters

[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 REAL 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]	active	INTEGER array, dimension N A mask of 1s and 0s showing if a vector remains or has been removed
[in]	queue	magma_queue_t Queue to execute in.

magma_sgeelltmv()

magma_int_t magma_sgeelltmv	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		magma_int_t	nnz_per_row,
		float	alpha,
		magmaFloat_ptr	dval,
		magmaIndex_ptr	dcolind,
		magmaFloat_ptr	dx,
		float	beta,
		magmaFloat_ptr	dy,
		magma_queue_t	queue )

This routine computes y = alpha * A^t * x + beta * y on the GPU.

Input format is ELL.

Parameters

[in]	transA	magma_trans_t transposition parameter for A
[in]	m	magma_int_t number of rows in A
[in]	n	magma_int_t number of columns in A
[in]	nnz_per_row	magma_int_t number of elements in the longest row
[in]	alpha	float scalar multiplier
[in]	dval	magmaFloat_ptr array containing values of A in ELL
[in]	dcolind	magmaIndex_ptr columnindices of A in ELL
[in]	dx	magmaFloat_ptr input vector x
[in]	beta	float scalar multiplier
[out]	dy	magmaFloat_ptr input/output vector y
[in]	queue	magma_queue_t Queue to execute in.

magma_sgemvmdot()

magma_int_t magma_sgemvmdot	(	magma_int_t	n,
		magma_int_t	k,
		magmaFloat_ptr	v,
		magmaFloat_ptr	r,
		magmaFloat_ptr	d1,
		magmaFloat_ptr	d2,
		magmaFloat_ptr	skp,
		magma_queue_t	queue )

This is an extension of the merged dot product above by chunking the set of vectors v_i such that the data always fits into cache.

It is equivalent to a matrix vecor product Vr where V contains few rows and many columns. The computation is the same:

skp = ( <v_0,r>, <v_1,r>, .. )

Returns the vector skp.

Parameters

[in]	n	int length of v_i and r
[in]	k	int

vectors v_i

Parameters

[in]	v	magmaFloat_ptr v = (v_0 .. v_i.. v_k)
[in]	r	magmaFloat_ptr r
[in]	d1	magmaFloat_ptr workspace
[in]	d2	magmaFloat_ptr workspace
[out]	skp	magmaFloat_ptr vector[k] of scalar products (<v_i,r>...)
[in]	queue	magma_queue_t Queue to execute in.

magma_sjacobi_diagscal()

magma_int_t magma_sjacobi_diagscal	(	magma_int_t	num_rows,
		magma_s_matrix	d,
		magma_s_matrix	b,
		magma_s_matrix *	c,
		magma_queue_t	queue )

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

Parameters

[in]	num_rows	magma_int_t number of rows
[in]	b	magma_s_matrix RHS b
[in]	d	magma_s_matrix vector with diagonal entries
[out]	c	magma_s_matrix* c = D^(-1) * b
[in]	queue	magma_queue_t Queue to execute in.

magma_sjacobiupdate()

magma_int_t magma_sjacobiupdate	(	magma_s_matrix	t,
		magma_s_matrix	b,
		magma_s_matrix	d,
		magma_s_matrix *	x,
		magma_queue_t	queue )

Updates the iteration vector x for the Jacobi iteration according to x=x+d.

*(b-t) where d is the diagonal of the system matrix A and t=Ax.

Parameters

[in]	t	magma_s_matrix t = A*x
[in]	b	magma_s_matrix RHS b
[in]	d	magma_s_matrix vector with diagonal entries
[out]	x	magma_s_matrix* iteration vector
[in]	queue	magma_queue_t Queue to execute in.

magma_sjacobispmvupdate()

magma_int_t magma_sjacobispmvupdate	(	magma_int_t	maxiter,
		magma_s_matrix	A,
		magma_s_matrix	t,
		magma_s_matrix	b,
		magma_s_matrix	d,
		magma_s_matrix *	x,
		magma_queue_t	queue )

Updates the iteration vector x for the Jacobi iteration according to x=x+d.

*(b-Ax)

Parameters

[in]	maxiter	magma_int_t number of Jacobi iterations
[in]	A	magma_s_matrix system matrix
[in]	t	magma_s_matrix workspace
[in]	b	magma_s_matrix RHS b
[in]	d	magma_s_matrix vector with diagonal entries
[out]	x	magma_s_matrix* iteration vector
[in]	queue	magma_queue_t Queue to execute in.

magma_sjacobispmvupdate_bw()

magma_int_t magma_sjacobispmvupdate_bw	(	magma_int_t	maxiter,
		magma_s_matrix	A,
		magma_s_matrix	t,
		magma_s_matrix	b,
		magma_s_matrix	d,
		magma_s_matrix *	x,
		magma_queue_t	queue )

Updates the iteration vector x for the Jacobi iteration according to x=x+d.

*(b-Ax) This kernel processes the thread blocks in reversed order.

Parameters

[in]	maxiter	magma_int_t number of Jacobi iterations
[in]	A	magma_s_matrix system matrix
[in]	t	magma_s_matrix workspace
[in]	b	magma_s_matrix RHS b
[in]	d	magma_s_matrix vector with diagonal entries
[out]	x	magma_s_matrix* iteration vector
[in]	queue	magma_queue_t Queue to execute in.

magma_sjacobispmvupdateselect()

magma_int_t magma_sjacobispmvupdateselect	(	magma_int_t	maxiter,
		magma_int_t	num_updates,
		magma_index_t *	indices,
		magma_s_matrix	A,
		magma_s_matrix	t,
		magma_s_matrix	b,
		magma_s_matrix	d,
		magma_s_matrix	tmp,
		magma_s_matrix *	x,
		magma_queue_t	queue )

Updates the iteration vector x for the Jacobi iteration according to x=x+d.

*(b-Ax)

This kernel allows for overlapping domains: the indices-array contains the locations that are updated. Locations may be repeated to simulate overlapping domains.

Parameters

[in]	maxiter	magma_int_t number of Jacobi iterations
[in]	num_updates	magma_int_t number of updates - length of the indices array
[in]	indices	magma_index_t* indices, which entries of x to update
[in]	A	magma_s_matrix system matrix
[in]	t	magma_s_matrix workspace
[in]	b	magma_s_matrix RHS b
[in]	d	magma_s_matrix vector with diagonal entries
[in]	tmp	magma_s_matrix workspace
[out]	x	magma_s_matrix* iteration vector
[in]	queue	magma_queue_t Queue to execute in.

magma_sftjacobicontractions()

magma_int_t magma_sftjacobicontractions	(	magma_s_matrix	xkm2,
		magma_s_matrix	xkm1,
		magma_s_matrix	xk,
		magma_s_matrix *	z,
		magma_s_matrix *	c,
		magma_queue_t	queue )

Computes the contraction coefficients c_i:

c_i = z_i^{k-1} / z_i^{k}

= | x_i^{k-1} - x_i^{k-2} | / |  x_i^{k} - x_i^{k-1} |

Parameters

[in]	xkm2	magma_s_matrix vector x^{k-2}
[in]	xkm1	magma_s_matrix vector x^{k-2}
[in]	xk	magma_s_matrix vector x^{k-2}
[out]	z	magma_s_matrix* ratio
[out]	c	magma_s_matrix* contraction coefficients
[in]	queue	magma_queue_t Queue to execute in.

magma_sftjacobiupdatecheck()

magma_int_t magma_sftjacobiupdatecheck	(	float	delta,
		magma_s_matrix *	xold,
		magma_s_matrix *	xnew,
		magma_s_matrix *	zprev,
		magma_s_matrix	c,
		magma_int_t *	flag_t,
		magma_int_t *	flag_fp,
		magma_queue_t	queue )

Checks the Jacobi updates accorting to the condition in the ScaLA'15 paper.

Parameters

[in]	delta	float threshold
[in,out]	xold	magma_s_matrix* vector xold
[in,out]	xnew	magma_s_matrix* vector xnew
[in,out]	zprev	magma_s_matrix* vector z = | x_k-1 - x_k |
[in]	c	magma_s_matrix contraction coefficients
[in,out]	flag_t	magma_int_t threshold condition
[in,out]	flag_fp	magma_int_t false positive condition
[in]	queue	magma_queue_t Queue to execute in.

magma_sgemvmdot_shfl()

magma_int_t magma_sgemvmdot_shfl	(	magma_int_t	n,
		magma_int_t	k,
		magmaFloat_ptr	v,
		magmaFloat_ptr	r,
		magmaFloat_ptr	d1,
		magmaFloat_ptr	d2,
		magmaFloat_ptr	skp,
		magma_queue_t	queue )

This is an extension of the merged dot product above by chunking the set of vectors v_i such that the data always fits into cache.

It is equivalent to a matrix vecor product Vr where V contains few rows and many columns. The computation is the same:

skp = ( <v_0,r>, <v_1,r>, .. )

Returns the vector skp.

Parameters

[in]	n	int length of v_i and r
[in]	k	int

vectors v_i

Parameters

[in]	v	magmaFloat_ptr v = (v_0 .. v_i.. v_k)
[in]	r	magmaFloat_ptr r
[in]	d1	magmaFloat_ptr workspace
[in]	d2	magmaFloat_ptr workspace
[out]	skp	magmaFloat_ptr vector[k] of scalar products (<v_i,r>...)
[in]	queue	magma_queue_t Queue to execute in.