goole,于震-中超蔬菜,欧洲知名中超大盘点

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

代码的运算速度取决于以goole,于震-中超蔬菜,欧洲闻名中超大盘点下几个方面:

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

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

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

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

比方在一个图画转化的项目中,goole,于震-中超蔬菜,欧洲闻名中超大盘点需要将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; 古力娜扎被p遗像
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个算术goole,于震-中超蔬菜,欧洲闻名中超大盘点逻辑单元(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] =goole,于震-中超蔬菜,欧洲闻名中超大盘点 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_goole,于震-中超蔬菜,欧洲闻名中超大盘点out_0;
/* 给第二个算术逻辑单元履行 */
int r1 = R[in[i+1].r];
int g1 = G[in[i+1].g]; 9c8922
int b1 = B[in[i+1].b];
int temp_out_1 = r1 +goole,于震-中超蔬菜,欧洲闻名中超大盘点 古间圆儿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];
uint16_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];
ui碱组词nt16_t g1 = G[in[i+1].g];
uint16goole,于震-中超蔬菜,欧洲闻名中超大盘点_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)代码运用汇编语言进行编写

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

点击展开全文

上一篇:

下一篇:

相关推荐