Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
more cleanups in NAS
authorFrederic Suter <frederic.suter@cc.in2p3.fr>
Mon, 15 Feb 2016 23:08:15 +0000 (00:08 +0100)
committerFrederic Suter <frederic.suter@cc.in2p3.fr>
Mon, 15 Feb 2016 23:08:15 +0000 (00:08 +0100)
25 files changed:
examples/smpi/NAS/DT/Makefile
examples/smpi/NAS/EP/Makefile
examples/smpi/NAS/EP/README [deleted file]
examples/smpi/NAS/EP/ep-sampling.c
examples/smpi/NAS/EP/ep.c
examples/smpi/NAS/EP/mpinpb.h [deleted file]
examples/smpi/NAS/EP/randlc.c [deleted file]
examples/smpi/NAS/EP/randlc.h [deleted file]
examples/smpi/NAS/IS/Makefile
examples/smpi/NAS/Makefile
examples/smpi/NAS/README [deleted file]
examples/smpi/NAS/README.install
examples/smpi/NAS/common/c_print_results.c
examples/smpi/NAS/common/c_timers.c
examples/smpi/NAS/common/randdp.c
examples/smpi/NAS/config/NAS.samples/suite.def.ep [deleted file]
examples/smpi/NAS/config/NAS.samples/suite.def.is [deleted file]
examples/smpi/NAS/config/make.def
examples/smpi/NAS/config/make.def.template [deleted file]
examples/smpi/NAS/sys/Makefile
examples/smpi/NAS/sys/README
examples/smpi/NAS/sys/make.common
examples/smpi/NAS/sys/print_header [deleted file]
examples/smpi/NAS/sys/print_instructions
examples/smpi/NAS/sys/setparams.c

index f21a8a6..cfcfea5 100644 (file)
@@ -1,30 +1,19 @@
-SHELL=/bin/sh
 BENCHMARK=dt
 BENCHMARK=dt
-
 include ../config/make.def
 include ../config/make.def
-
 include ../sys/make.common
 include ../sys/make.common
-#Override PROGRAM
-DTPROGRAM  = $(BINDIR)/$(BENCHMARK).$(CLASS)
-
-OBJS = dt.o  DGraph.o \
-       ${COMMON}/c_print_results.o ${COMMON}/c_timers.o ${COMMON}/c_randdp.o
-
-OBJS-F = dt-folding.o DGraph.o \
-       ${COMMON}/c_print_results.o ${COMMON}/c_timers.o ${COMMON}/c_randdp.o
 
 
+OBJS = DGraph.o ${COMMON}/c_print_results.o ${COMMON}/c_timers.o ${COMMON}/randdp.o
 
 
-${PROGRAM}: config ${OBJS} ${OBJS-F}
-       ${CLINK} ${CLINKFLAGS} -o ${DTPROGRAM} ${OBJS} ${CMPI_LIB}
-       ${CLINK} ${CLINKFLAGS} -o ${DTPROGRAM}-folding ${OBJS-F} ${CMPI_LIB}
+${PROGRAM}: config dt.o dt-folding.o ${OBJS}
+       ${CLINK} ${CLINKFLAGS} -o $(BINDIR)/dt.${CLASS} dt.o ${OBJS} ${CMPI_LIB}
+       ${CLINK} ${CLINKFLAGS} -o ${BINDIR}/dt-folding.${CLASS} dt-folding.o ${OBJS} ${CMPI_LIB}
 
 .c.o:
        ${CCOMPILE} $<
 
 
 .c.o:
        ${CCOMPILE} $<
 
-dt.o:             dt.c  npbparams.h
-dt-folding.o:     dt-folding.c  npbparams.h
-DGraph.o:      DGraph.c DGraph.h
+dt.o:             dt.c npbparams.h
+dt-folding.o:     dt-folding.c npbparams.h
+DGraph.o:         DGraph.c DGraph.h
 
 clean:
 
 clean:
-       - rm -f *.o *~ mputil*
-       - rm -f dt dt-folding npbparams.h
+       - rm -f *.o *~ npbparams.h
index 3387d73..3d38c27 100644 (file)
@@ -1,26 +1,15 @@
-SHELL=/bin/sh
 BENCHMARK=ep
 BENCHMARK=ep
-BENCHMARKU=EP
-
 include ../config/make.def
 include ../config/make.def
-
-OBJS = ep.o randlc.o
-OBJS-S = ep-sampling.o randlc.o
-
 include ../sys/make.common
 
 include ../sys/make.common
 
-${PROGRAM}: config ${OBJS} ${OBJS-S}
-       ${CLINK} ${CLINKFLAGS} -o ${PROGRAM} ${OBJS} ${CMPI_LIB} -lm
-       ${CLINK} ${CLINKFLAGS} -o ${PROGRAM}-sampling ${OBJS-S} ${CMPI_LIB} -lm
+${PROGRAM}: config ep.o ep-sampling.o ../common/randdp.o
+       ${CLINK} ${CLINKFLAGS} -o ${BINDIR}/ep.${CLASS}.${NPROCS} ep.o ../common/randdp.o ${CMPI_LIB} -lm
+       ${CLINK} ${CLINKFLAGS} -o ${BINDIR}/ep-sampling.${CLASS}.${NPROCS} ep-sampling.o ../common/randdp.o ${CMPI_LIB} -lm
 
 
-ep.o:  ep.c randlc.c mpinpb.h npbparams.h
+ep.o:  ep.c npbparams.h
        ${CCOMPILE} ep.c
        ${CCOMPILE} ep.c
-ep-sampling.o: ep-sampling.c randlc.c mpinpb.h npbparams.h
+ep-sampling.o: ep-sampling.c npbparams.h
        ${CCOMPILE} ep-sampling.c
 
 clean:
        ${CCOMPILE} ep-sampling.c
 
 clean:
-       - rm -f *.o *~ 
-       - rm -f npbparams.h
-
-
-
+       - rm -f *.o *~ npbparams.h
diff --git a/examples/smpi/NAS/EP/README b/examples/smpi/NAS/EP/README
deleted file mode 100644 (file)
index 6eb3657..0000000
+++ /dev/null
@@ -1,6 +0,0 @@
-This code implements the random-number generator described in the
-NAS Parallel Benchmark document RNR Technical Report RNR-94-007.
-The code is "embarrassingly" parallel in that no communication is
-required for the generation of the random numbers itself. There is
-no special requirement on the number of processors used for running
-the benchmark.
index 01bd4c7..c5956b6 100644 (file)
@@ -6,8 +6,6 @@
 #include "mpi.h"
 #include "npbparams.h"
 
 #include "mpi.h"
 #include "npbparams.h"
 
-#include "randlc.h"
-
 #ifndef CLASS
 #define CLASS 'S'
 #define NUM_PROCS            1                 
 #ifndef CLASS
 #define CLASS 'S'
 #define NUM_PROCS            1                 
index 685fdca..569c2f2 100644 (file)
@@ -8,8 +8,6 @@
 
 #include "simgrid/instr.h" //TRACE_
 
 
 #include "simgrid/instr.h" //TRACE_
 
-#include "randlc.h"
-
 #ifndef CLASS
 #define CLASS 'S'
 #define NUM_PROCS            1                 
 #ifndef CLASS
 #define CLASS 'S'
 #define NUM_PROCS            1                 
diff --git a/examples/smpi/NAS/EP/mpinpb.h b/examples/smpi/NAS/EP/mpinpb.h
deleted file mode 100644 (file)
index 1f13637..0000000
+++ /dev/null
@@ -1,9 +0,0 @@
-
-c---------------------------------------------------------------------
-c---------------------------------------------------------------------
-
-      include 'mpif.h'
-
-      integer           me, nprocs, root, dp_type
-      common /mpistuff/ me, nprocs, root, dp_type
-
diff --git a/examples/smpi/NAS/EP/randlc.c b/examples/smpi/NAS/EP/randlc.c
deleted file mode 100644 (file)
index 4de6c93..0000000
+++ /dev/null
@@ -1,107 +0,0 @@
-
-/*
- *    FUNCTION RANDLC (X, A)
- *
- *  This routine returns a uniform pseudorandom double precision number in the
- *  range (0, 1) by using the linear congruential generator
- *
- *  x_{k+1} = a x_k  (mod 2^46)
- *
- *  where 0 < x_k < 2^46 and 0 < a < 2^46.  This scheme generates 2^44 numbers
- *  before repeating.  The argument A is the same as 'a' in the above formula,
- *  and X is the same as x_0.  A and X must be odd double precision integers
- *  in the range (1, 2^46).  The returned value RANDLC is normalized to be
- *  between 0 and 1, i.e. RANDLC = 2^(-46) * x_1.  X is updated to contain
- *  the new seed x_1, so that subsequent calls to RANDLC using the same
- *  arguments will generate a continuous sequence.
- *
- *  This routine should produce the same results on any computer with at least
- *  48 mantissa bits in double precision floating point data.  On Cray systems,
- *  double precision should be disabled.
- *
- *  David H. Bailey     October 26, 1990
- *
- *     IMPLICIT DOUBLE PRECISION (A-H, O-Z)
- *     SAVE KS, R23, R46, T23, T46
- *     DATA KS/0/
- *
- *  If this is the first call to RANDLC, compute R23 = 2 ^ -23, R46 = 2 ^ -46,
- *  T23 = 2 ^ 23, and T46 = 2 ^ 46.  These are computed in loops, rather than
- *  by merely using the ** operator, in order to insure that the results are
- *  exact on all systems.  This code assumes that 0.5D0 is represented exactly.
- */
-
-
-/*****************************************************************/
-/*************           R  A  N  D  L  C             ************/
-/*************                                        ************/
-/*************    portable random number generator    ************/
-/*****************************************************************/
-
-double  randlc( double *X, double *A )
-{
-      static int        KS=0;
-      static double  R23, R46, T23, T46;
-      double    T1, T2, T3, T4;
-      double    A1;
-      double    A2;
-      double    X1;
-      double    X2;
-      double    Z;
-      int         i, j;
-
-      if (KS == 0) 
-      {
-        R23 = 1.0;
-        R46 = 1.0;
-        T23 = 1.0;
-        T46 = 1.0;
-    
-        for (i=1; i<=23; i++)
-        {
-          R23 = 0.50 * R23;
-          T23 = 2.0 * T23;
-        }
-        for (i=1; i<=46; i++)
-        {
-          R46 = 0.50 * R46;
-          T46 = 2.0 * T46;
-        }
-        KS = 1;
-      }
-
-/*  Break A into two parts such that A = 2^23 * A1 + A2 and set X = N.  */
-
-      T1 = R23 * *A;
-      j  = T1;
-      A1 = j;
-      A2 = *A - T23 * A1;
-
-/*  Break X into two parts such that X = 2^23 * X1 + X2, compute
-    Z = A1 * X2 + A2 * X1  (mod 2^23), and then
-    X = 2^23 * Z + A2 * X2  (mod 2^46).                            */
-
-      T1 = R23 * *X;
-      j  = T1;
-      X1 = j;
-      X2 = *X - T23 * X1;
-      T1 = A1 * X2 + A2 * X1;
-      
-      j  = R23 * T1;
-      T2 = j;
-      Z = T1 - T23 * T2;
-      T3 = T23 * Z + A2 * X2;
-      j  = R46 * T3;
-      T4 = j;
-      *X = T3 - T46 * T4;
-      return(R46 * *X);
-} 
-
-
-
-/*****************************************************************/
-/************   F  I  N  D  _  M  Y  _  S  E  E  D    ************/
-/************                                         ************/
-/************ returns parallel random number seq seed ************/
-/*****************************************************************/
-
diff --git a/examples/smpi/NAS/EP/randlc.h b/examples/smpi/NAS/EP/randlc.h
deleted file mode 100644 (file)
index aff84d3..0000000
+++ /dev/null
@@ -1,3 +0,0 @@
-
-double      randlc( double *X, double *A );
-
index 26d35e8..bfdc3ed 100644 (file)
@@ -1,23 +1,17 @@
-SHELL=/bin/sh
 BENCHMARK=is
 BENCHMARK=is
-BENCHMARKU=IS
 
 include ../config/make.def
 
 include ../config/make.def
