老古开发网首页
导航:老古开发网首页→文章索引→文章分类→DSP数字信号处理→[C6000软件优化经验总结(4)]
| -文章搜索 - 最新文章 - |

C6000软件优化经验总结(4)
发布时间:2006年7月29日 点击次数:973
来源:无忧电子开发网   作者:
 

       十一、copy程序的优化

        1、源代码：

    Word16 i;

    for (i = 0; i < L; i++)

    {

        y[i] = x[i];

    }

        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[i] = 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 = 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)把最低位清零。

       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[i]);

  Ltmp = L_shl(st->ch_noise[i], norm_shift);

 

  norm_shift1 = norm_l(st->ch_enrg[i]);

  Ltmp3 = L_shl1(st->ch_enrg[i], 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); // * -round(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[i] = extract_h(Ltmp);

 }

 */

       2、优化后程序：

 //因循环体太大,拆成两个循环并把相应的函数内嵌以使程序能pipeline,

 //用L_div_tmp[]保存因拆分而产生的中间变量。

 for (i = LO_CHAN; i <= HI_CHAN; i++)

 {

  //norm_shift = norm_l(st->ch_noise[i]);

  norm_shift = _norm(st->ch_noise[i]);

  Ltmp = _sshl(st->ch_noise[i], norm_shift);

 

  //norm_shift1 = norm_l(st->ch_enrg[i]);

  norm_shift1 = _norm(st->ch_enrg[i]); 

  //Ltmp3 = L_shl1(st->ch_enrg[i], norm_shift1 - 1);

  LLtmp1 = st->ch_enrg[i]; 

  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[i] = Ltmp2;

 }

 for (i = LO_CHAN; i <= HI_CHAN; i++)

 {

  Ltmp2 = L_div_tmp[i];

  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[i] = extract_h(Ltmp);

  ch_snr[i] = (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。

 

欢迎进入老古论坛进行讨论
[DSP数字信号处理] 相关文章:
用DSP技术从模拟视频信号中获取数字图像
简介:
引 言 　　图像处理系统中图像源获取手段有很多种，同样图像的传感器也是多种多样的。现在比较流行的传感器有CCD、CMOS、CIS等等。这些传感器对于图像数据输出的格式各不相同，例如CCD输出的是模拟信号，需要通过A／D的采样才能得到图像处理所需要的数字图像信号;而CMOS传感器则直接输出数字信号。这样必然会对图像处理系统的通用性造成很大的影响。当图像传感器更改或者图像的分辨率发生更改以后，都会导致图像处理系统做出相应的修改，这样在很大程度上限制了专用图像处理板的应用范围以及通用性。 　　由于电视技术早已得到了广泛的普及，为了保证电视的通用性，世界上早已对其可以使用的模拟视频信号做出......

德金融时报:英特尔利诱德零售商禁售AMD产品
C6000软件优化经验总结(2)
C6000软件优化经验总结(1)
DSP HPI口与PC104总线接口的FPGA设计
电力电子装置控制系统的DSP设计方案
DSP集成开发环境中的混合编程及FFT算法的实现
嵌入式实时系统开发的正确选择
如何在网络视像系统设计中使用数字信号处理器
linux资源 		 
下一个:[DSP数字信号处理]C6000软件优化经验总结(3)
简介:
八、 1、源程序 for (k = 0; k &lt; NB_PULSE; k++) { i = codvec[k]; j = sign[i]; index = mult(i, Q15_1_5); track = sub(i, extract_l(L_shr(L_mult(index, 5), 1))); if (j &gt; 0) { &nbsp......
 

上一个:[电源技术]自制临时电源

老古开发网版权所有 2006年9月 asp.Net V2.0 设计：老古，
页面缓存:否 执行时间:31毫秒