errutil.c

mpi并行计算的c++代码 可用vc或gcc编译通过 可以用来搭建并行计算试验环境

    {
	int generic_idx;
		    
	generic_idx = ((errcode & ERROR_GENERIC_MASK) >> ERROR_GENERIC_SHIFT) - 1;
	
	if (generic_idx >= 0)
	{
	    fprintf(fp, "(unknown)(): %s\n", generic_err_msgs[generic_idx].long_name);
	    goto fn_exit;
	}
    }
#   endif
    
    {
	int error_class;

	error_class = ERROR_GET_CLASS(errcode);
	
	if (error_class <= MPICH_ERR_LAST_CLASS)
	{
	    fprintf(fp, "(unknown)(): %s\n", get_class_msg(ERROR_GET_CLASS(errcode)));
	}
	else
	{
	    fprintf(fp, "Error code contains an invalid class (%d)\n", error_class);
	}
    }
    
  fn_exit:
    return;
}

void MPIR_Err_print_stack_string(int errcode, char *str, int maxlen)
{
    int len;
    char *str_orig = str;
#   if MPICH_ERROR_MSG_LEVEL >= MPICH_ERROR_MSG_ALL
    {
	error_ring_mutex_lock();
	{
	    /* Find the longest fcname in the stack */
	    int max_fcname_len = 0;
	    int tmp_errcode = errcode;
	    while (tmp_errcode != MPI_SUCCESS)
	    {
		int ring_idx;
		int ring_id;
		int generic_idx;

		if (convertErrcodeToIndexes( tmp_errcode, &ring_idx, &ring_id,
					     &generic_idx ) != 0) {
		    MPIU_Error_printf( 
		  "Invalid error code (%d) (error ring index %d invalid)\n", 
		  tmp_errcode, ring_idx );
		    break;
		}

		if (generic_idx < 0)
		{
		    break;
		}
		    
		if (ErrorRing[ring_idx].id == ring_id) {
		    len = (int)strlen(ErrorRing[ring_idx].fcname);
		    max_fcname_len = MPIR_MAX(max_fcname_len, len);
		    tmp_errcode = ErrorRing[ring_idx].prev_error;
		}
		else
		{
		    break;
		}
	    }
	    max_fcname_len += 2; /* add space for the ": " */
	    /*printf("max_fcname_len = %d\n", max_fcname_len);fflush(stdout);*/
	    /* print the error stack */
	    while (errcode != MPI_SUCCESS)
	    {
		int ring_idx;
		int ring_id;
		int generic_idx;
		int i;
		char *cur_pos;

		if (convertErrcodeToIndexes( errcode, &ring_idx, &ring_id,
					     &generic_idx ) != 0) {
		    MPIU_Error_printf( 
		  "Invalid error code (%d) (error ring index %d invalid)\n", 
		  errcode, ring_idx );
		    break;
		}

		if (generic_idx < 0)
		{
		    break;
		}
		    
		if (ErrorRing[ring_idx].id == ring_id)
		{
		    MPIU_Snprintf(str, maxlen, "%s", ErrorRing[ring_idx].fcname);
		    len = (int)strlen(str);
		    maxlen -= len;
		    str += len;
		    for (i=0; i<max_fcname_len - (int)strlen(ErrorRing[ring_idx].fcname) - 2; i++)
		    {
			if (MPIU_Snprintf(str, maxlen, "."))
			{
			    maxlen--;
			    str++;
			}
		    }
		    if (MPIU_Snprintf(str, maxlen, ":"))
		    {
			maxlen--;
			str++;
		    }
		    if (MPIU_Snprintf(str, maxlen, " "))
		    {
			maxlen--;
			str++;
		    }

		    if (MPIR_Err_chop_error_stack)
		    {
			cur_pos = ErrorRing[ring_idx].msg;
			len = (int)strlen(cur_pos);
			if (len == 0)
			{
			    if (MPIU_Snprintf(str, maxlen, "\n"))
			    {
				maxlen--;
				str++;
			    }
			}
			while (len)
			{
			    if (len >= MPIR_Err_chop_width - max_fcname_len)
			    {
				if (len > maxlen)
				    break;
				MPIU_Snprintf(str, MPIR_Err_chop_width - 1 - max_fcname_len, "%s", cur_pos);
				str[MPIR_Err_chop_width - 1 - max_fcname_len] = '\n';
				cur_pos += MPIR_Err_chop_width - 1 - max_fcname_len;
				str += MPIR_Err_chop_width - max_fcname_len;
				maxlen -= MPIR_Err_chop_width - max_fcname_len;
				if (maxlen < max_fcname_len)
				    break;
				for (i=0; i<max_fcname_len; i++)
				{
				    MPIU_Snprintf(str, maxlen, " ");
				    maxlen--;
				    str++;
				}
				len = (int)strlen(cur_pos);
			    }
			    else
			    {
				MPIU_Snprintf(str, maxlen, "%s\n", cur_pos);
				len = (int)strlen(str);
				maxlen -= len;
				str += len;
				len = 0;
			    }
			}
		    }
		    else
		    {
			MPIU_Snprintf(str, maxlen, "%s\n", ErrorRing[ring_idx].msg);
			len = (int)strlen(str);
			maxlen -= len;
			str += len;
		    }
		    /*
		    MPIU_Snprintf(str, maxlen, "%s: %s\n", ErrorRing[ring_idx].fcname, ErrorRing[ring_idx].msg);
		    len = (int)strlen(str);
		    maxlen -= len;
		    str += len;
		    */
		    errcode = ErrorRing[ring_idx].prev_error;
		}
		else
		{
		    break;
		}
	    }
	}
	error_ring_mutex_unlock();

	if (errcode == MPI_SUCCESS)
	{
	    goto fn_exit;
	}
    }
#   endif

#   if MPICH_ERROR_MSG_LEVEL > MPICH_ERROR_MSG_NONE
    {
	int generic_idx;
		    
	generic_idx = ((errcode & ERROR_GENERIC_MASK) >> ERROR_GENERIC_SHIFT) - 1;
	
	if (generic_idx >= 0)
	{
	    MPIU_Snprintf(str, maxlen, "(unknown)(): %s\n", generic_err_msgs[generic_idx].long_name);
	    len = (int)strlen(str);
	    maxlen -= len;
	    str += len;
	    goto fn_exit;
	}
    }
#   endif
    
    {
	int error_class;

	error_class = ERROR_GET_CLASS(errcode);
	
	if (error_class <= MPICH_ERR_LAST_CLASS)
	{
	    MPIU_Snprintf(str, maxlen, "(unknown)(): %s\n", get_class_msg(ERROR_GET_CLASS(errcode)));
	    len = (int)strlen(str);
	    maxlen -= len;
	    str += len;
	}
	else
	{
	    MPIU_Snprintf(str, maxlen, "Error code contains an invalid class (%d)\n", error_class);
	    len = (int)strlen(str);
	    maxlen -= len;
	    str += len;
	}
    }
    
  fn_exit:
    if (str_orig != str)
    {
	str--;
	*str = '\0'; /* erase the last \n */
    }
    return;
}

