Benchmarking LLVM test suite
 Share
The version of the browser you are using is no longer supported. Please upgrade to a supported browser.Dismiss

 
View only
 
 
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1
S.No.
BenchmarkKernelLLVM RemarkPolyhedral infoVectorized?File pathComment
2
1MultiSource/Applications/ClamAV/for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj);
kk--;
}
s->mtfbase[ii] = kk + 1;
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Applications/ClamAV/libclamav_nsis_bzlib.c:746Test is getting failed
5
4MultiSource/Applications/lua/for (i=0; i<size; i++) {
Node *n = gnode(t, i);
gnext(n) = NULL;
setnilvalue(gkey(n));
setnilvalue(gval(n));
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loopContext : [shl] -> { : -2147483648 <= shl <= 2147483647 }
Invalid Context : [shl] -> { : 1 = 0 }
Assumed Context : [shl] -> { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial


=>This looks legal, as are just macros
llvm-test-suite/MultiSource/Applications/lua/ltable.c:285
Vectorized with pragma.
Execution time did not improve.
(regression)
6
5MultiSource/Applications/SPASS/for (i=1; i<memory__DYNMAXSIZE; i++) {
MEMORY_RESOURCE *CurrentResource;
int TotalSize;
memory_ARRAY[i] = &memory_PAGES[(i-1)/memory__SHAREDPAGES];
CurrentResource = memory_ARRAY[i];
CurrentResource->free = &memory__EOF;
CurrentResource->next = &memory__EOF;
CurrentResource->end_of_page = &memory__EOF;
CurrentResource->page = &memory__EOF;
CurrentResource->aligned_size = memory_CalculateRealBlockSize(i);
CurrentResource->total_size = memory_MARKSIZE
+ CurrentResource->aligned_size;
TotalSize = CurrentResource->total_size;
CurrentResource->offset =
((memory_PAGESIZE-extra)/TotalSize)*TotalSize
+ sizeof(POINTER) + memory_OFFSET;
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Applications/SPASS/memory.c:197
Before edition: 10.5028
After edition: 9.8123

We see a speedup.
9
8,9MultiSource/Benchmarks/TSVC/IndirectAddressing-flt/
MultiSource/Benchmarks/TSVC/IndirectAddressing-dbl/
for (int nl = 0; nl < ntimes; nl++) {
for (int i = 0; i < LEN; i++) {
a[i] = b[i] + c[i/2] * d[i];
}
dummy(a, b, c, d, e, aa, bb, cc, 0.);
}
loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Benchmarks/TSVC/IndirectAddressing-flt/../tsc.inc:5115
llvm-test-suite/MultiSource/Benchmarks/TSVC/IndirectAddressing-dbl/../tsc.inc:5115
Normal: 3.7420
After: 4.4345
FAILED
12
14,15
MultiSource/Benchmarks/TSVC/LinearDependence-flt/
MultiSource/Benchmarks/TSVC/LinearDependence-dbl/
for (int nl = 0; nl < 200*(ntimes/(LEN2)); nl++) {
for (int i = 0; i < LEN2; i++) {
for (int j = 0; j < i; j++) {
aa[i][j] = aa[j][i] + bb[i][j];
}
}
dummy(a, b, c, d, e, aa, bb, cc, 0.);
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Benchmarks/TSVC/LinearDependence-flt/../tsc.inc:1019
llvm-test-suite/MultiSource/Benchmarks/TSVC/LinearDependence-dbl/../tsc.inc:1019
13
16,17
MultiSource/Benchmarks/TSVC/LinearDependence-flt/
MultiSource/Benchmarks/TSVC/LinearDependence-dbl/
for (int nl = 0; nl < 100*(ntimes/LEN2); nl++) {
for (int i = 0; i < LEN2; i++) {
for (int j = 0; j < LEN2; j++) {
aa[i][j] = aa[i][j]*cc[j][i] + bb[i][j];
}
}
dummy(a, b, c, d, e, aa, bb, cc, 0.);
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Benchmarks/TSVC/LinearDependence-flt/../tsc.inc:1076
llvm-test-suite/MultiSource/Benchmarks/TSVC/LinearDependence-dbl/../tsc.inc:1076
14
18,19
MultiSource/Benchmarks/TSVC/InductionVariable-flt/
MultiSource/Benchmarks/TSVC/InductionVariable-dbl/
for (int nl = 0; nl < 2*ntimes; nl++) {
j = -1;
for (int i = 0; i < LEN/2; i++) {
j++;
a[j] = b[i] + c[i] * d[i];
j++;
a[j] = b[i] + d[i] * e[i];
}
dummy(a, b, c, d, e, aa, bb, cc, 0.);
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Benchmarks/TSVC/InductionVariable-flt/../tsc.inc:1423
llvm-test-suite/MultiSource/Benchmarks/TSVC/InductionVariable-dbl/../tsc.inc:1423
15
20,21
MultiSource/Benchmarks/TSVC/InductionVariable-flt/
MultiSource/Benchmarks/TSVC/InductionVariable-dbl/
for (int nl = 0; nl < 2*ntimes; nl++) {
j = -1;
for (int i = 0; i < LEN/2; i++) {
k = j + 1;
a[i] = b[k] - d[i];
j = k + 1;
b[k] = a[i] + c[k];
}
dummy(a, b, c, d, e, aa, bb, cc, 1.);
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Benchmarks/TSVC/InductionVariable-flt/../tsc.inc:1456
llvm-test-suite/MultiSource/Benchmarks/TSVC/InductionVariable-dbl/../tsc.inc:1456
16
22MultiSource/Benchmarks/7zip/C/ for (i = m = 0; m < 24; m++)
{
while (p->NS2Indx[i + 3] == m + 3)
i++;
for (k = 0; k < 32; k++)
{
CPpmd_See *s = &p->See[m][k];
s->Summ = (UInt16)((2 * i + 5) << (s->Shift = PPMD_PERIOD_BITS - 4));
s->Count = 7;
}
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : [p_0] -> { : 0 <= p_0 <= 23 }
Invalid Context : [p_0] -> { : 1 = 0 }
Assumed Context : [p_0] -> { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Benchmarks/7zip/C/Ppmd8.c:389
17
23MultiSource/Benchmarks/7zip/C/for (i = 0; i < NUM_MT_CODER_THREADS_MAX; i++)
{
CMtThread *t = &p->threads[i];
t->index = i;
CMtThread_Construct(t, p);
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Benchmarks/7zip/C/MtCoder.c:253
18
24MultiSource/Benchmarks/Trimaran/enc-3des/for( i = 0; i < 32; i += 2 )
{
ctx->dsk[i ] = ctx->esk[30 - i];
ctx->dsk[i + 1] = ctx->esk[31 - i];

ctx->esk[i + 32] = ctx->dsk[62 - i];
ctx->esk[i + 33] = ctx->dsk[63 - i];

ctx->esk[i + 64] = ctx->esk[ i];
ctx->esk[i + 65] = ctx->esk[ 1 + i];

ctx->dsk[i + 64] = ctx->dsk[ i];
ctx->dsk[i + 65] = ctx->dsk[ 1 + i];
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Benchmarks/Trimaran/enc-3des/des.c:400
19
25MultiSource/Benchmarks/Trimaran/enc-3des/for( i = 0; i < 32; i += 2 )
{
ctx->dsk[i ] = ctx->esk[94 - i];
ctx->dsk[i + 1] = ctx->esk[95 - i];

ctx->esk[i + 32] = ctx->dsk[62 - i];
ctx->esk[i + 33] = ctx->dsk[63 - i];

ctx->dsk[i + 64] = ctx->esk[30 - i];
ctx->dsk[i + 65] = ctx->esk[31 - i];
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Benchmarks/Trimaran/enc-3des/des.c:427
20
26MultiSource/Benchmarks/nbench/for(i=0;i<256;i++)
{
hufftree[i].freq=(float)0.0;
hufftree[i].c=(unsigned char)i;
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Benchmarks/nbench/nbench1.c:2899
22
28MultiSource/Benchmarks/MiBench/consumer-lame/for ( i = 0; i < words; i++ )
{
thisval = *loc;
dst = (char *) loc++;
dst[0] = src[1];
dst[1] = src[0];
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : [words] -> { : -2147483648 <= words <= 2147483647 }
Invalid Context : [words] -> { : 1 = 0 }
Assumed Context : [words] -> { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Benchmarks/MiBench/consumer-lame/util.c:213
23
29MultiSource/Benchmarks/MiBench/consumer-lame/ for ( sb = 0; sb < SBPSY_l; sb++ ) {
if (thm[0].l[sb] <= 1.58*thm[1].l[sb]
&& thm[1].l[sb] <= 1.58*thm[0].l[sb]) {

mld = mld_l[sb]*en[chside].l[sb];
rmid = Max(thm[chmid].l[sb], Min(thm[chside].l[sb],mld));

mld = mld_l[sb]*en[chmid].l[sb];
rside = Max(thm[chside].l[sb],Min(thm[chmid].l[sb],mld));

thm[chmid].l[sb]=rmid;
thm[chside].l[sb]=rside;
}
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : [_] -> { : -2147483648 <= _ <= 2147483647 }
Invalid Context : [_] -> { : 1 = 0 }
Assumed Context : [_] -> { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Benchmarks/MiBench/consumer-lame/psymodel.c:813
24
30MultiSource/Benchmarks/Bullet/for(i=0,ni=m_anchors.size();i<ni;++i)
{
m_anchors[i].m_node=PTR2IDX(m_anchors[i].m_node,base);
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : [p_0_loaded_from_this] -> { : -2147483648 <= p_0_loaded_from_this <= 2147483647 }
Invalid Context : [p_0_loaded_from_this] -> { : 1 = 0 }
Assumed Context : [p_0_loaded_from_this] -> { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Benchmarks/Bullet/btSoftBody.cpp:1813
25
31,32
MultiSource/Benchmarks/mafft/for (i = 0; i < 20; i++) r[i][i] = 0.0;
if( isTM )
{
for (i = 1; i < 20; i++) for (j = 0; j < i; j++)
{
r[j][i] /= 400.0 * freq0_TM[i] * freq0_TM[j];
r[i][j] = r[j][i];
}
for( i=0; i<20; i++ ) freq[i] = freq0_TM[i];
}
else
{
for (i = 1; i < 20; i++) for (j = 0; j < i; j++)
{
r[i][j] /= 400.0 * freq0[i] * freq0[j];
r[j][i] = r[i][j];
}
for( i=0; i<20; i++ ) freq[i] = freq0[i];
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Benchmarks/mafft/JTT.c:223
26
33MultiSource/Benchmarks/mafft/for( i=0; i<100; i++ )
{
shuryo[i].i = -1;
shuryo[i].j = -1;
shuryo[i].wm = 0.0;
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/MultiSource/Benchmarks/mafft/suboptalign11.c:190
28
35SingleSource/Benchmarks/Shootout/for (i=0, j=1; i<size; ++i, ++j) {
l[i].next = &l[i+1];
l[j].prev = &l[j-1];
l[i].val = from++;
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/SingleSource/Benchmarks/Shootout/lists.c:106
29
36SingleSource/Benchmarks/Misc/for (j = 2; j < nwh; j += 2) {
x = cos(delta * j);
y = sin(delta * j);
w[j] = x;
w[j + 1] = y;
w[nw - j] = y;
w[nw - j + 1] = x;
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/SingleSource/Benchmarks/Misc/oourafft.c:206
30
37SingleSource/Regression/C/ for (i = 1; i < n; ++i) {
for (j = 0; j < i; ++j) {
fftw_real ar, ai, br, bi;

ar = rA[i * is + j * js];
ai = iA[i * is + j * js];
br = rA[j * is + i * js];
bi = iA[j * is + i * js];

rA[j * is + i * js] = ar;
iA[j * is + i * js] = ai;
rA[i * is + j * js] = br;
iA[i * is + j * js] = bi;
}
}
loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop [-Rpass-analysis=loop-vectorize]Context : { : }
Invalid Context : { : 1 = 0 }
Assumed Context : { : }
Alias Groups : 0
Polly can vectorize with VF: 2147483647
No.
remark: the cost-model indicates that vectorization is not beneficial
llvm-test-suite/SingleSource/Regression/C/matrixTranspose.c:8
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
Loading...
 
 
 
Sheet1
Statistics
More Statistics
 
 
Main menu