This is an archive of the discontinued LLVM Phabricator instance.

Differential D25277

[test-suite] Run FP tests twice with -ffp-contract=off/on
AbandonedPublic

Authored by sebpop on Oct 5 2016, 6:26 AM.

Details

Reviewers
rengolin
Abe
MatzeB
cmatthews
Summary

With this patch all the tests specifying an FP_TOLERANCE or FP_ABSTOLERANCE will be run in two stages:

  • first step is with with extra flags "-ffp-contract=off -fno-fast-math", and recording the full output that will be checked against in the second step
  • second step is with the default flags specified by the user, and checks against the output recorded in the first step with the FP_TOLERANCE specified by the test.

There are at least two main problems with this approach:

  • some of the current golden files in the test-suite require testing with FP_TOLERANCE even for stage1
  • the build directory goes from 300M to 1.2G due to the extra reference outputs recorded by stage1, and for at least 2 tests (polybench/bicg, polybench/mvt disabled in the current patch) fpcmp takes more than 10 minutes to completely parse the outputs of stage1 and 2. When running test-suite over small devices will cost 1G more transfer over the network.

The current implementation has another smaller technical issue:
lit does not allow to specify dependences between tests.
When running "lit -j8" one can end up running stage 2 before stage 1.
The solution I was considering is to run step 1 as a PREPARE: step,
though that would fail to add the exit code in the output,
and that will end up mismatching the hash.

Diff Detail

Event Timeline

sebpop updated this revision to Diff 73639.Oct 5 2016, 6:26 AM
sebpop retitled this revision from to [test-suite] Run FP tests twice with -ffp-contract=off/on.
sebpop updated this object.
sebpop added reviewers: rengolin, cmatthews, MatzeB, Abe.
sebpop added a subscriber: llvm-commits.
Herald added subscribers: mgorny, beanz. · View Herald TranscriptOct 5 2016, 6:26 AM
spatel added a subscriber: spatel.Oct 5 2016, 6:43 AM
MatzeB edited edge metadata.Oct 5 2016, 11:23 AM
MatzeB added a subscriber: scanon.

Ugh, I don't like the added complexity and disk space bloat.

Is there no way to summarize/hash/compress a list of floating point numbers in a way that we can compare them against a reference output and at the same time allow some fluctuations in floatingpoint accuracy?

sebpop added a comment.Oct 5 2016, 1:17 PM
In D25277#562503, @MatzeB wrote:

Ugh, I don't like the added complexity and disk space bloat.

Is there no way to summarize/hash/compress a list of floating point numbers in a way that we can compare them against a reference output and at the same time allow some fluctuations in floatingpoint accuracy?

If those tests were written with testing with FP_TOLERANCE in mind, we won't have all those problems.
In the case of Polybench in general and specifically for bicg and mvt, the tests are dumping 4000 by 4000 double matrices, which is ridiculous, all Polybench should be restricted to only compare against a an exact reference hash. These tests (and maybe others) should only run under -ffp-contract=off.

rengolin edited edge metadata.Oct 6 2016, 8:29 AM

With this patch all the tests specifying an FP_TOLERANCE or FP_ABSTOLERANCE will be run in two stages:

first step is with with extra flags "-ffp-contract=off -fno-fast-math", and recording the full output that will be checked against in the second step
second step is with the default flags specified by the user, and checks against the output recorded in the first step with the FP_TOLERANCE specified by the test.

This doesn't make sense. If there's an FP bug, it can manifest on both sides, meaning we'd only be catching contract problems, not FP problems.

The proposed way was to have the exact same reference output and compare with a higher FP tolerance when running with fp-contract=on.

There are at least two main problems with this approach:

some of the current golden files in the test-suite require testing with FP_TOLERANCE even for stage1

Of course, as expected.

the build directory goes from 300M to 1.2G due to the extra reference outputs recorded by stage1, and for at least 2 tests (polybench/bicg, polybench/mvt disabled in the current patch) fpcmp takes more than 10 minutes to completely parse the outputs of stage1 and 2. When running test-> suite over small devices will cost 1G more transfer over the network.