void MPIR_Err_print_stack_string_ext(int errcode, char *str, int maxlen, 
				     MPIR_Err_get_class_string_func_t fn)
{
    char *str_orig = str;
    int len;
#   if MPICH_ERROR_MSG_LEVEL >= MPICH_ERROR_MSG_ALL
    {
	error_ring_mutex_lock();
	{
	    /* Find the longest fcname in the stack */
	    int max_fcname_len = 0;
	    int tmp_errcode = errcode;
	    while (tmp_errcode != MPI_SUCCESS)
	    {
		int ring_idx;
		int ring_id;
		int generic_idx;

		if (convertErrcodeToIndexes( tmp_errcode, &ring_idx, &ring_id,
					     &generic_idx ) != 0) {
		    MPIU_Error_printf( 
		  "Invalid error code (%d) (error ring index %d invalid)\n", 
		  errcode, ring_idx );
		    break;
		}

		if (generic_idx < 0)
		{
		    break;
		}
		    
		if (ErrorRing[ring_idx].id == ring_id) {
		    len = (int)strlen(ErrorRing[ring_idx].fcname);
		    max_fcname_len = MPIR_MAX(max_fcname_len, len);
		    tmp_errcode = ErrorRing[ring_idx].prev_error;
		}
		else
		{
		    break;
		}
	    }
	    max_fcname_len += 2; /* add space for the ": " */
	    /*printf("max_fcname_len = %d\n", max_fcname_len);fflush(stdout);*/
	    /* print the error stack */
	    while (errcode != MPI_SUCCESS)
	    {
		int ring_idx;
		int ring_id;
		int generic_idx;
		int i;
		char *cur_pos;

		if (convertErrcodeToIndexes( errcode, &ring_idx, &ring_id,
					     &generic_idx ) != 0) {
		    MPIU_Error_printf( 
		  "Invalid error code (%d) (error ring index %d invalid)\n", 
		  errcode, ring_idx );
		}

		if (generic_idx < 0)
		{
		    break;
		}
		    
		if (ErrorRing[ring_idx].id == ring_id)
		{
		    MPIU_Snprintf(str, maxlen, "%s", ErrorRing[ring_idx].fcname);
		    len = (int)strlen(str);
		    maxlen -= len;
		    str += len;
		    for (i=0; i<max_fcname_len - (int)strlen(ErrorRing[ring_idx].fcname) - 2; i++)
		    {
			if (MPIU_Snprintf(str, maxlen, "."))
			{
			    maxlen--;
			    str++;
			}
		    }
		    if (MPIU_Snprintf(str, maxlen, ":"))
		    {
			maxlen--;
			str++;
		    }
		    if (MPIU_Snprintf(str, maxlen, " "))
		    {
			maxlen--;
			str++;
		    }

		    if (MPIR_Err_chop_error_stack)
		    {
			cur_pos = ErrorRing[ring_idx].msg;
			len = (int)strlen(cur_pos);
			if (len == 0)
			{
			    if (MPIU_Snprintf(str, maxlen, "\n"))
			    {
				maxlen--;
				str++;
			    }
			}
			while (len)
			{
			    if (len >= MPIR_Err_chop_width - max_fcname_len)
			    {
				if (len > maxlen)
				    break;
				MPIU_Snprintf(str, MPIR_Err_chop_width - 1 - max_fcname_len, "%s", cur_pos);
				str[MPIR_Err_chop_width - 1 - max_fcname_len] = '\n';
				cur_pos += MPIR_Err_chop_width - 1 - max_fcname_len;
				str += MPIR_Err_chop_width - max_fcname_len;
				maxlen -= MPIR_Err_chop_width - max_fcname_len;
				if (maxlen < max_fcname_len)
				    break;
				for (i=0; i<max_fcname_len; i++)
				{
				    MPIU_Snprintf(str, maxlen, " ");
				    maxlen--;
				    str++;
				}
				len = (int)strlen(cur_pos);
			    }
			    else
			    {
				MPIU_Snprintf(str, maxlen, "%s\n", cur_pos);
				len = (int)strlen(str);
				maxlen -= len;
				str += len;
				len = 0;
			    }
			}
		    }
		    else
		    {
			MPIU_Snprintf(str, maxlen, "%s\n", ErrorRing[ring_idx].msg);
			len = (int)strlen(str);
			maxlen -= len;
			str += len;
		    }
		    /*
		    MPIU_Snprintf(str, maxlen, "%s: %s\n", ErrorRing[ring_idx].fcname, ErrorRing[ring_idx].msg);
		    len = (int)strlen(str);
		    maxlen -= len;
		    str += len;
		    */
		    errcode = ErrorRing[ring_idx].prev_error;
		}
		else
		{
		    break;
		}
	    }
	}
	error_ring_mutex_unlock();

	if (errcode == MPI_SUCCESS)
	{
	    goto fn_exit;
	}
    }
#   endif

#   if MPICH_ERROR_MSG_LEVEL > MPICH_ERROR_MSG_NONE
    {
	int generic_idx;
		    
	generic_idx = ((errcode & ERROR_GENERIC_MASK) >> ERROR_GENERIC_SHIFT) - 1;
	
	if (generic_idx >= 0)
	{
	    const char *p;
	    /* FIXME: (Here and elsewhere)  Make sure any string is
	       non-null before you use it */
	    p = generic_err_msgs[generic_idx].long_name;
	    if (!p) { p = "<NULL>"; }
	    MPIU_Snprintf(str, maxlen, "(unknown)(): %s\n", p );
	    len = (int)strlen(str);
	    maxlen -= len;
	    str += len;
	    goto fn_exit;
	}
    }
#   endif
    
    {
	int error_class;

	error_class = ERROR_GET_CLASS(errcode);
	
	if (error_class <= MPICH_ERR_LAST_CLASS)
	{
	    MPIU_Snprintf(str, maxlen, "(unknown)(): %s\n", get_class_msg(ERROR_GET_CLASS(errcode)));
	    len = (int)strlen(str);
	    maxlen -= len;
	    str += len;
	}
	else
	{
	    if (fn != NULL)
	    {
		fn(errcode, str, maxlen);
	    }
	    else
	    {
		MPIU_Snprintf(str, maxlen, "Error code contains an invalid class (%d)\n", error_class);
	    }
	    len = (int)strlen(str);
	    maxlen -= len;
	    str += len;
	}
    }
    
  fn_exit:
    if (str_orig != str)
    {
	str--;
	*str = '\0';
    }
    return;
}

