mpid_type_debug.c

fortran并行计算包

/* -*- Mode: C; c-basic-offset:4 ; -*- */

/*
 *  (C) 2001 by Argonne National Laboratory.
 *      See COPYRIGHT in top-level directory.
 */

#include "mpiimpl.h"
#include "mpid_dataloop.h"
#include <stdlib.h>
#include <limits.h>

/* MPI datatype debugging helper routines.
 * 
 * The one you want to call is:
 *   MPIDU_Datatype_debug(MPI_Datatype type, int array_ct)
 *
 * The "array_ct" value tells the call how many array values to print
 * for struct, indexed, and blockindexed types.
 *
 */


void MPIDI_Datatype_dot_printf(MPI_Datatype type, int depth, int header);
void MPIDI_Dataloop_dot_printf(MPID_Dataloop *loop_p, int depth, int header);
void MPIDI_Datatype_contents_printf(MPI_Datatype type, int depth, int acount);
static char *MPIDI_Datatype_depth_spacing(int depth);

/* note: this isn't really "error handling" per se, but leave these comments
 * because Bill uses them for coverage analysis.
 */

/* --BEGIN ERROR HANDLING-- */
void MPIDI_Datatype_dot_printf(MPI_Datatype type,
			       int depth,
			       int header)
{
    if (HANDLE_GET_KIND(type) == HANDLE_KIND_BUILTIN) {
	MPIU_DBG_OUT(DATATYPE,
			 "MPIDI_Datatype_dot_printf: type is a basic");
	return;
    }
    else {
	MPID_Datatype *dt_p;
	MPID_Dataloop *loop_p;

	MPID_Datatype_get_ptr(type, dt_p);
	loop_p = dt_p->dataloop;

	MPIDI_Dataloop_dot_printf(loop_p, depth, header);
	return;
    }
}

