This is an archive of the discontinued LLVM Phabricator instance.

Differential D15416

Polybench: Remove undefined behavior introduce in r241675
ClosedPublic

Authored by grosser on Dec 10 2015, 6:35 AM.

Details

Reviewers
rengolin
hfinkel
Commits
rOLDT258498: Polybench: Remove undefined behavior introduce in r241675
rL258498: Polybench: Remove undefined behavior introduce in r241675
Summary
  • Make sure strings are NULL terminated
  • The floats we look at are double, not single precision. Hence, do not forget to hash the second part.

Diff Detail

Event Timeline

grosser updated this revision to Diff 42423.Dec 10 2015, 6:35 AM
grosser retitled this revision from to Polybench: Remove undefined behavior introduce in r241675.
grosser updated this object.
grosser added a reviewer: rengolin.
grosser added a subscriber: llvm-commits.
grosser added a comment.Dec 23 2015, 9:39 AM

Hi Renato,

you are probably off for holidays, but I still want to "ping" this patch to at least ensure it's at the beginning of the mailbox when you get back. ;) I would very much appreciate a review then.

Thank you and happy holidays!
Tobias

grosser added a reviewer: hfinkel.Jan 6 2016, 7:38 AM

Hi Hal (or Renato),

I am waiting since a while on a review for this patch. Could you guys possibly have a look.

All the best,
Tobias

rengolin accepted this revision.Jan 14 2016, 1:38 AM
rengolin edited edge metadata.

Hi Tobi,

Sorry for the delay, I missed this completely!

The change makes total sense. LGTM!

cheers,
--renato

This revision is now accepted and ready to land.Jan 14 2016, 1:38 AM
Closed by commit rL258498: Polybench: Remove undefined behavior introduce in r241675 (authored by grosser). · Explain WhyJan 22 2016, 2:32 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
SingleSource/
Benchmarks/
Polybench/
datamining/
correlation/
7 lines
2 lines
2 lines
covariance/
4 lines
2 lines
2 lines
linear-algebra/
kernels/
2mm/
4 lines
2 lines
2 lines
3mm/
4 lines
2 lines
2 lines
atax/
4 lines
2 lines
bicg/
6 lines
2 lines
cholesky/
4 lines
2 lines
2 lines
doitgen/
4 lines
2 lines
2 lines
gemm/
4 lines
2 lines
2 lines
gesummv/
4 lines
2 lines
2 lines
mvt/
6 lines
2 lines
symm/
4 lines
2 lines
2 lines
syr2k/
4 lines
2 lines
2 lines
syrk/
4 lines
2 lines
2 lines
trisolv/
4 lines
2 lines
trmm/
4 lines
2 lines
2 lines
solvers/
lu/
4 lines
2 lines
medley/
floyd-warshall/
4 lines
2 lines
2 lines
stencils/
adi/
4 lines
2 lines
2 lines
fdtd-2d/
8 lines
2 lines
2 lines
jacobi-1d-imper/
4 lines
2 lines
jacobi-2d-imper/
4 lines
2 lines
2 lines
seidel-2d/
4 lines
2 lines
2 lines
utilities/
38 lines

Diff 42423

SingleSource/Benchmarks/Polybench/datamining/correlation/correlation.c

