HASSA代码分析常例（更新）

通过大量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分析１: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];
}