This is an archive of the discontinued LLVM Phabricator instance.

Differential D25346

[test-suite] [Polybench] run tests twice with -ffp-contract=on/off
ClosedPublic

Authored by sebpop on Oct 6 2016, 1:58 PM.

Details

Reviewers
rengolin
grosser
MatzeB
Commits
rOLDT284334: [polybench] check against strict fp
rL284334: [polybench] check against strict fp
Summary

This patch implements the idea that I posted as a reply to Matthias on D25277:
On Wed, Oct 5, 2016 at 5:33 PM, Matthias Braun <matze@braunis.de> wrote:

I was mainly wondering here whether there may be a sensible generic mechanism to combine a list of floatingpoint numbers

For all the tests in the polybench, I think we can do bisimulation.
What I mean by bisimulation is that we would copy the kernel()
function of each polybench/test.c and name it kernelNoFP() and add
flag attributes "-fno-fast-math -ffp-contract=off" (can be split
compilation if flag attributes do not work.)
main() will call kernel() and kernelNoFP() and compare their output
with FP_TOLERANCE.
Only the execution of kernel() will be timed for benchmark performance result.
main() will only print the output from kernelNoFP() that will be
hashed and compared against the reference hash (as we currently expect
exact match of the output hash.)

The good things:

  • no modifications to CMake and Makefiles
  • no extra space to store the extra reference output
  • tests both user CFLAGS specified mode and fast-math and fp-contraction=off.

The bad things: (because of the extra reference run of kernelNoFP())

  • compilation time will double: e.g., Polly will optimize both kernels,
  • memory requirements on the device will almost double: added one

extra output array, input arrays are not modified, so no need to
duplicate them,

  • compute time on the device will more than double: running the kernel

twice, plus an extra loop over both outputs to compare with
FP_TOLERANCE.

Diff Detail

Repository
rL LLVM

Event Timeline

