#! /bin/csh -f
#
# 16 Apr 02 - MWS - C-shell script to compile one MODULE of GAMESS.
#
#------------------------
# 23 Mar 1993 - MH
# Modified to be part of CHARMM make procedure
#------------------------
# 24 Jul 1997 - MH
# Modified for automatic creation for various systems
# from CHARMM install.com
#------------------------
# 15 Jun 2002 - MH
# Upgrade to current comp script
#
# Invoke this script by 'comp MODULE >& MODULE.log &'.
# Sometimes systems with the Rand MH installed already have a "comp"
# command as part of the system. The best fix for this is to put the
# current path (.) ahead of all system paths in your PATH variable.
#
# ----- The next two lines require your attention -----
# 1. Choose your machine, the legal values for TARGET are
# compaq-axp,compaq-shmem,convex-spp,cray-pvp,cray-t3e,
# fuji-ap,fuji-vpp,hitachi,hp9000,ibm32,ibm64,ibm32-sp,ibm64-sp,
# linux-pc,macosx,necsx,sgi32,sun,win32
# 2. Choose your GAMESS directory tree.
#
set TARGET=linux-pc
#
unset echo
#set MODULE=$1
set MODULE=$1:t
set MODULE=$MODULE:r
set ENVMT=charmm
set chmsrc=$chmsrc/gamint
set PARALLEL=true
set ACTONLY=$2 # this argument is almost always omitted
if (null$MODULE == null) then
echo No compile module name given...
exit
endif
#
echo ======================== $MODULE ==============================
date
#
# ----- Is this a vector machine? -----
#
set VECTORIZE=false
if ($TARGET == cray-pvp) set VECTORIZE=true
if ($TARGET == fuji-vpp) set VECTORIZE=true
if ($TARGET == necsx) set VECTORIZE=true
#
# ----- on sequential scalar machines only -----
# Are level 3 BLAS in a system library?
# If so, matrix multiplies in MTHLIB.SRC can use DGEMM calls
#
set BLAS3=false
if ($TARGET == compaq-shmem) set BLAS3=true
if (($TARGET == compaq-axp) && (-e /lib/libdxml.a)) set BLAS3=true
if ($TARGET == cray-pvp) set BLAS3=true
if ($TARGET == cray-t3e) set BLAS3=true
if ($TARGET == fuji-vpp) set BLAS3=true
if ($TARGET == hitachi) set BLAS3=true
if ($TARGET == hp9000) set BLAS3=true
if ($TARGET == ibm32) set BLAS3=true
if ($TARGET == ibm64) set BLAS3=true
if ($TARGET == ibm32-sp) set BLAS3=true
if ($TARGET == ibm64-sp) set BLAS3=true
if (($TARGET == linux-pc) && (-e /usr/local/bin/libblas-asci.a)) set BLAS3=true
if ($TARGET == sgi32) set BLAS3=true
if ($TARGET == sgi64) set BLAS3=true
if (($TARGET == sun) && (-e /opt/SUNWspro/lib/libsunperf.so)) set BLAS3=true
#
if ($MODULE == mthlib) then
if ($BLAS3 == true) then
echo Compiling matrix multiply routines to use a system BLAS library...
else
echo FORTRAN matrix multiply routines will be used, not a BLAS library...
endif
endif
#
# ----- delete scalar code before compiling on vector systems -----
# UNIX's 'ld' loader is incapable of loading two copies of the
# object code for a routine, and simply using the first one.
# So, if we are using VECTOR.SRC on this machine, we must split
# up some of the modules, delete the scalar code for the routines
# which are found in VECTOR.SRC, and then recombine the rest of
# the code in that module. Ugh!
#
if ($VECTORIZE == true) then
rm -f *.f
switch ($MODULE)
case int2a:
echo Deleting scalar code forms.f
cp $chmsrc/gamess/int2a.src int2a.src
fsplit int2a.src
rm -f int2a.src
if (-e forms.f) rm forms.f
if (-e FORMS.f) rm FORMS.f
cat *.f > int2a.src
rm -f *.f
set SRCDIR=.
breaksw
case grd2c:
echo Deleting scalar code dspdfv, jdxyzv, jkgnmv, jkxyzv
cp $chmsrc/gamess/grd2c.src grd2c.src
fsplit grd2c.src
rm -f grd2c.src
if (-e dspdfv.f) rm -f dspdfv.f jdxyzv.f jkgnmv.f jkxyzv.f
if (-e DSPDFV.f) rm -f DSPDFV.f JDXYZV.f JKGNMV.f JKXYZV.f
cat *.f > grd2c.src
rm -f *.f
set SRCDIR=.
breaksw
case hss2b:
echo Deleting scalar code jddspd.f
cp $chmsrc/gamess/hss2b.src hss2b.src
fsplit hss2b.src
rm -f hss2b.src
if (-e jddspd.f) rm -f jddspd.f
if (-e JDDSPD.f) rm -f JDDSPD.f
cat *.f > hss2b.src
rm -f *.f
set SRCDIR=.
breaksw
case eigen:
echo Deleting scalar code gldiag.f
cp source/eigen.src eigen.src
fsplit eigen.src
rm -f eigen.src
if (-e gldiag.f) rm -f gldiag.f
if (-e GLDIAG.f) rm -f GLDIAG.f
cat *.f > eigen.src
rm -f *.f
set SRCDIR=.
breaksw
case mthlib:
echo Deleting scalar code mrarbr, mrtrbr, mtarbr, tfsqb, tftri.
cp source/mthlib.src mthlib.src
fsplit mthlib.src
rm -f mthlib.src
if (-e mrarbr.f) rm -f mrarbr.f mrtrbr.f mtarbr.f tfsqb.f tftri.f
if (-e MRARBR.f) rm -f MRARBR.f MRTRBR.f MTARBR.f TFSQB.f TFTRI.f
cat *.f > mthlib.src
rm -f *.f
set SRCDIR=.
breaksw
default:
set SRCDIR=$chmsrc/gamess
breaksw
endsw
else
set SRCDIR=$chmsrc/gamess
# if ($MODULE == blaswrap) set SRCDIR=misc
endif
#
# optional SIMOMM method using Tinker MM program
set TINKER=false
if ($MODULE == Libtad) set TINKER=true
if ($MODULE == Libteac) set TINKER=true
if ($MODULE == Libtedl) set TINKER=true
if ($MODULE == Libtemo) set TINKER=true
if ($MODULE == Libterx) set TINKER=true
if ($MODULE == Libtfi) set TINKER=true
if ($MODULE == Libtjo) set TINKER=true
if ($MODULE == Libtpr) set TINKER=true
if ($MODULE == Libtsx) set TINKER=true
if ($MODULE == Tdrive) set TINKER=true
if ($MODULE == Tinkin) set TINKER=true
if ($MODULE == Toys) set TINKER=true
if ($TINKER == true) then
set SRCDIR=.
set OBJDIR=../object
chdir tinker
goto cmp
endif
set OBJDIR=object
#
# ----- Does this module need to be activated? -----
# Note that if "DOUBLE PRECISION" translates to more than a 64
# bit floating point quantity, all modules must be passed into
# the activator to ensure the source is made single precision.
#
if ($TARGET == cray-pvp) goto act
if ($TARGET == cray-t3e) goto act
if ($TARGET == ibm64) goto act
if ($TARGET == ibm64-sp) goto act
if ($TARGET == necsx) goto act
if ($TARGET == sgi64) goto act
#
# Any module with machine dependent code must be activated...
#
if ($MODULE == aldeci) goto act
if ($MODULE == ccsdt) goto act
if ($MODULE == cphf) goto act
if ($MODULE == cprohf) goto act
if ($MODULE == ddi) goto act
if ($MODULE == ddishm) goto act
if ($MODULE == dft) goto act
if ($MODULE == dftint) goto act
if ($MODULE == grd2a) goto act
if ($MODULE == gugdga) goto act
if ($MODULE == gugdgb) goto act
if ($MODULE == gugdm2) goto act
if ($MODULE == gugem) goto act
if ($MODULE == gugsrt) goto act
if ($MODULE == gvb) goto act
if ($MODULE == hss2a) goto act
if ($MODULE == int2a) goto act
if ($MODULE == iolib) goto act
if ($MODULE == lagran) goto act
if ($MODULE == local) goto act
if ($MODULE == locpol) goto act
if ($MODULE == mccas) goto act
if ($MODULE == mcqdpt) goto act
if ($MODULE == mcqud) goto act
if ($MODULE == mcscf) goto act
if ($MODULE == mctwo) goto act
if ($MODULE == morokm) goto act
if ($MODULE == mp2) goto act
if ($MODULE == mp2grd) goto act
if ($MODULE == ordint) goto act
if ($MODULE == rhfuhf) goto act
if ($MODULE == tdhf) goto act
if ($MODULE == trans) goto act
if ($MODULE == trfdm2) goto act
if ($MODULE == unport) goto act
if ($MODULE == vector) goto act
#
# We may need to do a hack below on the matrix multiply routines
#
if (($BLAS3 == true) && ($MODULE == mthlib)) goto act
#
# On Hitachi, zheev.src should be changed by a hack below
#
if (($MODULE == zheev) && ($TARGET == hitachi)) goto act
#
# All other modules are straight FORTRAN, just copy them.
#
echo Copying source code, $MODULE.src does not require activation.
cp $SRCDIR/$MODULE.src $MODULE.f
goto cmp
#
# ----- Choose which version is to be activated -----
#
act:
#
if ($TARGET == convex-spp) then
setenv MACHIN '*I32'
if ($MODULE == ddi) setenv MACHIN '*XXX'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*HP '
endif
if ($TARGET == cray-pvp) then
setenv MACHIN '*I64'
if ($MODULE == ddi) setenv MACHIN '*SOC'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*CRY'
if ($MODULE == vector) setenv MACHIN '*CRY'
endif
# the T3E has a special SHMEM replacement for ddi.src
if ($TARGET == cray-t3e) then
setenv MACHIN '*I64'
if ($MODULE == ddishm) setenv MACHIN '*T3E'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*T3E'
endif
if ($TARGET == compaq-axp) then
setenv MACHIN '*I64'
if ($MODULE == ddi) setenv MACHIN '*SOC'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*DEC'
endif
# SHMEM on Compaq has a special SHMEM replacement for ddi.src
if ($TARGET == compaq-shmem) then
setenv MACHIN '*I64'
if ($MODULE == ddishm) setenv MACHIN '*DEC'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*DEC'
endif
if ($TARGET == fuji-vpp) then
setenv MACHIN '*I32'
if ($MODULE == ddi) setenv MACHIN '*XXX'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*FUJ'
if ($MODULE == vector) setenv MACHIN '*FUJ'
endif
if ($TARGET == fuji-ap) then
setenv MACHIN '*I32'
if ($MODULE == ddi) setenv MACHIN '*XXX'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*SUN'
endif
if ($TARGET == hitachi) then
setenv MACHIN '*I32'
if ($MODULE == ddi) setenv MACHIN '*XXX'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*HIT'
endif
if ($TARGET == hp9000) then
setenv MACHIN '*I32'
if ($MODULE == ddi) setenv MACHIN '*SOC'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*HP '
endif
if (($TARGET == ibm32) || ($TARGET == ibm64)) then
setenv MACHIN '*I32'
if ($TARGET == ibm64) setenv MACHIN '*I64'
if ($MODULE == ddi) setenv MACHIN '*SOC' # workstations use TCP/IP
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*AIX'
endif
if (($TARGET == ibm32-sp) || ($TARGET == ibm64-sp)) then
setenv MACHIN '*I32'
if ($TARGET == ibm64-sp) setenv MACHIN '*I64'
if ($MODULE == ddi) setenv MACHIN '*MPI' # but the SP uses MPI-1
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*AIX'
endif
if ($TARGET == linux-pc) then
setenv MACHIN '*I32'
if ($MODULE == ddi) setenv MACHIN '*MPI'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*F2C'
endif
if ($TARGET == macosx) then
setenv MACHIN '*I32'
if ($MODULE == ddi) setenv MACHIN '*SOC'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*F2C'
endif
if ($TARGET == necsx) then
setenv MACHIN '*I64'
if ($MODULE == ddi) setenv MACHIN '*SEQ'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*NEC'
if ($MODULE == vector) setenv MACHIN '*NEC'
endif
if ($TARGET == sgi32) then
setenv MACHIN '*I32'
if ($MODULE == ddi) setenv MACHIN '*SOC'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*SGI'
endif
if ($TARGET == sgi64) then
setenv MACHIN '*I64'
if ($MODULE == ddi) setenv MACHIN '*MPI'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*SGI'
endif
if ($TARGET == sun) then
setenv MACHIN '*I32'
if ($MODULE == ddi) setenv MACHIN '*SOC'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*SUN'
endif
if ($TARGET == win32) then
setenv MACHIN '*I32'
if ($MODULE == ddi) setenv MACHIN '*SEQ'
if ($MODULE == iolib) setenv MACHIN '*UNX'
if ($MODULE == unport) setenv MACHIN '*WIN'
endif
#
# Here we catch machines for which porting of message passing has
# not yet been done...
# Please note that this is not just as simple as picking the
# string to be activated in DDI above, as you will need to at
# least think about your compiling clause below.
#
if (($MODULE == ddi) && ("$MACHIN" == "*XXX")) then
echo "--------------------- error ----------------------------"
echo The 'comp' script does not know how to compile DDI.SRC.
echo Compilation is bombing...
echo "--------------------- error ----------------------------"
exit 8
endif
#
# ----- Activate the source code to produce FORTRAN -----
#
# On Hitachi, to get the normal Unix calling arguments for -getenv-
# which is called by ACTVTE, we need a special run time option:
if ($TARGET == hitachi) setenv HF_90OPTS '-FPORT(GETENV)'
#
set echo
setenv SRCIN $SRCDIR/$MODULE.src
setenv CODEOUT $MODULE.f
$chmtool/actvte.x_gnu
unset echo
#
# --------------- special machine "sed hacks" --------------------
# Not everything can be done with ACTVTE, so we use "sed" (ugh!).
#
# Direct access record length is measured in bytes on most Unix,
# but some kinds insist in measuring 4-byte words. This changes
# only one line in RAOPEN and one line in OPENDA in IOLIB.SRC.
# SGI's f90 should not execute the following, but SGI's f77 must.
#
if (($MODULE == iolib) && \
($TARGET == compaq-axp || $TARGET == compaq-shmem || \
$TARGET == sgi32 || $TARGET == sgi64)) then
mv iolib.f iolib.junk
sed -e "s/ \* RECL=8\*IRECLN/ * RECL=2*IRECLN/" \
iolib.junk > iolib.f
rm -f iolib.junk
endif
#
# Use DGEMM matrix multiply if possible.
#
if (($MODULE == mthlib) && ($BLAS3 == true)) then
mv mthlib.f mthlib.junk
sed -e "s/\*BL3/ /" mthlib.junk > mthlib.f
rm -f mthlib.junk
endif
#
# For 64 bit IBM or SGI machines, select 64 bit integers.
# This corrects the source code's assumption of 32 bits for these.
#
if (($MODULE == unport) && \
(($TARGET == ibm64) || ($TARGET == ibm64-sp) || ($TARGET == sgi64))) then
mv unport.f unport.junk
sed -e "s/ NWDVAR = 2/ NWDVAR = 1/" unport.junk > unport.f
rm -f unport.junk
endif
#
# This hack is necessary only if compiler flags below request the
# use of 64 bit integers in GAMESS, and if the vendor's BLAS library
# insists that its integer arguments be 32 bit quantities.
# There is a special wrapper file gamess/misc/blaswrap.src that deals
# with this problem, provided we hack the source to call the wrappers.
#
if (($MODULE != blaswrap) && \
(($TARGET == ibm64) || ($TARGET == ibm64-sp) || ($TARGET == sgi64))) then
sed -e "s/DASUM/XASUM/g" -e "s/dasum/XASUM/g" \
-e "s/DAXPY/XAXPY/g" -e "s/daxpy/XAXPY/g" \
-e "s/DCOPY/XCOPY/g" -e "s/dcopy/XCOPY/g" \
-e "s/DDOT/XDOT/g" -e "s/ddot/XDOT/g" \
-e "s/DNRM2/XNRM2/g" -e "s/dnrm2/XNRM2/g" \
-e "s/DROT/XROT/g" -e "s/drot/XROT/g" \
-e "s/DROTG/XROTG/g" -e "s/drotg/XROTG/g" \
-e "s/DSCAL/XSCAL/g" -e "s/dscal/XSCAL/g" \
-e "s/DSWAP/XSWAP/g" -e "s/dswap/XSWAP/g" \
-e "s/IDAMAX/IXAMAX/g" -e "s/idamax/IXAMAX/g" \
-e "s/DGER/XGER/g" -e "s/dger/XGER/g" \
-e "s/DTRMM/XTRMM/g" -e "s/dtrmm/XTRMM/g" \
-e "s/DTRMV/XTRMV/g" -e "s/dtrmv/XTRMV/g" \
-e "s/DTRSM/XTRSM/g" -e "s/dtrsm/XTRSM/g" \
-e "s/DGEMV/XGEMV/g" -e "s/dgemv/XGEMV/g" \
-e "s/DGEMM/XGEMM/g" -e "s/dgemm/XGEMM/g" \
$MODULE.f >> $MODULE.munged
mv $MODULE.munged $MODULE.f
endif
#
# The following hack selects AOINTS=DIST as the default on high end
# Compaq and IBM systems, where we know we have a high quality network.
#
if (($MODULE == unport) && \
(($TARGET == compaq-shmem) || ($TARGET == ibm32-sp) || \
($TARGET == ibm64-sp))) then
mv unport.f unport.junk
sed -e "s/\*TRF/ /" unport.junk > unport.f
rm -f unport.junk
endif
#
# Fujitsu AP3000, enable stripping of path information for local I/O files
#
if (($MODULE == iolib) && ($TARGET == fuji-ap)) then
mv iolib.f iolib.junk
sed -e "s/ISTRIP=1/ISTRIP=0/" iolib.junk > iolib.f
rm -f iolib.junk
endif
#
# Hitachi prefers a different double precision complex syntax
#
if (($MODULE == zheev) && ($TARGET == hitachi)) then
mv zheev.f zheev.junk
sed -e "s/COMPLEX\*16 FUNCTION ZLADIV/COMPLEX FUNCTION ZLADIV\*16/" \
-e "s/COMPLEX\*16 FUNCTION ZDOTC/COMPLEX FUNCTION ZDOTC\*16/" \
zheev.junk > zheev.f
rm -f zheev.junk
endif
#
# On Hitachi, the first argument of HF_CFUNC is actually a name of C
# routine, so it is case sensitive.
#
if (($MODULE == unport) && ($TARGET == hitachi)) then
mv unport.f unport.junk
sed -e "s/HF_CFUNC('ABORT'/HF_CFUNC('abort'/" unport.junk > unport.f
rm -f unport.junk
endif
#
# On Sun, avoid ugly warning about possible floating point errors issued
# by every data server process, which come from a FORTRAN STOP statement.
#
if (($MODULE == ddi) && ($TARGET == sun)) then
mv ddi.f ddi.junk
sed -e "s/ STOP/ CALL EXIT(0)/" ddi.junk > ddi.f
rm -f ddi.junk
endif
#
# ...and this is the end of the ugly "sed hack"s.
#
# --------- Now we are ready to compile on the target machine ----------
#
cmp:
#
# Optionally, save pure FORTRAN in temporary directory for
# syntax scan by the nifty FORTRAN analysis program FTNCHEK.
#
if ($ACTONLY == true) then
mv $MODULE.f ~/scr
exit
endif
#
if (-e $OBJDIR/$MODULE.o) rm -f $OBJDIR/$MODULE.o
#
# Options for the Compaq AXP FORTRAN 5.2 compiler under Tru64 V4.0F are
# -O0 turns off all optimization
# -O1 does local optimizations
# -O2 also does global optimizations
# -O3 also does additional global optimizations
# -O4 also does routine inlining (default)
# -O5 also does software pipelining
# -fast implies less accurate but faster libraries, etc. and -O4.
# -c means compile only
# -i8 selects use of 64 bit integers
# -v gives compiler phase information, and timings
# -automatic and -static use/avoid stack for local variables
# -col72 chops source lines past 72 columns
# -stand nosemantic means don't warn of nonANSI usage (default)
# -stand nosource_form means don't warn of tabs/lowercase (default)
# -stand nosyntax means don't warn of nonANSI syntax (default)
#
# Note that we've tried f77 3.3, 3.7, 3.8, and 5.2, but nothing in between.
# This is an excellent compiler, and probably all versions work.
#
if ($TARGET == compaq-axp) then
set OPT = '-O4'
set echo
f77 -c -i8 -v -automatic -col72 $OPT $MODULE.f
unset echo
endif
# The SuperCluster assumes a specific AXP chip...
if ($TARGET == compaq-shmem) then
set OPT = '-fast -tune ev67 -arch ev67'
if ($MODULE == zheev) set OPT='-O0'
set echo
f77 -c -i8 -v -col72 $OPT $MODULE.f
unset echo
endif
#
# Cray parallel vector processor (e.g. T90, J90, SV1...)
# Cray T90 tested in February of 2000
# Cray SV1 rev C with CF90 3.4.0.0.4 tested in March of 2000
# Note that all Cray clauses now use f90 compiler only.
#
if ($TARGET == cray-pvp) then
set OPT = '-O2 '
if ($MODULE == int2a) set OPT='-Ovector0,scalar3 '
if ($MODULE == grd2a) set OPT='-Ovector0,scalar2 ' # Jerry says
if ($MODULE == grd2b) set OPT='-Ovector0,scalar3 '
if ($MODULE == grd2c) set OPT='-Ovector0,scalar3 '
if ($MODULE == gugem) set OPT='-Ovector0,scalar3 '
if ($MODULE == vector) set OPT='-O1 '
if ($MODULE == gvb) set OPT='-O1 ' # use -O0 if exam15,16,21 fail
if ($MODULE == gamess) set OPT='-O0 '
if ($MODULE == efinp) set OPT='-O0 '
if ($MODULE == efinta) set OPT='-Ovector0,scalar3 '
if ($MODULE == efintb) set OPT='-Ovector0,scalar3 '
if ($MODULE == efgrda) set OPT='-Ovector0,scalar3 '
if ($MODULE == efgrdb) set OPT='-Ovector0,scalar3 '
if ($MODULE == efgrdc) set OPT='-Ovector0,scalar3 '
if ($MODULE == efgrd2) set OPT='-Ovector0,scalar3 '
set echo
f90 -c -V $OPT $MODULE.f
unset echo
endif
#
# Compiler flags for Cray T3E under UNICOS/mk 2.0.3.18, cf90 3.1.0.3
# -Oscalarn is various scalar optimizations (n=0,1,2,3)
# -Oaggress increases table sizes used during optimizations
# -O[no]msgs,[no]negmsgs [disables]enables compiler optimization messages
# -dp disables double precision
#
if ($TARGET == cray-t3e) then
set OPT = '-Oscalar3,aggress'
if ($MODULE == grd2c) set OPT='-O1' # for cf90 3.1.0.3 and others
if ($MODULE == hss1b) set OPT='-O1' # for cf90 3.4.0.0
set echo
env TARGET=cray-t3e f90 -c $OPT -dp -Onomsgs,nonegmsgs $MODULE.f
unset echo
endif
#
# Fujitsu VPP300 options
# Modified by Anthony J. Russell, ANU Supercomputer Facility, 20/1/98
#
# Should also be suitable for other VPP and VX supercomputers.
#
# Options for Fujitsu's UXP/V Fortran90 compiler under UXP/M are
# -Ab means reference dummy arguments by address
# -c means compile only
# -Oe is for extended scalar optimization
# -Ss turns off I and W level messages
# -Kfast produces code optimized for speed of execution
# on the compile time machine
# Vectorization options
# -Wv,-Of,-te,-ilfunc invokes the vector compiler
# with full optimization for vector intrinsic functions
# -te Expands the work area for vectorization
# -ilfunc inlines function calls
#
if ($TARGET == fuji-vpp) then
set OPT = '-Oe -Kfast -Wv,-Of,-te,-ilfunc'
# next ones are faster in scalar
if ($MODULE == int2a) set OPT='-Oe'
if ($MODULE == grd2a) set OPT='-Oe'
if ($MODULE == grd2b) set OPT='-Oe'
if ($MODULE == grd2c) set OPT='-Oe'
if ($MODULE == gugem) set OPT='-Oe'
if ($MODULE == mctwo) set OPT='-Oe'
set INCPATH='-I/usr/lang/mpi/include'
set echo
frt -c -Ab -Ss $OPT $MODULE.f $INCPATH
unset echo
endif
#
# Fujitsu AP-3000 options
# this is an array of UltraSPARC chips used to construct a parallel computer
# Anthony J. Russell, ANU Supercomputer Facility, 5/2/98
#
# The OPT string is fastest compiler generated code
# -c compile only
# -w66 suppress the messages generated by using F66 features
# -Nl indicates continuation line
#
if ($TARGET == fuji-ap) then
set OPT = '-fast -xarch=v8plus'
set echo
f77 -c -w66 -Nl30 $OPT $MODULE.f
unset echo
endif
#
# Options for HITACH SR2201 machine's HI-UX/MPP compiler
# blank implies full scalar optimization
# -W0,'OPT(O(0))' turns off optimization
# -W0,'OPT(O(ss)),PVEC(DIAG(1))' is vectorization (not tested yet)
#
if ($TARGET == hitachi) then
set FORT='f90'
set INCPATH='-I/usr/mpi/include'
set OPT=" "
if ($MODULE == sobrt) set OPT="-W0,'OPT(O(0))'"
set echo
$FORT -c $OPT $INCPATH $MODULE.f
unset echo
endif
#
# HP-UX B.11.0, using f90 2.4.10 (f90 +version reports version number)
# The options mean:
# +[no]save governs automatic variable allocation strategy
# +On selects optimization level; n=0,1,2,3,4 (-O means +O2)
# 0 is none, 1 is block transforms, 2 is full within subprograms
# 3 crosses subprograms (includes inlining) also loop transforms
# +Oaggressive selects the following four additions to +O2:
# +Oentrysched = instruction scheduling on entry/exit
# +Olibcalls = special trig and power functions (lacking error hand.)
# +Onofltacc = permits use of a faster single multiply/add instruction.
# +Onoinitcheck = disable initialization of any unitialized datum
# other optimizations include
# +Onolimit = ignores time and memory limits when optimizing
# +Ofastaccess = gives fast access to global data
# +U77 gives access to BSD's 3F library
#
if ($TARGET == hp9000) then
set OPT='+O2 +Oaggressive +Onolimit +Ofastaccess'
if ($MODULE == unport) set OPT='+O2 +Oaggressive +Onolimit +Ofastaccess +U77'
set echo
f90 -c $OPT +nosave $MODULE.f
unset echo
endif
#
# The following was used for compiler version 10.20 under HP-UX 10.
#
#---if ($TARGET == hp9000) then
#--- set OPT='+O2'
#--- if($MODULE == hss1a) set OPT='+O1'
#--- set echo
#--- f77 -c $OPT +U77 +Oentrysched +Ofastaccess \
#--- +Olibcalls +Onofltacc +Onolimit $MODULE.f
#--- unset echo
#---endif
#
if ($TARGET == convex-spp) then
set OPT='+O2 +Obb600'
if ($TARGET == convex-spp) set OPT='$OPT -K'
if ($MODULE == guess) set OPT='+O1'
if ($MODULE == hss2a) set OPT='+O1'
if ($MODULE == inputa) set OPT='+O1'
set echo
f77 -c $OPT +FPD +E1 +E6 +T -s $MODULE.f
unset echo
endif
#
# For IBM 32 or 64 bit RS/6000 workstations or SP parallel systems,
# the options for XL FORTRAN 7.1.0 and AIX 4.3.3 are
# -c means compile only
# -O2 and -O3 choose optimization levels (there is no -O1)
# -qarch=com,601,pwr,pwr2,pwr3 (see also -qtune)
# -qflag requests I,L,W,E,S,Q (information, language,
# warning, error, severe, quiet) messages
# -qflttrap=ov:zero:inv:inex:enable traps bad arithmetic
# -qhalt stops compiler after certain error level
# -qnosave forces non-static storage
# -qinitauto=ff initializes non-static storage
# -qextchk checks calling args and common lengths at link
# -qsource requests a printable .lst file.
# -qtune selects target chip
#
# The following clause requires XL FORTRAN 3.2 or higher.
# Use of 64 bit integers requires XL FORTRAN 6.1 or higher.
# The command to find your FORTRAN version level depends on your
# AIX version: v3 is "lslpp -h xlfcmp.obj", v4="lslpp -h xlfcmp".
#
# To profile code during development stages,
# 1. "comp" desired modules with -pg added to the xlf flags
# 2. "lked" after adding -p to the xlf flags.
# 3. execute to completion, generating 'mon.out' file.
# 4. profile by 'prof gamess.00.x mon.out'.
#
if (($TARGET == ibm32) || ($TARGET == ibm64) || \
($TARGET == ibm32-sp) || ($TARGET == ibm64-sp)) then
set FORT='xlf'
if ($TARGET == ibm32-sp) set FORT='mpxlf'
if ($TARGET == ibm64-sp) set FORT='mpxlf'
# old 32 bit workstations, whether Power, Power2, or PowerPC
# should all select plain vanilla common architecture. Its
# faster and runs on any combination of these chips you own.
# under xlf 4.1.0 a few files won't fully optimize
if ($TARGET == ibm32) then
set OPT='-O3'
if ($MODULE == grd2b) set OPT='-O3 -qspillsize=1500'
if ($MODULE == gugdm) set OPT='-O2'
if ($MODULE == gugem) set OPT='-O2'
if ($MODULE == resc) set OPT='-O2'
if ($MODULE == trnstn) set OPT='-O2'
set ARCH='com'
set TUNE='604' # PowerPC tuning makes even Power1 run faster
endif
# 64 bit workstations or SP is sure to be Power3 or 4 chips.
# everything optimizes under xlf 5.1.1 and 6.1.0 and 7.1.0
if (($TARGET == ibm64) || ($TARGET == ibm64-sp)) then
set OPT='-O3 -q64 -qintsize=8 -qspillsize=1500'
set ARCH='pwr3'
set TUNE='pwr3'
endif
# your 32 SP might not be a new one, if not, mimic ibm32 clause.
# Here ARCH/TUNE assume the SP is new enough to have Power3 nodes,
# but that the software is old and so lacks a 64 bit MPI library.
if ($TARGET == ibm32-sp) then
set OPT='-O3 -qspillsize=1500'
set ARCH='pwr3'
set TUNE='pwr3'
endif
set echo
$FORT -c $OPT -qarch=$ARCH -qtune=$TUNE \
-qflag=I:I -qhalt=W -qnosave $MODULE.f
unset echo
endif
#
# ------ RedHat Linux on "PC" (Pentium/Athlon chips) -----
# There are no less than four compilers for Linux included here!
# They are g77 (default), f2c/gcc, Intel's ifc, and Portland's pgf77.
# If you want to use one of the other three, just make sure that the
# one you prefer is uncommented. In addition, you will need to edit
# the link-edit script 'lked' to reflect your compiler choice here.
#
# Note that we have only used Redhat, so this is not necessarily
# correct for Slackware, SUSE, FreeBSD, ..., although many people
# have been able to get these others to work.
#
# 1. Using g77 compiler. compiler version query: rpm -q gcc-g77
# If your RedHat is older than 6.0, see the f2c/gcc clause below.
#
# There is an I/O library problem in g77, apparently in all RedHat
# releases from 6.0 through 7.1's gcc-g77-2.96-81. You can find a
# a fix on our web page: www.msg.ameslab.gov/GAMESS/GAMESS.html,
# then check the bottom of the "how to get a copy of GAMESS" page.
# It is crucial to install this, as it works around a very serious
# error in the g77 I/O library.
# The 3.0 release of GNU compilers is scheduled to fix this bug.
#
# The meaning of g77's flags are
# -O0, -O1, -O2, -O3 are the optimization levels, -O means -O1
# -Wno-globals -fno-globals together suppress argument type checking.
# -fautomatic defeats use of static storage
# -malign-double uses 64 bit data alignment
# Tests on a representative GAMESS test suite (executing energy, gradient
# hessian code, as well as various SCF, MCSCF, MP2 runs, show that each
# of the more aggressive optimizations -ffast-math, -march=i586, and -O3
# gave speedups of less than 1% each. (-march=i686 slows a Celeron type
# Pentium II fractionally). None of these optimizations are used below.
#
if ($TARGET == linux-pc) then
set OPT = '-O2'
set echo
g77 -c $OPT -malign-double -march=i686 -fschedule-insns2 -Wno-globals -fno-globals $MODULE.f
unset echo
endif
#
# 2. RedHat 4.x and 5.x's FORTRAN compiler was f2c/gcc, and early
# releases of g77 that were present in some of these distributions
# do not run GAMESS correctly. If you have RedHat 6.0 or higher,
# which do not contain the f2c interpreter, see just above. If
# your RedHat is older, use f2c/gcc instead of buggy old g77's.
#
#--if ($TARGET == linux-pc) then
#-- if (($MODULE == qfmm) || ($MODULE == solib) || ($MODULE == zheev)) then
#-- mv $MODULE.f $MODULE.junk
#-- sed -e s/DREAL/DBLE/g $MODULE.junk > $MODULE.f
#-- rm -f $MODULE.junk
#-- endif
#-- set OPT = '-O3 -malign-double'
#-- set echo
#-- f2c -w66 -a -Nn802 -Nx400 $MODULE.f
#-- gcc -c $OPT $MODULE.c
#-- rm -f $MODULE.c
#-- unset echo
#--endif
#
# 3. Intel Fortran Compiler 5.0.1 for Linux
# This compiler can be downloaded for non-commercial purposes:
# http://developer.intel.com/software/products/compilers/f50/linux/noncom.htm
# -O3 is the most aggressive optimization, the default is -O2.
# -cm turn off printing of informational messages (f90 syntax, etc)
# -w turn off all warnings
# Remember to load compiler setup by running proper (for your shell)
# setup script as described in Intel's docs:
# . /opt/intel/compiler50/ia32/bin/ifcvars.sh
#
#--if ($TARGET == linux-pc) then
#-- set OPT = '-O3'
#-- if ($MODULE == zheev) set OPT='-O0'
#-- set echo
#-- ifc $OPT -cm -w -c $MODULE.f
#-- unset echo
#--endif
#
# 4. Portland Group compiler.
# This is a synthesis of recommendations from Fred Arnold and Brian
# Salter-Duke. -fast means -O2 -Munroll -Mnoframe, the latter option
# seems to be the source of several incorrect results. It is said that
# "-Munroll" and "-tp p6" gives no significant improvement in run times.
#
#--if ($TARGET == linux-pc) then
#-- setenv PATH $PATH\:/usr/pgi/linux86/bin
#-- setenv PGI /usr/pgi
#-- if (($MODULE == qfmm) || ($MODULE == solib) || ($MODULE == zheev)) then
#-- mv $MODULE.f $MODULE.junk
#-- sed -e s/DREAL/DBLE/g $MODULE.junk > $MODULE.f
#-- rm -f $MODULE.junk
#-- endif
#-- set OPT = '-O2'
#-- set echo
#-- pgf77 -c $OPT $MODULE.f
#-- unset echo
#--endif
#
# Mac OS X version 10.1 (aka Darwin)
# You must first install the Apple Developer Toolkit to get a cc
# compiler, this is available for download at Apple's web site.
# Then you have two choices for obtaining a FORTRAN compiler:
# 1. f2c, which in our experience was 10% faster, and is therefore
# the default. Download the f2c installation script from
# http://www.caos.aamu.edu/pub/MacOS_X/BSD/Development/Languages/f2c
# 2. g77, from the FINK project, http://fink.sourceforge.net/download,
# first to get the binary installer, and then under languages, g77.
# In the event you use g77, you also need to change the 'lked' script.
#
if ($TARGET == macosx) then
if (($MODULE == qfmm) || ($MODULE == solib) || ($MODULE == zheev)) then
mv $MODULE.f $MODULE.junk
sed -e s/DREAL/DBLE/g $MODULE.junk > $MODULE.f
rm -f $MODULE.junk
endif
set OPT = '-O3'
set echo
f2c -w66 -a -Nn802 -Nx400 $MODULE.f
cc -c $OPT $MODULE.c
rm -f $MODULE.c
unset echo
#
#-- set OPT = '-O2'
#-- set echo
#-- g77 -c $OPT -fautomatic -Wno-globals -fno-globals $MODULE.f
#-- unset echo
endif
#
# Options for f90 under SUPER-UX on the NEC SX Series are
# -float0 -w Cray compatible data
# -b sets needed passing of scalar arguments
# -pvtcl noassume vwork=stack sets vectorization temporaries parameters
# -Nv vectorization is turned off
#
if ($TARGET == necsx) then
set OPT = '-Wf"-v -pvctl noassume vwork=stack"'
if ($MODULE == mcqdpt) \
set OPT='-Wf"-v -pvctl noassume vwork=stack noaltcode nodivloop -NO"'
if ($MODULE == ddi) \
set OPT='-Wf"-v -pvctl noassume vwork=stack -I /usr/include"'
# compiler character problem
if ($MODULE == inputc) set OPT='-Wf"-Nv"'
# next ones are faster in scalar
if ($MODULE == int2a) set OPT='-Wf"-Nv"'
if ($MODULE == int2b) set OPT='-Wf"-Nv"'
if ($MODULE == grd2a) set OPT='-Wf"-Nv"'
if ($MODULE == grd2b) set OPT='-Wf"-Nv"'
if ($MODULE == grd2c) set OPT='-Wf"-Nv"'
if ($MODULE == gugem) set OPT='-Wf"-Nv"'
if ($MODULE == gugdrt) set OPT='-Wf"-Nv"'
#
set echo
f90 -c -float0 -ebw $OPT $MODULE.f
unset echo
endif
#
# Options for SGI f77 7.3 under Irix 6.5.14
# Type "versions -I ftn77_dev" to see the compiler revision.
#
# Different versions of the SGI compiler may not work with the fairly
# aggressive -O3 optimization used below. If you experience any numerical
# problems, please try using -O2 rather than -O3 below. It is unsafe to
# use very aggressive optimizations like "-OPT:IEEE_arith=3:roundoff=3".
#
# ARCH might need to be changed from -r12000 to -r10000 or -r8000 or -r5000,
# type "hinv -c processor" to see what your processor is.
# Especially for R5000 systems, or low end O2, the options "-64 -mips4"
# might need to be "-n32 -mips3", perhaps. If you change these here, be
# sure to make the corresponding change in compall and lked scripts too.
#
# If you use f90, do not reset the units for RECL in the sed hacks above.
#
# -show would add verbose printing of compiler phase information.
# -automatic is the opposite of -static storage allocation.
# -OPT:Olimit=0 removes subroutine size optimization limits.
# -woff suppresses warnings (2290=type checking on calling args).
# -i8 selects 8 byte integer and logical data types.
#
if (($TARGET == sgi32) || ($TARGET == sgi64)) then
set OPT='-O3'
if ($MODULE == grd2c) set OPT='-O2'
set ARCH='-r12000'
set INTS=' '
if ($TARGET == sgi64) set INTS='-i8'
set FLAGS='-64 -mips4 -automatic -G0 -woff 2290 -OPT:Olimit=0'
set echo
f77 -c $OPT $ARCH $FLAGS $INTS $MODULE.f
unset echo
endif
#
# Options for UltraSPARC Sun f77 4.2 under Solaris 2.6.
# -c compile only
# -v print verbose information on compiler phases and options
# -stackvar forces non-static storage
# -fast is a smorgasbord of all the below, if you wish to
# override one you must *follow* the -fast with it.
# -xtarget=native (optimize for chip being compiled upon)
# -O4 (see below)
# -libmil (inline some math routines)
# -fsimple=1 (0,1,2 control floating point simplifications)
# -dalign (double word alignment and instructions)
# -xlibmopt (link to optimized math library)
# -depend (DO loop data dependency analysis)
# -fns (fast underflow handling)
# -ftrap=%none (floating point error handling)
# -O5 = aggressive optimizations
# -O4 = automatic inlining
# -O3 = loop unrolling and additional global optimizations
# -O2 = basic local, global optimizations (must turn off -depend)
# -O1 = minimal optimization
# -xtarget=generic doesn't tune for any particular chip
# -xtarget=native selects a -xarch,-xchip,-xcache for compile host
# you may want to set this a particular chip if you run
# more times on a different system than you compile on.
# On an UltraSPARC, the -xtarget=native in -fast implied -xarch=v8!
# You get best results by picking -xarch value closest to your system.
# -xarch=generic no particular SPARC chip
# -xarch=v7 SPARC V7 (i.e. SPARCstn 1)
# -xarch=v8 SuperSPARC (i.e. SPARCstn 2 and SPARCstn 10)
# -xarch=v8a microSPARC
# -xarch=v8plus UltraSPARC II, using 32 bit instructions
# -xarch=v8plusb UltraSPARC III
# -xarch=v9 64 bit instruction set (not tested well)
#
# MPI usage: in comp, add -I/opt/SUNWhpc/include/
# in lked, add -L/opt/SUNWhpc/lib -lfmpi -lmpi
# as well as making the obvious changes to move Sun clauses from the
# TCP/IP sockets sections to the MPI sections in compall and lked.
#
# If you have a pre-ultraSPARC system, try OPT='-O2' or '-O3' while
# eliminating the -xarch flag, and you might also need -Nl30.
#
if ($TARGET == sun) then
set OPT='-fast -O4 -xarch=v8plus'
if ($MODULE == ddi) set OPT='-fast -O4 -nodepend -xarch=v8plus'
if ($MODULE == grd2c) set OPT='-fast -O4 -nodepend -xarch=v8plus'
set echo
f77 -c $OPT -stackvar $MODULE.f
unset echo
endif
#
# Windows (win32) versions using Compaq Visual Fortran compiler
# The scripts may be executed with UWIN's C-shell emulator.
#
if ($TARGET == win32) then
set OPT = '4'
if ($MODULE == inputa) set OPT = '2'
set echo
f77.exe /c /optimize:$OPT /object:$MODULE.o $MODULE.f
unset echo
endif
#
# Store the generated object code, clean up, and quit
#
#mv $MODULE.o $OBJDIR/$MODULE.o
#if ($TINKER == true) exit
#rm -f $MODULE.f
#if ($SRCDIR == .) rm -f $MODULE.src # delete copy with no scalar code
unset echo
date
time