This is not acceptable.

The current implementation has another smaller technical issue:
lit does not allow to specify dependences between tests.
When running "lit -j8" one can end up running stage 2 before stage 1.

Ouch, that's horrible!

The solution I was considering is to run step 1 as a PREPARE: step,
though that would fail to add the exit code in the output,
and that will end up mismatching the hash.

That's way too complex. Why not have two different tolerances for each run?

hfinkel added a subscriber: hfinkel.Oct 6 2016, 8:43 AM
In D25277#563486, @rengolin wrote:

With this patch all the tests specifying an FP_TOLERANCE or FP_ABSTOLERANCE will be run in two stages:

first step is with with extra flags "-ffp-contract=off -fno-fast-math", and recording the full output that will be checked against in the second step
second step is with the default flags specified by the user, and checks against the output recorded in the first step with the FP_TOLERANCE specified by the test.

This doesn't make sense. If there's an FP bug, it can manifest on both sides, meaning we'd only be catching contract problems, not FP problems.

The proposed way was to have the exact same reference output and compare with a higher FP tolerance when running with fp-contract=on.

There are at least two main problems with this approach:

some of the current golden files in the test-suite require testing with FP_TOLERANCE even for stage1

Of course, as expected.

the build directory goes from 300M to 1.2G due to the extra reference outputs recorded by stage1, and for at least 2 tests (polybench/bicg, polybench/mvt disabled in the current patch) fpcmp takes more than 10 minutes to completely parse the outputs of stage1 and 2. When running test-> suite over small devices will cost 1G more transfer over the network.

This is not acceptable.

We should look at making the polybench run on smaller data sets for these kinds of comparisons. As I recall, we're running into this problem because the current polybench setups are designed to run in a regime where the tests are memory-bandwidth bound. This is where polyhedral transformations are often profitable, which is good, but this is not as useful for this kind of regressions testing.

We can have large polybench tests, this is useful for performance testing of higher-order transformations. They should, however, hash their own output so we have an easy comparison. We can do full dumps on smaller-sized runs. As I've suggested previously, we should save the output of the IEEE-strict run, compare to the hashed output, and then compile/run in the default mode, and compare that to the IEEE-strict output with a higher tolerance.

The current implementation has another smaller technical issue:
lit does not allow to specify dependences between tests.
When running "lit -j8" one can end up running stage 2 before stage 1.

Ouch, that's horrible!

I think that running all of the configurations of a benchmark should happen as one "test", in the lit sense. i.e. the test file that is generated should have multiple run lines.

The solution I was considering is to run step 1 as a PREPARE: step,
though that would fail to add the exit code in the output,
and that will end up mismatching the hash.

That's way too complex. Why not have two different tolerances for each run?

No, we can have multiple RUN lines.

sebpop mentioned this in D25346: [test-suite] [Polybench] run tests twice with -ffp-contract=on/off.Oct 6 2016, 1:58 PM
sebpop abandoned this revision.Oct 19 2016, 6:48 AM
mibintc mentioned this in D102861: Suppress FP_CONTRACT due to planned command line changes.May 26 2021, 8:24 AM

Revision Contents

PathSize
11 lines
MultiSource/
Applications/
oggenc/
1 line
Benchmarks/
VersaBench/
beamformer/
1 line
SingleSource/
Benchmarks/
Polybench/
datamining/
correlation/
1 line
covariance/
1 line
linear-algebra/
kernels/
2mm/
1 line
3mm/
1 line
atax/
1 line
bicg/
2 lines
cholesky/
1 line
doitgen/
1 line
gemm/
1 line
gemver/
1 line
gesummv/
1 line
mvt/
2 lines
symm/
1 line
syr2k/
1 line
syrk/
1 line
trisolv/
1 line
trmm/
1 line
solvers/
durbin/
1 line
dynprog/
1 line
gramschmidt/
1 line
lu/
1 line
ludcmp/
1 line
medley/
floyd-warshall/
1 line
stencils/
adi/
1 line
fdtd-2d/
1 line
fdtd-apml/
1 line
jacobi-1d-imper/
1 line
jacobi-2d-imper/
1 line
seidel-2d/
1 line
cmake/
modules/
96 lines