-
 include ../sys/make.common
 
 OBJS = is.o ${COMMON}/c_print_results.o
 
 include ../sys/make.common
 
 OBJS = is.o ${COMMON}/c_print_results.o
 
-
-${PROGRAM}: config ${OBJS}
+${PROGRAM}: config ${OBJS} 
        ${CLINK} ${CLINKFLAGS} -o ${PROGRAM} ${OBJS} ${CMPI_LIB}
 
        ${CLINK} ${CLINKFLAGS} -o ${PROGRAM} ${OBJS} ${CMPI_LIB}
 
-.c.o:
+.c.o: 
        ${CCOMPILE} $<
 
        ${CCOMPILE} $<
 
-is.o:             is.c  npbparams.h
-
+is.o: is.c npbparams.h
 
 clean:
 
 clean:
-       - rm -f *.o *~ mputil*
-       - rm -f is npbparams.h core
+       - rm -f *.o *~ is npbparams.h
index 8e52972..a157254 100644 (file)
@@ -1,35 +1,24 @@
 SHELL=/bin/sh
 CLASS=S
 NPROCS=1
 SHELL=/bin/sh
 CLASS=S
 NPROCS=1
-SUBTYPE=
-VERSION=
-
-default: header
+default:
        @ sys/print_instructions
 
 IS: is
        @ sys/print_instructions
 
 IS: is
-is: header
+is: 
        cd IS; $(MAKE) NPROCS=$(NPROCS) CLASS=$(CLASS)
 
        cd IS; $(MAKE) NPROCS=$(NPROCS) CLASS=$(CLASS)
 
-
 EP: ep
 EP: ep
-ep: header
+ep:
        cd EP; $(MAKE) NPROCS=$(NPROCS) CLASS=$(CLASS)
 
 DT: dt
        cd EP; $(MAKE) NPROCS=$(NPROCS) CLASS=$(CLASS)
 
 DT: dt
-dt: header
+dt: 
        cd DT; $(MAKE) CLASS=$(CLASS)
 
        cd DT; $(MAKE) CLASS=$(CLASS)
 
-# It would be nice to make clean in each subdirectory (the targets
-# are defined) but on a really clean system this will won't work
-# because those makefiles need config/make.def
 clean:
        - rm -f *~  */*~ */*.o */npbparams.h 
        - rm -f sys/setparams sys/setparams.h
 
 veryclean: clean
 clean:
        - rm -f *~  */*~ */*.o */npbparams.h 
        - rm -f sys/setparams sys/setparams.h
 
 veryclean: clean
-       - rm -f config/make.def  
-       - rm -f bin/is.* bin/ep.* bin/dt.*
-
-header:
-       @ sys/print_header
+       - rm -f bin/*
\ No newline at end of file
diff --git a/examples/smpi/NAS/README b/examples/smpi/NAS/README
deleted file mode 100644 (file)
index dcaf02d..0000000
+++ /dev/null
@@ -1,13 +0,0 @@
-*** Warning ***
-This version of benchmarks IS, DT and EP contain special
-tweaks to work with SMPI.
-
-For problem reports and suggestions on the implementation, 
-please contact:
-
-   NAS Parallel Benchmark Team
-   npb@nas.nasa.gov
-
-   http://www.nas.nasa.gov/Software/NPB
-
-
index c38b765..e999d29 100644 (file)
@@ -5,14 +5,10 @@ NPB-MPI is a sample MPI implementation based on NPB2.4 and NPB3.0-SER.
 This subset contains three of the original benchmarks: one in Fortran: EP; 
 one in C: IS, as well as the DT benchmark, written in C, introduced in NPB3.2-MPI.
 
 This subset contains three of the original benchmarks: one in Fortran: EP; 
 one in C: IS, as well as the DT benchmark, written in C, introduced in NPB3.2-MPI.
 
-
 1. Compilation
 
    Before compilation, one needs to check the configuration file
    'make.def' in the config directory and modify the file if necessary.  
 1. Compilation
 
    Before compilation, one needs to check the configuration file
    'make.def' in the config directory and modify the file if necessary.  
-   If it does not (yet) exist, copy 'make.def.template' or one of the
-   sample files in the NAS.samples subdirectory to 'make.def' and
-   edit the content for site- and machine-specific data.  Then
 
        make <benchmark-name> NPROCS=<number> CLASS=<class> \
          [SUBTYPE=<type>] [VERSION=VEC]
 
        make <benchmark-name> NPROCS=<number> CLASS=<class> \
          [SUBTYPE=<type>] [VERSION=VEC]
@@ -21,13 +17,11 @@ one in C: IS, as well as the DT benchmark, written in C, introduced in NPB3.2-MP
          <number>          is the number of processes
          <class>           is "S", "W", "A", "B", "C", "D", or "E"
 
          <number>          is the number of processes
          <class>           is "S", "W", "A", "B", "C", "D", or "E"
 
-   Classes C, D and E are not available for DT.
-   Class E is not available for IS.
+   Class E is not available for IS and DT.
 
    Class D for IS (Integer Sort) requires a compiler/system that 
    supports the "long" type in C to be 64-bit.  
 
    Class D for IS (Integer Sort) requires a compiler/system that 
    supports the "long" type in C to be 64-bit.  
-   
-   
 2. Execution
 
    The executable is named <benchmark-name>.<class>.<nprocs>
 2. Execution
 
    The executable is named <benchmark-name>.<class>.<nprocs>
index 14a9d88..942c370 100644 (file)
@@ -1,34 +1,11 @@
-/*****************************************************************/
-/******     C  _  P  R  I  N  T  _  R  E  S  U  L  T  S     ******/
-/*****************************************************************/
 #include <stdlib.h>
 #include <stdio.h>
 
 #include <stdlib.h>
 #include <stdio.h>
 
