<small id='RrfdwoIS'></small> <noframes id='dSNux7RTC'>

  • <tfoot id='3cKX'></tfoot>

      <legend id='4i9KPGf1Z'><style id='VwzZ47'><dir id='7OSg'><q id='QK3Jj6'></q></dir></style></legend>
      <i id='OHtjIxlM'><tr id='9WX0U4dV6l'><dt id='jCoK'><q id='2bYAE'><span id='a7sySJWcL'><b id='InLU3'><form id='mv6IY'><ins id='GbAUI0'></ins><ul id='6aNGk'></ul><sub id='cVUA4CID8'></sub></form><legend id='m0Q1rnNhl'></legend><bdo id='ce3VT5AH9'><pre id='J2DGxZuHjX'><center id='tgoJV'></center></pre></bdo></b><th id='5DOUtlm7'></th></span></q></dt></tr></i><div id='JX8ENajI4'><tfoot id='B8gP'></tfoot><dl id='hwQd'><fieldset id='d8e7'></fieldset></dl></div>

          <bdo id='nGTY'></bdo><ul id='8ajHo1JWC'></ul>

          1. <li id='87CUnovj'></li>
            登陆

            章鱼彩票 苹果-程序的魂灵——算法

            admin 2019-12-13 217人围观 ,发现0个评论

            相同的工作,运用不相同的办法去完结,尽管终究的成果相同,可是完结的功率往往不相同。假设你离家一千公里旅程,新年要回家过新年,你能够走路回家,能够骑自行车回家,能够骑摩托车回家,能够坐轿车回家,能够坐火车回家,当然也能够坐飞机回家,尽管终究意图都是抵达一千公里的家园,可是乘坐不同的交通东西,回家的时刻各异。在程序中,这些不同的“交通东西”咱们称之为算法。

            代码的运算速度取决于以下几个方面:

            (1)处理器的主频和规划架构;

            (2)处理器的总线带宽;

            (3)程序代码的规划编写;

            (4)程序中所运用算法自身的杂乱度,比方MPEG比JPEG杂乱,JPEG比BMP图片的编码杂乱。

            比方在一个图画转化的项目中,需要将RGB格局的五颜六色图画先转化成是非图画。图画转化的公式如下:

            Y = 0.299 * R + 0.587 * G + 0.114章鱼彩票 苹果-程序的魂灵——算法 * B;

            图画尺度640*480*24 bits,RGB图画现已依照RGBRGB顺序排列的格局,放在内存里边了。

            例如,将这个喷火的战斗机引擎,转化为右边的是非图片。

            图片输入和输出的界说如下:

            #define XSIZE (640)
            #define YSIZE (480)
            #define IMGSIZE XSIZE*YSIZE
            typedef struct rgb
            {
            uint8_t r;
            uint8_t g;
            uint8_t b;
            }RGB;
            RGB in[IMGSIZE]; /* 未转化的图片数据 */
            uint8_t out[IMGSIZE]; /* 转化后的图片数据 */

            优化准则:

            图画是一个二维数组,我用一个一维数组来存储。编译器处理一维数组的功率要高于二维数组。

            第一个程序:

            void convert_rgb_image(void)
            {
            int i = 0;
            for(i = 0; i < IMGSIZE; i++)
            {
            uint8_t r = in[i].r;
            uint8_t g = in[i].g;
            uint8_t b = in[i].b;
            double temp_out = 0.299 * r + 0.587 * g + 0.114 * b;
            out[i] = temp_out;
            }
            }

            分别用VC6.0和穿插编译东西,生成2个版别,分别在PC和嵌入式开发板上面运转。

            A、在PC上,因为存在硬件浮点处理器,CPU频率也够高,运转时刻为20秒。

            B、在嵌入式开发板 ,主频时钟比较低,也没有浮点处理器,浮点操作被编译器分化成了整数运算,运转时刻为120秒左右。

            第一次章鱼彩票 苹果-程序的魂灵——算法优化

            优化准则:

            去掉浮点数运算。

            在公式Y = 0.299 * R + 0.587 * G + 0.114 * B因为RGB的取值规模都是0~255,仅仅系数都是浮点数,将RGB的系数转化为:

            R的系数:0.299 = 299 / 1000

            G的系数:0.587 = 587 / 1000

            B的系数:0.114 = 114 / 1000

            所以图片转化公式可表示成:Y = (299 * R + 587 * G + 114 * B)/ 1000

            即转化图片的程序变为:

            void convert_rgb_image(void)
            {
            int i = 0;
            for(i = 0; i < IMGSIZE; i++)
            {
            uint8_t r = in[i].r;
            uint8_t g = in[i].g;
            uint8_t b = in[i].b;
            double temp_out = (299 * r + 587 * g + 114 * b) / 1000;
            out[i] = temp_out;
            }
            }

            再次编译生成两个渠道的应用程序运转,发现:

            A、章鱼彩票 苹果-程序的魂灵——算法在PC上运转的时刻为2秒

            B、在嵌入式开发板上运转的时刻为45秒

            第2次优化

            优化准则:

            处理器在进行除法运算时,处理速度比较慢,去除除法操作

            将公式Y = (299 * R + 587 * G + 114 * B)/ 1000的RGB的系数优化如下:

            R的系数:0.299 = 299 / 1000 = 1224 / 4096

            G的系数:0.587 = 587 / 1000 = 2404 / 4096

            B的系数:0.114 = 114 / 1000 = 467 / 4096

            因为4096是2的倍数,除法可用功率更高的移位操作进行优化,所以图片转化公式为:

            Y = (1224 * R + 2404 * G + 467 * G) >> 12

            所以图片转化程序为:

            void convert_rgb_image(void)
            {
            int i = 0;
            for(i = 0; i < IMGSIZE; i++)
            {
            int r = 1224 * in[i].r;
            int g = 2404 * in[i].g;
            int b = 467 * in[i].b;
            int temp_out = (r + g + b) >> 12;
            out[i] = temp_out;
            }
            }

            再次编译运转,发现在嵌入式开发板上运转时刻为30秒。

            第三次优化

            优化准则:

            因为每一次转化的RGB系数都要通过核算得到,削减各个系数的核算次数。

            优化代码如下:

            #define RGB_SIZE (256)
            int R[RGB_SIZE];
            int G[RGB_SIZE];
            int B[RGB_SIZE];
            void rgb_table_init(void)
            {
            int i = 0;
            for(i = 0; i < RGB_SIZE; i++)
            {
            R[i] = 1224 * i;
            R[i] = R[i] >> 12;
            G[i] = 2404 * i;
            G[i] = G[i] >> 12;
            B[i] = 467 * i;
            B[i] = B[i] >> 12;
            }
            }
            void convert_rgb_image(void)
            {
            int i = 0;
            for(i = 0; i < IMGSIZE; i++)
            {
            int r = R[in[i].r];
            int g = G[in[i].g];
            int b = B[in[i].b];
            int temp_out = r + g + b;
            out[i] = temp_out;
            }
            }

            再次编译运转,发现在嵌入式开发板上运转时刻为2秒。

            第四次优化

            优化准则:

            32位的嵌入式CPU,都至少有2个算术逻辑单元(ALU),让2个ALU一同运转

            优化代码如下:

            #define RGB_SIZE (256)
            int R[RGB_SIZE];
            int G[RGB_SIZE];
            int B[RGB_SIZE];
            void rgb_table_init(void)
            {
            int i = 0;
            for(i = 0; i < RGB_SIZE; i++)
            {
            R[i] = 1224 * i;
            R[i] = R[i] >> 12;
            G[i] = 2404 * i;
            G[i] = G[i] >> 12;
            B[i] = 467 * i;
            B[i] = B[i] >> 12;
            }
            }
            void convert_rgb_image(void)
            {
            int i = 0;
            for(i=0; i < IMGSIZE; i += 2)
            {
            /* 给第一个算术逻辑单元履行 */
            int r0 = R[in[i].r];
            int g0 = G[in[i].g];
            int b0 = B[in[i].b];
            int temp_out_0 = r0 + g0 + b0;
            out[i] = temp_ou章鱼彩票 苹果-程序的魂灵——算法t_0;
            /* 给第二个算术逻辑单元履行 */
            int r1 = R[in[i+1].r];
            int g1 = G[in[i+1].g];
            int b1 = B[in[i+1].b];
            int temp_out_1 = r1 + g1 + b1;
            out[i+1] = temp_out_1;
            /* 如果有更多算术逻辑单元,能够相似的处理代码 */
            }
            }

            再次编译运转,发现在嵌入式开发板上运转时刻为1秒。

            第五次优化

            优化准则:

            因为各个数据类型巨细不相同,处理速度也不相同,因而能够对数据类型优化

            优化代码如下:

            #define RGB_SIZE (256)
            uint16_t R[RGB_SIZE];
            uint16_t G[RGB_SIZE];
            uint16_t B[RGB_SIZE];
            void rgb_table_init(void)
            {
            uint8_t i = 0;
            for(i = 0; i <= RGB_SIZE; i++)
            {
            R[i] = 1224 * i;
            R[i] = R[i] >> 12;
            G[i] = 2404 * i;
            G[i] = G[i] >> 12;
            B[i] = 467 * i;
            B[i] = B[i] >> 12;
            }
            }
            inline void convert_rgb_image(void)
            {
            uint32_t i = 0;
            for(i=0; i < IMGSIZE; i += 2)
            {
            /* 给第一个算术逻辑单元履行 */
            uint16_t r0 = R[in[i].r];
            u新抚网int16_t g0 = G[in[i].g];
            uint16_t b0 = B[in[i].b];
            uint32_t temp_out_0 = r0 + g0 + b0;
            out[i] = temp_out_0;
            章鱼彩票 苹果-程序的魂灵——算法/* 给第二个算术逻辑单元履行 */
            uint16_t r1 = R[in[i+1].r];
            uint16_t g1 = G[in[i+1].g];
            uint16_t b1 = B[in[i+1].b];
            uint32_t temp_out_1 = r1 + g1 + b1;
            out[i+1] = temp_out_1;
            }
            }

            将函数声明为inline,这样编译器就会将其嵌入到母函数中,能够削减CPU调用子函数所发生的开支。

            再次编译运转,发现在嵌入式开发板上运转时刻为0.5秒。

            后续可优化的方向:

            (1)将RGB查表的数据放入CPU的高速缓冲存储器(Cache)中,然后提高程序运转时的加载速度。

            (2)代码运用汇编语言进行编写

            阐明:本文来源于网络,我仅仅是对文章进行了必定的收拾,删繁就简,如有侵权,请及时联络我删去!

            请关注微信公众号
            微信二维码
            不容错过
            Powered By Z-BlogPHP