sebpop updated this revision to Diff 73849.Oct 6 2016, 1:58 PM
sebpop retitled this revision from to [test-suite] [Polybench] run tests twice with -ffp-contract=on/off.
sebpop updated this object.
sebpop added reviewers: grosser, rengolin, MatzeB.
sebpop added subscribers: llvm-commits, Abe.
rengolin requested changes to this revision.Oct 7 2016, 2:19 AM
rengolin edited edge metadata.
rengolin added inline comments.
SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c
116 ↗(On Diff #73849)

sigh... We've been over this...

This revision now requires changes to proceed.Oct 7 2016, 2:19 AM
sebpop added inline comments.Oct 7 2016, 2:23 AM
SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c
116 ↗(On Diff #73849)

What do you mean we've been over this? Please be more precise in your review.

I hope you do understand that this pragma only applies to the current function.
The test is thus testing both modes: kernel_2mm() tests with fp-contract=on and kernel_2mm_StrictFP tests with fp-contract=off.

rengolin added a comment.Oct 7 2016, 2:25 AM

What I mean by bisimulation is that we would copy the kernel()
function of each polybench/test.c and name it kernelNoFP() and add
flag attributes "-fno-fast-math -ffp-contract=off" (can be split
compilation if flag attributes do not work.)
main() will call kernel() and kernelNoFP() and compare their output
with FP_TOLERANCE.
Only the execution of kernel() will be timed for benchmark performance result.
main() will only print the output from kernelNoFP() that will be
hashed and compared against the reference hash (as we currently expect
exact match of the output hash.)

So, the end result is that we'll *test* what we don't ship and we'll *benchmark* what we don't test.

Meaning we'll have green bots and fast benchmarks, but we'll have no idea if the "fast" is correct of if the correct is fast.

--renato

rengolin added inline comments.Oct 7 2016, 2:29 AM
SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c
30 ↗(On Diff #73849)

clang-format

114 ↗(On Diff #73849)

clang format

132 ↗(On Diff #73849)

clang format

181 ↗(On Diff #73849)

clang format

205 ↗(On Diff #73849)

clang-format

rengolin added inline comments.Oct 7 2016, 2:33 AM
SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c
140 ↗(On Diff #73849)

why do you need the pragma here, too?

146 ↗(On Diff #73849)

If this has to be defined at compilation time, do we need to re-refine here? Maybe it's better to get a compilation error, to make sure the users know what they're getting.

208 ↗(On Diff #73849)

Why not do this to all arrays, not just D?

sebpop added a comment.Oct 7 2016, 2:34 AM
In D25346#564218, @rengolin wrote:

What I mean by bisimulation is that we would copy the kernel()
function of each polybench/test.c and name it kernelNoFP() and add
flag attributes "-fno-fast-math -ffp-contract=off" (can be split
compilation if flag attributes do not work.)
main() will call kernel() and kernelNoFP() and compare their output
with FP_TOLERANCE.
Only the execution of kernel() will be timed for benchmark performance result.
main() will only print the output from kernelNoFP() that will be
hashed and compared against the reference hash (as we currently expect
exact match of the output hash.)

So, the end result is that we'll *test* what we don't ship and we'll *benchmark* what we don't test.

Meaning we'll have green bots and fast benchmarks, but we'll have no idea if the "fast" is correct of if the correct is fast.

This statement is false.

kernel() is compiled with whatever Cflags are specified by the end user of the test-suite.
The output of kernel() is matched with FP_TOLERANCE against the output of kernel_Strict_FP().
The output of kernel_Strict_FP() is hashed and compared against reference output.

kernel() is timed, as this will be what the end-user of the test-suite asked for "-O0", or "-Ofast -polly", or any other combination.

sebpop added a comment.Oct 7 2016, 2:35 AM

clang-format

No. Not in the test-suite. We do not own that code, and I will not run clang-format on all the tests in the test-suite.

sebpop added inline comments.Oct 7 2016, 2:40 AM
SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c
140 ↗(On Diff #73849)

Maybe adding the pragma here is "overkill", and would have no effects.
Thanks for pointing out.

146 ↗(On Diff #73849)

This is a quick "get it done" define. Of course, I will modify the patch to add -DFP_ABSTOLERANCE from the CMake/Makefile to the C compilation, as the previous comment suggests.

208 ↗(On Diff #73849)

D is the only output of this test.
The other arrays are input, and input does not change.

rengolin added a comment.Oct 7 2016, 2:41 AM
In D25346#564231, @sebpop wrote:

clang-format

No. Not in the test-suite. We do not own that code, and I will not run clang-format on all the tests in the test-suite.

Not in the whole test, just in your changes. You're probably using TABS or something, and the formatting is coming wrong. Please look at the result in this page and you'll see.

sebpop added a comment.Oct 7 2016, 2:46 AM
In D25346#564243, @rengolin wrote:
In D25346#564231, @sebpop wrote:

clang-format

No. Not in the test-suite. We do not own that code, and I will not run clang-format on all the tests in the test-suite.

Not in the whole test, just in your changes. You're probably using TABS or something, and the formatting is coming wrong. Please look at the result in this page and you'll see.

I will run clang-format-patch on the changes in the patch.

rengolin added inline comments.Oct 7 2016, 2:49 AM
SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c
146 ↗(On Diff #73849)

I see. Are you adding the Makefile changes to this patch later?

208 ↗(On Diff #73849)

what about the rest of the output?

sebpop added inline comments.Oct 7 2016, 2:55 AM
SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c
146 ↗(On Diff #73849)

Yes, if we agree that this is the way to go forward, I will finish up the patch adding for each polybench this kind of change, and the Makefiles and CMake will be amended to add -DFP_{ABS}TOLERANCE to CFLAGS.

208 ↗(On Diff #73849)

Please help me here: which other output?

See the comment in the lines just below:

All live-out data must be printed
by the function call in argument. */

D is the only output of this benchmark (to my knowledge.)

rengolin added a comment.Oct 7 2016, 3:18 AM
In D25346#564230, @sebpop wrote:

kernel() is compiled with whatever Cflags are specified by the end user of the test-suite.
The output of kernel() is matched with FP_TOLERANCE against the output of kernel_Strict_FP().
The output of kernel_Strict_FP() is hashed and compared against reference output.

Right, now I get it. So, you basically just duplicated the kernel to force FP=OFF on the second. Then you compare against the *real* timed run for FP_TOLERANCE.

This should work as intended, I imagine, but would that scale to *all* problematic benchmarks? If there are 50 of them, duplicating all the cores may bring more problems than solving...

sebpop added a comment.Oct 7 2016, 3:32 AM
In D25346#564282, @rengolin wrote:
In D25346#564230, @sebpop wrote:

kernel() is compiled with whatever Cflags are specified by the end user of the test-suite.
The output of kernel() is matched with FP_TOLERANCE against the output of kernel_Strict_FP().
The output of kernel_Strict_FP() is hashed and compared against reference output.

Right, now I get it. So, you basically just duplicated the kernel to force FP=OFF on the second. Then you compare against the *real* timed run for FP_TOLERANCE.

Correct.

This should work as intended, I imagine, but would that scale to *all* problematic benchmarks? If there are 50 of them, duplicating all the cores may bring more problems than solving...

As I was mentioning, this is intended only for the Polybench, that are following a pretty regular pattern of testing loop kernels.
The patch makes 2mm run correctly for CFLAGS="", "-Ofast", and "-O3 -ffp-contract=on".
I have not looked at the other failing benchmarks to say whether this can apply to those.
I know that oggenc would be impossible to modify like this.

There are also these resource problems I was mentioning:

  • compilation time will double: e.g., Polly will optimize both kernels,
  • memory requirements on the device will almost double: added one extra output array, input arrays are not modified, so no need to duplicate them,
  • compute time on the device will more than double: running the kernel twice, plus an extra loop over both outputs to compare with FP_TOLERANCE.

Not perfect, though it will give us some extra FP tests that we can run at -Ofast and other flags that need FP_TOLERANCE testing.

rengolin added a comment.Oct 7 2016, 4:29 AM
In D25346#564284, @sebpop wrote:

As I was mentioning, this is intended only for the Polybench, that are following a pretty regular pattern of testing loop kernels.
The patch makes 2mm run correctly for CFLAGS="", "-Ofast", and "-O3 -ffp-contract=on".
I have not looked at the other failing benchmarks to say whether this can apply to those.
I know that oggenc would be impossible to modify like this.

Right. Abe was trying to change the Make/CMake files, which could be a one-size-fits-all solution. If that works, I think we should go with that.

There are also these resource problems I was mentioning:

  • compilation time will double: e.g., Polly will optimize both kernels,
  • compute time on the device will more than double: running the kernel twice, plus an extra loop over both outputs to compare with FP_TOLERANCE.

Those two are true for all solutions we can come up with. 2mm takes 100s on ARM and 3mm takes 150s. Doubling ~50 could make it several minutes longer.

You were proposing getting something running first, then change later, but with a tolerance of 0.0001 after all aggregations, I think we could have FP=on and that tolerance in fpcmp and just run the default as a first approach, then later expand the FP=off compare.

Of course, that only works if the tolerance is low enough on all 50.

  • memory requirements on the device will almost double: added one extra output array, input arrays are not modified, so no need to duplicate them,

Abe's solution wouldn't incur in additional memory consumption, but it would take longer to prepare/compile/run two completely different models of the same benchmark.

cheers,
--renato

sebpop added a comment.Oct 7 2016, 5:17 AM
In D25346#564313, @rengolin wrote:
In D25346#564284, @sebpop wrote:

As I was mentioning, this is intended only for the Polybench, that are following a pretty regular pattern of testing loop kernels.
The patch makes 2mm run correctly for CFLAGS="", "-Ofast", and "-O3 -ffp-contract=on".
I have not looked at the other failing benchmarks to say whether this can apply to those.
I know that oggenc would be impossible to modify like this.

Right. Abe was trying to change the Make/CMake files, which could be a one-size-fits-all solution. If that works, I think we should go with that.

There are also these resource problems I was mentioning:

  • compilation time will double: e.g., Polly will optimize both kernels,
  • compute time on the device will more than double: running the kernel twice, plus an extra loop over both outputs to compare with FP_TOLERANCE.

Those two are true for all solutions we can come up with. 2mm takes 100s on ARM and 3mm takes 150s. Doubling ~50 could make it several minutes longer.

You were proposing getting something running first, then change later, but with a tolerance of 0.0001 after all aggregations, I think we could have FP=on and that tolerance in fpcmp and just run the default as a first approach, then later expand the FP=off compare.

Of course, that only works if the tolerance is low enough on all 50.

I think that the tolerance may be even smaller for the way this patch checks for the outputs in Polybench.
FP_tolerance should be selected (computed as suggested by Stephen) on a per benchmark basis.

  • memory requirements on the device will almost double: added one extra output array, input arrays are not modified, so no need to duplicate them,

Abe's solution wouldn't incur in additional memory consumption, but it would take longer to prepare/compile/run two completely different models of the same benchmark.

Also don't forget Abe's solution has two negative points addressed by this patch:

The good things about this patch:

  • no modifications to CMake and Makefiles (Matthias was complaining about the added complexity to the build system)
  • no extra space to store the extra reference output (1GB extra space and transfer over the network in the case of separate test devices, i.e., ARM)
sebpop added a subscriber: scanon.Oct 7 2016, 5:18 AM
rengolin added a comment.Oct 7 2016, 5:22 AM
In D25346#564349, @sebpop wrote:

I think that the tolerance may be even smaller for the way this patch checks for the outputs in Polybench.
FP_tolerance should be selected (computed as suggested by Stephen) on a per benchmark basis.

Agreed.

cheers,
--renato

sebpop updated this revision to Diff 74327.Oct 11 2016, 11:16 PM
sebpop edited edge metadata.

Complete patch implementing Proposal 2 for Polybench.

There are 5 benchmarks that need more attention: they require different FP_ABSTOLERANCE and different initial values to be able to compare "-O0 -ffp-contract=off" to "-Ofast":

polybench/linear-algebra/kernels/symm, FP_ABSTOLERANCE=10
polybench/linear-algebra/solvers/gramschmidt, FP_ABSTOLERANCE=1
polybench/medley/reg_detect, FP_ABSTOLERANCE=1e4
polybench/stencils/adi, FP_ABSTOLERANCE=1e4
polybench/stencils/seidel-2d, FP_ABSTOLERANCE=1e-5

Herald added subscribers: mgorny, beanz. · View Herald TranscriptOct 11 2016, 11:16 PM
sebpop updated this revision to Diff 74754.Oct 14 2016, 5:01 PM
sebpop edited edge metadata.

Updated patch fixes problems in adi and reg_detect.
All polybench pass with -O3 -ffp-contract=on and off on x86_64-linux.
Ok to commit?

MatzeB accepted this revision.Oct 14 2016, 5:12 PM
MatzeB edited edge metadata.

LGTM, thanks for fixing this properly. I leave the final approval to Renato.

SingleSource/Benchmarks/Polybench/datamining/correlation/correlation.c
137 ↗(On Diff #74754)

you actually have to write more to use this macro than to just use sqrt(x[j]) in the first place.

sebpop added a comment.Oct 14 2016, 7:40 PM
In D25346#570962, @MatzeB wrote:

LGTM, thanks for fixing this properly. I leave the final approval to Renato.

I will wait for Renato's approval before commit.

SingleSource/Benchmarks/Polybench/datamining/correlation/correlation.c
137 ↗(On Diff #74754)

I have not changed the code of the kernel.
I intentionally copied the full text without any change from my side in order to avoid any possible error.
If you think there is an error with this line, let's fix that in a separate patch.

rengolin requested changes to this revision.Oct 16 2016, 6:45 AM
rengolin edited edge metadata.

Why are you setting the tolerance AND disabling FP contract, which I think we agreed it wasn't the right way?

Also, the attribute optnone will make sure none of the O2, O3 passes will make any difference, and will confuse the hell out of people trying to benchmark those tests.

You're adding the pragma to the strict loop AND the non-strict loop, what's the point? If both have contract disable, than obviously the compare will always work, regardless of the compiler flags the user sets.

From what I can see you've done everything we agreed should not be done, so I'm not sure what this patch is about...

cheers,
--renato

This revision now requires changes to proceed.Oct 16 2016, 6:45 AM
rengolin added inline comments.Oct 16 2016, 6:47 AM
SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/doitgen.c
28 ↗(On Diff #74754)

Maybe I understood it wrong, is this pragma's lifetime ended by the end of the function?

If so, then the remaining functions will not have the contract on, and the attribute will also remain in this context.

If that's so, than I think it should be fine.

rengolin added inline comments.Oct 16 2016, 6:54 AM
SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/doitgen.c
28 ↗(On Diff #74754)

It seems that the interpretation, ignore me, it's been a long week...

rengolin accepted this revision.Oct 16 2016, 6:55 AM
rengolin edited edge metadata.
This revision is now accepted and ready to land.Oct 16 2016, 6:55 AM
rengolin mentioned this in D25575: test-suite: disable tests that fail when FP optimization is in effect, add support for per-ISA reference outputs.Oct 16 2016, 6:59 AM
Closed by commit rL284334: [polybench] check against strict fp (authored by spop). · Explain WhyOct 16 2016, 8:03 AM
This revision was automatically updated to reflect the committed changes.
mibintc mentioned this in D102861: Suppress FP_CONTRACT due to planned command line changes.May 24 2021, 8:29 AM

Revision Contents

PathSize
test-suite/
trunk/
SingleSource/
Benchmarks/
Polybench/
datamining/
correlation/
1 line
2 lines
101 lines
covariance/
1 line
2 lines
74 lines
linear-algebra/
kernels/
2mm/
80 lines
1 line
2 lines
3mm/
80 lines
1 line
2 lines
atax/
1 line
2 lines
60 lines
bicg/
1 line
2 lines
69 lines
cholesky/
1 line
2 lines
79 lines
doitgen/
1 line
2 lines
64 lines
gemm/
1 line
2 lines
64 lines
gemver/
1 line
2 lines
100 lines
gesummv/
1 line
2 lines
63 lines
mvt/
1 line
70 lines
symm/
1 line
3 lines
68 lines
syr2k/
1 line
2 lines
68 lines
syrk/
1 line
2 lines
63 lines
trisolv/
1 line
2 lines
55 lines
trmm/
1 line
2 lines
60 lines
solvers/
durbin/
1 line
2 lines
76 lines
dynprog/
1 line
2 lines
67 lines
gramschmidt/
1 line
2 lines
84 lines
lu/
1 line
2 lines
60 lines
ludcmp/
1 line
2 lines
90 lines
medley/
floyd-warshall/
1 line
2 lines
52 lines
reg_detect/
1 line
2 lines
84 lines
stencils/
adi/
1 line
2 lines
79 lines
fdtd-2d/
1 line
2 lines
79 lines
fdtd-apml/
1 line
2 lines
142 lines
jacobi-1d-imper/
1 line
2 lines
52 lines
jacobi-2d-imper/
1 line
2 lines
57 lines
seidel-2d/
1 line
2 lines
51 lines

Diff 74800

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/datamining/correlation/Makefile

LEVEL = ../../../../.. LEVEL = ../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = correlation PROG = correlation
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/datamining/correlation/correlation.c

Show All 13 Lines
#include "../../utilities/polybench.h" #include "../../utilities/polybench.h"
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "correlation.h" #include "correlation.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array (int m, void init_array (int m,
int n, int n,
DATA_TYPE *float_n, DATA_TYPE *float_n,
DATA_TYPE POLYBENCH_2D(data,M,N,m,n)) DATA_TYPE POLYBENCH_2D(data,M,N,m,n))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
*float_n = 1.2; *float_n = 1.2;
for (i = 0; i < m; i++) for (i = 0; i < m; i++)
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
data[i][j] = ((DATA_TYPE) i*j) / M; data[i][j] = ((DATA_TYPE) i*j) / M;
} }
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines for (j1 = 0; j1 < _PB_M-1; j1++)
symmat[j2][j1] = symmat[j1][j2]; symmat[j2][j1] = symmat[j1][j2];
} }
} }
symmat[_PB_M-1][_PB_M-1] = 1.0; symmat[_PB_M-1][_PB_M-1] = 1.0;
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_correlation_StrictFP(int m, int n,
DATA_TYPE float_n,
DATA_TYPE POLYBENCH_2D(data,M,N,m,n),
DATA_TYPE POLYBENCH_2D(symmat,M,M,m,m),
DATA_TYPE POLYBENCH_1D(mean,M,m),
DATA_TYPE POLYBENCH_1D(stddev,M,m))
{
#pragma STDC FP_CONTRACT OFF
int i, j, j1, j2;
DATA_TYPE eps = 0.1f;
#define sqrt_of_array_cell(x,j) sqrt(x[j])
/* Determine mean of column vectors of input data matrix */
for (j = 0; j < _PB_M; j++)
{
mean[j] = 0.0;
for (i = 0; i < _PB_N; i++)
mean[j] += data[i][j];
mean[j] /= float_n;
}
/* Determine standard deviations of column vectors of data matrix. */
for (j = 0; j < _PB_M; j++)
{
stddev[j] = 0.0;
for (i = 0; i < _PB_N; i++)
stddev[j] += (data[i][j] - mean[j]) * (data[i][j] - mean[j]);
stddev[j] /= float_n;
stddev[j] = sqrt_of_array_cell(stddev, j);
/* The following in an inelegant but usual way to handle
near-zero std. dev. values, which below would cause a zero-
divide. */
stddev[j] = stddev[j] <= eps ? 1.0 : stddev[j];
}
/* Center and reduce the column vectors. */
for (i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_M; j++)
{
data[i][j] -= mean[j];
data[i][j] /= sqrt(float_n) * stddev[j];
}
/* Calculate the m * m correlation matrix. */
for (j1 = 0; j1 < _PB_M-1; j1++)
{
symmat[j1][j1] = 1.0;
for (j2 = j1+1; j2 < _PB_M; j2++)
{
symmat[j1][j2] = 0.0;
for (i = 0; i < _PB_N; i++)
symmat[j1][j2] += (data[i][j1] * data[i][j2]);
symmat[j2][j1] = symmat[j1][j2];
}
}
symmat[_PB_M-1][_PB_M-1] = 1.0;
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int m,
DATA_TYPE POLYBENCH_2D(A,M,M,m,m),
DATA_TYPE POLYBENCH_2D(B,M,M,m,m)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_M; i++)
for (j = 0; j < _PB_M; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int n = N; int n = N;
int m = M; int m = M;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
DATA_TYPE float_n; DATA_TYPE float_n;
POLYBENCH_2D_ARRAY_DECL(data,DATA_TYPE,M,N,m,n); POLYBENCH_2D_ARRAY_DECL(data,DATA_TYPE,M,N,m,n);
POLYBENCH_2D_ARRAY_DECL(symmat,DATA_TYPE,M,M,m,m); POLYBENCH_2D_ARRAY_DECL(symmat,DATA_TYPE,M,M,m,m);
POLYBENCH_2D_ARRAY_DECL(symmat_StrictFP,DATA_TYPE,M,M,m,m);
POLYBENCH_1D_ARRAY_DECL(mean,DATA_TYPE,M,m); POLYBENCH_1D_ARRAY_DECL(mean,DATA_TYPE,M,m);
POLYBENCH_1D_ARRAY_DECL(stddev,DATA_TYPE,M,m); POLYBENCH_1D_ARRAY_DECL(stddev,DATA_TYPE,M,m);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (m, n, &float_n, POLYBENCH_ARRAY(data)); init_array (m, n, &float_n, POLYBENCH_ARRAY(data));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_correlation (m, n, float_n, kernel_correlation (m, n, float_n,
POLYBENCH_ARRAY(data), POLYBENCH_ARRAY(data),
POLYBENCH_ARRAY(symmat), POLYBENCH_ARRAY(symmat),
POLYBENCH_ARRAY(mean), POLYBENCH_ARRAY(mean),
POLYBENCH_ARRAY(stddev)); POLYBENCH_ARRAY(stddev));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
init_array (m, n, &float_n, POLYBENCH_ARRAY(data));
kernel_correlation (m, n, float_n,
POLYBENCH_ARRAY(data),
POLYBENCH_ARRAY(symmat_StrictFP),
POLYBENCH_ARRAY(mean),
POLYBENCH_ARRAY(stddev));
if (!check_FP(m, POLYBENCH_ARRAY(symmat), POLYBENCH_ARRAY(symmat_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(m, POLYBENCH_ARRAY(symmat))); polybench_prevent_dce(print_array(m, POLYBENCH_ARRAY(symmat_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(data); POLYBENCH_FREE_ARRAY(data);
POLYBENCH_FREE_ARRAY(symmat); POLYBENCH_FREE_ARRAY(symmat);
POLYBENCH_FREE_ARRAY(symmat_StrictFP);
POLYBENCH_FREE_ARRAY(mean); POLYBENCH_FREE_ARRAY(mean);
POLYBENCH_FREE_ARRAY(stddev); POLYBENCH_FREE_ARRAY(stddev);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/datamining/covariance/Makefile

LEVEL = ../../../../.. LEVEL = ../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = covariance PROG = covariance
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/datamining/covariance/covariance.c

Show All 13 Lines
#include "../../utilities/polybench.h" #include "../../utilities/polybench.h"
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "covariance.h" #include "covariance.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array (int m, int n, void init_array (int m, int n,
DATA_TYPE *float_n, DATA_TYPE *float_n,
DATA_TYPE POLYBENCH_2D(data,M,N,m,n)) DATA_TYPE POLYBENCH_2D(data,M,N,m,n))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
*float_n = 1.2; *float_n = 1.2;
for (i = 0; i < M; i++) for (i = 0; i < M; i++)
for (j = 0; j < N; j++) for (j = 0; j < N; j++)
data[i][j] = ((DATA_TYPE) i*j) / M; data[i][j] = ((DATA_TYPE) i*j) / M;
} }
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines for (j2 = j1; j2 < _PB_M; j2++)
for (i = 0; i < _PB_N; i++) for (i = 0; i < _PB_N; i++)
symmat[j1][j2] += data[i][j1] * data[i][j2]; symmat[j1][j2] += data[i][j1] * data[i][j2];
symmat[j2][j1] = symmat[j1][j2]; symmat[j2][j1] = symmat[j1][j2];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_covariance_StrictFP(int m, int n,
DATA_TYPE float_n,
DATA_TYPE POLYBENCH_2D(data,M,N,m,n),
DATA_TYPE POLYBENCH_2D(symmat,M,M,m,m),
DATA_TYPE POLYBENCH_1D(mean,M,m))
{
#pragma STDC FP_CONTRACT OFF
int i, j, j1, j2;
/* Determine mean of column vectors of input data matrix */
for (j = 0; j < _PB_M; j++)
{
mean[j] = 0.0;
for (i = 0; i < _PB_N; i++)
mean[j] += data[i][j];
mean[j] /= float_n;
}
/* Center the column vectors. */
for (i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_M; j++)
data[i][j] -= mean[j];
/* Calculate the m * m covariance matrix. */
for (j1 = 0; j1 < _PB_M; j1++)
for (j2 = j1; j2 < _PB_M; j2++)
{
symmat[j1][j2] = 0.0;
for (i = 0; i < _PB_N; i++)
symmat[j1][j2] += data[i][j1] * data[i][j2];
symmat[j2][j1] = symmat[j1][j2];
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int m,
DATA_TYPE POLYBENCH_2D(A,M,M,m,m),
DATA_TYPE POLYBENCH_2D(B,M,M,m,m)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_M; i++)
for (j = 0; j < _PB_M; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int n = N; int n = N;
int m = M; int m = M;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
DATA_TYPE float_n; DATA_TYPE float_n;
POLYBENCH_2D_ARRAY_DECL(data,DATA_TYPE,M,N,m,n); POLYBENCH_2D_ARRAY_DECL(data,DATA_TYPE,M,N,m,n);
POLYBENCH_2D_ARRAY_DECL(symmat,DATA_TYPE,M,M,m,m); POLYBENCH_2D_ARRAY_DECL(symmat,DATA_TYPE,M,M,m,m);
POLYBENCH_2D_ARRAY_DECL(symmat_StrictFP,DATA_TYPE,M,M,m,m);
POLYBENCH_1D_ARRAY_DECL(mean,DATA_TYPE,M,m); POLYBENCH_1D_ARRAY_DECL(mean,DATA_TYPE,M,m);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (m, n, &float_n, POLYBENCH_ARRAY(data)); init_array (m, n, &float_n, POLYBENCH_ARRAY(data));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_covariance (m, n, float_n, kernel_covariance (m, n, float_n,
POLYBENCH_ARRAY(data), POLYBENCH_ARRAY(data),
POLYBENCH_ARRAY(symmat), POLYBENCH_ARRAY(symmat),
POLYBENCH_ARRAY(mean)); POLYBENCH_ARRAY(mean));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
init_array (m, n, &float_n, POLYBENCH_ARRAY(data));
kernel_covariance (m, n, float_n,
POLYBENCH_ARRAY(data),
POLYBENCH_ARRAY(symmat_StrictFP),
POLYBENCH_ARRAY(mean));
if (!check_FP(m, POLYBENCH_ARRAY(symmat), POLYBENCH_ARRAY(symmat_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(m, POLYBENCH_ARRAY(symmat))); polybench_prevent_dce(print_array(m, POLYBENCH_ARRAY(symmat_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(data); POLYBENCH_FREE_ARRAY(data);
POLYBENCH_FREE_ARRAY(symmat); POLYBENCH_FREE_ARRAY(symmat);
POLYBENCH_FREE_ARRAY(symmat_StrictFP);
POLYBENCH_FREE_ARRAY(mean); POLYBENCH_FREE_ARRAY(mean);
return 0; return 0;
} }

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "2mm.h" #include "2mm.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array(int ni, int nj, int nk, int nl, void init_array(int ni, int nj, int nk, int nl,
DATA_TYPE *alpha, DATA_TYPE *alpha,
DATA_TYPE *beta, DATA_TYPE *beta,
DATA_TYPE POLYBENCH_2D(A,NI,NK,ni,nl), DATA_TYPE POLYBENCH_2D(A,NI,NK,ni,nl),
DATA_TYPE POLYBENCH_2D(B,NK,NJ,nk,nj), DATA_TYPE POLYBENCH_2D(B,NK,NJ,nk,nj),
DATA_TYPE POLYBENCH_2D(C,NL,NJ,nl,nj), DATA_TYPE POLYBENCH_2D(C,NL,NJ,nl,nj),
DATA_TYPE POLYBENCH_2D(D,NI,NL,ni,nl)) DATA_TYPE POLYBENCH_2D(D,NI,NL,ni,nl),
DATA_TYPE POLYBENCH_2D(D_StrictFP,NI,NL,ni,nl))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
*alpha = 32412; *alpha = 32412;
*beta = 2123; *beta = 2123;
for (i = 0; i < ni; i++) for (i = 0; i < ni; i++)
for (j = 0; j < nk; j++) for (j = 0; j < nk; j++)
A[i][j] = ((DATA_TYPE) i*j) / ni; A[i][j] = ((DATA_TYPE) i*j) / ni;
for (i = 0; i < nk; i++) for (i = 0; i < nk; i++)
for (j = 0; j < nj; j++) for (j = 0; j < nj; j++)
B[i][j] = ((DATA_TYPE) i*(j+1)) / nj; B[i][j] = ((DATA_TYPE) i*(j+1)) / nj;
for (i = 0; i < nl; i++) for (i = 0; i < nl; i++)
for (j = 0; j < nj; j++) for (j = 0; j < nj; j++)
C[i][j] = ((DATA_TYPE) i*(j+3)) / nl; C[i][j] = ((DATA_TYPE) i*(j+3)) / nl;
for (i = 0; i < ni; i++) for (i = 0; i < ni; i++)
for (j = 0; j < nl; j++) for (j = 0; j < nl; j++)
D[i][j] = ((DATA_TYPE) i*(j+2)) / nk; D_StrictFP[i][j] = D[i][j] = ((DATA_TYPE) i*(j+2)) / nk;
} }
/* DCE code. Must scan the entire live-out data. /* DCE code. Must scan the entire live-out data.
Can be used also to check the correctness of the output. */ Can be used also to check the correctness of the output. */
static static
void print_array(int ni, int nl, void print_array(int ni, int nl,
DATA_TYPE POLYBENCH_2D(D,NI,NL,ni,nl)) DATA_TYPE POLYBENCH_2D(D,NI,NL,ni,nl))
Show All 39 Lines#pragma scop
D[i][j] *= beta; D[i][j] *= beta;
for (k = 0; k < _PB_NJ; ++k) for (k = 0; k < _PB_NJ; ++k)
D[i][j] += tmp[i][k] * C[k][j]; D[i][j] += tmp[i][k] * C[k][j];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_2mm_StrictFP(int ni, int nj, int nk, int nl,
DATA_TYPE alpha,
DATA_TYPE beta,
DATA_TYPE POLYBENCH_2D(tmp,NI,NJ,ni,nj),
DATA_TYPE POLYBENCH_2D(A,NI,NK,ni,nk),
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))
{
#pragma STDC FP_CONTRACT OFF
int i, j, k;
/* D := alpha*A*B*C + beta*D */
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NJ; j++)
{
tmp[i][j] = 0;
for (k = 0; k < _PB_NK; ++k)
tmp[i][j] += alpha * A[i][k] * B[k][j];
}
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NL; j++)
{
D[i][j] *= beta;
for (k = 0; k < _PB_NJ; ++k)
D[i][j] += tmp[i][k] * C[k][j];
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int ni, int nl,
DATA_TYPE POLYBENCH_2D(A,NI,NL,ni,nl),
DATA_TYPE POLYBENCH_2D(B,NI,NL,ni,nl)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NL; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int ni = NI; int ni = NI;
int nj = NJ; int nj = NJ;
int nk = NK; int nk = NK;
int nl = NL; int nl = NL;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
DATA_TYPE alpha; DATA_TYPE alpha;
DATA_TYPE beta; DATA_TYPE beta;
POLYBENCH_2D_ARRAY_DECL(tmp,DATA_TYPE,NI,NJ,ni,nj); POLYBENCH_2D_ARRAY_DECL(tmp,DATA_TYPE,NI,NJ,ni,nj);
POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NK,ni,nk); POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NK,ni,nk);
POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NK,NJ,nk,nj); 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(C,DATA_TYPE,NL,NJ,nl,nj);
POLYBENCH_2D_ARRAY_DECL(D,DATA_TYPE,NI,NL,ni,nl); POLYBENCH_2D_ARRAY_DECL(D,DATA_TYPE,NI,NL,ni,nl);
POLYBENCH_2D_ARRAY_DECL(D_StrictFP,DATA_TYPE,NI,NL,ni,nl);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (ni, nj, nk, nl, &alpha, &beta, init_array (ni, nj, nk, nl, &alpha, &beta,
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B), POLYBENCH_ARRAY(B),
POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(C),
POLYBENCH_ARRAY(D)); POLYBENCH_ARRAY(D),
POLYBENCH_ARRAY(D_StrictFP));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_2mm (ni, nj, nk, nl, kernel_2mm (ni, nj, nk, nl,
alpha, beta, alpha, beta,
POLYBENCH_ARRAY(tmp), POLYBENCH_ARRAY(tmp),
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B), POLYBENCH_ARRAY(B),
POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(C),
POLYBENCH_ARRAY(D)); POLYBENCH_ARRAY(D));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
kernel_2mm_StrictFP(ni, nj, nk, nl,
alpha, beta,
POLYBENCH_ARRAY(tmp),
POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B),
POLYBENCH_ARRAY(C),
POLYBENCH_ARRAY(D_StrictFP));
if (!check_FP(ni, nl, POLYBENCH_ARRAY(D), POLYBENCH_ARRAY(D_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(ni, nl, POLYBENCH_ARRAY(D))); polybench_prevent_dce(print_array(ni, nl, POLYBENCH_ARRAY(D_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(tmp); POLYBENCH_FREE_ARRAY(tmp);
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(B); POLYBENCH_FREE_ARRAY(B);
POLYBENCH_FREE_ARRAY(C); POLYBENCH_FREE_ARRAY(C);
POLYBENCH_FREE_ARRAY(D); POLYBENCH_FREE_ARRAY(D);
POLYBENCH_FREE_ARRAY(D_StrictFP);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = 2mm PROG = 2mm
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
else else
ifeq ($(ARCH),XCore) ifeq ($(ARCH),XCore)
XCORE_TARGET_NEEDS_MEMORY := 64 XCORE_TARGET_NEEDS_MEMORY := 64
endif endif
endif endif
Show All 13 Lines

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/3mm.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "3mm.h" #include "3mm.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array(int ni, int nj, int nk, int nl, int nm, void init_array(int ni, int nj, int nk, int nl, int nm,
DATA_TYPE POLYBENCH_2D(A,NI,NK,ni,nk), DATA_TYPE POLYBENCH_2D(A,NI,NK,ni,nk),
DATA_TYPE POLYBENCH_2D(B,NK,NJ,nk,nj), DATA_TYPE POLYBENCH_2D(B,NK,NJ,nk,nj),
DATA_TYPE POLYBENCH_2D(C,NJ,NM,nj,nm), DATA_TYPE POLYBENCH_2D(C,NJ,NM,nj,nm),
DATA_TYPE POLYBENCH_2D(D,NM,NL,nm,nl)) DATA_TYPE POLYBENCH_2D(D,NM,NL,nm,nl))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
for (i = 0; i < ni; i++) for (i = 0; i < ni; i++)
for (j = 0; j < nk; j++) for (j = 0; j < nk; j++)
A[i][j] = ((DATA_TYPE) i*j) / ni; A[i][j] = ((DATA_TYPE) i*j) / ni;
for (i = 0; i < nk; i++) for (i = 0; i < nk; i++)
for (j = 0; j < nj; j++) for (j = 0; j < nj; j++)
B[i][j] = ((DATA_TYPE) i*(j+1)) / nj; B[i][j] = ((DATA_TYPE) i*(j+1)) / nj;
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines#pragma scop
G[i][j] = 0; G[i][j] = 0;
for (k = 0; k < _PB_NJ; ++k) for (k = 0; k < _PB_NJ; ++k)
G[i][j] += E[i][k] * F[k][j]; G[i][j] += E[i][k] * F[k][j];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static
void kernel_3mm_StrictFP(int ni, int nj, int nk, int nl, int nm,
DATA_TYPE POLYBENCH_2D(E,NI,NJ,ni,nj),
DATA_TYPE POLYBENCH_2D(A,NI,NK,ni,nk),
DATA_TYPE POLYBENCH_2D(B,NK,NJ,nk,nj),
DATA_TYPE POLYBENCH_2D(F,NJ,NL,nj,nl),
DATA_TYPE POLYBENCH_2D(C,NJ,NM,nj,nm),
DATA_TYPE POLYBENCH_2D(D,NM,NL,nm,nl),
DATA_TYPE POLYBENCH_2D(G,NI,NL,ni,nl))
{
#pragma STDC FP_CONTRACT OFF
int i, j, k;
/* E := A*B */
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NJ; j++)
{
E[i][j] = 0;
for (k = 0; k < _PB_NK; ++k)
E[i][j] += A[i][k] * B[k][j];
}
/* F := C*D */
for (i = 0; i < _PB_NJ; i++)
for (j = 0; j < _PB_NL; j++)
{
F[i][j] = 0;
for (k = 0; k < _PB_NM; ++k)
F[i][j] += C[i][k] * D[k][j];
}
/* G := E*F */
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NL; j++)
{
G[i][j] = 0;
for (k = 0; k < _PB_NJ; ++k)
G[i][j] += E[i][k] * F[k][j];
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int ni, int nl,
DATA_TYPE POLYBENCH_2D(A,NI,NL,ni,nl),
DATA_TYPE POLYBENCH_2D(B,NI,NL,ni,nl)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NL; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int ni = NI; int ni = NI;
int nj = NJ; int nj = NJ;
int nk = NK; int nk = NK;
int nl = NL; int nl = NL;
int nm = NM; int nm = NM;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(E, DATA_TYPE, NI, NJ, ni, nj); POLYBENCH_2D_ARRAY_DECL(E, DATA_TYPE, NI, NJ, ni, nj);
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, NI, NK, ni, nk); POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, NI, NK, ni, nk);
POLYBENCH_2D_ARRAY_DECL(B, DATA_TYPE, NK, NJ, nk, nj); POLYBENCH_2D_ARRAY_DECL(B, DATA_TYPE, NK, NJ, nk, nj);
POLYBENCH_2D_ARRAY_DECL(F, DATA_TYPE, NJ, NL, nj, nl); POLYBENCH_2D_ARRAY_DECL(F, DATA_TYPE, NJ, NL, nj, nl);
POLYBENCH_2D_ARRAY_DECL(C, DATA_TYPE, NJ, NM, nj, nm); 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(D, DATA_TYPE, NM, NL, nm, nl);
POLYBENCH_2D_ARRAY_DECL(G, DATA_TYPE, NI, NL, ni, nl); POLYBENCH_2D_ARRAY_DECL(G, DATA_TYPE, NI, NL, ni, nl);
POLYBENCH_2D_ARRAY_DECL(G_StrictFP, DATA_TYPE, NI, NL, ni, nl);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (ni, nj, nk, nl, nm, init_array (ni, nj, nk, nl, nm,
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B), POLYBENCH_ARRAY(B),
POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(C),
POLYBENCH_ARRAY(D)); POLYBENCH_ARRAY(D));
Show All 9 Lines kernel_3mm (ni, nj, nk, nl, nm,
POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(C),
POLYBENCH_ARRAY(D), POLYBENCH_ARRAY(D),
POLYBENCH_ARRAY(G)); POLYBENCH_ARRAY(G));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
kernel_3mm_StrictFP(ni, nj, nk, nl, nm,
POLYBENCH_ARRAY(E),
POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B),
POLYBENCH_ARRAY(F),
POLYBENCH_ARRAY(C),
POLYBENCH_ARRAY(D),
POLYBENCH_ARRAY(G_StrictFP));
if (!check_FP(ni, nl, POLYBENCH_ARRAY(G), POLYBENCH_ARRAY(G_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(ni, nl, POLYBENCH_ARRAY(G))); polybench_prevent_dce(print_array(ni, nl, POLYBENCH_ARRAY(G_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(E); POLYBENCH_FREE_ARRAY(E);
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(B); POLYBENCH_FREE_ARRAY(B);
POLYBENCH_FREE_ARRAY(F); POLYBENCH_FREE_ARRAY(F);
POLYBENCH_FREE_ARRAY(C); POLYBENCH_FREE_ARRAY(C);
POLYBENCH_FREE_ARRAY(D); POLYBENCH_FREE_ARRAY(D);
POLYBENCH_FREE_ARRAY(G); POLYBENCH_FREE_ARRAY(G);
POLYBENCH_FREE_ARRAY(G_StrictFP);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = 3mm PROG = 3mm
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
else else
ifeq ($(ARCH),XCore) ifeq ($(ARCH),XCore)
XCORE_TARGET_NEEDS_MEMORY := 64 XCORE_TARGET_NEEDS_MEMORY := 64
endif endif
endif endif
Show All 13 Lines

test-suite/trunk/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()
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = atax PROG = atax
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
ifeq ($(ARCH),XCore) ifeq ($(ARCH),XCore)
XCORE_TARGET_NEEDS_MEMORY := 128 XCORE_TARGET_NEEDS_MEMORY := 128
endif endif
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/atax.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "atax.h" #include "atax.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array (int nx, int ny, void init_array (int nx, int ny,
DATA_TYPE POLYBENCH_2D(A,NX,NY,nx,ny), DATA_TYPE POLYBENCH_2D(A,NX,NY,nx,ny),
DATA_TYPE POLYBENCH_1D(x,NY,ny)) DATA_TYPE POLYBENCH_1D(x,NY,ny))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
for (i = 0; i < ny; i++) for (i = 0; i < ny; i++)
x[i] = i * M_PI; x[i] = i * M_PI;
for (i = 0; i < nx; i++) for (i = 0; i < nx; i++)
for (j = 0; j < ny; j++) for (j = 0; j < ny; j++)
A[i][j] = ((DATA_TYPE) i*(j+1)) / nx; A[i][j] = ((DATA_TYPE) i*(j+1)) / nx;
} }
/* DCE code. Must scan the entire live-out data. /* DCE code. Must scan the entire live-out data.
Can be used also to check the correctness of the output. */ Can be used also to check the correctness of the output. */
static static
void print_array(int nx, void print_array(int nx,
DATA_TYPE POLYBENCH_1D(y,NX,nx)) DATA_TYPE POLYBENCH_1D(y,NX,nx))
{ {
int i; int i;
Show All 27 Lines#pragma scop
tmp[i] = tmp[i] + A[i][j] * x[j]; tmp[i] = tmp[i] + A[i][j] * x[j];
for (j = 0; j < _PB_NY; j++) for (j = 0; j < _PB_NY; j++)
y[j] = y[j] + A[i][j] * tmp[i]; y[j] = y[j] + A[i][j] * tmp[i];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_atax_StrictFP(int nx, int ny,
DATA_TYPE POLYBENCH_2D(A,NX,NY,nx,ny),
DATA_TYPE POLYBENCH_1D(x,NY,ny),
DATA_TYPE POLYBENCH_1D(y,NY,ny),
DATA_TYPE POLYBENCH_1D(tmp,NX,nx))
{
#pragma STDC FP_CONTRACT OFF
int i, j;
for (i = 0; i < _PB_NY; i++)
y[i] = 0;
for (i = 0; i < _PB_NX; i++)
{
tmp[i] = 0;
for (j = 0; j < _PB_NY; j++)
tmp[i] = tmp[i] + A[i][j] * x[j];
for (j = 0; j < _PB_NY; j++)
y[j] = y[j] + A[i][j] * tmp[i];
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static int
check_FP(int ny,
DATA_TYPE POLYBENCH_1D(A,NY,ny),
DATA_TYPE POLYBENCH_1D(B,NY,ny)) {
int i;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_NY; i++)
{
double V1 = A[i];
double V2 = B[i];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d] = %lf and B[%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, V1, i, V2, AbsTolerance);
return 0;
}
}
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int nx = NX; int nx = NX;
int ny = NY; int ny = NY;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, NX, NY, nx, ny); POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, NX, NY, nx, ny);
POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, NY, ny); POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, NY, ny);
POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, NY, ny); POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, NY, ny);
POLYBENCH_1D_ARRAY_DECL(y_StrictFP, DATA_TYPE, NY, ny);
POLYBENCH_1D_ARRAY_DECL(tmp, DATA_TYPE, NX, nx); POLYBENCH_1D_ARRAY_DECL(tmp, DATA_TYPE, NX, nx);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (nx, ny, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(x)); init_array (nx, ny, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(x));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_atax (nx, ny, kernel_atax (nx, ny,
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(x), POLYBENCH_ARRAY(x),
POLYBENCH_ARRAY(y), POLYBENCH_ARRAY(y),
POLYBENCH_ARRAY(tmp)); POLYBENCH_ARRAY(tmp));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
kernel_atax_StrictFP (nx, ny,
POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(x),
POLYBENCH_ARRAY(y_StrictFP),
POLYBENCH_ARRAY(tmp));
if (!check_FP(ny, POLYBENCH_ARRAY(y), POLYBENCH_ARRAY(y_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(nx, POLYBENCH_ARRAY(y))); polybench_prevent_dce(print_array(nx, POLYBENCH_ARRAY(y_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(x); POLYBENCH_FREE_ARRAY(x);
POLYBENCH_FREE_ARRAY(y); POLYBENCH_FREE_ARRAY(y);
POLYBENCH_FREE_ARRAY(y_StrictFP);
POLYBENCH_FREE_ARRAY(tmp); POLYBENCH_FREE_ARRAY(tmp);
return 0; return 0;
} }

test-suite/trunk/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)
if(ARCH STREQUAL "XCore") if(ARCH STREQUAL "XCore")
set(XCORE_TARGET_NEEDS_MEMORY 128) set(XCORE_TARGET_NEEDS_MEMORY 128)
endif() endif()
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = bicg PROG = bicg
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
ifeq ($(ARCH),XCore) ifeq ($(ARCH),XCore)
XCORE_TARGET_NEEDS_MEMORY := 128 XCORE_TARGET_NEEDS_MEMORY := 128
endif endif
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/bicg.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "bicg.h" #include "bicg.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array (int nx, int ny, void init_array (int nx, int ny,
DATA_TYPE POLYBENCH_2D(A,NX,NY,nx,ny), DATA_TYPE POLYBENCH_2D(A,NX,NY,nx,ny),
DATA_TYPE POLYBENCH_1D(r,NX,nx), DATA_TYPE POLYBENCH_1D(r,NX,nx),
DATA_TYPE POLYBENCH_1D(p,NY,ny)) DATA_TYPE POLYBENCH_1D(p,NY,ny))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
for (i = 0; i < ny; i++) for (i = 0; i < ny; i++)
p[i] = i * M_PI; p[i] = i * M_PI;
for (i = 0; i < nx; i++) { for (i = 0; i < nx; i++) {
r[i] = i * M_PI; r[i] = i * M_PI;
for (j = 0; j < ny; j++) for (j = 0; j < ny; j++)
A[i][j] = ((DATA_TYPE) i*(j+1))/nx; A[i][j] = ((DATA_TYPE) i*(j+1))/nx;
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines for (i = 0; i < _PB_NX; i++)
s[j] = s[j] + r[i] * A[i][j]; s[j] = s[j] + r[i] * A[i][j];
q[i] = q[i] + A[i][j] * p[j]; q[i] = q[i] + A[i][j] * p[j];
} }
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static
void kernel_bicg_StrictFP(int nx, int ny,
DATA_TYPE POLYBENCH_2D(A,NX,NY,nx,ny),
DATA_TYPE POLYBENCH_1D(s,NY,ny),
DATA_TYPE POLYBENCH_1D(q,NX,nx),
DATA_TYPE POLYBENCH_1D(p,NY,ny),
DATA_TYPE POLYBENCH_1D(r,NX,nx))
{
#pragma STDC FP_CONTRACT OFF
int i, j;
for (i = 0; i < _PB_NY; i++)
s[i] = 0;
for (i = 0; i < _PB_NX; i++)
{
q[i] = 0;
for (j = 0; j < _PB_NY; j++)
{
s[j] = s[j] + r[i] * A[i][j];
q[i] = q[i] + A[i][j] * p[j];
}
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static int
check_FP(int ny,
DATA_TYPE POLYBENCH_1D(A,NY,ny),
DATA_TYPE POLYBENCH_1D(B,NX,nx)) {
int i;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_NY; i++)
{
double V1 = A[i];
double V2 = B[i];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d] = %lf and B[%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, V1, i, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int nx = NX; int nx = NX;
int ny = NY; int ny = NY;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, NX, NY, nx, ny); POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, NX, NY, nx, ny);
POLYBENCH_1D_ARRAY_DECL(s, DATA_TYPE, NY, ny); POLYBENCH_1D_ARRAY_DECL(s, DATA_TYPE, NY, ny);
POLYBENCH_1D_ARRAY_DECL(q, DATA_TYPE, NX, nx); POLYBENCH_1D_ARRAY_DECL(q, DATA_TYPE, NX, nx);
POLYBENCH_1D_ARRAY_DECL(p, DATA_TYPE, NY, ny); POLYBENCH_1D_ARRAY_DECL(p, DATA_TYPE, NY, ny);
POLYBENCH_1D_ARRAY_DECL(r, DATA_TYPE, NX, nx); POLYBENCH_1D_ARRAY_DECL(r, DATA_TYPE, NX, nx);
POLYBENCH_1D_ARRAY_DECL(s_StrictFP, DATA_TYPE, NY, ny);
POLYBENCH_1D_ARRAY_DECL(q_StrictFP, DATA_TYPE, NX, nx);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (nx, ny, init_array (nx, ny,
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(r), POLYBENCH_ARRAY(r),
POLYBENCH_ARRAY(p)); POLYBENCH_ARRAY(p));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_bicg (nx, ny, kernel_bicg (nx, ny,
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(s), POLYBENCH_ARRAY(s),
POLYBENCH_ARRAY(q), POLYBENCH_ARRAY(q),
POLYBENCH_ARRAY(p), POLYBENCH_ARRAY(p),
POLYBENCH_ARRAY(r)); POLYBENCH_ARRAY(r));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
kernel_bicg_StrictFP(nx, ny,
POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(s_StrictFP),
POLYBENCH_ARRAY(q_StrictFP),
POLYBENCH_ARRAY(p),
POLYBENCH_ARRAY(r));
if (!check_FP(ny, POLYBENCH_ARRAY(s), POLYBENCH_ARRAY(s_StrictFP)))
return 1;
if (!check_FP(ny, POLYBENCH_ARRAY(q), POLYBENCH_ARRAY(q_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(nx, ny, POLYBENCH_ARRAY(s), POLYBENCH_ARRAY(q))); polybench_prevent_dce(print_array(nx, ny, POLYBENCH_ARRAY(s_StrictFP),
POLYBENCH_ARRAY(q_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(s); POLYBENCH_FREE_ARRAY(s);
POLYBENCH_FREE_ARRAY(q); POLYBENCH_FREE_ARRAY(q);
POLYBENCH_FREE_ARRAY(p); POLYBENCH_FREE_ARRAY(p);
POLYBENCH_FREE_ARRAY(r); POLYBENCH_FREE_ARRAY(r);
POLYBENCH_FREE_ARRAY(s_StrictFP);
POLYBENCH_FREE_ARRAY(q_StrictFP);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/cholesky/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = cholesky PROG = cholesky
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/cholesky/cholesky.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "cholesky.h" #include "cholesky.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array(int n, void init_array(int n,
DATA_TYPE POLYBENCH_1D(p,N,n), DATA_TYPE POLYBENCH_1D(p,N,n),
DATA_TYPE POLYBENCH_2D(A,N,N,n,n)) DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_2D(A_StrictFP,N,N,n,n))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
/* /*
LLVM: This change ensures we do not calculate nan values, which are LLVM: This change ensures we do not calculate nan values, which are
formatted differently on different platforms and which may also formatted differently on different platforms and which may also
be optimized unexpectedly. be optimized unexpectedly.
Original code: Original code:
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
p[i] = 1.0 / n; p[i] = 1.0 / n;
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
A[i][j] = 1.0 / n; A[i][j] = 1.0 / n;
} }
*/ */
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
p[i] = i + n; p[i] = i + n;
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
A[i][j] = j + n; A[i][j] = j + n;
} }
for (i = 0; i < n; i++)
{
p[i] = i + n;
for (j = 0; j < n; j++)
A_StrictFP[i][j] = j + n;
}
} }
/* DCE code. Must scan the entire live-out data. /* DCE code. Must scan the entire live-out data.
Can be used also to check the correctness of the output. */ Can be used also to check the correctness of the output. */
static static
void print_array(int n, void print_array(int n,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n)) DATA_TYPE POLYBENCH_2D(A,N,N,n,n))
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines for (k = 0; k <= i - 1; ++k)
x = x - A[j][k] * A[i][k]; x = x - A[j][k] * A[i][k];
A[j][i] = x * p[i]; A[j][i] = x * p[i];
} }
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static
void kernel_cholesky_StrictFP(int n,
DATA_TYPE POLYBENCH_1D(p,N,n),
DATA_TYPE POLYBENCH_2D(A,N,N,n,n))
{
#pragma STDC FP_CONTRACT OFF
int i, j, k;
DATA_TYPE x;
for (i = 0; i < _PB_N; ++i)
{
/*
LLVM: This change ensures we do not calculate nan values, which are
formatted differently on different platforms and which may also
be optimized unexpectedly.
Original line:
x = A[i][i];
*/
x = A[i][i] * n;
for (j = 0; j <= i - 1; ++j)
x = x - A[i][j] * A[i][j];
p[i] = 1.0 / sqrt(x);
for (j = i + 1; j < _PB_N; ++j)
{
x = A[i][j];
for (k = 0; k <= i - 1; ++k)
x = x - A[j][k] * A[i][k];
A[j][i] = x * p[i];
}
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int n,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_2D(B,N,N,n,n)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_N; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int n = N; int n = N;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n);
POLYBENCH_1D_ARRAY_DECL(p, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(p, DATA_TYPE, N, n);
POLYBENCH_2D_ARRAY_DECL(A_StrictFP, DATA_TYPE, N, N, n, n);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (n, POLYBENCH_ARRAY(p), POLYBENCH_ARRAY(A)); init_array (n, POLYBENCH_ARRAY(p), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(A_StrictFP));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_cholesky (n, POLYBENCH_ARRAY(p), POLYBENCH_ARRAY(A)); kernel_cholesky (n, POLYBENCH_ARRAY(p), POLYBENCH_ARRAY(A));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
kernel_cholesky_StrictFP(n, POLYBENCH_ARRAY(p), POLYBENCH_ARRAY(A_StrictFP));
if (!check_FP(n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(A_StrictFP);
POLYBENCH_FREE_ARRAY(p); POLYBENCH_FREE_ARRAY(p);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = doitgen PROG = doitgen
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
else else
ifeq ($(ARCH),XCore) ifeq ($(ARCH),XCore)
XCORE_TARGET_NEEDS_MEMORY := 64 XCORE_TARGET_NEEDS_MEMORY := 64
endif endif
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/doitgen.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "doitgen.h" #include "doitgen.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array(int nr, int nq, int np, 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,NR,NQ,NP,nr,nq,np),
DATA_TYPE POLYBENCH_3D(A_StrictFP,NR,NQ,NP,nr,nq,np),
DATA_TYPE POLYBENCH_2D(C4,NP,NP,np,np)) DATA_TYPE POLYBENCH_2D(C4,NP,NP,np,np))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j, k; int i, j, k;
for (i = 0; i < nr; i++) for (i = 0; i < nr; i++)
for (j = 0; j < nq; j++) for (j = 0; j < nq; j++)
for (k = 0; k < np; k++) for (k = 0; k < np; k++)
A[i][j][k] = ((DATA_TYPE) i*j + k) / np; A_StrictFP[i][j][k] = A[i][j][k] = ((DATA_TYPE) i*j + k) / np;
for (i = 0; i < np; i++) for (i = 0; i < np; i++)
for (j = 0; j < np; j++) for (j = 0; j < np; j++)
C4[i][j] = ((DATA_TYPE) i*j) / np; C4[i][j] = ((DATA_TYPE) i*j) / np;
} }
/* DCE code. Must scan the entire live-out data. /* DCE code. Must scan the entire live-out data.
Can be used also to check the correctness of the output. */ Can be used also to check the correctness of the output. */
Show All 34 Lines sum[r][q][p] = sum[r][q][p] + A[r][q][s] * C4[s][p];
} }
for (p = 0; p < _PB_NR; p++) for (p = 0; p < _PB_NR; p++)
A[r][q][p] = sum[r][q][p]; A[r][q][p] = sum[r][q][p];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static
void kernel_doitgen_StrictFP(int nr, int nq, int np,
DATA_TYPE POLYBENCH_3D(A,NR,NQ,NP,nr,nq,np),
DATA_TYPE POLYBENCH_2D(C4,NP,NP,np,np),
DATA_TYPE POLYBENCH_3D(sum,NR,NQ,NP,nr,nq,np))
{
#pragma STDC FP_CONTRACT OFF
int r, q, p, s;
for (r = 0; r < _PB_NR; r++)
for (q = 0; q < _PB_NQ; q++) {
for (p = 0; p < _PB_NP; p++) {
sum[r][q][p] = 0;
for (s = 0; s < _PB_NP; s++)
sum[r][q][p] = sum[r][q][p] + A[r][q][s] * C4[s][p];
}
for (p = 0; p < _PB_NR; p++)
A[r][q][p] = sum[r][q][p];
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int nr, int nq, int np,
DATA_TYPE POLYBENCH_3D(A,NR,NQ,NP,nr,nq,np),
DATA_TYPE POLYBENCH_3D(B,NR,NQ,NP,nr,nq,np)) {
double AbsTolerance = FP_ABSTOLERANCE;
int r, q, p, s;
for (r = 0; r < _PB_NR; r++)
for (q = 0; q < _PB_NQ; q++)
for (p = 0; p < _PB_NP; p++) {
double V1 = A[r][q][p];
double V2 = B[r][q][p];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d][%d] = %lf and B[%d][%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", r, q, p, V1, r, q, p, V2, AbsTolerance);
return 0;
}
}
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int nr = NR; int nr = NR;
int nq = NQ; int nq = NQ;
int np = NP; int np = NP;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_3D_ARRAY_DECL(A,DATA_TYPE,NR,NQ,NP,nr,nq,np); POLYBENCH_3D_ARRAY_DECL(A,DATA_TYPE,NR,NQ,NP,nr,nq,np);
POLYBENCH_3D_ARRAY_DECL(A_StrictFP,DATA_TYPE,NR,NQ,NP,nr,nq,np);
POLYBENCH_3D_ARRAY_DECL(sum,DATA_TYPE,NR,NQ,NP,nr,nq,np); POLYBENCH_3D_ARRAY_DECL(sum,DATA_TYPE,NR,NQ,NP,nr,nq,np);
POLYBENCH_2D_ARRAY_DECL(C4,DATA_TYPE,NP,NP,np,np); POLYBENCH_2D_ARRAY_DECL(C4,DATA_TYPE,NP,NP,np,np);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (nr, nq, np, init_array (nr, nq, np,
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(A_StrictFP),
POLYBENCH_ARRAY(C4)); POLYBENCH_ARRAY(C4));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_doitgen (nr, nq, np, kernel_doitgen (nr, nq, np,
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(C4), POLYBENCH_ARRAY(C4),
POLYBENCH_ARRAY(sum)); POLYBENCH_ARRAY(sum));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
kernel_doitgen_StrictFP(nr, nq, np,
POLYBENCH_ARRAY(A_StrictFP),
POLYBENCH_ARRAY(C4),
POLYBENCH_ARRAY(sum));
if (!check_FP(nr, nq, np, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(nr, nq, np, POLYBENCH_ARRAY(A))); polybench_prevent_dce(print_array(nr, nq, np, POLYBENCH_ARRAY(A_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(A_StrictFP);
POLYBENCH_FREE_ARRAY(sum); POLYBENCH_FREE_ARRAY(sum);
POLYBENCH_FREE_ARRAY(C4); POLYBENCH_FREE_ARRAY(C4);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemm/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = gemm PROG = gemm
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemm/gemm.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "gemm.h" #include "gemm.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array(int ni, int nj, int nk, void init_array(int ni, int nj, int nk,
DATA_TYPE *alpha, DATA_TYPE *alpha,
DATA_TYPE *beta, DATA_TYPE *beta,
DATA_TYPE POLYBENCH_2D(C,NI,NJ,ni,nj), DATA_TYPE POLYBENCH_2D(C,NI,NJ,ni,nj),
DATA_TYPE POLYBENCH_2D(C_StrictFP,NI,NJ,ni,nj),
DATA_TYPE POLYBENCH_2D(A,NI,NK,ni,nk), DATA_TYPE POLYBENCH_2D(A,NI,NK,ni,nk),
DATA_TYPE POLYBENCH_2D(B,NK,NJ,nk,nj)) DATA_TYPE POLYBENCH_2D(B,NK,NJ,nk,nj))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
*alpha = 32412; *alpha = 32412;
*beta = 2123; *beta = 2123;
for (i = 0; i < ni; i++) for (i = 0; i < ni; i++)
for (j = 0; j < nj; j++) for (j = 0; j < nj; j++)
C[i][j] = ((DATA_TYPE) i*j) / ni; C_StrictFP[i][j] = C[i][j] = ((DATA_TYPE) i*j) / ni;
for (i = 0; i < ni; i++) for (i = 0; i < ni; i++)
for (j = 0; j < nk; j++) for (j = 0; j < nk; j++)
A[i][j] = ((DATA_TYPE) i*j) / ni; A[i][j] = ((DATA_TYPE) i*j) / ni;
for (i = 0; i < nk; i++) for (i = 0; i < nk; i++)
for (j = 0; j < nj; j++) for (j = 0; j < nj; j++)
B[i][j] = ((DATA_TYPE) i*j) / ni; B[i][j] = ((DATA_TYPE) i*j) / ni;
} }
Show All 36 Lines#pragma scop
C[i][j] *= beta; C[i][j] *= beta;
for (k = 0; k < _PB_NK; ++k) for (k = 0; k < _PB_NK; ++k)
C[i][j] += alpha * A[i][k] * B[k][j]; C[i][j] += alpha * A[i][k] * B[k][j];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static
void kernel_gemm_StrictFP(int ni, int nj, int nk,
DATA_TYPE alpha,
DATA_TYPE beta,
DATA_TYPE POLYBENCH_2D(C,NI,NJ,ni,nj),
DATA_TYPE POLYBENCH_2D(A,NI,NK,ni,nk),
DATA_TYPE POLYBENCH_2D(B,NK,NJ,nk,nj))
{
#pragma STDC FP_CONTRACT OFF
int i, j, k;
/* C := alpha*A*B + beta*C */
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NJ; j++)
{
C[i][j] *= beta;
for (k = 0; k < _PB_NK; ++k)
C[i][j] += alpha * A[i][k] * B[k][j];
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int ni, int nk,
DATA_TYPE POLYBENCH_2D(A,NI,NK,ni,nk),
DATA_TYPE POLYBENCH_2D(B,NI,NK,ni,nk)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NK; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int ni = NI; int ni = NI;
int nj = NJ; int nj = NJ;
int nk = NK; int nk = NK;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
DATA_TYPE alpha; DATA_TYPE alpha;
DATA_TYPE beta; DATA_TYPE beta;
POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NJ,ni,nj); POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NJ,ni,nj);
POLYBENCH_2D_ARRAY_DECL(C_StrictFP,DATA_TYPE,NI,NJ,ni,nj);
POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NK,ni,nk); POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NK,ni,nk);
POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NK,NJ,nk,nj); POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NK,NJ,nk,nj);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (ni, nj, nk, &alpha, &beta, init_array (ni, nj, nk, &alpha, &beta,
POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(C),
POLYBENCH_ARRAY(C_StrictFP),
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B)); POLYBENCH_ARRAY(B));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_gemm (ni, nj, nk, kernel_gemm (ni, nj, nk,
alpha, beta, alpha, beta,
POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(C),
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B)); POLYBENCH_ARRAY(B));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
kernel_gemm_StrictFP(ni, nj, nk,
alpha, beta,
POLYBENCH_ARRAY(C_StrictFP),
POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B));
if (!check_FP(ni, nk, POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(C_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(ni, nj, POLYBENCH_ARRAY(C))); polybench_prevent_dce(print_array(ni, nj, POLYBENCH_ARRAY(C_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(C); POLYBENCH_FREE_ARRAY(C);
POLYBENCH_FREE_ARRAY(C_StrictFP);
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(B); POLYBENCH_FREE_ARRAY(B);
return 0; return 0;
} }

test-suite/trunk/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)
if(ARCH STREQUAL "XCore") if(ARCH STREQUAL "XCore")
set(XCORE_TARGET_NEEDS_MEMORY 128) set(XCORE_TARGET_NEEDS_MEMORY 128)
endif() endif()
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = gemver PROG = gemver
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
ifeq ($(ARCH),XCore) ifeq ($(ARCH),XCore)
XCORE_TARGET_NEEDS_MEMORY := 128 XCORE_TARGET_NEEDS_MEMORY := 128
endif endif
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemver/gemver.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "gemver.h" #include "gemver.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array (int n, void init_array (int n,
DATA_TYPE *alpha, DATA_TYPE *alpha,
DATA_TYPE *beta, DATA_TYPE *beta,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n), DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_1D(u1,N,n), DATA_TYPE POLYBENCH_1D(u1,N,n),
DATA_TYPE POLYBENCH_1D(v1,N,n), DATA_TYPE POLYBENCH_1D(v1,N,n),
DATA_TYPE POLYBENCH_1D(u2,N,n), DATA_TYPE POLYBENCH_1D(u2,N,n),
DATA_TYPE POLYBENCH_1D(v2,N,n), DATA_TYPE POLYBENCH_1D(v2,N,n),
DATA_TYPE POLYBENCH_1D(w,N,n), DATA_TYPE POLYBENCH_1D(w,N,n),
DATA_TYPE POLYBENCH_1D(x,N,n), DATA_TYPE POLYBENCH_1D(w_StrictFP,N,n),
DATA_TYPE POLYBENCH_1D(y,N,n), DATA_TYPE POLYBENCH_1D(y,N,n),
DATA_TYPE POLYBENCH_1D(z,N,n)) DATA_TYPE POLYBENCH_1D(z,N,n))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
*alpha = 43532; *alpha = 43532;
*beta = 12313; *beta = 12313;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
u1[i] = i; u1[i] = i;
u2[i] = (i+1)/n/2.0; u2[i] = (i+1)/n/2.0;
v1[i] = (i+1)/n/4.0; v1[i] = (i+1)/n/4.0;
v2[i] = (i+1)/n/6.0; v2[i] = (i+1)/n/6.0;
y[i] = (i+1)/n/8.0; y[i] = (i+1)/n/8.0;
z[i] = (i+1)/n/9.0; z[i] = (i+1)/n/9.0;
x[i] = 0.0; w_StrictFP[i] = w[i] = 0.0;
w[i] = 0.0;
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
A[i][j] = ((DATA_TYPE) i*j) / n; A[i][j] = ((DATA_TYPE) i*j) / n;
} }
} }
/* DCE code. Must scan the entire live-out data. /* DCE code. Must scan the entire live-out data.
Can be used also to check the correctness of the output. */ Can be used also to check the correctness of the output. */
Show All 11 Lines
/* Main computational kernel. The whole function will be timed, /* Main computational kernel. The whole function will be timed,
including the call and return. */ including the call and return. */
static static
void kernel_gemver(int n, void kernel_gemver(int n,
DATA_TYPE alpha, DATA_TYPE alpha,
DATA_TYPE beta, DATA_TYPE beta,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n), DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_2D(A_tmp,N,N,n,n),
DATA_TYPE POLYBENCH_1D(u1,N,n), DATA_TYPE POLYBENCH_1D(u1,N,n),
DATA_TYPE POLYBENCH_1D(v1,N,n), DATA_TYPE POLYBENCH_1D(v1,N,n),
DATA_TYPE POLYBENCH_1D(u2,N,n), DATA_TYPE POLYBENCH_1D(u2,N,n),
DATA_TYPE POLYBENCH_1D(v2,N,n), DATA_TYPE POLYBENCH_1D(v2,N,n),
DATA_TYPE POLYBENCH_1D(w,N,n), DATA_TYPE POLYBENCH_1D(w,N,n),
DATA_TYPE POLYBENCH_1D(x,N,n), DATA_TYPE POLYBENCH_1D(x,N,n),
DATA_TYPE POLYBENCH_1D(y,N,n), DATA_TYPE POLYBENCH_1D(y,N,n),
DATA_TYPE POLYBENCH_1D(z,N,n)) DATA_TYPE POLYBENCH_1D(z,N,n))
{ {
int i, j; int i, j;
#pragma scop #pragma scop
for (i = 0; i < _PB_N; i++) for (i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_N; j++) for (j = 0; j < _PB_N; j++)
A[i][j] = A[i][j] + u1[i] * v1[j] + u2[i] * v2[j]; A_tmp[i][j] = A[i][j] + u1[i] * v1[j] + u2[i] * v2[j];
for (i = 0; i < _PB_N; i++) for (i = 0; i < _PB_N; i++) {
x[i] = 0.0;
for (j = 0; j < _PB_N; j++) for (j = 0; j < _PB_N; j++)
x[i] = x[i] + beta * A[j][i] * y[j]; x[i] = x[i] + beta * A_tmp[j][i] * y[j];
}
for (i = 0; i < _PB_N; i++) for (i = 0; i < _PB_N; i++)
x[i] = x[i] + z[i]; x[i] = x[i] + z[i];
for (i = 0; i < _PB_N; i++) for (i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_N; j++) for (j = 0; j < _PB_N; j++)
w[i] = w[i] + alpha * A[i][j] * x[j]; w[i] = w[i] + alpha * A_tmp[i][j] * x[j];
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static
void kernel_gemver_StrictFP(int n,
DATA_TYPE alpha,
DATA_TYPE beta,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_2D(A_tmp,N,N,n,n),
DATA_TYPE POLYBENCH_1D(u1,N,n),
DATA_TYPE POLYBENCH_1D(v1,N,n),
DATA_TYPE POLYBENCH_1D(u2,N,n),
DATA_TYPE POLYBENCH_1D(v2,N,n),
DATA_TYPE POLYBENCH_1D(w,N,n),
DATA_TYPE POLYBENCH_1D(x,N,n),
DATA_TYPE POLYBENCH_1D(y,N,n),
DATA_TYPE POLYBENCH_1D(z,N,n))
{
#pragma STDC FP_CONTRACT OFF
int i, j;
for (i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_N; j++)
A_tmp[i][j] = A[i][j] + u1[i] * v1[j] + u2[i] * v2[j];
for (i = 0; i < _PB_N; i++) {
x[i] = 0.0;
for (j = 0; j < _PB_N; j++)
x[i] = x[i] + beta * A_tmp[j][i] * y[j];
}
for (i = 0; i < _PB_N; i++)
x[i] = x[i] + z[i];
for (i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_N; j++)
w[i] = w[i] + alpha * A_tmp[i][j] * x[j];
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static int
check_FP(int n,
DATA_TYPE POLYBENCH_1D(A,N,n),
DATA_TYPE POLYBENCH_1D(B,N,n)) {
int i;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_N; i++)
{
double V1 = A[i];
double V2 = B[i];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d] = %lf and B[%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, V1, i, V2, AbsTolerance);
return 0;
}
}
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int n = N; int n = N;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
DATA_TYPE alpha; DATA_TYPE alpha;
DATA_TYPE beta; DATA_TYPE beta;
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n);
POLYBENCH_2D_ARRAY_DECL(A_tmp, DATA_TYPE, N, N, n, n);
POLYBENCH_1D_ARRAY_DECL(u1, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(u1, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(v1, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(v1, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(u2, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(u2, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(v2, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(v2, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(w, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(w, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(w_StrictFP, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(z, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(z, DATA_TYPE, N, n);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (n, &alpha, &beta, init_array (n, &alpha, &beta,
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(u1), POLYBENCH_ARRAY(u1),
POLYBENCH_ARRAY(v1), POLYBENCH_ARRAY(v1),
POLYBENCH_ARRAY(u2), POLYBENCH_ARRAY(u2),
POLYBENCH_ARRAY(v2), POLYBENCH_ARRAY(v2),
POLYBENCH_ARRAY(w), POLYBENCH_ARRAY(w),
POLYBENCH_ARRAY(x), POLYBENCH_ARRAY(w_StrictFP),
POLYBENCH_ARRAY(y), POLYBENCH_ARRAY(y),
POLYBENCH_ARRAY(z)); POLYBENCH_ARRAY(z));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_gemver (n, alpha, beta, kernel_gemver (n, alpha, beta,
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(A_tmp),
POLYBENCH_ARRAY(u1), POLYBENCH_ARRAY(u1),
POLYBENCH_ARRAY(v1), POLYBENCH_ARRAY(v1),
POLYBENCH_ARRAY(u2), POLYBENCH_ARRAY(u2),
POLYBENCH_ARRAY(v2), POLYBENCH_ARRAY(v2),
POLYBENCH_ARRAY(w), POLYBENCH_ARRAY(w),
POLYBENCH_ARRAY(x), POLYBENCH_ARRAY(x),
POLYBENCH_ARRAY(y), POLYBENCH_ARRAY(y),
POLYBENCH_ARRAY(z)); POLYBENCH_ARRAY(z));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
kernel_gemver_StrictFP(n, alpha, beta,
POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(A_tmp),
POLYBENCH_ARRAY(u1),
POLYBENCH_ARRAY(v1),
POLYBENCH_ARRAY(u2),
POLYBENCH_ARRAY(v2),
POLYBENCH_ARRAY(w_StrictFP),
POLYBENCH_ARRAY(x),
POLYBENCH_ARRAY(y),
POLYBENCH_ARRAY(z));
if (!check_FP(n, POLYBENCH_ARRAY(w), POLYBENCH_ARRAY(w_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(w))); polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(w_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(A_tmp);
POLYBENCH_FREE_ARRAY(u1); POLYBENCH_FREE_ARRAY(u1);
POLYBENCH_FREE_ARRAY(v1); POLYBENCH_FREE_ARRAY(v1);
POLYBENCH_FREE_ARRAY(u2); POLYBENCH_FREE_ARRAY(u2);
POLYBENCH_FREE_ARRAY(v2); POLYBENCH_FREE_ARRAY(v2);
POLYBENCH_FREE_ARRAY(w); POLYBENCH_FREE_ARRAY(w);
POLYBENCH_FREE_ARRAY(w_StrictFP);
POLYBENCH_FREE_ARRAY(x); POLYBENCH_FREE_ARRAY(x);
POLYBENCH_FREE_ARRAY(y); POLYBENCH_FREE_ARRAY(y);
POLYBENCH_FREE_ARRAY(z); POLYBENCH_FREE_ARRAY(z);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = gesummv PROG = gesummv
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
else else
ifeq ($(ARCH),XCore) ifeq ($(ARCH),XCore)
XCORE_TARGET_NEEDS_MEMORY := 256 XCORE_TARGET_NEEDS_MEMORY := 256
endif endif
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/gesummv.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "gesummv.h" #include "gesummv.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array(int n, void init_array(int n,
DATA_TYPE *alpha, DATA_TYPE *alpha,
DATA_TYPE *beta, DATA_TYPE *beta,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n), DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_2D(B,N,N,n,n), DATA_TYPE POLYBENCH_2D(B,N,N,n,n),
DATA_TYPE POLYBENCH_1D(x,N,n)) DATA_TYPE POLYBENCH_1D(x,N,n))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
*alpha = 43532; *alpha = 43532;
*beta = 12313; *beta = 12313;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
x[i] = ((DATA_TYPE) i) / n; x[i] = ((DATA_TYPE) i) / n;
for (j = 0; j < n; j++) { for (j = 0; j < n; j++) {
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines for (i = 0; i < _PB_N; i++)
y[i] = B[i][j] * x[j] + y[i]; y[i] = B[i][j] * x[j] + y[i];
} }
y[i] = alpha * tmp[i] + beta * y[i]; y[i] = alpha * tmp[i] + beta * y[i];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static
void kernel_gesummv_StrictFP(int n,
DATA_TYPE alpha,
DATA_TYPE beta,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_2D(B,N,N,n,n),
DATA_TYPE POLYBENCH_1D(tmp,N,n),
DATA_TYPE POLYBENCH_1D(x,N,n),
DATA_TYPE POLYBENCH_1D(y,N,n))
{
#pragma STDC FP_CONTRACT OFF
int i, j;
for (i = 0; i < _PB_N; i++)
{
tmp[i] = 0;
y[i] = 0;
for (j = 0; j < _PB_N; j++)
{
tmp[i] = A[i][j] * x[j] + tmp[i];
y[i] = B[i][j] * x[j] + y[i];
}
y[i] = alpha * tmp[i] + beta * y[i];
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static int
check_FP(int n,
DATA_TYPE POLYBENCH_1D(A,N,n),
DATA_TYPE POLYBENCH_1D(B,N,n)) {
int i;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_N; i++)
{
double V1 = A[i];
double V2 = B[i];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d] = %lf and B[%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, V1, i, V2, AbsTolerance);
return 0;
}
}
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int n = N; int n = N;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
DATA_TYPE alpha; DATA_TYPE alpha;
DATA_TYPE beta; DATA_TYPE beta;
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n);
POLYBENCH_2D_ARRAY_DECL(B, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(B, DATA_TYPE, N, N, n, n);
POLYBENCH_1D_ARRAY_DECL(tmp, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(tmp, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(y_StrictFP, DATA_TYPE, N, n);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (n, &alpha, &beta, init_array (n, &alpha, &beta,
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B), POLYBENCH_ARRAY(B),
POLYBENCH_ARRAY(x)); POLYBENCH_ARRAY(x));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_gesummv (n, alpha, beta, kernel_gesummv (n, alpha, beta,
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B), POLYBENCH_ARRAY(B),
POLYBENCH_ARRAY(tmp), POLYBENCH_ARRAY(tmp),
POLYBENCH_ARRAY(x), POLYBENCH_ARRAY(x),
POLYBENCH_ARRAY(y)); POLYBENCH_ARRAY(y));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
kernel_gesummv_StrictFP(n, alpha, beta,
POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B),
POLYBENCH_ARRAY(tmp),
POLYBENCH_ARRAY(x),
POLYBENCH_ARRAY(y_StrictFP));
if (!check_FP(n, POLYBENCH_ARRAY(y), POLYBENCH_ARRAY(y_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(y))); polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(y_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(B); POLYBENCH_FREE_ARRAY(B);
POLYBENCH_FREE_ARRAY(tmp); POLYBENCH_FREE_ARRAY(tmp);
POLYBENCH_FREE_ARRAY(x); POLYBENCH_FREE_ARRAY(x);
POLYBENCH_FREE_ARRAY(y); POLYBENCH_FREE_ARRAY(y);
return 0; return 0;
} }

test-suite/trunk/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)
if(ARCH STREQUAL "XCore") if(ARCH STREQUAL "XCore")
set(XCORE_TARGET_NEEDS_MEMORY 128) set(XCORE_TARGET_NEEDS_MEMORY 128)
endif() endif()
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/mvt/mvt.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "mvt.h" #include "mvt.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array(int n, void init_array(int n,
DATA_TYPE POLYBENCH_1D(x1,N,n), DATA_TYPE POLYBENCH_1D(x1,N,n),
DATA_TYPE POLYBENCH_1D(x2,N,n), DATA_TYPE POLYBENCH_1D(x2,N,n),
DATA_TYPE POLYBENCH_1D(x1_StrictFP,N,n),
DATA_TYPE POLYBENCH_1D(x2_StrictFP,N,n),
DATA_TYPE POLYBENCH_1D(y_1,N,n), DATA_TYPE POLYBENCH_1D(y_1,N,n),
DATA_TYPE POLYBENCH_1D(y_2,N,n), DATA_TYPE POLYBENCH_1D(y_2,N,n),
DATA_TYPE POLYBENCH_2D(A,N,N,n,n)) DATA_TYPE POLYBENCH_2D(A,N,N,n,n))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
x1[i] = ((DATA_TYPE) i) / n; x1_StrictFP[i] = x1[i] = ((DATA_TYPE) i) / n;
x2[i] = ((DATA_TYPE) i + 1) / n; x2_StrictFP[i] = x2[i] = ((DATA_TYPE) i + 1) / n;
y_1[i] = ((DATA_TYPE) i + 3) / n; y_1[i] = ((DATA_TYPE) i + 3) / n;
y_2[i] = ((DATA_TYPE) i + 4) / n; y_2[i] = ((DATA_TYPE) i + 4) / n;
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
A[i][j] = ((DATA_TYPE) i*j) / N; A[i][j] = ((DATA_TYPE) i*j) / N;
} }
} }
Show All 36 Lines for (j = 0; j < _PB_N; j++)
x1[i] = x1[i] + A[i][j] * y_1[j]; x1[i] = x1[i] + A[i][j] * y_1[j];
for (i = 0; i < _PB_N; i++) for (i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_N; j++) for (j = 0; j < _PB_N; j++)
x2[i] = x2[i] + A[j][i] * y_2[j]; x2[i] = x2[i] + A[j][i] * y_2[j];
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static
void kernel_mvt_StrictFP(int n,
DATA_TYPE POLYBENCH_1D(x1,N,n),
DATA_TYPE POLYBENCH_1D(x2,N,n),
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))
{
#pragma STDC FP_CONTRACT OFF
int i, j;
for (i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_N; j++)
x1[i] = x1[i] + A[i][j] * y_1[j];
for (i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_N; j++)
x2[i] = x2[i] + A[j][i] * y_2[j];
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static int
check_FP(int n,
DATA_TYPE POLYBENCH_1D(A,N,n),
DATA_TYPE POLYBENCH_1D(B,N,n)) {
int i;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_N; i++)
{
double V1 = A[i];
double V2 = B[i];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d] = %lf and B[%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, V1, i, V2, AbsTolerance);
return 0;
}
}
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int n = N; int n = N;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n);
POLYBENCH_1D_ARRAY_DECL(x1, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(x1, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(x2, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(x2, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(x1_StrictFP, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(x2_StrictFP, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(y_1, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(y_1, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(y_2, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(y_2, DATA_TYPE, N, n);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (n, init_array (n,
POLYBENCH_ARRAY(x1), POLYBENCH_ARRAY(x1),
POLYBENCH_ARRAY(x2), POLYBENCH_ARRAY(x2),
POLYBENCH_ARRAY(x1_StrictFP),
POLYBENCH_ARRAY(x2_StrictFP),
POLYBENCH_ARRAY(y_1), POLYBENCH_ARRAY(y_1),
POLYBENCH_ARRAY(y_2), POLYBENCH_ARRAY(y_2),
POLYBENCH_ARRAY(A)); POLYBENCH_ARRAY(A));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_mvt (n, kernel_mvt (n,
POLYBENCH_ARRAY(x1), POLYBENCH_ARRAY(x1),
POLYBENCH_ARRAY(x2), POLYBENCH_ARRAY(x2),
POLYBENCH_ARRAY(y_1), POLYBENCH_ARRAY(y_1),
POLYBENCH_ARRAY(y_2), POLYBENCH_ARRAY(y_2),
POLYBENCH_ARRAY(A)); POLYBENCH_ARRAY(A));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
kernel_mvt_StrictFP(n,
POLYBENCH_ARRAY(x1_StrictFP),
POLYBENCH_ARRAY(x2_StrictFP),
POLYBENCH_ARRAY(y_1),
POLYBENCH_ARRAY(y_2),
POLYBENCH_ARRAY(A));
if (!check_FP(n, POLYBENCH_ARRAY(x1), POLYBENCH_ARRAY(x1_StrictFP)))
return 1;
if (!check_FP(n, POLYBENCH_ARRAY(x2), POLYBENCH_ARRAY(x2_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x1), POLYBENCH_ARRAY(x2))); polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x1_StrictFP),
POLYBENCH_ARRAY(x2_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(x1); POLYBENCH_FREE_ARRAY(x1);
POLYBENCH_FREE_ARRAY(x2); POLYBENCH_FREE_ARRAY(x2);
POLYBENCH_FREE_ARRAY(x1_StrictFP);
POLYBENCH_FREE_ARRAY(x2_StrictFP);
POLYBENCH_FREE_ARRAY(y_1); POLYBENCH_FREE_ARRAY(y_1);
POLYBENCH_FREE_ARRAY(y_2); POLYBENCH_FREE_ARRAY(y_2);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=10)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = symm PROG = symm
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=10
ifeq ($(ARCH),Mips) ifeq ($(ARCH),Mips)
RUNTIMELIMIT := 2000 RUNTIMELIMIT := 2000
endif endif
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/symm.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "symm.h" #include "symm.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array(int ni, int nj, void init_array(int ni, int nj,
DATA_TYPE *alpha, DATA_TYPE *alpha,
DATA_TYPE *beta, DATA_TYPE *beta,
DATA_TYPE POLYBENCH_2D(C,NI,NJ,ni,nj), DATA_TYPE POLYBENCH_2D(C,NI,NJ,ni,nj),
DATA_TYPE POLYBENCH_2D(C_StrictFP,NI,NJ,ni,nj),
DATA_TYPE POLYBENCH_2D(A,NJ,NJ,nj,nj), DATA_TYPE POLYBENCH_2D(A,NJ,NJ,nj,nj),
DATA_TYPE POLYBENCH_2D(B,NI,NJ,ni,nj)) DATA_TYPE POLYBENCH_2D(B,NI,NJ,ni,nj))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
*alpha = 32412; *alpha = 32412;
*beta = 2123; *beta = 2123;
for (i = 0; i < ni; i++) for (i = 0; i < ni; i++)
for (j = 0; j < nj; j++) { for (j = 0; j < nj; j++) {
C[i][j] = ((DATA_TYPE) i*j) / ni; C_StrictFP[i][j] = C[i][j] = ((DATA_TYPE) i*j) / ni;
B[i][j] = ((DATA_TYPE) i*j) / ni; B[i][j] = ((DATA_TYPE) i*j) / ni;
} }
for (i = 0; i < nj; i++) for (i = 0; i < nj; i++)
for (j = 0; j < nj; j++) for (j = 0; j < nj; j++)
A[i][j] = ((DATA_TYPE) i*j) / ni; A[i][j] = ((DATA_TYPE) i*j) / ni;
} }
Show All 40 Lines for (k = 0; k < j - 1; k++)
acc += B[k][j] * A[k][i]; acc += B[k][j] * A[k][i];
} }
C[i][j] = beta * C[i][j] + alpha * A[i][i] * B[i][j] + alpha * acc; C[i][j] = beta * C[i][j] + alpha * A[i][i] * B[i][j] + alpha * acc;
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static
void kernel_symm_StrictFP(int ni, int nj,
DATA_TYPE alpha,
DATA_TYPE beta,
DATA_TYPE POLYBENCH_2D(C,NI,NJ,ni,nj),
DATA_TYPE POLYBENCH_2D(A,NJ,NJ,nj,nj),
DATA_TYPE POLYBENCH_2D(B,NI,NJ,ni,nj))
{
#pragma STDC FP_CONTRACT OFF
int i, j, k;
DATA_TYPE acc;
/* C := alpha*A*B + beta*C, A is symetric */
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NJ; j++)
{
acc = 0;
for (k = 0; k < j - 1; k++)
{
C[k][j] += alpha * A[k][i] * B[i][j];
acc += B[k][j] * A[k][i];
}
C[i][j] = beta * C[i][j] + alpha * A[i][i] * B[i][j] + alpha * acc;
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int ni, int nj,
DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj),
DATA_TYPE POLYBENCH_2D(B,NI,NJ,ni,nj)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NJ; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int ni = NI; int ni = NI;
int nj = NJ; int nj = NJ;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
DATA_TYPE alpha; DATA_TYPE alpha;
DATA_TYPE beta; DATA_TYPE beta;
POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NJ,ni,nj); POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NJ,ni,nj);
POLYBENCH_2D_ARRAY_DECL(C_StrictFP,DATA_TYPE,NI,NJ,ni,nj);
POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NJ,NJ,nj,nj); POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NJ,NJ,nj,nj);
POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NI,NJ,ni,nj); POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NI,NJ,ni,nj);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (ni, nj, &alpha, &beta, init_array (ni, nj, &alpha, &beta,
POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(C),
POLYBENCH_ARRAY(C_StrictFP),
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B)); POLYBENCH_ARRAY(B));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_symm (ni, nj, kernel_symm (ni, nj,
alpha, beta, alpha, beta,
POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(C),
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B)); POLYBENCH_ARRAY(B));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
kernel_symm_StrictFP(ni, nj,
alpha, beta,
POLYBENCH_ARRAY(C_StrictFP),
POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B));
if (!check_FP(ni, nj, POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(C_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(ni, nj, POLYBENCH_ARRAY(C))); polybench_prevent_dce(print_array(ni, nj, POLYBENCH_ARRAY(C_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(C); POLYBENCH_FREE_ARRAY(C);
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(B); POLYBENCH_FREE_ARRAY(B);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syr2k/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = syr2k PROG = syr2k
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syr2k/syr2k.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "syr2k.h" #include "syr2k.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array(int ni, int nj, void init_array(int ni, int nj,
DATA_TYPE *alpha, DATA_TYPE *alpha,
DATA_TYPE *beta, DATA_TYPE *beta,
DATA_TYPE POLYBENCH_2D(C,NI,NI,ni,ni), DATA_TYPE POLYBENCH_2D(C,NI,NI,ni,ni),
DATA_TYPE POLYBENCH_2D(C_StrictFP,NI,NI,ni,ni),
DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj), DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj),
DATA_TYPE POLYBENCH_2D(B,NI,NJ,ni,nj)) DATA_TYPE POLYBENCH_2D(B,NI,NJ,ni,nj))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
*alpha = 32412; *alpha = 32412;
*beta = 2123; *beta = 2123;
for (i = 0; i < ni; i++) for (i = 0; i < ni; i++)
for (j = 0; j < nj; j++) { for (j = 0; j < nj; j++) {
A[i][j] = ((DATA_TYPE) i*j) / ni; A[i][j] = ((DATA_TYPE) i*j) / ni;
B[i][j] = ((DATA_TYPE) i*j) / ni; B[i][j] = ((DATA_TYPE) i*j) / ni;
} }
for (i = 0; i < ni; i++) for (i = 0; i < ni; i++)
for (j = 0; j < ni; j++) for (j = 0; j < ni; j++)
C[i][j] = ((DATA_TYPE) i*j) / ni; C_StrictFP[i][j] = C[i][j] = ((DATA_TYPE) i*j) / ni;
} }
/* DCE code. Must scan the entire live-out data. /* DCE code. Must scan the entire live-out data.
Can be used also to check the correctness of the output. */ Can be used also to check the correctness of the output. */
static static
void print_array(int ni, void print_array(int ni,
DATA_TYPE POLYBENCH_2D(C,NI,NI,ni,ni)) DATA_TYPE POLYBENCH_2D(C,NI,NI,ni,ni))
Show All 33 Lines#pragma scop
{ {
C[i][j] += alpha * A[i][k] * B[j][k]; C[i][j] += alpha * A[i][k] * B[j][k];
C[i][j] += alpha * B[i][k] * A[j][k]; C[i][j] += alpha * B[i][k] * A[j][k];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_syr2k_StrictFP(int ni, int nj,
DATA_TYPE alpha,
DATA_TYPE beta,
DATA_TYPE POLYBENCH_2D(C,NI,NI,ni,ni),
DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj),
DATA_TYPE POLYBENCH_2D(B,NI,NJ,ni,nj))
{
#pragma STDC FP_CONTRACT OFF
int i, j, k;
/* C := alpha*A*B' + alpha*B*A' + beta*C */
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NI; j++)
C[i][j] *= beta;
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NI; j++)
for (k = 0; k < _PB_NJ; k++)
{
C[i][j] += alpha * A[i][k] * B[j][k];
C[i][j] += alpha * B[i][k] * A[j][k];
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int ni,
DATA_TYPE POLYBENCH_2D(A,NI,NI,ni,ni),
DATA_TYPE POLYBENCH_2D(B,NI,NI,ni,ni)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NI; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int ni = NI; int ni = NI;
int nj = NJ; int nj = NJ;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
DATA_TYPE alpha; DATA_TYPE alpha;
DATA_TYPE beta; DATA_TYPE beta;
POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NI,ni,ni); POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NI,ni,ni);
POLYBENCH_2D_ARRAY_DECL(C_StrictFP,DATA_TYPE,NI,NI,ni,ni);
POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NJ,ni,nj); POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NJ,ni,nj);
POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NI,NJ,ni,nj); POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NI,NJ,ni,nj);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (ni, nj, &alpha, &beta, init_array (ni, nj, &alpha, &beta,
POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(C),
POLYBENCH_ARRAY(C_StrictFP),
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B)); POLYBENCH_ARRAY(B));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_syr2k (ni, nj, kernel_syr2k (ni, nj,
alpha, beta, alpha, beta,
POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(C),
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B)); POLYBENCH_ARRAY(B));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
kernel_syr2k_StrictFP(ni, nj,
alpha, beta,
POLYBENCH_ARRAY(C_StrictFP),
POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B));
if (!check_FP(ni, POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(C_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(C))); polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(C_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(C); POLYBENCH_FREE_ARRAY(C);
POLYBENCH_FREE_ARRAY(C_StrictFP);
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(B); POLYBENCH_FREE_ARRAY(B);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syrk/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = syrk PROG = syrk
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syrk/syrk.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "syrk.h" #include "syrk.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array(int ni, int nj, void init_array(int ni, int nj,
DATA_TYPE *alpha, DATA_TYPE *alpha,
DATA_TYPE *beta, DATA_TYPE *beta,
DATA_TYPE POLYBENCH_2D(C,NI,NI,ni,ni), DATA_TYPE POLYBENCH_2D(C,NI,NI,ni,ni),
DATA_TYPE POLYBENCH_2D(C_StrictFP,NI,NI,ni,ni),
DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj)) DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
*alpha = 32412; *alpha = 32412;
*beta = 2123; *beta = 2123;
for (i = 0; i < ni; i++) for (i = 0; i < ni; i++)
for (j = 0; j < nj; j++) for (j = 0; j < nj; j++)
A[i][j] = ((DATA_TYPE) i*j) / ni; A[i][j] = ((DATA_TYPE) i*j) / ni;
for (i = 0; i < ni; i++) for (i = 0; i < ni; i++)
for (j = 0; j < ni; j++) for (j = 0; j < ni; j++)
C[i][j] = ((DATA_TYPE) i*j) / ni; C_StrictFP[i][j] = C[i][j] = ((DATA_TYPE) i*j) / ni;
} }
/* DCE code. Must scan the entire live-out data. /* DCE code. Must scan the entire live-out data.
Can be used also to check the correctness of the output. */ Can be used also to check the correctness of the output. */
static static
void print_array(int ni, void print_array(int ni,
DATA_TYPE POLYBENCH_2D(C,NI,NI,ni,ni)) DATA_TYPE POLYBENCH_2D(C,NI,NI,ni,ni))
Show All 29 Lines#pragma scop
for (i = 0; i < _PB_NI; i++) for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NI; j++) for (j = 0; j < _PB_NI; j++)
for (k = 0; k < _PB_NJ; k++) for (k = 0; k < _PB_NJ; k++)
C[i][j] += alpha * A[i][k] * A[j][k]; C[i][j] += alpha * A[i][k] * A[j][k];
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static
void kernel_syrk_StrictFP(int ni, int nj,
DATA_TYPE alpha,
DATA_TYPE beta,
DATA_TYPE POLYBENCH_2D(C,NI,NI,ni,ni),
DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj))
{
#pragma STDC FP_CONTRACT OFF
int i, j, k;
/* C := alpha*A*A' + beta*C */
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NI; j++)
C[i][j] *= beta;
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NI; j++)
for (k = 0; k < _PB_NJ; k++)
C[i][j] += alpha * A[i][k] * A[j][k];
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int ni,
DATA_TYPE POLYBENCH_2D(A,NI,NI,ni,ni),
DATA_TYPE POLYBENCH_2D(B,NI,NI,ni,ni)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NI; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int ni = NI; int ni = NI;
int nj = NJ; int nj = NJ;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
DATA_TYPE alpha; DATA_TYPE alpha;
DATA_TYPE beta; DATA_TYPE beta;
POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NI,ni,ni); POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,NI,NI,ni,ni);
POLYBENCH_2D_ARRAY_DECL(C_StrictFP,DATA_TYPE,NI,NI,ni,ni);
POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NJ,ni,nj); POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NJ,ni,nj);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (ni, nj, &alpha, &beta, POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(A)); init_array (ni, nj, &alpha, &beta, POLYBENCH_ARRAY(C),
POLYBENCH_ARRAY(C_StrictFP), POLYBENCH_ARRAY(A));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_syrk (ni, nj, alpha, beta, POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(A)); kernel_syrk (ni, nj, alpha, beta, POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(A));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
kernel_syrk_StrictFP(ni, nj, alpha, beta, POLYBENCH_ARRAY(C_StrictFP),
POLYBENCH_ARRAY(A));
if (!check_FP(ni, POLYBENCH_ARRAY(C), POLYBENCH_ARRAY(C_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(C))); polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(C_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(C); POLYBENCH_FREE_ARRAY(C);
POLYBENCH_FREE_ARRAY(C_StrictFP);
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
return 0; return 0;
} }

