smpd_printf.c

fortran并行计算包

/* -*- Mode: C; c-basic-offset:4 ; -*- */
/*
 *  (C) 2001 by Argonne National Laboratory.
 *      See COPYRIGHT in top-level directory.
 */

#include "smpd.h"
#include <stdio.h>
#ifdef HAVE_STDARG_H
#include <stdarg.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif

#define SMPD_MAX_INDENT 20
static char indent[SMPD_MAX_INDENT+1] = "";
static int cur_indent = 0;

#ifdef HAVE_WINDOWS_H
void smpd_translate_win_error(int error, char *msg, int maxlen, char *prepend, ...)
{
    HLOCAL str;
    int num_bytes;
    int len;
    va_list list;

    num_bytes = FormatMessage(
	FORMAT_MESSAGE_FROM_SYSTEM |
	FORMAT_MESSAGE_ALLOCATE_BUFFER,
	0,
	error,
	MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
	(LPTSTR) &str,
	0,0);
    if (prepend == NULL)
	memcpy(msg, str, min(maxlen, num_bytes+1));
    else
    {
	va_start(list, prepend);
	len = vsnprintf(msg, maxlen, prepend, list);
	va_end(list);
	msg += len;
	maxlen -= len;
	snprintf(msg, maxlen, "%s", str);
    }
    LocalFree(str);
}
#endif

char * get_sock_error_string(int error)
{
    static char str[1024];

    if (error == MPIDU_SOCK_SUCCESS)
	return "operation completed successfully";

    str[0] = '\0';
    MPIR_Err_get_string(error, str, 1024, MPIDU_Sock_get_error_class_string);
    /*
    MPIR_Err_get_string_ext(error, str, 1024, MPIDU_Sock_get_error_class_string);
    if (MPIR_Err_print_stack_flag)
    {
	char *str2;
	int len;
	strcat(str, "\n");
	len = (int)strlen(str);
	str2 = str + len;
	MPIR_Err_print_stack_string_ext(error, str2, 1024-len, MPIDU_Sock_get_error_class_string);
    }
    */

    return str;
}

char * smpd_get_context_str(smpd_context_t *context)
{
    if (context == NULL)
	return "null";
    switch (context->type)
    {
    case SMPD_CONTEXT_INVALID:
	return "invalid";
    case SMPD_CONTEXT_STDIN:
	return "stdin";
    case SMPD_CONTEXT_MPIEXEC_STDIN:
	return "mpi_stdin";
    case SMPD_CONTEXT_MPIEXEC_STDIN_RSH:
	return "mpi_stdin_rsh";
    case SMPD_CONTEXT_STDOUT:
	return "stdout";
    case SMPD_CONTEXT_STDOUT_RSH:
	return "stdout_rsh";
    case SMPD_CONTEXT_STDERR:
	return "stderr";
    case SMPD_CONTEXT_STDERR_RSH:
	return "stderr_rsh";
    case SMPD_CONTEXT_PARENT:
	return "parent";
    case SMPD_CONTEXT_LEFT_CHILD:
	return "left";
    case SMPD_CONTEXT_RIGHT_CHILD:
	return "right";
    case SMPD_CONTEXT_CHILD:
	return "child";
    case SMPD_CONTEXT_LISTENER:
	return "listener";
    case SMPD_CONTEXT_PMI_LISTENER:
    return "PMI_LISTENER";
    case SMPD_CONTEXT_SMPD:
	return "smpd";
    case SMPD_CONTEXT_PMI:
	return "pmi";
    case SMPD_CONTEXT_TIMEOUT:
	return "timeout";
    case SMPD_CONTEXT_MPIEXEC_ABORT:
	return "MPIEXEC_ABORT";
    case SMPD_CONTEXT_SINGLETON_INIT_CLIENT:
    return "SINGLETON_INIT_CLIENT";
    case SMPD_CONTEXT_SINGLETON_INIT_MPIEXEC:
    return "SINGLETON_INIT_MPIEXEC";
    case SMPD_CONTEXT_UNDETERMINED:
	return "undetermined";
    case SMPD_CONTEXT_FREED:
	return "freed";
    }
    return "unknown";
}

