buildiface

fortran并行计算包

          INTEGER a,b,c,d,e
        END SUBROUTINE MPI_NULL_DELETE_FN

        SUBROUTINE MPI_DUP_FN(a,b,c,d,e,f,g)
          INTEGER a,b,c,d,e,g
          LOGICAL f
        END SUBROUTINE MPI_DUP_FN

        SUBROUTINE MPI_NULL_COPY_FN(a,b,c,d,e,f,g)
          INTEGER a,b,c,d,e,g
          LOGICAL f
        END SUBROUTINE MPI_NULL_COPY_FN

        SUBROUTINE MPI_COMM_NULL_DELETE_FN(a,b,c,d,e)
          USE MPI_CONSTANTS,ONLY: MPI_ADDRESS_KIND
          INTEGER a,b,e
          INTEGER (KIND=MPI_ADDRESS_KIND) c, d
        END SUBROUTINE MPI_COMM_NULL_DELETE_FN

        SUBROUTINE MPI_COMM_DUP_FN(a,b,c,d,e,f,g)
          USE MPI_CONSTANTS,ONLY: MPI_ADDRESS_KIND
          INTEGER a,b,g
          INTEGER (KIND=MPI_ADDRESS_KIND) c,d,e
          LOGICAL f
        END SUBROUTINE MPI_COMM_DUP_FN

        SUBROUTINE MPI_COMM_NULL_COPY_FN(a,b,c,d,e,f,g)
          USE MPI_CONSTANTS,ONLY: MPI_ADDRESS_KIND
          INTEGER a,b,g
          INTEGER (KIND=MPI_ADDRESS_KIND) c,d,e
          LOGICAL f
        END SUBROUTINE MPI_COMM_NULL_COPY_FN

        SUBROUTINE MPI_TYPE_NULL_DELETE_FN(a,b,c,d,e)
          USE MPI_CONSTANTS,ONLY: MPI_ADDRESS_KIND
          INTEGER a,b,e
          INTEGER (KIND=MPI_ADDRESS_KIND) c, d
        END SUBROUTINE MPI_TYPE_NULL_DELETE_FN

        SUBROUTINE MPI_TYPE_DUP_FN(a,b,c,d,e,f,g)
          USE MPI_CONSTANTS,ONLY: MPI_ADDRESS_KIND
          INTEGER a,b,g
          INTEGER (KIND=MPI_ADDRESS_KIND) c,d,e
          LOGICAL f
        END SUBROUTINE MPI_TYPE_DUP_FN

        SUBROUTINE MPI_TYPE_NULL_COPY_FN(a,b,c,d,e,f,g)
          USE MPI_CONSTANTS,ONLY: MPI_ADDRESS_KIND
          INTEGER a,b,g
          INTEGER (KIND=MPI_ADDRESS_KIND) c,d,e
          LOGICAL f
        END SUBROUTINE MPI_TYPE_NULL_COPY_FN

        SUBROUTINE MPI_WIN_NULL_DELETE_FN(a,b,c,d,e)
          USE MPI_CONSTANTS,ONLY: MPI_ADDRESS_KIND
          INTEGER a,b,e
          INTEGER (KIND=MPI_ADDRESS_KIND) c, d
        END SUBROUTINE MPI_WIN_NULL_DELETE_FN

        SUBROUTINE MPI_WIN_DUP_FN(a,b,c,d,e,f,g)
          USE MPI_CONSTANTS,ONLY: MPI_ADDRESS_KIND
          INTEGER a,b,g
          INTEGER (KIND=MPI_ADDRESS_KIND) c,d,e
          LOGICAL f
        END SUBROUTINE MPI_WIN_DUP_FN

        SUBROUTINE MPI_WIN_NULL_COPY_FN(a,b,c,d,e,f,g)
          USE MPI_CONSTANTS,ONLY: MPI_ADDRESS_KIND
          INTEGER a,b,g
          INTEGER (KIND=MPI_ADDRESS_KIND) c,d,e
          LOGICAL f
        END SUBROUTINE MPI_WIN_NULL_COPY_FN

";

# Here's where we need to place the interface definitions for the functions
# that take vector or scalar arguments (startall, testall/any/some, 
# waitall/any/some, group_translate_ranks, etc.)
# For each such routine, we need to generate two entries.  Here's the 
# example for STARTALL:
#     subroutine MPI_STARTALL_S(c,r,ierr)
#     integer c,r,ierr
#     external MPI_STARTALL
#         call MPI_STARTALL(c,r,ierr)
#     end subroutine MPI_STARTALL_S
#     subroutine MPI_STARTALL_V(c,r,ierr)
#     integer c,r(*),ierr
#     external MPI_STARTALL
#         call MPI_STARTALL(c,r,ierr)
#     end subroutine MPI_STARTALL_V

