PolyBench/Fortran

News

• 03/28/12: Public release of PolyBench/Fortran 1.0 Download. PolyBench/Fortran is a port of PolyBench/C 3.2 in Fortran, written by Mohanish Narayan

Description

PolyBench is a collection of benchmarks containing static control parts. The purpose is to uniformize the execution and monitoring of kernels, typically used in past and current publications. PolyBench features include:

• A single file, tunable at compile-time, used for the kernel instrumentation. It performs extra operations such as cache flushing before the kernel execution, and can set real-time scheduling to prevent OS interference.
• Non-null data initialization, and live-out data dump.
• Syntactic constructs to prevent any dead code elimination on the kernel.
• Parametric loop bounds in the kernels, for general-purpose implementation.
• Clear kernel marking, using !$pragma scop and !$pragma endscop delimiters.

Available benchmarks (PolyBench/Fortran version 1.0)

Download

Download Polybench/Fortran 1.0: polybench-fortran-1.0.tar.gz

Documentation

* * * * * * * * * * * * *
* PolyBench/Fortran 1.0 *
* * * * * * * * * * * * *

Copyright (c) 2011-2012 the Ohio State University.
Contact: Louis-Noel Pouchet <pouchet@cse.ohio-state.edu>
         Mohanish Narayan <narayanm@cse.ohio-state.edu>


-------------
* New in 1.0:
-------------

- First release of Polybench/Fortran, based on 
  Polybench/C 3.2


----------------
* Mailing lists:
----------------

** polybench-announces@lists.sourceforge.net:
---------------------------------------------

Announces about releases of PolyBench.

** polybench-discussion@lists.sourceforge.net:
----------------------------------------------

General discussions reg. PolyBench.



-----------------------
* Available benchmarks:
-----------------------

::linear-algebra::
linear-algebra/kernels:
linear-algebra/kernels/2mm/2mm.F90
linear-algebra/kernels/3mm/3mm.F90
linear-algebra/kernels/atax/atax.F90
linear-algebra/kernels/bicg/bicg.F90
linear-algebra/kernels/cholesky/cholesky.F90
linear-algebra/kernels/doitgen/doitgen.F90
linear-algebra/kernels/gemm/gemm.F90
linear-algebra/kernels/gemver/gemver.F90
linear-algebra/kernels/gesummv/gesummv.F90
linear-algebra/kernels/mvt/mvt.F90
linear-algebra/kernels/symm/symm.F90
linear-algebra/kernels/syr2k/syr2k.F90
linear-algebra/kernels/syrk/syrk.F90
linear-algebra/kernels/trisolv/trisolv.F90
linear-algebra/kernels/trmm/trmm.F90

linear-algebra/solvers:
linear-algebra/solvers/durbin/durbin.F90
linear-algebra/solvers/dynprog/dynprog.F90
linear-algebra/solvers/gramschmidt/gramschmidt.F90
linear-algebra/solvers/lu/lu.F90
linear-algebra/solvers/ludcmp/ludcmp.F90

::datamining::
datamining/correlation/correlation.F90
datamining/covariance/covariance.F90

::medley::
medley/floyd-warshall/floyd-warshall.F90
medley/reg_detect/reg_detect.F90

::stencils::
stencils/adi/adi.F90
stencils/fdtd-2d/fdtd-2d.F90
stencils/fdtd-apml/fdtd-apml.F90
stencils/jacobi-1d-imper/jacobi-1d-imper.F90
stencils/jacobi-2d-imper/jacobi-2d-imper.F90
stencils/seidel-2d/seidel-2d.F90



------------------------------
* Sample compilation commands:
------------------------------


** To compile a benchmark without any monitoring:
-------------------------------------------------

#  Build utilities first 
$> gcc -c utilities/fpolybench.c -o utilities/fpolybench.o

#  Build the benchmark
$> gfortran -ffree-line-length-none linear-algebra/kernels/atax/atax.F90 -Iutilities utilities/fpolybench.o -o atax_base


** To compile a benchmark with execution time reporting:
--------------------------------------------------------

#  Build utilities first 
$> gcc -c -DPOLYBENCH_TIME utilities/fpolybench.c -o utilities/fpolybench.o

#  Build the benchmark
$> gfortran -ffree-line-length-none -DPOLYBENCH_TIME linear-algebra/kernels/atax/atax.F90 -Iutilities utilities/fpolybench.o -o atax_time


** To generate the reference output of a benchmark:
---------------------------------------------------

#  Build utilities first 
$> gcc -c utilities/fpolybench.c -o utilities/fpolybench.o