Show All 37 Lines
/* 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 m, void print_array(int m,
DATA_TYPE POLYBENCH_2D(symmat,M,M,m,m)) DATA_TYPE POLYBENCH_2D(symmat,M,M,m,m))
{ {
int i, j; int i, j;
char *printmat = malloc(m*8); char *printmat = malloc(m*16 + 1); printmat[m*16] = 0;
for (i = 0; i < m; i++) { for (i = 0; i < m; i++) {
for (j = 0; j < m; j++) for (j = 0; j < m; j++) {
print_element(symmat[i][j], j*8, printmat); print_element(symmat[i][j], j*16, printmat);
}
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/datamining/correlation/correlation.reference_output

ab44d09216ee09fe72e448e7c9a0a13b 1ba44a2636ee1214d9358c8a1a9890ef

SingleSource/Benchmarks/Polybench/datamining/correlation/correlation.reference_output.small

4dcdd4b95a19a6cfbd32f4d5f24e17be e8a2fb6cb92e6edbf300ecdacd647316

SingleSource/Benchmarks/Polybench/datamining/covariance/covariance.c

Show All 36 Lines
/* 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 m, void print_array(int m,
DATA_TYPE POLYBENCH_2D(symmat,M,M,m,m)) DATA_TYPE POLYBENCH_2D(symmat,M,M,m,m))
{ {
int i, j; int i, j;
char *printmat = malloc(m*8); char *printmat = malloc(m*16 + 1); printmat[m*16] = 0;
for (i = 0; i < m; i++) { for (i = 0; i < m; i++) {
for (j = 0; j < m; j++) for (j = 0; j < m; j++)
print_element(symmat[i][j], j*8, printmat); print_element(symmat[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/datamining/covariance/covariance.reference_output

7a284ecb4d8b0f9e4132181b8c8754cc 82b48e22752b25e42e5ba7a456c07467

SingleSource/Benchmarks/Polybench/datamining/covariance/covariance.reference_output.small

cd7b8424a3c3635d1ea90f42e415faa7 63a8ee32bee3b68a5edc4fd680ed438d

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

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
/* 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))
{ {
int i, j; int i, j;
char *printmat = malloc(nl*8); char *printmat = malloc(nl*16 + 1); printmat[nl*16] = 0;
for (i = 0; i < ni; i++) { for (i = 0; i < ni; i++) {
for (j = 0; j < nl; j++) for (j = 0; j < nl; j++)
print_element(D[i][j], j*8, printmat); print_element(D[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.reference_output

f9f294040187318bc2cc477e7eecab01 422aa03845e5d0cd97cb018c5b4d61e5

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/2mm/2mm.reference_output.small

68efcbd188b404f4fb09803b61c02f60 eac6d4f27d66fcd1d9e32bc3155f93b6

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

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
/* 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(G,NI,NL,ni,nl)) DATA_TYPE POLYBENCH_2D(G,NI,NL,ni,nl))
{ {
int i, j; int i, j;
char *printmat = malloc(nl*8); char *printmat = malloc(nl*16 + 1); printmat[nl*16] = 0;
for (i = 0; i < ni; i++) { for (i = 0; i < ni; i++) {
for (j = 0; j < nl; j++) for (j = 0; j < nl; j++)
print_element(G[i][j], j*8, printmat); print_element(G[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/3mm.reference_output

f52121e0bccc072008e52a06798e05db bddaec967faf18122e44b0073e6f8532

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/3mm/3mm.reference_output.small

7779d064d80186d46a0d91b8f6116c62 5649bd55b3ddd097acb8ebb6cb14b3b0

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/atax.c

Show All 36 Lines
/* 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;
char *printmat = malloc(nx*8); char *printmat = malloc(nx*16 + 1); printmat[nx*16] = 0;
for (i = 0; i < nx; i++) for (i = 0; i < nx; i++)
print_element(y[i], i*8, printmat); print_element(y[i], i*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
free(printmat); free(printmat);
} }
/* 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
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/atax/atax.reference_output

88a04eb3d01f6346a6ee4b678e311fe5 55df10ccc646517c6e78304b428a5b53

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/bicg.c

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
static static
void print_array(int nx, int ny, void print_array(int nx, int ny,
DATA_TYPE POLYBENCH_1D(s,NY,ny), DATA_TYPE POLYBENCH_1D(s,NY,ny),
DATA_TYPE POLYBENCH_1D(q,NX,nx)) DATA_TYPE POLYBENCH_1D(q,NX,nx))
{ {
int i; int i;
int n = nx > ny ? nx : ny; int n = nx > ny ? nx : ny;
char *printmat = malloc(n*8); char *printmat = malloc(n*16 + 1); printmat[n*16] = 0;
for (i = 0; i < ny; i++) for (i = 0; i < ny; i++)
print_element(s[i], i*8, printmat); print_element(s[i], i*16, printmat);
*(printmat+i) = 0; *(printmat+i) = 0;
fputs(printmat, stderr); fputs(printmat, stderr);
for (i = 0; i < nx; i++) for (i = 0; i < nx; i++)
print_element(q[i], i*8, printmat); print_element(q[i], i*16, printmat);
*(printmat+i) = 0; *(printmat+i) = 0;
fputs(printmat, stderr); fputs(printmat, stderr);
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/bicg/bicg.reference_output

22fab907b016327a2808510b55959131 74944d07ab36d6b25801a785eae90cac

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/cholesky/cholesky.c

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
/* 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))
{ {
int i, j; int i, j;
char *printmat = malloc(n*8); char *printmat = malloc(n*16 + 1); printmat[n*16] = 0;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
print_element(A[i][j], j*8, printmat); print_element(A[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/cholesky/cholesky.reference_output

5da79cc798c356034dfdf5ac98b3ecaa 2adac2da4878b10c3a2c0881ecb534ac

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/cholesky/cholesky.reference_output.small

e9aaf9cf2963bd1cc5183174c0dfadc1 637d089a6787bb1a31273d62104fbee1

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/doitgen.c

Show All 37 Lines
/* 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 nr, int nq, int np, void print_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))
{ {
int i, j, k; int i, j, k;
char *printmat = malloc(np*8); char *printmat = malloc(np*16 + 1); printmat[np*16] = 0;
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++)
print_element(A[i][j][k], k*8, printmat); print_element(A[i][j][k], k*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/doitgen.reference_output

73c37cc505bf1b3706695ed80db85dbf fbacccfd2d72d91c5287be840c949cec

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/doitgen/doitgen.reference_output.small

3c8a6a1e9fe6738b6d2d79335360194d 8a5318ea2236f721194816e9aea7fd56

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemm/gemm.c

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
/* 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 nj, void print_array(int ni, int nj,
DATA_TYPE POLYBENCH_2D(C,NI,NJ,ni,nj)) DATA_TYPE POLYBENCH_2D(C,NI,NJ,ni,nj))
{ {
int i, j; int i, j;
char *printmat = malloc(nj*8); char *printmat = malloc(nj*16 + 1); printmat[nj*16] = 0;
for (i = 0; i < ni; i++) { for (i = 0; i < ni; i++) {
for (j = 0; j < nj; j++) for (j = 0; j < nj; j++)
print_element(C[i][j], j*8, printmat); print_element(C[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemm/gemm.reference_output

622af90c831b234ea835317cd4bb4123 d72834010eeff657031ceb2493f9e3f7

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gemm/gemm.reference_output.small

8685643738936fe8ee951f5e06200e56 84e7a821aa0da2cf1d477d1b779d5e9a

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/gesummv.c

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
/* 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_1D(y,N,n)) DATA_TYPE POLYBENCH_1D(y,N,n))
{ {
int i; int i;
char *printmat = malloc(n*8); char *printmat = malloc(n*16 + 1); printmat[n*16] = 0;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
print_element(y[i], i*8, printmat); print_element(y[i], i*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
free(printmat); free(printmat);
} }
/* 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
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/gesummv.reference_output

23b6382cb41cacbb93c669e92d7c4b7e a98456b34f7d94e1763bfddd510d248d

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/gesummv/gesummv.reference_output.small

d0f71814a5109a3f373ed7587e6b0b0b 3ab0068ba1a4869e1be8da112aef0ea5

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/mvt/mvt.c

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines/* 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_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))
{ {
int i; int i;
char *printmat = malloc(n*8); char *printmat = malloc(n*16 + 1); printmat[n*16] = 0;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
print_element(x1[i], i*8, printmat); print_element(x1[i], i*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
print_element(x2[i], i*8, printmat); print_element(x2[i], i*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
free(printmat); free(printmat);
} }
/* 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
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/mvt/mvt.reference_output

74b403cb1904ef24879eeb0f8e031b4e 5c582f225125e1421faaf093ae45d7db

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/symm.c

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
/* 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 nj, void print_array(int ni, int nj,
DATA_TYPE POLYBENCH_2D(C,NI,NJ,ni,nj)) DATA_TYPE POLYBENCH_2D(C,NI,NJ,ni,nj))
{ {
int i, j; int i, j;
char *printmat = malloc(nj*8); char *printmat = malloc(nj*16 + 1); printmat[nj*16] = 0;
for (i = 0; i < ni; i++) { for (i = 0; i < ni; i++) {
for (j = 0; j < nj; j++) for (j = 0; j < nj; j++)
print_element(C[i][j], j*8, printmat); print_element(C[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/symm.reference_output

e1dddd8c9c19bf9f1e7cbf0c239ce46a b407e999602930ed00169900fb4142de

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/symm/symm.reference_output.small

7d05186f98518c24e49d2229c5e0ad1c c83a78a6235a46dd9a6fc6c7c13f3a39

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syr2k/syr2k.c

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
/* 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))
{ {
int i, j; int i, j;
char *printmat = malloc(ni*8); char *printmat = malloc(ni*16 + 1); printmat[ni*16] = 0;
for (i = 0; i < ni; i++) { for (i = 0; i < ni; i++) {
for (j = 0; j < ni; j++) for (j = 0; j < ni; j++)
print_element(C[i][j], j*8, printmat); print_element(C[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syr2k/syr2k.reference_output

3c957bddeddf967b7ae73a4c4546e229 81f28343f4089dfc8545b25249067d8a

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syr2k/syr2k.reference_output.small

5e7018090d8a48bc5171713008ad0831 91822c3c95174cc637351e386eb6adfa

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syrk/syrk.c

Show All 40 Lines
/* 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))
{ {
int i, j; int i, j;
char *printmat = malloc(ni*8); char *printmat = malloc(ni*16 + 1); printmat[ni*16] = 0;
for (i = 0; i < ni; i++) { for (i = 0; i < ni; i++) {
for (j = 0; j < ni; j++) for (j = 0; j < ni; j++)
print_element(C[i][j], j*8, printmat); print_element(C[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syrk/syrk.reference_output

622af90c831b234ea835317cd4bb4123 d72834010eeff657031ceb2493f9e3f7

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/syrk/syrk.reference_output.small

8685643738936fe8ee951f5e06200e56 84e7a821aa0da2cf1d477d1b779d5e9a

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/trisolv.c

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
/* 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_1D(x,N,n)) DATA_TYPE POLYBENCH_1D(x,N,n))
{ {
int i; int i;
char *printmat = malloc(n*8); char *printmat = malloc(n*16 + 1); printmat[n*16] = 0;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
print_element(x[i], i*8, printmat); print_element(x[i], i*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
free(printmat); free(printmat);
} }
/* 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
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trisolv/trisolv.reference_output

6b6b1c3ed0d6abeda5af3b76f89a3331 d58d21a9e558bfff03ca8558a9d0251d

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/trmm.c

Show All 37 Lines
/* 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(B,NI,NI,ni,ni)) DATA_TYPE POLYBENCH_2D(B,NI,NI,ni,ni))
{ {
int i, j; int i, j;
char *printmat = malloc(ni*8); char *printmat = malloc(ni*16 + 1); printmat[ni*16] = 0;
for (i = 0; i < ni; i++) { for (i = 0; i < ni; i++) {
for (j = 0; j < ni; j++) for (j = 0; j < ni; j++)
print_element(B[i][j], j*8, printmat); print_element(B[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/trmm.reference_output

93f3c10749d75b23e8a19b6931b48486 b15ac1b0d0cd75da78f553b1f9da2673

SingleSource/Benchmarks/Polybench/linear-algebra/kernels/trmm/trmm.reference_output.small

1d2d6c667c5f036d5e51428f5aed37ef 7e371557248fa085c906fec361fbfeac

SingleSource/Benchmarks/Polybench/linear-algebra/solvers/lu/lu.c

Show All 33 Lines
/* 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))
{ {
int i, j; int i, j;
char *printmat = malloc(n*8); char *printmat = malloc(n*16 + 1); printmat[n*16] = 0;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
print_element(A[i][j], j*8, printmat); print_element(A[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/linear-algebra/solvers/lu/lu.reference_output

83a3b7d418f8e147ab88fa04966c7c37 064a3e60f06aeecd598f7f66b60035b6

SingleSource/Benchmarks/Polybench/medley/floyd-warshall/floyd-warshall.c

Show All 33 Lines
/* 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(path,N,N,n,n)) DATA_TYPE POLYBENCH_2D(path,N,N,n,n))
{ {
int i, j; int i, j;
char *printmat = malloc(n*8); char *printmat = malloc(n*16 + 1); printmat[n*16] = 0;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
print_element(path[i][j], j*8, printmat); print_element(path[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/medley/floyd-warshall/floyd-warshall.reference_output

72d6ab856485d06c244c238122cd13a8 cb96c8306dcb184cd35dea4694abb3ab

SingleSource/Benchmarks/Polybench/medley/floyd-warshall/floyd-warshall.reference_output.small

90b8c539c785cf4ca34231d074058d43 88615b373db5ad02fe09a10d3bba92dc

SingleSource/Benchmarks/Polybench/stencils/adi/adi.c

Show All 39 Lines
/* 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(X,N,N,n,n)) DATA_TYPE POLYBENCH_2D(X,N,N,n,n))
{ {
int i, j; int i, j;
char *printmat = malloc(n*8); char *printmat = malloc(n*16 + 1); printmat[n*16] = 0;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
print_element(X[i][j], j*8, printmat); print_element(X[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/stencils/adi/adi.reference_output

1823d3f6cf83a9b28749d6edaa5fedc9 a954c885e6119039294e81fd5cda4324

SingleSource/Benchmarks/Polybench/stencils/adi/adi.reference_output.small

5182fd4f225bdeea7e9cb31766de5ee2 dac9b9113be723b7da52c2887d065b04

SingleSource/Benchmarks/Polybench/stencils/fdtd-2d/fdtd-2d.c

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
static static
void print_array(int nx, void print_array(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))
{ {
int i, j; int i, j;
char *printmat = malloc(ny*8); char *printmat = malloc(ny*16 + 1); printmat[ny*16] = 0;
for (i = 0; i < nx; i++) { for (i = 0; i < nx; i++) {
for (j = 0; j < ny; j++) for (j = 0; j < ny; j++)
print_element(ex[i][j], j*8, printmat); print_element(ex[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
for (j = 0; j < ny; j++) for (j = 0; j < ny; j++)
print_element(ey[i][j], j*8, printmat); print_element(ey[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
for (j = 0; j < ny; j++) for (j = 0; j < ny; j++)
print_element(hz[i][j], j*8, printmat); print_element(hz[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/stencils/fdtd-2d/fdtd-2d.reference_output

70ea9d7528f3022d056656af4d540929 2eef9f06f24753aeca4fdb6190dfca15

SingleSource/Benchmarks/Polybench/stencils/fdtd-2d/fdtd-2d.reference_output.small

cd41e645df13df9fa373727b6e285f64 cf61a62ee26fc0ece455545f5789a4d8

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

Show All 36 Lines
/* 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_1D(A,N,n)) DATA_TYPE POLYBENCH_1D(A,N,n))
{ {
int i; int i;
char *printmat = malloc(n*8); char *printmat = malloc(n*16 + 1); printmat[n*16] = 0;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
print_element(A[i], i*8, printmat); print_element(A[i], i*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
free(printmat); free(printmat);
} }
/* 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
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/stencils/jacobi-1d-imper/jacobi-1d-imper.reference_output

53110044128f4550e864b8dd19771ba2 a9f60f2ecfde681ef37298d993dfb0db

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

Show All 37 Lines
/* 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))
{ {
int i, j; int i, j;
char *printmat = malloc(n*8); char *printmat = malloc(n*16 + 1); printmat[n*16] = 0;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
print_element(A[i][j], j*8, printmat); print_element(A[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/stencils/jacobi-2d-imper/jacobi-2d-imper.reference_output

58213157f3b250a08e33f260ecf70ee0 2f14483f199678d07eb29cc539b07546

SingleSource/Benchmarks/Polybench/stencils/jacobi-2d-imper/jacobi-2d-imper.reference_output.small

6a17fdd70db1d0cab444fdb6e69c1363 448bf8d2e52eb27f7f8d13ce2d7760af

SingleSource/Benchmarks/Polybench/stencils/seidel-2d/seidel-2d.c

Show All 33 Lines
/* 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))
{ {
int i, j; int i, j;
char *printmat = malloc(n*8); char *printmat = malloc(n*16 + 1); printmat[n*16] = 0;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) for (j = 0; j < n; j++)
print_element(A[i][j], j*8, printmat); print_element(A[i][j], j*16, printmat);
fputs(printmat, stderr); fputs(printmat, stderr);
} }
free(printmat); free(printmat);
} }
/* 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. */
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

