mpicovsimple.cxx

fortran并行计算包

//-*- Mode: C++; c-basic-offset:4 ; -*- */
//
//  Copyright (C) 2004 by Argonne National Laboratory.
//      See COPYRIGHT in top-level directory.
//
// This is a *very* simple tool for basic coverage analysis.  
// This is intended as a stop-gap until gcov works with the C++ files
// used in the MPICH2 binding of C++ (as of 2/23/2004, gcov aborts when
// processing the coverage files produced by g++ for the MPICH2 C++
// binding).
//

#include <iostream.h>
#include <fstream.h>
#include <string.h>

#include "mpicovsimple.h"

/* For remove */
#include <stdio.h>

// Find the matching entry or insert and initialize a new one
covinfo * MPIX_Coverage::findOrInsert( const char name[], int argcount )
{
    covinfo *p = head, *newp;
    int cmp;
    static covinfo *lastp = 0;    // We use lastp to start where we
                                  // left off if we can; this speeds
                                  // sorted inserts
    
    // See if we can skip ahead...
    if (lastp) {
	cmp = strcmp( lastp->name, name );
	if (cmp < 0 || (cmp == 0 && lastp->argcount <= argcount )) p = lastp;
    }

    while (p) {
	cmp = strcmp( p->name, name );
	if (cmp == 0) {
	    cmp = p->argcount - argcount;
	    if (cmp == 0) { 
		// If still 0, we've found our match.
		lastp = p;
		return p;
	    }
	}

	if (cmp > 0) {
	    // If we got here, backup and exit to perform the insert
	    p = p->bLink;
	    break;
	}
	// If we're at the end of the list, this p is the last element,
	// so we exit now
	if (!p->fLink) break;

	p = p->fLink;
    }
    
    // If we got here, we need to insert after p
    newp             = new covinfo;
    newp->name       = new char [strlen(name)+1];
    strcpy( newp->name, name );
    newp->argcount   = argcount;
    newp->count      = 0;
    newp->sourceFile = 0;
    newp->firstLine  = -1;
    newp->lastLine   = -1;
    newp->bLink      = p;
    if (p) {
	// insert after p
	newp->fLink = p->fLink;
	p->fLink    = newp;
	if (newp->fLink) {
	    newp->fLink->bLink = newp;
	}
    }
    else {
	// insert at the head of the list
	newp->fLink = head;
	if (head) { 
	    head->bLink = newp; 
	}
	head        = newp;
    }

    lastp = newp;
    return newp;
}

// Add an item to the coverage list, including the first line
void MPIX_Coverage::Add( const char name[], int argcnt, 
		    const char file[], int line )
{
    covinfo *p = findOrInsert( name, argcnt );

    p->count ++;
    if (!p->sourceFile) {
	p->sourceFile = new char [strlen(file)+1];
	strcpy( p->sourceFile, file );
	p->firstLine = line;
    }
}

// Add the last line value to an item in the coverage list
void MPIX_Coverage::AddEnd( const char name[], int argcnt,
		       const char file[], int line )
{
    covinfo *p = findOrInsert( name, argcnt );

    if (p->lastLine < 0) 
	p->lastLine = line;
}