Diff 73639

HashProgramOutput.sh

#!/bin/sh #!/bin/sh
if [ $# != 1 ]; then if [ $# -lt 1 -o $# -gt 2 ]; then
echo "$0 <output path>" echo "$0 <output path> [<copy of original output>]"
exit 1 exit 1
fi fi
md5cmd=$(which md5sum) md5cmd=$(which md5sum)
is_md5sum=1 is_md5sum=1
if [ ! -x "$md5cmd" ]; then if [ ! -x "$md5cmd" ]; then
md5cmd=$(which md5) md5cmd=$(which md5)
is_md5sum=0 is_md5sum=0
if [ ! -x "$md5cmd" ]; then if [ ! -x "$md5cmd" ]; then
echo "error: unable to find either 'md5sum' or 'md5'" echo "error: unable to find either 'md5sum' or 'md5'"
exit 1 exit 1
fi fi
fi fi
mv $1 $1.bak mv $1 $1.bak
if [ $is_md5sum = "0" ]; then if [ $is_md5sum = "0" ]; then
$md5cmd < $1.bak > $1 $md5cmd < $1.bak > $1
else else
$md5cmd < $1.bak | cut -d' ' -f 1 > $1 $md5cmd < $1.bak | cut -d' ' -f 1 > $1
fi fi
if [ x"$2" != x ]; then
mv -f $1.bak $2
else
rm -f $1.bak rm -f $1.bak
fi

MultiSource/Applications/oggenc/CMakeLists.txt

set(PROG oggenc) set(PROG oggenc)
list(APPEND CPPFLAGS -fno-strict-aliasing) list(APPEND CPPFLAGS -fno-strict-aliasing)
list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(STDIN_FILENAME ${CMAKE_CURRENT_SOURCE_DIR}/tune) set(STDIN_FILENAME ${CMAKE_CURRENT_SOURCE_DIR}/tune)
set(RUN_OPTIONS "-Q -s 901820 -") set(RUN_OPTIONS "-Q -s 901820 -")
set(FP_ABSTOLERANCE 1.0e-5)
llvm_multisource() llvm_multisource()

MultiSource/Benchmarks/VersaBench/beamformer/CMakeLists.txt

list(APPEND LDFLAGS -lm) list(APPEND LDFLAGS -lm)
set(PROG beamformer) set(PROG beamformer)
if(DEFINED LARGE_PROBLEM_SIZE) if(DEFINED LARGE_PROBLEM_SIZE)
set(RUN_OPTIONS -i 400) set(RUN_OPTIONS -i 400)
else() else()
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
set(RUN_OPTIONS -i 25) set(RUN_OPTIONS -i 25)
else() else()
set(RUN_OPTIONS -i 140) set(RUN_OPTIONS -i 140)
endif() endif()
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_multisource() llvm_multisource()

SingleSource/Benchmarks/Polybench/datamining/correlation/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG correlation) set(PROG correlation)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/datamining/covariance/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG covariance) set(PROG covariance)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/CMakeLists.txt

Show All 9 Lines
endif() endif()
if(ARCH STREQUAL "Mips") if(ARCH STREQUAL "Mips")
set(RUNTIMELIMIT 2000) set(RUNTIMELIMIT 2000)
elseif(ARCH STREQUAL "XCore") elseif(ARCH STREQUAL "XCore")
else() else()
set(RUNTIMELIMIT 1000) set(RUNTIMELIMIT 1000)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/CMakeLists.txt

