descriptor_helpers.c

Go to the documentation of this file.

 
#include "control/common.h"
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include "control/descriptor.h"
#include "chameleon/runtime.h"
 
int chameleon_getrankof_2d( const CHAM_desc_t *A, int m, int n )
{
    int mm = m + A->i / A->mb;
    int nn = n + A->j / A->nb;
    return (mm % chameleon_desc_datadist_get_iparam(A,0)) * chameleon_desc_datadist_get_iparam(A,1) + (nn % chameleon_desc_datadist_get_iparam(A,1));
}
 
int chameleon_getrankof_2d_diag( const CHAM_desc_t *A, int m, int n )
{
    int mm = m + A->i / A->mb;
    (void)n;
    return (mm % chameleon_desc_datadist_get_iparam(A,0)) * chameleon_desc_datadist_get_iparam(A,1) + (mm % chameleon_desc_datadist_get_iparam(A,1));
}
 
int chameleon_getrankof_ipiv_2d_row( const CHAM_ipiv_t *IPIV, int m, int n )
{
    int Q = IPIV->NP / IPIV->P;
    (void)n;
    return ( m % IPIV->P ) * Q;
}
 
int chameleon_getrankof_ipiv_2d_col( const CHAM_ipiv_t *IPIV, int m, int n )
{
    int Q = IPIV->NP / IPIV->P;
    (void)m;
    return n % Q;
}
 
int chameleon_getrankof_ipiv_2d_diag( const CHAM_ipiv_t *IPIV, int m, int n )
{
    (void)n;
    int Q = IPIV->NP / IPIV->P;
    return (m % IPIV->P) * Q + (m % Q);
}
 
int chameleon_involved_in_panelk_2dbc( const CHAM_desc_t *A, int k ) {
    int myrank = A->myrank;
    return ( myrank % chameleon_desc_datadist_get_iparam(A,1) == k % chameleon_desc_datadist_get_iparam(A,1) );
}
 
int chameleon_p_involved_in_panelk_2dbc( const CHAM_desc_t *A, int k, int p ) {
    return ( p % chameleon_desc_datadist_get_iparam(A,1) == k % chameleon_desc_datadist_get_iparam(A,1) );
}
 
void chameleon_get_proc_involved_in_panelk_2dbc( const CHAM_desc_t *A,
                                                 int                k,
                                                 int                n,
                                                 void              *ws_reduce )
{
#if defined (CHAMELEON_USE_MPI)
    CHAM_reduce_t *reduce        = (CHAM_reduce_t*) ws_reduce;
    int           *proc_involved = reduce->proc_involved;
    int            b, rank, np;
 
    np = 0;
    reduce->involved = 0;
    for ( b = k; (b < A->mt) && ((b-k) < chameleon_desc_datadist_get_iparam(A, 0)); b ++ ) {
        rank = A->get_rankof( A, b, n );
        proc_involved[ b-k ] = rank;
        np ++;
        if ( rank == A->myrank ) {
            reduce->involved = 1;
        }
    }
    reduce->proc_involved = proc_involved;
    reduce->np_involved   = np;
#else
    (void)A;
    (void)k;
    (void)n;
    (void)ws_reduce;
#endif
}
 
void chameleon_get_proc_involved_in_rowpanelk_2dbc( const CHAM_desc_t *A,
                                                    int                m,
                                                    int                k,
                                                    void              *ws_reduce )
{
#if defined (CHAMELEON_USE_MPI)
    CHAM_reduce_t *reduce = (CHAM_reduce_t*) ws_reduce;
    int           *proc_involved = reduce->proc_involved;
    int            b, rank, np;
 
    np = 0;
    reduce->involved = 0;
    for ( b = k; (b < A->nt) && ((b-k) < chameleon_desc_datadist_get_iparam(A, 1)); b ++ ) {
        rank = chameleon_getrankof_2d( A, m, b );
        proc_involved[ b-k ] = rank;
        np ++;
        if ( rank == A->myrank ) {
            reduce->involved = 1;
        }
    }
    reduce->proc_involved = proc_involved;
    reduce->np_involved   = np;
#else
    (void)A;
    (void)k;
    (void)m;
    (void)ws_reduce;
#endif
}
 