void MPIDI_Dataloop_dot_printf(MPID_Dataloop *loop_p,
			       int depth,
			       int header)
{
    int i;

    if (loop_p == NULL) {
	MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,"<null dataloop>\n"));
	return;
    }

    if (header) {
	MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,
				   "digraph %p {   {", loop_p));
    }

    switch (loop_p->kind & DLOOP_KIND_MASK) {
	case DLOOP_KIND_CONTIG:
	    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,
	    "      dl%d [shape = record, label = \"contig |{ ct = %d; el_sz = %d; el_ext = %d }\"];",
			    depth,
			    (int) loop_p->loop_params.c_t.count,
			    (int) loop_p->el_size,
			    (int) loop_p->el_extent));
	    break;
	case DLOOP_KIND_VECTOR:
	    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,
	    "      dl%d [shape = record, label = \"vector |{ ct = %d; blk = %d; str = %d; el_sz = %d; el_ext = %d }\"];",
			    depth,
			    (int) loop_p->loop_params.v_t.count,
			    (int) loop_p->loop_params.v_t.blocksize,
			    (int) loop_p->loop_params.v_t.stride,
			    (int) loop_p->el_size,
			    (int) loop_p->el_extent));
	    break;
	case DLOOP_KIND_INDEXED:
	    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,
	    "      dl%d [shape = record, label = \"indexed |{ ct = %d; tot_blks = %d; regions = ",
			    depth,
			    (int) loop_p->loop_params.i_t.count,
			    (int) loop_p->loop_params.i_t.total_blocks));
	    
	    /* 3 picked as arbitrary cutoff */
	    for (i=0; i < 3 && i < loop_p->loop_params.i_t.count; i++) {
		if (i + 1 < loop_p->loop_params.i_t.count) {
		    /* more regions after this one */
		    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,
		    "(%d, %d), ",
			  (int) loop_p->loop_params.i_t.offset_array[i],
		          (int) loop_p->loop_params.i_t.blocksize_array[i]));
		}
		else {
		    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,
		           "(%d, %d); ",
		           (int) loop_p->loop_params.i_t.offset_array[i],
			   (int) loop_p->loop_params.i_t.blocksize_array[i]));
		}
	    }
	    if (i < loop_p->loop_params.i_t.count) {
		MPIU_DBG_OUT(DATATYPE,"...; ");
	    }

	    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,
				       "el_sz = %d; el_ext = %d }\"];\n",
				       (int) loop_p->el_size,
				       (int) loop_p->el_extent));
	    break;
	case DLOOP_KIND_BLOCKINDEXED:
	    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,
	    "      dl%d [shape = record, label = \"blockindexed |{ ct = %d; blk = %d; disps = ",
			    depth,
			    (int) loop_p->loop_params.bi_t.count,
			    (int) loop_p->loop_params.bi_t.blocksize));
	    
	    /* 3 picked as arbitrary cutoff */
	    for (i=0; i < 3 && i < loop_p->loop_params.bi_t.count; i++) {
		if (i + 1 < loop_p->loop_params.bi_t.count) {
		    /* more regions after this one */
		    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,
		        "%d, ",
			(int) loop_p->loop_params.bi_t.offset_array[i]));
		}
		else {
		    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,
		         "%d; ",
		         (int) loop_p->loop_params.bi_t.offset_array[i]));
		}
	    }
	    if (i < loop_p->loop_params.bi_t.count) {
		MPIU_DBG_OUT(DATATYPE,"...; ");
	    }

	    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,
				      "el_sz = %d; el_ext = %d }\"];",
				       (int) loop_p->el_size,
				       (int) loop_p->el_extent));
	    break;
	case DLOOP_KIND_STRUCT:
	    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,
	    "      dl%d [shape = record, label = \"struct | {ct = %d; blks = ",
			    depth,
			    (int) loop_p->loop_params.s_t.count));
	    for (i=0; i < 3 && i < loop_p->loop_params.s_t.count; i++) {
		if (i + 1 < loop_p->loop_params.s_t.count) {
		    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,"%d, ",
			    (int) loop_p->loop_params.s_t.blocksize_array[i]));
		}
		else {
		    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,"%d; ",
			    (int) loop_p->loop_params.s_t.blocksize_array[i]));
		}
	    }
	    if (i < loop_p->loop_params.s_t.count) {
		MPIU_DBG_OUT(DATATYPE,"...; disps = ");
	    }
	    else {
		MPIU_DBG_OUT(DATATYPE,"disps = ");
	    }

	    for (i=0; i < 3 && i < loop_p->loop_params.s_t.count; i++) {
		if (i + 1 < loop_p->loop_params.s_t.count) {
		    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,"%d, ",
			    (int) loop_p->loop_params.s_t.offset_array[i]));
		}
		else {
		    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,"%d; ",
			    (int) loop_p->loop_params.s_t.offset_array[i]));
		}
	    }
	    if (i < loop_p->loop_params.s_t.count) {
		MPIU_DBG_OUT(DATATYPE,"... }\"];");
	    }
	    else {
		MPIU_DBG_OUT(DATATYPE,"}\"];");
	    }
	    break;
	default:
	    MPIU_Assert(0);
    }

    if (!(loop_p->kind & DLOOP_FINAL_MASK)) {
	/* more loops to go; recurse */
	MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,
				   "      dl%d -> dl%d;\n", depth, depth + 1));
	switch (loop_p->kind & DLOOP_KIND_MASK) {
	    case DLOOP_KIND_CONTIG:
		MPIDI_Dataloop_dot_printf(loop_p->loop_params.c_t.dataloop, depth + 1, 0);
		break;
	    case DLOOP_KIND_VECTOR:
		MPIDI_Dataloop_dot_printf(loop_p->loop_params.v_t.dataloop, depth + 1, 0);
		break;
	    case DLOOP_KIND_INDEXED:
		MPIDI_Dataloop_dot_printf(loop_p->loop_params.i_t.dataloop, depth + 1, 0);
		break;
	    case DLOOP_KIND_BLOCKINDEXED:
		MPIDI_Dataloop_dot_printf(loop_p->loop_params.bi_t.dataloop, depth + 1, 0);
		break;
	    case DLOOP_KIND_STRUCT:
		for (i=0; i < loop_p->loop_params.s_t.count; i++) {
		    MPIDI_Dataloop_dot_printf(loop_p->loop_params.s_t.dataloop_array[i],
					      depth + 1, 0);
		}
		break;
	    default:
		MPIU_DBG_OUT(DATATYPE,"      < unsupported type >");
	}
    }


    if (header) {
	MPIU_DBG_OUT(DATATYPE,"   }\n}");
    }
    return;
}