#  Build the benchmark
$> gfortran -ffree-line-length-none -O0 -DPOLYBENCH_DUMP_ARRAYS linear-algebra/kernels/atax/atax.F90 -Iutilities utilities/fpolybench.o -o atax_ref
$> ./atax_ref 2>atax_ref.out




-------------------------
* Some available options:
-------------------------

They are all passed as macro definitions during compilation time (e.g,
-Dname_of_the_option).

- POLYBENCH_TIME: output execution time (gettimeofday) [default: off]

- POLYBENCH_NO_FLUSH_CACHE: don't flush the cache before calling the
  timer [default: flush the cache]

- POLYBENCH_LINUX_FIFO_SCHEDULER: use FIFO real-time scheduler for the
  kernel execution, the program must be run as root, under linux only,
  and compiled with -lc [default: off]

- POLYBENCH_CACHE_SIZE_KB: cache size to flush, in kB [default: 33MB]

- POLYBENCH_STACK_ARRAYS: use stack allocation instead of malloc [default: off]

- POLYBENCH_DUMP_ARRAYS: dump all live-out arrays on stderr [default: off]

- POLYBENCH_CYCLE_ACCURATE_TIMER: Use Time Stamp Counter to monitor
  the execution time of the kernel [default: off]

- POLYBENCH_PAPI: turn on papi timing (see below).

- MINI_DATASET, SMALL_DATASET, STANDARD_DATASET, LARGE_DATASET,
  EXTRALARGE_DATASET: set the dataset size to be used
  [default: STANDARD_DATASET]

- POLYBENCH_USE_SCALAR_LB: Use scalar loop bounds instead of parametric ones.



---------------
* PAPI support:
---------------

** To compile a benchmark with PAPI support:
--------------------------------------------

#  Build utilities first 
$> gcc -c utilities/fpolybench.c -o utilities/fpolybench.o -DPOLYBENCH_PAPI

#  Build the benchmark
$> gfortran -ffree-line-length-none -O3 -DPOLYBENCH_PAPI linear-algebra/kernels/atax/atax.F90 -Iutilities utilities/fpolybench.o -o atax_papi


** To specify which counter(s) to monitor:
------------------------------------------

Edit utilities/papi_counters.list, and add 1 line per event to
monitor. Each line (including the last one) must finish with a ',' and
both native and standard events are supported.

The whole kernel is run one time per counter (no multiplexing) and
there is no sampling being used for the counter value.



------------------------------
* Accurate performance timing:
------------------------------

With kernels that have an execution time in the orders of a few tens
of milliseconds, it is critical to validate any performance number by
repeating several times the experiment. A companion script is
available to perform reasonable performance measurement of a PolyBench.

#  Build utilities first 
$> gcc -c -O3 utilities/fpolybench.c -o utilities/fpolybench.o -DPOLYBENCH_TIME

#  Build the benchmark
$> gfortran -ffree-line-length-none -O3 -DPOLYBENCH_TIME linear-algebra/kernels/atax/atax.F90 -Iutilities utilities/fpolybench.o -o atax_time

#  Run the benchmark using the companion script.
$> ./utilities/time_benchmark.sh ./atax_time

This script will run five times the benchmark (that must be a
PolyBench compiled with -DPOLYBENCH_TIME), eliminate the two extremal
times, and check that the deviation of the three remaining does not
exceed a given thresold, set to 5%.

It is also possible to use POLYBENCH_CYCLE_ACCURATE_TIMER to use the
Time Stamp Counter instead of gettimeofday() to monitor the number of
elapsed cycles.




----------------------------------------
* Generating macro-free benchmark suite:
----------------------------------------

(from the root of the archive:)
$> PARGS="-I utilities -DPOLYBENCH_TIME";
$> for i in `cat utilities/benchmark_list`; do create_pped_version.sh $i "$PARGS"; done

This create for each benchmark file 'xxx.F' a new file
'xxx.preproc.F'. The PARGS variable in the above example can be set to
the desired configuration.

e.g
$> PARGS="-I utilities -DPOLYBENCH_STACK_ARRAYS -DPOLYBENCH_USE_SCALAR_LB -DLARGE_DATASET -DPOLYBENCH_TIME";
$> for i in `cat utilities/benchmark_list`; do ./utilities/create_pped_version.sh "$i" "$PARGS"; done




----------------------------------------
* Acknowledgements:
----------------------------------------

This software was produced with support from the Department of Energy's
Office of Advanced Scientific Computing under grant DE-SC0005033 and by the
National Science Foundation under grant CCF-0811781. Nothing in this work
should be construed as reflecting the official policy or position of the
Department of Energy, the National Science Foundation, the United States
government, or the Ohio State University.