#if MPICH_ERROR_MSG_LEVEL >= MPICH_ERROR_MSG_ALL
/* Convert an error code into ring_idx, ring_id, and generic_idx.
   Return non-zero if there is a problem with the decode values
   (e.g., out of range for the ring index) */
static int convertErrcodeToIndexes( int errcode, int *ring_idx, int *ring_id,
				    int *generic_idx )
{
    *ring_idx = (errcode & ERROR_SPECIFIC_INDEX_MASK) >> 
	ERROR_SPECIFIC_INDEX_SHIFT;
    *ring_id = errcode & (ERROR_CLASS_MASK | 
			  ERROR_GENERIC_MASK | ERROR_SPECIFIC_SEQ_MASK);
    *generic_idx = ((errcode & ERROR_GENERIC_MASK) >> ERROR_GENERIC_SHIFT) - 1;
    
    if (*ring_idx < 0 || *ring_idx >= MAX_ERROR_RING) return 1;

    return 0;
}
#endif

/* 
   Nesting level for routines.
   Note that since these use per-thread data, no locks or atomic update
   routines are required.

   In a single-threaded environment, These are replaced with
   MPIR_Thread.nest_count ++, --.  These are defined in the mpiimpl.h file.
 */
#if (MPICH_THREAD_LEVEL >= MPI_THREAD_MULTIPLE)
void MPIR_Nest_incr( void )
{
    MPICH_PerThread_t *p;
    MPIR_GetPerThread(&p);
    p->nest_count++;
}
void MPIR_Nest_decr( void )
{
    MPICH_PerThread_t *p;
    MPIR_GetPerThread(&p);
    p->nest_count--;
}
int MPIR_Nest_value()
{
    MPICH_PerThread_t *p;
    MPIR_GetPerThread(&p);
    return p->nest_count;
}
#endif

