通过大量Benchmark集的分析,提取以下较为常见的例子。
暂时总结一般性结论:
1.加法树计算运用较为普遍
2.有较多认知错觉,以为计算密集的算法并非如此:如密码算法,财务计算模型,网页搜索,跟踪算法等
3. if-else循环运用较多
4. 循环指令并行性分析能够覆盖大多数代码分析;
有相关性的情况:迭代间自相关最多,接着迭代内相关,接着迭代间他相关
1. MachSuite.viterbi
Benchmark分析2: MachSuite.viterbi
/* 函数 viterbi */
// vi.L1
for( t=1; t<N_OBS; t++ )
{
for( curr=0; curr<N_STATES; curr++ )
{
// vi.L1.1.1
for( prev=1; prev<N_STATES; prev++ )
{
// P1
p = llike[t-1][prev] + transition[prev*N_STATES+curr] + emission[curr*N_TOKENS+obs[t]];
}
}
}
2. MachSuite.stencil.stencil2d
Benchmark分析2: MachSuite.stencil.stencil2d
/* 函数 stencil */
// st.L1
for (r=0; r<row_size-2; r++)
{
for (c=0; c<col_size-2; c++)
{
for (k1=0;k1<3;k1++)
{
// st.L1.1.1.1
for (k2=0;k2<3;k2++)
{
// P1
mul = filter[k1*3 + k2] * orig[(r+k1)*col_size + c+k2];
// P2
temp += mul;
}
}
}
}
3. Cortexsuite.pca
Benchmark分析1:Cortexsuite.pca
/* 函数1 corcol */
// co.L1
for (j1 = 1; j1 <= m-1; j1++)
{
for (j2 = j1+1; j2 <= m; j2++)
{
// co.L1.1.1
for (i = 1; i <= n; i++)
{
// P1
symmat[j1][j2] += ( data[i][j1] * data[i][j2]);
}
}
}
/* 函数2 tqli */
// tq.L1
for (l = 1; l <= n; l++)
{
do
{
if (m != l)
{
for (i = m-1; i >= l; i--)
{
// tq.L1.1.1.1.1
for (k = 1; k <= n; k++)
{
f = z[k][i+1];
// P2
z[k][i+1] = s * z[k][i] + c * f;
// P3
z[k][i] = c * z[k][i] - s * f;
}
}
}
} while (m != l);
}
/* 函数3 tred2 */
// tr.L1
for (i = 1; i <= n; i++)
{
if (d[i])
{
for (j = 1; j <= l; j++)
{
// tr.L1.1.1.1
for (k = 1; k <= l; k++)
// P4
g += a[i][k] * a[k][j];
// tr.L1.1.1.2
for (k = 1; k <= l; k++)
// P5
a[k][j] -= g * a[k][i];
}
}
}
4. MineBench.Hop
Benchmark分析[3]: MineBench.Hop
/* 函数 smBallGather */
// sBG.L1
while (1)
{
else(cp < nSplit)
{
// sBG.L1.1.1
for (pj=c[cp].pLower;pj<=c[cp].pUpper;++pj)
{
// P18
dx = sx - p[pj].r[0];
// P19
dy = sy - p[pj].r[1];
// P20
dz = sz - p[pj].r[2];
// P21
fDist2 = dx*dx + dy*dy + dz*dz;
}
}
}
5. parsec.dedup
Benchmark分析[4]: parsec.dedup
/* 函数 rabinseg */
// ra.L1
while(i<n)
{
// P1
x = p[i-NWINDOW];
// P2
h ^= rabinwintab[x];
// P3
x = h >> 24;
// P4
h <<= 8;
// P5
h |= p[i++];
// P6
h ^= rabintab[x];
}