四、使用 const可以限定目标优化
1、源代码：  
void fir_fxd1(short input[], short coefs[], short out[])   
{      int i, j;  
        for (i = 0; i < 40; i++)   
    {  
      for (j = 0; j < 16; j++)  
            out[i*16+j]= coefs[j] * input[i + 15 - j];  
   }  
}  
2、改编后的代码：  
void fir_fxd2(const short input[], const short coefs[], short out[])   
{  
   int i, j;  
        for (i = 0; i < 40; i++)   
    {  
      for (j = 0; j < 16; j++)  
            out[i*16+j]= coefs[j] * input[i + 15 - j];  
   }  
3、优化方法说明：  
C6000 编译器如果确定两条指令是不相关的，则安排它们并行执行。  关键字 const可以
指定一个变量或者一个变量的存储单元保持不变。这有助于帮助编译器确定指令的不相关
性。例如上例中，源代码不能并行执行，而结果改编后的代码可以并行执行。  
4、技巧：  
使用 const 可以限定目标，确定存在于循环迭代中的存储器的不相关性。  
五、 使用内联指令优化算法
1、源代码：  
void vecsum(short *sum, short *in1, short *in2, unsigned int N)   
{  
    int i;  
          for (i = 0; i < N; i++)   
        sum = in1 + in2;  
}  
2、改编后的代码：  
void vecsum6(int *sum, const int *in1, const int *in2, unsigned int N)   
{  
    int i;  
        int sz = N >> 2;   
    _nassert(N >= 20);  
        for (i = 0; i < sz; i += 2)   
    {  
        sum   = _add2(in1  , in2);  
        sum[i+1] = _add2(in1[i+1], in2[i+1]);  
    }  
}  
3、优化方法说明：  
源代码中，函数变量的定义是  short *sum, short *in1, short *in2,    改编后的代码函数变
量是  int *sum, const int *in1, const int *in2,    整数类型由 16 位改编成 32 位，这时使用内联指令“_add2”一次可以完成两组 16位整数的加法，效率提高一倍。注意这里还使用了关键字 const和内联指令_nassert优化源代码。  
4、技巧：  
用内联指令_add2、_mpyhl、_mpylh 完成两组 16 位数的加法和乘法，效率比单纯 16 位数的加法和乘法提高一倍。

六、if...else...语句的优化  
实例（一）  
1、源代码：  
        if (sub (ltpg, LTP_GAIN_THR1) <= 0)   
    {  
        adapt = 0;  
    }  
    else  
    {  
        if (sub (ltpg, LTP_GAIN_THR2) <= 0)  
        {  
            adapt = 1;  
        }  
        else  
        {              adapt = 2;  
        }  
    }  
  2、改编后的代码：  
        adapt = (ltpg>LTP_GAIN_THR1) + (ltpg>LTP_GAIN_THR2);   
   实列（二）
1、源代码：  
    if (adapt == 0)  
    {  
        if (filt>5443)  
        {  
            result = 0;  
        }  
        else  
        {  
            if (filt < 0)  
            {  
                result = 16384;  
            }  
            else  
            {  
                filt = _sshl (filt, 18)>>16; // Q15  
                result = _ssub (16384, _smpy(24660, filt)>>16);   
            }  
        }  
    }  
    else  
    {  
        result = 0;  
    }  
2、改编后的代码：  
        filt1 = _sshl (filt, 18)>>16;   
    tmp = _smpy(24660, filt1)>>16;  
        result = _ssub(16384, tmp * (filt>=0));   
        result = result * (!((adapt!=0)||(filt>5443)));  
实例（三）  
1、源代码：  
static Word16 saturate(Word32 L_var1)   
{   
  Word16 swOut;  
    if (L_var1 > SW_MAX)  
    {  
        swOut = SW_MAX;  
        giOverflow = 1;  
    }  
        else if (L_var1 < SW_MIN)   
    {  
        swOut = SW_MIN;  
        giOverflow = 1;  
    }  
    else  
        swOut = (Word16) L_var1;        /* automatic type conversion */  
    return (swOut);  
}  
2、改编后的代码：  
static inline Word32 L_shl(Word32 a,Word16 b)   
{  
return ((Word32)((b) < 0 ? (Word32)(a) >> (-(b)) : _sshl((a),(b)))) ;   
}  
3、优化方法说明：  
如果在循环中出现 if...else...语句，由于 if...else...语句中有跳转指令，而每个跳转指令有
5 个延迟间隙，因此程序执行时间延长；另外，循环内跳转也使软件流水受到阻塞。直接使
用逻辑判断语句可以去除不必要的跳转。例如在例 1 的源代码最多有两次跳转，而改编后不
存在跳转。例 2 和例 3同样也去掉了跳转。  
4、技巧：
尽可能地用逻辑判断语句替代 if...else...语句，减少跳转语句。  
七、数组最小值运算优化  
1、源程序  
    dm = 0x7FFF;  
        for (j = 0; j < nsiz[m]; j = add(j, 1))   
    {  
        if (d[j] <= dm)  
        {  
            dm = d[j];  
            jj = j;  
        }  
    }  
    index[m] = jj;  
2、优化后的程序  
        dm0 = dm1 = 0x7fff;   
            d0  = (Word16 *)&d[0];  
            d1  = (Word16 *)&d[1];  
    #pragma MUST_ITERATE(32,256,64);  
        for (j = 0; j < Nsiz; j+=2)   
    {  
        n0 = *d0;  
        d0 += 2;  
        n1 = *d1;  
        d1 += 2;  
        if (n0 <= dm0)  
        {  
            dm0 = n0;  
            jj0 = j;  
        }  
        if (n1 <= dm1)  
        {  
            dm1 = n1;  
            jj1 = j+1;  
        }  
    }  
    if (dm1 != dm0)  
    {  
        index[m] = (dm1 < dm0)? jj1:jj0;  
}      
else  
    {  
       index[m] = (jj1 > jj0)? jj1:jj0;  
    }  
  3、优化说明  
     求数组的最小值程序，优化时为了提高程序效率在一个循环之内计算 N=1,3,5..和
n=2,4,6...的最小值，然后在比较二者的大小以求得整个数组的最小值。  
八、 循环内部存在 if判断程序的优化
1、源程序  
        for (k = 0; k < NB_PULSE; k++)   
    {  
        i = codvec[k];  
        j = sign;  
        index = mult(i, Q15_1_5);  
        track = sub(i, extract_l(L_shr(L_mult(index, 5), 1)));  
        if (j > 0)  
        {  
            if (i < l_subfr) code = add(code, 4096);
             codvec[k] += (2 * L_SUBFR);  
        }  
        else  
        {  
            if (i < l_subfr) code = sub(code, 4096);  
            index = add(index, 16);  
        }  
        if (indx[track] < 0)  
        {  
            indx[track] = index;  
        }  
        else  
        {  
            if (((index ^ indx[track]) & 16) == 0)  
            {  
                if (sub(indx[track], index) <= 0)  
                {  
                    indx[track] = shl((indx[track] & 16), 3)  
                   + shr(extract_l(L_mult((indx[track]&15), NB_POS)), 1) + (index & 15);  
                }  
                else  
                {   indx[track] = shl((index & 16), 3)  
                   + shr(extract_l(L_mult((index & 15),NB_POS)), 1) + (indx[track] & 15);  
                }  
            }  
            else
            {  
                if (sub((indx[track] & 15), (index & 15)) <= 0)  
                {  
                    indx[track] = shl((index & 16), 3)  
                  + shr(extract_l(L_mult((index & 15),NB_POS)), 1) + (indx[track] & 15)
                }  
                else  
                {   indx[track] = shl((indx[track] & 16), 3)  
                    + shr(extract_l(L_mult((indx[track] & 15),NB_POS)), 1) + (index & 1
                }  
            }  
        }  
    }  
2、优化后的程序  
        for (k = 0; k < 8; k++)   
    {  
        i         = codvec[k];  
        j         = sign;  
        index           = _smpy(i, 6554)>>16;  
        track         = i - index*5;  
        con              = (j > 0);  
                codvec[k]    = codvec[k] + 110*con;  
                           index     = index + (!con)*16;  
        conn      = (i < l_subfr);  
        cono    = (j > 0)? 1:-1;  
        code  = code + 4096*conn*cono;  
                           n0   = index;  
                           t0   = indx[track];  
                           n1   = n0&16;  
                           t1   = t0&16;  
                           n2   = n0&15;  
                           t2   = t0&15;  
        tmp0    = (_sshl(n1,19)>>16) + n2*NB_POS + t2;  
        tmp1    = (_sshl(t1,19)>>16) + t2*NB_POS + n2;  
        conp    = (((n1 == t1)&&(t0 > n0))||((n1 != t1)&&(t2 <= n2)));  
                           tmp   = conp*tmp0 + (!conp)*tmp1;  
        if (t0 < 0)  
            indx[track] = n0;  
        else  
            indx[track] = tmp;  
}  
  3、优化说明  
     源程序中在循环中含有许多的 if 结构，在优化时对 if 结构首先进行化简，再将化简后的 if结构用条件运算表达式进行改写，最后使循环可以 Pipeline。  
九、 少量中值问题的优化
1、源程序  
        for (i = 0; i < n; i++)   
    {  
            max = -32767;  
            for (j = 0; j < n; j++)  
            {  
                    if (sub (tmp2[j], max) >= 0)  
                            {  
                                max = tmp2[j];  
                                ix = j;  
                    }  
                     }  
                     tmp2[ix] = -32768;  
                     tmp = ix;  
        }  

2、优化后的程序  
       if (n0>n1) {temp=n0;n0=n1;n1=temp;}  
       if (n1>n2) {temp=n1;n1=n2;n2=temp;}  
       if (n2>n3) {temp=n2;n2=n3;n3=temp;}  
       if (n3>n4) {temp=n3;n3=n4;n4=temp;}  
       if (n0>n1) {temp=n0;n0=n1;n1=temp;}  
       if (n1>n2) {temp=n1;n1=n2;n2=temp;}  
       if (n2>n3) {temp=n2;n2=n3;n3=temp;}  
       if (n0>n1) {temp=n0;n0=n1;n1=temp;}  
       if (n1>n2) {return n1;}  
3、优化说明  
     源程序也为一个求中值的问题，由于已知循环次数固定为 5，因此将循环展开使用 if语句直接求取中值。  
十、 位操作优化
1、源程序  
static Word16 Bin2int (Word16 no_of_bits,    Word16 *bitstream)   
{  
    Word16 value, i, bit;  
    value = 0;  
        for (i = 0; i < no_of_bits; i++)   
    {  
        value = shl (value, 1);  
        bit = *bitstream++;  
        if (sub (bit, BIT_1) == 0)  
        value = add (value, 1);  
    }  
    return (value);  
}  
        for (i = 0; i < prmno[mode]; i++)   
    {  
        prm = Bin2int (bitno[mode], bits);  
        bits += bitno[mode];  
    }  
2、优化后的程序  
    value = 0;  
    bitsp = bits;  
    bitnop= &bitno[mode][0];  
    j  = *bitnop++;  
    j1 = *bitnop++;  
    j2 = *bitnop++;  
    j3 = *bitnop++;  
    j4 = *bitnop++;  
    _nassert(loop[mode]>=35);  
        for (i = 0; i < loop[mode]; i++)   
    {  
        value = value*2 + *bitsp++;  
        j--;  
        if (j == 0)  
        {  
           *prm++ = value;  
           value = 0;  
           j  = j1;  
           j1 = j2;  
           j2 = j3;  
           j3 = j4;  
           j4 = *bitnop++;  
        }  
    }  
3、优化说明  
源程序按照数据位流定义取出参数，为双重循环结构，优化中采用重新根据位流的 bit
长度定义循环次数，化简为单重循环，然后优化循环，去除 boundary，使 pipeline 的数目最小。

十一、copy程序的优化  
    1、源代码：  
    Word16 i;  
        for (i = 0; i < L; i++)   
    {  
        y = x;  
    }  
     2、改编代码：  
（1）要求数组长度能被 2 整除  
    Word32  i;  
    Word32      temp;  
        int *p1 = (int *)&x[0];   
        int *q1 = (int *)&y[0];   
        for (i = 0; i < L/2; i++)   
    {  
        temp = *p1++;  
        *q1++ = temp;  
    }  
（2）要求数组长度能被 4 整除  
    Word32  i;  
    Word32      temp1, temp2;  
    Word32  *pin1, *pin2, *pout1, *pout2;  
        pin1 = (Word32 *)&x[0];   
        pin2 = (Word32 *)&x[2];   
    pout1= (Word32 *)&y[0];  
    pout2= (Word32 *)&y[2];  
        for (i = 0; i < L/4; i++)   
    {  
        temp1 = *pin1;  
        temp2 = *pin2;  
        pin1+=2;  
        pin2+=2;  
        *pout1= temp1;  
        *pout2= temp2;  
        pout1+=2;  
        pout2+=2;  
    }  
3、优化方法说明：  
把一次循  拷贝一个 word16 的数改为一次循环拷贝 2 个 word16 或4 个 word16 的数。  
4、技巧：  
充分利用 c6xx 一次读取32 位数的特性，并利用一个指令周期能读取两个数据的特点。   
十二、set_zero 程序的优化  
    1、源代码：  
    Word16 i;  
        for (i = 0; i < L; i++)   
    {  
       x = 0;  
   }  
2、改编代码：  
（1）数组长度能被 2 整除  
    Word32 i;  
        int *x1 = (int *)&x[0];   
        for (i = 0; i < L/2; i++)   
    {  
        *x1++ = 0;  
    }  
（2）数组长度能被 4 整除  
    Word32 i;  
        int *x1 = (int *)&x[0];   
        int *x2 = (int *)&x[2];   
        for (i = 0; i < L/4; i++)   
    {  
        *x1 = 0;  
        *x2 = 0;  
        x1++;  
        x2++;  
        x1++;  
        x2++;  
    }  
3、优化方法说明：  
把一次循环为一个 word16 的数赋值改为一次为 2个或 4 个 word16 的数赋值。  
4、技巧：  
充分利用C6XX一次读取32位数的特点， 并利用一个指令周期能读取两个数据的特点。   
十三、32bit数与 16bit 数相乘  
1、源代码：  
L_tmp0 = Mac_32_16(L_32, hi1, lo1, lo2);   
2、改编代码：  
L_tmp0=_sadd(_sadd(_smpyhl(hl32, lo2),   
    (_mpyus(hl32, lo2)>>16)<<1), L_32);  
3、优化方法说明：  
    hl32 是32bit 的数， hi1 和 lo1 是 16bit的数， 且  hl32 = hi1<<16 + lo1 << 1  ， 即 hi1 和 lo1分别是 hl32的高 16 位数和低 16 位数。 函数 Mac_32_16(L_32, hi1, lo1, lo2)实现  
  L_32 = L_32 + (hi1*lo2)<<1 + ((lo1*lo2)>>15)<<1  
     源代码是把一个 32 位的数拆成两个 16 位的数与一个 16 位的数相乘，优化后的代码不拆开 32 位的数，直接用 32 位的数与16 位的数相乘。运用这种方法必须保证 hl32 的最低一位数必须为 0，否则应用指令_clr(hl32, 0, 0)把最低位清零。  
4、技巧：  
     源代码中的低 16 位数 lo1 是hl32 的低16 位右移一位得到的（留出一位符号位） 。在与lo2 相乘时又右移了 15 位，所以在改编代码中右移 16 位，并且是以无符号数与 lo2 相乘。  
十四、32bit数与 32bit 数相乘  
1、源代码：  
                      L_tmp = Mac_32 (L_32, hi1, lo1, hi2, lo2);   
2、改编代码：  
L_tmp = _sadd(_sadd(_smpyh(hl1_32, hl2_32),   
     ((_mpyhslu(hl1_32, hl2_32)>>16)<<1)+((_mpyhslu(hl2_32, hl1_32)>>16)<<1)), L_32);  
3、优化方法说明：  
     两个 32位的数相乘，不必分成四个 16 位的数相乘，直接用 32 位相乘。其中：  
        hl1_32 = hi1<<16 + lo1<<1,       hl2_32 = hi2 <<16 + lo2 <<1  。  
源代码实现：  L_32 = L_32 + (hi1*hi2)<<1 + ( (hi1*lo2)>>15 + (lo1*hi2)>>15) <<1   
4、技巧：  
低 16 位与高16 位相乘时，低 16 位使用的是无符号数。  

十五、16 位除法的优化  
1、源代码：  
Word16 div_s (Word16 var1, Word16 var2) //实现  var1/var2  
{  
    Word16 var_out = 0;  
    Word16 iteration;  
    Word32 L_num = (Word32)var1;  
    Word32 L_denom = (Word32)var2;  
            for (iteration = 0; iteration < 15; iteration++)  
            {  
                var_out <<= 1;  
                L_num <<= 1;  
                if (L_num >= L_denom)  
                {  
                    L_num = L_sub (L_num, L_denom);  
                    var_out = add (var_out, 1);  
                }  
            }  
    return (var_out);  
}  

2、改编代码：  
Word16 div_s1 (Word16 var1, Word16 var2)   
{  
    Word32 var1int;  
    Word32 var2int;  
        var1int = var1 << 16;   
        var2int = var2 << 15;   
    var1int = _subc(var1int,var2int);  
    var1int = _subc(var1int,var2int);  
    var1int = _subc(var1int,var2int);  
    var1int = _subc(var1int,var2int);  
    var1int = _subc(var1int,var2int);  
    var1int = _subc(var1int,var2int);  
    var1int = _subc(var1int,var2int);  
    var1int = _subc(var1int,var2int);  
    var1int = _subc(var1int,var2int);  
    var1int = _subc(var1int,var2int);  
    var1int = _subc(var1int,var2int);  
    var1int = _subc(var1int,var2int);  
    var1int = _subc(var1int,var2int);  
    var1int = _subc(var1int,var2int);  
    var1int = _subc(var1int,var2int);  
    return (var1int & 0xffff);  
}  
3、优化方法说明：  
实现 16 位的除法，要求被除数 var1和除数 var2都是整数，且 var1<=var2。利用 C6XX特有的指令 subc，实现除法的循环移位相减操作。  
4、技巧：  
把被除数和除数都转换成 32 位数来操作，返回时取低 16 位数。
十六、C6X优化 inline 举例:  
1、原程序：  
        for (i = LO_CHAN; i <= HI_CHAN; i++)   
    {  
        norm_shift = norm_l(st->ch_noise);  
        Ltmp = L_shl(st->ch_noise, norm_shift);  
        norm_shift1 = norm_l(st->ch_enrg);  
        Ltmp3 = L_shl1(st->ch_enrg, norm_shift1 - 1);  
        Ltmp2 = L_divide(Ltmp3, Ltmp);  
                Ltmp2 = L_shr(Ltmp2, 27 - 1 + norm_shift1 - norm_shift);   
                    // * scaled as 27,4 *  
        if (Ltmp2 == 0)  
           Ltmp2 = 1;  
        Ltmp1 = fnLog10(Ltmp2);  
        Ltmp3 = L_add(Ltmp1, LOG_OFFSET - 80807124);   
                    // * --ound(log10(2^4)*2^26 *  
        Ltmp2 = L_mult(TEN_S5_10, extract_h(Ltmp3));  
        if (Ltmp2 < 0)  
            Ltmp2 = 0;  
        // * 0.1875 scaled as 10,21 *  
        Ltmp1 = L_add(Ltmp2, CONST_0_1875_S10_21);  
                // * tmp / 0.375    2.667 scaled as 5,10, Ltmp is scaled 15,16 *   
        Ltmp = L_mult(extract_h(Ltmp1), CONST_2_667_S5_10);  
        ch_snr = extract_h(Ltmp);  
    }  

2、优化后程序：  
    //因循环体太大，拆成两个循环并把相应的函数内嵌以使程序能 pipeline，  
    //用 L_div_tmp[]保存因拆分而产生的中间变量。  
        for (i = LO_CHAN; i <= HI_CHAN; i++)   

    {  
        //norm_shift = norm_l(st->ch_noise);  
        norm_shift = _norm(st->ch_noise);  
        Ltmp = _sshl(st->ch_noise, norm_shift);  
        //norm_shift1 = norm_l(st->ch_enrg);  
        norm_shift1 = _norm(st->ch_enrg);  
        //Ltmp3 = L_shl1(st->ch_enrg, norm_shift1 - 1);  
        LLtmp1 = st->ch_enrg;  
        LLtmp1 = LLtmp1 << (norm_shift1 + 7);  
        Ltmp3 = (Word32)(LLtmp1 >> 8);  
        Ltmp2 = IL_divide(Ltmp3, Ltmp);  
        //Ltmp2 = L_shr(Ltmp2, 27 - 1 + norm_shift1 - norm_shift);  
                Ltmp2 = (Ltmp2 >> (27 - 1 + norm_shift1 - norm_shift));   
        if (Ltmp2 == 0)  
            Ltmp2 = 1;  
        L_div_tmp = Ltmp2;  
    }  
        for (i = LO_CHAN; i <= HI_CHAN; i++)   
    {  
        Ltmp2 = L_div_tmp;  
        Ltmp1 = IfnLog10(Ltmp2);  
        //Ltmp3 = L_add(Ltmp1, LOG_OFFSET - 80807124);   
        Ltmp3 = _sadd(Ltmp1, LOG_OFFSET - 80807124);  
        //Ltmp2 = L_mult(TEN_S5_10, extract_h(Ltmp3));  
        Ltmp2 = _smpy(TEN_S5_10, (Ltmp3 >> 16));  
        if (Ltmp2 < 0)  
            Ltmp2 = 0;  
        Ltmp1 = _sadd(Ltmp2, CONST_0_1875_S10_21);  
        //Ltmp = L_mult(extract_h(Ltmp1), CONST_2_667_S5_10);  
        Ltmp = _smpy((Ltmp1 >> 16), CONST_2_667_S5_10);  
        //ch_snr = extract_h(Ltmp);  
        ch_snr = (Ltmp >> 16);  
    }  
3、优化说明  
     观察上面这个循环，循环体本身比较大，且含有两个函数 L_divide（）和 fnLog10（） ，而 C62 内部只有 32 个寄存器，且有些寄存器是系统用的，如 B14、B15 这样循环体太大将会导致寄存器不够分配，从而导致系统编译器无法实现循环的 pipeline。  
     为了实现循环的 pipeline。我们需要把循环体进行拆分，拆分时要考虑以下几点：  
（1） 、拆分成几个循环比较合适？在各个循环能 pipeline 的前提下，拆开的循环个数越少越好。这就要求尽可能让各个循环的运算量接近。  
（2）考虑在什么地方把程序拆开比较合适？循环体里的数据流往往并不是单一的  ，
在拆开的断点处势必要用中间变量保存上次的循环运算结果，供以后的循环用。  适当的拆开循环体，使所需的中间变量越少越好。  
     （3）循环体中的函数调用必须定义成内嵌形式，含有函数调用的循环系统是无法使之pipeline 的；各个循环体中的判断分支机构不可太多，否则系统也无法使之 pipeline，为此应近可能把可以确定下来的分支确定下来，并尽可能用内嵌指令。  
     针对上面这个例子，考虑：  
     （1）为让各个循环的运算量大致相当，应把 L_divide（）和 fnLog10（）分到两个循环中去，从循环体大小上考虑，估计拆成两个循环比较合适。  
     （2）考虑在什么地方把程序拆开比较合适？在         
if (Ltmp2 == 0)  
            Ltmp2 = 1;  
后拆开，因为后面用到的数据只有 Ltmp2，故只需用一个数组保存每次循环的 Ltmp2 值即可。  
（3） 循环体中的两处函数调用L_divide （） 和fnLog10 （） 都定义了其内嵌形式，  IL_divide（）和 IfnLog10（） 。当把可以确定下来的分支作确定处理，并尽可能用内嵌指令后，该循环体中所剩的分支结构已很少，循环体可以 pipeline。优化前程  序用 2676 cycle，优化后用400 cycle。优化后两个子循环的 MII 分别为14和 6cycle。

好有用的文章

学习一下