Show All 9 Lines
endif() endif()
if(ARCH STREQUAL "Mips") if(ARCH STREQUAL "Mips")
set(RUNTIMELIMIT 2000) set(RUNTIMELIMIT 2000)
elseif(ARCH STREQUAL "XCore") elseif(ARCH STREQUAL "XCore")
else() else()
set(RUNTIMELIMIT 1000) set(RUNTIMELIMIT 1000)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG atax) set(PROG atax)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
if(ARCH STREQUAL "XCore") if(ARCH STREQUAL "XCore")
set(XCORE_TARGET_NEEDS_MEMORY 128) set(XCORE_TARGET_NEEDS_MEMORY 128)
endif() endif()
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG bicg) set(PROG bicg)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
# FIXME: Checking the exact output of this benchmark takes an unreasonable amount of time and space.
#set(FP_ABSTOLERANCE 1.0e-5)
if(ARCH STREQUAL "XCore") if(ARCH STREQUAL "XCore")
set(XCORE_TARGET_NEEDS_MEMORY 128) set(XCORE_TARGET_NEEDS_MEMORY 128)
endif() endif()
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/cholesky/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG cholesky) set(PROG cholesky)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG doitgen) set(PROG doitgen)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
else() else()
if(ARCH STREQUAL "XCore") if(ARCH STREQUAL "XCore")
set(XCORE_TARGET_NEEDS_MEMORY 64) set(XCORE_TARGET_NEEDS_MEMORY 64)
endif() endif()
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemm/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG gemm) set(PROG gemm)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG gemver) set(PROG gemver)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
if(ARCH STREQUAL "XCore") if(ARCH STREQUAL "XCore")
set(XCORE_TARGET_NEEDS_MEMORY 128) set(XCORE_TARGET_NEEDS_MEMORY 128)
endif() endif()
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG gesummv) set(PROG gesummv)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
else() else()
if(ARCH STREQUAL "XCore") if(ARCH STREQUAL "XCore")
set(XCORE_TARGET_NEEDS_MEMORY 256) set(XCORE_TARGET_NEEDS_MEMORY 256)
endif() endif()
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/mvt/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG mvt) set(PROG mvt)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
# FIXME: Checking the exact output of this benchmark takes an unreasonable amount of time and space.
#set(FP_ABSTOLERANCE 1.0e-5)
if(ARCH STREQUAL "XCore") if(ARCH STREQUAL "XCore")
set(XCORE_TARGET_NEEDS_MEMORY 128) set(XCORE_TARGET_NEEDS_MEMORY 128)
endif() endif()
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG symm) set(PROG symm)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(ARCH STREQUAL "Mips") if(ARCH STREQUAL "Mips")
set(RUNTIMELIMIT 2000) set(RUNTIMELIMIT 2000)
endif() endif()
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syr2k/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG syr2k) set(PROG syr2k)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syrk/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG syrk) set(PROG syrk)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG trisolv) set(PROG trisolv)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
if(ARCH STREQUAL "XCore") if(ARCH STREQUAL "XCore")
set(XCORE_TARGET_NEEDS_MEMORY 128) set(XCORE_TARGET_NEEDS_MEMORY 128)
endif() endif()
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG trmm) set(PROG trmm)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/solvers/durbin/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG durbin) set(PROG durbin)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
if(ARCH STREQUAL "XCore") if(ARCH STREQUAL "XCore")
set(XCORE_TARGET_NEEDS_MEMORY 256) set(XCORE_TARGET_NEEDS_MEMORY 256)
endif() endif()
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/solvers/dynprog/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG dynprog) set(PROG dynprog)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG gramschmidt) set(PROG gramschmidt)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/solvers/lu/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG lu) set(PROG lu)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/linear-algebra/solvers/ludcmp/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG ludcmp) set(PROG ludcmp)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/medley/floyd-warshall/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG floyd-warshall) set(PROG floyd-warshall)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/stencils/adi/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG adi) set(PROG adi)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/stencils/fdtd-2d/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG fdtd-2d) set(PROG fdtd-2d)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/stencils/fdtd-apml/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG fdtd-apml) set(PROG fdtd-apml)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/stencils/jacobi-1d-imper/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG jacobi-1d-imper) set(PROG jacobi-1d-imper)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/stencils/jacobi-2d-imper/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG jacobi-2d-imper) set(PROG jacobi-2d-imper)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