SingleSource/Benchmarks/Polybench/stencils/seidel-2d/seidel-2d.reference_output

58213157f3b250a08e33f260ecf70ee0 0769894932e6a061493d271cc177d667

SingleSource/Benchmarks/Polybench/stencils/seidel-2d/seidel-2d.reference_output.small

6a17fdd70db1d0cab444fdb6e69c1363 de38fe7aea37fb6a05cb2f18bff8502d

SingleSource/Benchmarks/Polybench/utilities/polybench.h

Show First 20 Lines • Show All 604 Lines • ▼ Show 20 Linesvoid* polybench_alloc_data(unsigned long long int n, int elt_size)
return ret; return ret;
} }
/* To avoid calling printf M*M times (and make it run /* To avoid calling printf M*M times (and make it run
for a long time), we split the output into an encoded string, for a long time), we split the output into an encoded string,
and print it as a simple char pointer, M times. */ and print it as a simple char pointer, M times. */
static inline static inline
void print_element(float el, int pos, char *out) void print_element(double el, int pos, char *out)
{ {
union { union {
float datum; double datum;
char bytes[4]; char bytes[8];
} block; } block;
block.datum = el; block.datum = el;
/* each nibble as a char, within the printable range */ /* each nibble as a char, within the printable range */
#ifdef __BIG_ENDIAN__ #ifdef __BIG_ENDIAN__
*(out+pos+7) = (block.bytes[0]&0xF0>>4)+'0'; *(out+pos+15) = (block.bytes[0]&0xF0>>4)+'0';
*(out+pos+6) = (block.bytes[0]&0x0F) +'0'; *(out+pos+14) = (block.bytes[0]&0x0F) +'0';
*(out+pos+5) = (block.bytes[1]&0xF0>>4)+'0'; *(out+pos+13) = (block.bytes[1]&0xF0>>4)+'0';
*(out+pos+4) = (block.bytes[1]&0x0F) +'0'; *(out+pos+12) = (block.bytes[1]&0x0F) +'0';
*(out+pos+3) = (block.bytes[2]&0xF0>>4)+'0'; *(out+pos+11) = (block.bytes[2]&0xF0>>4)+'0';
*(out+pos+2) = (block.bytes[2]&0x0F) +'0'; *(out+pos+10) = (block.bytes[2]&0x0F) +'0';
*(out+pos+1) = (block.bytes[3]&0xF0>>4)+'0'; *(out+pos+9) = (block.bytes[3]&0xF0>>4)+'0';
*(out+pos) = (block.bytes[3]&0x0F) +'0'; *(out+pos+8) = (block.bytes[3]&0x0F) +'0';
*(out+pos+7) = (block.bytes[4]&0xF0>>4)+'0';
*(out+pos+6) = (block.bytes[4]&0x0F) +'0';
*(out+pos+5) = (block.bytes[5]&0xF0>>4)+'0';
*(out+pos+4) = (block.bytes[5]&0x0F) +'0';
*(out+pos+3) = (block.bytes[6]&0xF0>>4)+'0';
*(out+pos+2) = (block.bytes[6]&0x0F) +'0';
*(out+pos+1) = (block.bytes[7]&0xF0>>4)+'0';
*(out+pos) = (block.bytes[7]&0x0F) +'0';
#else #else
*(out+pos) = (block.bytes[0]&0xF0>>4)+'0'; *(out+pos) = (block.bytes[0]&0xF0>>4)+'0';
*(out+pos+1) = (block.bytes[0]&0x0F) +'0'; *(out+pos+1) = (block.bytes[0]&0x0F) +'0';
*(out+pos+2) = (block.bytes[1]&0xF0>>4)+'0'; *(out+pos+2) = (block.bytes[1]&0xF0>>4)+'0';
*(out+pos+3) = (block.bytes[1]&0x0F) +'0'; *(out+pos+3) = (block.bytes[1]&0x0F) +'0';
*(out+pos+4) = (block.bytes[2]&0xF0>>4)+'0'; *(out+pos+4) = (block.bytes[2]&0xF0>>4)+'0';
*(out+pos+5) = (block.bytes[2]&0x0F) +'0'; *(out+pos+5) = (block.bytes[2]&0x0F) +'0';
*(out+pos+6) = (block.bytes[3]&0xF0>>4)+'0'; *(out+pos+6) = (block.bytes[3]&0xF0>>4)+'0';
*(out+pos+7) = (block.bytes[3]&0x0F) +'0'; *(out+pos+7) = (block.bytes[3]&0x0F) +'0';
*(out+pos+8) = (block.bytes[4]&0xF0>>4)+'0';
*(out+pos+9) = (block.bytes[4]&0x0F) +'0';
*(out+pos+10) = (block.bytes[5]&0xF0>>4)+'0';
*(out+pos+11) = (block.bytes[5]&0x0F) +'0';
*(out+pos+12) = (block.bytes[6]&0xF0>>4)+'0';
*(out+pos+13) = (block.bytes[6]&0x0F) +'0';
*(out+pos+14) = (block.bytes[7]&0xF0>>4)+'0';
*(out+pos+15) = (block.bytes[7]&0x0F) +'0';
#endif #endif
} }
#endif /* !POLYBENCH_H */ #endif /* !POLYBENCH_H */