fastdebug.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <time.h>
#include <alloca.h> 

// If I want a no mpi version, define this macro
#ifdef NOMPI
#define MPI_COMM_WORLD 0
int MPI_Initialized(int *result) { *result=1; }
int MPI_Comm_rank(int unused, int *myrank ){ *myrank=0 ; }
int MPI_Init(int *argc, char ***argv) { return 0; }
int MPI_Finalize() { return 0 ;}
#else
#include <mpi.h>
#endif

// Default value of whether this routine does anything
#define START_AS_STUB 0

static int fp=-1;
static int mypid=-1;
static int myrank=999;
static int fast_debug_error=0;
static int is_stubbed = START_AS_STUB;

#ifdef DEBUG
#define VERBOSE 1
#else
#define VERBOSE 0
#endif
#define USE_MPI 1
#define MAX_STR_LEN 2048
#define ROUGH_PREAMBLE_LENGTH 100

// Setters to toggle debug
void fastdebug_activate_(long on_off) {
	is_stubbed = (int)on_off;
}

//
// Returns unix time stamp with micro time appended
long long f_gettimeofday_() {
	struct timeval tv;
	long long the_time;

	gettimeofday(&tv,NULL);
	the_time=tv.tv_sec;
	the_time=the_time*1000000 + tv.tv_usec;
	return (the_time);
}

/* Simple trim function taken from
 * http://stackoverflow.com/questions/122616/how-do-i-trim-leading-trailing-whitespace-in-a-standard-way
 * This function shifts the string into the first position of the buffer.
 * This way, if the string was dynamically allocated, it can be deallocated
 * on the original pointer.
 */
char *trim(char *str) {
	size_t len = 0;
	char *frontp = str - 1;
	char *endp = NULL;

	if( str == NULL ) return NULL;

	if( str[0] == '\0' ) return str;

	len = strlen(str);
	endp = str + len;

	/* Move the front and back pointers to address
	* the first non-whitespace characters from
	* each end.
	*/
    while( isspace(*(++frontp)) );
    while( isspace(*(--endp)) && endp != frontp );

	if ( str + len - 1 != endp )
		*(endp + 1) = '\0';
	else if( frontp != str &&  endp == frontp )
		*str = '\0';

	/* Shift the string so that it starts at str so
	* that if it's dynamically allocated, we can
	* still free it on the returned pointer.  Note
	* the reuse of endp to mean the front of the
	* string buffer now.
	*/
	endp = str;
	if( frontp != str ) {
		while( *frontp ) *endp++ = *frontp++;
		*endp = '\0';
	}

	return str;
}

int fastdebug_(const char *str, int *lineno ,int str_len) {

	int flag;
	mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
	char *msg, *nstr;
	char hostname[30], fname[50];
//	char prefix[] = "/tmp/gmdebug/debug-";
	char *prefix = "/scratch/gmdebug-";
	char preamble[ROUGH_PREAMBLE_LENGTH];

	// Bail immediately if there has been an error, or we're simply deactivated
	// and acting as a stub file.
	if (fast_debug_error || is_stubbed) return 0;

	// Get the hostname
	gethostname(hostname, sizeof hostname);

	MPI_Initialized(&flag);
	if(flag==0) return 1;
	if (fp == -1) {
		if(NULL!=getenv("MATT_PREFIX")) prefix=getenv("MATT_PREFIX");
		mypid=getpid();
		MPI_Initialized(&flag);
		if(flag) MPI_Comm_rank(MPI_COMM_WORLD, &myrank );
		else fprintf(stderr,"[fastdebug] MPI NOT STARTED\n");

		// just for debug..
 		if (VERBOSE) mypid=0;

		snprintf(fname,sizeof(fname)-1,"%s%5.5d-%3.3d",prefix,mypid,myrank);
		if (VERBOSE) printf("Opening file %s\n", fname);
		if ((fp=open(fname, O_WRONLY | O_CREAT | O_APPEND, mode)) < 0) {
			fprintf(stderr, "[fastdebug]: Cannot open file %s on %s.  Deactivating fastdebug.\n", fname, hostname);
			//exit(1);
			fast_debug_error=1;
			return 0;
		}
	}

	// Write the preable, so, time, hostname, etc.
	snprintf(preamble, ROUGH_PREAMBLE_LENGTH+1,
	   "%lld [%s:%05d:%02d]",
	   f_gettimeofday_(),
	   hostname, mypid, myrank);

	// Magic number ROUGH_PREAMBLE_LENGTH is estimated length of all the
	// host/pid/rank info in the debug line
	if ((str_len + strlen(preamble)) > MAX_STR_LEN) {
		// Truncate message
		str_len = MAX_STR_LEN - strlen(preamble);
	}
	str_len++; // null character

	// Trim white space
	if (VERBOSE) printf("[fastdebug] Trying to allocation %d characters for nstr \"%s\"\n", str_len, str);
	if ((nstr=(char *)alloca(str_len)) == NULL) {
		fprintf(stderr, "[fastdebug]: Cannot allocate msg %d characters for string.\n", (str_len+2));
		exit(1);
	}
	snprintf(nstr, str_len, "%s", str); // copy it to a mutable stirng
	nstr=trim(nstr); // trim white space
	str_len=strlen(nstr);


	// str_len will now be the entire output message (preample and all)
	// The 128 is a magic number buffer, for the spaces and line breaks, etc..
	str_len=str_len+strlen(preamble)+128;

	if (VERBOSE) printf("[fastdebug] Trying to allocation %d characters for combined string \"%s %s\"\n", str_len+2, preamble, nstr);
	if ((msg=(char *)alloca(str_len)) == NULL) {
		fprintf(stderr, "[fastdebug]: Cannot allocate msg %d characters for string.\n", (str_len+2));
		exit(1);
	}

	// Combine the string
	snprintf(msg, str_len, "%s(%5d) %s\n", preamble,*lineno, nstr);
	//snprintf(msg, str_len+2, "%s %s\n", nstr);

	if (VERBOSE) printf("Writing \"%s\" to %s\n", msg, fname);
	write(fp,msg,strlen(msg));

	/*close(fp);*/

	return 1;
}

// Function was first implemented under this name,
// so now this is just a deprecated redirection function
int mattdebug_(const char *str, int *lineno ,int str_len) {
	return fastdebug_(str, lineno, str_len);
}

// This is done to allow me to either directly build this
// as an executable, or build it with s.compile using a bidon
#if defined(TEST)
int main(int argc, char **argv) {
#else
int mattmain_(int argc, char **argv) {
#endif
	char msg[] = "Hello";
	long long the_time;
	int lineno;

	MPI_Init(&argc, &argv);

	the_time=f_gettimeofday_();
	printf("time=%lld\n", the_time);

	lineno = 1234;
	fastdebug_(msg,&lineno, strlen(msg));
	lineno = 2345;
	fastdebug_("Hello again",&lineno, 11);
	lineno = 3456;
	fastdebug_("Testing trim           ",&lineno, 23);

	MPI_Finalize();

	return 0;
}