-void c_print_results( char   *name,
-                      char   class,
-                      int    n1, 
-                      int    n2,
-                      int    n3,
-                      int    niter,
-                      int    nprocs_compiled,
-                      int    nprocs_total,
-                      double t,
-                      double mops,
-          char   *optype,
-                      int    passed_verification,
-                      char   *npbversion,
-                      char   *compiletime,
-                      char   *mpicc,
-                      char   *clink,
-                      char   *cmpi_lib,
-                      char   *cmpi_inc,
-                      char   *cflags,
-                      char   *clinkflags )
+void c_print_results(char *name, char class, int n1, int n2, int n3, int niter, int nprocs_compiled, int nprocs_total,
+                     double t, double mops, char *optype, int passed_verification, char *npbversion, char *compiletime,
+                     char *mpicc, char *clink, char *cmpi_lib, char *cmpi_inc, char *cflags, char *clinkflags)
 {
 {
-    char *evalue="1000";
-
     printf( "\n\n %s Benchmark Completed\n", name ); 
     printf( "\n\n %s Benchmark Completed\n", name ); 
-
     printf( " Class           =                        %c\n", class );
 
     if( n3 == 0 ) {
     printf( " Class           =                        %c\n", class );
 
     if( n3 == 0 ) {
@@ -40,18 +17,14 @@ void c_print_results( char   *name,
         printf( " Size            =              %3dx %3dx %3d\n", n1,n2,n3 );
 
     printf( " Iterations      =             %12d\n", niter );
         printf( " Size            =              %3dx %3dx %3d\n", n1,n2,n3 );
 
     printf( " Iterations      =             %12d\n", niter );
     printf( " Time in seconds =             %12.2f\n", t );
     printf( " Time in seconds =             %12.2f\n", t );
-
     printf( " Total processes =             %12d\n", nprocs_total );
 
     if ( nprocs_compiled != 0 )
         printf( " Compiled procs  =             %12d\n", nprocs_compiled );
 
     printf( " Mop/s total     =             %12.2f\n", mops );
     printf( " Total processes =             %12d\n", nprocs_total );
 
     if ( nprocs_compiled != 0 )
         printf( " Compiled procs  =             %12d\n", nprocs_compiled );
 
     printf( " Mop/s total     =             %12.2f\n", mops );
-
     printf( " Mop/s/process   =             %12.2f\n", mops/((float) nprocs_total) );
     printf( " Mop/s/process   =             %12.2f\n", mops/((float) nprocs_total) );
-
     printf( " Operation type  = %24s\n", optype);
 
     if( passed_verification )
     printf( " Operation type  = %24s\n", optype);
 
     if( passed_verification )
@@ -60,27 +33,14 @@ void c_print_results( char   *name,
         printf( " Verification    =             UNSUCCESSFUL\n" );
 
     printf( " Version         =             %12s\n", npbversion );
         printf( " Verification    =             UNSUCCESSFUL\n" );
 
     printf( " Version         =             %12s\n", npbversion );
-
     printf( " Compile date    =             %12s\n", compiletime );
     printf( " Compile date    =             %12s\n", compiletime );
-
     printf( "\n Compile options:\n" );
     printf( "\n Compile options:\n" );
-
     printf( "    MPICC        = %s\n", mpicc );
     printf( "    MPICC        = %s\n", mpicc );
-
     printf( "    CLINK        = %s\n", clink );
     printf( "    CLINK        = %s\n", clink );
-
     printf( "    CMPI_LIB     = %s\n", cmpi_lib );
     printf( "    CMPI_LIB     = %s\n", cmpi_lib );
-
     printf( "    CMPI_INC     = %s\n", cmpi_inc );
     printf( "    CMPI_INC     = %s\n", cmpi_inc );
-
     printf( "    CFLAGS       = %s\n", cflags );
     printf( "    CFLAGS       = %s\n", cflags );
-
     printf( "    CLINKFLAGS   = %s\n", clinkflags );
     printf( "    CLINKFLAGS   = %s\n", clinkflags );
-#ifdef SMP
-    evalue = getenv("MP_SET_NUMTHREADS");
-    printf( "   MULTICPUS = %s\n", evalue );
-#endif
-
     printf( "\n\n" );
     printf( " Please send the results of this run to:\n\n" );
     printf( " NPB Development Team\n" );
     printf( "\n\n" );
     printf( " Please send the results of this run to:\n\n" );
     printf( " NPB Development Team\n" );
@@ -91,4 +51,3 @@ void c_print_results( char   *name,
     printf( " Moffett Field, CA  94035-1000\n\n" );
     printf( " Fax: 650-604-3957\n\n" );
 }
     printf( " Moffett Field, CA  94035-1000\n\n" );
     printf( " Fax: 650-604-3957\n\n" );
 }
index c8c81e7..a3af153 100644 (file)
@@ -1,43 +1,25 @@
-
 #include "mpi.h"
 
 double start[64], elapsed[64];
 
 #include "mpi.h"
 
 double start[64], elapsed[64];
 
-/*****************************************************************/
-/******            T  I  M  E  R  _  C  L  E  A  R          ******/
-/*****************************************************************/
 void timer_clear( int n )
 {
     elapsed[n] = 0.0;
 }
 
 void timer_clear( int n )
 {
     elapsed[n] = 0.0;
 }
 
-
-/*****************************************************************/
-/******            T  I  M  E  R  _  S  T  A  R  T          ******/
-/*****************************************************************/
 void timer_start( int n )
 {
     start[n] = MPI_Wtime();
 }
 
 void timer_start( int n )
 {
     start[n] = MPI_Wtime();
 }
 
-
-/*****************************************************************/
-/******            T  I  M  E  R  _  S  T  O  P             ******/
-/*****************************************************************/
 void timer_stop( int n )
 {
     double t, now;
 void timer_stop( int n )
 {
     double t, now;
-
     now = MPI_Wtime();
     t = now - start[n];
     elapsed[n] += t;
     now = MPI_Wtime();
     t = now - start[n];
     elapsed[n] += t;
-
 }
 
 }
 
-
-/*****************************************************************/
-/******            T  I  M  E  R  _  R  E  A  D             ******/
-/*****************************************************************/
 double timer_read( int n )
 {
     return( elapsed[n] );
 double timer_read( int n )
 {
     return( elapsed[n] );
index 0390135..554d6b6 100644 (file)
@@ -1,64 +1,81 @@
-//---------------------------------------------------------------------
-//   This function is C verson of random number generator randdp.f 
-//---------------------------------------------------------------------
-
-double  randlc(X, A)
-double *X;
-double *A;
+/*
+ *    FUNCTION RANDLC (X, A)
+ *
+ *  This routine returns a uniform pseudorandom double precision number in the
+ *  range (0, 1) by using the linear congruential generator
+ *
+ *  x_{k+1} = a x_k  (mod 2^46)
+ *
+ *  where 0 < x_k < 2^46 and 0 < a < 2^46.  This scheme generates 2^44 numbers
+ *  before repeating.  The argument A is the same as 'a' in the above formula,
+ *  and X is the same as x_0.  A and X must be odd double precision integers
+ *  in the range (1, 2^46).  The returned value RANDLC is normalized to be
+ *  between 0 and 1, i.e. RANDLC = 2^(-46) * x_1.  X is updated to contain
+ *  the new seed x_1, so that subsequent calls to RANDLC using the same
+ *  arguments will generate a continuous sequence.
+ *
+ *  This routine should produce the same results on any computer with at least
+ *  48 mantissa bits in double precision floating point data.  On Cray systems,
+ *  double precision should be disabled.
+ *
+ *  David H. Bailey     October 26, 1990
+ *
+ *     IMPLICIT DOUBLE PRECISION (A-H, O-Z)
+ *     SAVE KS, R23, R46, T23, T46
+ *     DATA KS/0/
+ *
+ *  If this is the first call to RANDLC, compute R23 = 2 ^ -23, R46 = 2 ^ -46,
+ *  T23 = 2 ^ 23, and T46 = 2 ^ 46.  These are computed in loops, rather than
+ *  by merely using the ** operator, in order to insure that the results are
+ *  exact on all systems.  This code assumes that 0.5D0 is represented exactly.
+ */
+double  randlc(double *X, double*A)
 {
 {
-      static int        KS=0;
-      static double  R23, R46, T23, T46;
-      double    T1, T2, T3, T4;
-      double    A1;
-      double    A2;
-      double    X1;
-      double    X2;
-      double    Z;
-      int         i, j;
+  static int        KS=0;
+  static double  R23, R46, T23, T46;
+  double    T1, T2, T3, T4;
+  double    A1, A2;
+  double    X1, X2;
+  double    Z;
+  int       i, j;
 
 
-      if (KS == 0) 
-      {
-        R23 = 1.0;
-        R46 = 1.0;
-        T23 = 1.0;
-        T46 = 1.0;
-    
-        for (i=1; i<=23; i++)
-        {
-          R23 = 0.50 * R23;
-          T23 = 2.0 * T23;
-        }
-        for (i=1; i<=46; i++)
-        {
-          R46 = 0.50 * R46;
-          T46 = 2.0 * T46;
-        }
-        KS = 1;
-      }
+  if (KS == 0) {
+    R23 = 1.0;
+    R46 = 1.0;
+    T23 = 1.0;
+    T46 = 1.0;
 
 
-/*  Break A into two parts such that A = 2^23 * A1 + A2 and set X = N.  */
+    for (i=1; i<=23; i++) {
+      R23 = 0.50 * R23;
+      T23 = 2.0 * T23;
+    }
+    for (i=1; i<=46; i++) {
+      R46 = 0.50 * R46;
+      T46 = 2.0 * T46;
+    }
+    KS = 1;
+  }
 
 
-      T1 = R23 * *A;
-      j  = T1;
-      A1 = j;
-      A2 = *A - T23 * A1;
+/*  Break A into two parts such that A = 2^23 * A1 + A2 and set X = N.  */
+  T1 = R23 * *A;
+  j  = T1;
+  A1 = j;
+  A2 = *A - T23 * A1;
 
 /*  Break X into two parts such that X = 2^23 * X1 + X2, compute
 
 /*  Break X into two parts such that X = 2^23 * X1 + X2, compute
-    Z = A1 * X2 + A2 * X1  (mod 2^23), and then
-    X = 2^23 * Z + A2 * X2  (mod 2^46).                            */
+    Z = A1 * X2 + A2 * X1  (mod 2^23), and then X = 2^23 * Z + A2 * X2  (mod 2^46). */
+  T1 = R23 * *X;
+  j  = T1;
+  X1 = j;
+  X2 = *X - T23 * X1;
+  T1 = A1 * X2 + A2 * X1;
 
 
-      T1 = R23 * *X;
-      j  = T1;
-      X1 = j;
-      X2 = *X - T23 * X1;
-      T1 = A1 * X2 + A2 * X1;
-      
-      j  = R23 * T1;
-      T2 = j;
-      Z = T1 - T23 * T2;
-      T3 = T23 * Z + A2 * X2;
-      j  = R46 * T3;
-      T4 = j;
-      *X = T3 - T46 * T4;
-      return(R46 * *X);
-} 
+  j  = R23 * T1;
+  T2 = j;
+  Z = T1 - T23 * T2;
+  T3 = T23 * Z + A2 * X2;
+  j  = R46 * T3;
+  T4 = j;
+  *X = T3 - T46 * T4;
+  return(R46 * *X);
+}
diff --git a/examples/smpi/NAS/config/NAS.samples/suite.def.ep b/examples/smpi/NAS/config/NAS.samples/suite.def.ep
deleted file mode 100644 (file)
index e2ca3cd..0000000
+++ /dev/null
@@ -1,29 +0,0 @@
-ep     S       1
-ep     S       2
-ep     S       4
-ep     S       8
-ep     S       16
-ep     A       1
-ep     A       2
-ep     A       4
-ep     A       8
-ep     A       16
-ep     A       32
-ep     A       64
-ep     A       128
-ep     B       1
-ep     B       2
-ep     B       4
-ep     B       8
-ep     B       16
-ep     B       32
-ep     B       64
-ep     B       128
-ep     C       1
-ep     C       2
-ep     C       4
-ep     C       8
-ep     C       16
-ep     C       32
-ep     C       64
-ep     C       128
diff --git a/examples/smpi/NAS/config/NAS.samples/suite.def.is b/examples/smpi/NAS/config/NAS.samples/suite.def.is
deleted file mode 100644 (file)
index 97e898d..0000000
+++ /dev/null
@@ -1,29 +0,0 @@
-is     S       1
-is     S       2
-is     S       4
-is     S       8
-is     S       16
-is     A       1
-is     A       2
-is     A       4
-is     A       8
-is     A       16
-is     A       32
-is     A       64
-is     A       128
-is     B       1
-is     B       2
-is     B       4
-is     B       8
-is     B       16
-is     B       32
-is     B       64
-is     B       128
-is     C       1
-is     C       2
-is     C       4
-is     C       8
-is     C       16
-is     C       32
-is     C       64
-is     C       128
index f56b0f1..ad8f454 100644 (file)
@@ -8,58 +8,9 @@
 # Items in this file will need to be changed for each platform.
 #---------------------------------------------------------------------------
 
 # Items in this file will need to be changed for each platform.
 #---------------------------------------------------------------------------
 
-#---------------------------------------------------------------------------
-# Parallel Fortran:
-#
-# For CG, EP, FT, MG, LU, SP and BT, which are in Fortran, the following must 
-# be defined:
-#
-# MPIF77     - Fortran compiler
-# FFLAGS     - Fortran compilation arguments
-# FMPI_INC   - any -I arguments required for compiling MPI/Fortran 
-# FLINK      - Fortran linker
-# FLINKFLAGS - Fortran linker arguments
-# FMPI_LIB   - any -L and -l arguments required for linking MPI/Fortran 
-# 
-# compilations are done with $(MPIF77) $(FMPI_INC) $(FFLAGS) or
-#                            $(MPIF77) $(FFLAGS)
-# linking is done with       $(FLINK) $(FMPI_LIB) $(FLINKFLAGS)
-#---------------------------------------------------------------------------
-
-#---------------------------------------------------------------------------
-# This is the fortran compiler used for MPI programs
-#---------------------------------------------------------------------------
-MPIF77 = smpiff
-# This links MPI fortran programs; usually the same as ${MPIF77}
-FLINK  = $(MPIF77)
-
-#---------------------------------------------------------------------------
-# These macros are passed to the linker to help link with MPI correctly
-#---------------------------------------------------------------------------
-FMPI_LIB  =
-
-#---------------------------------------------------------------------------
-# These macros are passed to the compiler to help find 'mpif.h'
-#---------------------------------------------------------------------------
-FMPI_INC =
-
-#---------------------------------------------------------------------------
-# Global *compile time* flags for Fortran programs
-#---------------------------------------------------------------------------
-FFLAGS = -O2
-
-#---------------------------------------------------------------------------
-# Global *link time* flags. Flags for increasing maximum executable 
-# size usually go here. 
-#---------------------------------------------------------------------------
-FLINKFLAGS = -O2
-
-
 #---------------------------------------------------------------------------
 # Parallel C:
 #
 #---------------------------------------------------------------------------
 # Parallel C:
 #
-# For IS, which is in C, the following must be defined:
-#
 # MPICC      - C compiler 
 # CFLAGS     - C compilation arguments
 # CMPI_INC   - any -I arguments required for compiling MPI/C 
 # MPICC      - C compiler 
 # CFLAGS     - C compilation arguments
 # CMPI_INC   - any -I arguments required for compiling MPI/C 
@@ -77,7 +28,7 @@ FLINKFLAGS = -O2
 #---------------------------------------------------------------------------
 MPICC = smpicc
 # This links MPI C programs; usually the same as ${MPICC}
 #---------------------------------------------------------------------------
 MPICC = smpicc
 # This links MPI C programs; usually the same as ${MPICC}
-CLINK  = $(MPICC)
+CLINK = $(MPICC)
 
 #---------------------------------------------------------------------------
 # These macros are passed to the linker to help link with MPI correctly
 
 #---------------------------------------------------------------------------
 # These macros are passed to the linker to help link with MPI correctly
@@ -92,7 +43,7 @@ CMPI_INC =
 #---------------------------------------------------------------------------
 # Global *compile time* flags for C programs
 #---------------------------------------------------------------------------
 #---------------------------------------------------------------------------
 # Global *compile time* flags for C programs
 #---------------------------------------------------------------------------
-CFLAGS = -O2
+CFLAGS = -O2
 
 #---------------------------------------------------------------------------
 # Global *link time* flags. Flags for increasing maximum executable 
 
 #---------------------------------------------------------------------------
 # Global *link time* flags. Flags for increasing maximum executable 
@@ -100,18 +51,6 @@ CFLAGS      = -O2
 #---------------------------------------------------------------------------
 CLINKFLAGS = -O2
 
 #---------------------------------------------------------------------------
 CLINKFLAGS = -O2
 
-
-#---------------------------------------------------------------------------
-# MPI dummy library:
-#
-# Uncomment if you want to use the MPI dummy library supplied by NAS instead 
-# of the true message-passing library. The include file redefines several of
-# the above macros. It also invokes make in subdirectory MPI_dummy. Make 
-# sure that no spaces or tabs precede include.
-#---------------------------------------------------------------------------
-# include ../config/make.dummy
-
-
 #---------------------------------------------------------------------------
 # Utilities C:
 #
 #---------------------------------------------------------------------------
 # Utilities C:
 #
@@ -121,42 +60,14 @@ CLINKFLAGS = -O2
 #---------------------------------------------------------------------------
 CC     = gcc -g
 
 #---------------------------------------------------------------------------
 CC     = gcc -g
 
-
 #---------------------------------------------------------------------------
 # Destination of executables, relative to subdirs of the main directory. . 
 #---------------------------------------------------------------------------
 BINDIR = ../bin
 
 #---------------------------------------------------------------------------
 # Destination of executables, relative to subdirs of the main directory. . 
 #---------------------------------------------------------------------------
 BINDIR = ../bin
 
-
-#---------------------------------------------------------------------------
-# Some machines (e.g. Crays) have 128-bit DOUBLE PRECISION numbers, which
-# is twice the precision required for the NPB suite. A compiler flag 
-# (e.g. -dp) can usually be used to change DOUBLE PRECISION variables to
-# 64 bits, but the MPI library may continue to send 128 bits. Short of
-# recompiling MPI, the solution is to use MPI_REAL to send these 64-bit
-# numbers, and MPI_COMPLEX to send their complex counterparts. Uncomment
-# the following line to enable this substitution. 
-# 
-# NOTE: IF THE I/O BENCHMARK IS BEING BUILT, WE USE CONVERTFLAG TO
-#       SPECIFIY THE FORTRAN RECORD LENGTH UNIT. IT IS A SYSTEM-SPECIFIC
-#       VALUE (USUALLY 1 OR 4). UNCOMMENT THE SECOND LINE AND SUBSTITUTE
-#       THE CORRECT VALUE FOR "length".
-#       IF BOTH 128-BIT DOUBLE PRECISION NUMBERS AND I/O ARE TO BE ENABLED,
-#       UNCOMMENT THE THIRD LINE AND SUBSTITUTE THE CORRECT VALUE FOR
-#       "length"
-#---------------------------------------------------------------------------
-# CONVERTFLAG  = -DCONVERTDOUBLE
-# CONVERTFLAG  = -DFORTRAN_REC_SIZE=length
-# CONVERTFLAG  = -DCONVERTDOUBLE -DFORTRAN_REC_SIZE=length
-
-
 #---------------------------------------------------------------------------
 # The variable RAND controls which random number generator 
 # is used. It is described in detail in README.install. 
 # Use "randi8" unless there is a reason to use another one. 
 #---------------------------------------------------------------------------
 # The variable RAND controls which random number generator 
 # is used. It is described in detail in README.install. 
 # Use "randi8" unless there is a reason to use another one. 
-# Other allowed values are "randi8_safe", "randdp" and "randdpvec"
 #---------------------------------------------------------------------------
 RAND   = randi8
 #---------------------------------------------------------------------------
 RAND   = randi8
-# The following is highly reliable but may be slow:
-# RAND   = randdp
-
diff --git a/examples/smpi/NAS/config/make.def.template b/examples/smpi/NAS/config/make.def.template
deleted file mode 100644 (file)
index 8cccc29..0000000
+++ /dev/null
@@ -1,162 +0,0 @@
-#---------------------------------------------------------------------------
-#
-#                SITE- AND/OR PLATFORM-SPECIFIC DEFINITIONS. 
-#
-#---------------------------------------------------------------------------
-
-#---------------------------------------------------------------------------
-# Items in this file will need to be changed for each platform.
-#---------------------------------------------------------------------------
-
-#---------------------------------------------------------------------------
-# Parallel Fortran:
-#
-# For CG, EP, FT, MG, LU, SP and BT, which are in Fortran, the following must 
-# be defined:
-#
-# MPIF77     - Fortran compiler
-# FFLAGS     - Fortran compilation arguments
-# FMPI_INC   - any -I arguments required for compiling MPI/Fortran 
-# FLINK      - Fortran linker
-# FLINKFLAGS - Fortran linker arguments
-# FMPI_LIB   - any -L and -l arguments required for linking MPI/Fortran 
-# 
-# compilations are done with $(MPIF77) $(FMPI_INC) $(FFLAGS) or
-#                            $(MPIF77) $(FFLAGS)
-# linking is done with       $(FLINK) $(FMPI_LIB) $(FLINKFLAGS)
-#---------------------------------------------------------------------------
-
-#---------------------------------------------------------------------------
-# This is the fortran compiler used for MPI programs
-#---------------------------------------------------------------------------
-MPIF77 = f77
-# This links MPI fortran programs; usually the same as ${MPIF77}
-FLINK  = $(MPIF77)
-
-#---------------------------------------------------------------------------
-# These macros are passed to the linker to help link with MPI correctly
-#---------------------------------------------------------------------------
-FMPI_LIB  = -L/usr/local/lib -lmpi
-
-#---------------------------------------------------------------------------
-# These macros are passed to the compiler to help find 'mpif.h'
-#---------------------------------------------------------------------------
-FMPI_INC = -I/usr/local/include
-
-#---------------------------------------------------------------------------
-# Global *compile time* flags for Fortran programs
-#---------------------------------------------------------------------------
-FFLAGS = -O
-
-#---------------------------------------------------------------------------
-# Global *link time* flags. Flags for increasing maximum executable 
-# size usually go here. 
-#---------------------------------------------------------------------------
-FLINKFLAGS = -O
-
-
-#---------------------------------------------------------------------------
-# Parallel C:
-#
-# For IS, which is in C, the following must be defined:
-#
-# MPICC      - C compiler 
-# CFLAGS     - C compilation arguments
-# CMPI_INC   - any -I arguments required for compiling MPI/C 
-# CLINK      - C linker
-# CLINKFLAGS - C linker flags
-# CMPI_LIB   - any -L and -l arguments required for linking MPI/C 
-#
-# compilations are done with $(MPICC) $(CMPI_INC) $(CFLAGS) or
-#                            $(MPICC) $(CFLAGS)
-# linking is done with       $(CLINK) $(CMPI_LIB) $(CLINKFLAGS)
-#---------------------------------------------------------------------------
-
-#---------------------------------------------------------------------------
-# This is the C compiler used for MPI programs
-#---------------------------------------------------------------------------
-MPICC = cc
-# This links MPI C programs; usually the same as ${MPICC}
-CLINK  = $(MPICC)
-
-#---------------------------------------------------------------------------
-# These macros are passed to the linker to help link with MPI correctly
-#---------------------------------------------------------------------------
-CMPI_LIB  = -L/usr/local/lib -lmpi
-
-#---------------------------------------------------------------------------
-# These macros are passed to the compiler to help find 'mpi.h'
-#---------------------------------------------------------------------------
-CMPI_INC = -I/usr/local/include
-
-#---------------------------------------------------------------------------
-# Global *compile time* flags for C programs
-#---------------------------------------------------------------------------
-CFLAGS = -O
-
-#---------------------------------------------------------------------------
-# Global *link time* flags. Flags for increasing maximum executable 
-# size usually go here. 
-#---------------------------------------------------------------------------
-CLINKFLAGS = -O
-
-
-#---------------------------------------------------------------------------
-# MPI dummy library:
-#
-# Uncomment if you want to use the MPI dummy library supplied by NAS instead 
-# of the true message-passing library. The include file redefines several of
-# the above macros. It also invokes make in subdirectory MPI_dummy. Make 
-# sure that no spaces or tabs precede include.
-#---------------------------------------------------------------------------
-# include ../config/make.dummy
-
-
-#---------------------------------------------------------------------------
-# Utilities C:
-#
-# This is the C compiler used to compile C utilities.  Flags required by 
-# this compiler go here also; typically there are few flags required; hence 
-# there are no separate macros provided for such flags.
-#---------------------------------------------------------------------------
-CC     = cc -g
-
-
-#---------------------------------------------------------------------------
-# Destination of executables, relative to subdirs of the main directory. . 
-#---------------------------------------------------------------------------
-BINDIR = ../bin
-
-
-#---------------------------------------------------------------------------
-# Some machines (e.g. Crays) have 128-bit DOUBLE PRECISION numbers, which
-# is twice the precision required for the NPB suite. A compiler flag 
-# (e.g. -dp) can usually be used to change DOUBLE PRECISION variables to
-# 64 bits, but the MPI library may continue to send 128 bits. Short of
-# recompiling MPI, the solution is to use MPI_REAL to send these 64-bit
-# numbers, and MPI_COMPLEX to send their complex counterparts. Uncomment
-# the following line to enable this substitution. 
-# 
-# NOTE: IF THE I/O BENCHMARK IS BEING BUILT, WE USE CONVERTFLAG TO
-#       SPECIFIY THE FORTRAN RECORD LENGTH UNIT. IT IS A SYSTEM-SPECIFIC
-#       VALUE (USUALLY 1 OR 4). UNCOMMENT THE SECOND LINE AND SUBSTITUTE
-#       THE CORRECT VALUE FOR "length".
-#       IF BOTH 128-BIT DOUBLE PRECISION NUMBERS AND I/O ARE TO BE ENABLED,
-#       UNCOMMENT THE THIRD LINE AND SUBSTITUTE THE CORRECT VALUE FOR
-#       "length"
-#---------------------------------------------------------------------------
-# CONVERTFLAG  = -DCONVERTDOUBLE
-# CONVERTFLAG  = -DFORTRAN_REC_SIZE=length
-# CONVERTFLAG  = -DCONVERTDOUBLE -DFORTRAN_REC_SIZE=length
-
-
-#---------------------------------------------------------------------------
-# The variable RAND controls which random number generator 
-# is used. It is described in detail in README.install. 
-# Use "randi8" unless there is a reason to use another one. 
-# Other allowed values are "randi8_safe", "randdp" and "randdpvec"
-#---------------------------------------------------------------------------
-RAND   = randi8
-# The following is highly reliable but may be slow:
-# RAND   = randdp
-
index 56d1c44..35b4166 100644 (file)
@@ -1,22 +1,12 @@
 include ../config/make.def
 include ../config/make.def
-
-# Note that COMPILE is also defined in make.common and should
-# be the same. We can't include make.common because it has a lot
-# of other garbage. LINK is not defined in make.common because
-# ${MPI_LIB} needs to go at the end of the line. 
-FCOMPILE = $(MPIF77) -c $(FMPI_INC) $(FFLAGS)
-
 all: setparams 
 
 all: setparams 
 
-# setparams creates an npbparam.h file for each benchmark 
-# configuration. npbparams.h also contains info about how a benchmark
-# was compiled and linked
+# setparams creates an npbparam.h file for each benchmark configuration. 
+# npbparams.h also contains info about how a benchmark was compiled and linked
 
 setparams: setparams.c ../config/make.def
        $(CC) ${CONVERTFLAG} -o setparams setparams.c
 
 
 setparams: setparams.c ../config/make.def
        $(CC) ${CONVERTFLAG} -o setparams setparams.c
 
-
 clean: 
 clean: 
-       -rm -f setparams setparams.h npbparams.h
-       -rm -f *~ *.o
+       -rm -f setparams setparams.h npbparams.h *~ *.o
 
 
index 3c97c52..0a62dd1 100644 (file)
@@ -30,7 +30,6 @@ Makefile
 README
         This file. 
 
 README
         This file. 
 
-
 Created files
 -------------
 
 Created files
 -------------
 
index 4469596..2280367 100644 (file)
@@ -1,5 +1,4 @@
 PROGRAM  = $(BINDIR)/$(BENCHMARK).$(CLASS).$(NPROCS)
 PROGRAM  = $(BINDIR)/$(BENCHMARK).$(CLASS).$(NPROCS)
-FCOMPILE = $(MPIF77) -c $(FMPI_INC) $(FFLAGS)
 CCOMPILE = $(MPICC)  -c $(CMPI_INC) $(CFLAGS)
 
 # Class "U" is used internally by the setparams program to mean
 CCOMPILE = $(MPICC)  -c $(CMPI_INC) $(CFLAGS)
 
 # Class "U" is used internally by the setparams program to mean
@@ -22,20 +21,12 @@ config:
        ../sys/setparams ${BENCHMARK} ${NPROCS} ${CLASS} ${SUBTYPE}
 
 COMMON=../common
        ../sys/setparams ${BENCHMARK} ${NPROCS} ${CLASS} ${SUBTYPE}
 
 COMMON=../common
-${COMMON}/${RAND}.o: ${COMMON}/${RAND}.f
-       cd ${COMMON}; ${FCOMPILE} ${RAND}.f
-${COMMON}/c_randdp.o: ${COMMON}/randdp.c
+$${COMMON}/c_randdp.o: ${COMMON}/randdp.c
        cd ${COMMON}; ${CCOMPILE} -o c_randdp.o randdp.c
 
        cd ${COMMON}; ${CCOMPILE} -o c_randdp.o randdp.c
 
-${COMMON}/print_results.o: ${COMMON}/print_results.f
-       cd ${COMMON}; ${FCOMPILE} print_results.f
-
 ${COMMON}/c_print_results.o: ${COMMON}/c_print_results.c
        cd ${COMMON}; ${CCOMPILE} c_print_results.c
 
 ${COMMON}/c_print_results.o: ${COMMON}/c_print_results.c
        cd ${COMMON}; ${CCOMPILE} c_print_results.c
 
-${COMMON}/timers.o: ${COMMON}/timers.f
-       cd ${COMMON}; ${FCOMPILE} timers.f
-
 ${COMMON}/c_timers.o: ${COMMON}/c_timers.c
        cd ${COMMON}; ${CCOMPILE} c_timers.c
 
 ${COMMON}/c_timers.o: ${COMMON}/c_timers.c
        cd ${COMMON}; ${CCOMPILE} c_timers.c
 
diff --git a/examples/smpi/NAS/sys/print_header b/examples/smpi/NAS/sys/print_header
deleted file mode 100755 (executable)
index 4fdb578..0000000
+++ /dev/null
@@ -1,5 +0,0 @@
-echo '   ========================================='
-echo '   =      NAS Parallel Benchmarks 3.3      ='
-echo '   =      MPI/F77/C                        ='
-echo '   ========================================='
-echo ''
index d2f1999..6a09f2a 100755 (executable)
@@ -1,26 +1,10 @@
 echo ''
 echo '   To make a NAS benchmark type '
 echo ''
 echo ''
 echo '   To make a NAS benchmark type '
 echo ''
-echo '         make <benchmark-name> NPROCS=<number> CLASS=<class> [SUBTYPE=<type>]'
+echo '         make <benchmark-name> NPROCS=<number> CLASS=<class>'
 echo ''
 echo ''
-echo '   where <benchmark-name>  is "bt", "cg", "ep", "ft", "is", "lu",'
-echo '                              "mg", or "sp"'
+echo '   where <benchmark-name>  is "ep", "dt", or "is"
 echo '         <number>          is the number of processors'
 echo '         <class>           is "S", "W", "A", "B", "C", or "D"'
 echo ''
 echo '         <number>          is the number of processors'
 echo '         <class>           is "S", "W", "A", "B", "C", or "D"'
 echo ''
-echo '   Only when making the I/O benchmark:'
-echo ''
-echo '         <benchmark-name>  is "bt"'
-echo '         <number>, <class> as above'
-echo '         <type>            is "full", "simple", "fortran", or "epio"'
-echo ''
-echo '   To make a set of benchmarks, create the file config/suite.def'
-echo '   according to the instructions in config/suite.def.template and type'
-echo ''
-echo '         make suite'
-echo ''
-echo ' ***************************************************************'
-echo ' * Remember to edit the file config/make.def for site specific *'
-echo ' * information as described in the README file                 *'
-echo ' ***************************************************************'
 
 
index 70fca1c..a01dab5 100644 (file)
@@ -7,10 +7,10 @@
  * the number of nodes and class for which a benchmark is being built. 
 
  * The utility takes 3 arguments: 
  * the number of nodes and class for which a benchmark is being built. 
 
  * The utility takes 3 arguments: 
- *       setparams benchmark-name nprocs class
- *    benchmark-name is "sp", "bt", etc
- *    nprocs is the number of processors to run on
- *    class is the size of the benchmark
+ *    setparams benchmark-name nprocs class
+ *      benchmark-name is "ep", "dt", or "is"
+ *      nprocs is the number of processors to run on
+ *      class is the size of the benchmark
  * These parameters are checked for the current benchmark. If they
  * are invalid, this program prints a message and aborts. 
  * If the parameters are ok, the current npbsize.h (actually just
  * These parameters are checked for the current benchmark. If they
  * are invalid, this program prints a message and aborts. 
  * If the parameters are ok, the current npbsize.h (actually just
@@ -41,8 +41,7 @@
 #include <time.h>
 
 /*
 #include <time.h>
 
 /*
- * This is the master version number for this set of 
- * NPB benchmarks. It is in an obscure place so people
+ * This is the master version number for this set of NPB benchmarks. It is in an obscure place so people
  * won't accidentally change it. 
  */
 
  * won't accidentally change it. 
  */
 
 
 #define FILENAME "npbparams.h"
 #define DESC_LINE "c NPROCS = %d CLASS = %c\n"
 
 #define FILENAME "npbparams.h"
 #define DESC_LINE "c NPROCS = %d CLASS = %c\n"
-#define BT_DESC_LINE "c NPROCS = %d CLASS = %c SUBTYPE = %s\n"
 #define DEF_CLASS_LINE     "#define CLASS '%c'\n"
 #define DEF_NUM_PROCS_LINE "#define NUM_PROCS %d\n"
 #define FINDENT  "        "
 #define CONTINUE "     > "
 
 #define DEF_CLASS_LINE     "#define CLASS '%c'\n"
 #define DEF_NUM_PROCS_LINE "#define NUM_PROCS %d\n"
 #define FINDENT  "        "
 #define CONTINUE "     > "
 
-#ifdef FORTRAN_REC_SIZE
-int fortran_rec_size = FORTRAN_REC_SIZE;
-#else
-int fortran_rec_size = 4;
-#endif
-
-void get_info(int argc, char *argv[], int *typep, int *nprocsp, char *classp,
-        int* subtypep);
+void get_info(int argc, char *argv[], int *typep, int *nprocsp, char *classp, int* subtypep);
 void check_info(int type, int nprocs, char class);
 void read_info(int type, int *nprocsp, char *classp, int *subtypep);
 void write_info(int type, int nprocs, char class, int subtype);
 void check_info(int type, int nprocs, char class);
 void read_info(int type, int *nprocsp, char *classp, int *subtypep);
 void write_info(int type, int nprocs, char class, int subtype);
-void write_sp_info(FILE *fp, int nprocs, char class);
-void write_bt_info(FILE *fp, int nprocs, char class, int io);
-void write_lu_info(FILE *fp, int nprocs, char class);
-void write_mg_info(FILE *fp, int nprocs, char class);
-void write_cg_info(FILE *fp, int nprocs, char class);
-void write_ft_info(FILE *fp, int nprocs, char class);
-void write_ep_info(FILE *fp, int nprocs, char class);
 void write_ep_info_C(FILE *fp, int nprocs, char class);  /* after C translation */
 void write_is_info(FILE *fp, int nprocs, char class);
 void write_dt_info(FILE *fp, int nprocs, char class);
 void write_compiler_info(int type, FILE *fp);
 void write_ep_info_C(FILE *fp, int nprocs, char class);  /* after C translation */
 void write_is_info(FILE *fp, int nprocs, char class);
 void write_dt_info(FILE *fp, int nprocs, char class);
 void write_compiler_info(int type, FILE *fp);
-void write_convertdouble_info(int type, FILE *fp);
 void check_line(char *line, char *label, char *val);
 int  check_include_line(char *line, char *filename);
 void put_string(FILE *fp, char *name, char *val);
 void check_line(char *line, char *label, char *val);
 int  check_include_line(char *line, char *filename);
 void put_string(FILE *fp, char *name, char *val);
@@ -91,15 +74,14 @@ int isqrt(int i);
 int ilog2(int i);
 int ipow2(int i);
 
 int ilog2(int i);
 int ipow2(int i);
 
-enum benchmark_types {SP, BT, LU, MG, FT, IS, DT, EP, CG};
-enum iotypes { NONE = 0, FULL, SIMPLE, EPIO, FORTRAN};
+enum benchmark_types {IS, DT, EP};
 
 int main(int argc, char *argv[])
 {
   int nprocs, nprocs_old, type;
   char class, class_old;
   int subtype = -1, old_subtype = -1;
 
 int main(int argc, char *argv[])
 {
   int nprocs, nprocs_old, type;
   char class, class_old;
   int subtype = -1, old_subtype = -1;
-  
+
   /* Get command line arguments. Make sure they're ok. */
   get_info(argc, argv, &type, &nprocs, &class, &subtype);
   if (class != 'U') {
   /* Get command line arguments. Make sure they're ok. */
   get_info(argc, argv, &type, &nprocs, &class, &subtype);
   if (class != 'U') {
@@ -151,55 +133,21 @@ int main(int argc, char *argv[])
   return 0;
 }
 
   return 0;
 }
 
-
-/*
- *  get_info(): Get parameters from command line 
- */
-
-void get_info(int argc, char *argv[], int *typep, int *nprocsp, char *classp,
-        int *subtypep) 
+/*  get_info(): Get parameters from command line */
+void get_info(int argc, char *argv[], int *typep, int *nprocsp, char *classp, int *subtypep)
 {
 {
-
   if (argc < 4) {
     printf("Usage: %s (%d) benchmark-name nprocs class\n", argv[0], argc);
     exit(1);
   }
 
   *nprocsp = atoi(argv[2]);
   if (argc < 4) {
     printf("Usage: %s (%d) benchmark-name nprocs class\n", argv[0], argc);
     exit(1);
   }
 
   *nprocsp = atoi(argv[2]);
-
   *classp = *argv[3];
 
   *classp = *argv[3];
 
-  if      (!strcmp(argv[1], "sp") || !strcmp(argv[1], "SP")) *typep = SP;
-  else if (!strcmp(argv[1], "ft") || !strcmp(argv[1], "FT")) *typep = FT;
-  else if (!strcmp(argv[1], "lu") || !strcmp(argv[1], "LU")) *typep = LU;
-  else if (!strcmp(argv[1], "mg") || !strcmp(argv[1], "MG")) *typep = MG;
-  else if (!strcmp(argv[1], "is") || !strcmp(argv[1], "IS")) *typep = IS;
+  if      (!strcmp(argv[1], "is") || !strcmp(argv[1], "IS")) *typep = IS;
   else if (!strcmp(argv[1], "dt") || !strcmp(argv[1], "DT")) *typep = DT;
   else if (!strcmp(argv[1], "ep") || !strcmp(argv[1], "EP")) *typep = EP;
   else if (!strcmp(argv[1], "dt") || !strcmp(argv[1], "DT")) *typep = DT;
   else if (!strcmp(argv[1], "ep") || !strcmp(argv[1], "EP")) *typep = EP;
-  else if (!strcmp(argv[1], "cg") || !strcmp(argv[1], "CG")) *typep = CG;
-  else if (!strcmp(argv[1], "bt") || !strcmp(argv[1], "BT")) {
-    *typep = BT;
-    if (argc != 5) {
-      /* printf("Usage: %s (%d) benchmark-name nprocs class\n", argv[0], argc); */
-      /* exit(1); */
-      *subtypep = NONE;
-    } else {
-      if (!strcmp(argv[4], "full") || !strcmp(argv[4], "FULL")) {
-        *subtypep = FULL;
-      } else if (!strcmp(argv[4], "simple") || !strcmp(argv[4], "SIMPLE")) {
-        *subtypep = SIMPLE;
-      } else if (!strcmp(argv[4], "epio") || !strcmp(argv[4], "EPIO")) {
-        *subtypep = EPIO;
-      } else if (!strcmp(argv[4], "fortran") || !strcmp(argv[4], "FORTRAN")) {
-        *subtypep = FORTRAN;
-      } else if (!strcmp(argv[4], "none") || !strcmp(argv[4], "NONE")) {
-        *subtypep = NONE;
-      } else {
-        printf("setparams: Error: unknown btio type %s\n", argv[4]);
-        exit(1);
-      }
-    }
-  } else {
+  else {
     printf("setparams: Error: unknown benchmark type %s\n", argv[1]);
     exit(1);
   }
     printf("setparams: Error: unknown benchmark type %s\n", argv[1]);
     exit(1);
   }
@@ -219,33 +167,12 @@ void check_info(int type, int nprocs, char class)
     exit(1);
   }
   switch(type) {
     exit(1);
   }
   switch(type) {
-
-  case SP:
-  case BT:
-    rootprocs = isqrt(nprocs);
-    if (rootprocs < 0) {
-      printf("setparams: Number of processors %d must be a square (1,4,9,...) for this benchmark", 
-              nprocs);
-      exit(1);
-    }
-    if (class == 'S' && nprocs > 16) {
-      printf("setparams: BT and SP sample sizes cannot be run on more\n");
-      printf("           than 16 processors because the cell size would be too small.\n");
-      exit(1);
-    }
-    break;
-
-  case CG:
-  case FT:
-  case MG:
   case IS:
   case IS:
-  case LU:
     logprocs = ilog2(nprocs);
     if (logprocs < 0) {
       printf("setparams: Number of processors must be a power of two (1,2,4,...) for this benchmark\n");
       exit(1);
     }
     logprocs = ilog2(nprocs);
     if (logprocs < 0) {
       printf("setparams: Number of processors must be a power of two (1,2,4,...) for this benchmark\n");
       exit(1);
     }
-
     break;
 
   case EP:
     break;
 
   case EP:
@@ -282,13 +209,10 @@ void check_info(int type, int nprocs, char class)
   }
 }
 
   }
 }
 
-
 /* 
  * read_info(): Read previous information from file. 
 /* 
  * read_info(): Read previous information from file. 
- *              Not an error if file doesn't exist, because this
- *              may be the first time we're running. 
- *              Assumes the first line of the file is in a special
- *              format that we understand (since we wrote it). 
+ *              Not an error if file doesn't exist, because this may be the first time we're running.
+ *              Assumes the first two lines of the file is in a special format that we understand (since we wrote it).
  */
 
 void read_info(int type, int *nprocsp, char *classp, int *subtypep)
  */
 
 void read_info(int type, int *nprocsp, char *classp, int *subtypep)
@@ -302,68 +226,16 @@ void read_info(int type, int *nprocsp, char *classp, int *subtypep)
 #endif
     goto abort;
   }
 #endif
     goto abort;
   }
-  
-  /* first line of file contains info (fortran), first two lines (C) */
-
-  switch(type) {
-      case BT: {
-    char subtype_str[100];
-          nread = fscanf(fp, BT_DESC_LINE, nprocsp, classp, subtype_str);
-          if (nread != 3) {
-            if (nread != 2) {
-              printf("setparams: Error parsing config file %s. Ignoring previous settings\n", FILENAME);
-              goto abort;
-      }
-      *subtypep = 0;
-      break;
-          }
-          if (!strcmp(subtype_str, "full") || !strcmp(subtype_str, "FULL")) {
-    *subtypep = FULL;
-          } else if (!strcmp(subtype_str, "simple") ||
-         !strcmp(subtype_str, "SIMPLE")) {
-    *subtypep = SIMPLE;
-          } else if (!strcmp(subtype_str, "epio") || !strcmp(subtype_str, "EPIO")) {
-    *subtypep = EPIO;
-          } else if (!strcmp(subtype_str, "fortran") ||
-         !strcmp(subtype_str, "FORTRAN")) {
-    *subtypep = FORTRAN;
-          } else {
-    *subtypep = -1;
-    }
-          break;
-      }
 
 
-      case SP:
-      case FT:
-      case MG:
-      case LU:
-      //case EP:
-      case CG:
-          nread = fscanf(fp, DESC_LINE, nprocsp, classp);
-          if (nread != 2) {
-            printf("setparams: Error line %d parsing config file %s. Ignoring previous settings\n", __LINE__,FILENAME);
-            goto abort;
-          }
-          break;
-      case IS:
-      case EP:
-      case DT:
-          nread = fscanf(fp, DEF_CLASS_LINE, classp);
-          nread += fscanf(fp, DEF_NUM_PROCS_LINE, nprocsp);
-          if (nread != 2) {
-            printf("setparams: Error line %d parsing config file %s. Ignoring previous settings\n", __LINE__,FILENAME);
-            goto abort;
-          }
-          break;
-      default:
-        /* never should have gotten this far with a bad name */
-        printf("setparams: (Internal Error) Benchmark type %d unknown to this program\n", type); 
-        exit(1);
+  /* first two lines of file contains info */
+  nread = fscanf(fp, DEF_CLASS_LINE, classp);
+  nread += fscanf(fp, DEF_NUM_PROCS_LINE, nprocsp);
+  if (nread != 2) {
+    printf("setparams: Error line %d parsing config file %s. Ignoring previous settings\n", __LINE__,FILENAME);
+    goto abort;
   }
 
   fclose(fp);
   }
 
   fclose(fp);
-
-
   return;
 
  abort:
   return;
 
  abort:
@@ -373,7 +245,6 @@ void read_info(int type, int *nprocsp, char *classp, int *subtypep)
   return;
 }
 
   return;
 }
 
-
 /* 
  * write_info(): Write new information to config file. 
  *               First line is in a special format so we can read
 /* 
  * write_info(): Write new information to config file. 
  *               First line is in a special format so we can read
@@ -392,286 +263,36 @@ void write_info(int type, int nprocs, char class, int subtype)
     exit(1);
   }
 
     exit(1);
   }
 
-  switch(type) {
-      case BT:
-          /* Write out the header */
-    if (subtype == -1 || subtype == 0) {
-            fprintf(fp, DESC_LINE, nprocs, class);
-    } else {
-            fprintf(fp, BT_DESC_LINE, nprocs, class, BT_TYPES[subtype]);
-    }
-          /* Print out a warning so bozos don't mess with the file */
-          fprintf(fp, "\
-c  \n\
-c  \n\
-c  This file is generated automatically by the setparams utility.\n\
-c  It sets the number of processors and the class of the NPB\n\
-c  in this directory. Do not modify it by hand.\n\
-c  \n");
-
-          break;
-  
-      case SP:
-      case FT:
-      case MG:
-      case LU:
-      //case EP:
-      case CG:
-          /* Write out the header */
-          fprintf(fp, DESC_LINE, nprocs, class);
-          /* Print out a warning so bozos don't mess with the file */
-          fprintf(fp, "\
-c  \n\
-c  \n\
-c  This file is generated automatically by the setparams utility.\n\
-c  It sets the number of processors and the class of the NPB\n\
-c  in this directory. Do not modify it by hand.\n\
-c  \n");
-
-          break;
-  case EP:
-      case IS:
-      case DT:
-          fprintf(fp, DEF_CLASS_LINE, class);
-          fprintf(fp, DEF_NUM_PROCS_LINE, nprocs);
-          fprintf(fp, "\
+  fprintf(fp, DEF_CLASS_LINE, class);
+  fprintf(fp, DEF_NUM_PROCS_LINE, nprocs);
+  fprintf(fp, "\
 /*\n\
    This file is generated automatically by the setparams utility.\n\
    It sets the number of processors and the class of the NPB\n\
    in this directory. Do not modify it by hand.   */\n\
    \n");
 /*\n\
    This file is generated automatically by the setparams utility.\n\
    It sets the number of processors and the class of the NPB\n\
    in this directory. Do not modify it by hand.   */\n\
    \n");
-          break;
-      default:
-          printf("setparams: (Internal error): Unknown benchmark type %d\n", 
-                                                                         type);
-          exit(1);
-  }
 
   /* Now do benchmark-specific stuff */
   switch(type) {
 
   /* Now do benchmark-specific stuff */
   switch(type) {
-  case SP:
-    write_sp_info(fp, nprocs, class);
-    break;
-  case LU:
-    write_lu_info(fp, nprocs, class);
-    break;
-  case MG:
-    write_mg_info(fp, nprocs, class);
-    break;
   case IS:
     write_is_info(fp, nprocs, class);  
     break;
   case DT:
     write_dt_info(fp, nprocs, class);  
     break;
   case IS:
     write_is_info(fp, nprocs, class);  
     break;
   case DT:
     write_dt_info(fp, nprocs, class);  
     break;
-  case FT:
-    write_ft_info(fp, nprocs, class);
-    break;
   case EP:
   case EP:
-    //write_ep_info(fp, nprocs, class);
     write_ep_info_C(fp, nprocs, class);
     break;
     write_ep_info_C(fp, nprocs, class);
     break;
-  case CG:
-    write_cg_info(fp, nprocs, class);
-    break;
-  case BT:
-    write_bt_info(fp, nprocs, class, subtype);
-    break;
   default:
     printf("setparams: (Internal error): Unknown benchmark type %d\n", type);
     exit(1);
   }
   default:
     printf("setparams: (Internal error): Unknown benchmark type %d\n", type);
     exit(1);
   }
-  write_convertdouble_info(type, fp);
   write_compiler_info(type, fp);
   fclose(fp);
   return;
 }
 
   write_compiler_info(type, fp);
   fclose(fp);
   return;
 }
 
-
-/* 
- * write_sp_info(): Write SP specific info to config file
- */
-
-void write_sp_info(FILE *fp, int nprocs, char class) 
-{
-  int maxcells, problem_size, niter;
-  char *dt;
-  maxcells = isqrt(nprocs);
-  if      (class == 'S') { problem_size = 12;  dt = "0.015d0";   niter = 100; }
-  else if (class == 'W') { problem_size = 36;  dt = "0.0015d0";  niter = 400; }
-  else if (class == 'A') { problem_size = 64;  dt = "0.0015d0";  niter = 400; }
-  else if (class == 'B') { problem_size = 102; dt = "0.001d0";   niter = 400; }
-  else if (class == 'C') { problem_size = 162; dt = "0.00067d0"; niter = 400; }
-  else if (class == 'D') { problem_size = 408; dt = "0.00030d0"; niter = 500; }
-  else if (class == 'E') { problem_size = 1020; dt = "0.0001d0"; niter = 500; }
-  else {
-    printf("setparams: Internal error: invalid class %c\n", class);
-    exit(1);
-  }
-  fprintf(fp, "%sinteger maxcells, problem_size, niter_default\n", FINDENT);
-  fprintf(fp, "%sparameter (maxcells=%d, problem_size=%d, niter_default=%d)\n", 
-         FINDENT, maxcells, problem_size, niter);
-  fprintf(fp, "%sdouble precision dt_default\n", FINDENT);
-  fprintf(fp, "%sparameter (dt_default = %s)\n", FINDENT, dt);
-}
-  
-/* 
- * write_bt_info(): Write BT specific info to config file
- */
-
-void write_bt_info(FILE *fp, int nprocs, char class, int io) 
-{
-  int maxcells, problem_size, niter, wr_interval;
-  char *dt;
-  maxcells = isqrt(nprocs);
-  if      (class == 'S') { problem_size = 12;  dt = "0.010d0";    niter = 60;  }
-  else if (class == 'W') { problem_size = 24;  dt = "0.0008d0";   niter = 200; }
-  else if (class == 'A') { problem_size = 64;  dt = "0.0008d0";   niter = 200; }
-  else if (class == 'B') { problem_size = 102; dt = "0.0003d0";   niter = 200; }
-  else if (class == 'C') { problem_size = 162; dt = "0.0001d0";   niter = 200; }
-  else if (class == 'D') { problem_size = 408; dt = "0.00002d0";  niter = 250; }
-  else if (class == 'E') { problem_size = 1020; dt = "0.4d-5";    niter = 250; }
-  else {
-    printf("setparams: Internal error: invalid class %c\n", class);
-    exit(1);
-  }
-  wr_interval = 5;
-  fprintf(fp, "%sinteger maxcells, problem_size, niter_default\n", FINDENT);
-  fprintf(fp, "%sparameter (maxcells=%d, problem_size=%d, niter_default=%d)\n", 
-         FINDENT, maxcells, problem_size, niter);
-  fprintf(fp, "%sdouble precision dt_default\n", FINDENT);
-  fprintf(fp, "%sparameter (dt_default = %s)\n", FINDENT, dt);
-  fprintf(fp, "%sinteger wr_default\n", FINDENT);
-  fprintf(fp, "%sparameter (wr_default = %d)\n", FINDENT, wr_interval);
-  fprintf(fp, "%sinteger iotype\n", FINDENT);
-  fprintf(fp, "%sparameter (iotype = %d)\n", FINDENT, io);
-  if (io) {
-    fprintf(fp, "%scharacter*(*) filenm\n", FINDENT);
-    switch (io) {
-  case FULL:
-      fprintf(fp, "%sparameter (filenm = 'btio.full.out')\n", FINDENT);
-      break;
-  case SIMPLE:
-      fprintf(fp, "%sparameter (filenm = 'btio.simple.out')\n", FINDENT);
-      break;
-  case EPIO:
-      fprintf(fp, "%sparameter (filenm = 'btio.epio.out')\n", FINDENT);
-      break;
-  case FORTRAN:
-      fprintf(fp, "%sparameter (filenm = 'btio.fortran.out')\n", FINDENT);
-      fprintf(fp, "%sinteger fortran_rec_sz\n", FINDENT);
-      fprintf(fp, "%sparameter (fortran_rec_sz = %d)\n",
-        FINDENT, fortran_rec_size);
-      break;
-  default:
-      break;
-    }
-  }
-}
-  
-
-
-/* 
- * write_lu_info(): Write SP specific info to config file
- */
-
-void write_lu_info(FILE *fp, int nprocs, char class) 
-{
-  int isiz1, isiz2, itmax, inorm, problem_size;
-  int xdiv, ydiv; /* number of cells in x and y direction */
-  char *dt_default;
-
-  if      (class == 'S') { problem_size = 12;  dt_default = "0.5d0";  itmax = 50; }
-  else if (class == 'W') { problem_size = 33;  dt_default = "1.5d-3"; itmax = 300; }
-  else if (class == 'A') { problem_size = 64;  dt_default = "2.0d0";  itmax = 250; }
-  else if (class == 'B') { problem_size = 102; dt_default = "2.0d0";  itmax = 250; }
-  else if (class == 'C') { problem_size = 162; dt_default = "2.0d0";  itmax = 250; }
-  else if (class == 'D') { problem_size = 408; dt_default = "1.0d0";  itmax = 300; }
-  else if (class == 'E') { problem_size = 1020; dt_default = "0.5d0"; itmax = 300; }
-  else {
-    printf("setparams: Internal error: invalid class %c\n", class);
-    exit(1);
-  }
-  inorm = itmax;
-  xdiv = ydiv = ilog2(nprocs)/2;
-  if (xdiv+ydiv != ilog2(nprocs)) xdiv += 1;
-  xdiv = ipow2(xdiv); ydiv = ipow2(ydiv);
-  isiz1 = problem_size/xdiv; if (isiz1*xdiv < problem_size) isiz1++;
-  isiz2 = problem_size/ydiv; if (isiz2*ydiv < problem_size) isiz2++;
-  
-
-  fprintf(fp, "\nc number of nodes for which this version is compiled\n");
-  fprintf(fp, "%sinteger nnodes_compiled\n", FINDENT);
-  fprintf(fp, "%sparameter (nnodes_compiled = %d)\n", FINDENT, nprocs);
-
-  fprintf(fp, "\nc full problem size\n");
-  fprintf(fp, "%sinteger isiz01, isiz02, isiz03\n", FINDENT);
-  fprintf(fp, "%sparameter (isiz01=%d, isiz02=%d, isiz03=%d)\n", 
-    FINDENT, problem_size, problem_size, problem_size);
-
-  fprintf(fp, "\nc sub-domain array size\n");
-  fprintf(fp, "%sinteger isiz1, isiz2, isiz3\n", FINDENT);
-  fprintf(fp, "%sparameter (isiz1=%d, isiz2=%d, isiz3=isiz03)\n", 
-         FINDENT, isiz1, isiz2);
-
-  fprintf(fp, "\nc number of iterations and how often to print the norm\n");
-  fprintf(fp, "%sinteger itmax_default, inorm_default\n", FINDENT);
-  fprintf(fp, "%sparameter (itmax_default=%d, inorm_default=%d)\n", 
-    FINDENT, itmax, inorm);
-
-  fprintf(fp, "%sdouble precision dt_default\n", FINDENT);
-  fprintf(fp, "%sparameter (dt_default = %s)\n", FINDENT, dt_default);
-  
-}
-
-/* 
- * write_mg_info(): Write MG specific info to config file
- */
-
-void write_mg_info(FILE *fp, int nprocs, char class) 
-{
-  int problem_size, nit, log2_size, log2_nprocs, lt_default, lm;
-  int ndim1, ndim2, ndim3;
-  if      (class == 'S') { problem_size = 32;   nit = 4; }
-  else if (class == 'W') { problem_size = 128;  nit = 4; }
-  else if (class == 'A') { problem_size = 256;  nit = 4; }
-  else if (class == 'B') { problem_size = 256;  nit = 20; }
-  else if (class == 'C') { problem_size = 512;  nit = 20; }
-  else if (class == 'D') { problem_size = 1024; nit = 50; }
-  else if (class == 'E') { problem_size = 2048; nit = 50; }
-  else {
-    printf("setparams: Internal error: invalid class type %c\n", class);
-    exit(1);
-  }
-  log2_size = ilog2(problem_size);
-  log2_nprocs = ilog2(nprocs);
-  /* lt is log of largest total dimension */
-  lt_default = log2_size;
-  /* log of log of maximum dimension on a node */
-  lm = log2_size - log2_nprocs/3;
-  ndim1 = lm;
-  ndim3 = log2_size - (log2_nprocs+2)/3;
-  ndim2 = log2_size - (log2_nprocs+1)/3;
-
-  fprintf(fp, "%sinteger nprocs_compiled\n", FINDENT);
-  fprintf(fp, "%sparameter (nprocs_compiled = %d)\n", FINDENT, nprocs);
-  fprintf(fp, "%sinteger nx_default, ny_default, nz_default\n", FINDENT);
-  fprintf(fp, "%sparameter (nx_default=%d, ny_default=%d, nz_default=%d)\n", 
-    FINDENT, problem_size, problem_size, problem_size);
-  fprintf(fp, "%sinteger nit_default, lm, lt_default\n", FINDENT);
-  fprintf(fp, "%sparameter (nit_default=%d, lm = %d, lt_default=%d)\n", 
-    FINDENT, nit, lm, lt_default);
-  fprintf(fp, "%sinteger debug_default\n", FINDENT);
-  fprintf(fp, "%sparameter (debug_default=%d)\n", FINDENT, 0);
-  fprintf(fp, "%sinteger ndim1, ndim2, ndim3\n", FINDENT);
-  fprintf(fp, "%sparameter (ndim1 = %d, ndim2 = %d, ndim3 = %d)\n", 
-    FINDENT, ndim1, ndim2, ndim3);
-}
-
-
-/* 
- * write_dt_info(): Write DT specific info to config file
- */
+/* write_dt_info(): Write DT specific info to config file */
 
 void write_dt_info(FILE *fp, int nprocs, char class) 
 {
 
 void write_dt_info(FILE *fp, int nprocs, char class) 
 {
@@ -691,162 +312,20 @@ void write_dt_info(FILE *fp, int nprocs, char class)
   fprintf(fp, "#define NUM_SOURCES %d\n", num_sources);
 }
 
   fprintf(fp, "#define NUM_SOURCES %d\n", num_sources);
 }
 
-/* 
- * write_is_info(): Write IS specific info to config file
- */
-
-void write_is_info(FILE *fp, int nprocs, char class) 
-{
-  if( class != 'S' &&
-      class != 'W' &&
-      class != 'A' &&
-      class != 'B' &&
-      class != 'C' &&
-      class != 'D' )
-  {
-    printf("setparams: Internal error: invalid class type %c\n", class);
-    exit(1);
-  }
-}
-
-/* 
- * write_cg_info(): Write CG specific info to config file
- */
-
-void write_cg_info(FILE *fp, int nprocs, char class) 
+/* write_is_info(): Write IS specific info to config file */
+void write_is_info(FILE *fp, int nprocs, char class)
 {
 {
-  int na,nonzer,niter;
-  char *shift,*rcond="1.0d-1";
-  char *shiftS="10.",
-       *shiftW="12.",
-       *shiftA="20.",
-       *shiftB="60.",
-       *shiftC="110.",
-       *shiftD="500.",
-       *shiftE="1.5d3";
-
-  int num_proc_cols, num_proc_rows;
-
-
-  if( class == 'S' )
-  { na=1400;    nonzer=7;  niter=15;  shift=shiftS; }
-  else if( class == 'W' )
-  { na=7000;    nonzer=8;  niter=15;  shift=shiftW; }
-  else if( class == 'A' )
-  { na=14000;   nonzer=11; niter=15;  shift=shiftA; }
-  else if( class == 'B' )
-  { na=75000;   nonzer=13; niter=75;  shift=shiftB; }
-  else if( class == 'C' )
-  { na=150000;  nonzer=15; niter=75;  shift=shiftC; }
-  else if( class == 'D' )
-  { na=1500000; nonzer=21; niter=100; shift=shiftD; }
-  else if( class == 'E' )
-  { na=9000000; nonzer=26; niter=100; shift=shiftE; }
-  else
+  if( class != 'S' && class != 'W' && class != 'A' && class != 'B' && class != 'C' && class != 'D' )
   {
     printf("setparams: Internal error: invalid class type %c\n", class);
     exit(1);
   }
   {
     printf("setparams: Internal error: invalid class type %c\n", class);
     exit(1);
   }
-  fprintf( fp, "%sinteger            na, nonzer, niter\n", FINDENT );
-  fprintf( fp, "%sdouble precision   shift, rcond\n", FINDENT );
-  fprintf( fp, "%sparameter(  na=%d,\n", FINDENT, na );
-  fprintf( fp, "%s             nonzer=%d,\n", CONTINUE, nonzer );
-  fprintf( fp, "%s             niter=%d,\n", CONTINUE, niter );
-  fprintf( fp, "%s             shift=%s,\n", CONTINUE, shift );
-  fprintf( fp, "%s             rcond=%s )\n", CONTINUE, rcond );
-
-
-  num_proc_cols = num_proc_rows = ilog2(nprocs)/2;
-  if (num_proc_cols+num_proc_rows != ilog2(nprocs)) num_proc_cols += 1;
-  num_proc_cols = ipow2(num_proc_cols); num_proc_rows = ipow2(num_proc_rows);
-  
-  fprintf( fp, "\nc number of nodes for which this version is compiled\n" );
-  fprintf( fp, "%sinteger    nnodes_compiled\n", FINDENT );
-  fprintf( fp, "%sparameter( nnodes_compiled = %d)\n", FINDENT, nprocs );
-  fprintf( fp, "%sinteger    num_proc_cols, num_proc_rows\n", FINDENT );
-  fprintf( fp, "%sparameter( num_proc_cols=%d, num_proc_rows=%d )\n", 
-                                                          FINDENT,
-                                                          num_proc_cols,
-                                                          num_proc_rows );
-}
-
-
-/* 
- * write_ft_info(): Write FT specific info to config file
- */
-
-void write_ft_info(FILE *fp, int nprocs, char class) 
-{
-  /* easiest way (given the way the benchmark is written)
-   * is to specify log of number of grid points in each
-   * direction m1, m2, m3. nt is the number of iterations
-   */
-  int nx, ny, nz, maxdim, niter;
-  if      (class == 'S') { nx = 64;   ny = 64;   nz = 64;   niter = 6;}
-  else if (class == 'W') { nx = 128;  ny = 128;  nz = 32;   niter = 6;}
-  else if (class == 'A') { nx = 256;  ny = 256;  nz = 128;  niter = 6;}
-  else if (class == 'B') { nx = 512;  ny = 256;  nz = 256;  niter =20;}
-  else if (class == 'C') { nx = 512;  ny = 512;  nz = 512;  niter =20;}
-  else if (class == 'D') { nx = 2048; ny = 1024; nz = 1024; niter =25;}
-  else if (class == 'E') { nx = 4096; ny = 2048; nz = 2048; niter =25;}
-  else {
-    printf("setparams: Internal error: invalid class type %c\n", class);
-    exit(1);
-  }
-  maxdim = nx;
-  if (ny > maxdim) maxdim = ny;
-  if (nz > maxdim) maxdim = nz;
-  fprintf(fp, "%sinteger nx, ny, nz, maxdim, niter_default, ntdivnp, np_min\n", FINDENT);
-  fprintf(fp, "%sparameter (nx=%d, ny=%d, nz=%d, maxdim=%d)\n", 
-          FINDENT, nx, ny, nz, maxdim);
-  fprintf(fp, "%sparameter (niter_default=%d)\n", FINDENT, niter);
-  fprintf(fp, "%sparameter (np_min = %d)\n", FINDENT, nprocs);
-  fprintf(fp, "%sparameter (ntdivnp=((nx*ny)/np_min)*nz)\n", FINDENT);
-  fprintf(fp, "%sdouble precision ntotal_f\n", FINDENT);
-  fprintf(fp, "%sparameter (ntotal_f=1.d0*nx*ny*nz)\n", FINDENT);
-}
-
-/*
- * write_ep_info(): Write EP specific info to config file
- */
-
-void write_ep_info(FILE *fp, int nprocs, char class)
-{
-  /* easiest way (given the way the benchmark is written)
-   * is to specify log of number of grid points in each
-   * direction m1, m2, m3. nt is the number of iterations
-   */
-  int m;
-  if      (class == 'S') { m = 24; }
-  else if (class == 'W') { m = 25; }
-  else if (class == 'A') { m = 28; }
-  else if (class == 'B') { m = 30; }
-  else if (class == 'C') { m = 32; }
-  else if (class == 'D') { m = 36; }
-  else if (class == 'E') { m = 40; }
-  else {
-    printf("setparams: Internal error: invalid class type %c\n", class);
-    exit(1);
-  }
-  /* number of processors given by "npm" */
-
-
-  fprintf(fp, "%scharacter class\n",FINDENT);
-  fprintf(fp, "%sparameter (class =\'%c\')\n",
-                  FINDENT, class);
-  fprintf(fp, "%sinteger m, npm\n", FINDENT);
-  fprintf(fp, "%sparameter (m=%d, npm=%d)\n",
-          FINDENT, m, nprocs);
 }
 }
-/*
- * write_ep_info_C(): Write EP specific info to config file
- */
-
 
 
+/* write_ep_info_C(): Write EP specific info to config file */
 void write_ep_info_C(FILE *fp, int nprocs, char class)
 {
 void write_ep_info_C(FILE *fp, int nprocs, char class)
 {
-  /* easiest way (given the way the benchmark is written)
-   * is to specify log of number of grid points in each
+  /* easiest way (given the way the benchmark is written) is to specify log of number of grid points in each
    * direction m1, m2, m3. nt is the number of iterations
    */
   int m;
    * direction m1, m2, m3. nt is the number of iterations
    */
   int m;
@@ -861,23 +340,19 @@ void write_ep_info_C(FILE *fp, int nprocs, char class)
     printf("setparams: Internal error: invalid class type %c\n", class);
     exit(1);
   }
     printf("setparams: Internal error: invalid class type %c\n", class);
     exit(1);
   }
-  /* number of processors given by "npm" */
-
 
 
+  /* number of processors given by "npm" */
   fprintf(fp, "%schar *_class=\"%c\";\n",FINDENT,class);
   fprintf(fp, "%sint m=%d;\n", FINDENT,m);
   fprintf(fp, "%sint npm=%d;\n", FINDENT,nprocs);
 }
   fprintf(fp, "%schar *_class=\"%c\";\n",FINDENT,class);
   fprintf(fp, "%sint m=%d;\n", FINDENT,m);
   fprintf(fp, "%sint npm=%d;\n", FINDENT,nprocs);
 }
+
 /* 
 /* 
- * This is a gross hack to allow the benchmarks to 
- * print out how they were compiled. Various other ways
- * of doing this have been tried and they all fail on
- * some machine - due to a broken "make" program, or
- * F77 limitations, of whatever. Hopefully this will
- * always work because it uses very portable C. Unfortunately
+ * This is a gross hack to allow the benchmarks to  print out how they were compiled. Various other ways
+ * of doing this have been tried and they all fail on some machine - due to a broken "make" program, or
+ * F77 limitations, of whatever. Hopefully this will always work because it uses very portable C. Unfortunately
  * it relies on parsing the make.def file - YUK. 
  * If your machine doesn't have <string.h> or <ctype.h>, happy hacking!
  * it relies on parsing the make.def file - YUK. 
  * If your machine doesn't have <string.h> or <ctype.h>, happy hacking!
- * 
  */
 
 #define VERBOSE
  */
 
 #define VERBOSE
@@ -889,7 +364,6 @@ FILE *deffile;
 void write_compiler_info(int type, FILE *fp)
 {
   char line[LL];
 void write_compiler_info(int type, FILE *fp)
 {
   char line[LL];
-  char mpif77[LL], flink[LL], fmpi_lib[LL], fmpi_inc[LL], fflags[LL], flinkflags[LL];
   char compiletime[LL], randfile[LL];
   char mpicc[LL], cflags[LL], clink[LL], clinkflags[LL],
        cmpi_lib[LL], cmpi_inc[LL];
   char compiletime[LL], randfile[LL];
   char mpicc[LL], cflags[LL], clink[LL], clinkflags[LL],
        cmpi_lib[LL], cmpi_inc[LL];
@@ -904,12 +378,6 @@ setparams: File %s doesn't exist. To build the NAS benchmarks\n\
            the file config/make.def.template\n", DEFFILE);
     exit(1);
   }
            the file config/make.def.template\n", DEFFILE);
     exit(1);
   }
-  strcpy(mpif77, DEFAULT_MESSAGE);
-  strcpy(flink, DEFAULT_MESSAGE);
-  strcpy(fmpi_lib, DEFAULT_MESSAGE);
-  strcpy(fmpi_inc, DEFAULT_MESSAGE);
-  strcpy(fflags, DEFAULT_MESSAGE);
-  strcpy(flinkflags, DEFAULT_MESSAGE);
   strcpy(randfile, DEFAULT_MESSAGE);
   strcpy(mpicc, DEFAULT_MESSAGE);
   strcpy(cflags, DEFAULT_MESSAGE);
   strcpy(randfile, DEFAULT_MESSAGE);
   strcpy(mpicc, DEFAULT_MESSAGE);
   strcpy(cflags, DEFAULT_MESSAGE);
@@ -921,12 +389,6 @@ setparams: File %s doesn't exist. To build the NAS benchmarks\n\
   while (fgets(line, LL, deffile) != NULL) {
     if (*line == '#') continue;
     /* yes, this is inefficient. but it's simple! */
   while (fgets(line, LL, deffile) != NULL) {
     if (*line == '#') continue;
     /* yes, this is inefficient. but it's simple! */
-    check_line(line, "MPIF77", mpif77);
-    check_line(line, "FLINK", flink);
-    check_line(line, "FMPI_LIB", fmpi_lib);
-    check_line(line, "FMPI_INC", fmpi_inc);
-    check_line(line, "FFLAGS", fflags);
-    check_line(line, "FLINKFLAGS", flinkflags);
     check_line(line, "RAND", randfile);
     check_line(line, "MPICC", mpicc);
     check_line(line, "CFLAGS", cflags);
     check_line(line, "RAND", randfile);
     check_line(line, "MPICC", mpicc);
     check_line(line, "CFLAGS", cflags);
@@ -934,58 +396,20 @@ setparams: File %s doesn't exist. To build the NAS benchmarks\n\
     check_line(line, "CLINKFLAGS", clinkflags);
     check_line(line, "CMPI_LIB", cmpi_lib);
     check_line(line, "CMPI_INC", cmpi_inc);
     check_line(line, "CLINKFLAGS", clinkflags);
     check_line(line, "CMPI_LIB", cmpi_lib);
     check_line(line, "CMPI_INC", cmpi_inc);
-    /* if the dummy library is used by including make.dummy, we set the
-       Fortran and C paths to libraries and headers accordingly     */
-    if(check_include_line(line, "../config/make.dummy")) {
-       strcpy(fmpi_lib, "-L../MPI_dummy -lmpi");
-       strcpy(fmpi_inc, "-I../MPI_dummy");
-       strcpy(cmpi_lib, "-L../MPI_dummy -lmpi");
-       strcpy(cmpi_inc, "-I../MPI_dummy");
-    }
   }
 
   }
 