print MPIBASEFD "       END INTERFACE\n";

if ($buildScalarVector) {
    # Create the interface modules
    foreach my $routine (keys(%scalarVectorRoutines)) {
	$ucname = uc($routine);
	print MPIBASEFD "       INTERFACE MPI_$ucname\n";
        print MPIBASEFD "           MODULE PROCEDURE MPI_${ucname}_S\n";
        print MPIBASEFD "           MODULE PROCEDURE MPI_${ucname}_V\n";
	print MPIBASEFD "       END INTERFACE ! MPI_$ucname\n\n";
        
    }
    print MPIBASEFD "\n        CONTAINS\n";
    # This is much like the base name (interface) block code
    foreach my $routine (keys(%scalarVectorRoutines)) {
	$ucname = uc($routine);
	$args   = $mpi_routines{$routine};
	@parms  = split(/,/, $args );
	$svArgs = $scalarVectorRoutines{$routine};
	# The scalar version
        print MPIBASEFD "       SUBROUTINE MPI_${ucname}_S(";
        for ($i=0; $i<=$#parms; $i++) {
	    print MPIBASEFD "v$i,";
        }
        print MPIBASEFD "ierror)\n";
	&PrintArgDecls( $routine, 1, $svArgs );
	print MPIBASEFD "       EXTERNAL MPI_${ucname}\n";
	print MPIBASEFD "       call MPI_$ucname(";
        for ($i=0; $i<=$#parms; $i++) {
	    print MPIBASEFD "v$i,";
        }
	print MPIBASEFD "ierror)\n";

	print MPIBASEFD "       END SUBROUTINE MPI_${ucname}_S\n\n";

	# The vector version
        print MPIBASEFD "       SUBROUTINE MPI_${ucname}_V(";
        for ($i=0; $i<=$#parms; $i++) {
	    print MPIBASEFD "v$i,";
        }
        print MPIBASEFD "ierror)\n";
	&PrintArgDecls( $routine, 0, "" );
	print MPIBASEFD "       EXTERNAL MPI_${ucname}\n";
	print MPIBASEFD "       call MPI_$ucname(";
        for ($i=0; $i<=$#parms; $i++) {
	    print MPIBASEFD "v$i,";
        }
	print MPIBASEFD "ierror)\n";

	print MPIBASEFD "       END SUBROUTINE MPI_${ucname}_V\n\n";

    }
}

print MPIBASEFD "       END MODULE MPI_BASE\n";
close MPIBASEFD;
&ReplaceIfDifferent( "mpi_base.f90", "mpi_base.f90.new" );

open ( MPIFD, ">mpi_constants.f90.new" ) || die "Cannot open mpi_constants.f90.new\n";
print MPIFD "        MODULE MPI_CONSTANTS
        IMPLICIT NONE
        INCLUDE 'mpifnoext.h'
        END MODULE MPI_CONSTANTS\n";
close MPIFD;
&ReplaceIfDifferent( "mpi_constants.f90", "mpi_constants.f90.new" );

#
# Generate the choice argument routines
# FIXME: This file is not quite right.  Also note that it is 
# *input* for yet another step, one that generates particular values 
# for the types of the choice arguments.  We should consider using 
# a different extension for this file, such as sed or in, so that 
# it is clearly not a ready-to-use Fortran 90 input file.
# In particular, it needs to be set up so that
#   <typesize>
#   <type>
#   <dims>
#   <type1>
#   <dims1>
# can all be substituted as necessary.  For example
#   <typesize> => 4
#   <type> => real
#   <dims> => (*)
#   <type1> => real
#   <dims1> => (*)
# For scalar arguments, <dims> should be empty.
# Finally, the module name needs to be distinct for each choice of
# <type>, <dims>, <type1>, and <dims1>
open( MPIFD, ">mpi_t1.f90.new" ) || die "Cannot open mpi_t1.f90.new\n";
print MPIFD "        MODULE MPI_t1_s
        IMPLICIT NONE
        PRIVATE\n";

# Generate the interface specs
foreach $routine (keys(%mpi_choice_routines)) {
    $ucname = uc($routine);

    print MPIFD "        PUBLIC :: MPI_$ucname\n";
    print MPIFD "        INTERFACE MPI_$ucname\n";
    print MPIFD "           MODULE PROCEDURE MPI_${ucname}_T\n";
    print MPIFD "        END INTERFACE MPI_$ucname\n\n";
}

# MPI_Sizeof has its own module

    print MPIFD "        CONTAINS\n\n";

