core_zshift.c

Go to the documentation of this file.

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

#if defined(PLASMA_HAVE_WEAK)
#pragma weak CORE_zshiftw = PCORE_zshiftw
#define CORE_zshiftw PCORE_zshiftw
#endif
void CORE_zshiftw(int s, int cl, int m, int n, int L, PLASMA_Complex64_t *A, PLASMA_Complex64_t *W) {
    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(PLASMA_Complex64_t));
}

/***************************************************************************/
void QUARK_CORE_zshiftw(Quark *quark, Quark_Task_Flags *task_flags,
                        int s, int cl, int m, int n, int L, PLASMA_Complex64_t *A, PLASMA_Complex64_t *W)
{
    DAG_CORE_SHIFTW;
    QUARK_Insert_Task(quark, CORE_zshiftw_quark, task_flags,
        sizeof(int),                      &s,   VALUE,
        sizeof(int),                      &cl,  VALUE,
        sizeof(int),                      &m,   VALUE,
        sizeof(int),                      &n,   VALUE,
        sizeof(int),                      &L,   VALUE,
        sizeof(PLASMA_Complex64_t)*m*n*L, A,        INOUT,
        sizeof(PLASMA_Complex64_t)*L,     W,        INPUT,
        0);
}

/***************************************************************************/
#if defined(PLASMA_HAVE_WEAK)
#pragma weak CORE_zshiftw_quark = PCORE_zshiftw_quark
#define CORE_zshiftw_quark PCORE_zshiftw_quark
#endif
void CORE_zshiftw_quark(Quark *quark)
{
    int s;
    int cl;
    int m;
    int n;
    int L;
    PLASMA_Complex64_t *A;
    PLASMA_Complex64_t *W;

    quark_unpack_args_7(quark, s, cl, m, n, L, A, W);
    CORE_zshiftw(s, cl, m, n, L, A, W);
}

#if defined(PLASMA_HAVE_WEAK)
#pragma weak CORE_zshift = PCORE_zshift
#define CORE_zshift PCORE_zshift
#endif
void CORE_zshift(int s, int m, int n, int L, PLASMA_Complex64_t *A) {
    PLASMA_Complex64_t *W;

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

/***************************************************************************/
void QUARK_CORE_zshift(Quark *quark, Quark_Task_Flags *task_flags,
                       int s, int m, int n, int L, PLASMA_Complex64_t *A)
{
    DAG_CORE_SHIFT;
    QUARK_Insert_Task(quark, CORE_zshift_quark, task_flags,
        sizeof(int),                      &s,    VALUE,
        sizeof(int),                      &m,    VALUE,
        sizeof(int),                      &n,    VALUE,
        sizeof(int),                      &L,    VALUE,
        sizeof(PLASMA_Complex64_t)*m*n*L, A,        INOUT | GATHERV,
        sizeof(PLASMA_Complex64_t)*L,     NULL,     SCRATCH,
        0);
}

/***************************************************************************/
#if defined(PLASMA_HAVE_WEAK)
#pragma weak CORE_zshift_quark = PCORE_zshift_quark
#define CORE_zshift_quark PCORE_zshift_quark
#endif
void CORE_zshift_quark(Quark *quark)
{
    int s;
    int m;
    int n;
    int L;
    PLASMA_Complex64_t *A;
    PLASMA_Complex64_t *W;

    quark_unpack_args_6(quark, s, m, n, L, A, W);
    memcpy(W, &(A[s*L]), L*sizeof(PLASMA_Complex64_t));
    CORE_zshiftw(s, 0, m, n, L, A, W);
}