test-suite/trunk/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)
if(ARCH STREQUAL "XCore") if(ARCH STREQUAL "XCore")
set(XCORE_TARGET_NEEDS_MEMORY 128) set(XCORE_TARGET_NEEDS_MEMORY 128)
endif() endif()
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = trisolv PROG = trisolv
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
ifeq ($(ARCH),XCore) ifeq ($(ARCH),XCore)
XCORE_TARGET_NEEDS_MEMORY := 128 XCORE_TARGET_NEEDS_MEMORY := 128
endif endif
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/trisolv.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "trisolv.h" #include "trisolv.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array(int n, void init_array(int n,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n), DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_1D(x,N,n), DATA_TYPE POLYBENCH_1D(x,N,n),
DATA_TYPE POLYBENCH_1D(x_StrictFP,N,n),
DATA_TYPE POLYBENCH_1D(c,N,n)) DATA_TYPE POLYBENCH_1D(c,N,n))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
/* /*
LLVM: This change ensures we do not calculate nan values, which are LLVM: This change ensures we do not calculate nan values, which are
formatted differently on different platforms and which may also formatted differently on different platforms and which may also
be optimized unexpectedly. be optimized unexpectedly.
Original code: Original code:
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
c[i] = x[i] = ((DATA_TYPE) i) / n; c[i] = x[i] = ((DATA_TYPE) i) / n;
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
A[i][j] = ((DATA_TYPE) i*j) / n; A[i][j] = ((DATA_TYPE) i*j) / n;
} }
*/ */
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
c[i] = x[i] = ((DATA_TYPE) i+n) / n; c[i] = x_StrictFP[i] = x[i] = ((DATA_TYPE) i+n) / n;
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
A[i][j] = ((DATA_TYPE) i*j+n) / n; A[i][j] = ((DATA_TYPE) i*j+n) / n;
} }
} }
/* DCE code. Must scan the entire live-out data. /* DCE code. Must scan the entire live-out data.
Can be used also to check the correctness of the output. */ Can be used also to check the correctness of the output. */
Show All 29 Lines for (i = 0; i < _PB_N; i++)
for (j = 0; j <= i - 1; j++) for (j = 0; j <= i - 1; j++)
x[i] = x[i] - A[i][j] * x[j]; x[i] = x[i] - A[i][j] * x[j];
x[i] = x[i] / A[i][i]; x[i] = x[i] / A[i][i];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_trisolv_StrictFP(int n,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_1D(x,N,n),
DATA_TYPE POLYBENCH_1D(c,N,n))
{
#pragma STDC FP_CONTRACT OFF
int i, j;
for (i = 0; i < _PB_N; i++)
{
x[i] = c[i];
for (j = 0; j <= i - 1; j++)
x[i] = x[i] - A[i][j] * x[j];
x[i] = x[i] / A[i][i];
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static int
check_FP(int n,
DATA_TYPE POLYBENCH_1D(A,N,n),
DATA_TYPE POLYBENCH_1D(B,N,n)) {
int i;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_N; i++)
{
double V1 = A[i];
double V2 = B[i];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d] = %lf and B[%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, V1, i, V2, AbsTolerance);
return 0;
}
}
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int n = N; int n = N;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n);
POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(x_StrictFP, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(c, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(c, DATA_TYPE, N, n);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(x), POLYBENCH_ARRAY(c)); init_array (n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(x),
POLYBENCH_ARRAY(x_StrictFP), POLYBENCH_ARRAY(c));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_trisolv (n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(x), POLYBENCH_ARRAY(c)); kernel_trisolv (n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(x), POLYBENCH_ARRAY(c));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
kernel_trisolv (n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(x_StrictFP), POLYBENCH_ARRAY(c));
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x))); polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(x); POLYBENCH_FREE_ARRAY(x);
POLYBENCH_FREE_ARRAY(x_StrictFP);
POLYBENCH_FREE_ARRAY(c); POLYBENCH_FREE_ARRAY(c);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = trmm PROG = trmm
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/trmm.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "trmm.h" #include "trmm.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array(int ni, void init_array(int ni,
DATA_TYPE *alpha, DATA_TYPE *alpha,
DATA_TYPE POLYBENCH_2D(A,NI,NI,ni,ni), DATA_TYPE POLYBENCH_2D(A,NI,NI,ni,ni),
DATA_TYPE POLYBENCH_2D(B,NI,NI,ni,ni)) DATA_TYPE POLYBENCH_2D(B,NI,NI,ni,ni),
DATA_TYPE POLYBENCH_2D(B_StrictFP,NI,NI,ni,ni))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
*alpha = 32412; *alpha = 32412;
for (i = 0; i < ni; i++) for (i = 0; i < ni; i++)
for (j = 0; j < ni; j++) { for (j = 0; j < ni; j++) {
A[i][j] = ((DATA_TYPE) i*j) / ni; A[i][j] = ((DATA_TYPE) i*j) / ni;
B[i][j] = ((DATA_TYPE) i*j) / ni; B_StrictFP[i][j] = B[i][j] = ((DATA_TYPE) i*j) / ni;
} }
} }
/* DCE code. Must scan the entire live-out data. /* DCE code. Must scan the entire live-out data.
Can be used also to check the correctness of the output. */ Can be used also to check the correctness of the output. */
static static
void print_array(int ni, void print_array(int ni,
Show All 26 Lines#pragma scop
for (i = 1; i < _PB_NI; i++) for (i = 1; i < _PB_NI; i++)
for (j = 0; j < _PB_NI; j++) for (j = 0; j < _PB_NI; j++)
for (k = 0; k < i; k++) for (k = 0; k < i; k++)
B[i][j] += alpha * A[i][k] * B[j][k]; B[i][j] += alpha * A[i][k] * B[j][k];
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_trmm_StrictFP(int ni,
DATA_TYPE alpha,
DATA_TYPE POLYBENCH_2D(A,NI,NI,ni,ni),
DATA_TYPE POLYBENCH_2D(B,NI,NI,ni,ni))
{
#pragma STDC FP_CONTRACT OFF
int i, j, k;
/* B := alpha*A'*B, A triangular */
for (i = 1; i < _PB_NI; i++)
for (j = 0; j < _PB_NI; j++)
for (k = 0; k < i; k++)
B[i][j] += alpha * A[i][k] * B[j][k];
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int ni,
DATA_TYPE POLYBENCH_2D(A,NI,NI,ni,ni),
DATA_TYPE POLYBENCH_2D(B,NI,NI,ni,ni)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NI; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int ni = NI; int ni = NI;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
DATA_TYPE alpha; DATA_TYPE alpha;
POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NI,ni,ni); POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NI,ni,ni);
POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NI,NI,ni,ni); POLYBENCH_2D_ARRAY_DECL(B,DATA_TYPE,NI,NI,ni,ni);
POLYBENCH_2D_ARRAY_DECL(B_StrictFP,DATA_TYPE,NI,NI,ni,ni);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (ni, &alpha, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); init_array (ni, &alpha, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B),
POLYBENCH_ARRAY(B_StrictFP));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_trmm (ni, alpha, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); kernel_trmm (ni, alpha, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
kernel_trmm_StrictFP(ni, alpha, POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B_StrictFP));
if (!check_FP(ni, POLYBENCH_ARRAY(B), POLYBENCH_ARRAY(B_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(B))); polybench_prevent_dce(print_array(ni, POLYBENCH_ARRAY(B_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(B); POLYBENCH_FREE_ARRAY(B);
return 0; return 0;
} }

test-suite/trunk/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)
if(ARCH STREQUAL "XCore") if(ARCH STREQUAL "XCore")
set(XCORE_TARGET_NEEDS_MEMORY 256) set(XCORE_TARGET_NEEDS_MEMORY 256)
endif() endif()
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/durbin/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = durbin PROG = durbin
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
ifeq ($(ARCH),XCore) ifeq ($(ARCH),XCore)
XCORE_TARGET_NEEDS_MEMORY := 256 XCORE_TARGET_NEEDS_MEMORY := 256
endif endif
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/durbin/durbin.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */ /* Default data type is double, default size is 4000. */
#include "durbin.h" #include "durbin.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array (int n, void init_array (int n,
DATA_TYPE POLYBENCH_2D(y,N,N,n,n), DATA_TYPE POLYBENCH_2D(y,N,N,n,n),
DATA_TYPE POLYBENCH_2D(sum,N,N,n,n), DATA_TYPE POLYBENCH_2D(sum,N,N,n,n),
DATA_TYPE POLYBENCH_1D(alpha,N,n), DATA_TYPE POLYBENCH_1D(alpha,N,n),
DATA_TYPE POLYBENCH_1D(beta,N,n), DATA_TYPE POLYBENCH_1D(beta,N,n),
DATA_TYPE POLYBENCH_1D(r,N,n)) DATA_TYPE POLYBENCH_1D(r,N,n))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
alpha[i] = i; alpha[i] = i;
beta[i] = (i+1)/n/2.0; beta[i] = (i+1)/n/2.0;
r[i] = (i+1)/n/4.0; r[i] = (i+1)/n/4.0;
for (j = 0; j < n; j++) { for (j = 0; j < n; j++) {
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines y[i][k] = y[i][k-1] + alpha[k] * y[k-i-1][k-1];
y[k][k] = alpha[k]; y[k][k] = alpha[k];
} }
for (i = 0; i < _PB_N; i++) for (i = 0; i < _PB_N; i++)
out[i] = y[i][_PB_N-1]; out[i] = y[i][_PB_N-1];
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static
void kernel_durbin_StrictFP(int n,
DATA_TYPE POLYBENCH_2D(y,N,N,n,n),
DATA_TYPE POLYBENCH_2D(sum,N,N,n,n),
DATA_TYPE POLYBENCH_1D(alpha,N,n),
DATA_TYPE POLYBENCH_1D(beta,N,n),
DATA_TYPE POLYBENCH_1D(r,N,n),
DATA_TYPE POLYBENCH_1D(out,N,n))
{
#pragma STDC FP_CONTRACT OFF
int i, k;
y[0][0] = r[0];
beta[0] = 1;
alpha[0] = r[0];
for (k = 1; k < _PB_N; k++)
{
beta[k] = beta[k-1] - alpha[k-1] * alpha[k-1] * beta[k-1];
sum[0][k] = r[k];
for (i = 0; i <= k - 1; i++)
sum[i+1][k] = sum[i][k] + r[k-i-1] * y[i][k-1];
alpha[k] = -sum[k][k] * beta[k];
for (i = 0; i <= k-1; i++)
y[i][k] = y[i][k-1] + alpha[k] * y[k-i-1][k-1];
y[k][k] = alpha[k];
}
for (i = 0; i < _PB_N; i++)
out[i] = y[i][_PB_N-1];
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static int
check_FP(int n,
DATA_TYPE POLYBENCH_1D(A,N,n),
DATA_TYPE POLYBENCH_1D(B,N,n)) {
int i;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_N; i++)
{
double V1 = A[i];
double V2 = B[i];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d] = %lf and B[%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, V1, i, V2, AbsTolerance);
return 0;
}
}
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int n = N; int n = N;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(y, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(y, DATA_TYPE, N, N, n, n);
POLYBENCH_2D_ARRAY_DECL(sum, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(sum, DATA_TYPE, N, N, n, n);
POLYBENCH_1D_ARRAY_DECL(alpha, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(alpha, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(beta, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(beta, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(r, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(r, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(out, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(out, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(out_StrictFP, DATA_TYPE, N, n);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (n, init_array (n,
POLYBENCH_ARRAY(y), POLYBENCH_ARRAY(y),
POLYBENCH_ARRAY(sum), POLYBENCH_ARRAY(sum),
POLYBENCH_ARRAY(alpha), POLYBENCH_ARRAY(alpha),
POLYBENCH_ARRAY(beta), POLYBENCH_ARRAY(beta),
Show All 10 Lines kernel_durbin (n,
POLYBENCH_ARRAY(beta), POLYBENCH_ARRAY(beta),
POLYBENCH_ARRAY(r), POLYBENCH_ARRAY(r),
POLYBENCH_ARRAY(out)); POLYBENCH_ARRAY(out));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
init_array (n,
POLYBENCH_ARRAY(y),
POLYBENCH_ARRAY(sum),
POLYBENCH_ARRAY(alpha),
POLYBENCH_ARRAY(beta),
POLYBENCH_ARRAY(r));
kernel_durbin_StrictFP (n,
POLYBENCH_ARRAY(y),
POLYBENCH_ARRAY(sum),
POLYBENCH_ARRAY(alpha),
POLYBENCH_ARRAY(beta),
POLYBENCH_ARRAY(r),
POLYBENCH_ARRAY(out_StrictFP));
if (!check_FP(n, POLYBENCH_ARRAY(out), POLYBENCH_ARRAY(out_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(out))); polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(out_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(y); POLYBENCH_FREE_ARRAY(y);
POLYBENCH_FREE_ARRAY(sum); POLYBENCH_FREE_ARRAY(sum);
POLYBENCH_FREE_ARRAY(alpha); POLYBENCH_FREE_ARRAY(alpha);
POLYBENCH_FREE_ARRAY(beta); POLYBENCH_FREE_ARRAY(beta);
POLYBENCH_FREE_ARRAY(r); POLYBENCH_FREE_ARRAY(r);
POLYBENCH_FREE_ARRAY(out); POLYBENCH_FREE_ARRAY(out);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/dynprog/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = dynprog PROG = dynprog
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/dynprog/dynprog.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is int, default size is 50. */ /* Default data type is int, default size is 50. */
#include "dynprog.h" #include "dynprog.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array(int length, void init_array(int length,
DATA_TYPE POLYBENCH_2D(c,LENGTH,LENGTH,length,length), DATA_TYPE POLYBENCH_2D(c,LENGTH,LENGTH,length,length),
DATA_TYPE POLYBENCH_2D(W,LENGTH,LENGTH,length,length)) DATA_TYPE POLYBENCH_2D(W,LENGTH,LENGTH,length,length))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
for (i = 0; i < length; i++) for (i = 0; i < length; i++)
for (j = 0; j < length; j++) { for (j = 0; j < length; j++) {
c[i][j] = i*j % 2; c[i][j] = i*j % 2;
W[i][j] = ((DATA_TYPE) i-j) / length; W[i][j] = ((DATA_TYPE) i-j) / length;
} }
} }
Show All 40 Lines#pragma scop
} }
out_l += c[0][_PB_LENGTH - 1]; out_l += c[0][_PB_LENGTH - 1];
} }
#pragma endscop #pragma endscop
*out = out_l; *out = out_l;
} }
__attribute__((optnone)) static void
kernel_dynprog_StrictFP(int tsteps, int length,
DATA_TYPE POLYBENCH_2D(c,LENGTH,LENGTH,length,length),
DATA_TYPE POLYBENCH_2D(W,LENGTH,LENGTH,length,length),
DATA_TYPE POLYBENCH_3D(sum_c,LENGTH,LENGTH,LENGTH,length,length,length),
DATA_TYPE *out)
{
#pragma STDC FP_CONTRACT OFF
int iter, i, j, k;
DATA_TYPE out_l = 0;
for (iter = 0; iter < _PB_TSTEPS; iter++)
{
for (i = 0; i <= _PB_LENGTH - 1; i++)
for (j = 0; j <= _PB_LENGTH - 1; j++)
c[i][j] = 0;
for (i = 0; i <= _PB_LENGTH - 2; i++)
{
for (j = i + 1; j <= _PB_LENGTH - 1; j++)
{
sum_c[i][j][i] = 0;
for (k = i + 1; k <= j-1; k++)
sum_c[i][j][k] = sum_c[i][j][k - 1] + c[i][k] + c[k][j];
c[i][j] = sum_c[i][j][j-1] + W[i][j];
}
}
out_l += c[0][_PB_LENGTH - 1];
}
*out = out_l;
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static int
check_FP(DATA_TYPE A,
DATA_TYPE B) {
double AbsTolerance = FP_ABSTOLERANCE;
double V1 = A;
double V2 = B;
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A = %lf and B = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", V1, V2, AbsTolerance);
return 0;
}
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int length = LENGTH; int length = LENGTH;
int tsteps = TSTEPS; int tsteps = TSTEPS;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
DATA_TYPE out; DATA_TYPE out, out_StrictFP;
POLYBENCH_3D_ARRAY_DECL(sum_c,DATA_TYPE,LENGTH,LENGTH,LENGTH,length,length,length); 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(c,DATA_TYPE,LENGTH,LENGTH,length,length);
POLYBENCH_2D_ARRAY_DECL(W,DATA_TYPE,LENGTH,LENGTH,length,length); POLYBENCH_2D_ARRAY_DECL(W,DATA_TYPE,LENGTH,LENGTH,length,length);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (length, POLYBENCH_ARRAY(c), POLYBENCH_ARRAY(W)); init_array (length, POLYBENCH_ARRAY(c), POLYBENCH_ARRAY(W));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_dynprog (tsteps, length, kernel_dynprog (tsteps, length,
POLYBENCH_ARRAY(c), POLYBENCH_ARRAY(c),
POLYBENCH_ARRAY(W), POLYBENCH_ARRAY(W),
POLYBENCH_ARRAY(sum_c), POLYBENCH_ARRAY(sum_c),
&out); &out);
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
init_array (length, POLYBENCH_ARRAY(c), POLYBENCH_ARRAY(W));
kernel_dynprog (tsteps, length,
POLYBENCH_ARRAY(c),
POLYBENCH_ARRAY(W),
POLYBENCH_ARRAY(sum_c),
&out_StrictFP);
if (!check_FP(out, out_StrictFP))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(out)); polybench_prevent_dce(print_array(out_StrictFP));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(sum_c); POLYBENCH_FREE_ARRAY(sum_c);
POLYBENCH_FREE_ARRAY(c); POLYBENCH_FREE_ARRAY(c);
POLYBENCH_FREE_ARRAY(W); POLYBENCH_FREE_ARRAY(W);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = gramschmidt PROG = gramschmidt
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/gramschmidt/gramschmidt.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 512. */ /* Default data type is double, default size is 512. */
#include "gramschmidt.h" #include "gramschmidt.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array(int ni, int nj, void init_array(int ni, int nj,
DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj), DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj),
DATA_TYPE POLYBENCH_2D(R,NJ,NJ,nj,nj), DATA_TYPE POLYBENCH_2D(R,NJ,NJ,nj,nj),
DATA_TYPE POLYBENCH_2D(Q,NI,NJ,ni,nj)) DATA_TYPE POLYBENCH_2D(Q,NI,NJ,ni,nj))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
/* /*
LLVM: This change ensures we do not calculate nan values, which are LLVM: This change ensures we do not calculate nan values, which are
formatted differently on different platforms and which may also formatted differently on different platforms and which may also
be optimized unexpectedly. be optimized unexpectedly.
Original code: Original code:
for (i = 0; i < ni; i++) for (i = 0; i < ni; i++)
for (j = 0; j < nj; j++) { for (j = 0; j < nj; j++) {
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines for (k = 0; k < _PB_NJ; k++)
for (i = 0; i < _PB_NI; i++) for (i = 0; i < _PB_NI; i++)
A[i][j] = A[i][j] - Q[i][k] * R[k][j]; A[i][j] = A[i][j] - Q[i][k] * R[k][j];
} }
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_gramschmidt_StrictFP(int ni, int nj,
DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj),
DATA_TYPE POLYBENCH_2D(R,NJ,NJ,nj,nj),
DATA_TYPE POLYBENCH_2D(Q,NI,NJ,ni,nj))
{
#pragma STDC FP_CONTRACT OFF
int i, j, k;
DATA_TYPE nrm;
for (k = 0; k < _PB_NJ; k++)
{
nrm = 0;
for (i = 0; i < _PB_NI; i++)
nrm += A[i][k] * A[i][k];
R[k][k] = sqrt(nrm);
for (i = 0; i < _PB_NI; i++)
Q[i][k] = A[i][k] / R[k][k];
for (j = k + 1; j < _PB_NJ; j++)
{
R[k][j] = 0;
for (i = 0; i < _PB_NI; i++)
R[k][j] += Q[i][k] * A[i][j];
for (i = 0; i < _PB_NI; i++)
A[i][j] = A[i][j] - Q[i][k] * R[k][j];
}
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int ni, int nj,
DATA_TYPE POLYBENCH_2D(A,NI,NJ,ni,nj),
DATA_TYPE POLYBENCH_2D(B,NI,NJ,ni,nj)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_NI; i++)
for (j = 0; j < _PB_NJ; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int ni = NI; int ni = NI;
int nj = NJ; int nj = NJ;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(A,DATA_TYPE,NI,NJ,ni,nj); 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(R,DATA_TYPE,NJ,NJ,nj,nj);
POLYBENCH_2D_ARRAY_DECL(Q,DATA_TYPE,NI,NJ,ni,nj); POLYBENCH_2D_ARRAY_DECL(Q,DATA_TYPE,NI,NJ,ni,nj);
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);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (ni, nj, init_array (ni, nj,
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(R), POLYBENCH_ARRAY(R),
POLYBENCH_ARRAY(Q)); POLYBENCH_ARRAY(Q));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_gramschmidt (ni, nj, kernel_gramschmidt (ni, nj,
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(R), POLYBENCH_ARRAY(R),
POLYBENCH_ARRAY(Q)); POLYBENCH_ARRAY(Q));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
init_array (ni, nj,
POLYBENCH_ARRAY(A_StrictFP),
POLYBENCH_ARRAY(R_StrictFP),
POLYBENCH_ARRAY(Q_StrictFP));
kernel_gramschmidt_StrictFP(ni, nj,
POLYBENCH_ARRAY(A_StrictFP),
POLYBENCH_ARRAY(R_StrictFP),
POLYBENCH_ARRAY(Q_StrictFP));
if (!check_FP(ni, nj, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A_StrictFP)))
return 1;
if (!check_FP(ni, nj, POLYBENCH_ARRAY(R), POLYBENCH_ARRAY(R_StrictFP)))
return 1;
if (!check_FP(ni, nj, POLYBENCH_ARRAY(Q), POLYBENCH_ARRAY(Q_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(ni, nj, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(R), POLYBENCH_ARRAY(Q))); polybench_prevent_dce(print_array(ni, nj,
POLYBENCH_ARRAY(A_StrictFP),
POLYBENCH_ARRAY(R_StrictFP),
POLYBENCH_ARRAY(Q_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(R); POLYBENCH_FREE_ARRAY(R);
POLYBENCH_FREE_ARRAY(Q); POLYBENCH_FREE_ARRAY(Q);
POLYBENCH_FREE_ARRAY(A_StrictFP);
POLYBENCH_FREE_ARRAY(R_StrictFP);
POLYBENCH_FREE_ARRAY(Q_StrictFP);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/lu/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = lu PROG = lu
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/lu/lu.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 1024. */ /* Default data type is double, default size is 1024. */
#include "lu.h" #include "lu.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array (int n, void init_array (int n,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n)) DATA_TYPE POLYBENCH_2D(A,N,N,n,n))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
A[i][j] = ((DATA_TYPE) (i+1)*(j+1)) / n; A[i][j] = ((DATA_TYPE) (i+1)*(j+1)) / n;
} }
Show All 40 Lines#pragma scop
*/ */
for (j = k + 1; j < _PB_N; j++) for (j = k + 1; j < _PB_N; j++)
A[i][j] = A[i][j] + A[i][k] * A[k][j]; A[i][j] = A[i][j] + A[i][k] * A[k][j];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_lu_StrictFP(int n,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n))
{
#pragma STDC FP_CONTRACT OFF
int i, j, k;
for (k = 0; k < _PB_N; k++)
{
for (j = k + 1; j < _PB_N; j++)
A[k][j] = A[k][j] / A[k][k];
for(i = k + 1; i < _PB_N; i++)
/*
LLVM: This change ensures we do not calculate nan values, which are
formatted differently on different platforms and which may also
be optimized unexpectedly.
Original code:
for (j = k + 1; j < _PB_N; j++)
A[i][j] = A[i][j] - A[i][k] * A[k][j];
*/
for (j = k + 1; j < _PB_N; j++)
A[i][j] = A[i][j] + A[i][k] * A[k][j];
}
}
static inline int
check_FP(int n,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_2D(B,N,N,n,n)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_N; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int n = N; int n = N;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n);
POLYBENCH_2D_ARRAY_DECL(A_StrictFP, DATA_TYPE, N, N, n, n);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (n, POLYBENCH_ARRAY(A)); init_array (n, POLYBENCH_ARRAY(A));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_lu (n, POLYBENCH_ARRAY(A)); kernel_lu (n, POLYBENCH_ARRAY(A));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
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)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(A_StrictFP);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/ludcmp/Makefile