SingleSource/Benchmarks/Polybench/stencils/seidel-2d/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG seidel-2d) set(PROG seidel-2d)
list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS)
if(DEFINED SMALL_PROBLEM_SIZE) if(DEFINED SMALL_PROBLEM_SIZE)
list(APPEND CFLAGS -DSMALL_DATASET) list(APPEND CFLAGS -DSMALL_DATASET)
endif() endif()
set(HASH_PROGRAM_OUTPUT 1) set(HASH_PROGRAM_OUTPUT 1)
set(FP_ABSTOLERANCE 1.0e-5)
llvm_singlesource() llvm_singlesource()

cmake/modules/SingleMultiSource.cmake

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Linesfunction(llvm_test_traditional testfile executable name)
endif() endif()
if(WORKDIR) if(WORKDIR)
list(APPEND RUN_OPTIONS WORKDIR ${WORKDIR}) list(APPEND RUN_OPTIONS WORKDIR ${WORKDIR})
endif() endif()
llvm_test_run(${RUN_OPTIONS}) llvm_test_run(${RUN_OPTIONS})
# Hash if we've been asked to. # Hash if we've been asked to.
if(HASH_PROGRAM_OUTPUT) if(HASH_PROGRAM_OUTPUT)
if(DEFINED OUTPUT_FP_CONTRACT_OFF)
llvm_test_verify("${CMAKE_SOURCE_DIR}/HashProgramOutput.sh %o ${OUTPUT_FP_CONTRACT_OFF}")
else()
llvm_test_verify("${CMAKE_SOURCE_DIR}/HashProgramOutput.sh %o") llvm_test_verify("${CMAKE_SOURCE_DIR}/HashProgramOutput.sh %o")
endif() endif()
elseif(DEFINED OUTPUT_FP_CONTRACT_OFF AND DEFINED FP_FIRST_STEP)
llvm_test_verify("cp -p %o ${OUTPUT_FP_CONTRACT_OFF}")
endif()
if(NOT DEFINED PROGRAM_IS_NONDETERMINISTIC) if(NOT DEFINED PROGRAM_IS_NONDETERMINISTIC)
# Find the reference output file key name. # Find the reference output file key name.
if(SMALL_PROBLEM_SIZE) if(SMALL_PROBLEM_SIZE)
set(KEY small) set(KEY small)
elseif(LARGE_PROBLEM_SIZE) elseif(LARGE_PROBLEM_SIZE)
set(KEY large) set(KEY large)
else() else()
set(KEY) set(KEY)
endif() endif()
# Pick the best reference output based on "programname.reference_output". # Pick the best reference output based on "programname.reference_output".
if(NOT DEFINED NO_REFERENCE_OUTPUT) if(DEFINED OUTPUT_FP_CONTRACT_OFF AND NOT DEFINED FP_FIRST_STEP)
set(REFERENCE_OUTPUT ${OUTPUT_FP_CONTRACT_OFF})
elseif(NOT DEFINED NO_REFERENCE_OUTPUT)
if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${ENDIAN}-endian.${KEY}) if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${ENDIAN}-endian.${KEY})
set(REFERENCE_OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${ENDIAN}-endian.${KEY}) set(REFERENCE_OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${ENDIAN}-endian.${KEY})
elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${KEY}) elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${KEY})
set(REFERENCE_OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${KEY}) set(REFERENCE_OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${KEY})
elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${ENDIAN}-endian) elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${ENDIAN}-endian)
set(REFERENCE_OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${ENDIAN}-endian) set(REFERENCE_OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output.${ENDIAN}-endian)
elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output) elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output)
set(REFERENCE_OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output) set(REFERENCE_OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/${name}.reference_output)
else() else()
message("-- No reference output found for test ${name}") message("-- No reference output found for test ${name}")
endif() endif()
endif() endif()
set(DIFFPROG ${CMAKE_BINARY_DIR}/tools/fpcmp) set(DIFFPROG ${CMAKE_BINARY_DIR}/tools/fpcmp)
if(DEFINED FP_TOLERANCE) if(DEFINED FP_TOLERANCE AND NOT DEFINED HASH_PROGRAM_OUTPUT)
set(DIFFPROG "${DIFFPROG} -r ${FP_TOLERANCE}") set(DIFFPROG "${DIFFPROG} -r ${FP_TOLERANCE}")
endif() endif()
if(DEFINED FP_ABSTOLERANCE) if(DEFINED FP_ABSTOLERANCE AND NOT DEFINED HASH_PROGRAM_OUTPUT)
set(DIFFPROG "${DIFFPROG} -a ${FP_ABSTOLERANCE}") set(DIFFPROG "${DIFFPROG} -a ${FP_ABSTOLERANCE}")
endif() endif()
if(REFERENCE_OUTPUT) if(REFERENCE_OUTPUT)
llvm_test_verify("${DIFFPROG} %o ${REFERENCE_OUTPUT}") llvm_test_verify("${DIFFPROG} %o ${REFERENCE_OUTPUT}")
endif() endif()
endif() endif()
llvm_add_test(${testfile} ${executable}) llvm_add_test(${testfile} ${executable})
endfunction() endfunction()
macro (test_suite_add_build_dependencies executable) macro (test_suite_add_build_dependencies executable)
if (NOT TEST_SUITE_USE_PERF) if (NOT TEST_SUITE_USE_PERF)
add_dependencies(${executable} timeit-target) add_dependencies(${executable} timeit-target)
endif() endif()
add_dependencies(${executable} timeit-host fpcmp-host) add_dependencies(${executable} timeit-host fpcmp-host)
endmacro() endmacro()
macro(llvm_test_executable name) macro(llvm_test_executable_end executable name)
cmake_parse_arguments(_LTARG "" "PREFIX;TARGET_VAR" "" ${ARGN})
if (_LTARG_PREFIX)
set(executable "${_LTARG_PREFIX}-${name}")
else()
set(executable ${name})
endif()
unset("${_LTARG_TARGET_VAR}")
list(FIND PROGRAMS_TO_SKIP ${executable} exe_idx)
list(FIND PROGRAMS_TO_SKIP ${name} name_idx)
# Should we skip this?
if(${name_idx} EQUAL -1 AND ${exe_idx} EQUAL -1)
add_executable(${executable} ${_LTARG_UNPARSED_ARGUMENTS})
if (_LTARG_TARGET_VAR) if (_LTARG_TARGET_VAR)
set(${_LTARG_TARGET_VAR} ${executable}) set(${_LTARG_TARGET_VAR} ${executable})
endif() endif()
append_compile_flags(${executable} ${CFLAGS}) append_compile_flags(${executable} ${CFLAGS})
append_compile_flags(${executable} ${CPPFLAGS}) append_compile_flags(${executable} ${CPPFLAGS})
append_compile_flags(${executable} ${CXXFLAGS}) append_compile_flags(${executable} ${CXXFLAGS})
# Note that we cannot use target_link_libraries() here because that one # Note that we cannot use target_link_libraries() here because that one
# only interprets inputs starting with '-' as flags. # only interprets inputs starting with '-' as flags.
append_link_flags(${executable} ${LDFLAGS}) append_link_flags(${executable} ${LDFLAGS})
set(executable_path ${CMAKE_CURRENT_BINARY_DIR}/${executable}) set(executable_path ${CMAKE_CURRENT_BINARY_DIR}/${executable})
if (TEST_SUITE_PROFILE_USE) if (TEST_SUITE_PROFILE_USE)
append_compile_flags(${executable} -fprofile-instr-use=${executable_path}.profdata) append_compile_flags(${executable} -fprofile-instr-use=${executable_path}.profdata)
append_link_flags(${executable} -fprofile-instr-use=${executable_path}.profdata) append_link_flags(${executable} -fprofile-instr-use=${executable_path}.profdata)
endif() endif()
set_property(GLOBAL APPEND PROPERTY TEST_SUITE_TARGETS ${executable}) set_property(GLOBAL APPEND PROPERTY TEST_SUITE_TARGETS ${executable})
# Fall back to old style involving RUN_OPTIONS and STDIN_FILENAME if # Fall back to old style involving RUN_OPTIONS and STDIN_FILENAME if
# llvm_test_run() was not called yet. # llvm_test_run() was not called yet.
if(NOT TESTSCRIPT) if(NOT TESTSCRIPT)
llvm_test_traditional(${executable_path}.test ${executable_path} ${name}) llvm_test_traditional(${executable_path}.test ${executable_path} ${name})
else() else()
llvm_add_test(${executable_path}.test ${executable_path}) llvm_add_test(${executable_path}.test ${executable_path})
endif() endif()
test_suite_add_build_dependencies(${executable}) test_suite_add_build_dependencies(${executable})
endmacro()
macro(llvm_test_executable name)
cmake_parse_arguments(_LTARG "" "PREFIX;TARGET_VAR" "" ${ARGN})
if (_LTARG_PREFIX)
set(executable "${_LTARG_PREFIX}-${name}")
else()
set(executable ${name})
endif()
unset("${_LTARG_TARGET_VAR}")
list(FIND PROGRAMS_TO_SKIP ${executable} exe_idx)
list(FIND PROGRAMS_TO_SKIP ${name} name_idx)
# Should we skip this?
if(${name_idx} EQUAL -1 AND ${exe_idx} EQUAL -1)
# FP tests need two steps: the first run records the output of the program
# compiled with -ffp-contract=off, and compares the hash of the output
# against a reference hashed value. The second run tests the default
# behavior of the compiler, and compares the output with tolerance against
# the output of the first step.
if (DEFINED FP_ABSTOLERANCE OR DEFINED FP_TOLERANCE)
set(executable_fpcoff "${executable}-fp-contract-off")
add_executable(${executable_fpcoff} ${_LTARG_UNPARSED_ARGUMENTS})
# The first step must compile without -ffast-math and -ffp-contract.
append_compile_flags(${executable_fpcoff} "-ffp-contract=off" "-fno-fast-math")
set(OUTPUT_FP_CONTRACT_OFF ${CMAKE_CURRENT_BINARY_DIR}/Output/${executable_fpcoff}.out)
# The first run cannot do an exact comparison: there are some tests that are failing.
#set(ORIG_FP_TOLERANCE ${FP_TOLERANCE})
#set(ORIG_FP_ABSTOLERANCE ${FP_ABSTOLERANCE})
#unset(FP_TOLERANCE)
#unset(FP_ABSTOLERANCE)
set(FP_FIRST_STEP 1)
llvm_test_executable_end(${executable_fpcoff} ${name})
unset(FP_FIRST_STEP)
# Next run should be a comparison against the golden file recorded in the
# first step.
unset(HASH_PROGRAM_OUTPUT)
#set(FP_TOLERANCE ${ORIG_FP_TOLERANCE})
#set(FP_ABSTOLERANCE ${ORIG_FP_ABSTOLERANCE})
endif ()
add_executable(${executable} ${_LTARG_UNPARSED_ARGUMENTS})
llvm_test_executable_end(${executable} ${name})
endif() endif()
endmacro() endmacro()
# Configure the current directory as a SingleSource subdirectory - i.e. every # Configure the current directory as a SingleSource subdirectory - i.e. every
# file in *.{c,cpp,cc} is treated as its own test. # file in *.{c,cpp,cc} is treated as its own test.
macro(llvm_singlesource) macro(llvm_singlesource)
cmake_parse_arguments(_LSARG "" "PREFIX;TARGET_VAR" "" ${ARGN}) cmake_parse_arguments(_LSARG "" "PREFIX;TARGET_VAR" "" ${ARGN})
unset(_llvm_singlesource_extra_args) unset(_llvm_singlesource_extra_args)
Show All 40 Lines