-  
   (void) time(&t);
   tmp = localtime(&t);
   (void) strftime(compiletime, (size_t)LL, "%d %b %Y", tmp);
 
   (void) time(&t);
   tmp = localtime(&t);
   (void) strftime(compiletime, (size_t)LL, "%d %b %Y", tmp);
 
-
-  switch(type) {
-      case FT:
-      case SP:
-      case BT:
-      case MG:
-      case LU:
-      //case EP:
-      case CG:
-          put_string(fp, "compiletime", compiletime);
-          put_string(fp, "npbversion", VERSION);
-          put_string(fp, "cs1", mpif77);
-          put_string(fp, "cs2", flink);
-          put_string(fp, "cs3", fmpi_lib);
-          put_string(fp, "cs4", fmpi_inc);
-          put_string(fp, "cs5", fflags);
-          put_string(fp, "cs6", flinkflags);
-    put_string(fp, "cs7", randfile);
-          break;
-      case IS:
-      case EP:
-      case DT:
-          put_def_string(fp, "COMPILETIME", compiletime);
-          put_def_string(fp, "NPBVERSION", VERSION);
-          put_def_string(fp, "MPICC", mpicc);
-          put_def_string(fp, "CFLAGS", cflags);
-          put_def_string(fp, "CLINK", clink);
-          put_def_string(fp, "CLINKFLAGS", clinkflags);
-          put_def_string(fp, "CMPI_LIB", cmpi_lib);
-          put_def_string(fp, "CMPI_INC", cmpi_inc);
-          break;
-      default:
-          printf("setparams: (Internal error): Unknown benchmark type %d\n", 
-                                                                         type);
-          exit(1);
-  }
-
+  put_def_string(fp, "COMPILETIME", compiletime);
+  put_def_string(fp, "NPBVERSION", VERSION);
+  put_def_string(fp, "MPICC", mpicc);
+  put_def_string(fp, "CFLAGS", cflags);
+  put_def_string(fp, "CLINK", clink);
+  put_def_string(fp, "CLINKFLAGS", clinkflags);
+  put_def_string(fp, "CMPI_LIB", cmpi_lib);
+  put_def_string(fp, "CMPI_INC", cmpi_inc);
 }
 
 void check_line(char *line, char *label, char *val)
 }
 
 void check_line(char *line, char *label, char *val)