LEVEL = ../../../../../.. LEVEL = ../../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = ludcmp PROG = ludcmp
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/linear-algebra/solvers/ludcmp/ludcmp.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 1024. */ /* Default data type is double, default size is 1024. */
#include "ludcmp.h" #include "ludcmp.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array (int n, void init_array (int n,
DATA_TYPE POLYBENCH_2D(A,N+1,N+1,n+1,n+1), DATA_TYPE POLYBENCH_2D(A,N+1,N+1,n+1,n+1),
DATA_TYPE POLYBENCH_1D(b,N+1,n+1), DATA_TYPE POLYBENCH_1D(b,N+1,n+1),
DATA_TYPE POLYBENCH_1D(x,N+1,n+1), DATA_TYPE POLYBENCH_1D(x,N+1,n+1),
DATA_TYPE POLYBENCH_1D(y,N+1,n+1)) DATA_TYPE POLYBENCH_1D(y,N+1,n+1))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
for (i = 0; i <= n; i++) for (i = 0; i <= n; i++)
{ {
x[i] = i + 1; x[i] = i + 1;
y[i] = (i+1)/n/2.0 + 1; y[i] = (i+1)/n/2.0 + 1;
b[i] = (i+1)/n/2.0 + 42; b[i] = (i+1)/n/2.0 + 42;
for (j = 0; j <= n; j++) { for (j = 0; j <= n; j++) {
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines for (i = 0; i <= _PB_N - 1; i++)
for (j = _PB_N - i; j <= _PB_N; j++) for (j = _PB_N - i; j <= _PB_N; j++)
w = w - A[_PB_N - 1 - i][j] * x[j]; w = w - A[_PB_N - 1 - i][j] * x[j];
x[_PB_N - 1 - i] = w / A[_PB_N - 1 - (i)][_PB_N - 1-(i)]; x[_PB_N - 1 - i] = w / A[_PB_N - 1 - (i)][_PB_N - 1-(i)];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_ludcmp_StrictFP(int n,
DATA_TYPE POLYBENCH_2D(A,N+1,N+1,n+1,n+1),
DATA_TYPE POLYBENCH_1D(b,N+1,n+1),
DATA_TYPE POLYBENCH_1D(x,N+1,n+1),
DATA_TYPE POLYBENCH_1D(y,N+1,n+1))
{
#pragma STDC FP_CONTRACT OFF
int i, j, k;
DATA_TYPE w;
b[0] = 1.0;
for (i = 0; i < _PB_N; i++)
{
for (j = i+1; j <= _PB_N; j++)
{
w = A[j][i];
for (k = 0; k < i; k++)
w = w- A[j][k] * A[k][i];
A[j][i] = w / A[i][i];
}
for (j = i+1; j <= _PB_N; j++)
{
w = A[i+1][j];
for (k = 0; k <= i; k++)
w = w - A[i+1][k] * A[k][j];
A[i+1][j] = w;
}
}
y[0] = b[0];
for (i = 1; i <= _PB_N; i++)
{
w = b[i];
for (j = 0; j < i; j++)
w = w - A[i][j] * y[j];
y[i] = w;
}
x[_PB_N] = y[_PB_N] / A[_PB_N][_PB_N];
for (i = 0; i <= _PB_N - 1; i++)
{
w = y[_PB_N - 1 - (i)];
for (j = _PB_N - i; j <= _PB_N; j++)
w = w - A[_PB_N - 1 - i][j] * x[j];
x[_PB_N - 1 - i] = w / A[_PB_N - 1 - (i)][_PB_N - 1-(i)];
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static int
check_FP(int n,
DATA_TYPE POLYBENCH_1D(A,N+1,n),
DATA_TYPE POLYBENCH_1D(B,N+1,n)) {
int i;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_N+1; i++)
{
double V1 = A[i];
double V2 = B[i];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d] = %lf and B[%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, V1, i, V2, AbsTolerance);
return 0;
}
}
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int n = N; int n = N;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N+1, N+1, n+1, n+1); 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(b, DATA_TYPE, N+1, n+1);
POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N+1, n+1); POLYBENCH_1D_ARRAY_DECL(x, DATA_TYPE, N+1, n+1);
POLYBENCH_1D_ARRAY_DECL(x_StrictFP, DATA_TYPE, N+1, n+1);
POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, N+1, n+1); POLYBENCH_1D_ARRAY_DECL(y, DATA_TYPE, N+1, n+1);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (n, init_array (n,
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(b), POLYBENCH_ARRAY(b),
POLYBENCH_ARRAY(x), POLYBENCH_ARRAY(x),
POLYBENCH_ARRAY(y)); POLYBENCH_ARRAY(y));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_ludcmp (n, kernel_ludcmp (n,
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(b), POLYBENCH_ARRAY(b),
POLYBENCH_ARRAY(x), POLYBENCH_ARRAY(x),
POLYBENCH_ARRAY(y)); POLYBENCH_ARRAY(y));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
init_array (n,
POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(b),
POLYBENCH_ARRAY(x_StrictFP),
POLYBENCH_ARRAY(y));
kernel_ludcmp (n,
POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(b),
POLYBENCH_ARRAY(x_StrictFP),
POLYBENCH_ARRAY(y));
if (!check_FP(n, POLYBENCH_ARRAY(x), POLYBENCH_ARRAY(x_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x))); polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(x_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(b); POLYBENCH_FREE_ARRAY(b);
POLYBENCH_FREE_ARRAY(x); POLYBENCH_FREE_ARRAY(x);
POLYBENCH_FREE_ARRAY(x_StrictFP);
POLYBENCH_FREE_ARRAY(y); POLYBENCH_FREE_ARRAY(y);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/medley/floyd-warshall/Makefile

LEVEL = ../../../../.. LEVEL = ../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = floyd-warshall PROG = floyd-warshall
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/medley/floyd-warshall/floyd-warshall.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 1024. */ /* Default data type is double, default size is 1024. */
#include "floyd-warshall.h" #include "floyd-warshall.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array (int n, void init_array (int n,
DATA_TYPE POLYBENCH_2D(path,N,N,n,n)) DATA_TYPE POLYBENCH_2D(path,N,N,n,n))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
path[i][j] = ((DATA_TYPE) (i+1)*(j+1)) / n; path[i][j] = ((DATA_TYPE) (i+1)*(j+1)) / n;
} }
Show All 31 Lines#pragma scop
for (j = 0; j < _PB_N; j++) for (j = 0; j < _PB_N; j++)
path[i][j] = path[i][j] < path[i][k] + path[k][j] ? path[i][j] = path[i][j] < path[i][k] + path[k][j] ?
path[i][j] : path[i][k] + path[k][j]; path[i][j] : path[i][k] + path[k][j];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_floyd_warshall_StrictFP(int n, DATA_TYPE POLYBENCH_2D(path,N,N,n,n))
{
#pragma STDC FP_CONTRACT OFF
int i, j, k;
for (k = 0; k < _PB_N; k++)
{
for(i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_N; j++)
path[i][j] = path[i][j] < path[i][k] + path[k][j] ?
path[i][j] : path[i][k] + path[k][j];
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int n,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_2D(B,N,N,n,n)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_N; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int n = N; int n = N;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(path, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(path, DATA_TYPE, N, N, n, n);
POLYBENCH_2D_ARRAY_DECL(path_StrictFP, DATA_TYPE, N, N, n, n);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (n, POLYBENCH_ARRAY(path)); init_array (n, POLYBENCH_ARRAY(path));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_floyd_warshall (n, POLYBENCH_ARRAY(path)); kernel_floyd_warshall (n, POLYBENCH_ARRAY(path));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
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)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(path))); polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(path_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(path); POLYBENCH_FREE_ARRAY(path);
POLYBENCH_FREE_ARRAY(path_StrictFP);
return 0; return 0;
} }