# For each choice routine, add the modules
foreach $routine (keys(%mpi_choice_routines)) {
    $ucname = uc($routine);
    $args   = $mpi_routines{$routine};
    @parms  = split(/,/, $args );

    print MPIFD "        SUBROUTINE MPI_${ucname}_T(";
    for ($i=0; $i<=$#parms; $i++) {
	print MPIFD "v$i,";
    }
    print MPIFD "ierror)\n";

    if (defined($NeedConstants{$routine})) {
	print MPIFD "       USE MPI_CONSTANTS,ONLY:";
	$sep = "";
	foreach $name (split(/\s+/,$NeedConstants{$routine})) {
	    print MPIFD "$sep$name";
	    $sep = ", ";
	}
	print MPIFD "\n";
    }

    # print the arg decls ...
    # convert %type% to the various types and %dims% to the dimensions,
    # including scalar.
    $nchoice = 0;
    for ($i=0; $i<=$#parms; $i++) {
	$parm = $parms[$i];
	# Check for special args
	$loc = $i+1;
	if (defined($special_args{"$routine-$loc"})) {
	    $parm = $special_args{"$routine-$loc"};
	}

	if ($parm =~ /void/) {
	    # An alternative to this is to have a separate file for
	    # routines with 2 choice arguments
	    if ($nchoice == 0) {
		print MPIFD "        <type> v$i<dims>\n";
	    }
	    else {
		print MPIFD "        <type$nchoice> v$i<dims$nchoice>\n";
	    }
	    $nchoice ++;
	}
	else {
	    # Map the C type to the Fortran type
	    $cparm = $parm;
	    $cparm =~ s/\s+//g;
	    $fparm = $parmc2f{$cparm};
	    if ($fparm eq "") {
		print STDERR "$routine: No parm type for $cparm ($parm)\n";
	    }
	    if ($fparm =~ /%name%/) {
		$fparm =~ s/%name%/v$i/;
		# In the name case, convert any %nl% to newlines and spaces
		$fparm =~ s/%nl%/\n       /g;
		print MPIFD "        $fparm\n";
	    }
	    else {
		print MPIFD "        $fparm v$i\n";
	    }
	}
    }
    print MPIFD "        INTEGER ierror\n";
    print MPIFD "        EXTERNAL MPI_${ucname}\n";
    print MPIFD "        CALL MPI_${ucname}(";
    for ($i=0; $i<=$#parms; $i++) {
	print MPIFD "v$i,";
    }
    print MPIFD "ierror)\n";
    print MPIFD "        END SUBROUTINE MPI_${ucname}_T\n\n";
}

# The base sizeof's are handled separately now in their own file

print MPIFD "        END MODULE MPI_t1_s\n";
close MPIFD;
&ReplaceIfDifferent( "mpi_t1.f90", "mpi_t1.f90.new" );

# -----------------------------------------------------------------------------
# This block can be used to create the Makefile
open ( MAKEFD, ">Makefile.sm.new" ) || die "Cannot create Makefile.sm.new";
print MAKEFD "# DO NOT EDIT\n# This file created by buildiface $arg_string\n";

print MAKEFD "smvar_do_dependencies = ignore\n";
#print MAKEFD "smvar_do_sharedlibs   = 0\n";
print MAKEFD "smvar_makefile_configdir = ../../..\n";
#print MAKEFD "smvar_debug=1\n";
print MAKEFD "MOD              = \@F90MODEXT\@\n";
print MAKEFD "MPIMOD           = \@MPIMODNAME\@\n";
print MAKEFD "MPICONSTMOD      = \@MPICONSTMODNAME\@\n";
print MAKEFD "MPISIZEOFMOD     = \@MPISIZEOFMODNAME\@\n";
print MAKEFD "MPIBASEMOD       = \@MPIBASEMODNAME\@\n";
print MAKEFD "F90INCFLAG       = \@F90INCFLAG\@\n";
print MAKEFD "F90EXT           = \@F90EXT\@\n";
print MAKEFD "F90_COMPILE_MODS = \$(F90_COMPILE)\n";
print MAKEFD 
"# We need to tell some compilers (e.g., Solaris f90) to look in the current 
# directory when the source file is not in the working directory (i.e.,
# in a VPATH build)
F90INCLUDES = \@F90INCFLAG\@.

";

print MAKEFD "mpi_sources = create_f90_int.c create_f90_real.c \\\
	create_f90_complex.c \\\
        typef90cmplxf.c typef90realf.c typef90intf.c\n";

# Add the C versions to the C library
print MAKEFD "lib\${MPILIBNAME}_a_SOURCES = \${mpi_sources} create_f90_util.c \
profilelib_\${MPILIBNAME}_SOURCES = \${mpi_sources}
profilelib_\${MPILIBNAME} = p\${MPILIBNAME}\
INCLUDES = -I../../include -I\${master_top_srcdir}/src/include\n";

# Add the MPI module objects to the f90 library
print MAKEFD "\
lib\${MPILIBNAME}f90_a_NOSHARED