int chameleon_getrankof_custom_init( custom_dist_t **custom_dist,
                                     const char     *dist_file )
{
    custom_dist_t *result;
    FILE          *f;
    int            i, j, rc;
    int            np, dist_m, dist_n;
 
    *custom_dist = NULL;
 
    /* Get number of processes to check for correctness */
    np = CHAMELEON_Comm_size();
 
    /* Allocate memory */
    result = (custom_dist_t*) malloc( sizeof(custom_dist_t) );
    if ( result == NULL ) {
        chameleon_error( "chameleon_getrankof_custom_init", "malloc() failed" );
        return CHAMELEON_ERR_OUT_OF_RESOURCES;
    }
 
    result->dist_file = dist_file;
    f = fopen( result->dist_file , "r" );
    if ( f == NULL ) {
        char message[300];
        snprintf( message, 300, "could not open file '%s'", dist_file );
        chameleon_error( "chameleon_getrankof_custom_init", message );
        free( result );
        return CHAMELEON_ERR_ILLEGAL_VALUE;
    }
 
    rc = fscanf( f, "%d %d", &dist_m, &dist_n );
    if ( rc < 2 ) {
        char message[300];
        snprintf( message, 300, "could not read m and n in file '%s'", dist_file );
        chameleon_error( "chameleon_getrankof_custom_init", message );
        free( result );
        fclose( f );
        return CHAMELEON_ERR_ILLEGAL_VALUE;
    }
 
    if ( (dist_m <= 0 ) || (dist_n <= 0) ) {
        char message[300];
        snprintf( message, 300, "Incorrect values for dist_m(%d) and/or dist_n(%d)", dist_m, dist_n );
        chameleon_error( "chameleon_getrankof_custom_init", message );
        free( result );
        fclose( f );
        return CHAMELEON_ERR_ILLEGAL_VALUE;
    }
 
    result->dist_m = dist_m;
    result->dist_n = dist_n;
 
    result->blocks_dist = (int*) malloc( sizeof(int) * dist_m * dist_n );
    if ( result->blocks_dist == NULL ) {
        chameleon_error( "chameleon_getrankof_custom_init", "could not allocate blocks table" );
        free( result );
        fclose( f );
        return CHAMELEON_ERR_OUT_OF_RESOURCES;
    }
 
    for(i = 0; i < dist_m; i++) {
        for(j = 0; j < dist_n; j++) {
            int rank;
 
            rc = fscanf( f, "%d", &rank );
            if ( rc < 1 ) {
                char message[300];
                snprintf(message, 300, "file '%s': could not read value at position (%d, %d)", dist_file, i, j );
                chameleon_error( "chameleon_getrankof_custom_init", message );
                free( result->blocks_dist );
                free( result );
                fclose( f );
                return CHAMELEON_ERR_ILLEGAL_VALUE;
            }
 
            if ( (rank < 0 ) || (rank >= np) )
            {
                char message[300];
                snprintf( message, 300, "file '%s': value %d at position (%d, %d) is invalid with %d processes",
                          dist_file, rank, i, j, np );
                chameleon_error( "chameleon_getrankof_custom_init", message );
                free( result->blocks_dist );
                free( result );
                fclose( f );
                return CHAMELEON_ERR_ILLEGAL_VALUE;
            }
 
            result->blocks_dist[j * dist_m + i] = rank;
        }
    }
    fclose(f);
 
    *custom_dist = result;
    return CHAMELEON_SUCCESS;
}
 
int
chameleon_getrankof_custom_destroy( custom_dist_t **dist )
{
    if ((dist == NULL) || (*dist == NULL)) {
        chameleon_error("chameleon_getrankof_custom_destroy", "attempting to destroy a NULL descriptor");
        return CHAMELEON_ERR_UNALLOCATED;
    }
 
    free((*dist)->blocks_dist);
    free(*dist);
    *dist = NULL;
    return CHAMELEON_SUCCESS;
}
 
int chameleon_getrankof_custom( const CHAM_desc_t *desc, int m, int n )
{
    custom_dist_t *dist = desc->get_rankof_init_arg;
    return dist->blocks_dist[(n % dist->dist_n) * dist->dist_m + (m % dist->dist_m)];
}
 
void* chameleon_getaddr_ccrb( const CHAM_desc_t *A, int m, int n )
{
    size_t mm = m + A->i / A->mb;
    size_t nn = n + A->j / A->nb;
    size_t eltsize = CHAMELEON_Element_Size(A->dtyp);
    size_t offset  = 0;
 
#if defined(CHAMELEON_USE_MPI)
    assert( A->myrank == A->get_rankof( A, mm, nn ) );
    mm = mm / chameleon_desc_datadist_get_iparam(A, 0);
    nn = nn / chameleon_desc_datadist_get_iparam(A, 1);
#endif
 
    if (mm < (size_t)(A->llm1)) {
        if (nn < (size_t)(A->lln1))
            offset = (size_t)(A->bsiz) * (mm + (size_t)(A->llm1) * nn );
        else
            offset = A->A12 + ((size_t)(A->mb * (A->lln%A->nb)) * mm );
    }
    else {
        if (nn < (size_t)(A->lln1))
            offset = A->A21 + ((size_t)((A->llm%A->mb) * A->nb) * nn );
        else
            offset = A->A22;
    }
 
    return (void*)((intptr_t)A->mat + (offset*eltsize) );
}
 
void *chameleon_getaddr_cm( const CHAM_desc_t *A, int m, int n )
{
    size_t eltsize = CHAMELEON_Element_Size(A->dtyp);
    size_t offset  = chameleon_getaddr_cm_offset( A, m, n, A->llm );
 
    return (void*)((intptr_t)A->mat + (offset*eltsize) );
}
 
void *chameleon_getaddr_diag( const CHAM_desc_t *A, int m, int n )
{
    (void)n;
    return chameleon_getaddr_ccrb( A, m, 0 );
}
 
void *chameleon_getaddr_null( const CHAM_desc_t *A, int m, int n )
{
    (void)A; (void)m; (void)n;
    return NULL;
}
 
int chameleon_getblkldd_ccrb( const CHAM_desc_t *A, int m )
{
    int mm = m + A->i / A->mb;
    return ( ((mm+1) == A->lmt) && ((A->lm % A->mb) != 0)) ? A->lm % A->mb : A->mb;
}
 
int chameleon_getblkldd_cm( const CHAM_desc_t *A, int m )
{
    (void)m;
    return A->llm;
}