//
// Merge the coverage data with the data in the file
// The directory for the coverage file is defined by the
// cpp value COVERAGE_DIR
int MPIX_Coverage::FileMerge( const char filename[] )
{
    ifstream infile;
    ofstream outfile;
    covinfo *p;
    covinfo fp;
    char *infilename, *tmpfilename;

    // Try to open the input file.  
    {
#ifdef COVERAGE_DIR
	infilename = new char [strlen(filename) + strlen(COVERAGE_DIR) + 2 ];
	strcpy( infilename, COVERAGE_DIR );
	strcat( infilename, "/" );
	strcat( infilename, filename );
#else
	infilename = (char *)filename;
#endif
	infile.open( infilename );

	// Create a place in which to read the data
	fp.name       = new char [1024];
	fp.sourceFile = new char [1024];

	// Add the contents of the file to the internal list
	// This is easy but not the most memory efficient.
	// If this becomes a problem, we can merge the two
	// into a single output
	while (infile) {
	    fp.count = -1;  // Set a sentinal on eof in infile
	    infile >> fp.name >> fp.argcount >> fp.count >> fp.sourceFile >>
		fp.firstLine >> fp.lastLine;
	    if (fp.count == -1) break;
	    p = findOrInsert( fp.name, fp.argcount );
	    if (!p->sourceFile) {
		p->sourceFile = strdup( fp.sourceFile );
		p->firstLine  = fp.firstLine;
		p->lastLine   = fp.lastLine;
	    }
	    p->count += fp.count;
	}
	infile.close();
	// Recover new storage
	delete fp.name;
	delete fp.sourceFile;
    }
    
    // Try to open the output file
#ifdef COVERAGE_DIR
    tmpfilename = new char [strlen(".covtmp") + strlen(COVERAGE_DIR) + 2 ];
    strcpy( tmpfilename, COVERAGE_DIR );
    strcat( tmpfilename, "/" );
    strcat( tmpfilename, ".covtmp" );
#else
    tmpfilename = ".covtmp";
#endif
    outfile.open( tmpfilename );

    p = head;
    while (p) {
	outfile << p->name << '\t' << p->argcount << '\t' << 
	    p->count << '\t' << p->sourceFile << '\t' <<
	    p->firstLine << '\t' << p->lastLine << '\n';
	p = p->fLink;
    }
    
    outfile.close();
    
    // Now, remove the old file and move the new file over it
    remove( infilename );
    rename( tmpfilename, infilename );

    return 0;
}

#if 0
// This is partial and incomplete code for an alternative version of
// FileMerge that avoids reading the entire file into memory
// This was a early version that was lost in a terrible keyboarding 
// accident just after it was debugged :)
// This predates the current form of the coverage file and contains
// a number of bugs, but it would be a reasonable starting point 
// if it is desired to avoid reading the entire file into memory.
int MPIX_Ooverage::FileMerge( const char filename[] )
{
    covinfo *p, *fp=0;
    ifstream infile;
    ofstream outfile;
    char *tmpfile;

    infile.open( filename, ios::in );

    tmpfile = new char [ strlen(filename) + 5 ];
    strcpy( tmpfile, filename );
    strcat( tmpfile, ".tmp" );
    outfile.open( tmpfile );
    if (!outfile) {
	cerr << "Unable to open " << tmpfile << "\n";
    }
    p = head;
    if (infile) {
	fp = new covinfo;
	fp->name = new char [1024];
	infile >> fp->name >> fp->argcount >> fp->count;
    }
    while (p) {
	int cmp = 0;
	if (fp) {
	    cmp = strcmp( fp->name, p->name );
	    if (cmp == 0) {
		cmp = fp->argcount - p->argcount;
	    }
	    if (cmp < 0) {
		// output the file entry
		outfile << fp->name << '\t' << fp->argcount << '\t' <<
		    fp->count << '\n';
		infile >> fp->name >> fp->argcount >> fp->count;
		if (infile.eof()) break;
		continue;
	    }
	    else if (cmp == 0) {
		// Increment the p entry 
		p->count += fp->count;
		infile >> fp->name >> fp->argcount >> fp->count;
		if (infile.eof()) break;
	    }
	    // else keep this entry
	}
	outfile << p->name << '\t' << p->argcount << '\t' << p->count << '\n';
	p = p->fLink;
    }
    // Read the rest of the file, if any
    while (infile && !infile.eof()) {
	infile >> fp->name >> fp->argcount fp->count;
	outfile << fp->name << '\t' << fp->argcount << '\t' <<
	    fp->count << '\n';
    }
    // Output the rest of the list
    while (p) {
	outfile << p->name << '\t' << p->argcount << '\t' << p->count << '\n';
	p = p->fLink;
    }
    // Close the input file if we opened it...
    if (fp) {
	infile.close();
	... remove code as above
    }

}
#endif

MPIX_Coverage MPIR_Cov;

//#define TEST_PROGRAM
#ifdef TEST_PROGRAM
int main( int argc, char **argv )
{
    MPIR_Cov.Add( "foo", 2, __FILE__, __LINE__ );
    MPIR_Cov.Add( "foo", 1, __FILE__, __LINE__ );
    MPIR_Cov.Add( "bar", 2, __FILE__, __LINE__ );
    
    MPIR_Cov.FileMerge( "covtest.dat" );
    return 0;
}
#endif