#include <stdlib.h>
#include "common.h"
#include "quark.h"

Include dependency graph for core_dshift.c:

Functions
void	CORE_dshiftw (int s, int cl, int m, int n, int L, double A, double W)
void	QUARK_CORE_dshiftw (Quark quark, Quark_Task_Flags task_flags, int s, int cl, int m, int n, int L, double A, double W)
void	CORE_dshiftw_quark (Quark *quark)
void	CORE_dshift (int s, int m, int n, int L, double *A)
void	QUARK_CORE_dshift (Quark quark, Quark_Task_Flags task_flags, int s, int m, int n, int L, double *A)
void	CORE_dshift_quark (Quark *quark)

Detailed Description

PLASMA InPlaceTransformation module PLASMA is a software package provided by Univ. of Tennessee, Univ. of California Berkeley and Univ. of Colorado Denver

This work is the implementation of an inplace transformation based on the GKK algorithm by Gustavson, Karlsson, Kagstrom and its fortran implementation.

Version:: 2.4.5

Author:: Mathieu Faverge

Date:: 2010-11-15

d Tue Nov 22 14:35:21 2011

Definition in file core_dshift.c.

Function Documentation

void CORE_dshift	(	int	s,
		int	m,
		int	n,
		int	L,
		double *	A
	)

CORE_dshift Shift a cycle of block. Same as core_dshiftw but you don't need to provide the workspace. As a matter of fact, the cycle cannot be split anymore to keep data coherency.

Parameters:

[in]	s	Start value in the cycle
[in]	m	Number of lines of tile A
[in]	n	Number of columns of tile A
[in]	L	Length of each block of data to move
[in,out]	A	Matrix of size m-by-n with each element of size L. On exit, A = A', where A' contains the permutations

Definition at line 175 of file core_dshift.c.

References CORE_dshiftw(), and W.

                                                        {
    double *W;
    W = (double*)malloc(L * sizeof(double));
    memcpy(W, &(A[s*L]), L*sizeof(double));
    CORE_dshiftw(s, 0, m, n, L, A, W);
    free(W);
}

Here is the call graph for this function:

void CORE_dshift_quark ( Quark * quark )

Definition at line 208 of file core_dshift.c.

References A, CORE_dshiftw(), L, quark_unpack_args_6, and W.

{
    int s;
    int m;
    int n;
    int L;
    double *A;
    double *W;
    quark_unpack_args_6(quark, s, m, n, L, A, W);
    memcpy(W, &(A[s*L]), L*sizeof(double));
    CORE_dshiftw(s, 0, m, n, L, A, W);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_dshiftw	(	int	s,
		int	cl,
		int	m,
		int	n,
		int	L,
		double *	A,
		double *	W
	)

CORE_dshiftw Shift a linear chain of block using a supplied workspace by following the cycle defined by: k_(i+1) = (k_i * m) % q;

Parameters:

[in]	s	Start value in the cycle
[in]	cl	Cycle length if cl == 0, all the permutations from the cycle are done else the cycle is split onto several threads and the number of permutation to do has to be specified to not get overlap
[in]	m	Number of lines of tile A
[in]	n	Number of columns of tile A
[in]	L	Length of each block of data to move
[in,out]	A	Matrix of size m-by-n with each element of size L. On exit, A = A', where A' contains the permutations
[in]	W	Array of size L. On entry, must contain: W(:) = A(sL:sL+L-1)

Definition at line 66 of file core_dshift.c.

References L.

                                                                            {
    int64_t k, k1;
    int     i, j, q, kL, k1L;
    q = m * n - 1;
    k = s;
    if( cl != 0 ) {
        for (i=1; i<cl; i++) {
            k1 = (k * m) % (int64_t)q;
            
            /* A(k*L:k*L+L-1) = A(k1*L:k1*L+L-1) */
            kL  = k *L;
            k1L = k1*L;
            for(j=0; j<L; j++) {
                A[kL+j] = A[k1L+j];
            }
            k = k1;
        }
    } 
    else {
        while (1) {
            k1 = (k * m) % (int64_t)q;
            if( k1 == s ) 
                break;
            
            /* A(k*L:k*L+L-1) = A(k1*L:k1*L+L-1) */
            kL  = k *L;
            k1L = k1*L;
            for (j=0; j<L; j++) {
                A[kL+j] = A[k1L+j];
            }
            k = k1;
        }
    }
    memcpy(&(A[k*L]), W, L*sizeof(double));
}

Here is the caller graph for this function:

void CORE_dshiftw_quark ( Quark * quark )

Definition at line 130 of file core_dshift.c.

References A, CORE_dshiftw(), L, quark_unpack_args_7, and W.

{
    int s;
    int cl;
    int m;
    int n;
    int L;
    double *A;
    double *W;
    quark_unpack_args_7(quark, s, cl, m, n, L, A, W);
    CORE_dshiftw(s, cl, m, n, L, A, W);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_dshift	(	Quark *	quark,
		Quark_Task_Flags *	task_flags,
		int	s,
		int	m,
		int	n,
		int	L,
		double *	A
	)

Definition at line 187 of file core_dshift.c.

References CORE_dshift_quark(), DAG_CORE_SHIFT, GATHERV, INOUT, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
    DAG_CORE_SHIFT;
    QUARK_Insert_Task(quark, CORE_dshift_quark, task_flags,
        sizeof(int),                      &s,    VALUE,
        sizeof(int),                      &m,    VALUE,
        sizeof(int),                      &n,    VALUE,
        sizeof(int),                      &L,    VALUE,
        sizeof(double)*m*n*L, A,        INOUT | GATHERV,
        sizeof(double)*L,     NULL,     SCRATCH,
        0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_dshiftw	(	Quark *	quark,
		Quark_Task_Flags *	task_flags,
		int	s,
		int	cl,
		int	m,
		int	n,
		int	L,
		double *	A,
		double *	W
	)

Definition at line 108 of file core_dshift.c.

References CORE_dshiftw_quark(), DAG_CORE_SHIFTW, INOUT, INPUT, QUARK_Insert_Task(), and VALUE.

{
    DAG_CORE_SHIFTW;
    QUARK_Insert_Task(quark, CORE_dshiftw_quark, task_flags,
        sizeof(int),                      &s,   VALUE,
        sizeof(int),                      &cl,  VALUE,
        sizeof(int),                      &m,   VALUE,
        sizeof(int),                      &n,   VALUE,
        sizeof(int),                      &L,   VALUE,
        sizeof(double)*m*n*L, A,        INOUT,
        sizeof(double)*L,     W,        INPUT,
        0);
}

Here is the call graph for this function:

Functions

Detailed Description

Function Documentation