@@ -1065,7 +489,6 @@ int check_include_line(char *line, char *filename)
   else return(1);
 }
 
   else return(1);
 }
 
-
 #define MAXL 46
 void put_string(FILE *fp, char *name, char *val)
 {
 #define MAXL 46
 void put_string(FILE *fp, char *name, char *val)
 {
@@ -1111,14 +534,8 @@ void put_def_variable(FILE *fp, char *name, char *val)
   fprintf(fp, "#define %s %s\n", name, val);
 }
 
   fprintf(fp, "#define %s %s\n", name, val);
 }
 
-
-
 #if 0
 #if 0
-
-/* this version allows arbitrarily long lines but 
- * some compilers don't like that and they're rarely
- * useful 
- */
+/* this version allows arbitrarily long lines but some compilers don't like that and they're rarely useful */
 
 #define LINELEN 65
 void put_string(FILE *fp, char *name, char *val)
 
 #define LINELEN 65
 void put_string(FILE *fp, char *name, char *val)
@@ -1140,14 +557,10 @@ void put_string(FILE *fp, char *name, char *val)
     else             fprintf(fp, "\n");
   }
 }
     else             fprintf(fp, "\n");
   }
 }
-
 #endif
 
 
 #endif
 
 
-/* integer square root. Return error if argument isn't
- * a perfect square or is less than or equal to zero 
- */
-
+/* integer square root. Return error if argument isn't a perfect square or is less than or equal to zero */
 int isqrt(int i)
 {
   int root, square;
 int isqrt(int i)
 {
   int root, square;
@@ -1159,12 +572,8 @@ int isqrt(int i)
   }
   return(-1);
 }
   }
   return(-1);
 }
-  
-
-/* integer log base two. Return error is argument isn't
- * a power of two or is less than or equal to zero 
- */
 
 
+/* integer log base two. Return error is argument isn't a power of two or is less than or equal to zero */
 int ilog2(int i)
 {
   int log2;
 int ilog2(int i)
 {
   int log2;
@@ -1186,25 +595,3 @@ int ipow2(int i)
   while(i--) pow2 *= 2;
   return(pow2);
 }
   while(i--) pow2 *= 2;
   return(pow2);
 }
-
-
-void write_convertdouble_info(int type, FILE *fp)
-{
-  switch(type) {
-  case SP:
-  case BT:
-  case LU:
-  case FT:
-  case MG:
-  //case EP:
-  case CG:
-    fprintf(fp, "%slogical  convertdouble\n", FINDENT);
-#ifdef CONVERTDOUBLE
-    fprintf(fp, "%sparameter (convertdouble = .true.)\n", FINDENT);
-#else
-    fprintf(fp, "%sparameter (convertdouble = .false.)\n", FINDENT);
-#endif
-    break;
-  }
-}