int smpd_init_printf(void)
{
    char * envstr;
    static int initialized = 0;
    char str[1024];
    int len;

    if (initialized)
	return 0;
    initialized = 1;

    smpd_process.dbg_state = SMPD_DBG_STATE_ERROUT;

    envstr = getenv("SMPD_DBG_OUTPUT");
    if (envstr != NULL)
    {
	if (strstr(envstr, "stdout"))
	    smpd_process.dbg_state |= SMPD_DBG_STATE_STDOUT;
	if (strstr(envstr, "log"))
	    smpd_process.dbg_state |= SMPD_DBG_STATE_LOGFILE;
	if (strstr(envstr, "rank"))
	    smpd_process.dbg_state |= SMPD_DBG_STATE_PREPEND_RANK;
	if (strstr(envstr, "trace"))
	    smpd_process.dbg_state |= SMPD_DBG_STATE_TRACE;
	if (strstr(envstr, "all"))
	    smpd_process.dbg_state = SMPD_DBG_STATE_ALL;
    }

    if (smpd_option_on("log"))
	smpd_process.dbg_state |= SMPD_DBG_STATE_LOGFILE;
    if (smpd_option_on("prepend_rank"))
	smpd_process.dbg_state |= SMPD_DBG_STATE_PREPEND_RANK;
    if (smpd_option_on("trace"))
	smpd_process.dbg_state |= SMPD_DBG_STATE_TRACE;

    if (smpd_process.dbg_state & SMPD_DBG_STATE_LOGFILE)
    {
	envstr = getenv("SMPD_DBG_LOG_FILENAME");
	if (envstr)
	{
	    strcpy(smpd_process.dbg_filename, envstr);
	}
	else
	{
	    if (smpd_get_smpd_data("logfile", smpd_process.dbg_filename, SMPD_MAX_FILENAME) != SMPD_SUCCESS)
	    {
		smpd_process.dbg_state ^= SMPD_DBG_STATE_LOGFILE;
	    }
	}
	if (smpd_get_smpd_data("max_logfile_size", str, 1024) == SMPD_SUCCESS)
	{
	    smpd_process.dbg_file_size = atoi(str);
	}
	envstr = getenv("SMPD_MAX_LOG_FILE_SIZE");
	if (envstr)
	{
	    len = atoi(envstr);
	    if (len > 0)
	    {
		smpd_process.dbg_file_size = atoi(envstr);
	    }
	}
    }

#ifdef HAVE_WINDOWS_H
    if (!smpd_process.bOutputInitialized)
    {
	smpd_process.hOutputMutex = CreateMutex(NULL, FALSE, SMPD_OUTPUT_MUTEX_NAME);
	smpd_process.bOutputInitialized = TRUE;
    }
#endif
    return SMPD_SUCCESS;
}

int smpd_finalize_printf()
{
    fflush(stdout);
    fflush(stderr);
    return SMPD_SUCCESS;
}

void smpd_clean_output(char *str)
{
    char *temp_str;

    temp_str = strstr(str, "password");
    while (temp_str != NULL)
    {
	smpd_hide_string_arg(temp_str, "password");
	temp_str = strstr(temp_str+1, "password");
    }

    temp_str = strstr(str, "pwd");
    while (temp_str != NULL)
    {
	smpd_hide_string_arg(temp_str, "pwd");
	temp_str = strstr(temp_str+1, "pwd");
    }

    temp_str = strstr(str, "phrase");
    while (temp_str != NULL)
    {
	smpd_hide_string_arg(temp_str, "phrase");
	temp_str = strstr(temp_str+1, "phrase");
    }
}

