diff --git a/MicroBenchmarks/ImageProcessing/BilateralFiltering/CMakeLists.txt b/MicroBenchmarks/ImageProcessing/BilateralFiltering/CMakeLists.txt --- a/MicroBenchmarks/ImageProcessing/BilateralFiltering/CMakeLists.txt +++ b/MicroBenchmarks/ImageProcessing/BilateralFiltering/CMakeLists.txt @@ -2,6 +2,10 @@ list(APPEND CPPFLAGS -I ${CMAKE_SOURCE_DIR}/${IMAGEPROC_UTILS}) list(APPEND LDFLAGS -lm) +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + llvm_test_verify_hash_program_output(bilateralFilterOutput.txt) llvm_test_verify(WORKDIR ${CMAKE_CURRENT_BINARY_DIR} ${FPCMP} bilateralFilter.reference_output bilateralFilterOutput.txt diff --git a/MicroBenchmarks/ImageProcessing/Blur/CMakeLists.txt b/MicroBenchmarks/ImageProcessing/Blur/CMakeLists.txt --- a/MicroBenchmarks/ImageProcessing/Blur/CMakeLists.txt +++ b/MicroBenchmarks/ImageProcessing/Blur/CMakeLists.txt @@ -3,6 +3,10 @@ list(APPEND CPPFLAGS -I ${CMAKE_SOURCE_DIR}/${IMAGEPROC_UTILS}) list(APPEND LDFLAGS -lm) +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + llvm_test_verify_hash_program_output(boxBlurOutput.txt) llvm_test_verify(WORKDIR ${CMAKE_CURRENT_BINARY_DIR} ${FPCMP} boxBlur.reference_output boxBlurOutput.txt diff --git a/MultiSource/Applications/oggenc/CMakeLists.txt b/MultiSource/Applications/oggenc/CMakeLists.txt --- a/MultiSource/Applications/oggenc/CMakeLists.txt +++ b/MultiSource/Applications/oggenc/CMakeLists.txt @@ -1,4 +1,8 @@ list(APPEND CFLAGS -fno-strict-aliasing) +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + list(APPEND LDFLAGS -lm) set(RUN_OPTIONS -Q -s 901820 - < tune) llvm_multisource(oggenc) diff --git a/MultiSource/Benchmarks/DOE-ProxyApps-C++/CLAMR/CMakeLists.txt b/MultiSource/Benchmarks/DOE-ProxyApps-C++/CLAMR/CMakeLists.txt --- a/MultiSource/Benchmarks/DOE-ProxyApps-C++/CLAMR/CMakeLists.txt +++ b/MultiSource/Benchmarks/DOE-ProxyApps-C++/CLAMR/CMakeLists.txt @@ -1,2 +1,6 @@ set(RUN_OPTIONS -n 64 -t 1000) +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + llvm_multisource(CLAMR) diff --git a/MultiSource/Benchmarks/DOE-ProxyApps-C++/HPCCG/CMakeLists.txt b/MultiSource/Benchmarks/DOE-ProxyApps-C++/HPCCG/CMakeLists.txt --- a/MultiSource/Benchmarks/DOE-ProxyApps-C++/HPCCG/CMakeLists.txt +++ b/MultiSource/Benchmarks/DOE-ProxyApps-C++/HPCCG/CMakeLists.txt @@ -1,4 +1,8 @@ list(APPEND CXXFLAGS -DREDSTORM) # -DREDSTORM for mkdir +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + list(APPEND LDFLAGS -lm) set(RUN_OPTIONS 50 50 50) llvm_multisource(HPCCG) diff --git a/MultiSource/Benchmarks/DOE-ProxyApps-C++/miniFE/CMakeLists.txt b/MultiSource/Benchmarks/DOE-ProxyApps-C++/miniFE/CMakeLists.txt --- a/MultiSource/Benchmarks/DOE-ProxyApps-C++/miniFE/CMakeLists.txt +++ b/MultiSource/Benchmarks/DOE-ProxyApps-C++/miniFE/CMakeLists.txt @@ -6,6 +6,10 @@ if(CMAKE_SYSTEM_NAME STREQUAL "AIX") list(APPEND CXXFLAGS -D_XOPEN_SOURCE=700 -DUseTimes) endif() +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + list(APPEND LDFLAGS -lm) set(RUN_OPTIONS -nx 64 -ny 64 -nz 64) llvm_multisource(miniFE) diff --git a/MultiSource/Benchmarks/Rodinia/srad/CMakeLists.txt b/MultiSource/Benchmarks/Rodinia/srad/CMakeLists.txt --- a/MultiSource/Benchmarks/Rodinia/srad/CMakeLists.txt +++ b/MultiSource/Benchmarks/Rodinia/srad/CMakeLists.txt @@ -1,6 +1,10 @@ list(APPEND LDFLAGS -lm) set(FP_ABSTOLERANCE 0.00001) list(APPEND CFLAGS -I${CMAKE_CURRENT_SOURCE_DIR}/../Common) +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + llvm_multisource(srad main.c sradKernel.c diff --git a/SingleSource/Benchmarks/Linpack/CMakeLists.txt b/SingleSource/Benchmarks/Linpack/CMakeLists.txt --- a/SingleSource/Benchmarks/Linpack/CMakeLists.txt +++ b/SingleSource/Benchmarks/Linpack/CMakeLists.txt @@ -1,3 +1,7 @@ list(APPEND LDFLAGS -lm) set(FP_TOLERANCE 0.0001) +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + llvm_singlesource() diff --git a/SingleSource/Benchmarks/Misc-C++/Large/CMakeLists.txt b/SingleSource/Benchmarks/Misc-C++/Large/CMakeLists.txt --- a/SingleSource/Benchmarks/Misc-C++/Large/CMakeLists.txt +++ b/SingleSource/Benchmarks/Misc-C++/Large/CMakeLists.txt @@ -1,4 +1,8 @@ list(APPEND LDFLAGS -lm) set(FP_ABSTOLERANCE 0.01) set(HASH_PROGRAM_OUTPUT 1) +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + llvm_singlesource() diff --git a/SingleSource/Benchmarks/Polybench/datamining/correlation/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/datamining/correlation/CMakeLists.txt --- a/SingleSource/Benchmarks/Polybench/datamining/correlation/CMakeLists.txt +++ b/SingleSource/Benchmarks/Polybench/datamining/correlation/CMakeLists.txt @@ -3,6 +3,10 @@ if(SMALL_PROBLEM_SIZE) list(APPEND CFLAGS -DSMALL_DATASET) endif() +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + set(HASH_PROGRAM_OUTPUT 1) add_definitions(-DFP_ABSTOLERANCE=1e-5) llvm_singlesource() diff --git a/SingleSource/Benchmarks/Polybench/datamining/correlation/correlation.c b/SingleSource/Benchmarks/Polybench/datamining/correlation/correlation.c --- a/SingleSource/Benchmarks/Polybench/datamining/correlation/correlation.c +++ b/SingleSource/Benchmarks/Polybench/datamining/correlation/correlation.c @@ -121,6 +121,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_correlation_StrictFP(int m, int n, DATA_TYPE float_n, @@ -206,6 +210,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -217,7 +222,9 @@ DATA_TYPE float_n; POLYBENCH_2D_ARRAY_DECL(data,DATA_TYPE,M,N,m,n); POLYBENCH_2D_ARRAY_DECL(symmat,DATA_TYPE,M,M,m,m); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(symmat_StrictFP,DATA_TYPE,M,M,m,m); +#endif POLYBENCH_1D_ARRAY_DECL(mean,DATA_TYPE,M,m); POLYBENCH_1D_ARRAY_DECL(stddev,DATA_TYPE,M,m); @@ -238,6 +245,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(m, POLYBENCH_ARRAY(symmat))); +#else init_array (m, n, &float_n, POLYBENCH_ARRAY(data)); kernel_correlation (m, n, float_n, POLYBENCH_ARRAY(data), @@ -250,11 +262,14 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(m, POLYBENCH_ARRAY(symmat_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(data); POLYBENCH_FREE_ARRAY(symmat); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(symmat_StrictFP); +#endif POLYBENCH_FREE_ARRAY(mean); POLYBENCH_FREE_ARRAY(stddev); diff --git a/SingleSource/Benchmarks/Polybench/datamining/covariance/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/datamining/covariance/CMakeLists.txt --- a/SingleSource/Benchmarks/Polybench/datamining/covariance/CMakeLists.txt +++ b/SingleSource/Benchmarks/Polybench/datamining/covariance/CMakeLists.txt @@ -3,6 +3,10 @@ if(SMALL_PROBLEM_SIZE) list(APPEND CFLAGS -DSMALL_DATASET) endif() +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + set(HASH_PROGRAM_OUTPUT 1) add_definitions(-DFP_ABSTOLERANCE=1e-5) llvm_singlesource() diff --git a/SingleSource/Benchmarks/Polybench/datamining/covariance/covariance.c b/SingleSource/Benchmarks/Polybench/datamining/covariance/covariance.c --- a/SingleSource/Benchmarks/Polybench/datamining/covariance/covariance.c +++ b/SingleSource/Benchmarks/Polybench/datamining/covariance/covariance.c @@ -93,6 +93,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_covariance_StrictFP(int m, int n, DATA_TYPE float_n, @@ -152,6 +156,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -163,7 +168,9 @@ DATA_TYPE float_n; POLYBENCH_2D_ARRAY_DECL(data,DATA_TYPE,M,N,m,n); POLYBENCH_2D_ARRAY_DECL(symmat,DATA_TYPE,M,M,m,m); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(symmat_StrictFP,DATA_TYPE,M,M,m,m); +#endif POLYBENCH_1D_ARRAY_DECL(mean,DATA_TYPE,M,m); @@ -183,6 +190,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(m, POLYBENCH_ARRAY(symmat))); +#else init_array (m, n, &float_n, POLYBENCH_ARRAY(data)); kernel_covariance (m, n, float_n, POLYBENCH_ARRAY(data), @@ -194,11 +206,14 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(m, POLYBENCH_ARRAY(symmat_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(data); POLYBENCH_FREE_ARRAY(symmat); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(symmat_StrictFP); +#endif POLYBENCH_FREE_ARRAY(mean); return 0; diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c @@ -26,8 +26,11 @@ DATA_TYPE POLYBENCH_2D(A,NI,NK,ni,nl), DATA_TYPE POLYBENCH_2D(B,NK,NJ,nk,nj), DATA_TYPE POLYBENCH_2D(C,NL,NJ,nl,nj), - DATA_TYPE POLYBENCH_2D(D,NI,NL,ni,nl), - DATA_TYPE POLYBENCH_2D(D_StrictFP,NI,NL,ni,nl)) + DATA_TYPE POLYBENCH_2D(D,NI,NL,ni,nl) +#if !FMA_DISABLED + , DATA_TYPE POLYBENCH_2D(D_StrictFP,NI,NL,ni,nl) +#endif + ) { #pragma STDC FP_CONTRACT OFF int i, j; @@ -45,7 +48,10 @@ C[i][j] = ((DATA_TYPE) i*(j+3)) / nl; for (i = 0; i < ni; i++) for (j = 0; j < nl; j++) - D_StrictFP[i][j] = D[i][j] = ((DATA_TYPE) i*(j+2)) / nk; +#if !FMA_DISABLED + D_StrictFP[i][j] = +#endif + D[i][j] = ((DATA_TYPE) i*(j+2)) / nk; } @@ -101,6 +107,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_2mm_StrictFP(int ni, int nj, int nk, int nl, DATA_TYPE alpha, @@ -155,6 +165,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -172,15 +183,20 @@ POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NK,NJ,nk,nj); POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NL,NJ,nl,nj); POLYBENCH_2D_ARRAY_DECL(D,DATA_TYPE,NI,NL,ni,nl); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(D_StrictFP,DATA_TYPE,NI,NL,ni,nl); +#endif /* Initialize array(s). */ init_array (ni, nj, nk, nl, &alpha, &beta, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B), POLYBENCH_ARRAY(C), - POLYBENCH_ARRAY(D), - POLYBENCH_ARRAY(D_StrictFP)); + POLYBENCH_ARRAY(D) +#if !FMA_DISABLED + , POLYBENCH_ARRAY(D_StrictFP) +#endif + ); /* Start timer. */ polybench_start_instruments; @@ -198,6 +214,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(ni, nl, POLYBENCH_ARRAY(D))); +#else kernel_2mm_StrictFP(ni, nj, nk, nl, alpha, beta, POLYBENCH_ARRAY(tmp), @@ -212,6 +233,7 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(ni, nl, POLYBENCH_ARRAY(D_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(tmp); @@ -219,7 +241,9 @@ POLYBENCH_FREE_ARRAY(B); POLYBENCH_FREE_ARRAY(C); POLYBENCH_FREE_ARRAY(D); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(D_StrictFP); +#endif return 0; } diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/CMakeLists.txt --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/CMakeLists.txt +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/CMakeLists.txt @@ -5,4 +5,7 @@ endif() set(HASH_PROGRAM_OUTPUT 1) add_definitions(-DFP_ABSTOLERANCE=1e-5) +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) llvm_singlesource() diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/3mm.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/3mm.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/3mm.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/3mm.c @@ -105,6 +105,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_3mm_StrictFP(int ni, int nj, int nk, int nl, int nm, DATA_TYPE POLYBENCH_2D(E,NI,NJ,ni,nj), @@ -167,6 +171,7 @@ return 1; } +#endif int main(int argc, char** argv) { @@ -185,7 +190,9 @@ POLYBENCH_2D_ARRAY_DECL(C, DATA_TYPE, NJ, NM, nj, nm); POLYBENCH_2D_ARRAY_DECL(D, DATA_TYPE, NM, NL, nm, nl); POLYBENCH_2D_ARRAY_DECL(G, DATA_TYPE, NI, NL, ni, nl); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(G_StrictFP, DATA_TYPE, NI, NL, ni, nl); +#endif /* Initialize array(s). */ init_array (ni, nj, nk, nl, nm, @@ -211,6 +218,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(ni, nl, POLYBENCH_ARRAY(G))); +#else kernel_3mm_StrictFP(ni, nj, nk, nl, nm, POLYBENCH_ARRAY(E), POLYBENCH_ARRAY(A), @@ -225,6 +237,7 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(ni, nl, POLYBENCH_ARRAY(G_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(E); @@ -234,7 +247,9 @@ POLYBENCH_FREE_ARRAY(C); POLYBENCH_FREE_ARRAY(D); POLYBENCH_FREE_ARRAY(G); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(G_StrictFP); +#endif return 0; } diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/CMakeLists.txt --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/CMakeLists.txt +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/CMakeLists.txt @@ -5,4 +5,7 @@ endif() set(HASH_PROGRAM_OUTPUT 1) add_definitions(-DFP_ABSTOLERANCE=1e-5) +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) llvm_singlesource() diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/CMakeLists.txt --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/CMakeLists.txt +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/CMakeLists.txt @@ -2,4 +2,8 @@ list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) set(HASH_PROGRAM_OUTPUT 1) add_definitions(-DFP_ABSTOLERANCE=1e-5) +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + llvm_singlesource() diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/atax.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/atax.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/atax.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/atax.c @@ -77,6 +77,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_atax_StrictFP(int nx, int ny, DATA_TYPE POLYBENCH_2D(A,NX,NY,nx,ny), @@ -121,6 +125,7 @@ return 1; } +#endif int main(int argc, char** argv) { @@ -132,7 +137,9 @@ POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, NX, NY, nx, ny); POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, NY, ny); POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, NY, ny); +#if !FMA_DISABLED POLYBENCH_1D_ARRAY_DECL(y_StrictFP, DATA_TYPE, NY, ny); +#endif POLYBENCH_1D_ARRAY_DECL(tmp, DATA_TYPE, NX, nx); /* Initialize array(s). */ @@ -152,6 +159,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(nx, POLYBENCH_ARRAY(y))); +#else kernel_atax_StrictFP (nx, ny, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(x), @@ -163,12 +175,15 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(nx, POLYBENCH_ARRAY(y_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(x); POLYBENCH_FREE_ARRAY(y); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(y_StrictFP); +#endif POLYBENCH_FREE_ARRAY(tmp); return 0; diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/CMakeLists.txt --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/CMakeLists.txt +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/CMakeLists.txt @@ -2,4 +2,8 @@ list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) set(HASH_PROGRAM_OUTPUT 1) add_definitions(-DFP_ABSTOLERANCE=1e-5) +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + llvm_singlesource() diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/bicg.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/bicg.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/bicg.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/bicg.c @@ -90,6 +90,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_bicg_StrictFP(int nx, int ny, DATA_TYPE POLYBENCH_2D(A,NX,NY,nx,ny), @@ -137,6 +141,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -150,8 +155,10 @@ POLYBENCH_1D_ARRAY_DECL(q, DATA_TYPE, NX, nx); POLYBENCH_1D_ARRAY_DECL(p, DATA_TYPE, NY, ny); POLYBENCH_1D_ARRAY_DECL(r, DATA_TYPE, NX, nx); +#if !FMA_DISABLED POLYBENCH_1D_ARRAY_DECL(s_StrictFP, DATA_TYPE, NY, ny); POLYBENCH_1D_ARRAY_DECL(q_StrictFP, DATA_TYPE, NX, nx); +#endif /* Initialize array(s). */ init_array (nx, ny, @@ -174,6 +181,12 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(nx, ny, POLYBENCH_ARRAY(s), + POLYBENCH_ARRAY(q))); +#else kernel_bicg_StrictFP(nx, ny, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(s_StrictFP), @@ -190,6 +203,7 @@ by the function call in argument. */ polybench_prevent_dce(print_array(nx, ny, POLYBENCH_ARRAY(s_StrictFP), POLYBENCH_ARRAY(q_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(A); @@ -197,8 +211,10 @@ POLYBENCH_FREE_ARRAY(q); POLYBENCH_FREE_ARRAY(p); POLYBENCH_FREE_ARRAY(r); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(s_StrictFP); POLYBENCH_FREE_ARRAY(q_StrictFP); +#endif return 0; } diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/cholesky/cholesky.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/cholesky/cholesky.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/cholesky/cholesky.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/cholesky/cholesky.c @@ -22,8 +22,11 @@ static void init_array(int n, DATA_TYPE POLYBENCH_1D(p,N,n), - DATA_TYPE POLYBENCH_2D(A,N,N,n,n), - DATA_TYPE POLYBENCH_2D(A_StrictFP,N,N,n,n)) + DATA_TYPE POLYBENCH_2D(A,N,N,n,n) +#if !FMA_DISABLED + , DATA_TYPE POLYBENCH_2D(A_StrictFP,N,N,n,n) +#endif + ) { #pragma STDC FP_CONTRACT OFF int i, j; @@ -43,7 +46,10 @@ { p[i] = i + n; for (j = 0; j < n; j++) - A_StrictFP[i][j] = A[i][j] = j + n; +#if !FMA_DISABLED + A_StrictFP[i][j] = +#endif + A[i][j] = j + n; } } @@ -104,6 +110,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_cholesky_StrictFP(int n, DATA_TYPE POLYBENCH_1D(p,N,n), @@ -160,6 +170,7 @@ return 1; } +#endif int main(int argc, char** argv) { @@ -169,12 +180,17 @@ /* Variable declaration/allocation. */ POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); POLYBENCH_1D_ARRAY_DECL(p, DATA_TYPE, N, n); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(A_StrictFP, DATA_TYPE, N, N, n, n); +#endif /* Initialize array(s). */ - init_array (n, POLYBENCH_ARRAY(p), POLYBENCH_ARRAY(A), - POLYBENCH_ARRAY(A_StrictFP)); + init_array (n, POLYBENCH_ARRAY(p), POLYBENCH_ARRAY(A) +#if !FMA_DISABLED + , POLYBENCH_ARRAY(A_StrictFP) +#endif + ); /* Start timer. */ polybench_start_instruments; @@ -186,6 +202,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); +#else kernel_cholesky_StrictFP(n, POLYBENCH_ARRAY(p), POLYBENCH_ARRAY(A_StrictFP)); if (!check_FP(n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A_StrictFP))) return 1; @@ -193,10 +214,13 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(A); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(A_StrictFP); +#endif POLYBENCH_FREE_ARRAY(p); return 0; diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/doitgen.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/doitgen.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/doitgen.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/doitgen.c @@ -21,8 +21,10 @@ /* Array initialization. */ static void init_array(int nr, int nq, int np, - DATA_TYPE POLYBENCH_3D(A,NR,NQ,NP,nr,nq,np), - DATA_TYPE POLYBENCH_3D(A_StrictFP,NR,NQ,NP,nr,nq,np), + DATA_TYPE POLYBENCH_3D(A,NR,NQ,NP,nr,nq,np) +#if !FMA_DISABLED + , DATA_TYPE POLYBENCH_3D(A_StrictFP,NR,NQ,NP,nr,nq,np), +#endif DATA_TYPE POLYBENCH_2D(C4,NP,NP,np,np)) { #pragma STDC FP_CONTRACT OFF @@ -31,7 +33,10 @@ for (i = 0; i < nr; i++) for (j = 0; j < nq; j++) for (k = 0; k < np; k++) - A_StrictFP[i][j][k] = A[i][j][k] = ((DATA_TYPE) i*j + k) / np; +#if !FMA_DISABLED + A_StrictFP[i][j][k] = +#endif + A[i][j][k] = ((DATA_TYPE) i*j + k) / np; for (i = 0; i < np; i++) for (j = 0; j < np; j++) C4[i][j] = ((DATA_TYPE) i*j) / np; @@ -82,6 +87,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_doitgen_StrictFP(int nr, int nq, int np, DATA_TYPE POLYBENCH_3D(A,NR,NQ,NP,nr,nq,np), @@ -127,6 +136,7 @@ return 1; } +#endif int main(int argc, char** argv) { @@ -137,14 +147,18 @@ /* Variable declaration/allocation. */ POLYBENCH_3D_ARRAY_DECL(A,DATA_TYPE,NR,NQ,NP,nr,nq,np); +#if !FMA_DISABLED POLYBENCH_3D_ARRAY_DECL(A_StrictFP,DATA_TYPE,NR,NQ,NP,nr,nq,np); +#endif POLYBENCH_3D_ARRAY_DECL(sum,DATA_TYPE,NR,NQ,NP,nr,nq,np); POLYBENCH_2D_ARRAY_DECL(C4,DATA_TYPE,NP,NP,np,np); /* Initialize array(s). */ init_array (nr, nq, np, POLYBENCH_ARRAY(A), +#if !FMA_DISABLED POLYBENCH_ARRAY(A_StrictFP), +#endif POLYBENCH_ARRAY(C4)); /* Start timer. */ @@ -160,6 +174,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(nr, nq, np, POLYBENCH_ARRAY(A))); +#else kernel_doitgen_StrictFP(nr, nq, np, POLYBENCH_ARRAY(A_StrictFP), POLYBENCH_ARRAY(C4), @@ -171,10 +190,13 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(nr, nq, np, POLYBENCH_ARRAY(A_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(A); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(A_StrictFP); +#endif POLYBENCH_FREE_ARRAY(sum); POLYBENCH_FREE_ARRAY(C4); diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemm/gemm.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemm/gemm.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemm/gemm.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemm/gemm.c @@ -24,7 +24,9 @@ DATA_TYPE *alpha, DATA_TYPE *beta, DATA_TYPE POLYBENCH_2D(C,NI,NJ,ni,nj), +#if !FMA_DISABLED DATA_TYPE POLYBENCH_2D(C_StrictFP,NI,NJ,ni,nj), +#endif DATA_TYPE POLYBENCH_2D(A,NI,NK,ni,nk), DATA_TYPE POLYBENCH_2D(B,NK,NJ,nk,nj)) { @@ -35,7 +37,10 @@ *beta = 2123; for (i = 0; i < ni; i++) for (j = 0; j < nj; j++) - C_StrictFP[i][j] = C[i][j] = ((DATA_TYPE) i*j) / ni; +#if !FMA_DISABLED + C_StrictFP[i][j] = +#endif + C[i][j] = ((DATA_TYPE) i*j) / ni; for (i = 0; i < ni; i++) for (j = 0; j < nk; j++) A[i][j] = ((DATA_TYPE) i*j) / ni; @@ -88,6 +93,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_gemm_StrictFP(int ni, int nj, int nk, DATA_TYPE alpha, @@ -133,6 +142,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -145,14 +155,18 @@ DATA_TYPE alpha; DATA_TYPE beta; POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NJ,ni,nj); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(C_StrictFP,DATA_TYPE,NI,NJ,ni,nj); +#endif POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NK,ni,nk); POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NK,NJ,nk,nj); /* Initialize array(s). */ init_array (ni, nj, nk, &alpha, &beta, POLYBENCH_ARRAY(C), +#if !FMA_DISABLED POLYBENCH_ARRAY(C_StrictFP), +#endif POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); @@ -170,6 +184,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(ni, nj, POLYBENCH_ARRAY(C))); +#else kernel_gemm_StrictFP(ni, nj, nk, alpha, beta, POLYBENCH_ARRAY(C_StrictFP), @@ -181,10 +200,13 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(ni, nj, POLYBENCH_ARRAY(C_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(C); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(C_StrictFP); +#endif POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(B); diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/CMakeLists.txt --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/CMakeLists.txt +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/CMakeLists.txt @@ -2,4 +2,8 @@ list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) set(HASH_PROGRAM_OUTPUT 1) add_definitions(-DFP_ABSTOLERANCE=1e-5) +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + llvm_singlesource() diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/gemver.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/gemver.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/gemver.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/gemver.c @@ -29,7 +29,9 @@ DATA_TYPE POLYBENCH_1D(u2,N,n), DATA_TYPE POLYBENCH_1D(v2,N,n), DATA_TYPE POLYBENCH_1D(w,N,n), +#if !FMA_DISABLED DATA_TYPE POLYBENCH_1D(w_StrictFP,N,n), +#endif DATA_TYPE POLYBENCH_1D(y,N,n), DATA_TYPE POLYBENCH_1D(z,N,n)) { @@ -47,7 +49,10 @@ v2[i] = (i+1)/n/6.0; y[i] = (i+1)/n/8.0; z[i] = (i+1)/n/9.0; - w_StrictFP[i] = w[i] = 0.0; + w[i] = 0.0; +#if !FMA_DISABLED + w_StrictFP[i] = 0.0; +#endif for (j = 0; j < n; j++) A[i][j] = ((DATA_TYPE) i*j) / n; } @@ -109,6 +114,10 @@ #pragma endscop } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_gemver_StrictFP(int n, DATA_TYPE alpha, @@ -167,6 +176,7 @@ return 1; } +#endif int main(int argc, char** argv) { @@ -183,7 +193,9 @@ POLYBENCH_1D_ARRAY_DECL(u2, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(v2, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(w, DATA_TYPE, N, n); +#if !FMA_DISABLED POLYBENCH_1D_ARRAY_DECL(w_StrictFP, DATA_TYPE, N, n); +#endif POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(z, DATA_TYPE, N, n); @@ -197,7 +209,9 @@ POLYBENCH_ARRAY(u2), POLYBENCH_ARRAY(v2), POLYBENCH_ARRAY(w), +#if !FMA_DISABLED POLYBENCH_ARRAY(w_StrictFP), +#endif POLYBENCH_ARRAY(y), POLYBENCH_ARRAY(z)); @@ -221,6 +235,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(w))); +#else kernel_gemver_StrictFP(n, alpha, beta, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A_tmp), @@ -238,6 +257,7 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(w_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(A); @@ -247,7 +267,9 @@ POLYBENCH_FREE_ARRAY(u2); POLYBENCH_FREE_ARRAY(v2); POLYBENCH_FREE_ARRAY(w); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(w_StrictFP); +#endif POLYBENCH_FREE_ARRAY(x); POLYBENCH_FREE_ARRAY(y); POLYBENCH_FREE_ARRAY(z); diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/CMakeLists.txt --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/CMakeLists.txt +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/CMakeLists.txt @@ -3,6 +3,10 @@ if(SMALL_PROBLEM_SIZE) list(APPEND CFLAGS -DSMALL_DATASET) endif() +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + set(HASH_PROGRAM_OUTPUT 1) add_definitions(-DFP_ABSTOLERANCE=1e-5) llvm_singlesource() diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/gesummv.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/gesummv.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/gesummv.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/gesummv.c @@ -90,6 +90,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_gesummv_StrictFP(int n, DATA_TYPE alpha, @@ -138,6 +142,7 @@ return 1; } +#endif int main(int argc, char** argv) { @@ -152,7 +157,9 @@ POLYBENCH_1D_ARRAY_DECL(tmp, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, N, n); +#if !FMA_DISABLED POLYBENCH_1D_ARRAY_DECL(y_StrictFP, DATA_TYPE, N, n); +#endif /* Initialize array(s). */ @@ -176,6 +183,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(y))); +#else kernel_gesummv_StrictFP(n, alpha, beta, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B), @@ -188,6 +200,7 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(y_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(A); diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/mvt/mvt.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/mvt/mvt.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/mvt/mvt.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/mvt/mvt.c @@ -23,8 +23,10 @@ void init_array(int n, DATA_TYPE POLYBENCH_1D(x1,N,n), DATA_TYPE POLYBENCH_1D(x2,N,n), +#if !FMA_DISABLED DATA_TYPE POLYBENCH_1D(x1_StrictFP,N,n), DATA_TYPE POLYBENCH_1D(x2_StrictFP,N,n), +#endif DATA_TYPE POLYBENCH_1D(y_1,N,n), DATA_TYPE POLYBENCH_1D(y_2,N,n), DATA_TYPE POLYBENCH_2D(A,N,N,n,n)) @@ -34,8 +36,14 @@ for (i = 0; i < n; i++) { - x1_StrictFP[i] = x1[i] = ((DATA_TYPE) i) / n; - x2_StrictFP[i] = x2[i] = ((DATA_TYPE) i + 1) / n; +#if !FMA_DISABLED + x1_StrictFP[i] = +#endif + x1[i] = ((DATA_TYPE) i) / n; +#if !FMA_DISABLED + x2_StrictFP[i] = +#endif + x2[i] = ((DATA_TYPE) i + 1) / n; y_1[i] = ((DATA_TYPE) i + 3) / n; y_2[i] = ((DATA_TYPE) i + 4) / n; for (j = 0; j < n; j++) @@ -88,6 +96,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_mvt_StrictFP(int n, DATA_TYPE POLYBENCH_1D(x1,N,n), @@ -129,6 +141,7 @@ return 1; } +#endif int main(int argc, char** argv) { @@ -139,8 +152,10 @@ POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); POLYBENCH_1D_ARRAY_DECL(x1, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(x2, DATA_TYPE, N, n); +#if !FMA_DISABLED POLYBENCH_1D_ARRAY_DECL(x1_StrictFP, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(x2_StrictFP, DATA_TYPE, N, n); +#endif POLYBENCH_1D_ARRAY_DECL(y_1, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(y_2, DATA_TYPE, N, n); @@ -149,8 +164,10 @@ init_array (n, POLYBENCH_ARRAY(x1), POLYBENCH_ARRAY(x2), +#if !FMA_DISABLED POLYBENCH_ARRAY(x1_StrictFP), POLYBENCH_ARRAY(x2_StrictFP), +#endif POLYBENCH_ARRAY(y_1), POLYBENCH_ARRAY(y_2), POLYBENCH_ARRAY(A)); @@ -170,6 +187,12 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x1), + POLYBENCH_ARRAY(x2))); +#else kernel_mvt_StrictFP(n, POLYBENCH_ARRAY(x1_StrictFP), POLYBENCH_ARRAY(x2_StrictFP), @@ -185,13 +208,16 @@ by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x1_StrictFP), POLYBENCH_ARRAY(x2_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(x1); POLYBENCH_FREE_ARRAY(x2); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(x1_StrictFP); POLYBENCH_FREE_ARRAY(x2_StrictFP); +#endif POLYBENCH_FREE_ARRAY(y_1); POLYBENCH_FREE_ARRAY(y_2); diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/CMakeLists.txt --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/CMakeLists.txt +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/CMakeLists.txt @@ -3,6 +3,10 @@ if(SMALL_PROBLEM_SIZE) list(APPEND CFLAGS -DSMALL_DATASET) endif() +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + set(HASH_PROGRAM_OUTPUT 1) add_definitions(-DFP_ABSTOLERANCE=1e-5) llvm_singlesource() diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/symm.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/symm.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/symm.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/symm.c @@ -24,7 +24,9 @@ DATA_TYPE *alpha, DATA_TYPE *beta, DATA_TYPE POLYBENCH_2D(C,NI,NJ,ni,nj), +#if !FMA_DISABLED DATA_TYPE POLYBENCH_2D(C_StrictFP,NI,NJ,ni,nj), +#endif DATA_TYPE POLYBENCH_2D(A,NJ,NJ,nj,nj), DATA_TYPE POLYBENCH_2D(B,NI,NJ,ni,nj)) { @@ -35,7 +37,10 @@ *beta = 2123; for (i = 0; i < ni; i++) for (j = 0; j < nj; j++) { - C_StrictFP[i][j] = C[i][j] = ((DATA_TYPE) i*j) / ni; +#if !FMA_DISABLED + C_StrictFP[i][j] = +#endif + C[i][j] = ((DATA_TYPE) i*j) / ni; B[i][j] = ((DATA_TYPE) i*j) / ni; } for (i = 0; i < nj; i++) @@ -92,6 +97,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_symm_StrictFP(int ni, int nj, DATA_TYPE alpha, @@ -142,6 +151,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -153,14 +163,18 @@ DATA_TYPE alpha; DATA_TYPE beta; POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NJ,ni,nj); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(C_StrictFP,DATA_TYPE,NI,NJ,ni,nj); +#endif POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NJ,NJ,nj,nj); POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NI,NJ,ni,nj); /* Initialize array(s). */ init_array (ni, nj, &alpha, &beta, POLYBENCH_ARRAY(C), +#if !FMA_DISABLED POLYBENCH_ARRAY(C_StrictFP), +#endif POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); @@ -178,6 +192,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(ni, nj, POLYBENCH_ARRAY(C))); +#else kernel_symm_StrictFP(ni, nj, alpha, beta, POLYBENCH_ARRAY(C_StrictFP), @@ -189,10 +208,13 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(ni, nj, POLYBENCH_ARRAY(C_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(C); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(C_StrictFP); +#endif POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(B); diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syr2k/syr2k.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syr2k/syr2k.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syr2k/syr2k.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syr2k/syr2k.c @@ -24,7 +24,9 @@ DATA_TYPE *alpha, DATA_TYPE *beta, DATA_TYPE POLYBENCH_2D(C,NI,NI,ni,ni), +#if !FMA_DISABLED DATA_TYPE POLYBENCH_2D(C_StrictFP,NI,NI,ni,ni), +#endif DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj), DATA_TYPE POLYBENCH_2D(B,NI,NJ,ni,nj)) { @@ -40,7 +42,10 @@ } for (i = 0; i < ni; i++) for (j = 0; j < ni; j++) - C_StrictFP[i][j] = C[i][j] = ((DATA_TYPE) i*j) / ni; +#if !FMA_DISABLED + C_StrictFP[i][j] = +#endif + C[i][j] = ((DATA_TYPE) i*j) / ni; } @@ -90,6 +95,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_syr2k_StrictFP(int ni, int nj, DATA_TYPE alpha, @@ -138,6 +147,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -149,14 +159,18 @@ DATA_TYPE alpha; DATA_TYPE beta; POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NI,ni,ni); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(C_StrictFP,DATA_TYPE,NI,NI,ni,ni); +#endif POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NJ,ni,nj); POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NI,NJ,ni,nj); /* Initialize array(s). */ init_array (ni, nj, &alpha, &beta, POLYBENCH_ARRAY(C), +#if !FMA_DISABLED POLYBENCH_ARRAY(C_StrictFP), +#endif POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); @@ -174,6 +188,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(C))); +#else kernel_syr2k_StrictFP(ni, nj, alpha, beta, POLYBENCH_ARRAY(C_StrictFP), @@ -186,10 +205,13 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(C_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(C); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(C_StrictFP); +#endif POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(B); diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syrk/syrk.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syrk/syrk.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syrk/syrk.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syrk/syrk.c @@ -24,7 +24,9 @@ DATA_TYPE *alpha, DATA_TYPE *beta, DATA_TYPE POLYBENCH_2D(C,NI,NI,ni,ni), +#if !FMA_DISABLED DATA_TYPE POLYBENCH_2D(C_StrictFP,NI,NI,ni,ni), +#endif DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj)) { #pragma STDC FP_CONTRACT OFF @@ -37,7 +39,10 @@ A[i][j] = ((DATA_TYPE) i*j) / ni; for (i = 0; i < ni; i++) for (j = 0; j < ni; j++) - C_StrictFP[i][j] = C[i][j] = ((DATA_TYPE) i*j) / ni; +#if !FMA_DISABLED + C_StrictFP[i][j] = +#endif + C[i][j] = ((DATA_TYPE) i*j) / ni; } @@ -83,6 +88,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_syrk_StrictFP(int ni, int nj, DATA_TYPE alpha, @@ -127,6 +136,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -138,12 +148,17 @@ DATA_TYPE alpha; DATA_TYPE beta; POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NI,ni,ni); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(C_StrictFP,DATA_TYPE,NI,NI,ni,ni); +#endif POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NJ,ni,nj); /* Initialize array(s). */ init_array (ni, nj, &alpha, &beta, POLYBENCH_ARRAY(C), - POLYBENCH_ARRAY(C_StrictFP), POLYBENCH_ARRAY(A)); +#if !FMA_DISABLED + POLYBENCH_ARRAY(C_StrictFP), +#endif + POLYBENCH_ARRAY(A)); /* Start timer. */ polybench_start_instruments; @@ -155,6 +170,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(C))); +#else kernel_syrk_StrictFP(ni, nj, alpha, beta, POLYBENCH_ARRAY(C_StrictFP), POLYBENCH_ARRAY(A)); @@ -164,10 +184,13 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(C_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(C); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(C_StrictFP); +#endif POLYBENCH_FREE_ARRAY(A); return 0; diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/CMakeLists.txt --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/CMakeLists.txt +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/CMakeLists.txt @@ -1,5 +1,9 @@ set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) list(APPEND CFLAGS -I ${CMAKE_SOURCE_DIR}/${POLYBENCH_UTILS} -DPOLYBENCH_DUMP_ARRAYS) set(HASH_PROGRAM_OUTPUT 1) +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + add_definitions(-DFP_ABSTOLERANCE=1e-5) llvm_singlesource() diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/trisolv.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/trisolv.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/trisolv.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/trisolv.c @@ -23,7 +23,9 @@ void init_array(int n, DATA_TYPE POLYBENCH_2D(A,N,N,n,n), DATA_TYPE POLYBENCH_1D(x,N,n), +#if !FMA_DISABLED DATA_TYPE POLYBENCH_1D(x_StrictFP,N,n), +#endif DATA_TYPE POLYBENCH_1D(c,N,n)) { #pragma STDC FP_CONTRACT OFF @@ -42,7 +44,11 @@ */ for (i = 0; i < n; i++) { - c[i] = x_StrictFP[i] = x[i] = ((DATA_TYPE) i+n) / n; + c[i] = +#if !FMA_DISABLED + x_StrictFP[i] = +#endif + x[i] = ((DATA_TYPE) i+n) / n; for (j = 0; j < n; j++) A[i][j] = ((DATA_TYPE) i*j+n) / n; } @@ -88,6 +94,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_trisolv_StrictFP(int n, DATA_TYPE POLYBENCH_2D(A,N,N,n,n), @@ -128,6 +138,7 @@ return 1; } +#endif int main(int argc, char** argv) { @@ -137,13 +148,18 @@ /* Variable declaration/allocation. */ POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N, n); +#if !FMA_DISABLED POLYBENCH_1D_ARRAY_DECL(x_StrictFP, DATA_TYPE, N, n); +#endif POLYBENCH_1D_ARRAY_DECL(c, DATA_TYPE, N, n); /* Initialize array(s). */ init_array (n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(x), - POLYBENCH_ARRAY(x_StrictFP), POLYBENCH_ARRAY(c)); +#if !FMA_DISABLED + POLYBENCH_ARRAY(x_StrictFP), +#endif + POLYBENCH_ARRAY(c)); /* Start timer. */ polybench_start_instruments; @@ -155,16 +171,24 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x))); +#else kernel_trisolv (n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(x_StrictFP), POLYBENCH_ARRAY(c)); /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(x); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(x_StrictFP); +#endif POLYBENCH_FREE_ARRAY(c); return 0; diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/CMakeLists.txt --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/CMakeLists.txt +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/CMakeLists.txt @@ -3,6 +3,10 @@ if(SMALL_PROBLEM_SIZE) list(APPEND CFLAGS -DSMALL_DATASET) endif() +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + set(HASH_PROGRAM_OUTPUT 1) add_definitions(-DFP_ABSTOLERANCE=1e-5) llvm_singlesource() diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/trmm.c b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/trmm.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/trmm.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/trmm.c @@ -23,8 +23,11 @@ void init_array(int ni, DATA_TYPE *alpha, DATA_TYPE POLYBENCH_2D(A,NI,NI,ni,ni), - DATA_TYPE POLYBENCH_2D(B,NI,NI,ni,ni), - DATA_TYPE POLYBENCH_2D(B_StrictFP,NI,NI,ni,ni)) + DATA_TYPE POLYBENCH_2D(B,NI,NI,ni,ni) +#if !FMA_DISABLED + , DATA_TYPE POLYBENCH_2D(B_StrictFP,NI,NI,ni,ni) +#endif + ) { #pragma STDC FP_CONTRACT OFF int i, j; @@ -33,7 +36,10 @@ for (i = 0; i < ni; i++) for (j = 0; j < ni; j++) { A[i][j] = ((DATA_TYPE) i*j) / ni; - B_StrictFP[i][j] = B[i][j] = ((DATA_TYPE) i*j) / ni; +#if !FMA_DISABLED + B_StrictFP[i][j] = +#endif + B[i][j] = ((DATA_TYPE) i*j) / ni; } } @@ -76,6 +82,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_trmm_StrictFP(int ni, DATA_TYPE alpha, @@ -116,6 +126,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -126,11 +137,16 @@ DATA_TYPE alpha; POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NI,ni,ni); POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NI,NI,ni,ni); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(B_StrictFP,DATA_TYPE,NI,NI,ni,ni); +#endif /* Initialize array(s). */ - init_array (ni, &alpha, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B), - POLYBENCH_ARRAY(B_StrictFP)); + init_array (ni, &alpha, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B) +#if !FMA_DISABLED + , POLYBENCH_ARRAY(B_StrictFP) +#endif + ); /* Start timer. */ polybench_start_instruments; @@ -142,6 +158,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(B))); +#else kernel_trmm_StrictFP(ni, alpha, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B_StrictFP)); @@ -151,6 +172,7 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(B_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(A); diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/durbin/durbin.c b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/durbin/durbin.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/durbin/durbin.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/durbin/durbin.c @@ -92,6 +92,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_durbin_StrictFP(int n, DATA_TYPE POLYBENCH_2D(y,N,N,n,n), @@ -144,6 +148,7 @@ return 1; } +#endif int main(int argc, char** argv) { @@ -157,7 +162,9 @@ POLYBENCH_1D_ARRAY_DECL(beta, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(r, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(out, DATA_TYPE, N, n); +#if !FMA_DISABLED POLYBENCH_1D_ARRAY_DECL(out_StrictFP, DATA_TYPE, N, n); +#endif /* Initialize array(s). */ @@ -184,6 +191,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(out))); +#else init_array (n, POLYBENCH_ARRAY(y), POLYBENCH_ARRAY(sum), @@ -205,6 +217,7 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(out_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(y); diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/dynprog/dynprog.c b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/dynprog/dynprog.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/dynprog/dynprog.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/dynprog/dynprog.c @@ -81,6 +81,10 @@ *out = out_l; } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_dynprog_StrictFP(int tsteps, int length, DATA_TYPE POLYBENCH_2D(c,LENGTH,LENGTH,length,length), @@ -131,6 +135,7 @@ } return 1; } +#endif int main(int argc, char** argv) { @@ -139,7 +144,10 @@ int tsteps = TSTEPS; /* Variable declaration/allocation. */ - DATA_TYPE out, out_StrictFP; + DATA_TYPE out; +#if !FMA_DISABLED + DATA_TYPE out_StrictFP; +#endif POLYBENCH_3D_ARRAY_DECL(sum_c,DATA_TYPE,LENGTH,LENGTH,LENGTH,length,length,length); POLYBENCH_2D_ARRAY_DECL(c,DATA_TYPE,LENGTH,LENGTH,length,length); POLYBENCH_2D_ARRAY_DECL(W,DATA_TYPE,LENGTH,LENGTH,length,length); @@ -161,6 +169,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(out)); +#else init_array (length, POLYBENCH_ARRAY(c), POLYBENCH_ARRAY(W)); kernel_dynprog (tsteps, length, POLYBENCH_ARRAY(c), @@ -174,6 +187,7 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(out_StrictFP)); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(sum_c); diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/CMakeLists.txt --- a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/CMakeLists.txt +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/CMakeLists.txt @@ -3,6 +3,10 @@ if(SMALL_PROBLEM_SIZE) list(APPEND CFLAGS -DSMALL_DATASET) endif() +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + set(HASH_PROGRAM_OUTPUT 1) add_definitions(-DFP_ABSTOLERANCE=1e-5) llvm_singlesource() diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/gramschmidt.c b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/gramschmidt.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/gramschmidt.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/gramschmidt.c @@ -120,6 +120,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_gramschmidt_StrictFP(int ni, int nj, DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj), @@ -174,6 +178,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -185,9 +190,11 @@ POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NJ,ni,nj); POLYBENCH_2D_ARRAY_DECL(R,DATA_TYPE,NJ,NJ,nj,nj); POLYBENCH_2D_ARRAY_DECL(Q,DATA_TYPE,NI,NJ,ni,nj); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(A_StrictFP,DATA_TYPE,NI,NJ,ni,nj); POLYBENCH_2D_ARRAY_DECL(R_StrictFP,DATA_TYPE,NJ,NJ,nj,nj); POLYBENCH_2D_ARRAY_DECL(Q_StrictFP,DATA_TYPE,NI,NJ,ni,nj); +#endif /* Initialize array(s). */ init_array (ni, nj, @@ -208,6 +215,14 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(ni, nj, + POLYBENCH_ARRAY(A), + POLYBENCH_ARRAY(R), + POLYBENCH_ARRAY(Q))); +#else init_array (ni, nj, POLYBENCH_ARRAY(A_StrictFP), POLYBENCH_ARRAY(R_StrictFP), @@ -230,14 +245,17 @@ POLYBENCH_ARRAY(A_StrictFP), POLYBENCH_ARRAY(R_StrictFP), POLYBENCH_ARRAY(Q_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(R); POLYBENCH_FREE_ARRAY(Q); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(A_StrictFP); POLYBENCH_FREE_ARRAY(R_StrictFP); POLYBENCH_FREE_ARRAY(Q_StrictFP); +#endif return 0; } diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/lu/lu.c b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/lu/lu.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/lu/lu.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/lu/lu.c @@ -80,6 +80,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_lu_StrictFP(int n, DATA_TYPE POLYBENCH_2D(A,N,N,n,n)) @@ -127,6 +131,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -135,7 +140,9 @@ /* Variable declaration/allocation. */ POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(A_StrictFP, DATA_TYPE, N, N, n, n); +#endif /* Initialize array(s). */ init_array (n, POLYBENCH_ARRAY(A)); @@ -150,6 +157,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); +#else init_array (n, POLYBENCH_ARRAY(A_StrictFP)); kernel_lu (n, POLYBENCH_ARRAY(A_StrictFP)); if (!check_FP(n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A_StrictFP))) @@ -158,10 +170,13 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(A); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(A_StrictFP); +#endif return 0; } diff --git a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/ludcmp/ludcmp.c b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/ludcmp/ludcmp.c --- a/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/ludcmp/ludcmp.c +++ b/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/ludcmp/ludcmp.c @@ -109,6 +109,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_ludcmp_StrictFP(int n, DATA_TYPE POLYBENCH_2D(A,N+1,N+1,n+1,n+1), @@ -179,6 +183,7 @@ return 1; } +#endif int main(int argc, char** argv) { @@ -189,7 +194,9 @@ POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N+1, N+1, n+1, n+1); POLYBENCH_1D_ARRAY_DECL(b, DATA_TYPE, N+1, n+1); POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N+1, n+1); +#if !FMA_DISABLED POLYBENCH_1D_ARRAY_DECL(x_StrictFP, DATA_TYPE, N+1, n+1); +#endif POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, N+1, n+1); @@ -214,6 +221,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(X))); +#else init_array (n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(b), @@ -230,12 +242,15 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(b); POLYBENCH_FREE_ARRAY(x); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(x_StrictFP); +#endif POLYBENCH_FREE_ARRAY(y); return 0; diff --git a/SingleSource/Benchmarks/Polybench/medley/floyd-warshall/floyd-warshall.c b/SingleSource/Benchmarks/Polybench/medley/floyd-warshall/floyd-warshall.c --- a/SingleSource/Benchmarks/Polybench/medley/floyd-warshall/floyd-warshall.c +++ b/SingleSource/Benchmarks/Polybench/medley/floyd-warshall/floyd-warshall.c @@ -71,6 +71,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_floyd_warshall_StrictFP(int n, DATA_TYPE POLYBENCH_2D(path,N,N,n,n)) { @@ -110,6 +114,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -118,7 +123,9 @@ /* Variable declaration/allocation. */ POLYBENCH_2D_ARRAY_DECL(path, DATA_TYPE, N, N, n, n); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(path_StrictFP, DATA_TYPE, N, N, n, n); +#endif /* Initialize array(s). */ init_array (n, POLYBENCH_ARRAY(path)); @@ -133,6 +140,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(path))); +#else init_array (n, POLYBENCH_ARRAY(path_StrictFP)); kernel_floyd_warshall_StrictFP(n, POLYBENCH_ARRAY(path_StrictFP)); if (!check_FP(n, POLYBENCH_ARRAY(path), POLYBENCH_ARRAY(path_StrictFP))) @@ -141,10 +153,13 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(path_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(path); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(path_StrictFP); +#endif return 0; } diff --git a/SingleSource/Benchmarks/Polybench/medley/reg_detect/reg_detect.c b/SingleSource/Benchmarks/Polybench/medley/reg_detect/reg_detect.c --- a/SingleSource/Benchmarks/Polybench/medley/reg_detect/reg_detect.c +++ b/SingleSource/Benchmarks/Polybench/medley/reg_detect/reg_detect.c @@ -100,6 +100,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_reg_detect_StrictFP(int niter, int maxgrid, int length, DATA_TYPE POLYBENCH_2D(sum_tang,MAXGRID,MAXGRID,maxgrid,maxgrid), @@ -162,6 +166,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -174,7 +179,9 @@ POLYBENCH_2D_ARRAY_DECL(sum_tang, DATA_TYPE, MAXGRID, MAXGRID, maxgrid, maxgrid); POLYBENCH_2D_ARRAY_DECL(mean, DATA_TYPE, MAXGRID, MAXGRID, maxgrid, maxgrid); POLYBENCH_2D_ARRAY_DECL(path, DATA_TYPE, MAXGRID, MAXGRID, maxgrid, maxgrid); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(path_StrictFP, DATA_TYPE, MAXGRID, MAXGRID, maxgrid, maxgrid); +#endif POLYBENCH_3D_ARRAY_DECL(diff, DATA_TYPE, MAXGRID, MAXGRID, LENGTH, maxgrid, maxgrid, length); POLYBENCH_3D_ARRAY_DECL(sum_diff, DATA_TYPE, MAXGRID, MAXGRID, LENGTH, maxgrid, maxgrid, length); @@ -199,6 +206,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(maxgrid, POLYBENCH_ARRAY(path))); +#else init_array (maxgrid, POLYBENCH_ARRAY(sum_tang), POLYBENCH_ARRAY(mean), @@ -215,12 +227,15 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(maxgrid, POLYBENCH_ARRAY(path_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(sum_tang); POLYBENCH_FREE_ARRAY(mean); POLYBENCH_FREE_ARRAY(path); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(path_StrictFP); +#endif POLYBENCH_FREE_ARRAY(diff); POLYBENCH_FREE_ARRAY(sum_diff); diff --git a/SingleSource/Benchmarks/Polybench/stencils/adi/CMakeLists.txt b/SingleSource/Benchmarks/Polybench/stencils/adi/CMakeLists.txt --- a/SingleSource/Benchmarks/Polybench/stencils/adi/CMakeLists.txt +++ b/SingleSource/Benchmarks/Polybench/stencils/adi/CMakeLists.txt @@ -3,6 +3,10 @@ if(SMALL_PROBLEM_SIZE) list(APPEND CFLAGS -DSMALL_DATASET) endif() +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) + set(HASH_PROGRAM_OUTPUT 1) add_definitions(-DFP_ABSTOLERANCE=1e-5) llvm_singlesource() diff --git a/SingleSource/Benchmarks/Polybench/stencils/adi/adi.c b/SingleSource/Benchmarks/Polybench/stencils/adi/adi.c --- a/SingleSource/Benchmarks/Polybench/stencils/adi/adi.c +++ b/SingleSource/Benchmarks/Polybench/stencils/adi/adi.c @@ -102,6 +102,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_adi_StrictFP(int tsteps, int n, @@ -167,6 +171,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -176,7 +181,9 @@ /* Variable declaration/allocation. */ POLYBENCH_2D_ARRAY_DECL(X, DATA_TYPE, N, N, n, n); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(X_StrictFP, DATA_TYPE, N, N, n, n); +#endif POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(B, DATA_TYPE, N, N, n, n); @@ -195,6 +202,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(X))); +#else init_array (n, POLYBENCH_ARRAY(X_StrictFP), POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); kernel_adi (tsteps, n, POLYBENCH_ARRAY(X_StrictFP), @@ -205,10 +217,13 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(X_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(X); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(X_StrictFP); +#endif POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(B); diff --git a/SingleSource/Benchmarks/Polybench/stencils/fdtd-2d/fdtd-2d.c b/SingleSource/Benchmarks/Polybench/stencils/fdtd-2d/fdtd-2d.c --- a/SingleSource/Benchmarks/Polybench/stencils/fdtd-2d/fdtd-2d.c +++ b/SingleSource/Benchmarks/Polybench/stencils/fdtd-2d/fdtd-2d.c @@ -104,6 +104,10 @@ #pragma endscop } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_fdtd_2d_StrictFP(int tmax, int nx, @@ -157,6 +161,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -169,9 +174,11 @@ POLYBENCH_2D_ARRAY_DECL(ex,DATA_TYPE,NX,NY,nx,ny); POLYBENCH_2D_ARRAY_DECL(ey,DATA_TYPE,NX,NY,nx,ny); POLYBENCH_2D_ARRAY_DECL(hz,DATA_TYPE,NX,NY,nx,ny); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(ex_StrictFP,DATA_TYPE,NX,NY,nx,ny); POLYBENCH_2D_ARRAY_DECL(ey_StrictFP,DATA_TYPE,NX,NY,nx,ny); POLYBENCH_2D_ARRAY_DECL(hz_StrictFP,DATA_TYPE,NX,NY,nx,ny); +#endif POLYBENCH_1D_ARRAY_DECL(_fict_,DATA_TYPE,TMAX,tmax); /* Initialize array(s). */ @@ -196,6 +203,13 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(nx, ny, POLYBENCH_ARRAY(ex), + POLYBENCH_ARRAY(ey), + POLYBENCH_ARRAY(hz))); +#else init_array (tmax, nx, ny, POLYBENCH_ARRAY(ex_StrictFP), POLYBENCH_ARRAY(ey_StrictFP), @@ -212,14 +226,17 @@ polybench_prevent_dce(print_array(nx, ny, POLYBENCH_ARRAY(ex_StrictFP), POLYBENCH_ARRAY(ey_StrictFP), POLYBENCH_ARRAY(hz_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(ex); POLYBENCH_FREE_ARRAY(ey); POLYBENCH_FREE_ARRAY(hz); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(ex_StrictFP); POLYBENCH_FREE_ARRAY(ey_StrictFP); POLYBENCH_FREE_ARRAY(hz_StrictFP); +#endif POLYBENCH_FREE_ARRAY(_fict_); return 0; diff --git a/SingleSource/Benchmarks/Polybench/stencils/fdtd-apml/fdtd-apml.c b/SingleSource/Benchmarks/Polybench/stencils/fdtd-apml/fdtd-apml.c --- a/SingleSource/Benchmarks/Polybench/stencils/fdtd-apml/fdtd-apml.c +++ b/SingleSource/Benchmarks/Polybench/stencils/fdtd-apml/fdtd-apml.c @@ -166,6 +166,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_fdtd_apml_StrictFP(int cz, int cxm, @@ -253,6 +257,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -272,10 +277,12 @@ POLYBENCH_3D_ARRAY_DECL(Ex,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); POLYBENCH_3D_ARRAY_DECL(Ey,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); POLYBENCH_3D_ARRAY_DECL(Hz,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); +#if !FMA_DISABLED POLYBENCH_3D_ARRAY_DECL(Bza_StrictFP,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); POLYBENCH_3D_ARRAY_DECL(Ex_StrictFP,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); POLYBENCH_3D_ARRAY_DECL(Ey_StrictFP,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); POLYBENCH_3D_ARRAY_DECL(Hz_StrictFP,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); +#endif POLYBENCH_1D_ARRAY_DECL(czm,DATA_TYPE,CZ+1,cz+1); POLYBENCH_1D_ARRAY_DECL(czp,DATA_TYPE,CZ+1,cz+1); POLYBENCH_1D_ARRAY_DECL(cxmh,DATA_TYPE,CXM+1,cxm+1); @@ -321,6 +328,15 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(cz, cxm, cym, + POLYBENCH_ARRAY(Bza), + POLYBENCH_ARRAY(Ex), + POLYBENCH_ARRAY(Ey), + POLYBENCH_ARRAY(Hz))); +#else init_array (cz, cxm, cym, &mui, &ch, POLYBENCH_ARRAY(Ax), POLYBENCH_ARRAY(Ry), @@ -364,6 +380,7 @@ POLYBENCH_ARRAY(Ex_StrictFP), POLYBENCH_ARRAY(Ey_StrictFP), POLYBENCH_ARRAY(Hz_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(Ax); @@ -374,10 +391,12 @@ POLYBENCH_FREE_ARRAY(Ex); POLYBENCH_FREE_ARRAY(Ey); POLYBENCH_FREE_ARRAY(Hz); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(Bza_StrictFP); POLYBENCH_FREE_ARRAY(Ex_StrictFP); POLYBENCH_FREE_ARRAY(Ey_StrictFP); POLYBENCH_FREE_ARRAY(Hz_StrictFP); +#endif POLYBENCH_FREE_ARRAY(czm); POLYBENCH_FREE_ARRAY(czp); POLYBENCH_FREE_ARRAY(cxmh); diff --git a/SingleSource/Benchmarks/Polybench/stencils/jacobi-1d-imper/jacobi-1d-imper.c b/SingleSource/Benchmarks/Polybench/stencils/jacobi-1d-imper/jacobi-1d-imper.c --- a/SingleSource/Benchmarks/Polybench/stencils/jacobi-1d-imper/jacobi-1d-imper.c +++ b/SingleSource/Benchmarks/Polybench/stencils/jacobi-1d-imper/jacobi-1d-imper.c @@ -74,6 +74,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_jacobi_1d_imper_StrictFP(int tsteps, int n, @@ -114,6 +118,7 @@ return 1; } +#endif int main(int argc, char** argv) { @@ -123,7 +128,9 @@ /* Variable declaration/allocation. */ POLYBENCH_1D_ARRAY_DECL(A, DATA_TYPE, N, n); +#if !FMA_DISABLED POLYBENCH_1D_ARRAY_DECL(A_StrictFP, DATA_TYPE, N, n); +#endif POLYBENCH_1D_ARRAY_DECL(B, DATA_TYPE, N, n); @@ -140,6 +147,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); +#else init_array (n, POLYBENCH_ARRAY(A_StrictFP), POLYBENCH_ARRAY(B)); kernel_jacobi_1d_imper (tsteps, n, POLYBENCH_ARRAY(A_StrictFP), POLYBENCH_ARRAY(B)); @@ -149,6 +161,7 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(A); diff --git a/SingleSource/Benchmarks/Polybench/stencils/jacobi-2d-imper/jacobi-2d-imper.c b/SingleSource/Benchmarks/Polybench/stencils/jacobi-2d-imper/jacobi-2d-imper.c --- a/SingleSource/Benchmarks/Polybench/stencils/jacobi-2d-imper/jacobi-2d-imper.c +++ b/SingleSource/Benchmarks/Polybench/stencils/jacobi-2d-imper/jacobi-2d-imper.c @@ -79,6 +79,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_jacobi_2d_imper_StrictFP(int tsteps, int n, @@ -123,6 +127,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -132,7 +137,9 @@ /* Variable declaration/allocation. */ POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(A_StrictFP, DATA_TYPE, N, N, n, n); +#endif POLYBENCH_2D_ARRAY_DECL(B, DATA_TYPE, N, N, n, n); @@ -149,6 +156,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); +#else init_array (n, POLYBENCH_ARRAY(A_StrictFP), POLYBENCH_ARRAY(B)); kernel_jacobi_2d_imper_StrictFP(tsteps, n, POLYBENCH_ARRAY(A_StrictFP), POLYBENCH_ARRAY(B)); @@ -158,10 +170,13 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(A); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(A_StrictFP); +#endif POLYBENCH_FREE_ARRAY(B); return 0; diff --git a/SingleSource/Benchmarks/Polybench/stencils/seidel-2d/seidel-2d.c b/SingleSource/Benchmarks/Polybench/stencils/seidel-2d/seidel-2d.c --- a/SingleSource/Benchmarks/Polybench/stencils/seidel-2d/seidel-2d.c +++ b/SingleSource/Benchmarks/Polybench/stencils/seidel-2d/seidel-2d.c @@ -71,6 +71,10 @@ } +#if !FMA_DISABLED +// NOTE: FMA_DISABLED is true for targets where FMA contraction causes +// discrepancies which cause the accuracy checks to fail. +// In this case, the test runs with the option -ffp-contract=off static void kernel_seidel_2d_StrictFP(int tsteps, int n, @@ -111,6 +115,7 @@ /* All elements are within the allowed FP_ABSTOLERANCE error margin. */ return 1; } +#endif int main(int argc, char** argv) { @@ -120,7 +125,9 @@ /* Variable declaration/allocation. */ POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); +#if !FMA_DISABLED POLYBENCH_2D_ARRAY_DECL(A_StrictFP, DATA_TYPE, N, N, n, n); +#endif /* Initialize array(s). */ @@ -136,6 +143,11 @@ polybench_stop_instruments; polybench_print_instruments; +#if FMA_DISABLED + /* Prevent dead-code elimination. All live-out data must be printed + by the function call in argument. */ + polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); +#else init_array (n, POLYBENCH_ARRAY(A_StrictFP)); kernel_seidel_2d (tsteps, n, POLYBENCH_ARRAY(A_StrictFP)); @@ -145,10 +157,13 @@ /* Prevent dead-code elimination. All live-out data must be printed by the function call in argument. */ polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A_StrictFP))); +#endif /* Be clean. */ POLYBENCH_FREE_ARRAY(A); +#if !FMA_DISABLED POLYBENCH_FREE_ARRAY(A_StrictFP); +#endif return 0; } diff --git a/SingleSource/UnitTests/Vector/SSE/CMakeLists.txt b/SingleSource/UnitTests/Vector/SSE/CMakeLists.txt --- a/SingleSource/UnitTests/Vector/SSE/CMakeLists.txt +++ b/SingleSource/UnitTests/Vector/SSE/CMakeLists.txt @@ -2,4 +2,7 @@ list(APPEND LDFLAGS -lm) list(APPEND TARGET_FLAGS -msse2) list(APPEND LCCFLAGS -msse2) +# Floating point contraction must be suppressed due to accuracy issues +list(APPEND CXXFLAGS -ffp-contract=off -DFMA_DISABLED=1) +list(APPEND CFLAGS -ffp-contract=off -DFMA_DISABLED=1) llvm_singlesource(PREFIX "Vector-")