/*
 * Error handlers.  These are handled just like the other opaque objects
 * in MPICH
 */

#ifndef MPID_ERRHANDLER_PREALLOC 
#define MPID_ERRHANDLER_PREALLOC 8
#endif

/* Preallocated errorhandler objects */
MPID_Errhandler MPID_Errhandler_builtin[2] = 
          { { MPI_ERRORS_ARE_FATAL, 0},
	    { MPI_ERRORS_RETURN, 0} }; 
MPID_Errhandler MPID_Errhandler_direct[MPID_ERRHANDLER_PREALLOC] = { {0} };
MPIU_Object_alloc_t MPID_Errhandler_mem = { 0, 0, 0, 0, MPID_ERRHANDLER, 
					    sizeof(MPID_Errhandler), 
					    MPID_Errhandler_direct,
					    MPID_ERRHANDLER_PREALLOC, };

void MPID_Errhandler_free(MPID_Errhandler *errhan_ptr)
{
    MPIU_Handle_obj_free(&MPID_Errhandler_mem, errhan_ptr);
}

#ifdef HAVE_CXX_BINDING
void MPIR_Errhandler_set_cxx( MPI_Errhandler errhand, void (*errcall)(void) )
{
    MPID_Errhandler *errhand_ptr;
    
    MPID_Errhandler_get_ptr( errhand, errhand_ptr );
    errhand_ptr->language		= MPID_LANG_CXX;
    MPIR_Process.cxx_call_errfn	= (void (*)( int, int *, int *, 
					    void (*)(void) ))errcall;
}
#endif