static int read_file(FILE *fin, void *buffer, int length)
{
    int num_read, total = 0;
    char *buf = buffer;

    while (length > 0)
    {
	num_read = (int)fread(buf, sizeof(char), (size_t)length, fin);
	if (num_read < 1)
	{
	    return total;
	}
	length = length - num_read;
	buf = buf + num_read;
	total = total + num_read;
    }
    return total;
}

static int write_file(FILE *fout, void *buffer, int length)
{
    int num_written, total = 0;
    char *buf = buffer;

    while (length > 0)
    {
	num_written = (int)fwrite(buf, sizeof(char), (size_t)length, fout);
	if (num_written < 1)
	{
	    return total;
	}
	length = length - num_written;
	buf = buf + num_written;
	total = total + num_written;
    }
    return total;
}

void smpd_trim_logfile()
{
    /* Do nothing until I can figure out why the trim code isn't working */
}

#if 0
void smpd_trim_logfile_new()
{
    static int count = 0;
    FILE *fout;
    long size;
    int num_read, num_written;
    char *buffer, *buffer_orig;
    char copy_cmd[4096];
    int docopy = 0;
    static copy_number = 0;
    int a, b;

    /* check every 1000 iterations */
    if (count++ % 1000)
	return;

    fout = fopen(smpd_process.dbg_filename, "rb");
    if (fout == NULL)
    {
	/*printf("unable to open the smpd log file\n");*/
	return;
    }
    setvbuf(fout, NULL, _IONBF, 0);
    fseek(fout, 0, SEEK_END);
    size = ftell(fout);
    if (size > smpd_process.dbg_file_size)
    {
	if (copy_number == 0)
	{
	    srand(smpd_getpid());
	    copy_number = rand();
	}
	sprintf(copy_cmd, "copy %s %s.%d.old", smpd_process.dbg_filename, smpd_process.dbg_filename, copy_number);
	system(copy_cmd);
	buffer = buffer_orig = malloc(size);
	if (buffer != NULL)
	{
	    fseek(fout, 0, SEEK_SET);
	    num_read = read_file(fout, buffer, size);
	    if (num_read == size)
	    {
		fclose(fout);
		fout = fopen(smpd_process.dbg_filename, "rb");
		if (fout == NULL)
		{
		}
		setvbuf(fout, NULL, _IONBF, 0);
		fseek(fout, -4, SEEK_END);
		fread(&a, 1, 4, fout);
		fclose(fout);
		if (a != *(int*)&buffer[size-4])
		{
		    FILE *ferr = fopen("c:\\temp\\smpd.err", "a+");
		    fprintf(ferr, "last 4 bytes not equal, a: %x != %x", a, *(int*)&buffer[size-4]);
		    fclose(ferr);
		}
		fout = fopen(smpd_process.dbg_filename, "wb");
		if (fout != NULL)
		{
		    buffer = buffer + size - (smpd_process.dbg_file_size / 2);
		    size = smpd_process.dbg_file_size / 2;
		    num_written = write_file(fout, buffer, size);
		    docopy = 1;
		    if (num_written != size)
		    {
			FILE *ferr = fopen("c:\\temp\\smpd.err", "a+");
			fprintf(ferr, "wrote %d instead of %d bytes to the smpd log file.\n", num_written, size);
			fclose(ferr);
		    }
		    /*
		    else
		    {
			printf("wrote %d bytes to the smpd log file.\n", num_written);
			fflush(stdout);
		    }
		    */
		    fclose(fout);
		    fout = fopen(smpd_process.dbg_filename, "rb");
		    if (fout == NULL)
		    {
		    }
		    setvbuf(fout, NULL, _IONBF, 0);
		    fseek(fout, -4, SEEK_END);
		    fread(&b, 1, 4, fout);
		    fclose(fout);
		    if (b != *(int*)&buffer[size-4])
		    {
			FILE *ferr = fopen("c:\\temp\\smpd.err", "a+");
			fprintf(ferr, "last 4 bytes not equal, b: %x != %x", b, *(int*)&buffer[size-4]);
			fclose(ferr);
		    }