zoukankan      html  css  js  c++  java

  • 【DSP开发】DSP程序优化

    此文是在http://blog.csdn.net/guanchanghui/article/details/1181851基础上，通过自己的学习理解修改而来。暂且算作是自己的原创吧。如有侵权，联系，立刻改转载。


    一、 c6x的编译的常用选项
    （一）c6x的编译程序为“cl6x.exe”使用的方法


    Cl6x [options] [filenames]


    Cl6x：   编译程序
    Options：  编译选项
    Filenames：  C或汇编源文件

    说明：
    编译选项是一个字母或者两个字母，对大小写不敏感。
    编译选项的前面需要有一个“－”符号。
    一个字母的选项可以合并在一起。比如“－sgq”与“－s －g －q”相同。
    两个字母的选项如果第一个字母相同也可以合并在一起。比如“－mgt”与“－mg －mt”相同。

    （二）有关优化的选项
    -mt：   表示在程序中没有使用alaising技术，这使得编译器可以进行比较好的优化。
    -o3：   对文件级别进行最强的优化，一般在编译时应该使用这个选项。但是在个别情况下使用这个选项优化程序可能会出现错误（-o2有相同现象，-o0和-o1不会出现错误）。可能是在优化循环，组织流水线的时候发生错误。如果有这种现象出现可以同时使用-g选项，程序优化就不会出现错误，但是优化效果会下降。另外可以调整程序的表达方式，可能会避免编译器发生错误。
    -pm：   在程序级别进行优化。可以将所以文件联合在一起进行优化，主要有去掉没有被调用的函数、总是常数的变量以及没有使用的函数返回值。建议由程序员自己进行这种优化工作。使用这个选项在win98下编译可能会出现找不到编译程序的情况。
    -ms0：  不使用冗余循环进行优化，减小程序的大小。一般情况下这个选项对程序大小的优化作用不明显。
    -mh[n]：去掉流水线的epilog，减小程序的大小。这个选项的作用比较明显。但是有可能出现读取地址超出有效范围的问题，所以要在数据段的开始和结尾处增加一些pading，或者在分配内存时保证数组的前面和后面一段范围内都是有效的地址。可选的参数n给出这种pading的长度字节数。

    （三）保留编译和优化信息的选项
    -k： 保留优化后生成汇编语言文件。
    -s： 汇编语言文件中加入优化信息，如果没有则加入C语言源程序作为注释。
    -mw：在汇编语言文件加入软件流水线信息。

    （四）有关调试和剖析的选项
    -g： 允许符号调试，在“out”文件中包含符号信息和行号信息，可以在c语言级别进行调试和剖析。使用联合使用－g、－mt和－o3可以保证能够进行符号调试的情况下最大限度的优化。
    -mg：允许profile优化后的程序。 在“out”文件中包含符号信息和很少的行号信息。允许在c语言的函数基本进行剖析。如果联合使用这两个选项，－g选项可能被忽略，结果与只用－mg相同。

    （五）其它类型
    -mln： 生成大内存模式的程序。
    -ml0： 缺省情况下将集合变量（数组和结构）作为far型。
    -ml1： 缺省情况下将全部函数作为far型
    -ml2： 等于-ml0加-ml1
    -ml3： 缺省情况下将全部数据和函数作为far型

    （六）建议使用的编译方式
    Cl6x －gk －mt －o3 －mw －ss  “filename”
    方式1用于程序的调试，这种方式具有比较强的优化能力，并且支持符号调试。在编译的过程中不会发生错误。由于生成的“out”文件中包含了符号信息和行号信息，所以比较大。
    Cl6x －k －mgt －o3 －mw －ss  “filename”
    方式2用于程序的剖析（profile），这种方式的优化能力几乎最强（绝大多数情况下与方式3相同），并且支持对程序进行profile。文件中只包含了符号信息和很少的行号信息，所以“out”文件比较小。
    Cl6x －k －mt －o3 －mw －ss  “filename”
    方式3用于最终的发行版本程序，可以对程序进行最强的优化，并且去掉了全部的符号和行号信息，所以“out”文件比较小。由多个文件组成的程序应该编写makefile，将编译参数放在该文件中，并在其中说明使用的编译器的版本号。

    （七）连接参数
    －heap： 指定堆的大小
    －stack： 指定栈的大小
    连接的各种选项应该统一放在“cmd”文件中



    二、 双重循环和多重循环的优化总结


            双重循环多重循环看起来比较复杂，但实际上多重循环优化方法比较简单，就在于一个字：“拆”，一旦完成这一步之后，多重循环就成为单层循环，优化就可以按照普通的单层循环来做了。
            多重循环的特点是在优化器优化时只在最内层循环中形成一个pipeline，这样循环语句就不能充分利用C6的软件流水线，而且对于内部循环的次数较少的情况，消耗在prolog(循环填充)和eplog(循环排空)上的cycle数也是不可忽视的。
    针对这种状况可以考虑将多重循环拆开形成一个单层循环，可以拆外层循环也可以拆内层循环，一般视具体情况而定。这样就可以充分利用优化器构成的Pipeline。如下例：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. void fir2(const short input[], const short coefs[], short out[])  
    2. {  
    3.     int i, j;  
    4.     int sum = 0;  
    5.     for (i = 0; i < 40; i++)  
    6.     {  
    7.         for (j = 0; j < 16; j++)  
    8.             sum += coefs[j] * input[i + 15 - j];  
    9.         out[i] = (sum >> 15);  
    10.     }  
    11. }  

            内层循环循环次数较少，运算量也不大，资源方面只占用了一个乘法器，一个cycle只使用一次乘法器，而事实上我们可以在一个cycle内使用两个乘法器，所以还可以充分利用另外的一个乘法器。因此考虑将内层循环拆开来执行，如下：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. void fir2_u(const short input[], const short coefs[], short out[])  
    2. {  
    3.     int i, j;  
    4.     int sum;  
    5.     for (i = 0; i < 40; i++)  
    6.     {  
    7.         sum = coefs[0] * input[i + 15];  
    8.         sum += coefs[1] * input[i + 14];  
    9.         sum += coefs[2] * input[i + 13];  
    10.         sum += coefs[3] * input[i + 12];  
    11.         sum += coefs[4] * input[i + 11];  
    12.         sum += coefs[5] * input[i + 10];  
    13.         sum += coefs[6] * input[i + 9];  
    14.         sum += coefs[7] * input[i + 8];  
    15.         sum += coefs[8] * input[i + 7];  
    16.         sum += coefs[9] * input[i + 6];  
    17.             sum += coefs[10] * input[i + 5];  
    18.         sum += coefs[11] * input[i + 4];  
    19.             sum += coefs[12] * input[i + 3];  
    20.             sum += coefs[13] * input[i + 2];  
    21.         sum += coefs[14] * input[i + 1];  
    22.         sum += coefs[15] * input[i + 0];  
    23.         out[i] = (sum >> 15);  
    24.     }  
    25. }  
            这样虽然代码长度增加了，可变成了单循环，所有的运算都参加到pipeline中来，在Piped loop kernal中产生每一个cycle内都使用了两个乘法器，充分利用了DSP内部的资源，提高了运行效率。又如下例：
    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. tot = 4;  
    2. for (k = 0; k < 4; k++)  
    3. {  
    4.     max = 0;  
    5.     for (i = k; i < 44; i += STEP)  
    6.     {  
    7.         s = 0;  
    8.         for (j = i; j < 44; j++)  
    9.             s = L_mac(s, x[j], h[j - i]);//乘加运算相当于_add(s,_mpy(x[j],h[j-i]))  
    10.         y32[i] = s;  
    11.         s = L_abs(s);  
    12.         if (L_sub(s, max) >(Word32) 0)  
    13.             max = s;  
    14.     }  
    15.     tot = L_add(tot, L_shr(max, 1));  
    16. }  
            在这个多层循环中一共有三层循环，而最内层的循环的运算量很小，只有一次乘累加操作，而我们知道C6中一个packet中可以做两个乘累加运算，所以为了增加内部循环的运算，减少外部循环的层数，我们可以将第一层循环的操作拆开，其负责的运算加入到内部循环中，也就是在内层循环中一次做四次的乘累加运算，这样将多次操作形成pipeline，提高了运行效率，优化后的C代码如下：
    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. tot = 4;  
    2. max0 = 0;  
    3. max1 = 0;  
    4. max2 = 0;  
    5. max3 = 0;  
    6. for (i = 0; i < 44; i += STEP) //STEP=4, 11 times cirs  
    7. {  
    8.     //code  
    9.     for (j = 0; j <= 40 - i; j++)  
    10.     {  
    11.         s0 = (Word32)(_sadd(s0, _smpy(hh[j], xx[j + i])));  
    12.         s1 = (Word32)(_sadd(s1, _smpy(hh[j], xx[j + i + 1])));  
    13.         s2 = (Word32)(_sadd(s2, _smpy(hh[j], xx[j + i + 2])));  
    14.         s3 = (Word32)(_sadd(s3, _smpy(hh[j], xx[j + i + 3])));  
    15.         }  
    16. }  
    17. //code  



    CCS的优化：
    三、16位变为32位操作，使用intrinsic函数，用const等。

     1、源代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. Word32 L_mpy_ll(Word32 L_var1, Word32 L_var2)  
    2. {  
    3.     double aReg;  
    4.     Word32 lvar;  
    5.     /* (unsigned)low1 * (unsigned)low1 */  
    6.     aReg = (double)(0xffff & L_var1) * (double)(0xffff & L_var2) * 2.0;  
    7.     /* >> 16 */  
    8.     aReg = (aReg / 65536);  
    9.     aReg = floor(aReg);  
    10.     /* (unsigned)low1 * (signed)high2 */  
    11.     aReg += (double)(0xffff & L_var1) * ((double)L_shr(L_var2, 16)) * 2.0;  
    12.     /* (unsigned)low2 * (signed)high1 */  
    13.     aReg += (double)(0xffff & L_var2) * ((double)L_shr(L_var1, 16)) * 2.0;  
    14.     /* >> 16 */  
    15.     aReg = (aReg / 65536);  
    16.     aReg = floor(aReg);  
    17.     /* (signed)high1 * (signed)high2 */  
    18.     aReg += (double)(L_shr(L_var1, 16)) * (double)(L_shr(L_var2, 16)) * 2.0;  
    19.     /* saturate result.. */  
    20.     lvar = L_saturate(aReg);  
    21.     return(lvar);  
    22. }  
    2、改编后的代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. static inline Word32 L_mpy_ll(Word32 L_var1, Word32 L_var2)  
    2. {  
    3.     Word32 aReg_hh;  
    4.     Word40 aReg, aReg_ll, aReg_lh, aReg_hl;  
    5.   
    6.     aReg_ll = (Word40)_mpyu(L_var1, L_var2) >> 16;  
    7.     aReg_lh = (Word40)_mpyluhs(L_var1, L_var2);  
    8.     aReg_hl = (Word40)_mpyhslu(L_var1, L_var2);  
    9.     aReg_hh = _smpyh(L_var1, L_var2);  
    10.     aReg = _lsadd(aReg_ll, _lsadd(aReg_lh, aReg_hl));  
    11.     aReg = _lsadd(aReg >> 15, aReg_hh);  
    12.   
    13.     return(_sat(aReg));  
    14. }  
    3、优化方法说明：

            C6000编译器提供的intrinsic 可快速优化C代码，intrinsic用前下划线表示同调用函数一样可以调用它，即直接内联为C6000的函数。
            例如，在上例的源代码中没有使用intrinsics，每一行C代码需多个指令周期，在改编后的代码中，每一行代码仅需一个指令周期。
            例如，“aReg_ll = (Word40)_mpyu(L_var1, L_var2) >> 16”中“_mpyu”就是一个intrinsics函数，它表示两个无符号数的高16位相乘，结果返回。C6000支持的所有intrinsics指令及其功能参见《TMS320C6000系列DSP的原理与应用》一书的第265、266页，该书还提供了另外的例子。这些内联函数定义在CCS所在的C6000 / CGTOOLS / Include目录下的C6X.h文件中。
    下面这个例子是C6000的“Programmer's Guide”上提取的使用intrinsics优化C代码的例子。

    源代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. int dotprod(const short *a, const short *b, unsigned int N)  
    2. {  
    3.     int i, sum = 0;  
    4.   
    5.     for (i = 0; i < N; i++)  
    6.         sum += a[i] * b[i];  
    7.     return sum;  
    8. }  
    改编后代码：
    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. int dotprod(const int *a, const int *b, unsigned int N)  
    2. {  
    3.     int i, sum1 = 0, sum2 = 0;  
    4.   
    5.     for (i = 0; i < (N >> 1); i++)  
    6.     {  
    7.         sum1 += _mpy(a[i], b[i]);  
    8.         sum2 += _mpyh(a[i], b[i]);  
    9.     }  
    10.     return sum1 + sum2;  
    11. }  
    技巧：
    在C语言的调试全部通过以后，可以尝试将尽可能多的语句使用intrinsics函数加以改编，尤其在循环体内，这种改编可以大幅度减少执行时间。

    四、

    1、源代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. void fir_fxd1(short input[], short coefs[], short out[])  
    2. {  
    3.     int i, j;  
    4.     for (i = 0; i < 40; i++)  
    5.     {  
    6.         for (j = 0; j < 16; j++)  
    7.             out[i * 16 + j] = coefs[j] * input[i + 15 - j];  
    8.     }  
    9. }  
    2、改编后的代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. void fir_fxd2(const short input[], const short coefs[], short out[])  
    2. {  
    3.     int i, j;  
    4.     for (i = 0; i < 40; i++)  
    5.     {  
    6.         for (j = 0; j < 16; j++)  
    7.             out[i * 16 + j] = coefs[j] * input[i + 15 - j];  
    8.     }  
    9. }  
    3、优化方法说明：

            C6000编译器如果确定两条指令是不相关的，则安排它们并行执行。 关键字const可以指定一个变量或者一个变量的存储单元保持不变。这有助于帮助编译器确定指令的不相关性。例如上例中，源代码不能并行执行，而结果改编后的代码可以并行执行。

    技巧：
    使用const可以限定目标，确定存在于循环迭代中的存储器的不相关性。


    五、

    1、源代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. void vecsum(short *sum, short *in1, short *in2, unsigned int N)  
    2. {  
    3.     int i;  
    4.   
    5.     for (i = 0; i < N; i++)  
    6.         sum[i] = in1[i] + in2[i];  
    7. }  

    2、改编后的代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. void vecsum6(int *sum, const int *in1, const int *in2, unsigned int N)  
    2. {  
    3.     int i;  
    4.     int sz = N >> 2;//用int型读取short数据，循环次数减半  
    5.   
    6.     _nassert(N >= 20);  
    7.   
    8.     for (i = 0; i < sz; i += 2)//循环展开i每次加2  
    9.     {  
    10.         sum[i] = _add2(in1[i], in2[i]);  
    11.         sum[i + 1] = _add2(in1[i + 1], in2[i + 1]);  
    12.     }  
    13. }  
    3、优化方法说明：
    源代码中，函数变量的定义是 short *sum, short *in1, short *in2, 改编后的代码函数变量是int *sum, const int *in1, const int *in2, 整数类型由16位改编成32位，这时使用内联指令“_add2”一次可以完成两组16位整数的加法，效率提高一倍。注意这里还使用了关键字const和内联指令_nassert优化源代码。

    技巧：
    用内联指令_add2、_mpyhl、_mpylh完成两组16位数的加法和乘法，效率比单纯16位数的加法和乘法提高一倍。

    六、if...else...语句的优化
    （一）

    1、源代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. if (sub(ltpg, LTP_GAIN_THR1) <= 0)//ltpg<LTP_GAIN_THR1时进入，如果ltpg>LTP_GAIN_THR1，则adapt=1  
    2. {  
    3.     adapt = 0;  
    4. }  
    5. else  
    6. {  
    7.     if (sub(ltpg, LTP_GAIN_THR2) <= 0)  
    8.     {  
    9.                     adapt = 1;  
    10.     }  
    11. }  
    12. else  
    13. {  
    14.     adapt = 2;  
    15. }  
    2、改编后的代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. adapt = (ltpg > LTP_GAIN_THR1) + (ltpg > LTP_GAIN_THR2);  
    （二）
    1、源代码：
    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. if (adapt == 0)  
    2. {  
    3.     if (filt > 5443)  
    4.     {  
    5.         result = 0;  
    6.     }  
    7.     else  
    8.     {  
    9.         if (filt < 0)  
    10.         {  
    11.             result = 16384;  
    12.         }  
    13.         else  
    14.         {  
    15.             filt = _sshl(filt, 18) >> 16; // Q15  
    16.             result = _ssub(16384, _smpy(24660, filt) >> 16);  
    17.         }  
    18.     }  
    19. }  
    20. else  
    21. {  
    22.     result = 0;  
    23. }  
    2、改编后的代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. filt1 = _sshl(filt, 18) >> 16;  
    2. tmp = _smpy(24660, filt1) >> 16;  
    3. result = _ssub(16384, tmp * (filt >= 0));//filt<0则result = 16384;  
    4. result = result * (!((adapt != 0) || (filt > 5443)));//最巧妙的是，将if...else...融入表达式，adapt!=0和filt>5443任意一个条件成立result就等于0  

    （三）

    1、源代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. static Word16 saturate(Word32 L_var1)  
    2. {  
    3.     Word16 swOut;  
    4.   
    5.     if (L_var1 > SW_MAX)  
    6.     {  
    7.         swOut = SW_MAX;  
    8.         giOverflow = 1;  
    9.     }  
    10.     else if (L_var1 < SW_MIN)  
    11.     {  
    12.         swOut = SW_MIN;  
    13.         giOverflow = 1;  
    14.     }  
    15.     else  
    16.         swOut = (Word16)L_var1;    /* automatic type conversion */  
    17.     return (swOut);  
    18. }  
    2、改编后的代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. static inline Word32 L_shl(Word32 a, Word16 b)  
    2. {  
    3.     return ((Word32)((b) < 0 ? (Word32)(a) >> (-(b)) : _sshl((a), (b))));  
    4. }  
    3、优化方法说明：
            如果在循环中出现if...else...语句，由于if...else...语句中有跳转指令，而每个跳转指令有5个延迟间隙，因此程序执行时间延长；另外，循环内跳转也使软件流水受到阻塞。直接使用逻辑判断语句可以去除不必要的跳转。例如在例1的源代码最多有两次跳转，而改编后不存在跳转。例2和例3同样也去掉了跳转。

    技巧：
            尽可能地用逻辑判断语句替代if...else...语句，减少跳转语句。


    七、
    1、源程序

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. dm = 0x7FFF;  
    2. for (j = 0; j < nsiz[m]; j = add(j, 1))//求每组数据的最小值，并把每组最小值的位置索引记录在index[m]中  
    3. {  
    4.     if (d[j] <= dm)  
    5.     {  
    6.         dm = d[j];  
    7.         jj = j;  
    8.     }  
    9. }  
    10. index[m] = jj;  
    2、优化后的程序

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. dm0 = dm1 = 0x7fff;  
    2. d0 = (Word16 *)&d[0];  
    3. d1 = (Word16 *)&d[1];  
    4. # pragma MUST_ITERATE(32,256,64);  
    5. for (j = 0; j < Nsiz; j += 2)  
    6. {  
    7.     n0 = *d0;  
    8.     d0 += 2;  
    9.     n1 = *d1;  
    10.     d1 += 2;  
    11.     if (n0 <= dm0)  
    12.     {  
    13.         dm0 = n0;  
    14.         jj0 = j;  
    15.     }  
    16.     if (n1 <= dm1)  
    17.     {  
    18.         dm1 = n1;  
    19.         jj1 = j + 1;  
    20.     }  
    21. }  
    22. if (dm1 != dm0)  
    23. {  
    24.     index[m] = (dm1 < dm0) ? jj1 : jj0;  
    25. }  
    26. else  
    27. {  
    28.     index[m] = (jj1 > jj0) ? jj1 : jj0;  
    29. }  
    3、优化说明
            求数组的最小值程序，优化时为了提高程序效率在一个循环之内计算N = 1, 3, 5..和n = 2, 4, 6...的最小值，然后在比较二者的大小以求得整个数组的最小值。


    八、
    1、源程序

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. for (k = 0; k < NB_PULSE; k++)  
    2. {  
    3.     i = codvec[k];  
    4.     j = sign[i];  
    5.     index = mult(i, Q15_1_5);  
    6.     track = sub(i, extract_l(L_shr(L_mult(index, 5), 1)));  
    7.     if (j > 0)  
    8.     {  
    9.         if (i < l_subfr) code[i] = add(code[i], 4096);  
    10.         codvec[k] += (2 * L_SUBFR);  
    11.     }  
    12.     else  
    13.     {  
    14.         if (i < l_subfr) code[i] = sub(code[i], 4096);  
    15.         index = add(index, 16);  
    16.     }  
    17.     if (indx[track] < 0)  
    18.     {  
    19.         indx[track] = index;  
    20.     }  
    21.     else  
    22.     {  
    23.         if (((index ^ indx[track]) & 16) == 0)  
    24.         {  
    25.             if (sub(indx[track], index) <= 0)  
    26.             {  
    27.                 indx[track] = shl((indx[track] & 16), 3)  
    28.                     + shr(extract_l(L_mult((indx[track] & 15), NB_POS)), 1) + (index & 15);  
    29.             }  
    30.             else  
    31.             {  
    32.                 indx[track] = shl((index & 16), 3)  
    33.                     + shr(extract_l(L_mult((index & 15), NB_POS)), 1) + (indx[track] & 15);  
    34.             }  
    35.         }  
    36.         else  
    37.     }  
    38.     if (sub((indx[track] & 15), (index & 15)) <= 0)  
    39.     {  
    40.         indx[track] = shl((index & 16), 3)  
    41.             + shr(extract_l(L_mult((index & 15), NB_POS)), 1) + (indx[track] & 15);  
    42.     }  
    43.     else  
    44.     {  
    45.         indx[track] = shl((indx[track] & 16), 3)  
    46.             + shr(extract_l(L_mult((indx[track] & 15), NB_POS)), 1) + (index & 15);  
    47.     }  
    48. }  
    2、优化后的程序
    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. for (k = 0; k < 8; k++)  
    2. {  
    3.     i = codvec[k];  
    4.     j = sign[i];  
    5.     index = _smpy(i, 6554) >> 16;  
    6.     track = i - index * 5;  
    7.     con = (j > 0);  
    8.     codvec[k] = codvec[k] + 110 * con;  
    9.     index = index + (!con) * 16;  
    10.     conn = (i < l_subfr);  
    11.     cono = (j > 0) ? 1 : -1;  
    12.     code[i] = code[i] + 4096 * conn*cono;  
    13.     n0 = index;  
    14.     t0 = indx[track];  
    15.     n1 = n0 & 16;  
    16.     t1 = t0 & 16;  
    17.     n2 = n0 & 15;  
    18.     t2 = t0 & 15;  
    19.     tmp0 = (_sshl(n1, 19) >> 16) + n2*NB_POS + t2;  
    20.     tmp1 = (_sshl(t1, 19) >> 16) + t2*NB_POS + n2;  
    21.     conp = (((n1 == t1) && (t0 > n0)) || ((n1 != t1) && (t2 <= n2)));  
    22.     tmp = conp*tmp0 + (!conp)*tmp1;  
    23.     if (t0 < 0)  
    24.         indx[track] = n0;  
    25.     else  
    26.         indx[track] = tmp;  
    27. }  
    3、优化说明
            源程序中在循环中含有许多的if结构，在优化时对if结构首先进行化简，再将化简后的if结构用条件运算表达式进行改写，最后使循环可以Pipeline。



    九、
    1、源程序

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. for (i = 0; i < n; i++)  
    2. {  
    3.     max = -32767;  
    4.     for (j = 0; j < n; j++)  
    5.     {  
    6.         if (sub(tmp2[j], max) >= 0)  
    7.         {  
    8.             max = tmp2[j];  
    9.             ix = j;  
    10.         }  
    11.     }  
    12.     tmp2[ix] = -32768;  
    13.     tmp[i] = ix;  
    14. }  
    2、优化后的程序

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. if (n0>n1) {temp=n0;n0=n1;n1=temp;}  
    2. if (n1>n2) {temp=n1;n1=n2;n2=temp;}  
    3. if (n2>n3) {temp=n2;n2=n3;n3=temp;}  
    4. if (n3>n4) {temp=n3;n3=n4;n4=temp;}  
    5. if (n0>n1) {temp=n0;n0=n1;n1=temp;}  
    6. if (n1>n2) {temp=n1;n1=n2;n2=temp;}  
    7. if (n2>n3) {temp=n2;n2=n3;n3=temp;}  
    8. if (n0>n1) {temp=n0;n0=n1;n1=temp;}  
    9. if (n1>n2) {return n1;}  
    3、优化说明
            源程序也为一个求中值的问题，由于已知循环次数固定为5，因此将循环展开使用if语句直接求取中值。


    十、
    1、源程序

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. static Word16 Bin2int(Word16 no_of_bits, Word16 *bitstream)  
    2. {  
    3.     Word16 value, i, bit;  
    4.   
    5.     value = 0;  
    6.     for (i = 0; i < no_of_bits; i++)  
    7.     {  
    8.         value = shl(value, 1);  
    9.         bit = *bitstream++;  
    10.         if (sub(bit, BIT_1) == 0)  
    11.             value = add(value, 1);  
    12.     }  
    13.     return (value);  
    14. }  
    15.   
    16. for (i = 0; i < prmno[mode]; i++)  
    17. {  
    18.     prm[i] = Bin2int(bitno[mode][i], bits);  
    19.     bits += bitno[mode][i];  
    20. }  
    2、优化后的程序

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. value = 0;  
    2. bitsp = bits;  
    3. bitnop= &bitno[mode][0];  
    4. j = *bitnop++;  
    5. j1 = *bitnop++;  
    6. j2 = *bitnop++;  
    7. j3 = *bitnop++;  
    8. j4 = *bitnop++;  
    9. _nassert(loop[mode]>=35);  
    10. for (i = 0; i < loop[mode]; i++)  
    11. {  
    12.     value = value * 2 + *bitsp++;  
    13.     j--;  
    14.     if (j == 0)  
    15.     {  
    16.         *prm++ = value;  
    17.         value = 0;  
    18.         j = j1;  
    19.         j1 = j2;  
    20.         j2 = j3;  
    21.         j3 = j4;  
    22.         j4 = *bitnop++;  
    23.     }  
    24. }  
    3、优化说明
            源程序按照数据位流定义取出参数，为双重循环结构，优化中采用重新根据位流的bit长度定义循环次数，化简为单重循环，然后优化循环，去除boundary，使pipeline的数目最小。


    十一、copy程序的优化
    1、源代码：
    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. Word16 i;  
    2. for (i = 0; i < L; i++)  
    3. {  
    4.     y[i] = x[i];  
    5. }  
    2、改编代码：
    （1）要求数组长度能被2整除
    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. Word32  i;  
    2. Word32   temp;  
    3. int *p1 = (int *)&x[0];  
    4. int *q1 = (int *)&y[0];  
    5. for (i = 0; i < L / 2; i++)  
    6. {  
    7.     temp = *p1++;  
    8.     *q1++ = temp;  
    9. }  
    （2）要求数组长度能被4整除

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. Word32  i;  
    2. Word32   temp1, temp2;  
    3. Word32   *pin1, *pin2, *pout1, *pout2;  
    4. pin1 = (Word32 *)&x[0];  
    5. pin2 = (Word32 *)&x[2];  
    6. pout1= (Word32 *)&y[0];  
    7. pout2= (Word32 *)&y[2];  
    8. for (i = 0; i < L / 4; i++)  
    9. {  
    10.     temp1 = *pin1;  
    11.     temp2 = *pin2;  
    12.     pin1 += 2;  
    13.     pin2 += 2;  
    14.     *pout1 = temp1;  
    15.     *pout2 = temp2;  
    16.     pout1 += 2;  
    17.     pout2 += 2;  
    18. }  
    3、优化方法说明：
            把一次循环拷贝一个word16的数改为一次循环拷贝2个word16或4个word16的数。
    技巧：
            充分利用c6xx一次读取32位数的特性，并利用一个指令周期能读取两个数据的特点。


    十二、set_zero程序的优化
    1、源代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. Word16 i;  
    2. for (i = 0; i < L; i++)  
    3. {  
    4.     x[i] = 0;  
    5. }  
      2、改编代码：
    （1）数组长度能被2整除

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. Word32 i;  
    2. int *x1 = (int *)&x[0];  
    3. for (i = 0; i < L / 2; i++)  
    4. {  
    5.     *x1++ = 0;  
    6. }  
    （2）数组长度能被4整除

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. Word32 i;  
    2. int *x1 = (int *)&x[0];  
    3. int *x2 = (int *)&x[2];  
    4. for (i = 0; i < L / 4; i++)  
    5. {  
    6.     *x1 = 0;  
    7.     *x2 = 0;  
    8.     x1++;  
    9.     x2++;  
    10.     x1++;  
    11.     x2++;  
    12. }  
    3、优化方法说明：
            把一次循环为一个word16的数赋值改为一次为2个或4个word16的数赋值。

    技巧：
            充分利用C6XX一次读取32位数的特点，并利用一个指令周期能读取两个数据的特点。


    十三、32bit数与16bit数相乘
    1、源代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. L_tmp0 = Mac_32_16(L_32, hi1, lo1, lo2);  

    2、改编代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. L_tmp0 = _sadd(_sadd(_smpyhl(hl32, lo2),(_mpyus(hl32, lo2) >> 16) << 1), L_32);  
    3、优化方法说明：
            hl32是32bit的数，hi1和lo1是16bit的数，且 hl32 = hi 1<<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)把最低位清零。

    技巧：
           源代码中的低16位数lo1是hl32的低16位右移一位得到的（留出一位符号位）。在与lo2相乘时又右移了15位，所以在改编代码中右移16位，并且是以无符号数与lo2相乘。


    十四、32bit数与32bit数相乘
    1、源代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. L_tmp = Mac_32 (L_32, hi1, lo1, hi2, lo2);  

    2、改编代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. L_tmp = _sadd(_sadd(_smpyh(hl1_32, hl2_32),  
    2. ((_mpyhslu(hl1_32, hl2_32) >> 16) << 1) +  
    3. ((_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

    技巧：
            低16位与高16位相乘时，低16位使用的是无符号数。


    十五、16位除法的优化
    1、源代码：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. Word16 div_s(Word16 var1, Word16 var2)  //实现 var1/var2  
    2. {  
    3.     Word16 var_out = 0;  
    4.     Word16 iteration;  
    5.     Word32 L_num = (Word32)var1;  
    6.     Word32 L_denom = (Word32)var2;  
    7.     for (iteration = 0; iteration < 15; iteration++)  
    8.     {  
    9.         var_out <<= 1;  
    10.         L_num <<= 1;  
    11.         if (L_num >= L_denom)  
    12.         {  
    13.             L_num = L_sub(L_num, L_denom);  
    14.             var_out = add(var_out, 1);  
    15.         }  
    16.     }  
    17.     return (var_out);  
    18. }  
    2、改编代码：
    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. Word16 div_s1(Word16 var1, Word16 var2)  
    2. {  
    3.     Word32 var1int;  
    4.     Word32 var2int;  
    5.     var1int = var1 << 16;  
    6.     var2int = var2 << 15;  
    7.     var1int = _subc(var1int, var2int);  
    8.     var1int = _subc(var1int, var2int);  
    9.     var1int = _subc(var1int, var2int);  
    10.     var1int = _subc(var1int, var2int);  
    11.     var1int = _subc(var1int, var2int);  
    12.     var1int = _subc(var1int, var2int);  
    13.     var1int = _subc(var1int, var2int);  
    14.     var1int = _subc(var1int, var2int);  
    15.     var1int = _subc(var1int, var2int);  
    16.     var1int = _subc(var1int, var2int);  
    17.     var1int = _subc(var1int, var2int);  
    18.     var1int = _subc(var1int, var2int);  
    19.     var1int = _subc(var1int, var2int);  
    20.     var1int = _subc(var1int, var2int);  
    21.     var1int = _subc(var1int, var2int);  
    22.     return (var1int & 0xffff);  
    23. }  
    3、优化方法说明：
            实现16位的除法，要求被除数var1和除数var2都是整数，且var1<=var2。利用C6XX特有的指令subc，实现除法的循环移位相减操作。

    技巧：
            把被除数和除数都转换成32位数来操作，返回时取低16位数。


    十六、C6X优化inline举例:
    1、源程序：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. for (i = LO_CHAN; i <= HI_CHAN; i++)  
    2. {  
    3.   
    4.     norm_shift = norm_l(st->ch_noise[i]);  
    5.     Ltmp = L_shl(st->ch_noise[i], norm_shift);  
    6.   
    7.     norm_shift1 = norm_l(st->ch_enrg[i]);  
    8.     Ltmp3 = L_shl1(st->ch_enrg[i], norm_shift1 - 1);  
    9.   
    10.     Ltmp2 = L_divide(Ltmp3, Ltmp);  
    11.     Ltmp2 = L_shr(Ltmp2, 27 - 1 + norm_shift1 - norm_shift);  // * scaled as 27,4 *  
    12.   
    13.     if (Ltmp2 == 0)  
    14.         Ltmp2 = 1;  
    15.   
    16.     Ltmp1 = fnLog10(Ltmp2);  
    17.     Ltmp3 = L_add(Ltmp1, LOG_OFFSET - 80807124);  // * -round(log10(2^4)*2^26 *  
    18.     Ltmp2 = L_mult(TEN_S5_10, extract_h(Ltmp3));  
    19.     if (Ltmp2 < 0)  
    20.         Ltmp2 = 0;  
    21.     // * 0.1875 scaled as 10,21 *  
    22.     Ltmp1 = L_add(Ltmp2, CONST_0_1875_S10_21);  
    23.     // * tmp / 0.375 2.667 scaled as 5,10, Ltmp is scaled 15,16 *  
    24.     Ltmp = L_mult(extract_h(Ltmp1), CONST_2_667_S5_10);  
    25.     ch_snr[i] = extract_h(Ltmp);  
    26. }  
    2、优化后程序：

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. //因循环体太大，拆成两个循环并把相应的函数内嵌以使程序能pipeline，  
    2. //用L_div_tmp[]保存因拆分而产生的中间变量。  
    3. for (i = LO_CHAN; i <= HI_CHAN; i++)  
    4. {  
    5.     //norm_shift = norm_l(st->ch_noise[i]);  
    6.     norm_shift = _norm(st->ch_noise[i]);  
    7.     Ltmp = _sshl(st->ch_noise[i], norm_shift);  
    8.   
    9.     //norm_shift1 = norm_l(st->ch_enrg[i]);    
    10.     norm_shift1 = _norm(st->ch_enrg[i]);  
    11.     //Ltmp3 = L_shl1(st->ch_enrg[i], norm_shift1 - 1);  
    12.     LLtmp1 = st->ch_enrg[i];  
    13.     LLtmp1 = LLtmp1 << (norm_shift1 + 7);  
    14.     Ltmp3 = (Word32)(LLtmp1 >> 8);  
    15.   
    16.     Ltmp2 = IL_divide(Ltmp3, Ltmp);  
    17.     //Ltmp2 = L_shr(Ltmp2, 27 - 1 + norm_shift1 - norm_shift);    
    18.     Ltmp2 = (Ltmp2 >> (27 - 1 + norm_shift1 - norm_shift));  
    19.   
    20.     if (Ltmp2 == 0)  
    21.         Ltmp2 = 1;  
    22.     L_div_tmp[i] = Ltmp2;  
    23. }  
    24. for (i = LO_CHAN; i <= HI_CHAN; i++)  
    25. {  
    26.     Ltmp2 = L_div_tmp[i];  
    27.     Ltmp1 = IfnLog10(Ltmp2);  
    28.     //Ltmp3 = L_add(Ltmp1, LOG_OFFSET - 80807124);    
    29.     Ltmp3 = _sadd(Ltmp1, LOG_OFFSET - 80807124);  
    30.     //Ltmp2 = L_mult(TEN_S5_10, extract_h(Ltmp3));  
    31.     Ltmp2 = _smpy(TEN_S5_10, (Ltmp3 >> 16));  
    32.     if (Ltmp2 < 0)  
    33.         Ltmp2 = 0;  
    34.   
    35.     Ltmp1 = _sadd(Ltmp2, CONST_0_1875_S10_21);  
    36.   
    37.     //Ltmp = L_mult(extract_h(Ltmp1), CONST_2_667_S5_10);  
    38.     Ltmp = _smpy((Ltmp1 >> 16), CONST_2_667_S5_10);  
    39.     //ch_snr[i] = extract_h(Ltmp);  
    40.     ch_snr[i] = (Ltmp >> 16);  
    41. }  
    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_divid()和IfnLog10()。当把可以确定下来的分支作确定处理，并尽可能用内嵌指令后，该循环体中所剩的分支结构已很少，循环体可以pipeline。
      优化前程序用2676 cycle，优化后用400 cycle。优化后两个子循环的MII分别为14和6cycle。


    内存地址形式： 奔腾，C6000都是32位计算机，字长32，但内存地址都是按字节组织的 一个字4字节（查看内存时候各个字
    时候:例如两个连续字ox1000 ox1004) 写汇编程序时候,下一个字也需要+4,但写 C语言时候,int 型,+1就是加4但是,在Tiger SHARC中,虽然也是32位机,但内存是地址是按字组织的,查看内存时,连续的字地址相差1

    //////////////////////////////////////////////////////////////////////////////////自己写的一段性能很高的代码///////////////////////////

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. #include <stdio.h>  
    2. #define INTRINSIC  
    3. short add(short var1, short var2)  
    4. {  
    5.     short var_out;  
    6.     int L_somme;  
    7.     L_somme = (int)var1 + var2;  
    8.     return(var_out);  
    9. }  
    10.    
    11. int main()  
    12. {  
    13.     int i, result;  
    14. #ifdef INTRINSIC  
    15.     for (i = 0; i<1000; i++)  
    16.     {  
    17.         result = _sadd(100000, 20);  
    18.         result>0X00007fff ? result = 0x7fff : (result < 0x8000 ? result = 0x8000 : 0);  
    19.     }  
    20. #else  
    21.     for (i = 0; i < 1000; i++)  
    22.         add(10, 20);  
    23. #endif  
    24.     return 0;  
    25. }  
  • 相关阅读:
    Spring Boot应用程序属性
    Spring Boot Bean和依赖注入
    Spring Boot构建系统
    Spring Boot Tomcat部署
    Spring Boot引导过程
    Spring Boot快速入门
    Spring Boot简介
    eclipse中将项目打包成jar的两种方法，及其问题与解决方法
    配置Zuul代理下游的认证
    WireMock和Spring MVC模拟器
  • 原文地址：https://www.cnblogs.com/huty/p/8518667.html
Copyright © 2011-2022 走看看