实际上，在我的项目中，我使用了好多优化ARM编程的方式（该项目是基于ARM平台的），也使用了好多互联网里面的技巧。但并不是所有文章提及的方式都能起到挺好的作用。所以，我对有用的和高效的方式进行了总结搜集。同时，我还更改了其中的一些技巧，使她们适用于所有的编程环境，而不是局限于ARM环境。
哪里须要使用这种方式？
没有这一点c语言实现图像处理，所有的讨论都无从谈起。程序优化最重要的就是找出待优化的地方，也就是找出程序的什么部份或则什么模块运行平缓亦或消耗大量的显存。只有程序的各部份经过了优化，程序能够执行的更快。
程序中运行最多的部份，特别是这些被程序内部循环重复调用的方式最该被优化。
对于一个有经验的码农，发现程序中最须要被优化的部份常常很简单。此外，还有好多工具可以帮助我们找出须要优化的部份。我使用过Visual C++外置的性能工具profiler来找出程序中消耗最多显存的地方。
另一个我使用过的工具是英特尔的Vtune，它也能挺好的测量出程序中运行最慢的部份。根据我的经验，内部或嵌套循环，调用第三方库的方式一般是造成程序运行平缓的最主要的起因。
整形数
如果我们确定整数非负，就应当使用unsigned int而不是int。有些处理器处理无符号unsigned 整形数的效率远远低于有符号signed整形数（这是一种挺好的做法，也有利于代码具体类型的自解释）。
因此，在一个紧密循环中，声明一个int整形变量的最好方式是：
register unsigned int variable_name;
记住，整形in的运算速率高浮点型float，并且可以被处理器直接完成运算，而不需要借助于FPU（浮点运算单元）或者浮点型运算库。
尽管这不保证编译器一定会使用到寄存器储存变量，也不能保证处理器处理能更高效处理unsigned整型，但这对于所有的编译器是通用的。
例如在一个估算包中，如果须要结果精确到小数点后两位，我们可以将其除以100，然后尽可能晚的把它转换为浮点型数字。
除法和取余数
在标准处理器中，对于分子和分母，一个32位的乘法须要使用20至140次循环操作。除法函数消耗的时间包括一个常量时间加上每一位乘法消耗的时间。
Time (numerator / denominator) = C0 + C1* log2 (numerator / denominator)
= C0 + C1 * (log2 (numerator) - log2 (denominator)).
对于ARM处理器，这个版本须要20+4.3N次循环。这是一个消耗很大的操作，应该尽可能的防止执行。有时，可以通过加法表达式来代替减法。
例如，假如我们晓得b是负数而且b*c是个整数，那么(a/b)>c可以改写为a>(c * b)。如果确定操作数是无符号unsigned的，使用无符号unsigned乘法更好一些，因为它比有符号signed乘法效率高。
合并乘法和取余数
在一些场景中，同时须要乘法（x/y）和取余数（x%y）操作。这种情况下，编译器可以通过调用一次乘法操作返回加法的结果和余数。如果既须要加法的结果又须要余数，我们可以将它们写在一起，如下所示：
int func_div_and_mod (int a, int b)
{
return (a / b) + (a % b);
}
通过2的幂次进行加法和取余数
如果乘法中的除数是2的幂次，我们可以更好的优化加法。编译器使用移位操作来执行加法。因此，我们须要尽可能的设置除数为2的幂次（例如64而不是66）。并且仍然记住，无符号unsigned整数乘法执行效率低于有符号signed整形出发。
typedef unsigned int uint;
uint div32u (uint a)
{
return a / 32;
}
int div32s (int a)
{
return a / 32;
}
上面两种乘法都避开直接调用加法函数，并且无符号unsigned的加法使用更少的计算机指令。由于须要移位到0和正数，有符号signed的乘法须要更多的时间执行。
取模的一种取代方式
我们使用取余数操作符来提供算数取模。但有时可以结合使用if句子进行取模操作。考虑如下两个事例：
uint modulo_func1 (uint count)
{
return (++count % 60);
}
uint modulo_func2 (uint count)
{
if (++count >= 60)
count = 0;
return (count);
}
优先使用if句子，而不是取余数运算符，因为if句子的执行速率更快。这里注意新版本函数只有在我们晓得输入的count节余0至59时在能正确的工作。
使用链表下标
如果你想给一个变量设置一个代表某种意思的字符值，你可能会这样做：
switch ( queue )
{
case 0 : letter = 'W';
break;
case 1 : letter = 'S';
break;
case 2 : letter = 'U';
break;
}
或者这样做：
if ( queue == 0 )
letter = 'W';
else if ( queue == 1 )
letter = 'S';
else letter = 'U';
一种更简练、更快的方式是使用链表下标获取字符字段的值。如下：
static char *classes="WSU";
letter = classes[queue];
全局变量
全局变量绝不会坐落寄存器中。使用表针或则函数调用，可以直接更改全局变量的值。因此，编译器不能将全局变量的值缓存在寄存器中，但这在使用全局变量时便须要额外的（常常是不必要的）读取和储存。所以，在重要的循环中我们不建议使用全局变量。
如果函数过多的使用全局变量，比较好的做法是拷贝全局变量的值到局部变量，这样它才可以储存在寄存器。这种方式仅仅适用于全局变量不会被我们调用的任意函数使用。例子如下：
int f(void);
int g(void);
int errs;
void test1(void)
{
errs += f();
errs += g();
}
void test2(void)
{
int localerrs = errs;
localerrs += f();
localerrs += g();
errs = localerrs;
}
注意，test1必须在每次降低操作时加载并储存全局变量errs的值，而test2储存localerrs于寄存器而且只须要一个计算机指令。
使用别称
考虑如下的事例：
void func1( int *data )
{
int i;
for(i=0; i<10; i++)
{
anyfunc( *data, i);
}
}
尽管*data的值可能未曾被改变，但编译器并不知道anyfunc函数不会更改它，所以程序必须在每次使用它的时侯从显存中读取它。如果我们晓得变量的值不会被改变，那么就应当使用如下的编码：
void func1( int *data )
{
int i;
int localdata;
localdata = *data;
for(i=0; i<10; i++)
{
anyfunc (localdata, i);
}
}
这为编译器优化代码提供了条件。
变量的生命周期分割
由于处理器中寄存器是固定宽度的，程序中数字型变量在寄存器中的储存是有一定限制的。
有些编译器支持“生命周期分割”（live-range splitting），也就是说在程序的不同部份，变量可以被分配到不同的寄存器或则显存中。
变量的生命周期开始于对它进行的最后一次形参，结束于上次形参前的最后一次使用。在生命周期内，变量的值是有效的，也就是说变量是活着的。不同生命周期之间，变量的值是不被须要的，也就是说变量是烂掉的。
这样，寄存器就可以被其余变量使用，从而容许编译器分配更多的变量使用寄存器。
需要使用寄存器分配的变量数量须要超过函数中不同变量生命周期的个数。如果不同变量生命周期的个数超过了寄存器的数量，那么一些变量必须临时储存于显存。这个过程就称之为分割。
编译器首先分割近来使用的变量，用以增加分割带来的消耗。禁止变量生命周期分割的方式如下：
变量类型
C编译器支持基本类型：char、short、int、long(包括有符号signed和无符号unsigned）、float和double。使用正确的变量类型至关重要，因为这可以减轻代码和数据的大小并急剧降低程序的性能。
局部变量
我们应当尽可能的不使用char和short类型的局部变量。对于char和short类型，编译器须要在每次形参的时侯将局部变量减小到8或则16位。这对于有符号变量称之为有符号扩充，对于无符号变量称之为零扩充。
这些扩充可以通过寄存器左移24或则16位，然后按照有无符号标志右移相同的位数实现，这会消耗两次计算机指令操作（无符号char类型的零扩充仅须要消耗一次计算机指令）。
可以通过使用int和unsigned int类型的局部变量来防止这样的移位操作。这对于先加载数据到局部变量，然后处理局部变量数据值这样的操作十分重要。无论输入输出数据是8位或则16位，将它们考虑为32位是值得的。
考虑下边的三个函数：
int wordinc (int a)
{
return a + 1;
}
short shortinc (short a)
{
return a + 1;
}
char charinc (char a)
{
return a + 1;
}
尽管结果均相同，但是第一个程序片断运行速率低于后二者。
指针
我们应当尽可能的使用引用值的方法传递结构数据，也就是说使用表针，否则传递的数据会被拷贝到栈中，从而减少程序的性能。我曾见过一个程序采用传值的形式传递特别大的结构数据，然后这可以通过一个简单的表针更好的完成。
函数通过参数接受结构数据的表针，如果我们确定不改变数据的值，我们须要将表针指向的内容定义为常量。例如：
void print_data_of_a_structure (const Thestruct *data_pointer)
{
...printf contents of the structure...
}
这个示例告诉编译器函数不会改变外部参数的值（使用const修饰），并且不用在每次访问时都进行读取。同时，确保编译器限制任何对只读结构的更改操作继而给与结构数据额外的保护。
指针链
指针链常常被用于访问结构数据。例如，常用的代码如下：
typedef struct { int x, y, z; } Point3;
typedef struct { Point3 *pos, *direction; } Object;
void InitPos1(Object *p)
{
p->pos->x = 0;
p->pos->y = 0;
p->pos->z = 0;
}
然而，这种的代码在每次操作时必须重复调用p->pos，因为编译器不知道p->pos->x与p->pos是相同的。一种更好的方式是缓存p->pos到一个局部变量：
void InitPos2(Object *p)
{
Point3 *pos = p->pos;
pos->x = 0;
pos->y = 0;
pos->z = 0;
}
另一种方式是在Object结构中直接包含Point3类型的数据，这能完全去除对Point3使用表针操作。
条件执行
条件执行句子大多在if句子中使用，也在使用关系运算符（等）或者布尔值表达式（&&，！等）计算复杂表达式时使用。对于包含函数调用的代码片断，由于函数返回值会被销毁，因此条件执行是无效的。
因此，保持if和else句子尽可能简单是非常有好处的，因为这样编译器可以集中处理它们。关系表达式应当写在一起。
下面的事例展示编译器怎样使用条件执行：
int g(int a, int b, int c, int d)
{
if (a > 0 && b > 0 && c < 0 && d < 0)
// grouped conditions tied up together//
return a + b + c + d;
return -1;
}
由于条件被集聚到一起，编译器才能将她们集中处理。
布尔表达式和范围检测
一个常用的布尔表达式是用于判定变量是否坐落某个范围内，例如，检查一个图形座标是否坐落一个窗口内：
bool PointInRectangelArea (Point p, Rectangle *r)
{
return (p.x >= r->xmin && p.x < r->xmax &&
p.y >= r->ymin && p.y < r->ymax);
}
这里有一种更快的方式：x>min && x
bool PointInRectangelArea (Point p, Rectangle *r)
{
return ((unsigned) (p.x - r->xmin) < r->xmax &&
(unsigned) (p.y - r->ymin) < r->ymax);
}
布尔表达式和零位比较
处理器的标志位在比较指令操作后被设置。标志位同样可以被例如MOV、ADD、AND、MUL等基本算术和裸机指令改写。如果数据指令设置了标志位，N和Z标志位也将与结果与0比较一样进行设置。N标志表示结果是否是负值，Z标志表示结果是否是0。
C语言中，处理器中的N和Z标志位与下边的指令联系在一起：有符号关系运算x=0，x==0，x!=0；无符号关系运算x==0，x!=0（或者x>0）。
C代码中每次关系运算符的调用，编译器就会发出一个比较指令。如果操作符是前面提及的，编译器便会优化掉比较指令。例如：
int aFunction(int x, int y)
{
if (x + y < 0)
return 1;
else
return 0;
}
尽可能的使用前面的判别方法，这可以在关键循环中降低比较指令的调用，进而降低代码容积并增强代码性能。C语言没有借位和溢出位的概念，因此，如果不依靠汇编，不可能直接使用借位标志C和溢出位标志V。但编译器支持借位（无符号溢出），例如：
int sum(int x, int y)
{
int res;
res = x + y;
if ((unsigned) res < (unsigned) x) // carry set? //
res++;
return res;
}
懒监测开发
在if(a>10 && b=4)这样的句子中，确保AND表达式的第一部分最可能较快的给出结果（或者最早、最快估算），这样第二部份便有可能不需要执行。
用switch()函数代替if…else…
对于涉及if…else…else…这样的多条件判定，例如：
if( val == 1)
dostuff1();
else if (val == 2)
dostuff2();
else if (val == 3)
dostuff3();
使用switch可能更快：
switch( val )
{
case 1: dostuff1(); break;
case 2: dostuff2(); break;
case 3: dostuff3(); break;
}
在if()语句中，如果最后一条句子命中，之前的条件都须要被测试执行一次。Switch容许我们不做额外的测试。如果必须使用if…else…语句，将最可能执行的置于最前面。
二分中断
使用二分形式中断代码而不是让代码堆成一列，不要像下边这样做：
if(a==1) {
} else if(a==2) {
} else if(a==3) {
} else if(a==4) {
} else if(a==5) {
} else if(a==6) {
} else if(a==7) {
} else if(a==8)
{
}
使用下边的二分方法取代它，如下：
if(a<=4) {
if(a==1) {
} else if(a==2) {
} else if(a==3) {
} else if(a==4) {
}
}
else
{
if(a==5) {
} else if(a==6) {
} else if(a==7) {
} else if(a==8) {
}
}
或者如下：
if(a<=4)
{
if(a<=2)
{
if(a==1)
{
/* a is 1 */
}
else
{
/* a must be 2 */
}
}
else
{
if(a==3)
{
/* a is 3 */
}
else
{
/* a must be 4 */
}
}
}
else
{
if(a<=6)
{
if(a==5)
{
/* a is 5 */
}
else
{
/* a must be 6 */
}
}
else
{
if(a==7)
{
/* a is 7 */
}
else
{
/* a must be 8 */
}
}
}
比较如下两种case句子：
======001switch语句vs查找表
Switch的应用场景如下：
如果case标签好多，在switch的前两个使用场景中，使用查找表可以更高效的完成。例如下边的两种转换字符串的形式：
char * Condition_String1(int condition) {
switch(condition) {
case 0: return "EQ";
case 1: return "NE";
case 2: return "CS";
case 3: return "CC";
case 4: return "MI";
case 5: return "PL";
case 6: return "VS";
case 7: return "VC";
case 8: return "HI";
case 9: return "LS";
case 10: return "GE";
case 11: return "LT";
case 12: return "GT";
case 13: return "LE";
case 14: return "";
default: return 0;
}
}
char * Condition_String2(int condition) {
if ((unsigned) condition >= 15) return 0;
return
"EQ\0NE\0CS\0CC\0MI\0PL\0VS\0VC\0HI\0LS\0GE\0LT\0GT\0LE\0\0" +
3 * condition;
}
第一个程序须要240 bytes，而第二个仅仅须要72 bytes。
循环
循环是大多数程序中的常用的结构；程序执行的大部分时间发生在循环中，因此非常值得在循环执行时间上下一番工夫。
循环中止
如果不加注意，循环中止条件的编撰会导致额外的负担。我们应当使用计数到零的循环和简单的循环中止条件。简单的中止条件消耗更少的时间。看下边估算n！的两个程序。第一个实现使用递增的循环，第二个实现使用递减循环。
int fact1_func (int n)
{
int i, fact = 1;
for (i = 1; i <= n; i++)
fact *= i;
return (fact);
}
int fact2_func(int n)
{
int i, fact = 1;
for (i = n; i != 0; i--)
fact *= i;
return (fact);
}
第二个程序的fact2_func执行效率低于第一个。
更快的for()循环
这是一个简单而高效的概念。通常，我们编撰for循环代码如下：
for( i=0; i<10; i++){ ... }
i从0循环到9。如果我们不介意循环计数的次序，我们可以这样写：
for( i=10; i--; ) { ... }
这样快的诱因是因为它能更快的处理i的值–测试条件是：i是非零的吗？如果这样，递减i的值。对于前面的代码，处理器须要估算“计算i除以10，其值非负吗？如果非负，i递增并继续”。
简单的循环却有很大的不同。这样，i从9递减到0，这样的循环执行速率更快。
这里的句型有点奇怪，但确实合法的。循环中的第三条句子是可选的（无限循环可以写为for(;;)）。如下代码拥有同样的疗效：
for(i=10; i; i--){}
或者更进一步的：
for(i=10; i!=0; i--){}
这里我们须要记住的是循环必须中止于0（因此，如果在50到80之间循环，这不会起作用），并且循环计数器是递减的。使用递增循环计数器的代码不享有这些优化。
合并循环
如果一个循环能解决问题坚决不用二个。但若果你须要在循环中做好多工作，这坑你并不适宜处理器的指令缓存。这种情况下，两个分开的循环可能会比单个循环执行的更快。下面是一个事例：
======002函数循环
调用函数时总是会有一定的性能消耗。不仅程序表针须要改变，而且使用的变量须要压栈并分配新变量。为提高程序的性能，在函数这点上有好多可以优化的。在保持程序代码可读性的同时也须要代码的大小是可控的。
如果在循环中一个函数常常被调用，那么就将循环列入到函数中，这样可以降低重复的函数调用。代码如下：
for(i=0 ; i<100 ; i++)
{
func(t,i);
}
-
-
-
void func(int w,d)
{
lots of stuff.
}
应改为：
func(t);
-
-
-
void func(w)
{
for(i=0 ; i<100 ; i++)
{
//lots of stuff.
}
}
循环展开
简单的循环可以展开以获取更好的性能，但须要付出代码容积降低的代价。循环展开后，循环计数应当越来越小因而执行更少的代码分支。如果循环迭代次数只有几次，那么可以完全展开循环，以便清除循坏带来的负担。
这会带来很大的不同。循环展开可以带十分可观的节约性能，原因是代码不用每次循环须要检测和降低i的值。例如：
======003
编译器一般会像前面那样展开简单的，迭代次数固定的循环。但是像下边的代码：
for(i=0;i< limit;i++) { ... }
下面的代码（Example 1）明显比使用循环的形式写的更长，但却更有效率。block-sie的值设置为8仅仅适用于测试的目的，只要我们重复执行“loop-contents”相同的次数，都会有挺好的疗效。
在这个反例中，循环条件每8次迭代就会被检测，而不是每次都进行检测。由于不知道迭代的次数，一般不会被展开。因此，尽可能的展开循环可以让我们获得更好的执行速率。
//Example 1
#include
#define BLOCKSIZE (8)
void main(void)
{
int i = 0;
int limit = 33; /* could be anything */
int blocklimit;
/* The limit may not be divisible by BLOCKSIZE,
* go as near as we can first, then tidy up.
*/
blocklimit = (limit / BLOCKSIZE) * BLOCKSIZE;
/* unroll the loop in blocks of 8 */
while( i < blocklimit )
{
printf("process(%d)\n", i);
printf("process(%d)\n", i+1);
printf("process(%d)\n", i+2);
printf("process(%d)\n", i+3);
printf("process(%d)\n", i+4);
printf("process(%d)\n", i+5);
printf("process(%d)\n", i+6);
printf("process(%d)\n", i+7);
/* update the counter */
i += 8;
}
/*
* There may be some left to do.
* This could be done as a simple for() loop,
* but a switch is faster (and more interesting)
*/
if( i < limit )
{
/* Jump into the case at the place that will allow
* us to finish off the appropriate number of items.
*/
switch( limit - i )
{
case 7 : printf("process(%d)\n", i); i++;
case 6 : printf("process(%d)\n", i); i++;
case 5 : printf("process(%d)\n", i); i++;
case 4 : printf("process(%d)\n", i); i++;
case 3 : printf("process(%d)\n", i); i++;
case 2 : printf("process(%d)\n", i); i++;
case 1 : printf("process(%d)\n", i);
}
}
}
统计非零值的数目
通过不断的左移，提取并统计最高位，示例程序1高效的检测一个字段中有几个非零值。示例程序2被循环展开四次，然后通过将四次移位合并成一次来优化代码。经常展开循环，可以提供好多优化的机会。
//Example - 1
int countbit1(uint n)
{
int bits = 0;
while (n != 0)
{
if (n & 1) bits++;
n >>= 1;
}
return bits;
}
//Example - 2
int countbit2(uint n)
{
int bits = 0;
while (n != 0)
{
if (n & 1) bits++;
if (n & 2) bits++;
if (n & 4) bits++;
if (n & 8) bits++;
n >>= 4;
}
return bits;
}
尽早的断掉循环
通常c语言实现图像处理，循环并不需要全部都执行。例如，如果我们在从链表中查找一个特殊的值，一经找到，我们应当尽可能早的断掉循环。例如：如下循环从10000个整数中查找是否存在-99。
found = FALSE;
for(i=0;i<10000;i++)
{
if( list[i] == -99 )
{
found = TRUE;
}
}
if( found )
printf("Yes, there is a -99. Hooray!\n");
上面的代码可以正常工作，但是须要循环全部执行完毕，而不论是否我们早已查找到。更好的方式是一旦找到我们查找的数字就中止继续查询。
found = FALSE;
for(i=0; i<10000; i++)
{
if( list[i] == -99 )
{
found = TRUE;
break;
}
}
if( found )
printf("Yes, there is a -99. Hooray!\n");
假如待查数据坐落第23个位置上，程序便会执行23次，从而节约9977次循环。
函数设计
设计小而简单的函数是个挺好的习惯。这容许寄存器可以执行一些诸如寄存器变量申请的优化，是极其高效的。
函数调用的性能消耗
函数调用对于处理器的性能消耗是很小的，只占有函数执行工作中性能消耗的一小部份。参数传入函数变量寄存器中有一定的限制。这些参数必须是整型兼容的（char，shorts，ints和floats都占用一个字）或者大于四个字大小（包括占用2个字的doubles和long longs）。
如果参数限制个数为4，那么第五个和以后的字才会储存在栈上。这便在调用函数是须要从栈上加载参数因而降低储存和读取的消耗。
看下边的代码：
int f1(int a, int b, int c, int d) {
return a + b + c + d;
}
int g1(void) {
return f1(1, 2, 3, 4);
}
int f2(int a, int b, int c, int d, int e, int f) {
return a + b + c + d + e + f;
}
ing g2(void) {
return f2(1, 2, 3, 4, 5, 6);
}
函数g2中的第五个和第六个参数储存于栈上并在函数f2中进行加载，会多消耗2个参数的储存。
减少函数参数传递消耗
减少函数参数传递消耗的方式有：
叶子函数
不调用任何函数的函数称之为叶子函数。在以下应用中，近一半的函数调用是调用叶子函数。由于不需要执行寄存器变量的储存和读取，叶子函数在任何平台都很高效。
寄存器变量读取的性能消耗，相比于使用四五个寄存器变量的叶子函数所做的工作带来的系能消耗是十分小的。所以尽可能的将常常调用的函数写成叶子函数。
函数调用的次数可以通过一些工具检测。下面是一些将一个函数编译为叶子函数的方式：
内联函数
内联函数禁用所有的编译选项。使用__inline修饰函数引起函数在调用处直接替换为函数体。这样代码调用函数更快，但降低代码的大小，特别在函数本身比较大并且时常调用的情况下。
__inline int square(int x) {
return x * x;
}
#include
double length(int x, int y){
return sqrt(square(x) + square(y));
}
使用内联函数的益处如下：
内联函数的缺陷是假如调用的地方好多，代码的容积会显得很大。这主要取决于函数本身的大小和调用的次数。
仅对重要的函数使用inline是明智的。如果使用得当，内联函数甚至可以降低代码的容积：函数调用会形成一些计算机指令，但是使用内联的优化版本可能形成更少的计算机指令。
使用查找表
函数一般可以设计成查找表，这样可以明显提高性能。查找表的精确度比一般的估算低，但对于通常的程序并没哪些差别。
许多讯号处理程序（例如，调制解调器混频软件）使用好多特别消耗估算性能的sin和cos函数。对于实时系统，精确性不是非常重要，sin、cos查找表可能更合适。当使用查找表时，尽可能将相像的操作装入查找表，这样比使用多个查找表更快，更能节约储存空间。
浮点运算
尽管浮点运算对于所有的处理器都很历时，但对于实现讯号处理软件时我们依然须要使用。在编撰浮点操作程序时，记住如下几点：
然而，浮点运算的表现可能不能满足特定软件对性能的需求。这种情况下，最好的办法或许是使用定点算数运算。当值的范围足够小，定点算数操作比浮点运算更精确、更快速。
其他方法
通常，可以使用空间换时间。如果你能缓存常常用的数据而不是重新估算，这便能更快的访问。比如sine和cosine查找表，或者伪随机数。
最后，但是是最重要的是-将编译器优化选项打开！看上去很显而易见，但却常常在产品推出时被忘掉。编译器才能在更底层上对代码进行优化，并针对目标处理器执行特定的优化处理。
--- END ---