void MPIDI_Datatype_printf(MPI_Datatype type,
			   int depth,
			   MPI_Aint displacement,
			   int blocklength,
			   int header)
{
    char *string;
    int size;
    MPI_Aint extent, true_lb, true_ub, lb, ub, sticky_lb, sticky_ub;
    MPIU_THREADPRIV_DECL;
    
    MPIU_THREADPRIV_GET;

    if (HANDLE_GET_KIND(type) == HANDLE_KIND_BUILTIN) {
	string = MPIDU_Datatype_builtin_to_string(type);
	if (type == MPI_LB) sticky_lb = 1;
	else sticky_lb = 0;
	if (type == MPI_UB) sticky_ub = 1;
	else sticky_ub = 0;
    }
    else {
	MPID_Datatype *type_ptr;

	MPID_Datatype_get_ptr(type, type_ptr);
	string = MPIDU_Datatype_combiner_to_string(type_ptr->contents->combiner);
	sticky_lb = type_ptr->has_sticky_lb;
	sticky_ub = type_ptr->has_sticky_ub;
    }

    MPIR_Nest_incr();
    NMPI_Type_size(type, &size);
    NMPI_Type_get_true_extent(type, &true_lb, &extent);
    true_ub = extent + true_lb;
    NMPI_Type_get_extent(type, &lb, &extent);
    ub = extent + lb;
    MPIR_Nest_decr();

    if (header == 1) {
	/*               012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 */
	MPIU_DBG_OUT(DATATYPE,"------------------------------------------------------------------------------------------------------------------------------------------\n");
	MPIU_DBG_OUT(DATATYPE,"depth                   type         size       extent      true_lb      true_ub           lb(s)           ub(s)         disp       blklen\n");
	MPIU_DBG_OUT(DATATYPE,"------------------------------------------------------------------------------------------------------------------------------------------\n");
    }
    MPIU_DBG_OUT_FMT(DATATYPE,(MPIU_DBG_FDEST,"%5d  %21s  %11d  %11d  %11d  %11d  %11d(%1d)  %11d(%1d)  %11d  %11d",
		    depth,
		    string,
		    (int) size,
		    (int) extent,
		    (int) true_lb,
		    (int) true_ub,
		    (int) lb,
		    (int) sticky_lb,
		    (int) ub,
		    (int) sticky_ub,
		    (int) displacement,
		    (int) blocklength));
    return;
}
/* --END ERROR HANDLING-- */

/* longest string is 21 characters */
char *MPIDU_Datatype_builtin_to_string(MPI_Datatype type)
{
    static char t_char[]             = "MPI_CHAR";
    static char t_uchar[]            = "MPI_UNSIGNED_CHAR";
    static char t_byte[]             = "MPI_BYTE";
    static char t_wchar_t[]          = "MPI_WCHAR";
    static char t_short[]            = "MPI_SHORT";
    static char t_ushort[]           = "MPI_UNSIGNED_SHORT";
    static char t_int[]              = "MPI_INT";
    static char t_uint[]             = "MPI_UNSIGNED";
    static char t_long[]             = "MPI_LONG";
    static char t_ulong[]            = "MPI_UNSIGNED_LONG";
    static char t_float[]            = "MPI_FLOAT";
    static char t_double[]           = "MPI_DOUBLE";
    static char t_longdouble[]       = "MPI_LONG_DOUBLE";
    static char t_longlongint[]      = "MPI_LONG_LONG_INT";
    static char t_longlong[]         = "MPI_LONG_LONG";
    static char t_ulonglong[]        = "MPI_UNSIGNED_LONG_LONG";
    static char t_schar[]            = "MPI_SIGNED_CHAR";

    static char t_packed[]           = "MPI_PACKED";
    static char t_lb[]               = "MPI_LB";
    static char t_ub[]               = "MPI_UB";