test-suite/trunk/SingleSource/Benchmarks/Polybench/medley/reg_detect/CMakeLists.txt

set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities ) set(POLYBENCH_UTILS SingleSource/Benchmarks/Polybench/utilities )
set(PROG reg_detect) set(PROG reg_detect)
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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/medley/reg_detect/Makefile

LEVEL = ../../../../.. LEVEL = ../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = reg_detect PROG = reg_detect
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/medley/reg_detect/reg_detect.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is int, default size is 50. */ /* Default data type is int, default size is 50. */
#include "reg_detect.h" #include "reg_detect.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array(int maxgrid, void init_array(int maxgrid,
DATA_TYPE POLYBENCH_2D(sum_tang,MAXGRID,MAXGRID,maxgrid,maxgrid), DATA_TYPE POLYBENCH_2D(sum_tang,MAXGRID,MAXGRID,maxgrid,maxgrid),
DATA_TYPE POLYBENCH_2D(mean,MAXGRID,MAXGRID,maxgrid,maxgrid), DATA_TYPE POLYBENCH_2D(mean,MAXGRID,MAXGRID,maxgrid,maxgrid),
DATA_TYPE POLYBENCH_2D(path,MAXGRID,MAXGRID,maxgrid,maxgrid)) DATA_TYPE POLYBENCH_2D(path,MAXGRID,MAXGRID,maxgrid,maxgrid))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
for (i = 0; i < maxgrid; i++) for (i = 0; i < maxgrid; i++)
for (j = 0; j < maxgrid; j++) { for (j = 0; j < maxgrid; j++) {
sum_tang[i][j] = (DATA_TYPE)((i+1)*(j+1)); sum_tang[i][j] = (DATA_TYPE)((i+1)*(j+1));
mean[i][j] = ((DATA_TYPE) i-j) / maxgrid; mean[i][j] = ((DATA_TYPE) i-j) / maxgrid;
path[i][j] = ((DATA_TYPE) i*(j-1)) / maxgrid; path[i][j] = ((DATA_TYPE) i*(j-1)) / maxgrid;
} }
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines path[0][i] = mean[0][i];
for (j = 1; j <= _PB_MAXGRID - 1; j++) for (j = 1; j <= _PB_MAXGRID - 1; j++)
for (i = j; i <= _PB_MAXGRID - 1; i++) for (i = j; i <= _PB_MAXGRID - 1; i++)
path[j][i] = path[j - 1][i - 1] + mean[j][i]; path[j][i] = path[j - 1][i - 1] + mean[j][i];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_reg_detect_StrictFP(int niter, int maxgrid, int length,
DATA_TYPE POLYBENCH_2D(sum_tang,MAXGRID,MAXGRID,maxgrid,maxgrid),
DATA_TYPE POLYBENCH_2D(mean,MAXGRID,MAXGRID,maxgrid,maxgrid),
DATA_TYPE POLYBENCH_2D(path,MAXGRID,MAXGRID,maxgrid,maxgrid),
DATA_TYPE POLYBENCH_3D(diff,MAXGRID,MAXGRID,LENGTH,maxgrid,maxgrid,length),
DATA_TYPE POLYBENCH_3D(sum_diff,MAXGRID,MAXGRID,LENGTH,maxgrid,maxgrid,length))
{
#pragma STDC FP_CONTRACT OFF
int t, i, j, cnt;
for (t = 0; t < _PB_NITER; t++)
{
for (j = 0; j <= _PB_MAXGRID - 1; j++)
for (i = j; i <= _PB_MAXGRID - 1; i++)
for (cnt = 0; cnt <= _PB_LENGTH - 1; cnt++)
diff[j][i][cnt] = sum_tang[j][i];
for (j = 0; j <= _PB_MAXGRID - 1; j++)
{
for (i = j; i <= _PB_MAXGRID - 1; i++)
{
sum_diff[j][i][0] = diff[j][i][0];
for (cnt = 1; cnt <= _PB_LENGTH - 1; cnt++)
sum_diff[j][i][cnt] = sum_diff[j][i][cnt - 1] + diff[j][i][cnt];
mean[j][i] = sum_diff[j][i][_PB_LENGTH - 1];
}
}
for (i = 0; i <= _PB_MAXGRID - 1; i++)
path[0][i] = mean[0][i];
for (j = 1; j <= _PB_MAXGRID - 1; j++)
for (i = j; i <= _PB_MAXGRID - 1; i++)
path[j][i] = path[j - 1][i - 1] + mean[j][i];
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int maxgrid,
DATA_TYPE POLYBENCH_2D(A,MAXGRID,MAXGRID,maxgrid,maxgrid),
DATA_TYPE POLYBENCH_2D(B,MAXGRID,MAXGRID,maxgrid,maxgrid)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_MAXGRID; i++)
for (j = 0; j < _PB_MAXGRID; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int niter = NITER; int niter = NITER;
int maxgrid = MAXGRID; int maxgrid = MAXGRID;
int length = LENGTH; int length = LENGTH;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(sum_tang, DATA_TYPE, MAXGRID, MAXGRID, maxgrid, maxgrid); 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(mean, DATA_TYPE, MAXGRID, MAXGRID, maxgrid, maxgrid);
POLYBENCH_2D_ARRAY_DECL(path, DATA_TYPE, MAXGRID, MAXGRID, maxgrid, maxgrid); POLYBENCH_2D_ARRAY_DECL(path, DATA_TYPE, MAXGRID, MAXGRID, maxgrid, maxgrid);
POLYBENCH_2D_ARRAY_DECL(path_StrictFP, DATA_TYPE, MAXGRID, MAXGRID, maxgrid, maxgrid);
POLYBENCH_3D_ARRAY_DECL(diff, DATA_TYPE, MAXGRID, MAXGRID, LENGTH, maxgrid, maxgrid, length); 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); POLYBENCH_3D_ARRAY_DECL(sum_diff, DATA_TYPE, MAXGRID, MAXGRID, LENGTH, maxgrid, maxgrid, length);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (maxgrid, init_array (maxgrid,
POLYBENCH_ARRAY(sum_tang), POLYBENCH_ARRAY(sum_tang),
POLYBENCH_ARRAY(mean), POLYBENCH_ARRAY(mean),
POLYBENCH_ARRAY(path)); POLYBENCH_ARRAY(path));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_reg_detect (niter, maxgrid, length, kernel_reg_detect (niter, maxgrid, length,
POLYBENCH_ARRAY(sum_tang), POLYBENCH_ARRAY(sum_tang),
POLYBENCH_ARRAY(mean), POLYBENCH_ARRAY(mean),
POLYBENCH_ARRAY(path), POLYBENCH_ARRAY(path),
POLYBENCH_ARRAY(diff), POLYBENCH_ARRAY(diff),
POLYBENCH_ARRAY(sum_diff)); POLYBENCH_ARRAY(sum_diff));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
init_array (maxgrid,
POLYBENCH_ARRAY(sum_tang),
POLYBENCH_ARRAY(mean),
POLYBENCH_ARRAY(path_StrictFP));
kernel_reg_detect_StrictFP(niter, maxgrid, length,
POLYBENCH_ARRAY(sum_tang),
POLYBENCH_ARRAY(mean),
POLYBENCH_ARRAY(path_StrictFP),
POLYBENCH_ARRAY(diff),
POLYBENCH_ARRAY(sum_diff));
if (!check_FP(maxgrid, POLYBENCH_ARRAY(path), POLYBENCH_ARRAY(path_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(maxgrid, POLYBENCH_ARRAY(path))); polybench_prevent_dce(print_array(maxgrid, POLYBENCH_ARRAY(path_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(sum_tang); POLYBENCH_FREE_ARRAY(sum_tang);
POLYBENCH_FREE_ARRAY(mean); POLYBENCH_FREE_ARRAY(mean);
POLYBENCH_FREE_ARRAY(path); POLYBENCH_FREE_ARRAY(path);
POLYBENCH_FREE_ARRAY(path_StrictFP);
POLYBENCH_FREE_ARRAY(diff); POLYBENCH_FREE_ARRAY(diff);
POLYBENCH_FREE_ARRAY(sum_diff); POLYBENCH_FREE_ARRAY(sum_diff);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/stencils/adi/Makefile

LEVEL = ../../../../.. LEVEL = ../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = adi PROG = adi
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/stencils/adi/adi.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 10x1024x1024. */ /* Default data type is double, default size is 10x1024x1024. */
#include "adi.h" #include "adi.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array (int n, void init_array (int n,
DATA_TYPE POLYBENCH_2D(X,N,N,n,n), DATA_TYPE POLYBENCH_2D(X,N,N,n,n),
DATA_TYPE POLYBENCH_2D(A,N,N,n,n), DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_2D(B,N,N,n,n)) DATA_TYPE POLYBENCH_2D(B,N,N,n,n))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
{ {
X[i][j] = ((DATA_TYPE) i*(j+1) + 1) / n; X[i][j] = ((DATA_TYPE) i*(j+1) + 1) / n;
A[i][j] = ((DATA_TYPE) i*(j+2) + 2) / n; A[i][j] = ((DATA_TYPE) i*(j+2) + 2) / n;
B[i][j] = ((DATA_TYPE) i*(j+3) + 3) / n; B[i][j] = ((DATA_TYPE) i*(j+3) + 3) / n;
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines X[_PB_N-1][i2] = X[_PB_N-1][i2] / B[_PB_N-1][i2];
for (i1 = 0; i1 < _PB_N-2; i1++) for (i1 = 0; i1 < _PB_N-2; i1++)
for (i2 = 0; i2 < _PB_N; i2++) for (i2 = 0; i2 < _PB_N; i2++)
X[_PB_N-2-i1][i2] = (X[_PB_N-2-i1][i2] - X[_PB_N-i1-3][i2] * A[_PB_N-3-i1][i2]) / B[_PB_N-2-i1][i2]; X[_PB_N-2-i1][i2] = (X[_PB_N-2-i1][i2] - X[_PB_N-i1-3][i2] * A[_PB_N-3-i1][i2]) / B[_PB_N-2-i1][i2];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_adi_StrictFP(int tsteps,
int n,
DATA_TYPE POLYBENCH_2D(X,N,N,n,n),
DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_2D(B,N,N,n,n))
{
#pragma STDC FP_CONTRACT OFF
int t, i1, i2;
for (t = 0; t < _PB_TSTEPS; t++)
{
for (i1 = 0; i1 < _PB_N; i1++)
for (i2 = 1; i2 < _PB_N; i2++)
{
X[i1][i2] = X[i1][i2] - X[i1][i2-1] * A[i1][i2] / B[i1][i2-1];
B[i1][i2] = B[i1][i2] - A[i1][i2] * A[i1][i2] / B[i1][i2-1];
}
for (i1 = 0; i1 < _PB_N; i1++)
X[i1][_PB_N-1] = X[i1][_PB_N-1] / B[i1][_PB_N-1];
for (i1 = 0; i1 < _PB_N; i1++)
for (i2 = 0; i2 < _PB_N-2; i2++)
X[i1][_PB_N-i2-2] = (X[i1][_PB_N-2-i2] - X[i1][_PB_N-2-i2-1] * A[i1][_PB_N-i2-3]) / B[i1][_PB_N-3-i2];
for (i1 = 1; i1 < _PB_N; i1++)
for (i2 = 0; i2 < _PB_N; i2++) {
X[i1][i2] = X[i1][i2] - X[i1-1][i2] * A[i1][i2] / B[i1-1][i2];
B[i1][i2] = B[i1][i2] - A[i1][i2] * A[i1][i2] / B[i1-1][i2];
}
for (i2 = 0; i2 < _PB_N; i2++)
X[_PB_N-1][i2] = X[_PB_N-1][i2] / B[_PB_N-1][i2];
for (i1 = 0; i1 < _PB_N-2; i1++)
for (i2 = 0; i2 < _PB_N; i2++)
X[_PB_N-2-i1][i2] = (X[_PB_N-2-i1][i2] - X[_PB_N-i1-3][i2] * A[_PB_N-3-i1][i2]) / B[_PB_N-2-i1][i2];
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int n,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_2D(B,N,N,n,n)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_N; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int n = N; int n = N;
int tsteps = TSTEPS; int tsteps = TSTEPS;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(X, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(X, DATA_TYPE, N, N, n, n);
POLYBENCH_2D_ARRAY_DECL(X_StrictFP, DATA_TYPE, N, N, n, n);
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n);
POLYBENCH_2D_ARRAY_DECL(B, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(B, DATA_TYPE, N, N, n, n);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (n, POLYBENCH_ARRAY(X), POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); init_array (n, POLYBENCH_ARRAY(X), POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_adi (tsteps, n, POLYBENCH_ARRAY(X), kernel_adi (tsteps, n, POLYBENCH_ARRAY(X),
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
init_array (n, POLYBENCH_ARRAY(X_StrictFP), POLYBENCH_ARRAY(A),
POLYBENCH_ARRAY(B));
kernel_adi (tsteps, n, POLYBENCH_ARRAY(X_StrictFP),
POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B));
if (!check_FP(n, POLYBENCH_ARRAY(X), POLYBENCH_ARRAY(X_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(X))); polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(X_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(X); POLYBENCH_FREE_ARRAY(X);
POLYBENCH_FREE_ARRAY(X_StrictFP);
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(B); POLYBENCH_FREE_ARRAY(B);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/stencils/fdtd-2d/Makefile

LEVEL = ../../../../.. LEVEL = ../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = fdtd-2d PROG = fdtd-2d
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/stencils/fdtd-2d/fdtd-2d.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 50x1000x1000. */ /* Default data type is double, default size is 50x1000x1000. */
#include "fdtd-2d.h" #include "fdtd-2d.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array (int tmax, void init_array (int tmax,
int nx, int nx,
int ny, int ny,
DATA_TYPE POLYBENCH_2D(ex,NX,NY,nx,ny), DATA_TYPE POLYBENCH_2D(ex,NX,NY,nx,ny),
DATA_TYPE POLYBENCH_2D(ey,NX,NY,nx,ny), DATA_TYPE POLYBENCH_2D(ey,NX,NY,nx,ny),
DATA_TYPE POLYBENCH_2D(hz,NX,NY,nx,ny), DATA_TYPE POLYBENCH_2D(hz,NX,NY,nx,ny),
DATA_TYPE POLYBENCH_1D(_fict_,TMAX,tmax)) DATA_TYPE POLYBENCH_1D(_fict_,TMAX,tmax))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
for (i = 0; i < tmax; i++) for (i = 0; i < tmax; i++)
_fict_[i] = (DATA_TYPE) i; _fict_[i] = (DATA_TYPE) i;
for (i = 0; i < nx; i++) for (i = 0; i < nx; i++)
for (j = 0; j < ny; j++) for (j = 0; j < ny; j++)
{ {
ex[i][j] = ((DATA_TYPE) i*(j+1)) / nx; ex[i][j] = ((DATA_TYPE) i*(j+1)) / nx;
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines#pragma scop
for (j = 0; j < _PB_NY - 1; j++) for (j = 0; j < _PB_NY - 1; j++)
hz[i][j] = hz[i][j] - 0.7* (ex[i][j+1] - ex[i][j] + hz[i][j] = hz[i][j] - 0.7* (ex[i][j+1] - ex[i][j] +
ey[i+1][j] - ey[i][j]); ey[i+1][j] - ey[i][j]);
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_fdtd_2d_StrictFP(int tmax,
int nx,
int ny,
DATA_TYPE POLYBENCH_2D(ex,NX,NY,nx,ny),
DATA_TYPE POLYBENCH_2D(ey,NX,NY,nx,ny),
DATA_TYPE POLYBENCH_2D(hz,NX,NY,nx,ny),
DATA_TYPE POLYBENCH_1D(_fict_,TMAX,tmax))
{
#pragma STDC FP_CONTRACT OFF
int t, i, j;
for(t = 0; t < _PB_TMAX; t++)
{
for (j = 0; j < _PB_NY; j++)
ey[0][j] = _fict_[t];
for (i = 1; i < _PB_NX; i++)
for (j = 0; j < _PB_NY; j++)
ey[i][j] = ey[i][j] - 0.5*(hz[i][j]-hz[i-1][j]);
for (i = 0; i < _PB_NX; i++)
for (j = 1; j < _PB_NY; j++)
ex[i][j] = ex[i][j] - 0.5*(hz[i][j]-hz[i][j-1]);
for (i = 0; i < _PB_NX - 1; i++)
for (j = 0; j < _PB_NY - 1; j++)
hz[i][j] = hz[i][j] - 0.7* (ex[i][j+1] - ex[i][j] +
ey[i+1][j] - ey[i][j]);
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int nx, int ny,
DATA_TYPE POLYBENCH_2D(A,NX,NY,nx,ny),
DATA_TYPE POLYBENCH_2D(B,NX,NY,nx,ny)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_NX; i++)
for (j = 0; j < _PB_NY; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int tmax = TMAX; int tmax = TMAX;
int nx = NX; int nx = NX;
int ny = NY; int ny = NY;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(ex,DATA_TYPE,NX,NY,nx,ny); 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(ey,DATA_TYPE,NX,NY,nx,ny);
POLYBENCH_2D_ARRAY_DECL(hz,DATA_TYPE,NX,NY,nx,ny); POLYBENCH_2D_ARRAY_DECL(hz,DATA_TYPE,NX,NY,nx,ny);
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);
POLYBENCH_1D_ARRAY_DECL(_fict_,DATA_TYPE,TMAX,tmax); POLYBENCH_1D_ARRAY_DECL(_fict_,DATA_TYPE,TMAX,tmax);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (tmax, nx, ny, init_array (tmax, nx, ny,
POLYBENCH_ARRAY(ex), POLYBENCH_ARRAY(ex),
POLYBENCH_ARRAY(ey), POLYBENCH_ARRAY(ey),
POLYBENCH_ARRAY(hz), POLYBENCH_ARRAY(hz),
POLYBENCH_ARRAY(_fict_)); POLYBENCH_ARRAY(_fict_));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_fdtd_2d (tmax, nx, ny, kernel_fdtd_2d (tmax, nx, ny,
POLYBENCH_ARRAY(ex), POLYBENCH_ARRAY(ex),
POLYBENCH_ARRAY(ey), POLYBENCH_ARRAY(ey),
POLYBENCH_ARRAY(hz), POLYBENCH_ARRAY(hz),
POLYBENCH_ARRAY(_fict_)); POLYBENCH_ARRAY(_fict_));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
init_array (tmax, nx, ny,
POLYBENCH_ARRAY(ex_StrictFP),
POLYBENCH_ARRAY(ey_StrictFP),
POLYBENCH_ARRAY(hz_StrictFP),
POLYBENCH_ARRAY(_fict_));
kernel_fdtd_2d_StrictFP(tmax, nx, ny,
POLYBENCH_ARRAY(ex_StrictFP),
POLYBENCH_ARRAY(ey_StrictFP),
POLYBENCH_ARRAY(hz_StrictFP),
POLYBENCH_ARRAY(_fict_));
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(nx, ny, POLYBENCH_ARRAY(ex), polybench_prevent_dce(print_array(nx, ny, POLYBENCH_ARRAY(ex_StrictFP),
POLYBENCH_ARRAY(ey), POLYBENCH_ARRAY(ey_StrictFP),
POLYBENCH_ARRAY(hz))); POLYBENCH_ARRAY(hz_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(ex); POLYBENCH_FREE_ARRAY(ex);
POLYBENCH_FREE_ARRAY(ey); POLYBENCH_FREE_ARRAY(ey);
POLYBENCH_FREE_ARRAY(hz); POLYBENCH_FREE_ARRAY(hz);
POLYBENCH_FREE_ARRAY(ex_StrictFP);
POLYBENCH_FREE_ARRAY(ey_StrictFP);
POLYBENCH_FREE_ARRAY(hz_StrictFP);
POLYBENCH_FREE_ARRAY(_fict_); POLYBENCH_FREE_ARRAY(_fict_);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/stencils/fdtd-apml/Makefile

LEVEL = ../../../../.. LEVEL = ../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = fdtd-apml PROG = fdtd-apml
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/stencils/fdtd-apml/fdtd-apml.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 256x256x256. */ /* Default data type is double, default size is 256x256x256. */
#include "fdtd-apml.h" #include "fdtd-apml.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array (int cz, void init_array (int cz,
int cxm, int cxm,
int cym, int cym,
DATA_TYPE *mui, DATA_TYPE *mui,
DATA_TYPE *ch, DATA_TYPE *ch,
DATA_TYPE POLYBENCH_2D(Ax,CZ+1,CYM+1,cz+1,cym+1), DATA_TYPE POLYBENCH_2D(Ax,CZ+1,CYM+1,cz+1,cym+1),
DATA_TYPE POLYBENCH_2D(Ry,CZ+1,CYM+1,cz+1,cym+1), DATA_TYPE POLYBENCH_2D(Ry,CZ+1,CYM+1,cz+1,cym+1),
DATA_TYPE POLYBENCH_3D(Ex,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1), DATA_TYPE POLYBENCH_3D(Ex,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1),
DATA_TYPE POLYBENCH_3D(Ey,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1), DATA_TYPE POLYBENCH_3D(Ey,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1),
DATA_TYPE POLYBENCH_3D(Hz,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1), DATA_TYPE POLYBENCH_3D(Hz,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1),
DATA_TYPE POLYBENCH_1D(czm,CZ+1,cz+1), DATA_TYPE POLYBENCH_1D(czm,CZ+1,cz+1),
DATA_TYPE POLYBENCH_1D(czp,CZ+1,cz+1), DATA_TYPE POLYBENCH_1D(czp,CZ+1,cz+1),
DATA_TYPE POLYBENCH_1D(cxmh,CXM+1,cxm+1), DATA_TYPE POLYBENCH_1D(cxmh,CXM+1,cxm+1),
DATA_TYPE POLYBENCH_1D(cxph,CXM+1,cxm+1), DATA_TYPE POLYBENCH_1D(cxph,CXM+1,cxm+1),
DATA_TYPE POLYBENCH_1D(cymh,CYM+1,cym+1), DATA_TYPE POLYBENCH_1D(cymh,CYM+1,cym+1),
DATA_TYPE POLYBENCH_1D(cyph,CYM+1,cym+1)) DATA_TYPE POLYBENCH_1D(cyph,CYM+1,cym+1))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j, k; int i, j, k;
*mui = 2341; *mui = 2341;
*ch = 42; *ch = 42;
for (i = 0; i <= cz; i++) for (i = 0; i <= cz; i++)
{ {
czm[i] = ((DATA_TYPE) i + 1) / cxm; czm[i] = ((DATA_TYPE) i + 1) / cxm;
czp[i] = ((DATA_TYPE) i + 2) / cxm; czp[i] = ((DATA_TYPE) i + 2) / cxm;
} }
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines Hz[iz][_PB_CYM][_PB_CXM] = (cxmh[_PB_CXM] / cxph[_PB_CXM]) * Hz[iz][_PB_CYM][_PB_CXM]
- (mui * czm[iz] / cxph[_PB_CXM]) * Bza[iz][_PB_CYM][_PB_CXM]; - (mui * czm[iz] / cxph[_PB_CXM]) * Bza[iz][_PB_CYM][_PB_CXM];
Bza[iz][_PB_CYM][_PB_CXM] = tmp[iz][iy]; Bza[iz][_PB_CYM][_PB_CXM] = tmp[iz][iy];
} }
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_fdtd_apml_StrictFP(int cz,
int cxm,
int cym,
DATA_TYPE mui,
DATA_TYPE ch,
DATA_TYPE POLYBENCH_2D(Ax,CZ+1,CYM+1,cz+1,cym+1),
DATA_TYPE POLYBENCH_2D(Ry,CZ+1,CYM+1,cz+1,cym+1),
DATA_TYPE POLYBENCH_2D(clf,CYM+1,CXM+1,cym+1,cxm+1),
DATA_TYPE POLYBENCH_2D(tmp,CYM+1,CXM+1,cym+1,cxm+1),
DATA_TYPE POLYBENCH_3D(Bza,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1),
DATA_TYPE POLYBENCH_3D(Ex,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1),
DATA_TYPE POLYBENCH_3D(Ey,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1),
DATA_TYPE POLYBENCH_3D(Hz,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1),
DATA_TYPE POLYBENCH_1D(czm,CZ+1,cz+1),
DATA_TYPE POLYBENCH_1D(czp,CZ+1,cz+1),
DATA_TYPE POLYBENCH_1D(cxmh,CXM+1,cxm+1),
DATA_TYPE POLYBENCH_1D(cxph,CXM+1,cxm+1),
DATA_TYPE POLYBENCH_1D(cymh,CYM+1,cym+1),
DATA_TYPE POLYBENCH_1D(cyph,CYM+1,cym+1))
{
#pragma STDC FP_CONTRACT OFF
int iz, iy, ix;
for (iz = 0; iz < _PB_CZ; iz++)
{
for (iy = 0; iy < _PB_CYM; iy++)
{
for (ix = 0; ix < _PB_CXM; ix++)
{
clf[iz][iy] = Ex[iz][iy][ix] - Ex[iz][iy+1][ix] + Ey[iz][iy][ix+1] - Ey[iz][iy][ix];
tmp[iz][iy] = (cymh[iy] / cyph[iy]) * Bza[iz][iy][ix] - (ch / cyph[iy]) * clf[iz][iy];
Hz[iz][iy][ix] = (cxmh[ix] /cxph[ix]) * Hz[iz][iy][ix]
+ (mui * czp[iz] / cxph[ix]) * tmp[iz][iy]
- (mui * czm[iz] / cxph[ix]) * Bza[iz][iy][ix];
Bza[iz][iy][ix] = tmp[iz][iy];
}
clf[iz][iy] = Ex[iz][iy][_PB_CXM] - Ex[iz][iy+1][_PB_CXM] + Ry[iz][iy] - Ey[iz][iy][_PB_CXM];
tmp[iz][iy] = (cymh[iy] / cyph[iy]) * Bza[iz][iy][_PB_CXM] - (ch / cyph[iy]) * clf[iz][iy];
Hz[iz][iy][_PB_CXM]=(cxmh[_PB_CXM] / cxph[_PB_CXM]) * Hz[iz][iy][_PB_CXM]
+ (mui * czp[iz] / cxph[_PB_CXM]) * tmp[iz][iy]
- (mui * czm[iz] / cxph[_PB_CXM]) * Bza[iz][iy][_PB_CXM];
Bza[iz][iy][_PB_CXM] = tmp[iz][iy];
for (ix = 0; ix < _PB_CXM; ix++)
{
clf[iz][iy] = Ex[iz][_PB_CYM][ix] - Ax[iz][ix] + Ey[iz][_PB_CYM][ix+1] - Ey[iz][_PB_CYM][ix];
tmp[iz][iy] = (cymh[_PB_CYM] / cyph[iy]) * Bza[iz][iy][ix] - (ch / cyph[iy]) * clf[iz][iy];
Hz[iz][_PB_CYM][ix] = (cxmh[ix] / cxph[ix]) * Hz[iz][_PB_CYM][ix]
+ (mui * czp[iz] / cxph[ix]) * tmp[iz][iy]
- (mui * czm[iz] / cxph[ix]) * Bza[iz][_PB_CYM][ix];
Bza[iz][_PB_CYM][ix] = tmp[iz][iy];
}
clf[iz][iy] = Ex[iz][_PB_CYM][_PB_CXM] - Ax[iz][_PB_CXM] + Ry[iz][_PB_CYM] - Ey[iz][_PB_CYM][_PB_CXM];
tmp[iz][iy] = (cymh[_PB_CYM] / cyph[_PB_CYM]) * Bza[iz][_PB_CYM][_PB_CXM] - (ch / cyph[_PB_CYM]) * clf[iz][iy];
Hz[iz][_PB_CYM][_PB_CXM] = (cxmh[_PB_CXM] / cxph[_PB_CXM]) * Hz[iz][_PB_CYM][_PB_CXM]
+ (mui * czp[iz] / cxph[_PB_CXM]) * tmp[iz][iy]
- (mui * czm[iz] / cxph[_PB_CXM]) * Bza[iz][_PB_CYM][_PB_CXM];
Bza[iz][_PB_CYM][_PB_CXM] = tmp[iz][iy];
}
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int cz, int cxm, int cym,
DATA_TYPE POLYBENCH_3D(A,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1),
DATA_TYPE POLYBENCH_3D(B,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1)) {
int i, j, k;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_CZ + 1; i++)
for (j = 0; j < _PB_CYM + 1; j++)
for (k = 0; k < _PB_CXM + 1; k++)
{
double V1 = A[i][j][k];
double V2 = B[i][j][k];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d][%d] = %lf and B[%d][%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, k, V1, i, j, k, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int cz = CZ; int cz = CZ;
int cym = CYM; int cym = CYM;
int cxm = CXM; int cxm = CXM;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
DATA_TYPE mui; DATA_TYPE mui;
DATA_TYPE ch; DATA_TYPE ch;
POLYBENCH_2D_ARRAY_DECL(Ax,DATA_TYPE,CZ+1,CYM+1,cz+1,cym+1); POLYBENCH_2D_ARRAY_DECL(Ax,DATA_TYPE,CZ+1,CYM+1,cz+1,cym+1);
POLYBENCH_2D_ARRAY_DECL(Ry,DATA_TYPE,CZ+1,CYM+1,cz+1,cym+1); POLYBENCH_2D_ARRAY_DECL(Ry,DATA_TYPE,CZ+1,CYM+1,cz+1,cym+1);
POLYBENCH_2D_ARRAY_DECL(clf,DATA_TYPE,CYM+1,CXM+1,cym+1,cxm+1); POLYBENCH_2D_ARRAY_DECL(clf,DATA_TYPE,CYM+1,CXM+1,cym+1,cxm+1);
POLYBENCH_2D_ARRAY_DECL(tmp,DATA_TYPE,CYM+1,CXM+1,cym+1,cxm+1); POLYBENCH_2D_ARRAY_DECL(tmp,DATA_TYPE,CYM+1,CXM+1,cym+1,cxm+1);
POLYBENCH_3D_ARRAY_DECL(Bza,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); POLYBENCH_3D_ARRAY_DECL(Bza,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1);
POLYBENCH_3D_ARRAY_DECL(Ex,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1); 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(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); POLYBENCH_3D_ARRAY_DECL(Hz,DATA_TYPE,CZ+1,CYM+1,CXM+1,cz+1,cym+1,cxm+1);
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);
POLYBENCH_1D_ARRAY_DECL(czm,DATA_TYPE,CZ+1,cz+1); 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(czp,DATA_TYPE,CZ+1,cz+1);
POLYBENCH_1D_ARRAY_DECL(cxmh,DATA_TYPE,CXM+1,cxm+1); POLYBENCH_1D_ARRAY_DECL(cxmh,DATA_TYPE,CXM+1,cxm+1);
POLYBENCH_1D_ARRAY_DECL(cxph,DATA_TYPE,CXM+1,cxm+1); POLYBENCH_1D_ARRAY_DECL(cxph,DATA_TYPE,CXM+1,cxm+1);
POLYBENCH_1D_ARRAY_DECL(cymh,DATA_TYPE,CYM+1,cym+1); POLYBENCH_1D_ARRAY_DECL(cymh,DATA_TYPE,CYM+1,cym+1);
POLYBENCH_1D_ARRAY_DECL(cyph,DATA_TYPE,CYM+1,cym+1); POLYBENCH_1D_ARRAY_DECL(cyph,DATA_TYPE,CYM+1,cym+1);
/* Initialize array(s). */ /* Initialize array(s). */
Show All 29 Lines kernel_fdtd_apml (cz, cxm, cym, mui, ch,
POLYBENCH_ARRAY(cxph), POLYBENCH_ARRAY(cxph),
POLYBENCH_ARRAY(cymh), POLYBENCH_ARRAY(cymh),
POLYBENCH_ARRAY(cyph)); POLYBENCH_ARRAY(cyph));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
init_array (cz, cxm, cym, &mui, &ch,
POLYBENCH_ARRAY(Ax),
POLYBENCH_ARRAY(Ry),
POLYBENCH_ARRAY(Ex_StrictFP),
POLYBENCH_ARRAY(Ey_StrictFP),
POLYBENCH_ARRAY(Hz_StrictFP),
POLYBENCH_ARRAY(czm),
POLYBENCH_ARRAY(czp),
POLYBENCH_ARRAY(cxmh),
POLYBENCH_ARRAY(cxph),
POLYBENCH_ARRAY(cymh),
POLYBENCH_ARRAY(cyph));
kernel_fdtd_apml_StrictFP(cz, cxm, cym, mui, ch,
POLYBENCH_ARRAY(Ax),
POLYBENCH_ARRAY(Ry),
POLYBENCH_ARRAY(clf),
POLYBENCH_ARRAY(tmp),
POLYBENCH_ARRAY(Bza_StrictFP),
POLYBENCH_ARRAY(Ex_StrictFP),
POLYBENCH_ARRAY(Ey_StrictFP),
POLYBENCH_ARRAY(Hz_StrictFP),
POLYBENCH_ARRAY(czm),
POLYBENCH_ARRAY(czp),
POLYBENCH_ARRAY(cxmh),
POLYBENCH_ARRAY(cxph),
POLYBENCH_ARRAY(cymh),
POLYBENCH_ARRAY(cyph));
if (!check_FP(cz, cxm, cym, POLYBENCH_ARRAY(Bza), POLYBENCH_ARRAY(Bza_StrictFP)))
return 1;
if (!check_FP(cz, cxm, cym, POLYBENCH_ARRAY(Ex), POLYBENCH_ARRAY(Ex_StrictFP)))
return 1;
if (!check_FP(cz, cxm, cym, POLYBENCH_ARRAY(Ey), POLYBENCH_ARRAY(Ey_StrictFP)))
return 1;
if (!check_FP(cz, cxm, cym, POLYBENCH_ARRAY(Hz), POLYBENCH_ARRAY(Hz_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(cz, cxm, cym, polybench_prevent_dce(print_array(cz, cxm, cym,
POLYBENCH_ARRAY(Bza), POLYBENCH_ARRAY(Bza_StrictFP),
POLYBENCH_ARRAY(Ex), POLYBENCH_ARRAY(Ex_StrictFP),
POLYBENCH_ARRAY(Ey), POLYBENCH_ARRAY(Ey_StrictFP),
POLYBENCH_ARRAY(Hz))); POLYBENCH_ARRAY(Hz_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(Ax); POLYBENCH_FREE_ARRAY(Ax);
POLYBENCH_FREE_ARRAY(Ry); POLYBENCH_FREE_ARRAY(Ry);
POLYBENCH_FREE_ARRAY(clf); POLYBENCH_FREE_ARRAY(clf);
POLYBENCH_FREE_ARRAY(tmp); POLYBENCH_FREE_ARRAY(tmp);
POLYBENCH_FREE_ARRAY(Bza); POLYBENCH_FREE_ARRAY(Bza);
POLYBENCH_FREE_ARRAY(Ex); POLYBENCH_FREE_ARRAY(Ex);
POLYBENCH_FREE_ARRAY(Ey); POLYBENCH_FREE_ARRAY(Ey);
POLYBENCH_FREE_ARRAY(Hz); POLYBENCH_FREE_ARRAY(Hz);
POLYBENCH_FREE_ARRAY(Bza_StrictFP);
POLYBENCH_FREE_ARRAY(Ex_StrictFP);
POLYBENCH_FREE_ARRAY(Ey_StrictFP);
POLYBENCH_FREE_ARRAY(Hz_StrictFP);
POLYBENCH_FREE_ARRAY(czm); POLYBENCH_FREE_ARRAY(czm);
POLYBENCH_FREE_ARRAY(czp); POLYBENCH_FREE_ARRAY(czp);
POLYBENCH_FREE_ARRAY(cxmh); POLYBENCH_FREE_ARRAY(cxmh);
POLYBENCH_FREE_ARRAY(cxph); POLYBENCH_FREE_ARRAY(cxph);
POLYBENCH_FREE_ARRAY(cymh); POLYBENCH_FREE_ARRAY(cymh);
POLYBENCH_FREE_ARRAY(cyph); POLYBENCH_FREE_ARRAY(cyph);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/stencils/jacobi-1d-imper/Makefile

LEVEL = ../../../../.. LEVEL = ../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = jacobi-1d-imper PROG = jacobi-1d-imper
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/stencils/jacobi-1d-imper/jacobi-1d-imper.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 100x10000. */ /* Default data type is double, default size is 100x10000. */
#include "jacobi-1d-imper.h" #include "jacobi-1d-imper.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array (int n, void init_array (int n,
DATA_TYPE POLYBENCH_1D(A,N,n), DATA_TYPE POLYBENCH_1D(A,N,n),
DATA_TYPE POLYBENCH_1D(B,N,n)) DATA_TYPE POLYBENCH_1D(B,N,n))
{ {
#pragma STDC FP_CONTRACT OFF
int i; int i;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
A[i] = ((DATA_TYPE) i+ 2) / n; A[i] = ((DATA_TYPE) i+ 2) / n;
B[i] = ((DATA_TYPE) i+ 3) / n; B[i] = ((DATA_TYPE) i+ 3) / n;
} }
} }
Show All 33 Lines#pragma scop
B[i] = 0.33333 * (A[i-1] + A[i] + A[i + 1]); B[i] = 0.33333 * (A[i-1] + A[i] + A[i + 1]);
for (j = 1; j < _PB_N - 1; j++) for (j = 1; j < _PB_N - 1; j++)
A[j] = B[j]; A[j] = B[j];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_jacobi_1d_imper_StrictFP(int tsteps,
int n,
DATA_TYPE POLYBENCH_1D(A,N,n),
DATA_TYPE POLYBENCH_1D(B,N,n))
{
#pragma STDC FP_CONTRACT OFF
int t, i, j;
for (t = 0; t < _PB_TSTEPS; t++)
{
for (i = 1; i < _PB_N - 1; i++)
B[i] = 0.33333 * (A[i-1] + A[i] + A[i + 1]);
for (j = 1; j < _PB_N - 1; j++)
A[j] = B[j];
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static int
check_FP(int n,
DATA_TYPE POLYBENCH_1D(A,N,n),
DATA_TYPE POLYBENCH_1D(B,N,n)) {
int i;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_N; i++)
{
double V1 = A[i];
double V2 = B[i];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d] = %lf and B[%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, V1, i, V2, AbsTolerance);
return 0;
}
}
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int n = N; int n = N;
int tsteps = TSTEPS; int tsteps = TSTEPS;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_1D_ARRAY_DECL(A, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(A, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(A_StrictFP, DATA_TYPE, N, n);
POLYBENCH_1D_ARRAY_DECL(B, DATA_TYPE, N, n); POLYBENCH_1D_ARRAY_DECL(B, DATA_TYPE, N, n);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); init_array (n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_jacobi_1d_imper (tsteps, n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); kernel_jacobi_1d_imper (tsteps, n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
init_array (n, POLYBENCH_ARRAY(A_StrictFP), POLYBENCH_ARRAY(B));
kernel_jacobi_1d_imper (tsteps, n, POLYBENCH_ARRAY(A_StrictFP),
POLYBENCH_ARRAY(B));
if (!check_FP(n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(B); POLYBENCH_FREE_ARRAY(B);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/stencils/jacobi-2d-imper/Makefile

LEVEL = ../../../../.. LEVEL = ../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = jacobi-2d-imper PROG = jacobi-2d-imper
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/stencils/jacobi-2d-imper/jacobi-2d-imper.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 20x1000. */ /* Default data type is double, default size is 20x1000. */
#include "jacobi-2d-imper.h" #include "jacobi-2d-imper.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array (int n, void init_array (int n,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n), DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_2D(B,N,N,n,n)) DATA_TYPE POLYBENCH_2D(B,N,N,n,n))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
{ {
A[i][j] = ((DATA_TYPE) i*(j+2) + 2) / n; A[i][j] = ((DATA_TYPE) i*(j+2) + 2) / n;
B[i][j] = ((DATA_TYPE) i*(j+3) + 3) / n; B[i][j] = ((DATA_TYPE) i*(j+3) + 3) / n;
} }
Show All 38 Lines B[i][j] = 0.2 * (A[i][j] + A[i][j-1] + A[i][1+j] + A[1+i][j] + A[i-1][j]);
for (i = 1; i < _PB_N-1; i++) for (i = 1; i < _PB_N-1; i++)
for (j = 1; j < _PB_N-1; j++) for (j = 1; j < _PB_N-1; j++)
A[i][j] = B[i][j]; A[i][j] = B[i][j];
} }
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_jacobi_2d_imper_StrictFP(int tsteps,
int n,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_2D(B,N,N,n,n))
{
#pragma STDC FP_CONTRACT OFF
int t, i, j;
for (t = 0; t < _PB_TSTEPS; t++)
{
for (i = 1; i < _PB_N - 1; i++)
for (j = 1; j < _PB_N - 1; j++)
B[i][j] = 0.2 * (A[i][j] + A[i][j-1] + A[i][1+j] + A[1+i][j] + A[i-1][j]);
for (i = 1; i < _PB_N-1; i++)
for (j = 1; j < _PB_N-1; j++)
A[i][j] = B[i][j];
}
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int n,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_2D(B,N,N,n,n)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_N; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int n = N; int n = N;
int tsteps = TSTEPS; int tsteps = TSTEPS;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n);
POLYBENCH_2D_ARRAY_DECL(A_StrictFP, DATA_TYPE, N, N, n, n);
POLYBENCH_2D_ARRAY_DECL(B, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(B, DATA_TYPE, N, N, n, n);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); init_array (n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_jacobi_2d_imper (tsteps, n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B)); kernel_jacobi_2d_imper (tsteps, n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(B));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
init_array (n, POLYBENCH_ARRAY(A_StrictFP), POLYBENCH_ARRAY(B));
kernel_jacobi_2d_imper_StrictFP(tsteps, n, POLYBENCH_ARRAY(A_StrictFP),
POLYBENCH_ARRAY(B));
if (!check_FP(n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A_StrictFP)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(A_StrictFP);
POLYBENCH_FREE_ARRAY(B); POLYBENCH_FREE_ARRAY(B);
return 0; return 0;
} }

test-suite/trunk/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)
add_definitions(-DFP_ABSTOLERANCE=1e-5)
llvm_singlesource() llvm_singlesource()

test-suite/trunk/SingleSource/Benchmarks/Polybench/stencils/seidel-2d/Makefile

LEVEL = ../../../../.. LEVEL = ../../../../..
POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities POLYBENCH_UTILS = SingleSource/Benchmarks/Polybench/utilities
PROG = seidel-2d PROG = seidel-2d
CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS CFLAGS += -I $(PROJ_SRC_ROOT)/$(POLYBENCH_UTILS) -DPOLYBENCH_DUMP_ARRAYS -DFP_ABSTOLERANCE=1e-5
ifdef SMALL_PROBLEM_SIZE ifdef SMALL_PROBLEM_SIZE
CFLAGS += -DSMALL_DATASET CFLAGS += -DSMALL_DATASET
endif endif
HASH_PROGRAM_OUTPUT = 1 HASH_PROGRAM_OUTPUT = 1
include $(LEVEL)/SingleSource/Makefile.singlesrc include $(LEVEL)/SingleSource/Makefile.singlesrc

test-suite/trunk/SingleSource/Benchmarks/Polybench/stencils/seidel-2d/seidel-2d.c

Show All 13 Lines
#include <polybench.h> #include <polybench.h>
/* Include benchmark-specific header. */ /* Include benchmark-specific header. */
/* Default data type is double, default size is 20x1000. */ /* Default data type is double, default size is 20x1000. */
#include "seidel-2d.h" #include "seidel-2d.h"
/* Array initialization. */ /* Array initialization. */
static __attribute__((optnone)) static
void init_array (int n, void init_array (int n,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n)) DATA_TYPE POLYBENCH_2D(A,N,N,n,n))
{ {
#pragma STDC FP_CONTRACT OFF
int i, j; int i, j;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
A[i][j] = ((DATA_TYPE) i*(j+2) + 2) / n; A[i][j] = ((DATA_TYPE) i*(j+2) + 2) / n;
} }
Show All 31 Lines for (i = 1; i<= _PB_N - 2; i++)
for (j = 1; j <= _PB_N - 2; j++) for (j = 1; j <= _PB_N - 2; j++)
A[i][j] = (A[i-1][j-1] + A[i-1][j] + A[i-1][j+1] A[i][j] = (A[i-1][j-1] + A[i-1][j] + A[i-1][j+1]
+ A[i][j-1] + A[i][j] + A[i][j+1] + A[i][j-1] + A[i][j] + A[i][j+1]
+ A[i+1][j-1] + A[i+1][j] + A[i+1][j+1])/9.0; + A[i+1][j-1] + A[i+1][j] + A[i+1][j+1])/9.0;
#pragma endscop #pragma endscop
} }
__attribute__((optnone)) static void
kernel_seidel_2d_StrictFP(int tsteps,
int n,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n))
{
#pragma STDC FP_CONTRACT OFF
int t, i, j;
for (t = 0; t <= _PB_TSTEPS - 1; t++)
for (i = 1; i<= _PB_N - 2; i++)
for (j = 1; j <= _PB_N - 2; j++)
A[i][j] = (A[i-1][j-1] + A[i-1][j] + A[i-1][j+1]
+ A[i][j-1] + A[i][j] + A[i][j+1]
+ A[i+1][j-1] + A[i+1][j] + A[i+1][j+1])/9.0;
}
/* Return 0 when one of the elements of arrays A and B do not match within the
allowed FP_ABSTOLERANCE. Return 1 when all elements match. */
static inline int
check_FP(int n,
DATA_TYPE POLYBENCH_2D(A,N,N,n,n),
DATA_TYPE POLYBENCH_2D(B,N,N,n,n)) {
int i, j;
double AbsTolerance = FP_ABSTOLERANCE;
for (i = 0; i < _PB_N; i++)
for (j = 0; j < _PB_N; j++)
{
double V1 = A[i][j];
double V2 = B[i][j];
double Diff = fabs(V1 - V2);
if (Diff > AbsTolerance) {
fprintf(stderr, "A[%d][%d] = %lf and B[%d][%d] = %lf differ more than"
" FP_ABSTOLERANCE = %lf\n", i, j, V1, i, j, V2, AbsTolerance);
return 0;
}
}
/* All elements are within the allowed FP_ABSTOLERANCE error margin. */
return 1;
}
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
/* Retrieve problem size. */ /* Retrieve problem size. */
int n = N; int n = N;
int tsteps = TSTEPS; int tsteps = TSTEPS;
/* Variable declaration/allocation. */ /* Variable declaration/allocation. */
POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n); POLYBENCH_2D_ARRAY_DECL(A, DATA_TYPE, N, N, n, n);
POLYBENCH_2D_ARRAY_DECL(A_StrictFP, DATA_TYPE, N, N, n, n);
/* Initialize array(s). */ /* Initialize array(s). */
init_array (n, POLYBENCH_ARRAY(A)); init_array (n, POLYBENCH_ARRAY(A));
/* Start timer. */ /* Start timer. */
polybench_start_instruments; polybench_start_instruments;
/* Run kernel. */ /* Run kernel. */
kernel_seidel_2d (tsteps, n, POLYBENCH_ARRAY(A)); kernel_seidel_2d (tsteps, n, POLYBENCH_ARRAY(A));
/* Stop and print timer. */ /* Stop and print timer. */
polybench_stop_instruments; polybench_stop_instruments;
polybench_print_instruments; polybench_print_instruments;
init_array (n, POLYBENCH_ARRAY(A_StrictFP));
kernel_seidel_2d (tsteps, n, POLYBENCH_ARRAY(A_StrictFP));
if (!check_FP(n, POLYBENCH_ARRAY(A), POLYBENCH_ARRAY(A_StrictFP)))
return 1;
/* Prevent dead-code elimination. All live-out data must be printed /* Prevent dead-code elimination. All live-out data must be printed
by the function call in argument. */ by the function call in argument. */
polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A))); polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(A)));
/* Be clean. */ /* Be clean. */
POLYBENCH_FREE_ARRAY(A); POLYBENCH_FREE_ARRAY(A);
POLYBENCH_FREE_ARRAY(A_StrictFP);
return 0; return 0;
} }